stylus-source 0.15.4

data/lib/stylus/token.js

@@ -0,0 +1,53 @@
+
+/*!
+ * Stylus - Token
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var inspect = require('sys').inspect;
+
+/**
+ * Initialize a new `Token` with the given `type` and `val`.
+ *
+ * @param {String} type
+ * @param {Mixed} val
+ * @api private
+ */
+
+var Token = exports = module.exports = function Token(type, val) {
+  this.type = type;
+  this.val = val;
+};
+
+/**
+ * Custom inspect.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Token.prototype.inspect = function(){
+  var val = ' ' + inspect(this.val);
+  return '[Token:' + this.lineno + ' '
+    + '\x1b[32m' + this.type + '\x1b[0m'
+    + '\x1b[33m' + (this.val ? val : '') + '\x1b[0m'
+    + ']';
+};
+
+/**
+ * Return type or val.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Token.prototype.toString = function(){
+  return (undefined === this.val
+    ? this.type
+    : this.val).toString();
+};

data/lib/stylus/utils.js

@@ -0,0 +1,237 @@
+
+/*!
+ * Stylus - utils
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var nodes = require('./nodes')
+  , join = require('path').join
+  , fs = require('fs');
+
+/**
+ * Check if `path` looks absolute.
+ *
+ * @param {String} path
+ * @return {Boolean}
+ * @api private
+ */
+
+exports.absolute = function(path){
+  return /^([a-z]:\\)|\//i.test(path);
+};
+
+/**
+ * Attempt to lookup `path` within `paths` from tail to head.
+ * Optionally a path to `ignore` may be passed.
+ *
+ * @param {String} path
+ * @param {String} paths
+ * @param {String} ignore
+ * @return {String}
+ * @api private
+ */
+
+exports.lookup = function(path, paths, ignore){
+  var lookup
+    , i = paths.length;
+
+  // Absolute
+  if (exports.absolute(path)) {
+    try {
+      fs.statSync(path);
+      return path;
+    } catch (err) {
+      // Ignore, continue on
+      // to trying relative lookup.
+      // Needed for url(/images/foo.png)
+      // for example
+    }
+  }
+
+  // Relative
+  while (i--) {
+    try {
+      lookup = join(paths[i], path);
+      if (ignore == lookup) continue;
+      fs.statSync(lookup);
+      return lookup;
+    } catch (err) {
+      // Ignore
+    }
+  }
+};
+
+/**
+ * Format the given `err` with the given `options`.
+ *
+ * Options:
+ *
+ *   - `filename`   context filename
+ *   - `context`    context line count [8]
+ *   - `lineno`     context line number
+ *   - `input`        input string
+ *
+ * @param {Error} err
+ * @param {Object} options
+ * @return {Error}
+ * @api private
+ */
+
+exports.formatException = function(err, options){
+  var lineno = options.lineno
+    , filename = options.filename
+    , str = options.input
+    , context = options.context || 8
+    , context = context / 2
+    , lines = ('\n' + str).split('\n')
+    , start = Math.max(lineno - context, 1)
+    , end = Math.min(lines.length, lineno + context)
+    , pad = end.toString().length;
+
+  var context = lines.slice(start, end).map(function(line, i){
+    var curr = i + start;
+    return (curr == lineno ? ' > ' : '   ')
+      + Array(pad - curr.toString().length + 1).join(' ')
+      + curr
+      + '| '
+      + line;
+  }).join('\n');
+
+  err.message = filename
+    + ':' + lineno
+    + '\n' + context
+    + '\n\n' + err.message + '\n'
+    + (err.stylusStack ? err.stylusStack + '\n' : '');
+
+  return err;
+};
+
+/**
+ * Assert that `node` is of the given `type`, or throw.
+ *
+ * @param {Node} node
+ * @param {Function} type
+ * @param {String} param
+ * @api public
+ */
+
+exports.assertType = function(node, type, param){
+  exports.assertPresent(node, param);
+  if (node.nodeName == type) return;
+  var actual = node.nodeName
+    , msg = 'expected "'
+      + param + '" to be a '
+      + type + ', but got '
+      + actual + ':' + node;
+  throw new Error('TypeError: ' + msg);
+};
+
+/**
+ * Assert that `node` is a `String` or `Ident`.
+ *
+ * @param {Node} node
+ * @param {String} param
+ * @api public
+ */
+
+exports.assertString = function(node, param){
+  exports.assertPresent(node, param);
+  switch (node.nodeName) {
+    case 'string':
+    case 'ident':
+    case 'literal':
+      return;
+    default:
+      var actual = node.nodeName
+        , msg = 'expected string, ident or literal, but got ' + actual + ':' + node;
+      throw new Error('TypeError: ' + msg);
+  }
+};
+
+/**
+ * Assert that `node` is a `RGBA` or `HSLA`.
+ *
+ * @param {Node} node
+ * @param {String} param
+ * @api public
+ */
+
+exports.assertColor = function(node, param){
+  exports.assertPresent(node, param);
+  switch (node.nodeName) {
+    case 'rgba':
+    case 'hsla':
+      return;
+    default:
+      var actual = node.nodeName
+        , msg = 'expected rgba or hsla, but got ' + actual + ':' + node;
+      throw new Error('TypeError: ' + msg);
+  }
+};
+
+/**
+ * Assert that param `name` is given, aka the `node` is passed.
+ *
+ * @param {Node} node
+ * @param {String} name
+ * @api public
+ */
+
+exports.assertPresent = function(node, name){
+  if (node) return;
+  if (name) throw new Error('"' + name + '" argument required');
+  throw new Error('argument missing');
+};
+
+/**
+ * Unwrap `expr`.
+ *
+ * Takes an expressions with length of 1
+ * such as `((1 2 3))` and unwraps it to `(1 2 3)`.
+ *
+ * @param {Expression} expr
+ * @return {Node}
+ * @api public
+ */
+
+exports.unwrap = function(expr){
+  // explicitly preserve the expression
+  if (expr.preserve) return expr;
+  if ('arguments' != expr.nodeName && 'expression' != expr.nodeName) return expr;
+  if (1 != expr.nodes.length) return expr;
+  if ('arguments' != expr.nodes[0].nodeName && 'expression' != expr.nodes[0].nodeName) return expr;
+  return exports.unwrap(expr.nodes[0]);
+};
+
+/**
+ * Return param names for `fn`.
+ *
+ * @param {Function} fn
+ * @return {Array}
+ * @api private
+ */
+
+exports.params = function(fn){
+  return fn
+    .toString()
+    .match(/\(([^)]*)\)/)[1].split(/ *, */);
+};
+
+/**
+ * Merge object `b` with `a`.
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ * @api private
+ */
+
+exports.merge = function(a, b){
+  for (var k in b) a[k] = b[k];
+  return a;
+}

data/lib/stylus/visitor/compiler.js

@@ -0,0 +1,472 @@
+
+/*!
+ * Stylus - Compiler
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Visitor = require('./')
+  , nodes = require('../nodes')
+  , fs = require('fs');
+
+/**
+ * Initialize a new `Compiler` with the given `root` Node
+ * and the following `options`.
+ *
+ * Options:
+ *
+ *   - `compress`  Compress the css output, defaults to false
+ *
+ * @param {Node} root
+ * @api public
+ */
+
+var Compiler = module.exports = function Compiler(root, options) {
+  options = options || {};
+  this.compress = options.compress;
+  this.firebug = options.firebug;
+  this.linenos = options.linenos;
+  this.indents = 1;
+  Visitor.call(this, root);
+  this.tree = [];
+  this.js = '';
+};
+
+/**
+ * Inherit from `Visitor.prototype`.
+ */
+
+Compiler.prototype.__proto__ = Visitor.prototype;
+
+/**
+ * Compile to css, and return a string of CSS.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Compiler.prototype.compile = function(){
+  return this.visit(this.root);
+};
+
+/**
+ * Return indentation string.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Compiler.prototype.__defineGetter__('indent', function(){
+  return this.compress
+     ? ''
+     : new Array(this.indents).join('  ');
+});
+
+/**
+ * Visit Root.
+ */
+
+Compiler.prototype.visitRoot = function(block){
+  this.buf = '';
+  for (var i = 0, len = block.nodes.length; i < len; ++i) {
+    var node = block.nodes[i];
+    switch (node.nodeName) {
+      case 'null':
+      case 'expression':
+      case 'function':
+      case 'jsliteral':
+      case 'unit':
+        continue;
+      default:
+        if (this.linenos || this.firebug) this.debugInfo(node);
+        var ret = this.visit(node);
+        if (ret) this.buf += ret + '\n';
+    }
+  }
+  return this.buf;
+};
+
+/**
+ * Visit Block.
+ */
+
+Compiler.prototype.visitBlock = function(block){
+  var node;
+
+  if (block.hasProperties) {
+    var arr = [this.compress ? '{' : ' {'];
+    ++this.indents;
+    for (var i = 0, len = block.nodes.length; i < len; ++i) {
+      this.last = len - 1 == i;
+      node = block.nodes[i];
+      switch (node.nodeName) {
+        case 'null':
+        case 'expression':
+        case 'function':
+        case 'jsliteral':
+        case 'group':
+        case 'unit':
+          continue;
+        default:
+          arr.push(this.visit(node));
+      } 
+    }
+    --this.indents;
+    arr.push(this.indent + '}');
+    this.buf += arr.join(this.compress ? '' : '\n');
+    this.buf += '\n';
+  }
+
+  // Nesting
+  for (var i = 0, len = block.nodes.length; i < len; ++i) {
+    node = block.nodes[i];
+    switch (node.nodeName) {
+      case 'group':
+      case 'print':
+      case 'page':
+      case 'block':
+      case 'keyframes':
+        if (this.linenos || this.firebug) this.debugInfo(node);
+        this.visit(node);
+        break;
+      case 'media':
+      case 'import':
+        this.visit(node);
+        break;
+    }
+  }
+};
+
+/**
+ * Visit Keyframes.
+ */
+
+Compiler.prototype.visitKeyframes = function(node){
+  var prefix = 'official' == node.prefix
+    ? ''
+    : '-' + node.prefix + '-';
+
+  this.buf += '@' + prefix + 'keyframes '
+    + this.visit(node.name)
+    + (this.compress ? '{' : ' {');
+  ++this.indents;
+  node.frames.forEach(function(frame){
+    if (!this.compress) this.buf += '\n  ';
+    this.buf += this.visit(frame.pos);
+    this.visit(frame.block);
+  }, this);
+  --this.indents;
+  this.buf += '}' + (this.compress ? '' : '\n');
+};
+
+/**
+ * Visit Media.
+ */
+
+Compiler.prototype.visitMedia = function(media){
+  this.buf += '@media ' + media.val;
+  this.buf += this.compress ? '{' : ' {\n';
+  ++this.indents;
+  this.visit(media.block);
+  --this.indents;
+  this.buf += '}' + (this.compress ? '' : '\n');
+};
+
+/**
+ * Visit Page.
+ */
+
+Compiler.prototype.visitPage = function(page){
+  this.buf += this.indent + '@page';
+  this.buf += page.selector ? ' ' + page.selector : '';
+  this.visit(page.block);
+};
+
+/**
+ * Visit Import.
+ */
+
+Compiler.prototype.visitImport = function(imported){
+  this.buf += '@import ' + this.visit(imported.path) + ';\n';
+};
+
+/**
+ * Visit FontFace.
+ */
+
+Compiler.prototype.visitFontFace = function(face){
+  this.buf += this.indent + '@font-face';
+  this.visit(face.block);
+};
+
+/**
+ * Visit JSLiteral.
+ */
+
+Compiler.prototype.visitJSLiteral = function(js){
+  this.js += '\n' + js.val.replace(/@selector/g, '"' + this.selector + '"');
+  return '';
+};
+
+/**
+ * Visit Comment.
+ */
+
+Compiler.prototype.visitComment = function(comment){
+  return this.compress
+    ? comment.suppress
+      ? ''
+      : comment.str
+    : comment.str;
+};
+
+/**
+ * Visit Function.
+ */
+
+Compiler.prototype.visitFunction = function(fn){
+  return fn.name;
+};
+
+/**
+ * Visit Variable.
+ */
+
+Compiler.prototype.visitVariable = function(variable){
+  return '';
+};
+
+/**
+ * Visit Charset.
+ */
+
+Compiler.prototype.visitCharset = function(charset){
+  return '@charset ' + this.visit(charset.val) + ';';
+};
+
+/**
+ * Visit Literal.
+ */
+
+Compiler.prototype.visitLiteral = function(lit){
+  return lit.val.trim().replace(/^  /gm, '');
+};
+
+/**
+ * Visit Boolean.
+ */
+
+Compiler.prototype.visitBoolean = function(bool){
+  return bool.toString();
+};
+
+/**
+ * Visit RGBA.
+ */
+
+Compiler.prototype.visitRGBA = function(rgba){
+  return rgba.toString();
+};
+
+/**
+ * Visit HSLA.
+ */
+
+Compiler.prototype.visitHSLA = function(hsla){
+  return hsla.rgba.toString();
+};
+
+/**
+ * Visit Unit.
+ */
+
+Compiler.prototype.visitUnit = function(unit){
+  var type = unit.type || ''
+    , n = unit.val
+    , float = n != (n | 0);
+
+  // Compress
+  if (this.compress) {
+    // Zero is always '0', unless when
+    // a percentage, this is required by keyframes
+    if ('%' != type && 0 == n) return '0';
+    // Omit leading '0' on floats
+    if (float && n < 1 && n > -1) {
+      return n.toString().replace('0.', '.') + type;
+    }
+  }
+
+  return n.toString() + type;
+};
+
+/**
+ * Visit Group.
+ */
+
+Compiler.prototype.visitGroup = function(group){
+  var self = this
+    , tree = this.tree
+    , prev = tree[tree.length - 1]
+    , curr = [];
+
+  // Construct an array of arrays
+  // representing the selector hierarchy
+  group.nodes.forEach(function(node){
+    curr.push(node.parent
+        ? node
+        : node.val);
+  });
+
+  tree.push(curr);
+
+  // Reverse recurse the
+  // hierarchy array to build
+  // up the selector combinations.
+  // When we reach root, we have our
+  // selector string built
+  var selectors = []
+    , buf = [];
+  function join(arr, i) {
+    if (i) {
+      arr[i].forEach(function(str){
+        buf.unshift(str);
+        join(arr, i - 1);
+        buf.shift();
+      });
+    } else {
+      arr[0].forEach(function(selector){
+        var str = selector.trim();
+        if (buf.length) {
+          for (var i = 0, len = buf.length; i < len; ++i) {
+            if (~buf[i].indexOf('&')) {
+              str = buf[i].replace(/&/g, str).trim();
+            } else {
+              str += ' ' + buf[i].trim();
+            }
+          }
+        }
+        selectors.push(self.indent + str.trimRight());
+      });
+    }
+  }
+
+  // Join selectors
+  if (group.block.hasProperties) {
+    join(tree, tree.length - 1);
+    this.buf += (this.selector = selectors.join(this.compress ? ',' : ',\n'));
+  }
+
+  // Output blocks
+  this.visit(group.block);
+  tree.pop();
+};
+
+/**
+ * Visit Ident.
+ */
+
+Compiler.prototype.visitIdent = function(ident){
+  return ident.name;
+};
+
+/**
+ * Visit String.
+ */
+
+Compiler.prototype.visitString = function(string){
+  return this.isURL
+    ? string.val
+    : string.toString();
+};
+
+/**
+ * Visit Null.
+ */
+
+Compiler.prototype.visitNull = function(node){
+  return '';
+};
+
+/**
+ * Visit Call.
+ */
+
+Compiler.prototype.visitCall = function(call){
+  this.isURL = 'url' == call.name;
+  var args = call.args.nodes.map(function(arg){
+    return this.visit(arg);
+  }, this).join(this.compress ? ',' : ', ');
+  if (this.isURL) args = '"' + args + '"';
+  delete this.isURL;
+  return call.name + '(' + args + ')';
+};
+
+/**
+ * Visit Expression.
+ */
+
+Compiler.prototype.visitExpression = function(expr){
+  var buf = []
+    , self = this
+    , len = expr.nodes.length
+    , nodes = expr.nodes.map(function(node){ return self.visit(node); });
+
+  nodes.forEach(function(node, i){
+    var last = i == len - 1;
+    buf.push(node);
+    if ('/' == nodes[i + 1] || '/' == node) return;
+    if (last) return;
+    buf.push(expr.isList
+      ? (self.compress ? ',' : ', ')
+      : (self.isURL ? '' : ' '));
+  });
+
+  return buf.join('');
+};
+
+/**
+ * Visit Arguments.
+ */
+
+Compiler.prototype.visitArguments = Compiler.prototype.visitExpression;
+
+/**
+ * Visit Property.
+ */
+
+Compiler.prototype.visitProperty = function(prop){
+  var self = this
+    , val = this.visit(prop.expr);
+  return this.indent + (prop.name || prop.segments.join(''))
+    + (this.compress ? ':' + val : ': ' + val)
+    + (this.compress
+        ? (this.last ? '' : ';')
+        : ';');
+};
+
+/**
+ * Debug info.
+ */
+
+Compiler.prototype.debugInfo = function(node){
+
+  var path = fs.realpathSync(node.filename)
+    , line = node.nodes ? node.nodes[0].lineno : node.lineno;
+
+  if (this.linenos){
+    this.buf += '\n/* ' + 'line ' + line + ' : ' + path + ' */\n';
+  }
+  
+  if (this.firebug){
+    // debug info for firebug, the crazy formatting is needed
+    path = 'file\\\:\\\/\\\/' + path.replace(/(\/|\.)/g, '\\$1');
+    line = '\\00003' + line;
+    this.buf += '\n@media -stylus-debug-info' 
+      + '{filename{font-family:' + path
+      + '}line{font-family:' + line + '}}\n';
+  }
+}