liquidscript 0.10.4 → 0.11.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c2c527652bdb7ece680508921dffafff168c7cb
-  data.tar.gz: 9d0c2a6c28d59681080a62cca518ff53f55d00aa
+  metadata.gz: 3659bbe0464cee916b09fbfb082e40cbd630c63b
+  data.tar.gz: c7708c7a59d1b5ac56edecc2babcd545b21d8321
 SHA512:
-  metadata.gz: 2f3e290757fcfb60f4c021d0f0613f0eddbbcf4df8e1b3d81b6d8d8fb6390b2c153be261692ede6961273218f1fdef63581548bc3324798ca7a3a505cf8e5347
-  data.tar.gz: 970b9501c509db02bcfcebf9fcb93ed11a5603ca7f71bfb5cb3a19357e49bf6fe0f726d7c9ef03421c15188e658ade3d90e612277f070bb66d249de6a389a6ef
+  metadata.gz: b0fb9dc4ef32911b666bc9914f64ae198e79be36f6dfad11814671717227d9e5b04b9cfd17868caa3ce40af91a81fe90a17e7333d1ecc4ff8eeb5a5391040364
+  data.tar.gz: 4323533b81a1fba55e715b89a5ffa3b8b369c8c46dce386fdf190fda4d4cb8ccf7204e406960848e7ad23a70ffdc765c74d156eb31b27e576d60a0ad7b8259a4

data/lib/liquidscript/cli.rb

@@ -23,13 +23,13 @@ module Liquidscript
         puts "COMPILING: #{file}"
         perform_compiliation(file,
           options[:out] || file.gsub('.liq', '.js'))
-      end 
+      end
     end
 
     desc "syntax FILES", "Syntax check given file"
     long_desc <<-LONGDESC
      It will run a syntax check on the file listed. If the file does
-     not pass the syntax check it will return the error code 1. If 
+     not pass the syntax check it will return the error code 1. If
      the file give is - it will check the standard input.
     LONGDESC
     def syntax(*files)
@@ -47,45 +47,42 @@ module Liquidscript
     private
 
     def perform_compiliation(file, out)
-      infile = if file == '-'
-        $stdin
-      else
-        File.open(file, "r")
+      open_files(file, out) do |infile, outfile|
+        out = Liquidscript.compile(infile.read)
+        outfile.write(out)
       end
+    end
 
-      outfile = if out == '-'
-        $stdout
-      else
-        File.open(out, "w")
+    def preform_syntax_check(file)
+      open_files(file) do |infile|
+        Liquidscript.compile(infile.read)
+        puts "OK"
       end
-
-      out = Liquidscript.compile(infile.read)
-      outfile.write(out)
-    rescue StandardError => e
-        $stderr.puts "ERROR: #{e.class}: #{e.message}"
-
-        $stderr.puts e.backtrace[0..5].map { |s| "\t#{s.gsub(/^.*?\/lib\/liquidscript\//, "")}" }.join("\n")
-        exit 1
-    ensure
-      ([infile, outfile] - [$stdin, $stdout]).each(&:close)
     end
 
-    def preform_syntax_check(file)
-      infile = if file == '-'
+    def open_files(inf, outf = nil)
+      inf = if inf == '-'
         $stdin
       else
-        File.open(file, "r")
+        File.open(inf, 'r')
       end
 
-      Liquidscript.compile(infile.read)
-      puts "OK"
-      return true
-    rescue StandardError => e
-        puts "FAIL"
+      outf = if outf == '-'
+        $stdout
+      elsif outf
+        File.open(outf, 'w')
+      end
+
+      begin
+        yield inf, outf
+      rescue StandardError => e
         $stderr.puts "ERROR: #{e.class}: #{e.message}"
-        return false
-    ensure
-      ([infile] - [$stdin]).each(&:close)
+        $stderr.puts e.backtrace[0..5].map { |s| "\t" +
+          s.gsub(/^lib\/liquidscript\//, "") }.join("\n")
+        false
+      ensure
+        ( [ inf, outf].compact - [$stdin, $stdout]).each(&:close)
+      end
     end
   end
 end

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

@@ -3,16 +3,18 @@ module Liquidscript
     class Base
       class Callable
 
+        attr_accessor :bind
+
         # Initialize the callable.
         #
         # @param bind [Object] the object that holds the method (if
         #   this represents a method call).
         # @param block [Symbol, Block] if it's a Symbol, it represents
         #   a method on bind; otherwise, it's a pure block.
-        def initialize(bind, block)
+        def initialize(bind, block, prefix = "compile_")
           @bind = bind
           @block = if block.is_a? Symbol
-            :"compile_#{block}"
+            :"#{prefix}#{block}"
           else
             block
           end

data/lib/liquidscript/compiler/icr.rb

@@ -1,4 +1,5 @@
 require "liquidscript/compiler/icr/expressions"
+require "liquidscript/compiler/icr/directives"
 require "liquidscript/compiler/icr/functions"
 require "liquidscript/compiler/icr/literals"
 require "liquidscript/compiler/icr/classes"
@@ -8,9 +9,49 @@ require "liquidscript/compiler/icr/groups"
 
 module Liquidscript
   module Compiler
+
+    # A list of codes:
+    #
+    # - :class
+    # - :module
+    # - :neg
+    # - :pos
+    # - :binop
+    # - :unop
+    # - :set
+    # - :expression
+    # - :property
+    # - :access
+    # - :call
+    # - :function
+    # - :if
+    # - :elsif
+    # - :unless
+    # - :else
+    # - :try
+    # - :catch
+    # - :finally
+    # - :nrange
+    # - :number
+    # - :action
+    # - :range
+    # - :while
+    # - :for_in
+    # - :for_seg
+    # - :regex
+    # - :href
+    # - :interop
+    # - :istring
+    # - :sstring
+    # - :operator
+    # - :keyword
+    # - :object
+    # - :array
+    # - :newline (depricated)
     class ICR < Base
 
       include Expressions
+      include Directives
       include Functions
       include Literals
       include Classes
@@ -20,8 +61,6 @@ module Liquidscript
       # (see Base#initialize)
       def initialize(*)
         super
-
-        handle_directives
       end
 
       # (see Base#reset!)
@@ -45,30 +84,8 @@ module Liquidscript
         compile_expression
       end
 
-      private
-
-      def handle_directives
-        return unless @scanner.metadata[:directives]
-
-        @scanner.metadata[:directives].each do |meta|
-          case meta[:command].downcase
-          when "allow"
-            variables = meta[:args].split(' ')
-            variables.map {|x| normalize(x) }.each { |v|
-              top.context.allow(v.intern) }
-          when "cvar"
-            variables = meta[:args].split(' ')
-            variables.map {|x| normalize(x) }.each { |v|
-              top.context.set(v.intern,
-                :class => true).parameter! }
-          else
-            raise UnknownDirectiveError.new(meta[:command])
-          end
-        end
-      end
-
       def normalize(s)
-        s.gsub(/\-[a-z]/) { |p| p[1].upcase }
+        s.map { |x| x.gsub(/\-[a-z]/) { |p| p[1].upcase } }
       end
     end
   end

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

@@ -0,0 +1,79 @@
+module Liquidscript
+  module Compiler
+    class ICR < Base
+      module Directives
+        module ClassMethods
+
+          def directives
+            @_directives ||= {}
+          end
+
+          def define_directive(name, body)
+            directives[name] = Base::Callable.new(nil, body, "")
+          end
+
+        end
+
+        module InstanceMethods
+
+          extend Forwardable
+
+          def handle_directive(directive)
+            command, args = directive[:command], directive[:arguments]
+
+            callable = directives.fetch(command)
+
+            callable.bind = self
+            callable.call(*args)
+
+          rescue KeyError
+            raise UnknownDirectiveError.new(command)
+          end
+
+          def directives
+            @_directives ||= self.class.directives.dup
+          end
+
+          def define_directive(name, body)
+            directives[name] = Base::Callable.new(nil, body, "")
+          end
+
+          def directive_allow(*args)
+            args.each do |a|
+              top.context.allow(a.value.intern)
+            end
+
+            nil
+          end
+
+          def directive_cvar(*args)
+            args.each do |a|
+              top.context.set(a.value.intern, :class => true).parameter!
+            end
+
+            nil
+          end
+
+          def directive_strict
+            top.metadata[:strict] = true
+
+            nil
+          end
+
+        end
+
+        def self.included(receiver)
+          receiver.extend         ClassMethods
+          receiver.send :include, InstanceMethods
+
+          InstanceMethods.instance_methods.each do |m|
+            if m.to_s =~ /\A_?directive_([A-Za-z0-9]+)\z/
+              receiver.define_directive($1, m)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -9,7 +9,8 @@ module Liquidscript
         # @return [ICR::Code]
         def compile_expression
           expect :if, :unless, :class, :module, :loop, :for,
-                 :while, :action, :try, :_ => :vexpression
+                 :while, :action, :try, :return,
+                 :colon => :directive, :_ => :vexpression
         end
 
         # Compiles an expression that returns a value.
@@ -62,6 +63,11 @@ module Liquidscript
           code :unop, shift(:unop, :preunop), compile_vexpression
         end
 
+        def compile_return
+          shift :return
+          code :return, compile_vexpression
+        end
+
         # Handles an assignment of the form `identifier = expression`,
         # with the argument being the identifier, and the position of
         # the compiler being after it.
@@ -100,6 +106,30 @@ module Liquidscript
           end
         end
 
+        def compile_directive
+          shift :colon
+          shift :lbrack
+          command = shift(:identifier).value
+          old, @in_directive = @in_directive, true
+          arguments = collect_compiles :rbrack do
+            expect :lbrace     => action { _compile_block },
+                   :identifier => action.shift,
+                   :_          => :vexpression
+          end
+
+          directive = {
+            :command => command,
+            :arguments => arguments }
+
+          @in_directive = old
+
+          if @in_directive
+            directive
+          else
+            handle_directive(directive)
+          end
+        end
+
         def _compile_lparen_method
           ident = shift :identifier
 
@@ -112,6 +142,7 @@ module Liquidscript
           end
         end
 
+
         def _compile_lparen_method_final(ident = nil)
           components = [ident].compact
 

data/lib/liquidscript/errors.rb

@@ -7,6 +7,8 @@ module Liquidscript
   class GeneratorError < Error; end
 
   class UnexpectedEndError < CompileError; end
+  class DirectiveError < CompileError; end
+
   class InvalidReferenceError < CompileError
 
     def initialize(name)
@@ -14,7 +16,8 @@ module Liquidscript
     end
   end
 
-  class UnknownDirectiveError < CompileError
+
+  class UnknownDirectiveError < DirectiveError
     def initialize(directive)
       super "Unkown directive: #{directive}"
     end

data/lib/liquidscript/generator/base/replacements.rb

@@ -8,12 +8,17 @@ module Liquidscript
         #
         # @param code [ICR::Code, #type]
         # @param context [Hash]
-        def replace(code)
-          send(:"generate_#{code.type}",
-            code)
+        def replace(code, options = {})
+          method_name = :"generate_#{code.type}"
+
+          if method(method_name).arity.abs == 1
+            send(method_name, code)
+          else
+            send(method_name, code, options)
+          end
 
         rescue NoMethodError => e
-          if e.name == :"generate_#{code.type}"
+          if e.name == method_name
             raise InvalidCodeError.new(code.type)
           else
             raise

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

@@ -21,9 +21,9 @@ module Liquidscript
         def generate_nrange(code)
           start  = code[1]
           ending = code[2]
-          
+
           if (start.to_i - ending.to_i).abs > 50
-            generate_range(code, true)
+            generate_range(code, {}, true)
           elsif ending > start
             buffer << "[" << (start..ending).to_a.join(', ') << "]"
           else
@@ -31,7 +31,7 @@ module Liquidscript
           end
         end
 
-        def generate_range(code, norep=false)
+        def generate_range(code, options = {}, norep = false)
           out = buffer
           a = norep ? code[1] : replace(code[1])
           b = norep ? code[2] : replace(code[2])
@@ -46,7 +46,7 @@ module Liquidscript
                  unindent! << "};\n"                            <<
                  indent    << "return t === undefined ?"        <<
                               "out : out.reverse();\n"          <<
-                 unindent! << "})(" << a << ", " << b << ")"  
+                 unindent! << "})(" << a << ", " << b << ")"
           out
         end
 
@@ -130,6 +130,10 @@ module Liquidscript
           "#{code[1].value} #{replace(code[2])}"
         end
 
+        def generate_return(code)
+          "return #{replace(code[1])}"
+        end
+
         def generate_href(code)
           heredoc = code[1]
           hbuf = buffer
@@ -207,7 +211,7 @@ module Liquidscript
             "function("                   <<
             code[1].parameters.join(', ') <<
             ") {\n"                       <<
-            replace(code[1])
+            replace(code[1], :final_return => true)
           unindent!
 
           function << indent_level << "}"

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

@@ -3,10 +3,18 @@ module Liquidscript
     class Javascript
       module Metas
 
-        def generate_exec(code)
+        def generate_exec(code, options)
           exec = buffer
+          return exec if code.codes.length == 0
           exec << _exec_context(code)
-          insert_into(code.codes, exec)
+          insert_into(code.codes[0..-2], exec)
+          last = code.codes.last
+
+          if last.value? && options[:final_return]
+            exec << indent << "return #{replace(last)};\n"
+          else
+            exec << indent << replace(last) << ";\n"
+          end
         end
 
         def generate_set(code)
@@ -59,9 +67,11 @@ module Liquidscript
         protected
 
         def _exec_context(code)
+          out = buffer
 
+          out << "#{indent}\"use strict\";\n" if code[:strict]
           unless code.locals.empty?
-            "#{indent_level}var #{code.locals.join(', ')};\n"
+            out << "#{indent_level}var #{code.locals.join(', ')};\n"
           end
         end
       end

data/lib/liquidscript/icr/code.rb

@@ -43,6 +43,18 @@ module Liquidscript
         [@action, *@arguments]
       end
 
+      # If this code respresents something with a definite
+      # value.
+      #
+      # @return [Boolean]
+      def value?
+        @_value ||= ![
+          :class, :module, :if, :elseif, :unless,
+          :else, :try, :catch, :finally, :while, :for_in,
+          :for_seg, :return
+        ].include?(@action)
+      end
+
       # If we don't respond to it, the @arguments array
       # might.  Ask them if they do, and if they don't,
       # respond accordingly.

data/lib/liquidscript/scanner/liquidscript.rb

@@ -37,6 +37,10 @@ module Liquidscript
         end
       end
 
+      def normalize_identifier(ident)
+        ident.gsub(/\-[a-z]/) { |p| p[1].upcase }
+      end
+
       def line
         @line
       end

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

@@ -35,7 +35,6 @@ module Liquidscript
               !
               ~
               new
-              return
               typeof
               throw
             )
@@ -82,13 +81,11 @@ module Liquidscript
             end
 
             action :directive do |_, c, a|
-              metadata[:directives] ||= []
-              metadata[:directives].push :command => c,
-                                         :args    => a
+              emit :directive, [c, a]
             end
 
             action :identifier do |m|
-              emit :identifier, m.gsub(/\-[a-z]/) { |p| p[1].upcase }
+              emit :identifier, normalize_identifier(m)
             end
 
             set :identifier, %r{[A-Za-z_$]([A-Za-z0-9_$-]*[A-Za-z0-9_$])?}
@@ -104,13 +101,14 @@ module Liquidscript
             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(: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)
@@ -132,7 +130,7 @@ module Liquidscript
             on("+")         {     emit :plus          }
             on("\n")        {     line!               }
             on(:identifier, :identifier)
-            on(%r{#! ([A-Za-z]+) ?(.*?)\n}, :directive)
+            on(%r{!\[\s*([A-Za-z]+)\s*(.*?)\s*\]\n}, :directive)
 
             on(%r{#.*?\n}) { }
             on(%r{\s})     { }

data/lib/liquidscript/scanner/liquidscript/regexs.rb

@@ -13,7 +13,7 @@ module Liquidscript
               exit
             end
             on(%r{#.*?\n}) { }
-            on("\n")       { }
+            on(/\s/)       { }
             on(:_)         { |m| @buffer << m }
           end
         end

data/lib/liquidscript/version.rb

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

data/spec/fixtures/class.generate.yml

@@ -1,5 +1,5 @@
 data: |
-  #! allow require set-timeout
+  :[allow require set-timeout]
 
   assert = require('assert)
 
@@ -52,15 +52,15 @@ compiled: |
 
   Test.prototype.initialize = function() {
     "this should be init";
-    this.wee();
+    return this.wee();
   };
 
   Test.prototype.wee = function() {
-    console.log(this.someNumber);
+    return console.log(this.someNumber);
   };
 
   Test.test = function() {
-    "class method!";
+    return "class method!";
   };
   Something.Test = Test;
 
@@ -73,7 +73,7 @@ compiled: |
   AnotherTest.prototype.__proto__ = Test.prototype;
 
   AnotherTest.prototype.thing = function() {
-    console.log("[another test]", this.someNumber, this.anotherThing);
+    return console.log("[another test]", this.someNumber, this.anotherThing);
   };
 
   Something.AnotherTest = AnotherTest;;

data/spec/fixtures/combination.generate.yml

@@ -1,5 +1,5 @@
 data: |
-  #! allow require
+  :[allow require]
   Test = require("assert")
 
   module SomeModule {
@@ -25,7 +25,7 @@ compiled: |
   };
 
   Thing.prototype.initialize = function() {
-    this.test = new Test();
+    return this.test = new Test();
   };
 
   Thing.prototype.do = function(thing) {

data/spec/fixtures/example.generate.yml

@@ -25,16 +25,16 @@ compiled: |
   };
 
   Greeter.prototype.initialize = function(name) {
-    this.name = name;
+    return this.name = name;
   };
 
   Greeter.prototype.greet = function() {
-    console.log("Hello " + (this.name) + "!");
+    return console.log("Hello " + (this.name) + "!");
   };
 
   Greeter.meet = function(first, second) {
     new Greeter(first).greet();
-    new Greeter(second).greet();
+    return new Greeter(second).greet();
   };;
 
   Greeter.meet("Alice", "Bob");

data/spec/fixtures/function.generate.yml

@@ -1,6 +1,7 @@
 data: |
   console = 2
   some_function = ()-> {
+    :[strict]
     console = 3
     test = 0..console
   }
@@ -10,9 +11,10 @@ compiled: |
   console = 2;
 
   some_function = function() {
+    "use strict";
     var test;
     console = 3;
-    test = (function(a, b) {
+    return test = (function(a, b) {
       var out, i, t;
       out = [];
       if(a > b) {

data/spec/fixtures/inline.generate.yml

@@ -5,6 +5,6 @@ data: |
 compiled: |
   var someFunction;
   someFunction = function() {
-    console.log("test");
+    return console.log("test");
   };
   someFunction();

data/spec/fixtures/underscore.js

@@ -1,6 +1,5 @@
 (function() {
-
-  var root,breaker,previousUnderscore,ArrayProto,ObjProto,FuncProto,push,slice,concat,toString,hasOwnProperty,nativeForEach,nativeMap,nativeReduce,nativeReduceRight,nativeFilter,nativeEvery,nativeSome,nativeIndexOf,nativeLastIndexOf,nativeIsArray,nativeKeys,nativeBind,_,each;
+  var root, breaker, previousUnderscore, ArrayProto, ObjProto, FuncProto, push, slice, concat, toString, hasOwnProperty, nativeForEach, nativeMap, nativeReduce, nativeReduceRight, nativeFilter, nativeEvery, nativeSome, nativeIndexOf, nativeLastIndexOf, nativeIsArray, nativeKeys, nativeBind, _, each;
   root = this;
   breaker = {};
   previousUnderscore = root._;
@@ -26,16 +25,16 @@
   nativeKeys = Object.keys;
   nativeBind = FuncProto.bind;
   _ = function(obj) {
-    if( obj instanceof _) {
-       return obj;
+    if(obj instanceof _) {
+      return obj;
     };
-    if( ! ( this instanceof _)) {
-       return  new _(obj);
+    if(! (this instanceof _)) {
+      return new _(obj);
     };
-    this._wrapped = obj;
+    return this._wrapped = obj;
   };
-  if( typeof  exports !== 'undefined') {
-    if( typeof  root.module !==  'undefined' && root.module.exports) {
+  if(typeof exports !== 'undefined') {
+    if(typeof root.module !== 'undefined' && root.module.exports) {
       exports = root.module.exports = _;
     };
     exports._ = _;
@@ -43,46 +42,44 @@
     root._ = _;
   };
   _.VERSION = "1.6.0";
-  each = _.each = _.forEach = function(obj,iterator,context) {
-
-    var i,length,keys;
-    if( obj ===  null ) {
-       return obj;
+  each = _.each = _.forEach = function(obj, iterator, context) {
+    var i, length, keys;
+    if(obj === null) {
+      return obj;
     };
-    if( nativeForEach &&  obj.forEach === nativeForEach) {
-      obj.forEach(iterator,context);
-    }else if( obj.length === (+obj.length)) {
+    if(nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, context);
+    }else if(obj.length === (+obj.length)) {
       i = 0;
       length = obj.length;
-      for(i = 0; i < length;i++) {
-      if( iterator.call(context,obj[i],i,obj) === breaker) {
-         return  null ;
-      };
+      for(i = 0; i < length; i++) {
+        if(iterator.call(context, obj[i], i, obj) === breaker) {
+          return null;
+        };
       };
     } else {
       keys = _.keys(obj);
       length = keys.length;
-      for(i = 0; i < length;i++) {
-      if( iterator.call(context,obj[keys[i]],keys[i],obj) === breaker) {
-         return  null ;
-      };
+      for(i = 0; i < length; i++) {
+        if(iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) {
+          return null;
+        };
       };
     };
-     return obj;
+    return obj;
   };
-  _.map = _.collect = function(obj,iterator,context) {
-
+  return _.map = _.collect = function(obj, iterator, context) {
     var results;
     results = [];
-    if( obj ==  null ) {
-       return results;
+    if(obj == null) {
+      return results;
     };
-    if( nativeMap &&  obj.map === nativeMap) {
-       return obj.map(iterator,context);
+    if(nativeMap && obj.map === nativeMap) {
+      return obj.map(iterator, context);
     };
-    each(obj,function(value,index,list) {
-      results.push(iterator.call(context,value,index,list));
+    each(obj, function(value, index, list) {
+      return results.push(iterator.call(context, value, index, list));
     });
-     return results;
+    return results;
   };
 }).call();

data/spec/fixtures/underscore.liq

@@ -1,6 +1,6 @@
 (-> {
 
-  #! allow Array Object Function
+  ![ allow Array Object Function ]
 
   root               = this
   breaker            = {}
@@ -32,7 +32,7 @@
 
   _ = (obj)-> {
     if(obj instanceof _) {
-      return obj
+       obj
     }
     if(!(this instanceof _)) {
       return new _(obj)

data/spec/liquidscript/compiler/icr_spec.rb

@@ -143,36 +143,26 @@ describe Compiler::ICR do
 
   describe "invalid directives" do
     let(:scanner) do
-      scanner = double("scanner")
-      iterator = double("iterator")
-      allow(iterator).to receive(:rewind)
-
-      expect(scanner).to receive(:each).once.and_return(iterator)
-      expect(scanner).to receive(:metadata).twice.and_return(
-        {:directives =>
-          [{:command => "test", :args => ""},
-           {:command => "allow", :args => "test"}]})
-      scanner
+      s = Liquidscript::Scanner::Liquidscript.new(
+        ":[test thing]\n:[allow thing]\n")
+      s.scan
+      s
     end
 
     it "raises an error" do
-      expect { subject }.to raise_error(Liquidscript::UnknownDirectiveError)
+      expect { subject.compile }.to raise_error(Liquidscript::UnknownDirectiveError)
     end
   end
 
   describe "directives" do
     let(:scanner) do
-      scanner = double("scanner")
-      iterator = double("iterator")
-      allow(iterator).to receive(:rewind)
-
-      expect(scanner).to receive(:each).once.and_return(iterator)
-      expect(scanner).to receive(:metadata).twice.and_return(
-        {:directives => [{:command => "allow", :args => "test"}]})
-      scanner
+      s = Liquidscript::Scanner::Liquidscript.new(":[allow test]\n")
+      s.scan
+      s
     end
 
     it "raises an error" do
+      subject.compile
       subject.top.context.get(:test)
     end
   end

data/spec/liquidscript/scanner/lexer_spec.rb

@@ -45,7 +45,7 @@ describe Liquidscript::Scanner::Liquidscript, :lexer_helper do
 
     it "scans keywords" do
       scan("return test = new foo").should eq [
-        [:preunop, "return"],
+        [:return, nil],
         [:identifier, "test"],
         [:equal, nil],
         [:preunop, "new"],
@@ -75,8 +75,8 @@ describe Liquidscript::Scanner::Liquidscript, :lexer_helper do
     end
 
     describe "scanning directives" do
-      subject { c = described_class.new("#! test thing\n"); c.scan; c }
-      its(:metadata) { should eq :directives => [{:command => "test", :args => "thing"}] }
+      subject { c = described_class.new("![ test thing ]\n"); c.scan; c }
+      its(:tokens) { should eq [[:directive, ["test", "thing"]]] }
     end
   end
 end

data/spec/support/matchers/compile.rb

@@ -32,7 +32,11 @@ RSpec::Matchers.define :compile do
   end
 
   def actual
-    (@_out || []).to_a!
+    if @_out.respond_to?(:to_a!)
+      @_out.to_a!
+    else
+      @_out
+    end
   end
 
   def compiler(data)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: liquidscript
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.11.0.rc1
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-15 00:00:00.000000000 Z
+date: 2014-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -137,6 +137,7 @@ files:
 - lib/liquidscript/compiler/base/helpers.rb
 - lib/liquidscript/compiler/icr.rb
 - lib/liquidscript/compiler/icr/classes.rb
+- lib/liquidscript/compiler/icr/directives.rb
 - lib/liquidscript/compiler/icr/expressions.rb
 - lib/liquidscript/compiler/icr/functions.rb
 - lib/liquidscript/compiler/icr/groups.rb
@@ -228,9 +229,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2