liquidscript 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8099fbffde0b4c86f743c1eeb2f7945876bda79
-  data.tar.gz: 61440eea14db6d81cff6245c03916e58092f310e
+  metadata.gz: 2630a75e954ba63bc5da7e92040fc2fce164236b
+  data.tar.gz: 92fca33ae8fec68d082e16ba4431f873c8b251c0
 SHA512:
-  metadata.gz: d58710b0697834bfa1501061adc3d9d0492206d71c24d8886a769e451dadff2e41bdcc527d8629fb4522ff92cb2a9e423ee96eb1559d7fc5370c04a3bbfd3262
-  data.tar.gz: 9552101c9846bde2f34eebedcf1e4dcd1fa4da268c3e563331e2872ad0d9d5d21ea82296c79044265cdc0f01023fb3333542c99ed52d312cb30e9b40fed3afa9
+  metadata.gz: 207d7676f032a4a00237f49c99d5feacb351ff7462b6354e240ce27e32d10f0eba5f787b116b2a91eed5893fe77d2f0754c8922dfda2867050ec7695cfa380ad
+  data.tar.gz: 29c50870b4ed865a79ab1939b38b568353f65746ca9f3e73a6f1a01880d47f80463d1ba0e5706c9529aa56b1392d56efc19f2164db7b94b5ddecd1e4fa2469f6

data/DOCS.md

@@ -0,0 +1,228 @@
+# ![Liquidscript](http://i.imgur.com/xbdhTsr.png)
+
+**A javascript-based language that compiles to javascript.**  It compiles directly to javascript, requiring no runtime libraries.  It means to take away the awkwardness of javascript, but keep the very essence and ideals of javascript.  It incorporates some of the most well-used concepts, and allows you to write the code as you like.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'liquidscript'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install liquidscript
+
+## Syntax
+
+Liquidscript has a very similar syntax to Javascript.
+
+	# This is a comment
+	something = 2
+    some_string = something.toString()
+    
+    if(some_string == '2) {
+      console.log("It lives!")
+    }
+    
+The thing that should stand out to you the most there is the lack of an end quote to the single quotes in the if conditional.  This is on purpose - a ending single quote is optional.
+
+Note that there are also no semicolons (they don't exist in the language), and no `var` statement.  The `var` statement is made automagically by liquidscript, so you don't have to.
+
+### Literals
+
+#### String
+
+Liquidscript has a very finite set of string literals - the only two options (so far) are double quotes and single quotes.  There are plans to introduce heredocs.  Double quotes are multiline, whereas **single quotes are limited to the same characters that identifiers are limited to**.  This is so that keys for objects (in the `object[key]` syntax feels more natural (i.e., `object['key]`).  Some examples:
+
+	string = "hello
+    
+    world" # this'll translate to "hello\n\nworld"
+    
+    single = 'test # there doesn't need to be an endquote here.
+    
+That's it!
+
+#### Functions
+
+Functions are defined using the arrow syntax:
+
+	some_function = -> {}
+    
+Brackets are **not** optional.  The parameter list before the arrow, however, is.  If you want something like coffeescript's fat arrow syntax, something like the following would have to be done:
+
+	self = this
+    
+    some_function = -> {
+    	# Change this to whatever property you wanted.
+    	self.whatever
+    }
+    
+A parameter list works exactly like you'd expect:
+
+	some_function = (a, b, c)-> {
+    	console.log(a, b, c)
+    }
+    
+    some_function(1, 2, 3)
+
+#### Numeric
+
+There are numbers in liquidscript as well.  It follows the JSON spec on this to the letter.
+
+	some_number = -2e+5
+
+#### Array, Object
+
+Arrays and objects are exactly like in javascript:
+
+	array = [1, "test", 'foo, bar]
+    
+    object = {
+    	test: "hello",
+        foo: "world" # a colon here is allowed
+    }
+    
+### Controls
+
+Liquidscript has control statements like `if`, and `else`.  Liquidscript uses `elsif` instead of `else if`.
+    
+    if(some_variable == 2) {
+    	console.log("It's 2!")
+    } elsif(some_variable == 3) {
+    	console.log("It's a 3!")
+    } else {
+    	console.log("I don't know what it is!")
+    }
+
+Liquidscript lacks `for`, `switch`, and `while`, but they will be added as well.
+
+### Classes and Modules
+
+#### Modules
+This is where liquidscript gets interesting, in my opinion.  Modules are extreme syntaxic sugar:
+
+	module SomeModule {
+    	VERSION: "1.7.0"
+    }
+    
+    SomeModule.VERSION # => 1.7.0
+    
+That compiles directly to:
+
+	var SomeModule;
+    SomeModule = {
+    	VERSION: "1.7.0"
+    };
+    
+    SomeModule.VERSION; // => 1.7.0
+    
+The point of modules, however, is to bind code together into units, in an easier to read syntax.  Commas are not needed between definitions, and other modules and classes can be defined within modules.
+
+	module SomeModule {
+    	module OtherModule {
+        	VERSION: "1.7.0"
+            VERSION_MAJOR: 1
+            VERSION_MINOR: 7
+            VERSION_PATCH: 0
+            
+            version: -> {
+            	return SomeModule.OtherModule.VERSION.split('.')
+            }
+        }
+    }
+    
+Which compiles directly to:
+
+	var SomeModule, OtherModule;
+    
+    SomeModule = {
+    	OtherModule: {
+        	VERSION: "1.7.0",
+            VERSION_MAJOR: 1,
+            VERSION_MINOR: 7,
+            VERSION_PATCH: 0,
+            version: function() {
+            	return SomeModule.OtherModule.VERSION.split('.');
+            }
+        }
+    };
+    
+#### Classes
+
+Classes are meant to be instantized with the `new` keyword.  They are defined very similarly to modules, but when values are defined, they default to being defined on the instance of the class:
+
+	class Greeter {
+    	# This is a special function that is called whenever a 
+        # new greeter is created.
+    	initialize: (name)-> {
+        	this.name = name
+        }
+        
+        greet: -> {
+        	console.log("Hello %s!", this.name)
+        }
+    }
+    
+    new Greeter("Alice").greet()
+    
+This would translate directly to this:
+
+	var Greeter;
+    
+    Greeter = function Greeter() {
+    	if(this.initialize) {
+        	this.initialize.apply(this, arguments);
+        }
+    };
+    
+    Greeter.prototype.initialize = function(name) {
+    	this.name = name;
+    };
+    
+    Greeter.prototype.greet = function() {
+    	console.log("Hello %s!", this.name);
+    };
+    
+    new Greeter("Alice").greet()
+    
+This uses the functional prototype system in order to create instances of classes.  Inheritance is not yet supported, but there will be progress towards it.
+
+If you want a method defined on the class itself instead of the instance, prefix the function name with `this`:
+
+	class Greeter {
+    	# This is a special function that is called whenever a 
+        # new greeter is created.
+    	initialize: (name)-> {
+        	this.name = name
+        }
+        
+        greet: -> {
+        	console.log("Hello %s!", this.name)
+        }
+        
+        self.meet: (first, second)-> {
+        	new Greeter(first).greet()
+            new Greeter(second).greet()
+        }
+    }
+    
+   	Greeter.meet("Alice", "Bob")
+    
+This translates roughly to:
+
+	// ...
+    
+    Greeter.meet = function(first, second) {
+    	new Greeter(first).greet()
+        new Greeter(second).greet()
+    }
+    
+    // ...
+    
+# The End!
+
+That wraps it all up!  If you're interested in more, checkout the [github repository](https://github.com/redjazz96/liquidscript) and read the documentation.

data/README.md

@@ -1,4 +1,4 @@
-# Liquidscript
+# ![Liquidscript](http://i.imgur.com/xbdhTsr.png)
 
 [![Build Status](https://travis-ci.org/redjazz96/liquidscript.png?branch=master)](https://travis-ci.org/redjazz96/liquidscript) [![Coverage Status](https://coveralls.io/repos/redjazz96/liquidscript/badge.png?branch=master)](https://coveralls.io/r/redjazz96/liquidscript?branch=master) [![Code Climate](https://codeclimate.com/github/redjazz96/liquidscript.png)](https://codeclimate.com/github/redjazz96/liquidscript)
 

data/bin/lscript

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "liquidscript"
+
+if ARGV.length < 1
+  puts "Usage: #{File.basename($0)} infile [outfile]"
+  exit 1
+end
+
+infile = ARGV.shift
+outfile = ARGV.shift || infile.gsub(/\.ls\Z/, ".js")
+
+File.open(infile, "r") do |f|
+  out = Liquidscript::Template.new(f.read).render
+
+  File.open(outfile, "w") { |f| f.write out }
+end

data/lib/liquidscript.rb

@@ -5,7 +5,12 @@ require "liquidscript/version"
 require "liquidscript/scanner"
 require "liquidscript/compiler"
 require "liquidscript/generator"
+require "liquidscript/template"
 
 module Liquidscript
-  # Your code goes here...
+  def compile(data)
+    compiler = Compiler::ICR.new(Scanner.new(data))
+    compiler.compile
+    Generate::Javascript.new(compiler.top)
+  end
 end

data/lib/liquidscript/compiler/base/helpers.rb

@@ -83,6 +83,75 @@ module Liquidscript
           types.any? { |type| peek.type == type }
         end
 
+        # @overload collect_compiles(compile, *end_on)
+        #   Calls the method `:compile_#{compile}` for every peeked
+        #   token that isn't a part of `end_on`.  Once it encounters
+        #   that, it returns the values of all of those calls.  If the
+        #   last element of `end_on` is a Hash, it is merged with the
+        #   default actions that this takes and passes it to `expect`.
+        #
+        #   @example
+        #     def compile_if
+        #       shift :if
+        #       shift :lparen
+        #       conditional = compile_expression
+        #       shift :rparen
+        #       shift :lbrack
+        #       body = collect_compiles(:expression, :rbrack)
+        #       [:if, conditional, body]
+        #     end
+        #   @param compile [Symbol] the method to call.
+        #   @param end_on [Array<Symbol>] an array of symbols to end
+        #     the loop.
+        #   @return [Array<Object>]
+        #
+        # @overload collect_compiles(*end_on, &block)
+        #    Calls the block for every peeked token that isn't in
+        #    `end_on`.  Once it encounters a token that it, it returns
+        #    the value of all of the block calls. If the
+        #   last element of `end_on` is a Hash, it is merged with the
+        #   default actions that this takes and passes it to `expect`.
+        #
+        #    @example
+        #      collect_compiles(:test) { shift :_ }
+        #
+        #    @yieldreturn The value you want to be placed in the
+        #      array.
+        #    @param end_on [Array<Symbol>] an array of symbols to end
+        #      the loop.
+        #    @return [Array<Object>] the results of all of the block
+        #      calls.
+        def collect_compiles(*end_on)
+          compiles = []
+
+          if block_given?
+            compile = Proc.new
+          else
+            compile = end_on.shift
+          end
+
+          block = Callable.new(self, compile)
+
+          hash = if end_on.last.is_a? Hash
+            end_on.pop.dup
+          else
+            {}
+          end
+
+          do_compile = action do
+            compiles << block.call
+          end
+
+          hash.merge! end_on => action.end_loop,
+                      :_     => do_compile
+
+          loop do
+            expect hash
+          end
+
+          compiles
+        end
+
         # The meat and potatos of the compiler.  This maps actions to
         # tokens.  In its basic form, it is passed a hash, with the
         # keys being token types, and the values the corresponding
@@ -176,7 +245,7 @@ module Liquidscript
         # @return [Hash]
         def normalize_arguments(args)
           hash = if args.last.is_a? Hash
-            args.pop
+            args.pop.dup
           else
             {}
           end

data/lib/liquidscript/compiler/icr.rb

@@ -14,8 +14,6 @@ module Liquidscript
       include Classes
       include Helpers
 
-      always :keyword
-
       # (see Base#reset!)
       def reset!
         @top         = Liquidscript::ICR::Set.new
@@ -33,7 +31,7 @@ module Liquidscript
       #
       # @return [ICR::Code]
       def compile_start
-        expect :class, :module, :_ => :expression
+        compile_expression
       end
     end
   end

data/lib/liquidscript/compiler/icr/classes.rb

@@ -29,7 +29,7 @@ module Liquidscript
           compile_object = action do
             components << [
               _compile_class_body_key(mod),
-              compile_expression
+              compile_vexpression
             ]
           end
 

data/lib/liquidscript/compiler/icr/expressions.rb

@@ -8,12 +8,36 @@ module Liquidscript
         #
         # @return [ICR::Code]
         def compile_expression
-          expect :number,     :identifier,
-                 :dstring,    :lparen,
-                 :sstring,    :keyword,
-                 :lbrack   => :object,
-                 :lbrace   => :array,
-                 :arrow    => :function
+          expect :if, :unless, :class, :module, :_ => :vexpression
+        end
+
+        # Compiles an expression that returns a value.
+        #
+        # @return [ICR::Code]
+        def compile_vexpression
+          out = expect :number,     :identifier,
+                       :dstring,    :lparen,
+                       :sstring,    :operator,
+                       :keyword,    :unop,
+                       :lbrack   => :object,
+                       :lbrace   => :array,
+                       :arrow    => :function
+
+          if peek? :binop
+            compile_binop out
+          elsif peek? :prop
+            compile_property(out)
+          else
+            out
+          end
+        end
+
+        def compile_binop(left)
+          code :binop, shift(:binop), left, compile_vexpression
+        end
+
+        def compile_unop
+          code :unop, shift(:unop), compile_vexpression
         end
 
         # Handles an assignment of the form `identifier = expression`,
@@ -23,7 +47,7 @@ module Liquidscript
         # @return [ICR::Code]
         def compile_assignment(identifier)
           shift :equal
-          value    = compile_expression
+          value    = compile_vexpression
 
           if identifier.type == :identifier
             variable = set(identifier)
@@ -52,7 +76,7 @@ module Liquidscript
 
           expression = action do
             maybe_func = 0
-            components << compile_expression
+            components << compile_vexpression
           end
 
           loop do
@@ -88,6 +112,44 @@ module Liquidscript
           end
         end
 
+        [:if, :elsif].each do |key|
+          define_method(:"compile_#{key}") do
+            shift key
+            shift :lparen
+            conditional = compile_vexpression
+            shift :rparen
+            shift :lbrack
+
+            body = collect_compiles(:expression, :rbrack)
+
+            if peek?(:elsif, :else)
+              code key, conditional, body, expect(:elsif, :else)
+            else
+              code key, conditional, body
+            end
+          end
+        end
+
+        def compile_unless
+          shift :unless
+          shift :lparen
+          conditional = compile_vexpression
+          shift :rparen
+          shift :lbrack
+
+          body = collect_compiles(:expression, :rbrack)
+          code :unless, conditional, body
+        end
+
+        def compile_else
+          shift :else
+          shift :lbrack
+
+          body = collect_compiles(:expression, :rbrack)
+
+          code :else, body
+        end
+
       end
     end
   end

data/lib/liquidscript/compiler/icr/functions.rb

@@ -6,7 +6,7 @@ module Liquidscript
         def compile_property(prop)
           shift :prop
 
-          ref = if prop.type == :identifier
+          ref = if [:identifier, :class, :module].include?(prop.type)
             ref(prop)
           else
             prop
@@ -16,7 +16,8 @@ module Liquidscript
             code :property, ref, ident
           end
 
-          code = expect :identifier => property
+          # Just in case there is a property named 'class' or 'module'
+          code = expect [:identifier, :class, :module] => property
 
           expect :lparen => action { compile_call(code)       },
                  :equal  => action { compile_assignment(code) },
@@ -26,13 +27,9 @@ module Liquidscript
 
         def compile_call(subject)
           shift :lparen
-          arguments = []
 
-          loop do
-            expect :comma  => action.shift,
-                   :rparen => action.end_loop,
-                   :_      => action { arguments << compile_expression }
-          end
+          arguments = collect_compiles :expression, :rparen,
+            :comma => action.shift
 
           code :call, subject, *arguments
         end

data/lib/liquidscript/compiler/icr/literals.rb

@@ -26,22 +26,20 @@ module Liquidscript
           code :sstring, pop.value[1..-1]
         end
 
+        def compile_operator
+          code :operator, shift(:operator), compile_vexpression
+        end
+
         def compile_keyword
-          code :keyword, shift(:keyword), compile_expression
+          code :keyword, shift(:keyword)
         end
 
         def compile_object
           shift :lbrack
 
-          objects = []
-          compile_object = action do
-            objects << [compile_object_key, compile_expression]
-          end
-
-          loop do
-            expect :rbrack => action.end_loop,
-            :comma         => action.shift,
-            [:identifier, :dstring] => compile_object
+          objects = collect_compiles :rbrack,
+            :comma => action.shift do
+            [compile_object_key, compile_vexpression]
           end
 
           code :object, objects
@@ -50,14 +48,8 @@ module Liquidscript
         def compile_array
           shift :lbrace
 
-          parts = []
-          compile_part = action { parts << compile_expression }
-
-          loop do
-            expect :rbrace => action.end_loop,
-            :comma         => action.shift,
-            :_             => compile_part
-          end
+          parts = collect_compiles(:vexpression, :rbrace,
+            :comma => action.shift)
 
           code :array, parts
         end
@@ -73,17 +65,17 @@ module Liquidscript
           compile_function_with_parameters([])
         end
 
-        def compile_function_with_parameters(parameter)
+        def compile_function_with_parameters(parameters)
           shift :arrow
           shift :lbrack
 
           expressions = Liquidscript::ICR::Set.new
           expressions.context = Liquidscript::ICR::Context.new
           expressions.context.parent = top.context
-          expressions[:arguments] = parameter
+          expressions[:arguments] = parameters
           @set << expressions
 
-          parameter.each do |parameter|
+          parameters.each do |parameter|
             set(parameter).parameter!
           end
 

data/lib/liquidscript/generator/javascript/literals.rb

@@ -3,6 +3,15 @@ module Liquidscript
     class Javascript < Base
       module Literals
 
+        BINOP_SWITCH = {
+          "==" => "===",
+          "===" => "==",
+          "!=" => "!==",
+          "!==" => "!=",
+          "or" => "||",
+          "and" => "&&"
+        }.freeze
+
         def generate_number(code)
 
           "#{code.first}"
@@ -10,7 +19,7 @@ module Liquidscript
 
         def generate_dstring(code)
 
-          "\"#{code.first.gsub(/"/, '\\"')}\""
+          "\"#{code.first.gsub("\n", "\\n")}\""
         end
 
         def generate_sstring(code)
@@ -18,10 +27,22 @@ module Liquidscript
           "'#{code.first.gsub(/'/, "\\'")}'"
         end
 
-        def generate_keyword(code)
+        def generate_unop(code)
           " #{code[1].value} #{replace(code[2])}"
         end
 
+        def generate_binop(code)
+          op = BINOP_SWITCH.fetch(code[1].value) do
+            code[1].value
+          end
+
+          " #{replace(code[2])} #{op} #{replace(code[3])}"
+        end
+
+        def generate_keyword(code)
+          " #{code[1].value} "
+        end
+
         def generate_object(code)
 
           object = buffer

data/lib/liquidscript/generator/javascript/metas.rb

@@ -4,7 +4,6 @@ module Liquidscript
       module Metas
 
         def generate_exec(code)
-
           exec = buffer
           exec << _exec_context(code)
           code.codes.inject(exec) do |m, c|
@@ -23,10 +22,34 @@ module Liquidscript
         end
 
         def generate_get(code)
-
           "#{code[1].name}"
         end
 
+        { :if     => "if(%s)",
+          :elsif  => "else if(%s)",
+          :unless => "if(!(%s))" }.each do |k, v|
+
+          define_method(:"generate_#{k}") do |code|
+            part = buffer
+            part << "\n#{v % replace(code[1])} {\n"
+            code[2].inject(part) { |m, p| m << replace(p) }
+            part << "\n}\n"
+
+            if code[3]
+              part << replace(code[3])
+            else
+              part
+            end
+          end
+        end
+
+        def generate_else(code)
+          part = buffer
+          part << "\nelse {\n"
+          code[1].inject(part) { |m, p| m << replace(p) }
+          part << "\n}\n"
+        end
+
         protected
 
         def _exec_context(code)

data/lib/liquidscript/icr/context.rb

@@ -12,7 +12,7 @@ module Liquidscript
       # The variables that are allowed to be used as a global scope,
       # i.e. used in a `get` context without a previous `set`.
       DEFAULT_ALLOWED_VARIABLES = [
-        :window, :global, :exports, :console, :this
+        :window, :global, :exports, :console, :this, :arguments
       ]
 
       # The parent of the current context.

data/lib/liquidscript/scanner/lexer.rl

@@ -17,6 +17,12 @@
   string_double = '"' ( any -- '"' | '\\"' )* '"';
   identifier = [A-Za-z_$][A-Za-z0-9_$]*;
   string_single = "'" [A-Za-z0-9_$\-]+;
+  keywords = 'undefined' | 'null' | 'true' | 'false';
+  unops = '!' | '++' | '--' | '~' | 'new' | 'return' |
+    'typeof';
+  binops = '+' | '-' | '*' | '/' | '&' | '|' | '^' | '<<' | '>>' |
+    '>>>' | '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' |
+    '&&' | '||' | 'instanceof' | 'or' | 'and';
 
   main := |*
     number        => { emit :number      };
@@ -24,8 +30,13 @@
     string_single => { emit :sstring     };
     'class'       => { emit :class       };
     'module'      => { emit :module      };
-    'new'         => { emit :keyword     };
-    'return'      => { emit :keyword     };
+    'if'          => { emit :if          };
+    'unless'      => { emit :unless      };
+    'elsif'       => { emit :elsif       };
+    'else'        => { emit :else        };
+    unops         => { emit :unop        };
+    binops        => { emit :binop       };
+    keywords      => { emit :keyword     };
     identifier    => { emit :identifier  };
     '->'          => { emit :arrow       };
     '='           => { emit :equal       };

data/lib/liquidscript/template.rb

@@ -9,7 +9,7 @@ module Liquidscript
       @_render ||= begin
         compiler = Compiler::ICR.new(Scanner.new(@data))
         compiler.compile
-        Generator::Javascript.new(compiler).generate
+        Generator::Javascript.new(compiler.top).generate
       end
     end
   end

data/lib/liquidscript/version.rb

@@ -1,5 +1,5 @@
 module Liquidscript
 
   # The current version of liquidscript.
-  VERSION = "0.0.1".freeze
+  VERSION = "0.1.0".freeze
 end

data/lib/sprockets/liquidscript_template.rb

@@ -0,0 +1,11 @@
+module Sprockets
+  class LiquidscriptTemplate < Template
+    def self.default_mime_type
+      'application/javascript'
+    end
+
+    def render(context)
+      @output ||= Liquidscript.compile(data)
+    end
+  end
+end

data/spec/fixtures/complex.generate.yml

@@ -1,7 +1,13 @@
 data: |
   thing = {
     test: -> {
-      "hello"
+      if(undefined) {
+        "test"
+      } elsif(null) {
+        "um"
+      } else {
+        "hello"
+      }
     }
   }
 
@@ -12,7 +18,13 @@ compiled: |
 
   thing = {
     "test": function() {
-      "hello"
+      if(undefined) {
+        "test"
+      } else if(null) {
+        "um"
+      } else {
+        "hello"
+      }
     }
   };
 

data/spec/fixtures/operator.generate.yml

@@ -0,0 +1,23 @@
+data: |
+  nodejs = -> {
+    out = false
+
+    if(typeof global != 'undefined) {
+      out = true
+    }
+
+    return out
+  }
+
+compiled: |
+  var nodejs;
+
+  nodejs = function() {
+    var out;
+    out = false;
+    if(typeof global !== 'undefined') {
+      out = true;
+    }
+
+    return out
+  };

data/spec/fixtures/string.generate.yml

@@ -1,6 +1,11 @@
 data: |
   test = "hello"
   foo  = 'world
+  thing = "hello \" test
+  world"
 
 compiled: |
-  var test,foo; test = "hello"; foo = 'world';
+  var test, foo, thing;
+  test = "hello";
+  foo = 'world';
+  thing = "hello \" test \n world";

data/spec/fixtures/underscore.ls

@@ -0,0 +1,29 @@
+(-> {
+  root = this
+  previousUnderscore = root._
+  breaker = {}
+  ArrayProto = root.Array.prototype
+  ObjProto = root.Object.prototype
+  FuncProto = root.Function.prototype
+
+  push = ArrayProto.push
+  slice = ArrayProto.slice
+  concat = ArrayProto.concat
+  toString = ObjProto.toString
+  hasOwnProperty = ObjProto.hasOwnProperty
+
+  class _ {
+
+  }
+
+  if(typeof exports != 'undefined) {
+    if(typeof root.module !== 'undefined && root.module.exports) {
+      exports = root.module.exports = _
+    }
+
+    exports._ = _
+  } else {
+    root._ = _
+  }
+  _.VERSION = "1.6.0"
+}).call()

data/spec/lib/liquidscript/scanner/lexer_spec.rb

@@ -47,10 +47,10 @@ describe Liquidscript::Scanner::Lexer, :lexer_helper do
 
     it "scans keywords" do
       scan("return test = new foo").should eq [
-        [:keyword, "return"],
+        [:unop, "return"],
         [:identifier, "test"],
         [:equal, "="],
-        [:keyword, "new"],
+        [:unop, "new"],
         [:identifier, "foo"]
       ]
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: liquidscript
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-07 00:00:00.000000000 Z
+date: 2014-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,18 +83,21 @@ dependencies:
 description: A javascript-based language that compiles to javascript.
 email:
 - redjazz96@gmail.com
-executables: []
+executables:
+- lscript
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- DOCS.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/lscript
 - lib/liquidscript.rb
 - lib/liquidscript/buffer.rb
 - lib/liquidscript/compiler.rb
@@ -131,6 +134,7 @@ files:
 - lib/liquidscript/scanner/token.rb
 - lib/liquidscript/template.rb
 - lib/liquidscript/version.rb
+- lib/sprockets/liquidscript_template.rb
 - liquidscript.gemspec
 - spec/fixtures/class.compile.yml
 - spec/fixtures/class.generate.yml
@@ -141,8 +145,10 @@ files:
 - spec/fixtures/get.generate.yml
 - spec/fixtures/literals.generate.yml
 - spec/fixtures/main.compile.yml
+- spec/fixtures/operator.generate.yml
 - spec/fixtures/set.generate.yml
 - spec/fixtures/string.generate.yml
+- spec/fixtures/underscore.ls
 - spec/lib/liquidscript/buffer_spec.rb
 - spec/lib/liquidscript/compiler/icr_spec.rb
 - spec/lib/liquidscript/generator/javascript_spec.rb
@@ -191,8 +197,10 @@ test_files:
 - spec/fixtures/get.generate.yml
 - spec/fixtures/literals.generate.yml
 - spec/fixtures/main.compile.yml
+- spec/fixtures/operator.generate.yml
 - spec/fixtures/set.generate.yml
 - spec/fixtures/string.generate.yml
+- spec/fixtures/underscore.ls
 - spec/lib/liquidscript/buffer_spec.rb
 - spec/lib/liquidscript/compiler/icr_spec.rb
 - spec/lib/liquidscript/generator/javascript_spec.rb