mdast/index.js

'use strict';

/*
 * Dependencies.
 */

var Ware = require('ware');
var extend = require('extend.js');
var parser = require('./lib/parse.js');
var stringifier = require('./lib/stringify.js');
var File = require('./lib/file.js');
var utilities = require('./lib/utilities.js');

/*
 * Methods.
 */

var Parser = parser.Parser;
var parseProto = Parser.prototype;
var Compiler = stringifier.Compiler;
var compileProto = Compiler.prototype;

/**
 * Throws if passed an exception.
 *
 * Here until the following PR is merged into
 * segmentio/ware:
 *
 *   https://github.com/segmentio/ware/pull/21
 *
 * @param {Error?} exception
 */
function fail(exception) {
    if (exception) {
        throw exception;
    }
}

/**
 * Create a custom, cloned, Parser.
 *
 * @return {Function}
 */
function constructParser() {
    var customProto;
    var expressions;
    var key;

    /**
     * Extensible prototype.
     */
    function CustomProto() {}

    CustomProto.prototype = parseProto;

    customProto = new CustomProto();

    /**
     * Extensible constructor.
     */
    function CustomParser() {
        Parser.apply(this, arguments);
    }

    CustomParser.prototype = customProto;

    /*
     * Construct new objects for things that plugin's
     * might modify.
     */

    customProto.blockTokenizers = extend({}, parseProto.blockTokenizers);
    customProto.blockMethods = extend([], parseProto.blockMethods);
    customProto.inlineTokenizers = extend({}, parseProto.inlineTokenizers);
    customProto.inlineMethods = extend([], parseProto.inlineMethods);

    expressions = parseProto.expressions;
    customProto.expressions = {};

    for (key in expressions) {
        customProto.expressions[key] = extend({}, expressions[key]);
    }

    return CustomParser;
}

/**
 * Create a custom, cloned, Compiler.
 *
 * @return {Function}
 */
function constructCompiler() {
    var customProto;

    /**
     * Extensible prototype.
     */
    function CustomProto() {}

    CustomProto.prototype = compileProto;

    customProto = new CustomProto();

    /**
     * Extensible constructor.
     */
    function CustomCompiler() {
        Compiler.apply(this, arguments);
    }

    CustomCompiler.prototype = customProto;

    return CustomCompiler;
}

/**
 * Construct an MDAST instance.
 *
 * @constructor {MDAST}
 */
function MDAST() {
    var self = this;

    if (!(self instanceof MDAST)) {
        return new MDAST();
    }

    self.ware = new Ware();
    self.attachers = [];

    self.Parser = constructParser();
    self.Compiler = constructCompiler();
}

/**
 * Attach a plugin.
 *
 * @param {Function|Array.<Function>} attach
 * @param {Object?} [options]
 * @param {FileSet?} [fileSet] - Optional file-set,
 *   passed by the CLI.
 * @return {MDAST}
 */
function use(attach, options, fileSet) {
    var self = this;
    var index;
    var transformer;

    if (!(self instanceof MDAST)) {
        self = new MDAST();
    }

    /*
     * Multiple attachers.
     */

    if ('length' in attach && typeof attach !== 'function') {
        index = -1;

        while (attach[++index]) {
            self.use(attach[index], options, fileSet);
        }

        return self;
    }

    /*
     * Single plugin.
     */

    if (self.attachers.indexOf(attach) === -1) {
        transformer = attach(self, options, fileSet);

        self.attachers.push(attach);

        if (transformer) {
            self.ware.use(transformer);
        }
    }

    return self;
}

/**
 * Apply transformers to `node`.
 *
 * @param {Node} ast
 * @param {File?} [file]
 * @param {Function?} [done]
 * @return {Node} - `ast`.
 */
function run(ast, file, done) {
    var self = this;

    if (typeof file === 'function') {
        done = file;
        file = null;
    }

    file = new File(file);

    done = typeof done === 'function' ? done : fail;

    if (typeof ast !== 'object' && typeof ast.type !== 'string') {
        utilities.raise(ast, 'ast');
    }

    /*
     * Only run when this is an instance of MDAST.
     */

    if (self.ware) {
        self.ware.run(ast, file, done);
    } else {
        done(null, ast, file);
    }

    return ast;
}

/**
 * Wrapper to pass a file to `parser`.
 */
function parse(value, options) {
    return parser.call(this, new File(value), options);
}

/**
 * Wrapper to pass a file to `stringifier`.
 */
function stringify(ast, file, options) {
    if (options === null || options === undefined) {
        options = file;
        file = null;
    }

    return stringifier.call(this, ast, new File(file), options);
}

/**
 * Parse a value and apply transformers.
 *
 * @param {string|File} value
 * @param {Object?} [options]
 * @param {Function?} [done]
 * @return {string?}
 */
function process(value, options, done) {
    var file = new File(value);
    var self = this instanceof MDAST ? this : new MDAST();
    var result = null;
    var ast;

    if (typeof options === 'function') {
        done = options;
        options = null;
    }

    if (!options) {
        options = {};
    }

    /**
     * Invoked when `run` completes. Hoists `result` into
     * the upper scope to return something for sync
     * operations.
     */
    function callback(exception) {
        if (exception) {
            (done || fail)(exception);
        } else {
            result = self.stringify(ast, file, options);

            if (done) {
                done(null, result, file);
            }
        }
    }

    ast = self.parse(file, options);
    file.ast = ast;
    self.run(ast, file, callback);

    return result;
}

/*
 * Methods.
 */

var proto = MDAST.prototype;

proto.use = use;
proto.parse = parse;
proto.run = run;
proto.stringify = stringify;
proto.process = process;

/*
 * Functions.
 */

MDAST.use = use;
MDAST.parse = parse;
MDAST.run = run;
MDAST.stringify = stringify;
MDAST.process = process;

/*
 * Expose `mdast`.
 */

module.exports = MDAST;