mochiscript 0.4.0.pre1 → 0.4.0.pre10

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mochiscript.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/mochiscript.rb

@@ -2,7 +2,7 @@ require 'v8'
 require 'json'
 
 module Mochiscript
-  VERSION = "0.4.0-pre1".sub("-", '.')
+  VERSION = "0.4.0-pre10".sub("-", '.')
   class Context
     def initialize
       @ctx = V8::Context.new 
@@ -238,16 +238,17 @@ var JS2 = $m;
   return $m;
 })(undefined, $m);
 
+
   var IDENT  = "[\\$\\w]+";
 var TOKENS = [
   [ "SPACE", "\\s+"  ],
 
+  [ "STATIC",   "static\\b" ], 
   [ "MODULE",   "module\\b", 'ModuleParser' ], 
   [ "CLASS",    "class\\b",  'ClassParser' ], 
   [ "FUNCTION", "function\\b" ], 
   [ "INCLUDE",  "include\\b" ], 
   [ "VAR",      "var\\b" ], 
-  [ "STATIC",   "static\\b" ], 
   [ "PRIVATE",  "private\\b" ], 
   [ "EXTENDS",  "extends\\b" ], 
   [ "FOREACH",  "foreach\\b", 'ForeachParser' ], 
@@ -264,6 +265,7 @@ var TOKENS = [
   [ "EQUALS",    "=" ],
 
   [ "COMMENT", "\\/\\/|\\/\\*", "CommentParser" ], 
+  [ "REGEX", "/", 'RegexParser' ], 
 
   [ "LBRACE", "\\(" ],
   [ "RBRACE", "\\)" ],
@@ -296,6 +298,7 @@ JS2.Class.extend('Tokens', function(KLASS, OO){
     this.orig     = str;
     this.str      = str;
     this.iterator = 0;
+    this.consumed = 0;
   });
 
   OO.addMember("peek",function () {
@@ -320,8 +323,26 @@ JS2.Class.extend('Tokens', function(KLASS, OO){
   OO.addMember("consume",function (n) {
     this.str   = this.str.substr(n, this.str.length-n);
     this._peek = null;
+    this.consumed += n;
+  });
+
+  OO.addMember("length",function () {
+    return this.str.length;
+  });
+
+  OO.addMember("lookback",function (n) {
+    var starting = this.consumed;
+    while (this.orig.charAt(starting).match(/\s/)) starting--;
+    return this.orig.substr(starting-1-n, n);
+  });
+
+  OO.addMember("lookahead",function (n) {
+    var starting = this.consumed;
+    while (this.orig.charAt(starting).match(/\s/)) starting++;
+    return this.orig.substr(starting, n);
   });
 
+
   OO.addMember("any",function () {
     return this.str.length > 0;
   });
@@ -332,6 +353,7 @@ JS2.Class.extend('Tokens', function(KLASS, OO){
 });
 var Tokens = $c.Tokens;
 
+
 $m.parse = function (str) {
   var parser = new $c.RootParser();
   parser.parse(new $c.Tokens(str));
@@ -347,31 +369,44 @@ JS2.Class.extend('RootParser', function(KLASS, OO){
   });
 
   OO.addMember("parse",function (tokens) {
-    this.startParse(tokens);
+    var len = tokens.length();
+    if (this.startParse(tokens) === false || this.parseTokens(tokens) === false || this.endParse(tokens) === false) return false 
+    return len != tokens.length();
+  });
+
+  OO.addMember("parseTokens",function (tokens) {
+    var sanity  = 100;
+    var origLen = tokens.length();
 
-    var sanity = 100;
     while (tokens.any()) {
-      var origLen = tokens.length;
-      var token = tokens.peek();
+      var token   = tokens.peek();
       if (!token) break;
+
+      // has a parser class associated with this token
       var handlerClass = this.getHandler(token) || token[2];
       if (handlerClass) {
         var handler = new $c[handlerClass];
-        handler.parse(tokens);
-        this.out.push(handler); 
-      } else {
+        if (handler.parse(tokens) !== false) {
+          this.out.push(handler); 
+          tokens.lastHandler = handler;
+        } else {
+          this.handleToken(token, tokens);
+        }
+      } 
+      
+      // no parser class, use "this" to just consume it
+      else {
         this.handleToken(token, tokens);
       }
+
       if (this.finished) break;
 
-      if (origLen == tokens.length && sanity-- == 0) {
+      if (origLen == tokens.length() && sanity-- == 0) {
         throw "parse error";
       } else {
         sanity = 100;
       }
     }
-
-    this.endParse(tokens);
   });
 
   OO.addMember("startParse",function () { });
@@ -390,6 +425,7 @@ JS2.Class.extend('RootParser', function(KLASS, OO){
     return ret.join("");
   });
 
+  // intercepts parser class for special cases
   OO.addMember("getHandler",function (token) {
     return null;
   });
@@ -430,7 +466,8 @@ RootParser.extend('ModuleParser', function(KLASS, OO){
 
   OO.addMember("parse",function (tokens) {
     var m = tokens.match(REGEX);
-    var name      = m[2];
+    if (!m) return false;
+    var name = m[2];
     tokens.consume(m[0].length-1);
 
     var content = new $c.ClassContentParser();
@@ -471,10 +508,11 @@ var CurlyParser = $c.CurlyParser;
 CurlyParser.extend('ClassContentParser', function(KLASS, OO){
   OO.addMember("getHandler",function (token) {
     switch(token[0]) {
-      case TYPES.VAR: return "MemberParser";
+      case TYPES.STATIC:   return "StaticParser";
+      case TYPES.VAR:      return "MemberParser";
       case TYPES.FUNCTION: return "MethodParser";
-      case TYPES.PRIVATE: return "PrivateParser";
-      case TYPES.INCLUDE: return "IncludeParser";
+      case TYPES.PRIVATE:  return "PrivateParser";
+      case TYPES.INCLUDE:  return "IncludeParser";
     }
   });
 
@@ -547,6 +585,35 @@ RootParser.extend('IStringParser', function(KLASS, OO){
   });
 });
 
+RootParser.extend('StaticParser', function(KLASS, OO){
+  // private closure
+
+    var VAR_REGEX = Tokens.regex("(<STATIC>(\\s+))<VAR>");
+    var FUNCT_REGEX = Tokens.regex("(<STATIC>(\\s+))<FUNCTION>");
+  
+
+  OO.addMember("parseTokens",function (tokens) {
+    var varMatch = tokens.match(VAR_REGEX);
+    if (varMatch) {
+      tokens.consume(varMatch[1].length);
+      var parser = new MemberParser();
+      parser.isStatic = true;
+      parser.parse(tokens);
+      this.out.push(parser);
+    } 
+    
+    else {
+      var functMatch = tokens.match(FUNCT_REGEX);
+      tokens.consume(functMatch[1].length);
+
+      var parser = new MethodParser();
+      parser.isStatic = true;
+      parser.parse(tokens);
+      this.out.push(parser);
+    }
+  });
+});
+
 RootParser.extend('MemberParser', function(KLASS, OO){
   // private closure
 
@@ -561,11 +628,14 @@ RootParser.extend('MemberParser', function(KLASS, OO){
     var parser = new $c.LineParser();
     parser.parse(tokens);
     parser.chop();
+    var addMethod = this.isStatic ? 'addStaticMember' : 'addMember';
 
-    this.out = [ "OO.addMember(", JSON.stringify(this.name), ",",  parser, ");" ];
+    this.out = [ "OO." + addMethod + "(", JSON.stringify(this.name), ",",  parser, ");" ];
   });
 });
 
+
+
 RootParser.extend('IncludeParser', function(KLASS, OO){
   // private closure
 
@@ -615,13 +685,16 @@ RootParser.extend('MethodParser', function(KLASS, OO){
   OO.addMember("parse",function (tokens) {
     var m = tokens.str.match(REGEX);
     tokens.consume(m[0].length);
-    this.name = m[2];
-    this.args = m[3];
-    this.body = new CurlyParser();
-    this.body.foo = true;
-    this.body.parse(tokens);
+    var name = m[2];
+    var args = m[3];
+
+    var body = new CurlyParser();
+    body.parse(tokens);
+
+    var addMethod = this.isStatic ? 'addStaticMember' : 'addMember';
+    
 
-    this.out = [ 'OO.addMember(', JSON.stringify(this.name), ', function', this.args, this.body, ');' ];
+    this.out = [ 'OO.' + addMethod + '(', JSON.stringify(name), ', function', args, body, ');' ];
   });
 });
 
@@ -660,13 +733,42 @@ RootParser.extend('CommentParser', function(KLASS, OO){
       return;
     }
 
-    var m2 = tokens.match(/^\/\*.*?\*\//);
+    var m2 = tokens.match(/^\/\*[\s\S]*?\*\//);
     if (m2) {
       tokens.consume(m2[0].length);
       this.out = [ m2[0] ];
       return;
+    } 
+
+    return false;
+  });
+});
+
+RootParser.extend('RegexParser', function(KLASS, OO){
+  // private closure
+
+    var REGEX  = /^\/(\\.|[^\/])+\/[imgy]{0,4}/;
+    var DIVIDE = /(\}|\)|\+\+|\-\-|[\w\$])$/;
+  
+
+  OO.addMember("parseTokens",function (tokens) {
+    var back = tokens.lookback(2);
+    if (back.match(DIVIDE)) {
+      tokens.consume(1);
+      this.out.push("/"); 
+    } 
+    
+    else {
+      var m = tokens.match(REGEX);
+      if (m) {
+        this.out.push(m[0]);
+        tokens.consume(m[0].length);
+      } else {
+        return false;
+      }
     }
   });
+
 });
 
 CurlyParser.extend('ForeachParser', function(KLASS, OO){
@@ -685,7 +787,7 @@ CurlyParser.extend('ForeachParser', function(KLASS, OO){
 
     // TODO ugly, revisit this later
     tokens.consume(m[0].length-1);
-    var declare = [ this.iterator + "=0", this.item + "=null", "_list_" + namespace + "=" + this.list, "_len_" + namespace + "=_list_.length" ].join(',');
+    var declare = [ this.iterator + "=0", this.item + "=null", "_list_" + namespace + "=" + this.list, "_len_" + namespace + "=_list_" + namespace + ".length" ].join(',');
 
     var bool = "(" + this.item + "=" + "_list_" + namespace + "[" + this.iterator + "])||" + this.iterator + "<_len_" + namespace;
 
@@ -698,6 +800,254 @@ CurlyParser.extend('ForeachParser', function(KLASS, OO){
  
 });
 
+
+JS2.Class.extend('JSML', function(KLASS, OO){
+  OO.addStaticMember("process",function (txt) {
+    return new KLASS(txt);
+  });
+
+  OO.addMember("initialize",function (txt) {
+    var lines = txt.split(/\n/);
+    this.root    = new JS2.JSMLElement();
+    this.stack   = [ this.root ];
+
+    for(var _i1=0,_c1=lines,_l1=_c1.length,l;(l=_c1[_i1])||(_i1<_l1);_i1++){
+      if (l.match(/^\s*$/)) continue;
+      this.processLine(l);
+    }
+
+    var toEval = 'function process() { var out = [];\n' + this.flatten().join('') + '\n return out.join("");\n}';
+    eval(toEval);
+
+    this.result = function(bound) {
+      bound = bound || {};
+      return process.call(bound);
+    };
+  });
+
+  OO.addMember("flatten",function () {
+    return this.root.flatten();
+  });
+
+  OO.addMember("processLine",function (line) {
+    if (line.match(/^\s*$/)) return;
+
+    var ele   = new JS2.JSMLElement(line);
+    var scope = this.getScope();
+
+    if (ele.scope == scope) {
+      this.stack.pop();
+      this.getLast().push(ele);
+      this.stack.push(ele);
+    } else if (ele.scope > scope) {
+      this.getLast().push(ele); 
+      this.stack.push(ele);
+    } else if (ele.scope < scope) {
+      var diff = scope - ele.scope + 1;
+      while(diff-- > 0) {
+        this.stack.pop();
+      }
+      this.getLast().push(ele);
+      this.stack.push(ele);
+    }
+  });
+
+
+  OO.addMember("getScope",function () {
+    return this.stack.length - 1;
+  });
+
+  OO.addMember("getLast",function () {
+    return this.stack[this.stack.length-1];
+  });
+
+});
+
+JS2.Class.extend('JSMLElement', function(KLASS, OO){
+  OO.addMember("SCOPE_REGEX",/^(\s*)(.*)$/);
+  OO.addMember("SPLIT_REGEX",/^((?:\.|\#|\%)[^=\s\{]*)?(\{.*\})?(=|-)?(?:\s*)(.*)$/);
+  OO.addMember("TOKEN_REGEX",/(\%|\#|\.)([\w][\w\-]*)/g);
+  OO.addMember("JS_REGEX",/^(-|=)(.*)$/g);
+  OO.addMember("SCOPE_OFFSET",1);
+  OO.addMember("SELF_CLOSING",{ area: null, basefont: null, br: null, hr: null, input: null, img: null, link: null, meta: null });
+
+  OO.addMember("initialize",function (line) {
+    this.children = [];
+
+    if (line == null) {
+      this.scope = this.SCOPE_OFFSET;
+      return;
+    }
+
+    var spaceMatch = line.match(this.SCOPE_REGEX);
+    this.scope = spaceMatch[1].length / 2 + this.SCOPE_OFFSET;
+
+    this.classes  = [];
+    this.nodeID   = null;
+
+    this.parse(spaceMatch[2]);
+  });
+
+  OO.addMember("push",function (child) {
+    this.children.push(child);
+  });
+
+  OO.addMember("parse",function (line) {
+    this.attributes;
+    this.line = line;
+    var self = this;
+
+    var splitted = line.match(this.SPLIT_REGEX);
+    var tokens   = splitted[1];
+    var attrs    = splitted[2];
+    var jsType   = splitted[3];
+    var content  = splitted[4];
+
+    if (tokens) {
+      tokens.replace(this.TOKEN_REGEX, function(match, type, name){ 
+        switch(type) {
+          case '%': self.nodeType = name; break;
+          case '.': self.classes.push(name); break;
+          case '#': self.nodeID = name; break;
+        } 
+        return '';
+      });
+    }
+
+    if (jsType == '=') {
+      this.jsEQ = content;
+    } else if (jsType == '-') {
+      this.jsExec = content;
+    } else {
+      this.content = content;
+    }
+
+    if (attrs) {
+      this.attributes = attrs;
+    }
+
+    if (!this.nodeType && (this.classes.length || this.nodeID)) {
+      this.nodeType = 'div';
+    }
+
+    if (this.SELF_CLOSING.hasOwnProperty(this.nodeType) && this.children.length == 0) {
+      this.selfClose = '/';
+    } else {
+      this.selfClose = '';
+    }
+  });
+
+  OO.addMember("flatten",function () {
+    var out = [];
+   
+    for(var _i1=0,_c1=this.children,_l1=_c1.length,c;(c=_c1[_i1])||(_i1<_l1);_i1++){
+      var arr = c.flatten();
+      for(var _i2=0,_c2=arr,_l2=_c2.length,item;(item=_c2[_i2])||(_i2<_l2);_i2++){
+        out.push(item);
+      }
+    }
+
+    if (this.nodeType) {
+      this.handleJsEQ(out);
+      this.handleContent(out);
+      out.unshift('out.push("<' + this.nodeType + '"+JS2.JSMLElement.parseAttributes(' + (this.attributes || "{}") + ', ' + JSON.stringify(this.classes || []) + ', ' + JSON.stringify(this.id || null) + ')+"' + this.selfClose + '>");\n');
+      if (this.selfClose == '') {
+        out.push('out.push(' + JSON.stringify("</"+(this.nodeType)+">") + ');\n');
+      }
+    } else {
+      this.handleJsExec(out);
+      this.handleJsEQ(out);
+      this.handleContent(out);
+    }
+
+    return out;
+  });
+
+  OO.addMember("handleJsEQ",function (out) {
+    if (this.jsEQ) {
+      this.jsEQ = this.jsEQ.replace(/;\s*$/, '');
+      out.unshift('out.push(' + this.jsEQ + ');\n');
+    }
+  });
+
+  OO.addMember("handleContent",function (out) {
+    if (this.content != null && this.content.length > 0) {
+      out.unshift('out.push(' + JSON.stringify(this.content) + ');\n');
+    }
+  });
+
+
+  OO.addMember("handleJsExec",function (out) {
+    if (this.jsExec) {
+      out.unshift(this.jsExec);
+      if (this.jsExec.match(/\{\s*$/)) {
+        out.push("}\n");
+      }
+    }
+  });
+
+  OO.addStaticMember("parseAttributes",function (hash, classes, id) {
+    var out = [];
+    classes = classes || [];
+    if (hash['class']) classes.push(hash['class']);
+    if (classes.length) hash['class'] = classes.join(" ");
+
+    for (var k in hash) {
+      if (hash.hasOwnProperty(k)) {
+        out.push(k + '=' + JSON.stringify(hash[k]));
+      }
+    }
+    return (out.length ? ' ' : '') + out.join(' ');
+  });
+});
+
+
+JS2.Class.extend('CLI', function(KLASS, OO){
+  // private closure
+
+    var COMMANDS = {
+      help:    'help',
+      render:  'render',
+      compile: 'compile',
+      watch:   'watch'
+    };
+  
+
+  OO.addMember("run",function (args) {
+    var opts = this.parseOpts(args);
+    var options = opts[0];
+    var command = opts[1];
+    var files   = opts[2];
+  });
+
+  OO.addMember("parseOpts",function (args) {
+    var files   = [];
+    var options = {};
+    var command = null;
+
+    var endedArgs = false;
+
+    for(var i=0,_c1=args,_l1=_c1.length,arg;(arg=_c1[i])||(i<_l1);i++){
+      if (endedArgs) {
+        files.push(arg);
+      }
+      
+      else if (COMMANDS[arg]) {
+        command   = arg;
+        endedArgs = true;
+      }
+
+      else {
+        var setting = arg.match(/^(\w+)(?:=(.*))?$/);
+        if (setting) options[setting[0]] = setting[1] || 'true';
+      }
+    }
+
+    return [ options, command, files ];
+  });
+});
+
+
 })();
 FINISH
   end

data/mochiscript/lib/mochiscript.rb

@@ -0,0 +1,5 @@
+require "mochiscript/version"
+
+module Mochiscript
+  # Your code goes here...
+end

data/mochiscript.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "./lib/mochiscript"
+
+Gem::Specification.new do |s|
+  s.name        = "mochiscript"
+  s.version     = Mochiscript::VERSION
+  s.authors     = ["Jeff Su"]
+  s.email       = ["me@jeffsu.com"]
+  s.homepage    = ""
+  s.summary     = %q{Javascript Dessert}
+  s.description = %q{Javascript Dessert}
+
+  s.rubyforge_project = "mochiscript"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -1,57 +1,51 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: mochiscript
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.4.0.pre10
   prerelease: 6
-  version: 0.4.0.pre1
 platform: ruby
-authors: 
+authors:
 - Jeff Su
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-25 00:00:00 -07:00
-default_executable: 
+date: 2011-10-30 00:00:00.000000000Z
 dependencies: []
-
 description: Javascript Dessert
-email: 
+email:
 - me@jeffsu.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- .gitignore
+- Gemfile
+- Rakefile
 - lib/mochiscript.rb
-has_rdoc: true
-homepage: ""
+- mochiscript.gemspec
+- mochiscript/lib/mochiscript.rb
+homepage: ''
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-
 rubyforge_project: mochiscript
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Javascript Dessert
 test_files: []
-