liquor 0.1.1 → 0.9.1

data/spec/function_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe Liquor::Function do
+  it "allows to define a function" do
+    fun = Liquor::Function.new("test",
+          unnamed_arg: :integer,
+          mandatory_named_args: { test: :any, add: :integer },
+          optional_named_args:  { once_more: :any }) do |arg, kw|
+      arg + kw[:add]
+    end
+    fun.unnamed_arg.should == :integer
+    fun.optional_named_args.should == { once_more: :any }
+    fun.call(1, add: 2).should == 3
+  end
+
+  it "requires a body" do
+    expect {
+      Liquor::Function.new("test")
+    }.to raise_error
+  end
+
+  it "checks types" do
+    fun = Liquor::Function.new("test",
+          unnamed_arg: [:string, :tuple],
+          optional_named_args: { some: :integer, other: :any }) do |arg, kw|
+      # nothing
+    end
+
+    expect { fun.call("a") }.not_to raise_error
+    expect { fun.call([1]) }.not_to raise_error
+    expect { fun.call(1)   }.to raise_error(Liquor::ArgumentTypeError)
+    expect { fun.call("a", some: "A") }.to raise_error(Liquor::ArgumentTypeError)
+    expect { fun.call("a", other: 1)  }.not_to raise_error
+    expect { fun.call("a", other: Class) }.to raise_error(Liquor::ArgumentTypeError)
+  end
+
+  it "accepts an indexable external as a tuple" do
+    fun = Liquor::Function.new("test",
+          unnamed_arg: [:tuple]) do |arg, kw|
+      # nothing
+    end
+
+    ext = Class.new do
+      include Liquor::External
+
+      def [](index); end
+      def size; 0;   end
+      def to_a; [];  end
+
+      export :[], :size, :to_a
+    end
+
+    ext2 = Class.new do
+      include Liquor::External
+
+      def nothing; end
+
+      export :nothing
+    end
+
+    expect { fun.call(ext.new) }.not_to raise_error
+    expect { fun.call(ext2.new) }.to raise_error(Liquor::ArgumentTypeError)
+  end
+
+  it "catches host errors" do
+    fun = Liquor::Function.new("test") do |arg, kw|
+      "".to_hash
+    end
+
+    expect { fun.call() }.to raise_error(Liquor::HostError)
+  end
+
+  it "provides loc to the inside of functions" do
+    fun = Liquor::Function.new("whereami") do |arg, kw, loc|
+      loc.to_s
+    end
+
+    fun.call(nil, {}, {rabbit: 'hole'}).should == '{:rabbit=>"hole"}'
+  end
+end

data/spec/lexer_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Liquor::Lexer do
+  it "parses plaintext" do
+    lex("abc\ndef").should have_token_structure(
+      [:plaintext, "abc\ndef"]
+    )
+  end
+
+  it "parses plaintext with braces" do
+    lex('abc { def').should have_token_structure( [:plaintext] )
+    lex('abc \{ def').should have_token_structure( [:plaintext] )
+    lex('abc \{% def').should have_token_structure( [:plaintext] )
+    lex('abc \{{\{% def').should have_token_structure( [:plaintext] )
+  end
+
+  it "parses comments" do
+    lex('abc {! def !} test').should have_token_structure(
+      [:plaintext, 'abc '],
+      [:plaintext, ' test']
+    )
+    lex('abc {! {% test %} !} test').should have_token_structure(
+      [:plaintext, 'abc '],
+      [:plaintext, ' test']
+    )
+    lex('abc {! {{ def }} !} test').should have_token_structure(
+      [:plaintext, 'abc '],
+      [:plaintext, ' test']
+    )
+    lex('abc {! test {! a !} b !} def').should have_token_structure(
+      [:plaintext, 'abc '],
+      [:plaintext, ' def'],
+    )
+  end
+
+  it "parses blocks and interpolations" do
+    lex('abc {{ def }}').should have_token_structure(
+      [:plaintext],
+      [:linterp],
+      [:ident],
+      [:rinterp],
+    )
+    lex('abc {% def %}').should have_token_structure(
+      [:plaintext],
+      [:lblock],
+      [:ident],
+      [:rblock],
+    )
+  end
+
+  it "fails on nested blocks and interpolations" do
+    expect { lex('abc {{ def {{') }.to raise_error(Liquor::SyntaxError, %r|unexpected `{'|)
+    expect { lex('abc {{ def {%') }.to raise_error(Liquor::SyntaxError, %r|unexpected `{'|)
+    expect { lex('abc {% def {{') }.to raise_error(Liquor::SyntaxError, %r|unexpected `{'|)
+    expect { lex('abc {% def {%') }.to raise_error(Liquor::SyntaxError, %r|unexpected `{'|)
+  end
+
+  it "fails on unrecognized symbols" do
+    expect { lex('abc {{ # }}') }.to raise_error(Liquor::SyntaxError, %r|unexpected `#'|)
+  end
+
+  it "fails invalid integer literals the correct way" do
+    expect { lex('{{ 1a }}') }.to raise_error(Liquor::SyntaxError, %r|unexpected `a'|)
+  end
+
+  it "parses complex expressions" do
+    lex('{{ 1 * 2 + substr("abc" from: 1 to: 10 via: an.external) }}').should have_token_structure(
+      [:linterp],
+      [:integer, 1], [:op_mul], [:integer, 2], [:op_plus],
+      [:ident], [:lparen],
+      [:string, "abc"],
+      [:keyword, "from"], [:integer, 1],
+      [:keyword, "to"],   [:integer, 10],
+      [:keyword, "via"],  [:ident, "an"], [:dot], [:ident, "external"],
+      [:rparen],
+      [:rinterp],
+    )
+  end
+
+  it "parses blocks with embedded blocks" do
+    lex('{% for x in: [ 1, 2, q ] do: %} value: {{ x }} {% end for %}').should have_token_structure(
+      [:lblock],
+      [:ident, "for"], [:ident, "x"],
+      [:keyword, "in"],
+      [:lbracket], [:integer, 1], [:comma], [:integer, 2], [:comma], [:ident, "q"], [:rbracket],
+      [:keyword, "do"],
+      [:rblock],
+      [:plaintext],
+      [:linterp], [:ident], [:rinterp],
+      [:plaintext],
+      [:lblock2], [:endtag], [:rblock],
+    )
+  end
+
+  it "fails on multiline blocks and interpolations" do
+    expect { lex("{{ \n }}") }.to raise_error(Liquor::SyntaxError, %r|unexpected end of line|)
+    expect { lex("{% \n %}") }.to raise_error(Liquor::SyntaxError, %r|unexpected end of line|)
+  end
+
+  it "parses complex string literals" do
+    lex('{{ "abc" + "def" }}').should have_token_structure(
+      [:linterp],
+      [:string, "abc"],
+      [:op_plus],
+      [:string, "def"],
+      [:rinterp]
+    )
+
+    expect { lex(%|{{ "test }}|) }.to raise_error(Liquor::SyntaxError, %r|literal not terminated|)
+    expect { lex(%|{{ "test\\" }}|) }.to raise_error(Liquor::SyntaxError, %r|literal not terminated|)
+    expect { lex(%|{{ "test\\\\" }}|) }.not_to raise_error
+
+    expect { lex(%|{{ 'test }}|) }.to raise_error(Liquor::SyntaxError, %r|literal not terminated|)
+    expect { lex(%|{{ 'test\\' }}|) }.to raise_error(Liquor::SyntaxError, %r|literal not terminated|)
+    expect { lex(%|{{ 'test\\\\' }}|) }.not_to raise_error
+
+    lex(%|{{ "test ' \\'" }}|).should have_token_structure(
+      [:linterp], [:string, %|test ' \\'|], [:rinterp]
+    )
+    lex(%|{{ 'test " \\'' }}|).should have_token_structure(
+      [:linterp], [:string, %|test " '|], [:rinterp]
+    )
+
+    expect { lex(%|{{ "test\n" }}|) }.to raise_error(Liquor::SyntaxError, %r|unexpected end of line|)
+  end
+
+  it "parses nested tags correctly" do
+    lex('{% a do: %} 1 {% b %} 2 {% c do: %} 3 {% end c %} 4 {% end a %} 5 {% ender %}').
+            should have_token_structure(
+      [:lblock], [:ident, "a"], [:keyword, "do"], [:rblock],
+      [:plaintext, " 1 "],
+      [:lblock], [:ident, "b"], [:rblock],
+      [:plaintext, " 2 "],
+      [:lblock], [:ident, "c"], [:keyword, "do"], [:rblock],
+      [:plaintext, " 3 "],
+      [:lblock2], [:endtag], [:rblock],
+      [:plaintext, " 4 "],
+      [:lblock2], [:endtag], [:rblock],
+      [:plaintext, " 5 "],
+      [:lblock], [:ident, "ender"], [:rblock],
+    )
+    lex('{% capture do: %}{% if a then: %} 1 {% elsif: b then: %} 2 {% end if %}{% end capture %}').
+            should have_token_structure(
+      [:lblock], [:ident, "capture"], [:keyword, "do"], [:rblock],
+      [:lblock], [:ident, "if"], [:ident, "a"], [:keyword, "then"], [:rblock],
+      [:plaintext, " 1 "],
+      [:lblock2], [:keyword, "elsif"], [:ident, "b"], [:keyword, "then"], [:rblock],
+      [:plaintext, " 2 "],
+      [:lblock2], [:endtag], [:rblock],
+      [:lblock2], [:endtag], [:rblock],
+    )
+  end
+
+  it "understands syntactic sugar for =" do
+    lex('{% assign x = 1 %}').should have_token_structure(
+      [:lblock], [:ident, "assign"], [:ident, "x"], [:keyword, "="], [:integer, 1], [:rblock]
+    )
+  end
+
+  it "fails unmatched end tag" do
+    expect { lex('{% end tag %}') }.to raise_error(Liquor::SyntaxError)
+    expect { lex('{% unless x then: %} {% end for %}') }.to raise_error(Liquor::SyntaxError)
+  end
+
+  it "correctly fails on complex runaway strings" do
+    expect {
+      lex(%Q${% for artist in: list do: %}
+             {% end 'for %}
+             #{"      \n" * 800}
+             '220x$)
+    }.to raise_error(Liquor::SyntaxError, %r|unexpected end of line .+?: line 2, column 28|)
+  end
+end

data/spec/library_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Liquor::Library do
+  it "allows to define a function and export it to a compiler" do
+    lib = Module.new do
+      include Liquor::Library
+
+      function "hello" do |arg, kw|
+        "hello world"
+      end
+    end
+
+    compiler = Liquor::Compiler.new
+    lib.export compiler
+    compiler.compile parse('{{ hello() }}')
+    compiler.code.call.should == 'hello world'
+  end
+end

data/spec/manager_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Liquor::Manager do
+  before do
+    @manager = Liquor::Manager.new
+  end
+
+  it "should be able to compile templates" do
+    @manager.register_template 'test', '{{ i }}', [:i]
+    @manager.compile.should be_true
+
+    @manager.render('test', i: 10).should == '10'
+  end
+
+  it "should decorate errors" do
+    @manager.register_template 'test', '{{ }}', [:i]
+    @manager.compile.should be_false
+
+    @manager.errors.count.should == 1
+    error = @manager.errors.first
+
+    @manager.decorate(error).should == [
+      "{{ }}",
+      "   ^^"
+    ]
+  end
+
+  it "should check names for correctness" do
+    expect {
+      @manager.register_template '_test', '{{ i }}', [:i]
+    }.to raise_error ArgumentError, %r|is a partial|
+    expect {
+      @manager.register_partial 'test', '{{ i }}'
+    }.to raise_error ArgumentError, %r|is not a partial|
+  end
+
+  it "should report presence of templates" do
+    @manager.register_template 'test', '{{ i }}', [:i]
+    @manager.compile.should be_true
+
+    @manager.has_template?('test').should be_true
+    @manager.has_template?('foo').should be_false
+  end
+
+  it "should render layouts" do
+    @manager.register_layout 'layout', '{% yield "head" %} 1 {% yield %}'
+    @manager.register_template 'action', '{% content_for "head" capture: %} 2 {% end content_for %} 3'
+    @manager.compile.should be_true
+
+    @manager.render_with_layout('layout', {}, 'action', {}).
+          scan(/\d+/).should == %w(2 1 3)
+  end
+
+  it "exports libraries to compiler" do
+    lib = Module.new do
+      include Liquor::Library
+
+      function "hello" do |arg, kw|
+        "world"
+      end
+    end
+
+    manager = Liquor::Manager.new(import: [lib])
+    manager.register_template 'test', '{{ hello() }}'
+    manager.compile.should be_true
+
+    manager.render('test').should == 'world'
+  end
+
+  it "dumps debug code" do
+    require 'tmpdir'
+
+    Dir.mktmpdir do |code_dir|
+      manager = Liquor::Manager.new(dump_intermediates: code_dir)
+      manager.register_template 'test', '{{ "hello world" }}'
+      manager.compile.should be_true
+
+      path = File.join(code_dir, 'test.liquor.rb')
+
+      File.exists?(path).should be_true
+      File.read(path).include?('hello world').should be_true
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,381 @@
+#coding:utf-8
+
+require 'spec_helper'
+
+describe Liquor::Parser do
+  it "parses plaintext" do
+    parse("abc\ndef").should have_node_structure(
+      [:plaintext, "abc\ndef"]
+    )
+  end
+
+  it "recognizes interpolations" do
+    parse("a {{ 1 + a }} b").should have_node_structure(
+      [:plaintext, "a "],
+      [:interp,
+        [:plus,
+          [:integer, 1],
+          [:ident, "a"]]],
+      [:plaintext, " b"],
+    )
+  end
+
+  it "fails on incorrect syntax" do
+    expect { parse("{{ }}") }.to raise_error(Liquor::SyntaxError, %r|unexpected token `}}'|)
+    expect { parse("{{ 1 %}") }.to raise_error(Liquor::SyntaxError, %r|unexpected token `%}'|)
+    expect { parse("{{ -2] }}") }.to raise_error(Liquor::SyntaxError, %r|unexpected token `\]'|)
+    expect { parse("{{ a[2 }}") }.to raise_error(Liquor::SyntaxError, %r|unexpected token `}}'|)
+    expect { parse("{{ a && (b || ) }}") }.to raise_error(Liquor::SyntaxError, %r|unexpected token `\)'|)
+  end
+
+  it "obeys operator precedence" do
+    parse('{{ 1 + 2 * 3 }}').should have_node_structure(
+      [:interp,
+        [:plus,
+          [:integer, 1],
+          [:mul,
+            [:integer, 2],
+            [:integer, 3]]]]
+    )
+    parse('{{ a && b || c && d }}').should have_node_structure(
+      [:interp,
+        [:or,
+          [:and, [:ident, "a"], [:ident, "b"]],
+          [:and, [:ident, "c"], [:ident, "d"]]]]
+    )
+    parse('{{ a || b && c || d }}').should have_node_structure(
+      [:interp,
+        [:or,
+          [:or,
+            [:ident, "a"],
+            [:and, [:ident, "b"], [:ident, "c"]]],
+          [:ident, "d"]]]
+    )
+    parse('{{ !x && x }}').should have_node_structure(
+      [:interp,
+        [:and,
+          [:not,
+            [:ident, "x"]],
+          [:ident, "x"]]]
+    )
+    expect {
+      exec(%|{% for x in: [1,2,3] do: %}{% if !x_loop.is_first then: %}y{% end if %}{% end for %}|)
+    }.not_to raise_error
+  end
+
+  it "changes evaluation order due to parentheses" do
+    parse('{{ a && (b || c) }}').should have_node_structure(
+      [:interp,
+        [:and,
+          [:ident, "a"],
+          [:or, [:ident, "b"], [:ident, "c"]]]]
+    )
+  end
+
+  it "recognizes every operator" do
+    expect { parse('{{ fun(a: 1 + 2 * 3 / 4 % 5 - 6 ' +
+        ' b: !(a && b || c) c: (1 >= 2) || 1 < 2 || ' +
+        'a != b || b == c || 5 <= 6 || 7 > 8 ' +
+        'd: e.f e: ([1,2])[0] ) }}') }.not_to raise_error
+
+    parse('{{ 2 - -1 }}').should have_node_structure(
+      [:interp,
+        [:minus,
+          [:integer, 2],
+          [:uminus, [:integer, 1]]]]
+    )
+    parse('{{ -1 }}').should have_node_structure(
+      [:interp,
+        [:uminus, [:integer, 1]]]
+    )
+  end
+
+  it "accepts correct tuples" do
+    parse('{{ [] }}').should have_node_structure(
+      [:interp,
+        [:tuple, []]]
+    )
+    parse('{{ [1] }}').should have_node_structure(
+      [:interp,
+        [:tuple, [ [:integer, 1] ]]]
+    )
+    parse('{{ [1,] }}').should have_node_structure(
+      [:interp,
+        [:tuple, [ [:integer, 1] ]]]
+    )
+    parse('{{ [1,2] }}').should have_node_structure(
+      [:interp,
+        [:tuple, [ [:integer, 1], [:integer, 2] ]]]
+    )
+    parse('{{ [1,2,] }}').should have_node_structure(
+      [:interp,
+        [:tuple, [ [:integer, 1], [:integer, 2] ]]]
+    )
+  end
+
+  it "accepts correct method calls" do
+    parse('{{ a() }}').should have_node_structure(
+      [:interp,
+        [:call,
+          [:ident, "a"],
+          [:args, nil, {}]]]
+    )
+    parse('{{ a("str") }}').should have_node_structure(
+      [:interp,
+        [:call,
+          [:ident, "a"],
+          [:args, [:string, "str"], {}]]]
+    )
+    parse('{{ a("str" from: 1) }}').should have_node_structure(
+      [:interp,
+        [:call,
+          [:ident, "a"],
+          [:args, [:string, "str"],
+                  {:from => [:integer, 1]}]]]
+    )
+    parse('{{ a(from: 1 to: 2) }}').should have_node_structure(
+      [:interp,
+        [:call,
+          [:ident, "a"],
+          [:args, nil,
+                  {:from => [:integer, 1],
+                   :to   => [:integer, 2]}]]]
+    )
+  end
+
+  it "rejects method calls with duplicate keyword arguments" do
+    expect { parse('{{ a(to: 1 to: 1) }}') }.to \
+                raise_error(Liquor::SyntaxError, %r|duplicate keyword argument `to'|)
+  end
+
+  it "accepts correct filter expressions" do
+    parse('{{ a | b }}').should have_node_structure(
+      [:interp,
+        [:call,
+          [:ident, "b"],
+          [:args,
+            [:ident, "a"],
+            {}]]]
+    )
+    parse('{{ a(x: 1) | b y: 2 z: 3 | c p: 4 }}').should have_node_structure(
+      [:interp,
+        [:call,
+          [:ident, "c"],
+          [:args,
+            [:call,
+              [:ident, "b"],
+              [:args,
+                [:call,
+                  [:ident, "a"],
+                  [:args,
+                    nil,
+                    { :x => [:integer, 1] }]],
+                { :y => [:integer, 2],
+                  :z => [:integer, 3] }]],
+            { :p => [:integer, 4] }]]]
+    )
+  end
+
+  it "rejects malformed filter expressions" do
+    expect { parse('{{ a b: 1 }}') }.to raise_error(Liquor::SyntaxError)
+    expect { parse('{{ a("str", b: 1) | b ') }.to raise_error(Liquor::SyntaxError, %r{unexpected token `|'})
+    expect { parse('{{ a | b(b: 1)') }.to raise_error(Liquor::SyntaxError, %r{unexpected token `\('})
+    expect { parse('{{ a | b("str", b: 1)') }.to raise_error(Liquor::SyntaxError, %r{unexpected token `\('})
+  end
+
+  it "parses blocks correctly" do
+    parse('{% yield %}').should have_node_structure(
+      [:tag,
+        [:ident, "yield"],
+        nil]
+    )
+    parse('{% yield 1 %}').should have_node_structure(
+      [:tag,
+        [:ident, "yield"],
+        [:integer, 1]]
+    )
+    parse('{% yield from: 1 %}').should have_node_structure(
+      [:tag,
+        [:ident, "yield"],
+        nil,
+        [:kwarg, [:keyword, "from"], [:integer, 1]]]
+    )
+    parse('{% yield "str" from: 1 %}').should have_node_structure(
+      [:tag,
+        [:ident, "yield"],
+        [:string, "str"],
+        [:kwarg, [:keyword, "from"], [:integer, 1]]]
+    )
+    parse('{% yield from: 1 to: 2 from: 3 %}').should have_node_structure(
+      [:tag,
+        [:ident, "yield"],
+        nil,
+        [:kwarg, [:keyword, "from" ], [:integer, 1]],
+        [:kwarg, [:keyword, "to" ],   [:integer, 2]],
+        [:kwarg, [:keyword, "from" ], [:integer, 3]]]
+    )
+    parse('{% capture do: %} 1 {% end capture %}').
+              should have_node_structure(
+      [:tag,
+        [:ident, "capture"],
+        nil,
+        [:blockarg, [:keyword, "do"],
+          [
+            [:plaintext, " 1 "]
+          ]]]
+    )
+    parse('{% capture "test" do: %} 1 {% end capture %}').
+              should have_node_structure(
+      [:tag,
+        [:ident, "capture"],
+        [:string, "test"],
+        [:blockarg, [:keyword, "do"],
+          [
+            [:plaintext, " 1 "]
+          ]]]
+    )
+    parse('{% capture as: "test" do: %} 1 {% end capture %}').
+              should have_node_structure(
+      [:tag,
+        [:ident, "capture"],
+        nil,
+        [:kwarg, [:keyword, "as"], [:string, "test"]],
+        [:blockarg, [:keyword, "do"],
+          [
+            [:plaintext, " 1 "]
+          ]]]
+    )
+    parse('{% if a1 then: %} 1 {% elsif: a2 then: %} 2 {% else: %} 3 {% end if %}').
+              should have_node_structure(
+      [:tag,
+        [:ident, "if"],
+        [:ident, "a1"],
+        [:blockarg, [:keyword, "then"],
+          [[:plaintext, " 1 "]]],
+        [:kwarg, [:keyword, "elsif"], [:ident, "a2"]],
+        [:blockarg, [:keyword, "then"],
+          [[:plaintext, " 2 "]]],
+        [:blockarg, [:keyword, "else"],
+          [[:plaintext, " 3 "]]]]
+    )
+  end
+
+  it "reports EOF errors" do
+    expect { parse('{% if a1 then: %} 1 {% wat %}') }.to raise_error(Liquor::SyntaxError, %r|unexpected end of program|)
+  end
+
+  it "handles lexer errors" do
+    parser = Liquor::Parser.new
+    parser.parse '{{ $'
+    parser.success?.should == false
+    parser.ast.should == nil
+  end
+
+  it "correctly handles multiple errors" do
+    parser = Liquor::Parser.new
+    parser.parse '{{ fun(a: 1 a: 1) + fun(b: 1 b: 1) }}'
+    parser.errors.count.should == 2
+    parser.ast.should_not == nil
+  end
+
+  it "resets error state on next parse" do
+    parser = Liquor::Parser.new
+    parser.parse '{{ fun(a: 1 a: 1) + fun(b: 1 b: 1) }}'
+    parser.errors.count.should == 2
+    parser.parse '{{ 1 }}'
+    parser.errors.count.should == 0
+    parser.success?.should == true
+  end
+
+  it "correctly handles empty blocks" do
+    parse('{% tag do: %}{% end tag %}').should have_node_structure(
+      [:tag,
+        [:ident, 'tag'],
+        nil,
+        [:blockarg,
+          [:keyword, 'do'],
+          []]]
+    )
+  end
+
+  it "understands various constructs for externals" do
+    parse('{{ ext.test }}').should have_node_structure(
+      [:interp,
+        [:external,
+          [:ident, "ext"],
+          [:ident, "test"],
+          nil]]
+    )
+    parse('{{ ext.test() }}').should have_node_structure(
+      [:interp,
+        [:external,
+          [:ident, "ext"],
+          [:ident, "test"],
+          [:args,
+            nil,
+            {}]]]
+    )
+    parse('{{ a.b.c }}').should have_node_structure(
+      [:interp,
+        [:external,
+          [:external,
+            [:ident, "a"],
+            [:ident, "b"],
+            nil
+          ],
+          [:ident, "c"],
+          nil]]
+    )
+    parse('{{ a.b().c }}').should have_node_structure(
+      [:interp,
+        [:external,
+          [:external,
+            [:ident, "a"],
+            [:ident, "b"],
+            [:args,
+              nil,
+              {}]
+          ],
+          [:ident, "c"],
+          nil]]
+    )
+    parse('{{ a.b[0] }}').should have_node_structure(
+      [:interp,
+        [:index,
+          [:external,
+            [:ident, "a"],
+            [:ident, "b"],
+            nil,
+          ],
+          [:integer, 0]]]
+    )
+  end
+
+  it "does not allow duplicate kwargs for external calls" do
+    expect { parse('{{ ext.call(kw: 1 kw: 2) }}') }.to raise_error(Liquor::SyntaxError, %r|duplicate keyword argument|)
+  end
+
+  it "does not want {% end elsif %}" do
+    expect {
+      compiler = Liquor::Compiler.new
+      parse %|
+        {% if !is_empty(clip_videos) then: %}
+          {% assign current_video = clip_videos[0] %}
+        {% elsif !is_empty(live_videos) then: %}
+        {% elsif: !is_empty(live_videos) then: %}
+        {% elsif !is_empty(live_videos) then: %}
+        {% end if %}
+      |, compiler
+    }.not_to raise_error
+  end
+
+  it "reports correct line numbers" do
+    expect {
+      parse("{\n%\n{% end if %}")
+    }.to raise_error(Liquor::SyntaxError, /line 3/)
+  end
+
+  it "does not return nil for empty string input" do
+    parse("").should_not == nil
+  end
+end