-- still working towards a functional engine --

Author: CLR

.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+**~
+casey.time.txt

README

@@ -0,0 +1,3 @@
+The library setup is virtually identical to the HAML / SASS layout, with exceptions for obvious refactoring opportunities, such as moving the 'shared' library out of 'haml/'
+
+

lib/sassij.js

@@ -0,0 +1,74 @@
+Sassij = function(){};
+
+// Sugar functions follow.
+// Inspired by [ http://www.crockford.com/javascript/inheritance.html ]
+
+Function.prototype.method = function( name, lambda ){
+  this.prototype[name] = lambda;
+  return this;
+};
+
+// To be used as in ChildClass.inherits( ParentClass )
+Function.method( 'inherits', function( parent ) {
+  var d = {};
+  var p = ( this.prototype = new parent() );
+
+  this.method( '_super', function _super( name ){
+    if( !( name in d ) ){
+      d[name] = 0;
+    }        
+    var f, r, t = d[name];
+    var v = parent.prototype;
+    if( t ){
+      while( t ){
+        v = v.constructor.prototype;
+        t -= 1;
+      }
+      f = v[name];
+    } else {
+      f = p[name];
+      if( f == this[name] ){
+        f = v[name];
+      }
+    }
+    d[name] += 1;
+    r = f.apply( this, Array.prototype.slice.apply( arguments, [1] ) );
+    d[name] -= 1;
+    return r;
+  });
+  return this;
+});
+
+Function.method( 'swiss', function( parent ){
+  for( var i = 1; i < arguments.length; i++ ){
+    var name = arguments[i];
+    this.prototype[name] = parent.prototype[name];
+  }
+  return this;
+});
+
+Function.method( 'attr', function( valueName, initialValue ){
+  var that = this;
+  that.prototype[valueName] = initialValue;
+  
+  // Create a getter.
+  this.method( ( 'get' + valueName.toCamelCase() ), function(){
+    return that.prototype[valueName];
+  } );
+
+  // Create a setter.
+  this.method( 'set' + valueName.toCamelCase(), function( newValue ){
+    that.prototype[valueName] = newValue;
+    return that;
+  });
+
+  return this;
+});
+
+Function.prototype.bind = function( object ){
+  var method = this;
+  var temp = function() {
+    return method.apply( object, arguments );
+   };
+  return temp;
+} 

lib/sassij/engine.js

@@ -0,0 +1,68 @@
+//  This is the class where all the parsing and processing of the Sass
+//  template is done. It can be directly used by the user by creating a
+//  new instance and calling <tt>render</tt> to render the template. For example:
+//  
+//    template = File.load('stylesheets/sassy.sass')
+//    sass_engine = Sass::Engine.new(template)
+//    output = sass_engine.render
+//    puts output
+SassijEngine = function( vars ){
+  
+  var dslString = vars;
+    // The character that begins a CSS attribute.
+  var attributeChar        = ':';     
+    // The character that designates that an attribute should be assigned to a SassScript,
+    // expression.
+  var scriptChar           = '=';
+    // The character that designates the beginning of a comment, either Sass or CSS.
+  var commentChar          = '/';
+    // The character that follows the general COMMENT_CHAR and designates a Sass comment,
+    // which is not output as a CSS comment.
+  var sassCommentChar     = '/';
+    // The character that follows the general COMMENT_CHAR and designates a CSS comment,
+    // which is embedded in the CSS document.
+  var cssCommentChar      = '*';
+    // The character used to denote a compiler directive.
+  var directiveChar        = '@';
+    // Designates a non-parsed rule.
+  var escapeChar           = '\\';
+    // Designates block as mixin definition rather than CSS rules to output
+  var mixinDefinitionChar = '=';
+    // Includes named mixin declared using MIXIN_DEFINITION_CHAR
+  var mixinIncludeChar    = '+';
+    // The regex that matches and extracts data from
+    // attributes of the form <tt>:name attr</tt>.
+  var attribute             = new RegExp( "^:([^\s=:]+)\s*(=?)(?:\s+|$)(.*)" );
+    // The regex that matches attributes of the form <tt>name: attr</tt>.
+  var attributeAlternateMatcher = new RegExp( "^[^\s:]+\s*[=:](\s|$)" );
+    // The regex that matches and extracts data from
+    // attributes of the form <tt>name: attr</tt>.
+  var attributeAltornate   = new RegExp( "^([^\s=:]+)(\s*=|:)(?:\s+|$)(.*)" );
+  
+  newOptions.style = 'nested';
+  newOptions.loadPaths = [ '.' ];
+  this.options = newOptions;
+  this.template = template;
+}
+
+SassijTreeNode.attr( 'environment', new SassijEnvironment() );
+SassijTreeNode.prototype.environment.important = new SassijScriptString( "!important" );
+
+SassijEngine.method( 'render', function(){
+  return 'test';
+});
+
+SassijEngine.method( 'toSassij', function(){
+  return dslString;
+});
+
+// We interpret the syntax as a tree, with each indentation representing a new leaf.
+SassijEngine.method( 'renderToTree', function(){ 
+  root = new SassijTreeNode();
+  root.appendChildren( tree( tabulate( this.toSassij() ) );
+  return root;
+});
+
+
+Sassij.prototype.engine = new SassijEngine();
+

lib/sassij/error.js

@@ -0,0 +1,4 @@
+SassijError = function( comment, lineNumber ){
+  return comment + ": " + lineNumber;
+} 
+ 

lib/sassij/tree/attr-node.js

@@ -0,0 +1,86 @@
+SassijTreeAttrNode = function( newName, newValue, newOptions ){
+  this.name = newName;
+  this.value = newValue;
+  this._super( newOptions );
+};
+
+SassijTreeAttrNode.inherits( SassijTreeNode );
+
+ = function( newOptions ){ 
+  
+  if( newOptions ){
+    this.options = newOptions;
+  } else {
+    this.options = { style: 'none' };
+  }
+  this.style = this.options.style;
+  this.children = [];
+
+  this.line = function(){
+  
+  }
+  this.filename = function(){
+  
+  }
+};
+
+module Sass::Tree
+  class AttrNode < Node
+    attr_accessor :name, :value
+    
+    def initialize(name, value, options)
+      @name = name
+      @value = value
+      super(options)
+    end
+    
+    def to_s(tabs, parent_name = nil)
+      if value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump} (This isn't CSS!).", @line)
+      end
+      real_name = name
+      real_name = "#{parent_name}-#{real_name}" if parent_name
+      
+      if value.empty? && children.empty?
+        raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump}.", @line)
+      end
+      
+      join_string = case @style
+                    when :compact; ' '
+                    when :compressed; ''
+                    else "\n"
+                    end
+      spaces = '  ' * (tabs - 1)
+      to_return = ''
+      if !value.empty?
+        to_return << "#{spaces}#{real_name}:#{@style == :compressed ? '' : ' '}#{value};#{join_string}"
+      end
+      
+      children.each do |kid|
+        to_return << "#{kid.to_s(tabs, real_name)}" << join_string
+      end
+      
+      (@style == :compressed && parent_name) ? to_return : to_return[0...-1]
+    end
+
+    protected
+    
+    def perform!(environment)
+      @name = interpolate(@name, environment)
+      @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
+      super
+    end
+
+    private
+
+    def declaration
+      ":#{name} #{value}"
+    end
+
+    def invalid_child?(child)
+      if !child.is_a?(AttrNode) && !child.is_a?(CommentNode)
+        "Illegal nesting: Only attributes may be nested beneath attributes."
+      end
+    end
+  end
+end

lib/sassij/tree/node.js

@@ -0,0 +1,148 @@
+SassijTreeNode = function( newOptions ){ 
+  
+  if( newOptions ){
+    this.options = newOptions;
+  } else {
+    this.options = { style: 'none' };
+  }
+  this.style = this.options.style;
+  this.line = function(){
+  
+  }
+  this.filename = function(){
+  
+  }
+};
+
+SassijTreeNode.attr( 'children', [] );
+
+SassijTreeNode.method( 'addChild', function( child ){
+  if( error = this.isInvalidChild( child ) ) {
+    throw( new SassijError( error, child.line ) );
+  }
+  this.children.push( child );
+  return this;
+});
+  
+SassijTreeNode.method( 'lastChild', function() {
+  return this.getChildren()[ this.getChildren().length - 1 ];
+});
+
+SassijTreeNode.method( 'toS', function() {
+  result = "";
+  for( child in this.getChildren() ){
+    if( child.isType( AttrNode ) ){
+      throw( new SassijError( 'Attributes aren\'t allowed at the root of a document.', child.line ) );
+    } else {
+      //    result << "#{child.to_s(1)}" + (@style == :compressed ? '' : "\n")
+      // need to add a @style indicator at some point
+      result += child.toS( 1 );
+    }
+  }
+      // @style == :compressed ? result+"\n" : result[0...-1]
+  return result;
+});
+  
+  // This method should be overridden by subclasses to return an error message
+  // if the given child node is invalid,
+  // and false or nil otherwise.
+SassijTreeNode.method( 'isInvalidChild', function( child ){
+  return false;
+});
+
+
+//      def perform(environment)
+//        _perform(environment)
+//      rescue Sass::SyntaxError => e
+//        e.sass_line ||= line
+//        raise e
+//      end
+// Casey says: I don't really know what this function pretends to do.
+// I think this is just a wrapper to catch errors on evaluating the node.
+SassijTreeNode.method( 'perform', function( environment ){
+  try{
+    _perform( environment );
+  } catch( error ) {
+    throw( new SassijError( error, 'unknown' ) );
+  }
+});
+
+//      def _perform(environment)
+//        node = dup
+//        node.perform!(environment)
+//        node
+//      end
+SassijTreeNode.method( '_perform', function( environment ){
+  node = this.clone();
+  node.performBang( environment );
+  return node;
+});
+
+//      def perform!(environment)
+//        self.children = perform_children(Environment.new(environment))
+//      end
+// This function actually evaluates the node, and then recurses to 
+// the children for evaluation with performChildren().
+SassijTreeNode.method( 'performBang', function( environment ){
+  this.setChildren( this.performChildren( new SassijEnvironment( environment ) ) );
+});
+
+
+//      def perform_children(environment)
+//        children.map {|c| c.perform(environment)}.flatten
+//      end
+// Casey says: js function for flatten()?  Not sure why that would ever be needed.
+SassijTreeNode.method( 'performChildren', function( environment ){
+  childrenMap = [];
+  for( child in this.getChildren() ){
+    childrenMap.push( child.perform( environment ) );
+  }
+  return childrenMap;
+});
+  
+//      def interpolate(text, environment)
+//        res = ''
+//        rest = Haml::Shared.handle_interpolation text do |scan|
+//          escapes = scan[2].size
+//          res << scan.matched[0...-2 - escapes]
+//          if escapes % 2 == 1
+//            res << "\\" * (escapes - 1) << '#{'
+//          else
+//            res << "\\" * [0, escapes - 1].max
+//            res << Script::Parser.new(scan, line, scan.pos - scan.matchedsize, filename).
+//              parse_interpolated.perform(environment).to_s
+//          end
+//        end
+//        res + rest
+//      end
+  // From what I can tell, this function handles the escapes for ruby-style inline
+  // string evaluation.  We'll come back to this.
+//  this.interpolate = function( text, environment ){
+//    res = "";
+//    scanner = new Shared.handle_interpolate( text );
+//    while( var scan = scanner.scan( /(.*?)(\\*)\#\{/ ) ){
+//      if escapes = 
+//      res += 
+//      
+//    }
+//    escapes = rest[2].length;
+//    res += rest.matched[]
+//    //something else goes here!!!!!
+
+//    // Append the rest of the original string.
+//    return res += scanner.getCurrent();
+//  }
+
+// CAN'T FIND THIS METHOD CALLED ANYWHERE
+//      def balance(*args)
+//        res = Haml::Shared.balance(*args)
+//        return res if res
+//        raise Sass::SyntaxError.new("Unbalanced brackets.", line)
+//      end
+//  this.balance( args ){
+//    if( res = HamlijShared.balance( args ) ){
+//      return res;
+//    };
+//    throw( new SassijError( 'Unbalanced brackets.', 'unknown' ) );
+//  }
+