flavour_saver 4.0.2 → 5.0.0

data/spec/lib/flavour_saver/parser_spec.rb

@@ -1,104 +1,100 @@
-require 'flavour_saver/parser'
-require 'flavour_saver/lexer'
+require "flavour_saver/parser"
+require "flavour_saver/lexer"
 
 describe FlavourSaver::Parser do
-  let (:items) { subject.items }
+  let(:items) { subject.items }
 
-  it 'is a RLTK::Parser' do
-    expect(subject).to be_a(RLTK::Parser)
-  end
-
-  describe 'HTML template' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('<html><h1>Hello world!</h1></html>')) }
+  describe "HTML template" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("<html><h1>Hello world!</h1></html>")) }
 
-    it 'is an output node' do
+    it "is an output node" do
       expect(items.first).to be_a(FlavourSaver::OutputNode)
     end
 
-    it 'has the correct contents' do
-      expect(items.first.value).to eq '<html><h1>Hello world!</h1></html>'
+    it "has the correct contents" do
+      expect(items.first.value).to eq "<html><h1>Hello world!</h1></html>"
     end
   end
 
-  describe 'HTML template containing a handlebars expression' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('<html>{{foo}}</html>')) }
+  describe "HTML template containing a handlebars expression" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("<html>{{foo}}</html>")) }
 
-    it 'has template output either side of the expression' do
+    it "has template output either side of the expression" do
       expect(items.map(&:class)).to eq [FlavourSaver::OutputNode, FlavourSaver::ExpressionNode, FlavourSaver::OutputNode]
     end
   end
 
-  describe '{{foo}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo}}')) }
+  describe "{{foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{foo}}")) }
 
-    it 'contains an expression node' do
+    it "contains an expression node" do
       expect(items.first).to be_a(FlavourSaver::ExpressionNode)
     end
 
     it 'calls the method "foo" with no arguments' do
       expect(items.first.method).to be_one
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments).to be_empty
     end
   end
 
-  describe '{{foo.bar}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo.bar}}')) }
+  describe "{{foo.bar}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{foo.bar}}")) }
 
-    it 'calls two methods' do
+    it "calls two methods" do
       expect(items.first.method.size).to eq 2
     end
 
     it 'calls the method "foo" with no arguments first' do
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments).to be_empty
     end
 
     it 'calls the method "bar" with no arguments second' do
       expect(items.first.method[1]).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method[1].name).to eq 'bar'
+      expect(items.first.method[1].name).to eq "bar"
       expect(items.first.method[1].arguments).to be_empty
     end
   end
 
-  describe '{{foo.[&@^$*].bar}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo.[&@^$*].bar}}')) }
+  describe "{{foo.[&@^$*].bar}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{foo.[&@^$*].bar}}")) }
 
-    it 'calls three methods' do
+    it "calls three methods" do
       expect(items.first.method.size).to eq 3
     end
 
     it 'calls the method "foo" with no arguments first' do
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments).to be_empty
     end
 
     it 'calls the method "&@^$*" with no arguments second' do
       expect(items.first.method[1]).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method[1].name).to eq '&@^$*'
+      expect(items.first.method[1].name).to eq "&@^$*"
       expect(items.first.method[1].arguments).to be_empty
     end
 
     it 'calls the method "bar" with no arguments third' do
       expect(items.first.method[2]).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method[2].name).to eq 'bar'
+      expect(items.first.method[2].name).to eq "bar"
       expect(items.first.method[2].arguments).to be_empty
     end
   end
 
-  describe '{{foo bar}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo bar}}')) }
+  describe "{{foo bar}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{foo bar}}")) }
 
     it 'calls the method "foo" with a method argument of "bar"' do
       expect(items.first.method).to be_one
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments).to be_one
       expect(items.first.method.first.arguments.first.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.arguments.first.first.name).to eq 'bar'
+      expect(items.first.method.first.arguments.first.first.name).to eq "bar"
     end
   end
 
@@ -108,10 +104,10 @@ describe FlavourSaver::Parser do
     it 'calls the method "foo" with a string argument of "bar"' do
       expect(items.first.method).to be_one
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments).to be_one
       expect(items.first.method.first.arguments.first).to be_a(FlavourSaver::StringNode)
-      expect(items.first.method.first.arguments.first.value).to eq 'bar'
+      expect(items.first.method.first.arguments.first.value).to eq "bar"
     end
   end
 
@@ -121,23 +117,23 @@ describe FlavourSaver::Parser do
     it 'calls the method "foo"' do
       expect(items.first.method).to be_one
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
     end
 
-    describe 'with arguments' do
+    describe "with arguments" do
       subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo    bar  "baz" }}')).items.first.method.first.arguments }
 
-      describe '[0]' do
+      describe "[0]" do
         it 'is the method call "bar" with no arguments' do
           expect(subject.first.first).to be_a(FlavourSaver::CallNode)
-          expect(subject.first.first.name).to eq 'bar'
+          expect(subject.first.first.name).to eq "bar"
         end
       end
 
-      describe '[1]' do
+      describe "[1]" do
         it 'is the string "baz"' do
           expect(subject[1]).to be_a(FlavourSaver::StringNode)
-          expect(subject[1].value).to eq 'baz'
+          expect(subject[1].value).to eq "baz"
         end
       end
     end
@@ -149,19 +145,18 @@ describe FlavourSaver::Parser do
     it 'calls the method "foo"' do
       expect(items.first.method).to be_one
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
     end
 
-    describe 'with arguments' do
+    describe "with arguments" do
       subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo (bar "baz") }}')).items.first.method.first.arguments }
 
-      describe '[0]' do
-        it 'is a subexpression' do
+      describe "[0]" do
+        it "is a subexpression" do
           expect(subject.first.first).to be_a(FlavourSaver::CallNode)
-          expect(subject.first.first.name).to eq 'bar'
+          expect(subject.first.first.name).to eq "bar"
         end
       end
-
     end
   end
 
@@ -170,9 +165,9 @@ describe FlavourSaver::Parser do
 
     it 'calls the method "foo" with the hash {:bar => "baz"} as arguments' do
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments.first).to be_a(Hash)
-      expect(items.first.method.first.arguments.first).to eq({ :bar => FlavourSaver::StringNode.new('baz') })
+      expect(items.first.method.first.arguments.first).to eq({bar: FlavourSaver::StringNode.new("baz")})
     end
   end
 
@@ -181,7 +176,7 @@ describe FlavourSaver::Parser do
 
     it 'calls the method "foo" with the hash {:bar => (baz "qux")} as arguments' do
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments.first).to be_a(Hash)
       expect(items.first.method.first.arguments.first[:bar].first).to be_a(FlavourSaver::CallNode)
     end
@@ -196,9 +191,9 @@ describe FlavourSaver::Parser do
 
     it 'calls the method "foo" with the hash {:bar => 1} as arguments' do
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments.first).to be_a(Hash)
-      expect(items.first.method.first.arguments.first).to eq({ :bar => FlavourSaver::NumberNode.new('1') })
+      expect(items.first.method.first.arguments.first).to eq({bar: FlavourSaver::NumberNode.new("1")})
     end
   end
 
@@ -207,90 +202,98 @@ describe FlavourSaver::Parser do
 
     it 'calls the method "foo" with the hash {:bar => "baz", :fred => "wilma"} as arguments' do
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments.first).to be_a(Hash)
-      expect(items.first.method.first.arguments.first).to eq({ :bar => FlavourSaver::StringNode.new('baz'), :fred => FlavourSaver::StringNode.new('wilma') })
+      expect(items.first.method.first.arguments.first).to eq({bar: FlavourSaver::StringNode.new("baz"), fred: FlavourSaver::StringNode.new("wilma")})
     end
   end
 
   describe '{{foo bar="baz" fred "wilma"}}' do
     subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo bar="baz" fred "wilma"}}')) }
 
-    it 'raises an exception' do
-      expect { subject }.to raise_exception(RLTK::NotInLanguage)
+    it "raises an exception" do
+      expect { subject }.to raise_exception(FlavourSaver::Parser::NotInLanguage)
     end
   end
 
-  describe '{{{foo}}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{{foo}}}')) }
+  describe "{{{foo}}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{{foo}}}")) }
 
-    it 'returns a safe expression node' do
+    it "returns a safe expression node" do
       expect(items.first).to be_a(FlavourSaver::SafeExpressionNode)
     end
   end
 
-  describe '{{../foo}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{../foo}}')) }
+  describe "{{../foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{../foo}}")) }
 
-    it 'returns a parent call node' do
+    it "returns a parent call node" do
       expect(items.first.method.first).to be_a(FlavourSaver::ParentCallNode)
     end
   end
 
-  describe '{{! comment}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{! comment}}')) }
+  describe "{{! comment}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{! comment}}")) }
 
-    it 'returns a comment node' do
+    it "returns a comment node" do
       expect(items.first).to be_a(FlavourSaver::CommentNode)
     end
   end
 
-  describe '{{#foo}}hello{{/foo}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}hello{{/foo}}')) }
+  describe "{{#foo}}hello{{/foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{#foo}}hello{{/foo}}")) }
 
-    it 'has a block start and end' do
-      expect(items.map(&:class)).to eq [ FlavourSaver::BlockExpressionNode ]
+    it "has a block start and end" do
+      expect(items.map(&:class)).to eq [FlavourSaver::BlockExpressionNode]
     end
 
-    describe '#contents' do
-      it 'contains a single output node' do
+    describe "#contents" do
+      it "contains a single output node" do
         expect(items.first.contents.items.size).to eq 1
         expect(items.first.contents.items.first).to be_a(FlavourSaver::OutputNode)
-        expect(items.first.contents.items.first.value).to eq 'hello'
+        expect(items.first.contents.items.first.value).to eq "hello"
       end
     end
   end
 
-  describe '{{/foo}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{/foo}}')) }
+  describe "{{/foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{/foo}}")) }
+
+    it "raises a syntax error" do
+      expect { subject }.to raise_error(FlavourSaver::Parser::NotInLanguage)
+    end
 
-    it 'raises a syntax error' do
-      expect { subject }.to raise_error(RLTK::NotInLanguage)
+    it "is a FlavourSaver::Error" do
+      expect { subject }.to raise_error(FlavourSaver::Error)
     end
   end
 
-  describe '{{#foo}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}')) }
+  describe "{{#foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{#foo}}")) }
 
-    it 'raises a syntax error' do
-      expect { subject }.to raise_error(RLTK::NotInLanguage)
+    it "raises a syntax error" do
+      expect { subject }.to raise_error(FlavourSaver::Parser::NotInLanguage)
     end
   end
 
   describe "{{foo}}\n" do
     subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{foo}}\n")) }
 
-    it 'has a block start and end' do
-      expect(items.map(&:class)).to eq [ FlavourSaver::ExpressionNode, FlavourSaver::OutputNode ]
+    it "has a block start and end" do
+      expect(items.map(&:class)).to eq [FlavourSaver::ExpressionNode, FlavourSaver::OutputNode]
     end
   end
 
-  describe '{{#foo}}{{#bar}}{{/foo}}' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}{{#bar}}{{/foo}}')) }
+  describe "{{#foo}}{{#bar}}{{/foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{#foo}}{{#bar}}{{/foo}}")) }
 
-    it 'raises a syntax error' do
+    it "raises a syntax error" do
       expect { subject }.to raise_error(FlavourSaver::Parser::UnbalancedBlockError)
     end
+
+    it "is a FlavourSaver::Error" do
+      expect { subject }.to raise_error(FlavourSaver::Error)
+    end
   end
 
   describe "{{#foo}}\n{{/foo}}" do
@@ -302,12 +305,12 @@ describe FlavourSaver::Parser do
   end
 
   describe "{{#foo}}{#foo}}{{/foo}}{{/foo}}" do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}{{#foo}}{{/foo}}{{/foo}}')) }
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{#foo}}{{#foo}}{{/foo}}{{/foo}}")) }
 
-    describe 'the outer block' do
+    describe "the outer block" do
       let(:block) { subject.items.first }
 
-      it 'should contain another block' do
+      it "should contain another block" do
         expect(block.contents.items.size).to eq 1
         expect(block.contents.items.first).to be_a(FlavourSaver::BlockExpressionNode)
       end
@@ -329,10 +332,10 @@ describe FlavourSaver::Parser do
       expect { subject }.to_not raise_error
     end
   end
-  describe '' do
-    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('')) }
+  describe "" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("")) }
 
-    it 'returns an empty template' do
+    it "returns an empty template" do
       expect(items).to be_empty
     end
   end
@@ -340,11 +343,68 @@ describe FlavourSaver::Parser do
     subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo "bar" fred="wilma"}}')) }
     it 'calls the method "foo" with the "bar" and {:fred => "wilma"} as arguments' do
       expect(items.first.method.first).to be_a(FlavourSaver::CallNode)
-      expect(items.first.method.first.name).to eq 'foo'
+      expect(items.first.method.first.name).to eq "foo"
       expect(items.first.method.first.arguments.first).to be_a(FlavourSaver::StringNode)
-      expect(items.first.method.first.arguments.first.value).to eq 'bar'
+      expect(items.first.method.first.arguments.first.value).to eq "bar"
       expect(items.first.method.first.arguments.last).to be_a(Hash)
-      expect(items.first.method.first.arguments.last).to eq({ :fred => FlavourSaver::StringNode.new('wilma') })
+      expect(items.first.method.first.arguments.last).to eq({fred: FlavourSaver::StringNode.new("wilma")})
+    end
+  end
+  describe "{{^foo}}falsy{{else}}truthy{{/foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{^foo}}falsy{{else}}truthy{{/foo}}")) }
+
+    it "renders the {{else}} section when foo is truthy and the body when it is falsy" do
+      expect(items.first).to be_a(FlavourSaver::BlockExpressionNodeWithElse)
+      expect(items.first.contents.items.map(&:value)).to eq ["truthy"]
+      expect(items.first.alternate.items.map(&:value)).to eq ["falsy"]
+    end
+  end
+
+  describe "{{#foo bar}}{{/foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{#foo bar}}{{/foo}}")) }
+
+    it "links each call to the node that contains it" do
+      expect(items.first.method.first.parent).to eq items.first
+      expect(items.first.method.first.arguments.first.first.parent).to be_nil
+      expect(items.first.parent).to eq subject
+    end
+  end
+
+  describe "nesting depth" do
+    let(:max) { FlavourSaver::Parser::MAX_DEPTH }
+    let(:parse) { ->(template) { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex(template)) } }
+
+    def blocks(depth)
+      ("{{#foo}}" * depth) + ("{{/foo}}" * depth)
+    end
+
+    def subexpressions(depth)
+      "{{foo #{"(foo " * depth}bar#{")" * depth}}}"
+    end
+
+    it "allows blocks nested up to the limit" do
+      expect { parse.call(blocks(max)) }.not_to raise_error
+    end
+
+    it "raises NotInLanguage for blocks nested past the limit" do
+      expect { parse.call(blocks(max + 1)) }.to raise_error(FlavourSaver::Parser::NotInLanguage, /more than #{max} levels/)
+    end
+
+    it "allows subexpressions nested up to the limit" do
+      expect { parse.call(subexpressions(max)) }.not_to raise_error
+    end
+
+    it "raises NotInLanguage for subexpressions nested past the limit" do
+      expect { parse.call(subexpressions(max + 1)) }.to raise_error(FlavourSaver::Parser::NotInLanguage, /more than #{max} levels/)
+    end
+
+    it "counts blocks and subexpressions together" do
+      template = ("{{#foo}}" * max) + "{{bar (baz)}}" + ("{{/foo}}" * max)
+      expect { parse.call(template) }.to raise_error(FlavourSaver::Parser::NotInLanguage, /more than #{max} levels/)
+    end
+
+    it "raises NotInLanguage rather than SystemStackError inside a Fiber" do
+      expect { Fiber.new { parse.call(blocks(10_000)) }.resume }.to raise_error(FlavourSaver::Parser::NotInLanguage)
     end
   end
 end