flavour_saver 4.0.2 → 5.0.0

data/spec/lib/flavour_saver/lexer_spec.rb

@@ -1,82 +1,78 @@
-require 'flavour_saver/lexer'
+require "flavour_saver/lexer"
 
 describe FlavourSaver::Lexer do
-  it 'is an RLTK lexer' do
-    expect(subject).to be_a(RLTK::Lexer)
-  end
-
-  describe 'Tokens' do
-    describe 'Expressions' do
-      describe '{{foo}}' do
+  describe "Tokens" do
+    describe "Expressions" do
+      describe "{{foo}}" do
         subject { FlavourSaver::Lexer.lex "{{foo}}" }
 
-        it 'begins with an EXPRST' do
+        it "begins with an EXPRST" do
           expect(subject.first.type).to eq :EXPRST
         end
 
-        it 'ends with an EXPRE' do
+        it "ends with an EXPRE" do
           expect(subject[-2].type).to eq :EXPRE
         end
 
         it 'contains only the identifier "foo"' do
           expect(subject[1..-3].size).to eq 1
           expect(subject[1].type).to eq :IDENT
-          expect(subject[1].value).to eq 'foo'
+          expect(subject[1].value).to eq "foo"
         end
       end
 
-      describe '{{foo bar}}' do
+      describe "{{foo bar}}" do
         subject { FlavourSaver::Lexer.lex "{{foo bar}}" }
 
-        it 'has tokens in the correct order' do
-          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :WHITE, :IDENT, :EXPRE, :EOS ]
+        it "has tokens in the correct order" do
+          expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :WHITE, :IDENT, :EXPRE, :EOS]
         end
 
-        it 'has values in the correct order' do
-          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar' ]
+        it "has values in the correct order" do
+          expect(subject.map(&:value).compact).to eq ["foo", "bar"]
         end
       end
 
       describe '{{foo "bar"}}' do
         subject { FlavourSaver::Lexer.lex "{{foo \"bar\"}}" }
 
-        it 'has tokens in the correct order' do
-          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :WHITE, :STRING, :EXPRE, :EOS ]
+        it "has tokens in the correct order" do
+          expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :WHITE, :STRING, :EXPRE, :EOS]
         end
 
-        it 'has values in the correct order' do
-          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar' ]
+        it "has values in the correct order" do
+          expect(subject.map(&:value).compact).to eq ["foo", "bar"]
         end
       end
 
       describe '{{foo (bar "baz")}}' do
         subject { FlavourSaver::Lexer.lex "{{foo (bar 'baz')}}" }
 
-        it 'has tokens in the correct order' do
-          expect(subject.map(&:type)).to eq  [ :EXPRST, :IDENT, :WHITE, :OPAR, :IDENT, :WHITE, :S_STRING, :CPAR, :EXPRE, :EOS ]
+        it "has tokens in the correct order" do
+          expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :WHITE, :OPAR, :IDENT, :WHITE, :S_STRING, :CPAR, :EXPRE, :EOS]
         end
 
-        it 'has values in the correct order' do
-          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz' ]
+        it "has values in the correct order" do
+          expect(subject.map(&:value).compact).to eq ["foo", "bar", "baz"]
         end
       end
 
       describe '{{foo bar="baz" hello="goodbye"}}' do
         subject { FlavourSaver::Lexer.lex '{{foo bar="baz" hello="goodbye"}}' }
 
-        it 'has tokens in the correct order' do
-          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :STRING, :WHITE, :IDENT, :EQ, :STRING, :EXPRE, :EOS ]
+        it "has tokens in the correct order" do
+          expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :STRING, :WHITE, :IDENT, :EQ, :STRING, :EXPRE, :EOS]
         end
 
-        it 'has values in the correct order' do
-          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz', 'hello', 'goodbye' ]
+        it "has values in the correct order" do
+          expect(subject.map(&:value).compact).to eq ["foo", "bar", "baz", "hello", "goodbye"]
         end
       end
 
-      describe '{{0}}' do
+      describe "{{0}}" do
         subject { FlavourSaver::Lexer.lex "{{0}}" }
 
-        it 'properly lexes the expression' do
+        it "properly lexes the expression" do
           expect(subject.map(&:type)).to eq(
             [:EXPRST, :NUMBER, :EXPRE, :EOS]
           )
@@ -85,14 +81,14 @@ describe FlavourSaver::Lexer do
         it 'contains only the number "0"' do
           expect(subject[1..-3].size).to eq 1
           expect(subject[1].type).to eq :NUMBER
-          expect(subject[1].value).to eq '0'
+          expect(subject[1].value).to eq "0"
         end
       end
 
-      describe '{{0.0123456789}}' do
+      describe "{{0.0123456789}}" do
         subject { FlavourSaver::Lexer.lex "{{0.0123456789}}" }
 
-        it 'properly lexes the expression' do
+        it "properly lexes the expression" do
           expect(subject.map(&:type)).to eq(
             [:EXPRST, :NUMBER, :EXPRE, :EOS]
           )
@@ -101,15 +97,14 @@ describe FlavourSaver::Lexer do
         it 'contains only the number "0.0123456789"' do
           expect(subject[1..-3].size).to eq 1
           expect(subject[1].type).to eq :NUMBER
-          expect(subject[1].value).to eq '0.0123456789'
+          expect(subject[1].value).to eq "0.0123456789"
         end
       end
     end
 
-    describe 'Identities' do
-
-      it 'supports as ruby methods' do
-        ids = %w( _ __ __123__ __ABC__ ABC123 Abc134def )
+    describe "Identities" do
+      it "supports as ruby methods" do
+        ids = %w[_ __ __123__ __ABC__ ABC123 Abc134def]
         ids.each do |id|
           subject = FlavourSaver::Lexer.lex "{{#{id}}}"
           expect(subject[1].type).to eq :IDENT
@@ -117,8 +112,8 @@ describe FlavourSaver::Lexer do
         end
       end
 
-      it 'maps non-ruby identities to literals' do
-        ids = %w( A-B 12_Mine - :example 0A test? )
+      it "maps non-ruby identities to literals" do
+        ids = %w[A-B 12_Mine - :example 0A test?]
         ids.each do |id|
           subject = FlavourSaver::Lexer.lex "{{#{id}}}"
           expect(subject[1].type).to eq :LITERAL
@@ -127,101 +122,101 @@ describe FlavourSaver::Lexer do
       end
     end
 
-    describe '{{foo bar=(baz qux)}}' do
-      subject { FlavourSaver::Lexer.lex '{{foo bar=(baz qux)}}' }
+    describe "{{foo bar=(baz qux)}}" do
+      subject { FlavourSaver::Lexer.lex "{{foo bar=(baz qux)}}" }
 
-      it 'has tokens in the correct order' do
+      it "has tokens in the correct order" do
         expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :OPAR, :IDENT, :WHITE, :IDENT, :CPAR, :EXPRE, :EOS]
       end
 
-      it 'has values in the correct order' do
-        expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz', 'qux' ]
+      it "has values in the correct order" do
+        expect(subject.map(&:value).compact).to eq ["foo", "bar", "baz", "qux"]
       end
     end
 
-    describe '{{else}}' do
-      subject { FlavourSaver::Lexer.lex '{{else}}' }
+    describe "{{else}}" do
+      subject { FlavourSaver::Lexer.lex "{{else}}" }
 
-      it 'has tokens in the correct order' do
-        expect(subject.map(&:type)).to eq [ :EXPRST, :ELSE, :EXPRE, :EOS ]
+      it "has tokens in the correct order" do
+        expect(subject.map(&:type)).to eq [:EXPRST, :ELSE, :EXPRE, :EOS]
       end
     end
 
-    describe 'Object path expressions' do
-      describe '{{foo.bar}}' do
+    describe "Object path expressions" do
+      describe "{{foo.bar}}" do
         subject { FlavourSaver::Lexer.lex "{{foo.bar}}" }
 
-        it 'has tokens in the correct order' do
-          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :DOT, :IDENT, :EXPRE, :EOS ]
+        it "has tokens in the correct order" do
+          expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :DOT, :IDENT, :EXPRE, :EOS]
         end
 
-        it 'has the correct values' do
-          expect(subject.map(&:value).compact).to eq ['foo', 'bar']
+        it "has the correct values" do
+          expect(subject.map(&:value).compact).to eq ["foo", "bar"]
         end
       end
 
-      describe '{{foo.[10].bar}}' do
+      describe "{{foo.[10].bar}}" do
         subject { FlavourSaver::Lexer.lex "{{foo.[10].bar}}" }
 
-        it 'has tokens in the correct order' do
-          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
+        it "has tokens in the correct order" do
+          expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS]
         end
 
-        it 'has the correct values' do
-          expect(subject.map(&:value).compact).to eq ['foo', '10', 'bar']
+        it "has the correct values" do
+          expect(subject.map(&:value).compact).to eq ["foo", "10", "bar"]
         end
       end
 
       describe '{{foo.[he!@#$(&@klA)].bar}}' do
         subject { FlavourSaver::Lexer.lex '{{foo.[he!@#$(&@klA)].bar}}' }
 
-        it 'has tokens in the correct order' do
-          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
+        it "has tokens in the correct order" do
+          expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS]
         end
 
-        it 'has the correct values' do
-          expect(subject.map(&:value).compact).to eq ['foo', 'he!@#$(&@klA)', 'bar']
+        it "has the correct values" do
+          expect(subject.map(&:value).compact).to eq ["foo", 'he!@#$(&@klA)', "bar"]
         end
       end
     end
 
-    describe 'Triple-stash expressions' do
+    describe "Triple-stash expressions" do
       subject { FlavourSaver::Lexer.lex "{{{foo}}}" }
 
-      it 'has tokens in the correct order' do
-        expect(subject.map(&:type)).to eq [ :TEXPRST, :IDENT, :TEXPRE, :EOS ]
+      it "has tokens in the correct order" do
+        expect(subject.map(&:type)).to eq [:TEXPRST, :IDENT, :TEXPRE, :EOS]
       end
     end
 
-    describe 'Comment expressions' do
+    describe "Comment expressions" do
       subject { FlavourSaver::Lexer.lex "{{! WAT}}" }
 
-      it 'has tokens in the correct order' do
-        expect(subject.map(&:type)).to eq [ :EXPRST, :BANG, :COMMENT, :EXPRE, :EOS ]
+      it "has tokens in the correct order" do
+        expect(subject.map(&:type)).to eq [:EXPRST, :BANG, :COMMENT, :EXPRE, :EOS]
       end
     end
 
-    describe 'Backtrack expression' do
+    describe "Backtrack expression" do
       subject { FlavourSaver::Lexer.lex "{{../foo}}" }
 
-      it 'has tokens in the correct order' do
+      it "has tokens in the correct order" do
         expect(subject.map(&:type)).to eq [:EXPRST, :DOT, :DOT, :FWSL, :IDENT, :EXPRE, :EOS]
       end
     end
 
-    describe 'Carriage-return and new-lines' do
+    describe "Carriage-return and new-lines" do
       subject { FlavourSaver::Lexer.lex "{{foo}}\n{{bar}}\r{{baz}}" }
 
-      it 'has tokens in the correct order' do
-        expect(subject.map(&:type)).to eq [:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:EOS]
+      it "has tokens in the correct order" do
+        expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :EXPRE, :OUT, :EXPRST, :IDENT, :EXPRE, :OUT, :EXPRST, :IDENT, :EXPRE, :EOS]
       end
     end
 
-    describe 'Block Expressions' do
+    describe "Block Expressions" do
       subject { FlavourSaver::Lexer.lex "{{#foo}}{{bar}}{{/foo}}" }
 
-      describe '{{#foo}}{{bar}}{{/foo}}' do
-        it 'has tokens in the correct order' do
+      describe "{{#foo}}{{bar}}{{/foo}}" do
+        it "has tokens in the correct order" do
           expect(subject.map(&:type)).to eq [
             :EXPRST, :HASH, :IDENT, :EXPRE,
             :EXPRST, :IDENT, :EXPRE,
@@ -230,34 +225,53 @@ describe FlavourSaver::Lexer do
           ]
         end
 
-        it 'has identifiers in the correct order' do
-          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'foo' ]
+        it "has identifiers in the correct order" do
+          expect(subject.map(&:value).compact).to eq ["foo", "bar", "foo"]
         end
       end
     end
 
-    describe 'Carriage return' do
+    describe "Carriage return" do
       subject { FlavourSaver::Lexer.lex "\r" }
 
-      it 'has tokens in the correct order' do
-        expect(subject.map(&:type)).to eq [:OUT,:EOS]
+      it "has tokens in the correct order" do
+        expect(subject.map(&:type)).to eq [:OUT, :EOS]
       end
     end
 
-    describe 'New line' do
+    describe "New line" do
       subject { FlavourSaver::Lexer.lex "\n" }
 
-      it 'has tokens in the correct order' do
-        expect(subject.map(&:type)).to eq [:OUT,:EOS]
+      it "has tokens in the correct order" do
+        expect(subject.map(&:type)).to eq [:OUT, :EOS]
       end
     end
 
-    describe 'Single curly bracket' do
+    describe "Single curly bracket" do
       subject { FlavourSaver::Lexer.lex "{" }
 
-      it 'has tokens in the correct order' do
-        expect(subject.map(&:type)).to eq [:OUT,:EOS]
+      it "has tokens in the correct order" do
+        expect(subject.map(&:type)).to eq [:OUT, :EOS]
       end
     end
   end
+  describe "{{foo %}}" do
+    subject { FlavourSaver::Lexer.lex "{{foo %}}" }
+
+    it "raises a lexing error naming the unmatched input" do
+      expect { subject }.to raise_error(FlavourSaver::Lexer::LexingError, /: %}}\z/)
+    end
+
+    it "is a FlavourSaver::Error" do
+      expect { subject }.to raise_error(FlavourSaver::Error)
+    end
+  end
+
+  describe "an unlexable expression followed by a long template" do
+    subject { FlavourSaver::Lexer.lex "{{foo %}}#{"x" * 1000}" }
+
+    it "quotes only the start of the unmatched input" do
+      expect { subject }.to raise_error(FlavourSaver::Lexer::LexingError, /: %}}x{47}\.\.\.\z/)
+    end
+  end
 end

data/spec/lib/flavour_saver/nodes_spec.rb

@@ -0,0 +1,85 @@
+require "flavour_saver/nodes"
+
+describe FlavourSaver::Node do
+  describe "field inheritance" do
+    let(:parent) { Class.new(FlavourSaver::Node) { value :name, String } }
+
+    it "gives a subclass the fields its parent had when the subclass was defined" do
+      subclass = Class.new(parent)
+      parent.value :depth, Integer
+
+      expect(subclass.value_names).to eq [:name]
+    end
+
+    it "doesn't add a subclass's fields to its parent" do
+      Class.new(parent) { value :depth, Integer }
+
+      expect(parent.value_names).to eq [:name]
+    end
+  end
+
+  describe "field types" do
+    let(:call) { FlavourSaver::CallNode.new("foo", []) }
+
+    it "accepts fields of the declared types" do
+      expression = FlavourSaver::ExpressionNode.new([call])
+
+      expect(expression.method).to eq [call]
+      expect(call.parent).to eq expression
+    end
+
+    it "accepts nil for a field typed with a class" do
+      expect(FlavourSaver::PartialNode.new("foo", [], nil).context_value).to be_nil
+    end
+
+    it "raises TypeMismatch for a value of the wrong class" do
+      expect { FlavourSaver::CallNode.new(:foo, []) }
+        .to raise_error(FlavourSaver::Node::TypeMismatch, "FlavourSaver::CallNode#name must be String, not Symbol")
+    end
+
+    it "raises TypeMismatch for a child of the wrong class" do
+      expect { FlavourSaver::BlockExpressionNode.new([call], call) }
+        .to raise_error(FlavourSaver::Node::TypeMismatch, /#contents must be FlavourSaver::TemplateNode, not FlavourSaver::CallNode/)
+    end
+
+    it "raises TypeMismatch for an array containing the wrong class" do
+      expect { FlavourSaver::ExpressionNode.new([call, FlavourSaver::StringNode.new("bar")]) }
+        .to raise_error(FlavourSaver::Node::TypeMismatch, /#method must be \[FlavourSaver::CallNode\], not an Array of FlavourSaver::CallNode, FlavourSaver::StringNode/)
+    end
+
+    it "raises TypeMismatch when an array field is not an array" do
+      expect { FlavourSaver::ExpressionNode.new({foo: call}) }
+        .to raise_error(FlavourSaver::Node::TypeMismatch, /#method must be \[FlavourSaver::CallNode\], not Hash/)
+      expect { FlavourSaver::ExpressionNode.new(nil) }.to raise_error(FlavourSaver::Node::TypeMismatch)
+    end
+
+    it "checks fields set after the node is built" do
+      expect { call.name = 1 }.to raise_error(FlavourSaver::Node::TypeMismatch)
+    end
+
+    it "is a StandardError, as RLTK::TypeMismatch was" do
+      expect(FlavourSaver::Node::TypeMismatch.superclass).to eq StandardError
+    end
+  end
+
+  describe "field declarations" do
+    it "requires a type" do
+      expect { Class.new(FlavourSaver::Node) { value :name } }.to raise_error(ArgumentError)
+    end
+
+    it "doesn't allow a value to be typed as a node" do
+      expect { Class.new(FlavourSaver::Node) { value :call, FlavourSaver::CallNode } }
+        .to raise_error(ArgumentError, /type can't be a Node/)
+    end
+
+    it "requires a child to be typed as a node" do
+      expect { Class.new(FlavourSaver::Node) { child :name, [String] } }
+        .to raise_error(ArgumentError, /type must be a Node/)
+    end
+
+    it "requires the type to be a class or a class in an array" do
+      expect { Class.new(FlavourSaver::Node) { child :calls, [FlavourSaver::CallNode, FlavourSaver::StringNode] } }
+        .to raise_error(ArgumentError, /must have a class, or a class in an array/)
+    end
+  end
+end