curlybars 1.2.1 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fbfe78e305b68cad9c83ab0deafe39a1814b519ede424de8459dfe8f096bee1
-  data.tar.gz: 7fb5ee604e9379a73ef24cd607aea3a847656a3ecc6f3fddbedd0c4031b398fc
+  metadata.gz: 307c759c2acc1c33ab91a236aeb5042e6ecfee67581eef05f468c241a722e1f6
+  data.tar.gz: 68b0a401f830e5985d0d6b657974f84c2afdda2d49e70c696e97641845d31a16
 SHA512:
-  metadata.gz: 1f3d779a0858270de68a2715f6badb08290cf977ad792ea019ee8d5b6f20ecc837371129d98a97f2a118df2edff352ec41d71023b4789b05321315fac5847526
-  data.tar.gz: baeb86fd6563d5baca979bcc6cdd08f3a3a66b75bc29692fcbf366b7b3518725e2bd1fbdd6afa6b66567d95436f6d2d241c3d4c1cb81c6315a337df0aa9fc0aa
+  metadata.gz: 7db835baca28f2c15af2fb1a582059bb8346d1de41f8d9ed72262ea7ef1e2ff2e8130091b4e1494858b366f050e1b2fe2cf1753afbd1a403c66058c37f8fa9ff
+  data.tar.gz: 9a54e30bba2976a6c6f0ff4e6fef5f00075dc6186a9eb07c70a63ead7a96629a17897ce9ea9e09fad00049262a891eb88b1389873b629ca22f12c7b712686166

data/lib/curlybars/lexer.rb

@@ -32,6 +32,9 @@ module Curlybars
     r(/{{/) { push_state :curly; :START }
     r(/}}/, :curly) { pop_state; :END }
 
+    r(/\(/, :curly) { push_state :curly; :LPAREN }
+    r(/\)/, :curly) { pop_state; :RPAREN }
+
     r(/#/, :curly) { :HASH }
     r(/\//, :curly) { :SLASH }
     r(/>/, :curly) { :GT }

data/lib/curlybars/method_whitelist.rb

@@ -1,27 +1,57 @@
 module Curlybars
   module MethodWhitelist
-    def allow_methods(*methods, **methods_with_type)
-      methods_with_type.each do |(method_name, type)|
-        if type.is_a?(Array)
-          if type.size != 1 || !type.first.respond_to?(:dependency_tree)
-            raise "Invalid allowed method syntax for `#{method_name}`. Collections must be of one presenter class"
+    def allow_methods(*methods_without_type, **methods_with_type, &contextual_block)
+      methods_with_type_validator = lambda do |methods_to_validate|
+        methods_to_validate.each do |(method_name, type)|
+          if type.is_a?(Array)
+            if type.size != 1 || !type.first.respond_to?(:dependency_tree)
+              raise "Invalid allowed method syntax for `#{method_name}`. Collections must be of one presenter class"
+            end
           end
         end
       end
 
+      methods_with_type_validator.call(methods_with_type)
+
       define_method(:allowed_methods) do
-        methods_list = methods + methods_with_type.keys
-        defined?(super) ? super() + methods_list : methods_list
+        @method_whitelist_allowed_methods ||= begin
+          methods_list = methods_without_type + methods_with_type.keys
+
+          # Adds methods to the list of allowed methods
+          method_adder = lambda do |*more_methods, **more_methods_with_type|
+            methods_with_type_validator.call(more_methods_with_type)
+
+            methods_list += more_methods
+            methods_list += more_methods_with_type.keys
+          end
+
+          contextual_block&.call(self, method_adder)
+
+          defined?(super) ? super() + methods_list : methods_list
+        end
       end
 
-      define_singleton_method(:methods_schema) do |*args|
-        schema = methods.each_with_object({}) do |method, memo|
+      define_singleton_method(:methods_schema) do |context = nil|
+        all_methods_without_type = methods_without_type
+        all_methods_with_type = methods_with_type
+
+        # Adds methods to the schema
+        schema_adder = lambda do |*more_methods_without_type, **more_methods_with_type|
+          methods_with_type_validator.call(more_methods_with_type)
+
+          all_methods_without_type += more_methods_without_type
+          all_methods_with_type = all_methods_with_type.merge(more_methods_with_type)
+        end
+
+        contextual_block&.call(context, schema_adder)
+
+        schema = all_methods_without_type.each_with_object({}) do |method, memo|
           memo[method] = nil
         end
 
-        methods_with_type_resolved = methods_with_type.each_with_object({}) do |(method_name, type), memo|
+        methods_with_type_resolved = all_methods_with_type.each_with_object({}) do |(method_name, type), memo|
           memo[method_name] = if type.respond_to?(:call)
-            type.call(*args)
+            type.call(context)
           else
             type
           end
@@ -30,26 +60,26 @@ module Curlybars
         schema.merge!(methods_with_type_resolved)
 
         # Inheritance
-        schema.merge!(super(*args)) if defined?(super)
+        schema.merge!(super(context)) if defined?(super)
 
         # Included modules
         included_modules.each do |mod|
           next unless mod.respond_to?(:methods_schema)
-          schema.merge!(mod.methods_schema(*args))
+          schema.merge!(mod.methods_schema(context))
         end
 
         schema
       end
 
-      define_singleton_method(:dependency_tree) do |*args|
-        methods_schema(*args).each_with_object({}) do |method_with_type, memo|
+      define_singleton_method(:dependency_tree) do |context = nil|
+        methods_schema(context).each_with_object({}) do |method_with_type, memo|
           method_name = method_with_type.first
           type = method_with_type.last
 
           memo[method_name] = if type.respond_to?(:dependency_tree)
-            type.dependency_tree(*args)
+            type.dependency_tree(context)
           elsif type.is_a?(Array)
-            [type.first.dependency_tree(*args)]
+            [type.first.dependency_tree(context)]
           else
             type
           end

data/lib/curlybars/node/if_else.rb

@@ -15,7 +15,7 @@ module Curlybars
 
       def validate(branches)
         [
-          expression.validate(branches, check_type: :not_helper),
+          expression.validate(branches),
           if_template.validate(branches),
           else_template.validate(branches)
         ]

data/lib/curlybars/node/sub_expression.rb

@@ -0,0 +1,62 @@
+module Curlybars
+  module Node
+    SubExpression = Struct.new(:helper, :arguments, :options, :position) do
+      def compile
+        compiled_arguments = arguments.map do |argument|
+          "arguments.push(rendering.cached_call(#{argument.compile}))"
+        end.join("\n")
+
+        compiled_options = options.map do |option|
+          "options.merge!(#{option.compile})"
+        end.join("\n")
+
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          ::Module.new do
+            def self.exec(contexts, rendering)
+              rendering.check_timeout!
+
+              -> {
+                options = ::ActiveSupport::HashWithIndifferentAccess.new
+                #{compiled_options}
+
+                arguments = []
+                #{compiled_arguments}
+
+                helper = #{helper.compile}
+                helper_position = rendering.position(#{helper.position.line_number},
+                  #{helper.position.line_offset})
+
+                options[:this] = contexts.last
+
+                rendering.call(helper, #{helper.path.inspect}, helper_position,
+                  arguments, options)
+              }
+            end
+          end.exec(contexts, rendering)
+        RUBY
+      end
+
+      def validate_as_value(branches, check_type: :anything)
+        validate(branches, check_type: check_type)
+      end
+
+      def validate(branches, check_type: :anything)
+        [
+          helper.validate(branches, check_type: :helper),
+          arguments.map { |argument| argument.validate_as_value(branches) },
+          options.map { |option| option.validate(branches) }
+        ]
+      end
+
+      def cache_key
+        [
+          helper,
+          arguments,
+          options
+        ].flatten.map(&:cache_key).push(self.class.name).join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/unless_else.rb

@@ -15,7 +15,7 @@ module Curlybars
 
       def validate(branches)
         [
-          expression.validate(branches, check_type: :not_helper),
+          expression.validate(branches),
           unless_template.validate(branches),
           else_template.validate(branches)
         ]

data/lib/curlybars/parser.rb

@@ -15,6 +15,7 @@ require 'curlybars/node/block_helper_else'
 require 'curlybars/node/option'
 require 'curlybars/node/partial'
 require 'curlybars/node/output'
+require 'curlybars/node/sub_expression'
 
 module Curlybars
   class Parser < RLTK::Parser
@@ -155,6 +156,7 @@ module Curlybars
     production(:expression) do
       clause('value') { |value| value }
       clause('path') { |path| path }
+      clause('subexpression') { |subexpression| subexpression }
     end
 
     production(:value) do
@@ -164,6 +166,15 @@ module Curlybars
 
     production(:path, 'PATH') { |path| Node::Path.new(path, pos(0)) }
 
+    production(:subexpression, 'LPAREN .path .expressions? .options? RPAREN') do |helper, arguments, options|
+      Node::SubExpression.new(
+        helper,
+        arguments || [],
+        options || [],
+        pos(0)
+      )
+    end
+
     finalize
 
     VOID = Class.new do

data/lib/curlybars/rendering_support.rb

@@ -101,7 +101,7 @@ module Curlybars
 
     def cached_call(meth)
       return cached_calls[meth] if cached_calls.key? meth
-      instrument(meth) { cached_calls[meth] = meth.call }
+      instrument(meth) { cached_calls[meth] = meth.call(*arguments_for_signature(meth, [], {})) }
     end
 
     def call(helper, helper_path, helper_position, arguments, options, &block)

data/lib/curlybars/version.rb

@@ -1,3 +1,3 @@
 module Curlybars
-  VERSION = '1.2.1'.freeze
+  VERSION = '1.5.1'.freeze
 end

data/lib/curlybars/visitor.rb

@@ -75,6 +75,12 @@ module Curlybars
     def visit_string(_node)
     end
 
+    def visit_sub_expression(node)
+      visit(node.helper)
+      node.arguments.each { |argument| visit(argument) }
+      node.options.each { |option| visit(option) }
+    end
+
     def visit_template(node)
       node.items.each { |item| visit(item) }
     end

data/spec/curlybars/lexer_spec.rb

@@ -160,6 +160,28 @@ describe Curlybars::Lexer do
     end
   end
 
+  describe "{{path (path context options)}}" do
+    it "is lexed with path, context and options" do
+      expect(lex('{{path (path context key=value)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :PATH, :KEY, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed without options" do
+      expect(lex('{{path (path context)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed without context" do
+      expect(lex('{{path (path key=value)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :KEY, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed without context and options" do
+      expect(lex('{{path (path)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed with a nested subexpression" do
+      expect(lex('{{path (path (path context key=value) key=value)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :LPAREN, :PATH, :PATH, :KEY, :PATH, :RPAREN, :KEY, :PATH, :RPAREN, :END]
+    end
+  end
+
   describe "{{#if path}}...{{/if}}" do
     it "is lexed" do
       expect(lex('{{#if path}} text {{/if}}')).to produce(

data/spec/curlybars/method_whitelist_spec.rb

@@ -1,5 +1,32 @@
 describe Curlybars::MethodWhitelist do
-  let(:dummy_class) { Class.new { extend Curlybars::MethodWhitelist } }
+  let(:dummy_class) do
+    Class.new do
+      extend Curlybars::MethodWhitelist
+
+      # A method available in the context
+      def foo?
+        true
+      end
+
+      def qux?
+        false
+      end
+    end
+  end
+
+  let(:validation_context_class) do
+    Class.new do
+      attr_accessor :invocation_count
+
+      def foo?
+        true
+      end
+
+      def qux?
+        false
+      end
+    end
+  end
 
   describe "#allowed_methods" do
     it "returns an empty array as default" do
@@ -21,6 +48,25 @@ describe Curlybars::MethodWhitelist do
       expect(dummy_class.new.allowed_methods).to eq([:cook, :link, :article])
     end
 
+    it "supports adding more methods for validation" do
+      dummy_class.class_eval do
+        allow_methods do |context, allow_method|
+          if context.foo?
+            allow_method.call(:bar)
+          end
+
+          if context.qux?
+            allow_method.call(:quux)
+          end
+        end
+      end
+
+      aggregate_failures "test both allowed_methods and allows_method?" do
+        expect(dummy_class.new.allowed_methods).to eq([:bar])
+        expect(dummy_class.new.allows_method?(:bar)).to eq(true)
+      end
+    end
+
     it "raises when collection is not of presenters" do
       expect do
         dummy_class.class_eval { allow_methods :cook, links: ["foobar"] }
@@ -79,6 +125,81 @@ describe Curlybars::MethodWhitelist do
           wave: nil
         )
     end
+
+    context "with context dependent methods" do
+      let(:base_presenter) do
+        stub_const("LinkPresenter", Class.new)
+
+        Class.new do
+          extend Curlybars::MethodWhitelist
+          attr_accessor :invocation_count
+
+          allow_methods :cook, link: LinkPresenter do |context, allow_method|
+            if context.foo?
+              allow_method.call(:bar)
+            end
+
+            context.invocation_count ||= 0
+            context.invocation_count += 1
+          end
+
+          def foo?
+            true
+          end
+        end
+      end
+
+      let(:helpers) do
+        Module.new do
+          extend Curlybars::MethodWhitelist
+          allow_methods :form do |context, allow_method|
+            if context.foo?
+              allow_method.call(foo_bar: :helper)
+            end
+          end
+
+          def foo?
+            true
+          end
+        end
+      end
+
+      let(:post_presenter) do
+        Class.new(base_presenter) do
+          extend Curlybars::MethodWhitelist
+          include Helpers
+          allow_methods :wave
+        end
+      end
+
+      before do
+        stub_const("Helpers", helpers)
+      end
+
+      it "allows context methods from inheritance and composition" do
+        expect(post_presenter.new.allowed_methods).to eq([:cook, :link, :bar, :form, :foo_bar, :wave])
+      end
+
+      it "only invokes the context block once" do
+        presenter = post_presenter.new
+
+        10.times { presenter.allowed_methods }
+
+        expect(presenter.invocation_count).to eq(1)
+      end
+
+      it "returns a dependency_tree with inheritance and composition with context" do
+        expect(post_presenter.dependency_tree(validation_context_class.new)).
+          to eq(
+            cook: nil,
+            link: LinkPresenter,
+            form: nil,
+            wave: nil,
+            bar: nil,
+            foo_bar: :helper
+          )
+      end
+    end
   end
 
   describe ".methods_schema" do
@@ -110,16 +231,22 @@ describe Curlybars::MethodWhitelist do
       expect(dummy_class.methods_schema).to eq(links: [LinkPresenter])
     end
 
-    it "supports procs in schema" do
-      dummy_class.class_eval { allow_methods settings: -> { { color_1: nil } } }
+    it "supports procs with context in schema" do
+      dummy_class.class_eval { allow_methods settings: ->(context) { context.foo? ? Hash[:background_color, nil] : nil } }
 
-      expect(dummy_class.methods_schema).to eq(settings: { color_1: nil })
+      expect(dummy_class.methods_schema(validation_context_class.new)).to eq(settings: { background_color: nil })
     end
 
-    it "supports procs with arguments in schema" do
-      dummy_class.class_eval { allow_methods settings: ->(name) { Hash[name, nil] } }
+    it "supports context methods" do
+      dummy_class.class_eval do
+        allow_methods do |context, allow_method|
+          if context.foo?
+            allow_method.call(:bar)
+          end
+        end
+      end
 
-      expect(dummy_class.methods_schema(:background_color)).to eq(settings: { background_color: nil })
+      expect(dummy_class.methods_schema(validation_context_class.new)).to eq(bar: nil)
     end
   end
 

data/spec/integration/node/helper_spec.rb

@@ -15,6 +15,18 @@ describe "{{helper context key=value}}" do
       HTML
     end
 
+    it "calls a helper without arguments in an if statement" do
+      template = Curlybars.compile(<<-HBS)
+        {{#if print_args_and_options}}
+          {{print_args_and_options 'first' 'second'}}
+        {{/if}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        first, second, key=
+      HTML
+    end
+
     it "passes two arguments and options" do
       template = Curlybars.compile(<<-HBS)
         {{print_args_and_options 'first' 'second' key='value'}}

data/spec/integration/node/if_spec.rb

@@ -140,7 +140,7 @@ describe "{{#if}}...{{/if}}" do
       expect(errors).not_to be_empty
     end
 
-    it "validates with errors the helper as condition" do
+    it "validates without errors the helper as condition" do
       dependency_tree = { helper: :helper }
 
       source = <<-HBS
@@ -149,7 +149,7 @@ describe "{{#if}}...{{/if}}" do
 
       errors = Curlybars.validate(dependency_tree, source)
 
-      expect(errors).not_to be_empty
+      expect(errors).to be_empty
     end
   end
 end

data/spec/integration/node/sub_expression_spec.rb

@@ -0,0 +1,428 @@
+describe "{{(helper arg1 arg2 ... key=value ...)}}" do
+  let(:global_helpers_providers) { [IntegrationTest::GlobalHelperProvider.new] }
+
+  describe "#compile" do
+    let(:presenter) { IntegrationTest::Presenter.new(double("view_context")) }
+
+    it "can be an argument to helpers" do
+      template = Curlybars.compile(<<-HBS)
+        {{global_helper (global_helper 'argument' option='value') option='value'}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        argument - option:value - option:value
+      HTML
+    end
+
+    it "can be an argument to itself" do
+      template = Curlybars.compile(<<-HBS)
+        {{global_helper (global_helper (global_helper 'a' option='b') option='c') option='d'}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        a - option:b - option:c - option:d
+      HTML
+    end
+
+    it "can handle data objects as argument" do
+      template = Curlybars.compile(<<-HBS)
+        {{global_helper (extract user attribute='first_name') option='value'}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        Libo - option:value
+      HTML
+    end
+
+    it "can handle calls inside with" do
+      template = Curlybars.compile(<<-HBS)
+        {{#with article}}
+          {{global_helper (extract author attribute='first_name') option='value'}}
+        {{/with}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        Nicolò - option:value
+      HTML
+    end
+
+    it "does not accept subexpressions in the root" do
+      expect do
+        Curlybars.compile(<<-HBS)
+          {{(join articles attribute='title' separator='-'}}
+        HBS
+      end.to raise_error(Curlybars::Error::Parse)
+    end
+
+    it "can be called within if expressions" do
+      template = Curlybars.compile(<<-HBS)
+        {{#if (calc 3 ">" 1)}}
+          True
+        {{/if}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        True
+      HTML
+    end
+
+    # Replication of Handlebars' subexpression specs for feature parity
+    # https://github.com/handlebars-lang/handlebars.js/blob/1a08e1d0a7f500f2c1188cbd21750bb9180afcbb/spec/subexpressions.js
+
+    it "arg-less helper" do
+      template = Curlybars.compile(<<-HBS)
+        {{foo (bar)}}!
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        LOLLOL!
+      HTML
+    end
+
+    context "with blog presenter" do
+      let(:presenter) do
+        IntegrationTest::BlogPresenter.new(
+          lambda { |*args, options|
+            val = args.first
+            "val is #{val}"
+          }
+        )
+      end
+
+      it "helper w args" do
+        template = Curlybars.compile(<<-HBS)
+          {{blog (equal a b)}}
+        HBS
+
+        expect(eval(template)).to resemble(<<-HTML)
+          val is true
+        HTML
+      end
+
+      it "supports much nesting" do
+        template = Curlybars.compile(<<-HBS)
+          {{blog (equal (equal true true) true)}}
+        HBS
+
+        expect(eval(template)).to resemble(<<-HTML)
+          val is true
+        HTML
+      end
+
+      it "with hashes" do
+        template = Curlybars.compile(<<-HBS)
+          {{blog (equal (equal true true) true fun='yes')}}
+        HBS
+
+        expect(eval(template)).to resemble(<<-HTML)
+          val is true
+        HTML
+      end
+    end
+
+    context "with a different blog presenter" do
+      let(:presenter) do
+        IntegrationTest::BlogPresenter.new(
+          lambda { |*args, options|
+            "val is #{options[:fun]}"
+          }
+        )
+      end
+
+      it "as hashes" do
+        template = Curlybars.compile(<<-HBS)
+          {{blog fun=(equal (blog fun=1) 'val is 1')}}
+        HBS
+
+        expect(eval(template)).to resemble(<<-HTML)
+          val is true
+        HTML
+      end
+    end
+
+    context "with yet another blog presenter" do
+      let(:presenter) do
+        IntegrationTest::BlogPresenter.new(
+          lambda { |*args, options|
+            first, second, third = args
+            "val is #{first}, #{second} and #{third}"
+          }
+        )
+      end
+
+      it "mixed paths and helpers" do
+        template = Curlybars.compile(<<-HBS)
+          {{blog baz.bat (equal a b) baz.bar}}
+        HBS
+
+        expect(eval(template)).to resemble(<<-HTML)
+          val is bat!, true and bar!
+        HTML
+      end
+    end
+
+    describe "GH-800 : Complex subexpressions" do
+      let(:presenter) do
+        IntegrationTest::LetterPresenter.new(
+          a: 'a', b: 'b', c: { c: 'c' }, d: 'd', e: { e: 'e' }
+        )
+      end
+
+      it "can handle complex subexpressions" do
+        inputs = [
+          "{{dash 'abc' (concat a b)}}",
+          "{{dash d (concat a b)}}",
+          "{{dash c.c (concat a b)}}",
+          "{{dash (concat a b) c.c}}",
+          "{{dash (concat a e.e) c.c}}"
+        ]
+
+        expected_results = [
+          "abc-ab",
+          "d-ab",
+          "c-ab",
+          "ab-c",
+          "ae-c"
+        ]
+
+        aggregate_failures do
+          inputs.each_with_index do |input, i|
+            expect(eval(Curlybars.compile(input))).to resemble(expected_results[i])
+          end
+        end
+      end
+    end
+
+    it "multiple subexpressions in a hash" do
+      template = Curlybars.compile(<<-HBS)
+        {{input aria-label=(t "Name") placeholder=(t "Example User")}}
+      HBS
+
+      expected_output = '<input aria-label="Name" placeholder="Example User" />'
+                        .gsub("<", "&lt;")
+                        .gsub(">", "&gt;")
+                        .gsub('"', "&quot;")
+
+      expect(eval(template)).to resemble(expected_output)
+    end
+
+    context "with item show presenter" do
+      let(:presenter) do
+        IntegrationTest::ItemShowPresenter.new(field: "Name", placeholder: "Example User")
+      end
+
+      it "multiple subexpressions in a hash with context" do
+        template = Curlybars.compile(<<-HBS)
+          {{input aria-label=(t item.field) placeholder=(t item.placeholder)}}
+        HBS
+
+        expected_output = '<input aria-label="Name" placeholder="Example User" />'
+                          .gsub("<", "&lt;")
+                          .gsub(">", "&gt;")
+                          .gsub('"', "&quot;")
+
+        expect(eval(template)).to resemble(expected_output)
+      end
+    end
+  end
+
+  describe "#validate" do
+    let(:presenter_class) { double(:presenter_class) }
+
+    before do
+      allow(Curlybars.configuration).to receive(:global_helpers_provider_classes).and_return([IntegrationTest::GlobalHelperProvider])
+    end
+
+    it "without errors when global helper" do
+      dependency_tree = {}
+
+      source = <<-HBS
+        {{#if (global_helper)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "with errors when invoking a leaf" do
+      dependency_tree = { name: nil }
+
+      source = <<-HBS
+        {{#if (name)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
+
+    it "without errors if argument is a leaf" do
+      dependency_tree = { helper: :helper, argument: nil }
+
+      source = <<-HBS
+        {{#if (helper argument)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors if argument is a literal" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper 'argument')}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors if argument is a variable" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper @var)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors if argument is another subexpression" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper (helper option='argument'))}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors if option is a leaf" do
+      dependency_tree = { helper: :helper, argument: nil }
+
+      source = <<-HBS
+        {{#if (helper option=argument)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors if option is a literal" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper option='argument')}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors if option is a variable" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper option=@var)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors if option is another subexpression" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper option=(helper))}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "with errors when helper does not exist" do
+      dependency_tree = {}
+
+      source = <<-HBS
+        {{#if (helper)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
+
+    it "with errors when invoking a leaf with arguments" do
+      dependency_tree = { name: nil }
+
+      source = <<-HBS
+        {{#if (name 'argument')}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
+
+    it "with errors when invoking a leaf with options" do
+      dependency_tree = { name: nil }
+
+      source = <<-HBS
+        {{#if (name option='value')}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
+
+    it "with errors if argument is not a value" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper not_a_value)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
+
+    it "with errors if option is not a value" do
+      dependency_tree = { helper: :helper }
+
+      source = <<-HBS
+        {{#if (helper option=not_a_value)}} ... {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
+
+    it "without errors when invoking a helper with the result of a subexpression" do
+      dependency_tree = { join: :helper, uppercase: :helper, article: nil }
+
+      source = <<-HBS
+        {{join (uppercase article) attribute='title' separator='-'}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+  end
+end

data/spec/integration/node/unless_else_spec.rb

@@ -96,7 +96,7 @@ describe "{{#unless}}...{{else}}...{{/unless}}" do
       expect(errors).not_to be_empty
     end
 
-    it "validates with errors the helper as condition" do
+    it "validates without errors when using a helper in the condition" do
       dependency_tree = { helper: :helper }
 
       source = <<-HBS
@@ -105,7 +105,7 @@ describe "{{#unless}}...{{else}}...{{/unless}}" do
 
       errors = Curlybars.validate(dependency_tree, source)
 
-      expect(errors).not_to be_empty
+      expect(errors).to be_empty
     end
 
     it "validates with errors the nested unless_template" do

data/spec/integration/visitor_spec.rb

@@ -4,6 +4,8 @@ describe "visitor" do
       {{#print_args_and_options 'first' 'second' key='value'}}
       {{/print_args_and_options}}
 
+      {{calc (calc 1 "+" 2) "*" 3}}
+
       {{#render_inverse}}
         fn
       {{else}}
@@ -53,7 +55,7 @@ describe "visitor" do
     it "visits BlockHelperElse nodes" do
       visitor = counting_visitor_for(Curlybars::Node::BlockHelperElse)
       output = Curlybars.visit(visitor, source)
-      expect(output).to eq(4)
+      expect(output).to eq(5)
     end
 
     it "visits EachElse nodes" do
@@ -71,13 +73,13 @@ describe "visitor" do
     it "visits Item nodes" do
       visitor = counting_visitor_for(Curlybars::Node::Item)
       output = Curlybars.visit(visitor, source)
-      expect(output).to eq(42)
+      expect(output).to eq(44)
     end
 
     it "visits Literal nodes" do
       visitor = counting_visitor_for(Curlybars::Node::Literal)
       output = Curlybars.visit(visitor, source)
-      expect(output).to eq(3)
+      expect(output).to eq(8)
     end
 
     it "visits Option nodes" do
@@ -95,7 +97,7 @@ describe "visitor" do
     it "visits Path nodes" do
       visitor = counting_visitor_for(Curlybars::Node::Path)
       output = Curlybars.visit(visitor, source)
-      expect(output).to eq(13)
+      expect(output).to eq(15)
     end
 
     it "visits Root nodes" do
@@ -104,6 +106,12 @@ describe "visitor" do
       expect(output).to eq(1)
     end
 
+    it "visits SubExpression nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::SubExpression)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(1)
+    end
+
     it "visits Template nodes" do
       visitor = counting_visitor_for(Curlybars::Node::Template)
       output = Curlybars.visit(visitor, source)
@@ -113,7 +121,7 @@ describe "visitor" do
     it "visits Text nodes" do
       visitor = counting_visitor_for(Curlybars::Node::Text)
       output = Curlybars.visit(visitor, source)
-      expect(output).to eq(28)
+      expect(output).to eq(29)
     end
 
     it "visits UnlessElse nodes" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curlybars
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.5.1
 platform: ruby
 authors:
 - Libo Cannici
@@ -10,10 +10,11 @@ authors:
 - Mauro Codella
 - Luís Almeida
 - Andreas Garnæs
+- Augusto Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-14 00:00:00.000000000 Z
+date: 2020-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -190,7 +191,7 @@ dependencies:
 description: |-
   A view layer for your Rails apps that separates structure and logic, using Handlebars templates.
   Strongly inspired by Curly Template gem by Daniel Schierbeck.
-email: libo@zendesk.com
+email: vikings@zendesk.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -219,6 +220,7 @@ files:
 - lib/curlybars/node/path.rb
 - lib/curlybars/node/root.rb
 - lib/curlybars/node/string.rb
+- lib/curlybars/node/sub_expression.rb
 - lib/curlybars/node/template.rb
 - lib/curlybars/node/text.rb
 - lib/curlybars/node/unless_else.rb
@@ -265,6 +267,7 @@ files:
 - spec/integration/node/partial_spec.rb
 - spec/integration/node/path_spec.rb
 - spec/integration/node/root_spec.rb
+- spec/integration/node/sub_expression_spec.rb
 - spec/integration/node/template_spec.rb
 - spec/integration/node/unless_else_spec.rb
 - spec/integration/node/unless_spec.rb
@@ -292,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Create your views using Handlebars templates!
@@ -318,6 +321,7 @@ test_files:
 - spec/integration/node/unless_else_spec.rb
 - spec/integration/node/output_spec.rb
 - spec/integration/node/if_spec.rb
+- spec/integration/node/sub_expression_spec.rb
 - spec/integration/node/unless_spec.rb
 - spec/integration/node/with_spec.rb
 - spec/integration/node/partial_spec.rb