liquidscript 0.11.0.rc1 → 0.11.0

data/lib/liquidscript/icr/representable.rb

@@ -9,7 +9,7 @@ module Liquidscript
       extend Forwardable
       include Comparable
 
-      def_delegators :to_a, :to_s, :inspect, :[], :each, :'<=>'
+      def_delegators :to_a, :to_s, :inspect, :[], :each, :'<=>', :length
 
 
       def to_ary

data/lib/liquidscript/icr/set.rb

@@ -7,33 +7,50 @@ module Liquidscript
     # etc.
     class Set < Code
 
-      # The metadata that is applied to the set.
-      #
-      # @return [Hash]
-      attr_reader :metadata
-
       include Representable
 
       # Initialize the set.
       def initialize
-        @metadata = {}
-        @code = []
-        @contexts = []
-        @action = :exec
+        @context = nil
+        super :exec
       end
 
       #
       def context
-        contexts.last || @metadata.fetch(:parent).context
+        @context || @metadata.fetch(:parent).context
+      end
+
+      def parent=(parent)
+        @metadata[:parent] = parent
+        if @context
+          @context.parent = parent.context
+        end
+
+        parent
       end
 
-      def contexts
-        @contexts
+      def parent
+        @metadata[:parent]
       end
 
       #
-      def context=(new_context)
-        contexts << new_context
+      def context=(context)
+        @context = context
+      end
+
+      # Turns the code into an array, containing the
+      # action and the arguments.  Note that changing
+      # this array will not change the code.
+      #
+      # @return [Array]
+      def to_a
+        part = [@action]
+        part << [:_context, context] if @context
+        part.concat(@metadata.to_a.select { |(k, v)|
+          [:arguments, :heredocs, :herenum].include?(k)
+          }.map { |(k, v)| [:"_#{k}", v] })
+        part.concat(@arguments)
+        part
       end
 
       # Adds a code to the code list.  This is just a
@@ -43,12 +60,12 @@ module Liquidscript
       #   the action.
       # @param arguments the arguments for the code.
       def add(action, *arguments)
-        @code << Code.new(action, arguments)
+        self << Code.new(action, arguments)
       end
 
       def <<(*v)
         v.select { |p| p }.each do |part|
-          @code << part
+          @arguments << part
         end
       end
 
@@ -62,7 +79,7 @@ module Liquidscript
       #
       # @return [Array<Symbol>]
       def locals
-        variables - parameters
+        variables - parameters - hidden
       end
 
       # A list of components (or arguments) that are
@@ -75,6 +92,14 @@ module Liquidscript
         context.parameters.map(&:name)
       end
 
+      # A list of hidden variables in the current
+      # context.
+      #
+      # @return [Array<Symbol>]
+      def hidden
+        context.hidden.map(&:name)
+      end
+
       # A list of _all_ variables in the current
       # scope.
       #
@@ -83,74 +108,11 @@ module Liquidscript
         context.variables.keys - context.allowed_variables
       end
 
-      # Turns the set into an array.  Includes the
-      # metadata information and the actual internal
-      # array.
-      # Note that this is _not_ the array used in
-      # {#method_missing} - that actually operates on
-      # the internal array.
-      #
-      # @return [Array]
-      def to_a
-        part = [@action]
-        part << [:_context, context] if contexts.any?
-        part.concat(@metadata.to_a.map { |(m, i)| [:"_#{m}", i] })
-        part.concat(@code)
-        part
-      end
-
       # Outputs the codes in this set.
       #
       # @return [Array<Code>]
       def codes
-        @code
-      end
-
-      # Access either the metadata or the codes.  If
-      # the accessor is a Symbol, it access the metadata;
-      # if it the accessor is a Numeric, it access the
-      # codes.
-      #
-      # @param key [Symbol, Numeric] the key.
-      # @return [Object]
-      def [](key)
-        if key.is_a? Numeric
-          @code[key]
-        else
-          @metadata[key]
-        end
-      end
-
-      # Sets something from the metadata.  Unlike the
-      # accessor, it does not distinguish between
-      # Numeric and Symbol keys.
-      #
-      # @param key [Object] the key.
-      # @param value [Object] the value.
-      # @return [Object]
-      def []=(key, value)
-        @metadata[key] = value
-      end
-
-      # Tells ruby that we respond to some methods.
-      # Passes the method name to the internal
-      # array, asking if it responds to it.
-      #
-      # @param method [Symbol] the method to check.
-      # @param include_private [Boolean] whether or not
-      #   to include private methods.
-      # @return [Boolean] whether or not we respond
-      #   to that method.
-      def respond_to_missing?(method, include_private = false)
-        @code.respond_to?(method, include_private)
-      end
-
-      # For methods that we don't respond to, send
-      # them to the interal array.
-      #
-      # @return [Object]
-      def method_missing(method, *args, &block)
-        @code.public_send(method, *args, &block)
+        @arguments
       end
 
     end

data/lib/liquidscript/icr/variable.rb

@@ -50,6 +50,23 @@ module Liquidscript
         self
       end
 
+      # Marks this variable as hidden.  This variable does not show
+      # up as a parameter nor a class variable.
+      #
+      # @return [self]
+      def hidden!
+        @hidden = true
+        self
+      end
+
+      # WHether or not this variable is hidden.
+      #
+      # @see {#hidden!}
+      # @return [Boolean]
+      def hidden?
+        @hidden
+      end
+
       # Whether or not the variable is an argument to a function.
       #
       # @see {#parameter!}

data/lib/liquidscript/scanner/base.rb

@@ -17,12 +17,22 @@ module Liquidscript
 
       attr_accessor :metadata
 
-      def initialize(source)
+      def initialize(source, file = nil)
         @source   = source
         @scanner  = StringScanner.new(@source)
         @tokens   = []
         @_scan    = nil
         @metadata = {}
+
+        if !file and source.respond_to?(:to_path)
+          file = source.to_path
+        end
+
+        @metadata[:file] = file || "<none>"
+      end
+
+      def file
+        @metadata[:file]
       end
 
       def contexts

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

@@ -40,10 +40,11 @@ module Liquidscript
           out
         end
 
-        def error(scanner = @scanner, context = @context)
+        def error(scanner = @scanner, context = @context,
+                  file = @metadata[:file])
           raise SyntaxError, "Unexpected " +
             "#{scanner.matched}#{scanner.peek(2)}".inspect +
-            " (line: #{line}, column: #{column})"
+            " (line: #{line}, column: #{column}, file: #{file})"
         end
 
         private

data/lib/liquidscript/scanner/liquidscript/main.rb

@@ -90,45 +90,47 @@ module Liquidscript
 
             set :identifier, %r{[A-Za-z_$]([A-Za-z0-9_$-]*[A-Za-z0-9_$])?}
 
-            on("class")     {     emit :class         }
-            on("module")    {     emit :module        }
-            on("if")        {     emit :if            }
-            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("return")    {     emit :return        }
-            on(:number)     { |m| emit :number,  m    }
-            on(:string)     { |m| emit :sstring, m    }
-            on(:keywords)   { |m| emit :keyword, m    }
-            on(:actions)    { |m| emit :action,  m    }
-            on(:binops)     { |m| emit :binop,   m    }
-            on(:preunops)   { |m| emit :preunop, m    }
-            on(:unops)      { |m| emit :unop,    m    }
+            on("class")     {     emit :class           }
+            on("module")    {     emit :module          }
+            on("if")        {     emit :if              }
+            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("return")    {     emit :return          }
+            on("nil")       {     emit :keyword, "null" }
+            on(:number)     { |m| emit :number,  m      }
+            on(:string)     { |m| emit :sstring, m      }
+            on(:keywords)   { |m| emit :keyword, m      }
+            on(:actions)    { |m| emit :action,  m      }
+            on(:binops)     { |m| emit :binop,   m      }
+            on(:preunops)   { |m| emit :preunop, m      }
+            on(:unops)      { |m| emit :unop,    m      }
             on(%r{<<([A-Z]+)}, :heredoc)
             on(%r{<<-([A-Z]+)}, :iheredoc)
             on(%r{r/((?:.|\/)*)/([gimy]*)}, :regex)
             on(%r{"} => :istring)
             on("///" => :block_regex)
-            on("->")        {     emit :arrow         }
-            on("=")         {     emit :equal         }
-            on("{")         {     emit :lbrace        }
-            on("(")         {     emit :lparen        }
-            on("[")         {     emit :lbrack        }
-            on("}")         {     emit :rbrace        }
-            on(")")         {     emit :rparen        }
-            on("]")         {     emit :rbrack        }
-            on(":")         {     emit :colon         }
-            on("..")        {     emit :range         }
-            on(".")         {     emit :prop          }
-            on(",")         {     emit :comma         }
-            on("-")         {     emit :minus         }
-            on("+")         {     emit :plus          }
-            on("\n")        {     line!               }
+            on("->")        {     emit :arrow           }
+            on("=")         {     emit :equal           }
+            on("{")         {     emit :lbrace          }
+            on("(")         {     emit :lparen          }
+            on("[")         {     emit :lbrack          }
+            on("}")         {     emit :rbrace          }
+            on(")")         {     emit :rparen          }
+            on("]")         {     emit :rbrack          }
+            on(":")         {     emit :colon           }
+            on("..")        {     emit :range           }
+            on("...")       {     emit :erange          }
+            on(".")         {     emit :prop            }
+            on(",")         {     emit :comma           }
+            on("-")         {     emit :minus           }
+            on("+")         {     emit :plus            }
+            on("\n")        {     line!                 }
             on(:identifier, :identifier)
             on(%r{!\[\s*([A-Za-z]+)\s*(.*?)\s*\]\n}, :directive)
 

data/lib/liquidscript/version.rb

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

data/spec/fixtures/class.compile.yml

@@ -30,11 +30,9 @@ compiled:
                   - []
                 - - :_arguments
                   - []
-        - - :test
       - - :class
         - - :identifier
           - AnotherClass
         - - :_variable
           - :SomeClass
         - []
-        - []

data/spec/fixtures/function.generate.yml

@@ -6,8 +6,12 @@ data: |
     test = 0..console
   }
 
+  another_function = (a, b = a, c...)-> {
+    console.log()
+  }
+
 compiled: |
-  var some_function;
+  var some_function, another_function;
   console = 2;
 
   some_function = function() {
@@ -26,3 +30,12 @@ compiled: |
       return t === undefined ? out : out.reverse();
     })(0, console);
   };
+
+  another_function = function(a, b) {
+    if(b == null) {
+      b = a;
+    }
+    c = [].slice.call(arguments, 2);
+
+    return console.log();
+  };

data/spec/fixtures/literals.generate.yml

@@ -3,6 +3,7 @@ data: |
   test = [1, 2]
   range = 0x1..0x9
   range2 = 10..1
+  range3 = 10...1
   regex = r/^\/test/
   block = ///
     ^test # comment
@@ -10,11 +11,12 @@ data: |
   regex == block
 
 compiled: |
-  var object, test, range, range2, regex, block;
+  var object, test, range, range2, range3, regex, block;
   object = { "hello": "world" };
   test = [1, 2];
   range = [0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9];
   range2 = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+  range3 = [9, 8, 7, 6, 5, 4, 3, 2, 1];
   regex = /^\/test/;
   block = /^test/;
   regex === block;

data/spec/liquidscript/compiler/icr_spec.rb

@@ -114,7 +114,7 @@ describe Compiler::ICR do
         [:_context, []], [:function,
           [:exec,
             [:_context, [:test]],
-            [:_arguments, [[:identifier, "test"]]],
+            [:_arguments, [[[:identifier, "test"], nil]]],
             [:number, "2"]
           ]
       ]])

data/spec/liquidscript/icr/context_spec.rb

@@ -18,13 +18,13 @@ describe ICR::Context do
 
     let(:parent) do
       parent = double("parent")
-      expect(parent).to receive(:get).once.with(:foo).and_return(:test)
+      expect(parent).to receive(:get).once.with(:foo, {}).and_return(:test)
       parent
     end
 
     subject do
       context = ICR::Context.new
-      context.parents << parent
+      context.parent = parent
       context
     end
 

data/spec/liquidscript/icr/set_spec.rb

@@ -13,12 +13,12 @@ describe ICR::Set do
     context "with metadata" do
       subject do
         set = ICR::Set.new
-        set.metadata.merge! :hello => "world"
+        set.metadata.merge! :arguments => "world"
         set
       end
 
       specify { expect(subject.to_a).to have(2).items }
-      specify { expect(subject.to_a).to eq [:exec, [:_hello, "world"]] }
+      specify { expect(subject.to_a).to eq [:exec, [:_arguments, "world"]] }
 
     end
 
@@ -37,13 +37,13 @@ describe ICR::Set do
     context "with both" do
       subject do
         set = ICR::Set.new
-        set.metadata.merge! :hello => "world"
+        set.metadata.merge! :arguments => "world"
         set << "test"
         set
       end
 
       specify { expect(subject.to_a).to have(3).items }
-      specify { expect(subject.to_a).to eq [:exec, [:_hello, "world"], "test"] }
+      specify { expect(subject.to_a).to eq [:exec, [:_arguments, "world"], "test"] }
 
     end
   end