gr0uch

// ==UserScript==
// @name              Word Filter
// @description       Replace words with other words.
// @namespace         http://daliwa.li
// @include           *
// @version           1.0.0
// @grant             none
// ==/UserScript==

gr0uch

There are not enough tools in the JS ecosystem for generating docs from source code. There is dox which seems to be popular, but it is not very configurable and a bit limited in functionality in that has no lexical understanding of code. The gold standard is jsdoc but it still has its own shortcomings. It is also rigid in its expectations of input, and outputs JSON in a predefined way. I want to write a new tool that instruments code so that it has an understanding of what is being documented, and modular serializers for inputs and outputs.

Example input, JSDoc style:

App.UsersController = Framework.ArrayController.extend({
  /**
   * Get a list of inactive users.
   *
 * @public

gr0uch

// Hello. There is now a module for this.
// https://github.com/0x8890/error-class
// $ npm install error-class

const hasCaptureStackTrace = 'captureStackTrace' in Error

// Internal function to set up an error.
function setup (message) {
  const { constructor, constructor: { name } } = this

gr0uch

/**
 * Get a hash of a class's methods. This is not so straightforward
 * because class methods are not enumerable.
 * 
 * @param {Class} cls
 * @return {Object}'
 */
export default function enumerateMethods (cls = class {}) {
  return Object.getOwnPropertyNames(cls.prototype)
    .reduce((methods, method) => {

gr0uch

/**
 * Dependency injection in ES6. Parentheses can be omitted for arrow functions with
 * only one argument, and by omitting the curly braces it automatically returns
 * the proceeding expression, in this case, the Subclass that extends from the
 * Superclass that is injected. So cool.
 */
export default Superclass => class Subclass extends Superclass { ... }

gr0uch

/**
 * Take an array of functions that accept one argument and return a value or Promise,
 * and invoke each function serially, passing the resolved value to the next function.
 * 
 * @param {Array} fnArray
 * @param {Mixed} initialValue
 * @return {Promise}
 */
export default (fnArray, initialValue) =>
  fnArray.reduce((chain, fn, index) =>

gr0uch

/**
 * Immutable mapping on an object.
 *
 * @param {Object} object
 * @param {Function} mapFunction
 * @return {Object}
 */
export default (object, mapFunction) =>
  Object.keys(object).reduce((clone, key) => {
    clone[key] = mapFunction(object[key], key);

gr0uch

The use of the new keyword in JavaScript is highly divisive, some say that you should avoid it entirely. ES6 classes may seem at odds with this line of thinking, but I will show how you can have your cake and eat it too. Consider a module that exports a class:

export default class {
  constructor () { /* Do stuff here. */ }
}

The only way to get an instance out of this module, or rather an object that inherits the prototype of the class object, is to use the new keyword, which some consider harmful. Personally, I am not against new, it provides implicit understanding that the returned value is an object with inherited properties.

gr0uch

/**
 * Get the union of arrays with unique values by means of the Set type.
 * 
 * @param {Array[]}
 * @return {Set}
 */
function union () {
  return new Set(arguments[0].concat(
    ...Array.prototype.slice.call(arguments, 1)))
}

gr0uch

import fortune from 'fortune'
import express from 'express'

const store = fortune.create()
const server = express()

store.defineType('user', {})

server.use('/users', (request, response, next) => {
  // Do something...