requisite/lib/utils.js

A cosmic javascript bundler.

// Generated by CoffeeScript 1.10.0
var SourceMapConsumer, acorn, convert, escodegen, fs, guessMinifier, os, path, traverse, walk;

fs = require('fs');

os = require('os');

path = require('path');

acorn = require('acorn');

convert = require('convert-source-map');

escodegen = require('escodegen');

SourceMapConsumer = require('source-map').SourceMapConsumer;

traverse = require('estraverse').traverse;

exports.formatDate = function(date) {
  if (date == null) {
    date = new Date;
  }
  return (/\d{2}:\d{2}:\d{2}/.exec(date))[0];
};

exports.parse = function(source, opts) {
  var _opts, ast, comments, tokens;
  if (opts == null) {
    opts = {};
  }
  comments = [];
  tokens = [];
  _opts = {
    ranges: true,
    onComment: comments,
    onToken: tokens,
    locations: true,
    sourceFile: opts.filename
  };
  ast = acorn.parse(source, _opts);
  escodegen.attachComments(ast, comments, tokens);
  return ast;
};

guessMinifier = function() {
  var err, error, error1;
  try {
    if (require.resolve('uglify-js')) {
      return 'uglifyjs';
    }
  } catch (error) {
    err = error;
  }
  try {
    require.resolve('esmangle');
  } catch (error1) {
    err = error1;
    throw new Error('Unable to determine minifier to use');
  }
  return 'esmangle';
};

exports.codegen = function(ast, opts) {
  var _opts, code, map, minifier, minify, output, ref, ref1;
  if (opts == null) {
    opts = {};
  }
  if (opts.minify) {
    minifier = (ref = opts.minifier) != null ? ref : guessMinifier();
    if (/uglify/.test(minifier)) {
      minifier = 'uglifyjs';
    }
    minify = require('./minify');
    return minify[minifier](ast, opts);
  }
  _opts = {
    comment: true,
    format: {
      indent: {
        style: '  ',
        base: 0
      },
      compact: false,
      escapeless: true,
      parentheses: false,
      quotes: 'auto',
      semicolons: false
    }
  };
  if (!opts.sourceMap) {
    return escodegen.generate(ast, _opts);
  }
  _opts.sourceMap = true;
  _opts.sourceMapWithCode = true;
  _opts.sourceMapRoot = (ref1 = opts.sourceMapRoot) != null ? ref1 : "";
  output = escodegen.generate(ast, _opts);
  code = output.code;
  map = output.map;
  if (opts.onlySourceMap) {
    return convert.fromObject(map).toJSON();
  } else {
    return code + convert.fromObject(map).toComment();
  }
};

exports.walk = walk = function(node, visitor) {
  var el, i, k, len, results, results1, v;
  if ((node != null) && typeof node === 'object') {
    if (!visitor(node)) {
      results = [];
      for (k in node) {
        v = node[k];
        results.push(walk(v, visitor));
      }
      return results;
    }
  } else if (Array.isArray(node)) {
    results1 = [];
    for (i = 0, len = node.length; i < len; i++) {
      el = node[i];
      results1.push(walk(el, visitor));
    }
    return results1;
  }
};

exports.graph = function(mod) {
  var depth, i, idx, len, line, lines, nextDepth, nextLine, ref, ref1, seen, walkdeps;
  seen = {};
  walkdeps = function(mod, fn, depth) {
    var k, ref, results, v;
    if (depth == null) {
      depth = 0;
    }
    if (seen[mod.requireAs]) {
      fn(mod, depth, true);
      return;
    }
    seen[mod.requireAs] = true;
    depth += 1;
    ref = mod.dependencies;
    results = [];
    for (k in ref) {
      v = ref[k];
      if ((fn(v, depth)) !== false) {
        results.push(walkdeps(v, fn, depth));
      } else {
        results.push(void 0);
      }
    }
    return results;
  };
  console.log(mod.requireAs);
  lines = [];
  walkdeps(mod, function(mod, depth, seen) {
    var line;
    if (seen) {
      lines.pop();
      return;
    }
    line = '├─' + mod.requireAs;
    if (depth > 0) {
      line = (new Array(depth * 2)).join(' ') + line;
    }
    return lines.push([line, depth]);
  });
  for (idx = i = 0, len = lines.length; i < len; idx = ++i) {
    ref = lines[idx], line = ref[0], depth = ref[1];
    if (lines[idx + 1] == null) {
      lines[idx][0] = line.replace('├─', '└─');
    } else {
      ref1 = lines[idx + 1], nextLine = ref1[0], nextDepth = ref1[1];
      if ((nextLine != null) && depth !== nextDepth) {
        lines[idx][0] = line.replace('├─', '└─');
      }
    }
  }
  return console.log(((function() {
    var j, len1, results;
    results = [];
    for (j = 0, len1 = lines.length; j < len1; j++) {
      line = lines[j];
      results.push(line[0]);
    }
    return results;
  })()).join('\n'));
};

exports.requireTry = function(pkg) {
  var err, error;
  try {
    return require(pkg);
  } catch (error) {
    err = error;
    console.error("Unable to require '" + pkg + "'. Try `npm install -g " + pkg + "`.");
    throw new Error("Missing compiler");
  }
};

exports.normalizePath = function(absolutePath, basePath) {
  var normalizedPath, start;
  if ((absolutePath.indexOf(basePath)) !== -1) {
    normalizedPath = absolutePath.replace(basePath, '');
  } else {
    start = absolutePath.indexOf('node_modules');
    normalizedPath = absolutePath.substring(start, absolutePath.length);
  }
  if (os.platform() === 'win32') {
    return normalizedPath.replace(/^\\+/, '');
  } else {
    return normalizedPath.replace(/^\/+/, '');
  }
};

exports.sourceMapToAst = function(ast, map) {
  map = new SourceMapConsumer(map);
  traverse(ast, {
    enter: function(node) {
      var origEnd, origStart;
      if (!(node.type && node.loc)) {
        return;
      }
      origStart = map.originalPositionFor(node.loc.start);
      if (!origStart.line) {
        delete node.loc;
        return;
      }
      origEnd = map.originalPositionFor(node.loc.end);
      if (origEnd.line && (origEnd.line < origStart.line || origEnd.column < origStart.column)) {
        origEnd.line = null;
      }
      node.loc = {
        start: {
          line: origStart.line,
          column: origStart.column
        },
        source: origStart.source,
        name: origStart.name
      };
      if (origEnd.line) {
        node.loc.end = {
          line: origEnd.line,
          column: origEnd.column
        };
      }
    }
  });
  return ast;
};

//# sourceMappingURL=utils.js.map