liquidscript 0.4.1 → 0.5.0

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

@@ -0,0 +1,42 @@
+module Liquidscript
+  module Generator
+    class Javascript < Base
+      module Exceptions
+
+        def generate_try(code)
+          out = buffer
+          out << "try {\n"
+          insert_into(code[1], out)
+          out << indent_level << "}"
+
+          if code[2]
+            out << replace(code[2])
+          end
+
+          out
+        end
+
+        def generate_catch(code)
+          out = buffer
+          out << "catch(#{code[1].value}) {\n"
+          insert_into(code[2], out)
+          out << indent_level << "}"
+
+          if code[3]
+            out << replace(code[3])
+          end
+
+          out
+        end
+
+        def generate_finally(code)
+          out = buffer
+          out << "finally {\n"
+          insert_into(code[1], out)
+          out << indent_level << "}"
+        end
+
+      end
+    end
+  end
+end

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

@@ -4,19 +4,60 @@ module Liquidscript
       module Literals
 
         BINOP_SWITCH = {
-          "==" => "===",
+          "=="  => "===",
           "===" => "==",
-          "!=" => "!==",
+          "!="  => "!==",
           "!==" => "!=",
-          "or" => "||",
+          "or"  => "||",
           "and" => "&&"
         }.freeze
 
         def generate_number(code)
-
           "#{code.first}"
         end
 
+        def generate_action(code)
+          code[1].value
+        end
+
+        def generate_op(code)
+          if code[1].type == :variable
+            "#{code[1].name}#{code[2].value}"
+          else
+            "#{replace(code[1])}#{code[2].value}"
+          end
+        end
+
+        def generate_while(code)
+          loop_body = buffer
+          loop_body << "while(#{replace(code[1])}) {\n"
+          insert_into(code[2], loop_body)
+          loop_body << indent_level << "}"
+        end
+
+        def generate_for_in(code)
+          loop_body = buffer
+          loop_body << "for(#{code[1].value} in #{code[2].name}) {\n"
+          insert_into(code[3], loop_body)
+          loop_body << indent_level << "}"
+        end
+
+        def generate_for_seg(code)
+          loop_body = buffer
+          loop_body << "for("            <<
+                       replace(code[1])  << ";" <<
+                       replace(code[2])  << ";" <<
+                       replace(code[3])  << ") {\n"
+
+          insert_into(code[4], loop_body)
+
+          loop_body << indent_level << "}"
+        end
+
+        def generate_regex(code)
+          "/#{code[1].value[0]}/#{code[1].value[1]}"
+        end
+
         def generate_istring(code)
           "\"#{code.first.gsub("\n", "\\n")}\""
         end
@@ -24,18 +65,17 @@ module Liquidscript
         def generate_interop(code)
           content = code[1..-1]
           buf = buffer
-          buf.set_join! ','
 
           content.each do |part|
             case part.type
             when :istring_begin, :istring
               buf << "\"#{part.value}\""
             else
-              buf << "#{replace(part)}"
+              buf << " + (#{replace(part)}) + "
             end
           end
 
-          "[#{buf}].join('')"
+          buf
         end
 
         def generate_sstring(code)
@@ -47,6 +87,22 @@ module Liquidscript
           " #{code[1].value} #{replace(code[2])}"
         end
 
+        def generate_href(code)
+          heredoc = code[1]
+          hbuf = buffer
+
+          heredoc.body.each do |part|
+            case part.type
+            when :heredoc, :iheredoc, :iheredoc_begin
+              hbuf << '"' << part.value.gsub('"', '\\"') << '"'
+            else
+              hbuf << ' + ' << replace(part) << ' + '
+            end
+          end
+
+          hbuf
+        end
+
         def generate_binop(code)
           op = BINOP_SWITCH.fetch(code[1].value) do
             code[1].value
@@ -63,11 +119,13 @@ module Liquidscript
 
           object = buffer
           object.set_join! ', '
+          indent!
 
           code[1].inject(object) do |buf, part|
-            buf << "\"#{part[0].value}\": #{replace(part[1])}"
+            buf << "#{indent_level}\"#{part[0].value}\": #{replace(part[1])}"
           end
 
+          unindent!
           "{#{object}}"
         end
 
@@ -84,12 +142,13 @@ module Liquidscript
         end
 
         def generate_newline(_)
-          "\n"
+          ""
         end
 
         def generate_function(code)
 
           function = buffer
+          indent!
 
           function                       <<
             "function("                  <<
@@ -97,6 +156,9 @@ module Liquidscript
             ') {'                        <<
             replace(code[1])             <<
             '}'
+
+          unindent!
+          function
         end
       end
     end

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

@@ -6,18 +6,15 @@ module Liquidscript
         def generate_exec(code)
           exec = buffer
           exec << _exec_context(code)
-          code.codes.inject(exec) do |m, c|
-            m << replace(c)
-            m
-          end
+          insert_into(code.codes, exec)
         end
 
         def generate_set(code)
           case code[1].type
           when :variable
-            "#{code[1].name} = #{replace code[2]};"
+            "#{code[1].name} = #{replace code[2]}"
           when :property
-            "#{replace code[1]} = #{replace code[2]};"
+            "#{replace code[1]} = #{replace code[2]}"
           end
         end
 
@@ -31,9 +28,11 @@ module Liquidscript
 
           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"
+            part << "#{v % replace(code[1])} {\n"
+            indent!
+            insert_into(code[2], part)
+            unindent!
+            part << indent_level << "}"
 
             if code[3]
               part << replace(code[3])
@@ -45,9 +44,11 @@ module Liquidscript
 
         def generate_else(code)
           part = buffer
-          part << "\nelse {\n"
-          code[1].inject(part) { |m, p| m << replace(p) }
-          part << "\n}\n"
+          part << " else {\n"
+          indent!
+          insert_into(code[1], part)
+          unindent!
+          part << indent_level << "}"
         end
 
         protected
@@ -55,7 +56,7 @@ module Liquidscript
         def _exec_context(code)
 
           unless code.locals.empty?
-            "var #{code.locals.join(',')}; "
+            "\n#{indent_level}var #{code.locals.join(',')};\n"
           end
         end
       end

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

@@ -38,7 +38,7 @@ module Liquidscript
             prop << replace(code[1])
           end
 
-          prop << "." << code[2].value
+          prop << "." << code[2]
         end
 
         def generate_class(code)
@@ -46,23 +46,29 @@ module Liquidscript
           class_name = code[1].value
 
           in_module(class_name) do |last_module|
-            body.block <<-JS
+            body.block 7 - @indent, <<-JS
               #{class_name} = #{class_name} || function #{class_name}() {
                 if(this.initialize) {
                   this.initialize.apply(this, arguments);
                 }
-              };
+              }
             JS
 
-            code[2].each do |part|
+            if code[2]
+              body.block 8 - @indent, <<-JS
+                #{class_name}.prototype.__proto__ = #{code[2].value};
+              JS
+            end
+
+            code[3].each do |part|
               k, v = part
               case k.type
               when :identifier
-                body.block <<-JS
+                body.block 8 - @indent, <<-JS
                   #{class_name}.prototype.#{k.value} = #{replace(v)};
                 JS
-              when :dstring
-                body.block <<-JS
+              when :istring
+                body.block 8 - @indent, <<-JS
                   #{class_name}.prototype[#{k.value}] = #{replace(v)};
                 JS
               when :property
@@ -70,9 +76,8 @@ module Liquidscript
                   raise InvalidCodeError.new(k[1].value)
                 end
 
-                body.block <<-JS
-                  #{class_name}.#{k[2].value} =
-                    #{replace(v)};
+                body.block 8 - @indent, <<-JS
+                  #{class_name}.#{k[2]} = #{replace(v)};
                 JS
               when :class
                 body << generate_class(part)
@@ -82,8 +87,8 @@ module Liquidscript
             end
 
             if last_module
-              body.block <<-JS
-                #{last_module}.#{class_name} = #{class_name};
+              body.block 7, <<-JS
+                #{last_module}.#{class_name} = #{class_name}
               JS
             end
 
@@ -103,11 +108,11 @@ module Liquidscript
               k, v = part
               case k
               when :identifier
-                body.block <<-JS
+                body.block 8, <<-JS
                   #{module_name}.#{k.value} = #{replace(v)};
                 JS
               when :dstring
-                body.block <<-JS
+                body.block 8, <<-JS
                   #{module_name}[#{k.value}] = #{replace(v)};
                 JS
               when :class
@@ -118,8 +123,8 @@ module Liquidscript
             end
 
             if last_module
-              body.block <<-JS
-                #{last_module}.#{module_name} = #{module_name};
+              body.block 7, <<-JS
+                #{last_module}.#{module_name} = #{module_name}
               JS
             end
           end

data/lib/liquidscript/icr/set.rb

@@ -43,6 +43,14 @@ module Liquidscript
         @code << Code.new(action, arguments)
       end
 
+      def <<(*v)
+        v.select { |p| p }.each do |part|
+          @code << part
+        end
+      end
+
+      alias_method :push, :<<
+
       # A list of all the local variables in the
       # current scope.  Local variables are defined
       # as variables that were a) not passed in by

data/lib/liquidscript/scanner/base/lexer.rb

@@ -7,18 +7,20 @@ module Liquidscript
           key, value = context.find_matcher(scanner)
 
           if value.nil? && scanner.rest?
-            error scanner
+            error scanner, context
           end
 
           normalize_action key, value, scanner if scanner.rest?
         end
 
-        def lex(argument)
-          context, body =
-          if argument.is_a?(Hash)
-            argument.to_a.first
+        def lex(*args)
+          args.flatten!
+          to_lex = args.pop
+
+          context, body = if to_lex.is_a? Hash
+            to_lex.to_a.first
           else
-            argument
+            [to_lex, nil]
           end
 
           scanner = if body
@@ -29,7 +31,7 @@ module Liquidscript
           out = []
 
           context = find_context(context)
-          instance_exec &context.init
+          instance_exec(*args, &context.init)
 
           while scanner.rest? && out.last != EXIT
             out << perform_with_context(context, scanner)
@@ -38,8 +40,9 @@ module Liquidscript
           out
         end
 
-        def error(scanner = @scanner)
-          raise SyntaxError, "Unexpected #{scanner.peek(2).inspect}" \
+        def error(scanner = @scanner, context = @context)
+          raise SyntaxError, "Unexpected " +
+            "#{scanner.matched}#{scanner.peek(2)}".inspect +
             " (line: #{line}, column: #{column})"
         end
 
@@ -68,7 +71,7 @@ module Liquidscript
           when Proc
             instance_exec(*body.match(key), &value)
           when Symbol
-            lex value
+            lex(*body.match(key), value)
           when EXIT
             EXIT
           end

data/lib/liquidscript/scanner/liquidscript.rb

@@ -30,16 +30,23 @@ module Liquidscript
             new
             return
             typeof
+            throw
+          )
+
+          set :actions, %w(
+            break
+            continue
           )
 
           set :binops, %w(
-            + - * / & | ^
+            + - * / ^
             << >> >>>
             == ===
             != !==
             > >=
             < <=
             && ||
+            & |
             instanceof
             or and
           )
@@ -59,43 +66,59 @@ module Liquidscript
           on("unless")    {     emit :unless        }
           on("elsif")     {     emit :elsif         }
           on("else")      {     emit :else          }
+          on("for")       {     emit :for           }
+          on("while")     {     emit :while         }
+          on("try")       {     emit :try           }
+          on("catch")     {     emit :catch         }
+          on("finally")   {     emit :finally       }
           on(:number)     { |m| emit :number,  m    }
           on(:string)     { |m| emit :sstring, m    }
           on(:keywords)   { |m| emit :keyword, m    }
-          on(:unops)      { |m| emit :unop,    m    }
+          on(:actions)    { |m| emit :action, m     }
           on("->")        {     emit :arrow         }
           on("=")         {     emit :equal         }
-          on("{")         {     emit :lbrack        }
+          on("{")         {     emit :lbrace        }
           on("(")         {     emit :lparen        }
-          on("[")         {     emit :lbrace        }
-          on("}")         {     emit :rbrack        }
+          on("[")         {     emit :lbrack        }
+          on("}")         {     emit :rbrace        }
           on(")")         {     emit :rparen        }
-          on("]")         {     emit :rbrace        }
+          on("]")         {     emit :rbrack        }
           on(":")         {     emit :colon         }
           on(".")         {     emit :prop          }
           on(",")         {     emit :comma         }
-          on("\n")        {     line!; emit :newline}
+          on("\n")        {     line!               }
+          on(%r{"} => :istring)
+          on(%r{<<([A-Z]+)}) do |_, s|
+            emit :heredoc_ref, s
+            @lexes << [:heredoc, s]
+          end
+          on(%r{<<-([A-Z]+)}) do |_, s|
+            emit :iheredoc_ref, s
+            @lexes << [:iheredoc, s]
+          end
+          on(%r{/(.*?)/([a-z]*)}) { |_, m, b|
+            emit :regex, [m, b]
+          }
+          on("///" => :block_regex)
           on(:binops)     { |m| emit :binop,   m    }
+          on(:unops)      { |m| emit :unop,    m    }
           on(:identifier) { |m| emit :identifier, m }
 
-          on(/\"/ => :istring)
-          on(/#.*?\n/) { }
-          on(/[\s]/)   { }
-          on(:_) { error }
+          on(%r{#.*?\n}) { }
+          on(%r{\s})     { }
+          on(:_)         { |m| error }
         end
 
         context :istring do
-          init do
-            @buffer = []
-          end
+          init { @buffer = [] }
 
-          on(/\\"/) { |m| @buffer << m }
-          on(/"/) do
+          on('\\"') { |m| @buffer << m }
+          on('"') do
             emit :istring, @buffer.join
             exit
           end
 
-          on(/\#\{(.*?)\}/) do |_, b|
+          on(%r{\#\{(.*?)\}}) do |_, b|
             emit :istring_begin, @buffer.join
             lex :main => b
             @buffer = []
@@ -103,17 +126,72 @@ module Liquidscript
 
           on(:_) { |m| @buffer << m }
         end
+
+        context :heredoc do
+          init { @buffer = [] }
+
+          on(%r{\n\s*([A-Z]+)\s*\n}) do |_, s|
+            if @start == s
+              emit :heredoc, @buffer.join
+              exit
+            else
+              @buffer << _
+            end
+          end
+
+          on(:_) { |m| @buffer << m }
+        end
+
+        context :iheredoc do
+          init { @buffer = [] }
+
+          on(%r{\n\s*([A-Z]+)\s*\n}) do |_, s|
+            if @start == s
+              emit :iheredoc, @buffer.join
+              @start = nil
+              exit
+            else
+              @buffer << _
+            end
+          end
+
+          on(%r{\#\{(.*?)\}}) do |_, b|
+            emit :iheredoc_begin, @buffer.join
+            lex :main => b
+            @buffer = []
+          end
+
+          on(:_) { |m| @buffer << m }
+        end
+
+        context :block_regex do
+          init { @buffer = [] }
+
+          on(%r{///([a-z]*)}) do |_, m|
+            emit :regex, [@buffer.join, m]
+            exit
+          end
+          on(%r{#.*?\n}) { }
+          on("\n")       { }
+          on(:_)         { |m| @buffer << m }
+        end
       end
 
       def initialize(*)
         @line = 1
         @cstart = 0
+        @lexes = []
         super
       end
 
       def line!
         @line += 1
         @cstart = @scanner.pos
+        while @lexes.any?
+          type, @start = @lexes.shift
+
+          lex type
+        end
       end
 
       def line