curlybars 1.2.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7aaafd32b96d9cdf8e9af98ebe3636fc14d4df85761eea4ac804d4b623e1d186
-  data.tar.gz: f177926ffc2cf7c9026a15f6ba7f43089cc9bab4da6e3318ab29a38003f4afdd
+  metadata.gz: 662148aedd0a8a6fdb84727cbe92b66fe66abf3fc11fa3e7720d70337fd9c1ff
+  data.tar.gz: 9b599e7c0232ee1442e6f9e410a7e19f10405ea0dbb150bc309121a18be6afef
 SHA512:
-  metadata.gz: 25125dc3e0887ee7878a09f29e96c56f6d863d4aea21cb4c37e226d032cd9b5006c6a512837a9893b95188308d72de426673c8d8815c6d942bdad1ca60032403
-  data.tar.gz: 2cc5791470872a77703979523e3de41a0db3491b8dd453628dc2c68ffe00dbef6374db91feb2da56ddae6edf75d5e6c21c5da3947048a3e320eb67da4d6a10c6
+  metadata.gz: 35b139b2d8c393a2a5a0f413edb687dfae425d315ef22b6cf9652a34a2367737dab922417c52494983f32e10b4f86dbc85ff62a12ac30cf178b7953af3dae3f1
+  data.tar.gz: 271f1f72a18ec374eadead76df6eda66e982ee5863d0be690903d581fbf6387cd83af6e9dbeed2b1351bfd2206c99a7b74ef4619fe2166c2b8a446033a164eac

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/item.rb

@@ -15,9 +15,9 @@ module Curlybars
       end
 
       def validate(branches)
-        catch(:skip_item_validation) do
-          item.validate(branches)
-        end
+        item.validate(branches)
+      rescue Curlybars::Error::Validate => path_error
+        path_error
       end
 
       def cache_key

data/lib/curlybars/node/path.rb

@@ -60,10 +60,10 @@ module Curlybars
           path_split_by_slashes = path.split('/')
           backward_steps_on_branches = path_split_by_slashes.count - 1
           base_tree_position = branches.length - backward_steps_on_branches
+          base_tree_index = base_tree_position - 1
 
-          throw :skip_item_validation unless base_tree_position > 0
+          raise Curlybars::Error::Validate.new('unallowed_path', "'#{path}' goes out of scope", position) if base_tree_index < 0
 
-          base_tree_index = base_tree_position - 1
           base_tree = branches[base_tree_index]
 
           dotted_path_side = path_split_by_slashes.last

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.0'.freeze
+  VERSION = '1.5.0'.freeze
 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_else_spec.rb

@@ -137,5 +137,36 @@ describe "{{#if}}...{{else}}...{{/if}}" do
 
       expect(errors).not_to be_empty
     end
+
+    it "validates errors the nested else_template when out of context" do
+      dependency_tree = { condition: nil }
+
+      source = <<-HBS
+        {{#if ../condition}}
+        {{else}}
+          {{unallowed_ELSE_method}}
+        {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors.count).to eq(2)
+    end
+
+    it "gives all possible errors found in validation" do
+      dependency_tree = { condition: nil }
+
+      source = <<-HBS
+        {{#if ../condition}}
+          {{unallowed_IF_method}}
+        {{else}}
+          {{unallowed_ELSE_method}}
+        {{/if}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors.count).to eq(3)
+    end
   end
 end

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/path_spec.rb

@@ -139,7 +139,7 @@ describe "{{path}}" do
       expect(errors).to be_empty
     end
 
-    it "without errors when it goes out of context" do
+    it "gives errors errors when it goes out of context" do
       dependency_tree = {}
 
       source = <<-HBS
@@ -148,7 +148,7 @@ describe "{{path}}" do
 
       errors = Curlybars.validate(dependency_tree, source)
 
-      expect(errors).to be_empty
+      expect(errors).not_to be_empty
     end
 
     it "without errors using `this`" do
@@ -257,6 +257,18 @@ describe "{{path}}" do
         end
       end
 
+      it "with errors when going outside of scope" do
+        dependency_tree = { ok: { ok: { ok: nil } } }
+
+        source = <<~HBS
+          {{../ok.ok.ok}}
+        HBS
+
+        errors = Curlybars.validate(dependency_tree, source)
+
+        expect(errors.first.message).to eq("'../ok.ok.ok' goes out of scope")
+      end
+
       describe "raises exact location of unallowed steps" do
         let(:dependency_tree) { { ok: { allowed: { ok: nil } } } }
 

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curlybars
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.5.0
 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-03-15 00:00:00.000000000 Z
+date: 2020-10-27 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,8 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Create your views using Handlebars templates!
@@ -319,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