stylus-source 0.15.4

data/lib/stylus/nodes/if.js

@@ -0,0 +1,55 @@
+
+/*!
+ * Stylus - If
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node');
+
+/**
+ * Initialize a new `If` with the given `cond`.
+ *
+ * @param {Expression} cond
+ * @param {Boolean|Block} negate, block
+ * @api public
+ */
+
+var If = module.exports = function If(cond, negate){
+  Node.call(this);
+  this.cond = cond;
+  this.elses = [];
+  if (negate && negate.nodeName) {
+    this.block = negate;
+  } else {
+    this.negate = negate;
+  }
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+If.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return a clone of this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+If.prototype.clone = function(){
+  var cond = this.cond.clone()
+    , block = this.block.clone();
+  var clone = new If(cond, block);
+  clone.elses = this.elses.map(function(node){ return node.clone(); });
+  clone.negate = this.negate;
+  clone.lineno = this.lineno;
+  clone.filename = this.filename;
+  return clone;
+};

data/lib/stylus/nodes/import.js

@@ -0,0 +1,30 @@
+
+/*!
+ * Stylus - Import
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node');
+
+/**
+ * Initialize a new `Import` with the given `expr`.
+ *
+ * @param {Expression} expr
+ * @api public
+ */
+
+var Import = module.exports = function Import(expr){
+  Node.call(this);
+  this.path = expr;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Import.prototype.__proto__ = Node.prototype;

data/lib/stylus/nodes/index.js

@@ -0,0 +1,52 @@
+
+/*!
+ * Stylus - nodes
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Constructors
+ */
+
+exports.Node = require('./node');
+exports.Root = require('./root');
+exports.Null = require('./null');
+exports.Each = require('./each');
+exports.If = require('./if');
+exports.Call = require('./call');
+exports.Page = require('./page');
+exports.FontFace = require('./fontface');
+exports.UnaryOp = require('./unaryop');
+exports.BinOp = require('./binop');
+exports.Ternary = require('./ternary');
+exports.Block = require('./block');
+exports.Unit = require('./unit');
+exports.String = require('./string');
+exports.HSLA = require('./hsla');
+exports.RGBA = require('./rgba');
+exports.Ident = require('./ident');
+exports.Group = require('./group');
+exports.Literal = require('./literal');
+exports.JSLiteral = require('./jsliteral');
+exports.Boolean = require('./boolean');
+exports.Return = require('./return');
+exports.Media = require('./media');
+exports.Params = require('./params');
+exports.Comment = require('./comment');
+exports.Keyframes = require('./keyframes');
+exports.Charset = require('./charset');
+exports.Import = require('./import');
+exports.Function = require('./function');
+exports.Property = require('./property');
+exports.Selector = require('./selector');
+exports.Expression = require('./expression');
+exports.Arguments = require('./arguments');
+
+/**
+ * Singletons.
+ */
+
+exports.true = new exports.Boolean(true);
+exports.false = new exports.Boolean(false);
+exports.null = new exports.Null;

data/lib/stylus/nodes/jsliteral.js

@@ -0,0 +1,32 @@
+
+/*!
+ * Stylus - JSLiteral
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node')
+  , nodes = require('./');
+
+/**
+ * Initialize a new `JSLiteral` with the given `str`.
+ *
+ * @param {String} str
+ * @api public
+ */
+
+var JSLiteral = module.exports = function JSLiteral(str){
+  Node.call(this);
+  this.val = str;
+  this.string = str;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+JSLiteral.prototype.__proto__ = Node.prototype;

data/lib/stylus/nodes/keyframes.js

@@ -0,0 +1,78 @@
+
+/*!
+ * Stylus - Keyframes
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node');
+
+/**
+ * Initialize a new `Keyframes` with the given `name`,
+ * and optional vendor `prefix`.
+ *
+ * @param {String} name
+ * @param {String} prefix
+ * @api public
+ */
+
+var Keyframes = module.exports = function Keyframes(name, prefix){
+  Node.call(this);
+  this.name = name;
+  this.frames = [];
+  this.prefix = prefix || 'official';
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Keyframes.prototype.__proto__ = Node.prototype;
+
+/**
+ * Push the given `block` at `pos`.
+ *
+ * @param {Unit} pos
+ * @param {Block} block
+ * @api public
+ */
+
+Keyframes.prototype.push = function(pos, block){
+  this.frames.push({
+      pos: pos
+    , block: block
+  });
+};
+
+/**
+ * Return a clone of this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+Keyframes.prototype.clone = function(){
+  var clone = new Keyframes(this.name);
+  clone.lineno = this.lineno;
+  clone.prefix = this.prefix;
+  clone.frames = this.frames.map(function(node){
+    node.block = node.block.clone();
+    return node;
+  });
+  return clone;
+};
+
+/**
+ * Return `@keyframes name`.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Keyframes.prototype.toString = function(){
+  return '@keyframes ' + this.name;
+};

data/lib/stylus/nodes/literal.js

@@ -0,0 +1,92 @@
+
+/*!
+ * Stylus - Literal
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node')
+  , nodes = require('./');
+
+/**
+ * Initialize a new `Literal` with the given `str`.
+ *
+ * @param {String} str
+ * @api public
+ */
+
+var Literal = module.exports = function Literal(str){
+  Node.call(this);
+  this.val = str;
+  this.string = str;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Literal.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return hash.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Literal.prototype.__defineGetter__('hash', function(){
+  return this.val;
+});
+
+/**
+ * Return literal value.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Literal.prototype.toString = function(){
+  return this.val;
+};
+
+/**
+ * Coerce `other` to a literal.
+ *
+ * @param {Node} other
+ * @return {String}
+ * @api public
+ */
+
+Literal.prototype.coerce = function(other){
+  switch (other.nodeName) {
+    case 'ident':
+    case 'string':
+    case 'literal':
+      return new Literal(other.string);
+    default:
+      return Node.prototype.coerce.call(this, other);
+  }
+};
+
+/**
+ * Operate on `right` with the given `op`.
+ *
+ * @param {String} op
+ * @param {Node} right
+ * @return {Node}
+ * @api public
+ */
+
+Literal.prototype.operate = function(op, right){
+  var val = right.first;
+  switch (op) {
+    case '+':
+      return new nodes.Literal(this.string + this.coerce(val).string);
+    default:
+      return Node.prototype.operate.call(this, op, right);
+  }
+};

data/lib/stylus/nodes/media.js

@@ -0,0 +1,42 @@
+
+/*!
+ * Stylus - Media
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node')
+  , nodes = require('./');
+
+/**
+ * Initialize a new `Media` with the given `val`
+ *
+ * @param {String} val
+ * @api public
+ */
+
+var Media = module.exports = function Media(val){
+  Node.call(this);
+  this.val = val;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Media.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return @media "val".
+ *
+ * @return {String}
+ * @api public
+ */
+
+Media.prototype.toString = function(){
+  return '@media ' + this.val;
+};

data/lib/stylus/nodes/node.js

@@ -0,0 +1,209 @@
+
+/*!
+ * Stylus - Node
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Evaluator = require('../visitor/evaluator')
+  , utils = require('../utils')
+  , nodes = require('./');
+
+/**
+ * Node constructor.
+ *
+ * @api public
+ */
+
+var Node = module.exports = function Node(){
+  this.lineno = nodes.lineno;
+  Object.defineProperty(this, 'filename', { writable: true, value: nodes.filename });
+};
+
+/**
+ * Return this node.
+ *
+ * @return {Node}
+ * @api public
+ */
+
+Node.prototype.__defineGetter__('first', function(){
+  return this;
+});
+
+/**
+ * Return hash.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Node.prototype.__defineGetter__('hash', function(){
+  return this.val;
+});
+
+/**
+ * Return node name.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Node.prototype.__defineGetter__('nodeName', function(){
+  return this.constructor.name.toLowerCase();
+});
+
+/**
+ * Return this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+Node.prototype.clone = function(){
+  return this;
+};
+
+/**
+ * Nodes by default evaluate to themselves.
+ *
+ * @return {Node}
+ * @api public
+ */
+
+Node.prototype.eval = function(){
+  return new Evaluator(this).evaluate();
+};
+
+/**
+ * Return true.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+Node.prototype.toBoolean = function(){
+  return nodes.true;
+};
+
+/**
+ * Return false if `op` is generally not coerced.
+ *
+ * @param {String} op
+ * @return {Boolean}
+ * @api private
+ */
+
+Node.prototype.shouldCoerce = function(op){
+  switch (op) {
+    case 'is a':
+    case 'in':
+    case '||':
+    case '&&':
+      return false;
+    default:
+      return true;
+  }
+};
+
+/**
+ * Operate on `right` with the given `op`.
+ *
+ * @param {String} op
+ * @param {Node} right
+ * @return {Node}
+ * @api public
+ */
+
+Node.prototype.operate = function(op, right){
+  switch (op) {
+    case 'is a':
+      if ('string' == right.nodeName) {
+        return nodes.Boolean(this.nodeName == right.val);
+      } else {
+        throw new Error('"is a" expects a string, got ' + right.toString());
+      }
+    case '==':
+      return nodes.Boolean(this.hash == right.hash);
+    case '!=':
+      return nodes.Boolean(this.hash != right.hash);
+    case '>=':
+      return nodes.Boolean(this.hash >= right.hash);
+    case '<=':
+      return nodes.Boolean(this.hash <= right.hash);
+    case '>':
+      return nodes.Boolean(this.hash > right.hash);
+    case '<':
+      return nodes.Boolean(this.hash < right.hash);
+    case '||':
+      return this.toBoolean().isTrue
+        ? this
+        : right;
+    case 'in':
+      var vals = utils.unwrap(right).nodes
+        , hash = this.hash;
+      if (!vals) throw new Error('"in" given invalid right-hand operand, expecting an expression');
+      for (var i = 0, len = vals.length; i < len; ++i) {
+        if (hash == vals[i].hash) {
+          return nodes.true;
+        }
+      }
+      return nodes.false;
+    case '&&':
+      var a = this.toBoolean()
+        , b = right.toBoolean();
+      return a.isTrue && b.isTrue
+        ? right
+        : a.isFalse
+          ? this
+          : right;
+    default:
+      if ('[]' == op) {
+        var msg = 'cannot perform '
+          + this
+          + '[' + right + ']';
+      } else {
+        var msg = 'cannot perform'
+          + ' ' + this
+          + ' ' + op
+          + ' ' + right;
+      }
+      throw new Error(msg);
+  }
+};
+
+/**
+ * Initialize a new `CoercionError` with the given `msg`.
+ *
+ * @param {String} msg
+ * @api private
+ */
+
+function CoercionError(msg) {
+  this.name = 'CoercionError'
+  this.message = msg
+  Error.captureStackTrace(this, CoercionError);
+}
+
+/**
+ * Inherit from `Error.prototype`.
+ */
+
+CoercionError.prototype.__proto__ = Error.prototype;
+
+/**
+ * Default coercion throws.
+ *
+ * @param {Node} other
+ * @return {Node}
+ * @api public
+ */
+
+Node.prototype.coerce = function(other){
+  if (other.nodeName == this.nodeName) return other;
+  throw new CoercionError('cannot coerce ' + other + ' to ' + this.nodeName);
+};