stylus-source 0.15.4

data/lib/stylus/renderer.js

@@ -0,0 +1,157 @@
+
+/*!
+ * Stylus - Renderer
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Parser = require('./parser')
+  , Compiler = require('./visitor/compiler')
+  , Evaluator = require('./visitor/evaluator')
+  , utils = require('./utils')
+  , nodes = require('./nodes')
+  , path = require('path')
+  , join = path.join;
+
+/**
+ * Initialize a new `Renderer` with the given `str` and `options`.
+ *
+ * @param {String} str
+ * @param {Object} options
+ * @api public
+ */
+
+var Renderer = module.exports = function Renderer(str, options) {
+  options = options || {};
+  options.globals = {};
+  options.functions = {};
+  options.imports = [join(__dirname, 'functions')];
+  options.paths = options.paths || [];
+  options.filename = options.filename || 'stylus';
+  this.options = options;
+  this.str = str;
+};
+
+/**
+ * Parse and evaluate AST, then callback `fn(err, css, js)`.
+ *
+ * @param {Function} fn
+ * @api public
+ */
+
+Renderer.prototype.render = function(fn){
+  var parser = this.parser = new Parser(this.str, this.options);
+  try {
+    nodes.filename = this.options.filename;
+    var ast = parser.parse();
+    this.evaluator = new Evaluator(ast, this.options);
+    ast = this.evaluator.evaluate();
+    var compiler = new Compiler(ast, this.options)
+      , css = compiler.compile()
+      , js = compiler.js;
+    fn(null, css, js);
+  } catch (err) {
+    var options = {};
+    options.input = err.input || this.str;
+    options.filename = err.filename || this.options.filename;
+    options.lineno = err.lineno || parser.lexer.lineno;
+    fn(utils.formatException(err, options));
+  }
+};
+
+/**
+ * Set option `key` to `val`.
+ *
+ * @param {String} key
+ * @param {Mixed} val
+ * @return {Renderer} for chaining
+ * @api public
+ */
+
+Renderer.prototype.set = function(key, val){
+  this.options[key] = val;
+  return this;
+};
+
+/**
+ * Get option `key`.
+ *
+ * @param {String} key
+ * @return {Mixed} val
+ * @api public
+ */
+
+Renderer.prototype.get = function(key){
+  return this.options[key];
+};
+
+/**
+ * Include the given `path` to the lookup paths array.
+ *
+ * @param {String} path
+ * @return {Renderer} for chaining
+ * @api public
+ */
+
+Renderer.prototype.include = function(path){
+  this.options.paths.push(path);
+  return this;
+};
+
+/**
+ * Use the given `fn`.
+ *
+ * This allows for plugins to alter the renderer in
+ * any way they wish, exposing paths etc.
+ *
+ * @param {Function}
+ * @return {Renderer} for chaining
+ * @api public
+ */
+
+Renderer.prototype.use = function(fn){
+  fn.call(this, this);
+  return this;
+};
+
+/**
+ * Define function or global var with the given `name`. Optionally
+ * the function may accept full expressions, by setting `raw`
+ * to `true`.
+ *
+ * @param {String} name
+ * @param {Function|Node} fn
+ * @return {Renderer} for chaining
+ * @api public
+ */
+
+Renderer.prototype.define = function(name, fn, raw){
+  if (fn.nodeName) {
+    this.options.globals[name] = fn;
+    return this;
+  }
+
+  // function
+  this.options.functions[name] = fn;
+  if (undefined != raw) fn.raw = raw;
+  return this;
+};
+
+/**
+ * Import the given `file`.
+ *
+ * @param {String} file
+ * @return {Renderer} for chaining
+ * @api public
+ */
+
+Renderer.prototype.import = function(file){
+  this.options.imports.push(file);
+  return this;
+};
+
+

data/lib/stylus/source.rb

@@ -0,0 +1,7 @@
+module Stylus
+  module Source
+    def self.bundled_path
+      File.expand_path("../stylus.js", __FILE__)
+    end
+  end
+end

data/lib/stylus/stack/frame.js

@@ -0,0 +1,66 @@
+
+/*!
+ * Stylus - stack - Frame
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Scope = require('./scope')
+  , blocks = require('../nodes');
+
+/**
+ * Initialize a new `Frame` with the given `block`.
+ *
+ * @param {Block} block
+ * @api private
+ */
+
+var Frame = module.exports = function Frame(block) {
+  this._scope = false === block.scope
+    ? null
+    : new Scope;
+  this.block = block;
+};
+
+/**
+ * Return this frame's scope or the parent scope
+ * for scope-less blocks.
+ *
+ * @return {Scope}
+ * @api public
+ */
+
+Frame.prototype.__defineGetter__('scope', function(){
+  return this._scope || this.parent.scope;
+});
+
+/**
+ * Lookup the given local variable `name`.
+ *
+ * @param {String} name
+ * @return {Node}
+ * @api private
+ */
+
+Frame.prototype.lookup = function(name){
+  return this.scope.lookup(name)
+};
+
+/**
+ * Custom inspect.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Frame.prototype.inspect = function(){
+  return '[Frame '
+    + (false === this.block.scope
+        ? 'scope-less'
+        : this.scope.inspect())
+    + ']';
+};

data/lib/stylus/stack/index.js

@@ -0,0 +1,146 @@
+
+/*!
+ * Stylus - Stack
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Frame = require('./frame');
+
+/**
+ * Initialize a new `Stack`.
+ *
+ * @api private
+ */
+
+var Stack = module.exports = function Stack() {
+  Array.apply(this, arguments);
+};
+
+/**
+ * Inherit from `Array.prototype`.
+ */
+
+Stack.prototype.__proto__ = Array.prototype;
+
+/**
+ * Push the given `frame`.
+ *
+ * @param {Frame} frame
+ * @api public
+ */
+
+Stack.prototype.push = function(frame){
+  frame.stack = this;
+  frame.parent = this.currentFrame;
+  return [].push.apply(this, arguments);
+};
+
+/**
+ * Return the current stack `Frame`.
+ *
+ * @return {Frame}
+ * @api private
+ */
+
+Stack.prototype.__defineGetter__('currentFrame', function(){
+  return this[this.length - 1];
+});
+
+/**
+ * Lookup stack frame for the given `block`.
+ *
+ * @param {Block} block
+ * @return {Frame}
+ * @api private
+ */
+
+Stack.prototype.getBlockFrame = function(block){
+  for (var i = 0; i < this.length; ++i) {
+    if (block == this[i].block) {
+      return this[i];
+    }
+  }
+};
+
+/**
+ * Lookup the given local variable `name`, relative
+ * to the lexical scope of the current frame's `Block`.
+ *
+ * When the result of a lookup is an identifier
+ * a recursive lookup is performed, defaulting to
+ * returning the identifier itself.
+ *
+ * @param {String} name
+ * @return {Node}
+ * @api private
+ */
+
+Stack.prototype.lookup = function(name){
+  var block = this.currentFrame.block
+    , val
+    , ret;
+
+  do {
+    var frame = this.getBlockFrame(block);
+    if (frame && (val = frame.lookup(name))) {
+      switch (val.first.nodeName) {
+        case 'ident':
+          return this.lookup(val.first.name) || val;
+        default:
+          return val;
+      }
+    }
+  } while (block = block.parent);
+};
+
+/**
+ * Custom inspect.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Stack.prototype.inspect = function(){
+  return this.reverse().map(function(frame){
+    return frame.inspect();
+  }).join('\n');
+};
+
+/**
+ * Return stack string formatted as:
+ *
+ *   at <context> (<filename>:<lineno>)
+ *
+ * @return {String}
+ * @api private
+ */
+
+Stack.prototype.toString = function(){
+  var block
+    , node
+    , buf = []
+    , location
+    , len = this.length;
+
+  while (len--) {
+    block = this[len].block;
+    if (node = block.node) {
+      location = '(' + node.filename + ':' + (node.lineno + 1) + ')';
+      switch (node.nodeName) {
+        case 'function':
+          buf.push('    at ' + node.name + '() ' + location);
+          break;
+        case 'group':
+          buf.push('    at "' + node.nodes[0].val + '" ' + location);
+          break;
+      }
+    }
+  }
+
+  return buf.join('\n');
+};

data/lib/stylus/stack/scope.js

@@ -0,0 +1,53 @@
+
+/*!
+ * Stylus - stack - Scope
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Initialize a new `Scope`.
+ *
+ * @api private
+ */
+
+var Scope = module.exports = function Scope() {
+  this.locals = {};
+};
+
+/**
+ * Add `ident` node to the current scope.
+ *
+ * @param {Ident} ident
+ * @api private
+ */
+
+Scope.prototype.add = function(ident){
+  this.locals[ident.name] = ident.val;
+};
+
+/**
+ * Lookup the given local variable `name`.
+ *
+ * @param {String} name
+ * @return {Node}
+ * @api private
+ */
+
+Scope.prototype.lookup = function(name){
+  return this.locals[name];
+};
+
+/**
+ * Custom inspect.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Scope.prototype.inspect = function(){
+  var keys = Object.keys(this.locals).map(function(key){ return '@' + key; });
+  return '[Scope'
+    + (keys.length ? ' ' + keys.join(', ') : '')
+    + ']';
+};

data/lib/stylus/stylus.js

@@ -0,0 +1,102 @@
+
+/*!
+ * Stylus
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Renderer = require('./renderer')
+  , Parser = require('./parser')
+  , nodes = require('./nodes')
+  , utils = require('./utils');
+
+/**
+ * Export render as the module.
+ */
+
+exports = module.exports = render;
+
+/**
+ * Library version.
+ */
+
+exports.version = '0.15.4';
+
+/**
+ * Expose nodes.
+ */
+
+exports.nodes = nodes;
+
+/**
+ * Expose BIFs.
+ */
+
+exports.functions = require('./functions');
+
+/**
+ * Expose utils.
+ */
+
+exports.utils = require('./utils');
+
+/**
+ * Expose middleware.
+ */
+
+exports.middleware = require('./middleware');
+
+/**
+ * Expose constructors.
+ */
+
+exports.Visitor = require('./visitor');
+exports.Parser = require('./parser');
+exports.Evaluator = require('./visitor/evaluator');
+
+/**
+ * Convert the given `css` to `stylus` source.
+ *
+ * @param {String} css
+ * @return {String}
+ * @api public
+ */
+
+exports.convertCSS = require('./convert/css');
+
+/**
+ * Render the given `str` with `options` and callback `fn(err, css)`.
+ *
+ * @param {String} str
+ * @param {Object|Function} options
+ * @param {Function} fn
+ * @api public
+ */
+
+exports.render = function(str, options, fn){
+  if ('function' == typeof options) fn = options, options = {};
+  new Renderer(str, options).render(fn);
+};
+
+/**
+ * Return a new `Renderer` for the given `str` and `options`.
+ *
+ * @param {String} str
+ * @param {Object} options
+ * @return {Renderer}
+ * @api public
+ */
+
+function render(str, options) {
+  return new Renderer(str, options);
+}
+
+/**
+ * Expose optional functions.
+ */
+
+exports.url = require('./functions/url');