stylus-source 0.15.4

data/lib/stylus/nodes/root.js

@@ -0,0 +1,50 @@
+
+/*!
+ * Stylus - Root
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node');
+
+/**
+ * Initialize a new `Root` node.
+ *
+ * @api public
+ */
+
+var Root = module.exports = function Root(){
+  this.nodes = [];
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Root.prototype.__proto__ = Node.prototype;
+
+/**
+ * Push a `node` to this block.
+ *
+ * @param {Node} node
+ * @api public
+ */
+
+Root.prototype.push = function(node){
+  this.nodes.push(node);
+};
+
+/**
+ * Return "root".
+ *
+ * @return {String}
+ * @api public
+ */
+
+Root.prototype.toString = function(){
+  return '[Root]';
+};

data/lib/stylus/nodes/selector.js

@@ -0,0 +1,57 @@
+
+/*!
+ * Stylus - Selector
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Block = require('./block')
+  , Node = require('./node');
+
+/**
+ * Initialize a new `Selector` with the given `segs`.
+ *
+ * @param {Array} segs
+ * @api public
+ */
+
+var Selector = module.exports = function Selector(segs){
+  Node.call(this);
+  this.segments = segs;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Selector.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return the selector string.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Selector.prototype.toString = function(){
+  return this.segments.join('');
+};
+
+/**
+ * Return a clone of this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+Selector.prototype.clone = function(){
+  var clone = new Selector;
+  clone.lineno = this.lineno;
+  clone.filename = this.filename;
+  clone.segments = this.segments.map(function(node){ return node.clone(); });
+  return clone;
+};

data/lib/stylus/nodes/string.js

@@ -0,0 +1,120 @@
+
+/*!
+ * Stylus - String
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node')
+  , sprintf = require('../functions').s
+  , utils = require('../utils')
+  , nodes = require('./');
+
+/**
+ * Initialize a new `String` with the given `val`.
+ *
+ * @param {String} val
+ * @api public
+ */
+
+var String = module.exports = function String(val){
+  Node.call(this);
+  this.val = val;
+  this.string = val;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+String.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return quoted string.
+ *
+ * @return {String}
+ * @api public
+ */
+
+String.prototype.toString = function(){
+  return '"' + this.val + '"';
+};
+
+/**
+ * Return a clone of this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+String.prototype.clone = function(){
+  var clone = new String(this.val);
+  clone.lineno = this.lineno;
+  clone.filename = this.filename;
+  return clone;
+};
+
+/**
+ * Return Boolean based on the length of this string.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+String.prototype.toBoolean = function(){
+  return nodes.Boolean(this.val.length);
+};
+
+/**
+ * Coerce `other` to a string.
+ *
+ * @param {Node} other
+ * @return {String}
+ * @api public
+ */
+
+String.prototype.coerce = function(other){
+  switch (other.nodeName) {
+    case 'string':
+      return other;
+    case 'expression':
+      return new String(other.nodes.map(function(node){
+        return this.coerce(node).val;
+      }, this).join(' '));
+    default:
+      return new String(other.toString());
+  }
+};
+
+/**
+ * Operate on `right` with the given `op`.
+ *
+ * @param {String} op
+ * @param {Node} right
+ * @return {Node}
+ * @api public
+ */
+
+String.prototype.operate = function(op, right){
+  switch (op) {
+    case '%':
+      var expr = new nodes.Expression;
+      expr.push(this);
+
+      // constructargs
+      var args = 'expression' == right.nodeName
+        ? utils.unwrap(right).nodes
+        : [right];
+
+      // apply
+      return sprintf.apply(null, [expr].concat(args));
+    case '+':
+      return new String(this.val + this.coerce(right).val);
+    default:
+      return Node.prototype.operate.call(this, op, right);
+  }
+};

data/lib/stylus/nodes/ternary.js

@@ -0,0 +1,51 @@
+
+/*!
+ * Stylus - Ternary
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node');
+
+/**
+ * Initialize a new `Ternary` with `cond`, `trueExpr` and `falseExpr`.
+ *
+ * @param {Expression} cond
+ * @param {Expression} trueExpr
+ * @param {Expression} falseExpr
+ * @api public
+ */
+
+var Ternary = module.exports = function Ternary(cond, trueExpr, falseExpr){
+  Node.call(this);
+  this.cond = cond;
+  this.trueExpr = trueExpr;
+  this.falseExpr = falseExpr;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Ternary.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return a clone of this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+Ternary.prototype.clone = function(){
+  var clone = new Ternary(
+      this.cond.clone()
+    , this.trueExpr.clone()
+    , this.falseExpr.clone());
+  clone.lineno = this.lineno;
+  clone.filename = this.filename;
+  return clone;
+};

data/lib/stylus/nodes/unaryop.js

@@ -0,0 +1,46 @@
+
+/*!
+ * Stylus - UnaryOp
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node');
+
+/**
+ * Initialize a new `UnaryOp` with `op`, and `expr`.
+ *
+ * @param {String} op
+ * @param {Node} expr
+ * @api public
+ */
+
+var UnaryOp = module.exports = function UnaryOp(op, expr){
+  Node.call(this);
+  this.op = op;
+  this.expr = expr;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+UnaryOp.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return a clone of this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+UnaryOp.prototype.clone = function(){
+  var clone = new UnaryOp(this.op, this.expr.clone());
+  clone.lineno = this.lineno;
+  clone.filename = this.filename;
+  return clone;
+};

data/lib/stylus/nodes/unit.js

@@ -0,0 +1,207 @@
+
+/*!
+ * Stylus - Unit
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Node = require('./node')
+  , nodes = require('./');
+
+/**
+ * Initialize a new `Unit` with the given `val` and unit `type`
+ * such as "px", "pt", "in", etc.
+ *
+ * @param {String} val
+ * @param {String} type
+ * @api public
+ */
+
+var Unit = module.exports = function Unit(val, type){
+  Node.call(this);
+  this.val = val;
+  this.type = type;
+};
+
+/**
+ * Inherit from `Node.prototype`.
+ */
+
+Unit.prototype.__proto__ = Node.prototype;
+
+/**
+ * Return Boolean based on the unit value.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+Unit.prototype.toBoolean = function(){
+  return nodes.Boolean(this.type
+      ? true
+      : this.val);
+};
+
+/**
+ * Return unit string.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Unit.prototype.toString = function(){
+  var n = this.val;
+  if ('px' == this.type) n = n.toFixed(0);
+  return n + (this.type || '');
+};
+
+/**
+ * Return a clone of this node.
+ * 
+ * @return {Node}
+ * @api public
+ */
+
+Unit.prototype.clone = function(){
+  var clone = new Unit(this.val, this.type);
+  clone.lineno = this.lineno;
+  clone.filename = this.filename;
+  return clone;
+};
+
+/**
+ * Operate on `right` with the given `op`.
+ *
+ * @param {String} op
+ * @param {Node} right
+ * @return {Node}
+ * @api public
+ */
+
+Unit.prototype.operate = function(op, right){
+  var type = this.type || right.type;
+
+  // swap color
+  if ('rgba' == right.nodeName || 'hsla' == right.nodeName) {
+    return right.operate(op, this);
+  }
+
+  // operate
+  if (this.shouldCoerce(op)) {
+    // percentages
+    if (('-' == op || '+' == op) && '%' == right.type) {
+      right.val = this.val * (right.val / 100);
+    } else {
+      right = this.coerce(right.first);
+    }
+
+    switch (op) {
+      case '-':
+        return new Unit(this.val - right.val, type);
+      case '+':                               
+        return new Unit(this.val + right.val, type);
+      case '/':                               
+        return new Unit(this.val / right.val, type);
+      case '*':                               
+        return new Unit(this.val * right.val, type);
+      case '%':
+        return new Unit(this.val % right.val, type);
+      case '**':
+        return new Unit(Math.pow(this.val, right.val), type);
+      case '..':
+      case '...':
+        var start = this.val
+          , end = right.val
+          , expr = new nodes.Expression
+          , inclusive = '..' == op;
+        do {
+          expr.push(new nodes.Unit(start));
+        } while (inclusive ? ++start <= end : ++start < end);
+        return expr;
+    }
+  }
+
+  return Node.prototype.operate.call(this, op, right);
+};
+
+/**
+ * Coerce `other` unit to the same type as `this` unit.
+ *
+ * Supports:
+ *
+ *    mm -> cm | in
+ *    cm -> mm | in
+ *    in -> mm | cm
+ *    
+ *    ms -> s
+ *    s  -> ms
+ *    
+ *    Hz  -> kHz
+ *    kHz -> Hz
+ *
+ * @param {Unit} other
+ * @return {Unit}
+ * @api public
+ */
+
+Unit.prototype.coerce = function(other){
+  if ('unit' == other.nodeName) {
+    var a = this
+      , b = other;
+    switch (a.type) {
+      case 'mm':
+        switch (b.type) {
+          case 'cm':
+            return new nodes.Unit(b.val * 2.54, 'mm');
+          case 'in':
+            return new nodes.Unit(b.val * 25.4, 'mm');
+        }
+      case 'cm':
+        switch (b.type) {
+          case 'mm':
+            return new nodes.Unit(b.val / 10, 'cm');
+          case 'in':
+            return new nodes.Unit(b.val * 2.54, 'cm');
+        }
+      case 'in':
+        switch (b.type) {
+          case 'mm':
+            return new nodes.Unit(b.val / 25.4, 'in');
+          case 'cm':
+            return new nodes.Unit(b.val / 2.54, 'in');
+        }
+      case 'ms':
+        switch (b.type) {
+          case 's':
+            return new nodes.Unit(b.val * 1000, 'ms');
+        }
+      case 's':
+        switch (b.type) {
+          case 'ms':
+            return new nodes.Unit(b.val / 1000, 's');
+        }
+      case 'Hz':
+        switch (b.type) {
+          case 'kHz':
+            return new nodes.Unit(b.val * 1000, 'Hz');
+        }
+      case 'kHz':
+        switch (b.type) {
+          case 'Hz':
+            return new nodes.Unit(b.val / 1000, 'kHz');
+        }
+      default:
+        return new nodes.Unit(b.val, a.type);
+    }
+  } else if ('string' == other.nodeName) {
+    var val = parseInt(other.val, 10);
+    if (isNaN(val)) Node.prototype.coerce.call(this, other);
+    return new nodes.Unit(val);
+  } else {
+    return Node.prototype.coerce.call(this, other);
+  }
+};