flavour_saver 4.0.2 → 5.0.0

data/spec/lib/flavour_saver/runtime_spec.rb

@@ -1,224 +1,222 @@
-require 'flavour_saver'
+require "flavour_saver"
 
 describe FlavourSaver::Runtime do
-  let(:template) { '' }
-  let(:tokens)   { FlavourSaver.lex(template) }
-  let(:ast)      { FlavourSaver.parse(tokens) }
-  let(:context)  { double(:context) }
-  subject        { FlavourSaver::Runtime.new(ast, context) }
-
-  describe '#evaluate_node' do
-    describe 'when passed a TemplateNode' do
+  let(:template) { "" }
+  let(:tokens) { FlavourSaver.lex(template) }
+  let(:ast) { FlavourSaver.parse(tokens) }
+  let(:context) { double(:context) }
+  subject { FlavourSaver::Runtime.new(ast, context) }
+
+  describe "#evaluate_node" do
+    describe "when passed a TemplateNode" do
       let(:template) { "hello world" }
 
       it "concatenates all the nodes items together" do
-        expect(subject.evaluate_node(ast)).to eq 'hello world'
+        expect(subject.evaluate_node(ast)).to eq "hello world"
       end
     end
 
-    describe 'when passed an OutputNode' do
+    describe "when passed an OutputNode" do
       let(:template) { "hello world" }
 
       it "returns the value of OutputNodes" do
         node = ast.items.first
-        expect(subject.evaluate_node(node)).to eq 'hello world'
+        expect(subject.evaluate_node(node)).to eq "hello world"
       end
     end
 
-    describe 'when passed a StringNode' do
+    describe "when passed a StringNode" do
       let(:template) { "{{foo \"WAT\"}}" }
-      let(:node)     { ast.items.select { |n| n.class == FlavourSaver::ExpressionNode }.first.method.first.arguments.first }
+      let(:node) { ast.items.find { |n| n.instance_of?(FlavourSaver::ExpressionNode) }.method.first.arguments.first }
 
-      it 'returns the value of the string' do
-        expect(subject.evaluate_node(node)).to eq 'WAT'
+      it "returns the value of the string" do
+        expect(subject.evaluate_node(node)).to eq "WAT"
       end
     end
 
-    describe 'when passed an ExpressionNode' do
-      let(:node)      { ast.items.select { |n| n.class == FlavourSaver::ExpressionNode }.first }
-      let (:template) { "{{foo}}" }
+    describe "when passed an ExpressionNode" do
+      let(:node) { ast.items.find { |n| n.instance_of?(FlavourSaver::ExpressionNode) } }
+      let(:template) { "{{foo}}" }
 
-      it 'calls evaluate_node with the node' do
+      it "calls evaluate_node with the node" do
         expect(subject).to receive(:evaluate_expression).with(node)
         subject.evaluate_node(node)
       end
 
-      it 'should HTML escape the output' do
+      it "should HTML escape the output" do
         expect(context).to receive(:foo).and_return("<html>LOL</html>")
-        expect(subject.evaluate_node(node)).to eq '&lt;html&gt;LOL&lt;/html&gt;'
+        expect(subject.evaluate_node(node)).to eq "&lt;html&gt;LOL&lt;/html&gt;"
       end
     end
 
-    describe 'when passed a SafeExpressionNode' do
-      let(:node)      { ast.items.select { |n| n.class == FlavourSaver::SafeExpressionNode }.first }
-      let (:template) { "{{{foo}}}" }
+    describe "when passed a SafeExpressionNode" do
+      let(:node) { ast.items.find { |n| n.instance_of?(FlavourSaver::SafeExpressionNode) } }
+      let(:template) { "{{{foo}}}" }
 
-      it 'should not HTML escape the output' do
+      it "should not HTML escape the output" do
         expect(context).to receive(:foo).and_return("<html>LOL</html>")
-        expect(subject.evaluate_node(node)).to eq '<html>LOL</html>'
+        expect(subject.evaluate_node(node)).to eq "<html>LOL</html>"
       end
     end
 
-    describe 'when passed a CommentNode' do
+    describe "when passed a CommentNode" do
       let(:template) { "{{! I am a comment}}" }
-      let(:node)     { ast.items.select { |n| n.class == FlavourSaver::CommentNode }.first }
+      let(:node) { ast.items.find { |n| n.instance_of?(FlavourSaver::CommentNode) } }
 
-      it 'should return zilch' do
-        expect(subject.evaluate_node(node)).to eq ''
+      it "should return zilch" do
+        expect(subject.evaluate_node(node)).to eq ""
       end
     end
 
-    describe 'when passed a BlockExpressionStartNode' do
+    describe "when passed a BlockExpressionStartNode" do
       let(:template) { "{{#foo}}bar{{/foo}}baz" }
 
-      it 'snatches up the block contents and skips them from evaluation' do
+      it "snatches up the block contents and skips them from evaluation" do
         allow(context).to receive(:foo)
-        expect(subject.evaluate_node(ast)).to eq 'baz'
+        expect(subject.evaluate_node(ast)).to eq "baz"
       end
     end
   end
 
-  describe '#evaluate_expression' do
-    let(:node) { ast.items.select { |n| n.class == FlavourSaver::ExpressionNode }.first }
+  describe "#evaluate_expression" do
+    let(:node) { ast.items.find { |n| n.instance_of?(FlavourSaver::ExpressionNode) } }
     let(:expr) { node }
 
-    describe 'when called with a simple method expression' do
-      let (:template) { "{{foo}}" }
+    describe "when called with a simple method expression" do
+      let(:template) { "{{foo}}" }
 
-      it 'calls the method and return the result' do
-        expect(context).to receive(:foo).and_return('foo result')
-        expect(subject.evaluate_expression(expr)).to eq 'foo result'
+      it "calls the method and return the result" do
+        expect(context).to receive(:foo).and_return("foo result")
+        expect(subject.evaluate_expression(expr)).to eq "foo result"
       end
     end
 
-    describe 'when called with a simple method with arguments' do
+    describe "when called with a simple method with arguments" do
       let(:template) { "{{hello \"world\"}}" }
 
-      it 'calls the method with the arguments and return the result' do
+      it "calls the method with the arguments and return the result" do
         expect(context).to receive(:hello).with("world").and_return("hello world")
-        expect(subject.evaluate_expression(expr)).to eq 'hello world'
+        expect(subject.evaluate_expression(expr)).to eq "hello world"
       end
     end
 
-    describe 'when called with a simple method with another simple method argument' do
+    describe "when called with a simple method with another simple method argument" do
       let(:template) { "{{hello world}}" }
 
-      it 'calls hello & world on the context and return the result' do
-        expect(context).to receive(:world).and_return('world')
-        expect(context).to receive(:hello).with('world').and_return('hello world')
-        expect(subject.evaluate_expression(expr)).to eq 'hello world'
+      it "calls hello & world on the context and return the result" do
+        expect(context).to receive(:world).and_return("world")
+        expect(context).to receive(:hello).with("world").and_return("hello world")
+        expect(subject.evaluate_expression(expr)).to eq "hello world"
       end
     end
 
-    describe 'when called with a subexpression' do
+    describe "when called with a subexpression" do
       let(:template) { "{{hello (there world)}}" }
 
-      it 'calls there & world first, then passes off to hello' do
-        expect(context).to receive(:world).and_return('world')
-        expect(context).to receive(:there).with('world').and_return('there world')
-        expect(context).to receive(:hello).with('there world').and_return('hello there world')
-        expect(subject.evaluate_expression(expr)).to eq 'hello there world'
+      it "calls there & world first, then passes off to hello" do
+        expect(context).to receive(:world).and_return("world")
+        expect(context).to receive(:there).with("world").and_return("there world")
+        expect(context).to receive(:hello).with("there world").and_return("hello there world")
+        expect(subject.evaluate_expression(expr)).to eq "hello there world"
       end
     end
 
-    describe 'when called with an object path' do
+    describe "when called with an object path" do
       let(:template) { "{{hello.world}}" }
 
-      it 'calls world on the result of hello' do
-        allow(context).to receive_message_chain(:hello, :world).and_return('hello world')
-        expect(subject.evaluate_expression(expr)).to eq 'hello world'
+      it "calls world on the result of hello" do
+        allow(context).to receive_message_chain(:hello, :world).and_return("hello world")
+        expect(subject.evaluate_expression(expr)).to eq "hello world"
       end
     end
 
-    describe 'when called with a literal' do
+    describe "when called with a literal" do
       let(:template) { "{{[WAT]}}" }
 
-      it 'indexes the context with WAT' do
-        expect(context).to receive(:[]).with('WAT').and_return 'w00t'
-        expect(subject.evaluate_expression(expr)).to eq 'w00t'
+      it "indexes the context with WAT" do
+        expect(context).to receive(:[]).with("WAT").and_return "w00t"
+        expect(subject.evaluate_expression(expr)).to eq "w00t"
       end
     end
 
-    describe 'when called with an object path containing a literal' do
-      let (:template) { "{{hello.[WAT].world}}" }
+    describe "when called with an object path containing a literal" do
+      let(:template) { "{{hello.[WAT].world}}" }
 
-      it 'indexes the result of hello and calls world on it' do
+      it "indexes the result of hello and calls world on it" do
         world = double(:world)
-        expect(world).to receive(:world).and_return('vr00m')
+        expect(world).to receive(:world).and_return("vr00m")
         hash = double(:hash)
-        expect(hash).to receive(:[]).with('WAT').and_return(world)
+        expect(hash).to receive(:[]).with("WAT").and_return(world)
         expect(context).to receive(:hello).and_return(hash)
-        expect(subject.evaluate_expression(expr)).to eq 'vr00m'
+        expect(subject.evaluate_expression(expr)).to eq "vr00m"
       end
     end
 
-    describe 'when called with an path containing array indexes' do
-      let (:template) { "{{hello.[0].[1]}}" }
+    describe "when called with an path containing array indexes" do
+      let(:template) { "{{hello.[0].[1]}}" }
 
-      it 'indexes the value of a nested array' do
-        array2 = ['w00t', 'vr00m']
+      it "indexes the value of a nested array" do
+        array2 = ["w00t", "vr00m"]
         array = [array2]
         expect(context).to receive(:hello).and_return(array)
-        expect(subject.evaluate_expression(expr)).to eq 'vr00m'
+        expect(subject.evaluate_expression(expr)).to eq "vr00m"
       end
 
-      it 'handles non-existent indexes' do
-        world = ['w00t']
+      it "handles non-existent indexes" do
+        world = ["w00t"]
         array = [world]
         expect(context).to receive(:hello).and_return(array)
         expect(subject.evaluate_expression(expr)).to eq nil
       end
 
-      it 'handles calling on nil values' do
+      it "handles calling on nil values" do
         expect(context).to receive(:hello).and_return(nil)
         expect(subject.evaluate_expression(expr)).to eq nil
       end
     end
 
-    describe 'when called with a parent call node without a surrounding block' do
-      let (:template) { "{{../foo}}" }
+    describe "when called with a parent call node without a surrounding block" do
+      let(:template) { "{{../foo}}" }
 
-      it 'raises an error' do
+      it "raises an error" do
         expect { subject.evaluate_expression(expr) }.to raise_error(FlavourSaver::UnknownContextException)
       end
     end
 
-    describe 'when called with a hash argument containing a string value' do
-      let (:template) { '{{foo bar="baz"}}' }
+    describe "when called with a hash argument containing a string value" do
+      let(:template) { '{{foo bar="baz"}}' }
 
-      it 'receives the argument as a hash' do
-        expect(context).to receive(:foo).with({:bar => 'baz'})
+      it "receives the argument as a hash" do
+        expect(context).to receive(:foo).with({bar: "baz"})
         subject.evaluate_expression(expr)
       end
     end
 
-    describe 'when called with a hash argument containing a method reference' do
-      let (:template) { "{{foo bar=baz}}" }
+    describe "when called with a hash argument containing a method reference" do
+      let(:template) { "{{foo bar=baz}}" }
 
-      it 'calls the value and returns it\'s result in the hash' do
-        expect(context).to receive(:baz).and_return('OMGLOLWAT')
-        expect(context).to receive(:foo).with({:bar => 'OMGLOLWAT'})
+      it "calls the value and returns it's result in the hash" do
+        expect(context).to receive(:baz).and_return("OMGLOLWAT")
+        expect(context).to receive(:foo).with({bar: "OMGLOLWAT"})
         subject.evaluate_expression(expr)
       end
     end
-
   end
 
-  describe '#evaluate_block' do
+  describe "#evaluate_block" do
     let(:template) { "{{#foo}}hello world{{/foo}}" }
-    let(:block)    { ast.items.first }
+    let(:block) { ast.items.first }
 
-    it 'creates a new runtime' do
+    it "creates a new runtime" do
       expect(subject).to receive(:create_child_runtime)
       allow(context).to receive(:foo)
       subject.evaluate_block(block, context)
     end
   end
 
-  describe '#create_child_runtime' do
-    it 'creates a new runtime' do
+  describe "#create_child_runtime" do
+    it "creates a new runtime" do
       expect(subject.create_child_runtime([])).to be_a(FlavourSaver::Runtime)
     end
   end
-
 end

data/spec/lib/flavour_saver/template_spec.rb

@@ -1,5 +1,4 @@
-require 'flavour_saver'
+require "flavour_saver"
 
 describe FlavourSaver::Template do
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flavour_saver
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 5.0.0
 platform: ruby
 authors:
 - Clayton Passmore
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-12 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -40,33 +40,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rltk
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
+        version: 7.2.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 7.2.0
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +81,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
-description: FlavourSaver is a pure-ruby implimentation of the Handlebars templating
+description: FlavourSaver is a pure-ruby implementation of the Handlebars templating
   language
 email:
 - ctpassmore+flavoursaver@gmail.com
@@ -91,6 +91,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
+- ".standard.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -99,6 +100,7 @@ files:
 - Rakefile
 - flavour_saver.gemspec
 - lib/flavour_saver.rb
+- lib/flavour_saver/error.rb
 - lib/flavour_saver/helpers.rb
 - lib/flavour_saver/lexer.rb
 - lib/flavour_saver/nodes.rb
@@ -116,6 +118,7 @@ files:
 - spec/acceptance/handlebars_qunit_spec.rb
 - spec/acceptance/if_else_spec.rb
 - spec/acceptance/multi_level_with_spec.rb
+- spec/acceptance/nesting_depth_spec.rb
 - spec/acceptance/one_character_identifier_spec.rb
 - spec/acceptance/raw_block_spec.rb
 - spec/acceptance/runtime_run_spec.rb
@@ -138,6 +141,7 @@ files:
 - spec/fixtures/simple_expression.hbs
 - spec/fixtures/unless.hbs
 - spec/lib/flavour_saver/lexer_spec.rb
+- spec/lib/flavour_saver/nodes_spec.rb
 - spec/lib/flavour_saver/parser_spec.rb
 - spec/lib/flavour_saver/runtime_spec.rb
 - spec/lib/flavour_saver/template_spec.rb
@@ -168,37 +172,4 @@ rubygems_version: 3.3.27
 signing_key:
 specification_version: 4
 summary: Handlebars.js without the .js
-test_files:
-- spec/acceptance/backtrack_spec.rb
-- spec/acceptance/comment_spec.rb
-- spec/acceptance/custom_block_helper_spec.rb
-- spec/acceptance/custom_helper_spec.rb
-- spec/acceptance/ensure_no_rce_spec.rb
-- spec/acceptance/handlebars_qunit_spec.rb
-- spec/acceptance/if_else_spec.rb
-- spec/acceptance/multi_level_with_spec.rb
-- spec/acceptance/one_character_identifier_spec.rb
-- spec/acceptance/raw_block_spec.rb
-- spec/acceptance/runtime_run_spec.rb
-- spec/acceptance/sections_spec.rb
-- spec/acceptance/segment_literals_spec.rb
-- spec/acceptance/simple_expression_spec.rb
-- spec/acceptance/subexpression_spec.rb
-- spec/acceptance/unless_spec.rb
-- spec/fixtures/backtrack.hbs
-- spec/fixtures/comment.hbs
-- spec/fixtures/custom_block_helper.hbs
-- spec/fixtures/custom_helper.hbs
-- spec/fixtures/if_else.hbs
-- spec/fixtures/multi_level_if.hbs
-- spec/fixtures/multi_level_with.hbs
-- spec/fixtures/one_character_identifier.hbs
-- spec/fixtures/raw.hbs
-- spec/fixtures/rce.hbs
-- spec/fixtures/sections.hbs
-- spec/fixtures/simple_expression.hbs
-- spec/fixtures/unless.hbs
-- spec/lib/flavour_saver/lexer_spec.rb
-- spec/lib/flavour_saver/parser_spec.rb
-- spec/lib/flavour_saver/runtime_spec.rb
-- spec/lib/flavour_saver/template_spec.rb
+test_files: []