curlybars 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92b6cb3082b3fc52f509b72511b93937529f57170d4f8751f989e17727418889
-  data.tar.gz: cbe9843e0852ccdb2bd9aabcb4c77e4856de40e60bbc01f6dc10d17e3987754a
+  metadata.gz: 662148aedd0a8a6fdb84727cbe92b66fe66abf3fc11fa3e7720d70337fd9c1ff
+  data.tar.gz: 9b599e7c0232ee1442e6f9e410a7e19f10405ea0dbb150bc309121a18be6afef
 SHA512:
-  metadata.gz: 8a3cb40974bd6568a73b5640452403da9b40e63da6bc152fadd4ea375961cb8c5de21d561f094f5b181359c791ddf4237a0a58022ae2bd3b38d012748ae9eb6b
-  data.tar.gz: 4bd84f5a24ee7fcb3f59fac17844d65638f496f22c263fc1e94c47aac65c84e848718f1695a20421ade814c9e7e98f17b0e10d58b14920fccb33d92987606e6b
+  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/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/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/version.rb

@@ -1,3 +1,3 @@
 module Curlybars
-  VERSION = '1.4.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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curlybars
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Libo Cannici
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-29 00:00:00.000000000 Z
+date: 2020-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -220,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
@@ -266,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
@@ -293,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+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