curlybars 1.3.1 → 1.7.0

data/spec/integration/cache_spec.rb

@@ -1,29 +1,31 @@
 describe "caching" do
-  class DummyCache
-    attr_reader :reads, :hits
-
-    def initialize
-      @store = {}
-      @reads = 0
-      @hits = 0
-    end
+  let(:dummy_cache) do
+    Class.new do
+      attr_reader :reads, :hits
+
+      def initialize
+        @store = {}
+        @reads = 0
+        @hits = 0
+      end
 
-    def fetch(key)
-      @reads += 1
-      if @store.key?(key)
-        @hits += 1
-        @store[key]
-      else
-        value = yield
-        @store[key] = value
-        value
+      def fetch(key)
+        @reads += 1
+        if @store.key?(key)
+          @hits += 1
+          @store[key]
+        else
+          value = yield
+          @store[key] = value
+          value
+        end
       end
     end
   end
 
   let(:global_helpers_providers) { [] }
   let(:presenter) { IntegrationTest::Presenter.new(double("view_context")) }
-  let(:cache) { DummyCache.new }
+  let(:cache) { dummy_cache.new }
 
   before do
     Curlybars.configure do |config|

data/spec/integration/node/block_helper_else_spec.rb

@@ -230,8 +230,6 @@ describe "{{#helper arg1 arg2 ... key=value ...}}...<{{else}}>...{{/helper}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "without errors when global helper" do
       allow(Curlybars.configuration).to receive(:global_helpers_provider_classes).and_return([IntegrationTest::GlobalHelperProvider])
 

data/spec/integration/node/each_else_spec.rb

@@ -1,9 +1,10 @@
 describe "{{#each collection}}...{{else}}...{{/each}}" do
-  let(:global_helpers_providers) { [] }
+  let(:global_helpers_providers) { [IntegrationTest::GlobalHelperProvider.new] }
 
   describe "#compile" do
     let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
+    let(:presenter_class) { IntegrationTest::Presenter }
+    let(:presenter) { presenter_class.new(double("view_context"), post: post) }
 
     it "uses each_template when collection is not empty" do
       allow(presenter).to receive(:allows_method?).with(:non_empty_collection).and_return(true)
@@ -123,6 +124,41 @@ describe "{{#each collection}}...{{else}}...{{/each}}" do
       HTML
     end
 
+    it "allows subexpressions" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each (articles)}}left{{else}}right{{/each}}
+      HBS
+
+      expected = "left" * presenter.articles.size
+      expect(eval(template)).to resemble(expected)
+    end
+
+    it "allows subexpressions with collection helpers" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each (reverse_articles)}}
+          {{title}}
+        {{else}}
+          right
+        {{/each}}
+      HBS
+
+      expected = presenter.reverse_articles.inject("") { |res, a| res + a.title }
+      expect(eval(template)).to resemble(expected)
+    end
+
+    it "allows subexpressions with generic collection helpers" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each (refl articles)}}
+          {{title}}
+        {{else}}
+          right
+        {{/each}}
+      HBS
+
+      expected = presenter.articles.inject("") { |res, a| res + a.title }
+      expect(eval(template)).to resemble(expected)
+    end
+
     it "raises an error if the context is not an array-like object" do
       allow(IntegrationTest::Presenter).to receive(:allows_method?).with(:not_a_collection).and_return(true)
       allow(presenter).to receive(:not_a_collection).and_return("string")
@@ -151,8 +187,6 @@ describe "{{#each collection}}...{{else}}...{{/each}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "without errors" do
       dependency_tree = { a_presenter_collection: [{}] }
 
@@ -200,5 +234,175 @@ describe "{{#each collection}}...{{else}}...{{/each}}" do
 
       expect(errors).not_to be_empty
     end
+
+    describe "with subexpressions" do
+      before do
+        Curlybars.instance_variable_set(:@global_helpers_dependency_tree, nil)
+      end
+
+      it "without errors when called with a presenter collection" do
+        dependency_tree = { a_presenter_collection: [{}] }
+
+        source = <<-HBS
+          {{#each (a_presenter_collection)}} {{else}} {{/each}}
+        HBS
+
+        errors = Curlybars.validate(dependency_tree, source)
+
+        expect(errors).to be_empty
+      end
+
+      it "without errors when called with a collection helper" do
+        dependency_tree = { a_collection_helper: [:helper, [{ url: nil }]] }
+
+        source = <<-HBS
+          {{#each (a_collection_helper)}}
+            {{url}}
+          {{else}}
+            right
+          {{/each}}
+        HBS
+
+        errors = Curlybars.validate(dependency_tree, source)
+
+        expect(errors).to be_empty
+      end
+
+      context "with a generic collection helper" do
+        it "without errors when arguments are valid" do
+          dependency_tree = {
+            refl: [:helper, [{}]],
+            articles: [{ url: nil }]
+          }
+
+          source = <<-HBS
+            {{#each (refl articles)}}
+              {{url}}
+            {{else}}
+              right
+            {{/each}}
+          HBS
+
+          errors = Curlybars.validate(dependency_tree, source)
+
+          expect(errors).to be_empty
+        end
+
+        it "with errors when the first argument is not a collection" do
+          dependency_tree = {
+            refl: [:helper, [{}]],
+            articles: { url: nil }
+          }
+
+          source = <<-HBS
+            {{#each (refl articles)}}
+              {{url}}
+            {{else}}
+              right
+            {{/each}}
+          HBS
+
+          errors = Curlybars.validate(dependency_tree, source)
+
+          expect(errors).not_to be_empty
+        end
+
+        it "with errors when the first argument is not defined" do
+          dependency_tree = {
+            refl: [:helper, [{}]]
+          }
+
+          source = <<-HBS
+            {{#each (refl articles)}}
+              {{url}}
+            {{else}}
+              right
+            {{/each}}
+          HBS
+
+          errors = Curlybars.validate(dependency_tree, source)
+
+          expect(errors).not_to be_empty
+        end
+
+        it "with errors when no argument is given" do
+          dependency_tree = {
+            refl: [:helper, [{}]]
+          }
+
+          source = <<-HBS
+            {{#each (refl)}}
+              {{url}}
+            {{else}}
+              right
+            {{/each}}
+          HBS
+
+          errors = Curlybars.validate(dependency_tree, source)
+
+          expect(errors).not_to be_empty
+        end
+
+        describe "as a global helper" do
+          let(:global_helpers_provider_classes) { [IntegrationTest::GlobalHelperProvider] }
+
+          before do
+            allow(Curlybars.configuration).to receive(:global_helpers_provider_classes).and_return(global_helpers_provider_classes)
+          end
+
+          it "without errors when the first argument is a collection" do
+            dependency_tree = {
+              articles: [{ url: nil }]
+            }
+
+            source = <<-HBS
+              {{#each (slice articles 0 4)}}
+                {{url}}
+              {{else}}
+                right
+              {{/each}}
+            HBS
+
+            errors = Curlybars.validate(dependency_tree, source)
+
+            expect(errors).to be_empty
+          end
+
+          it "with errors when the first argument is not a collection" do
+            dependency_tree = {
+              articles: { url: nil }
+            }
+
+            source = <<-HBS
+              {{#each (slice articles 0 4)}}
+                {{url}}
+              {{else}}
+                right
+              {{/each}}
+            HBS
+
+            errors = Curlybars.validate(dependency_tree, source)
+
+            expect(errors).not_to be_empty
+          end
+
+          it "with errors when no argument is given" do
+            dependency_tree = {}
+
+            source = <<-HBS
+              {{#each (slice)}}
+                {{url}}
+              {{else}}
+                right
+              {{/each}}
+            HBS
+
+            errors = Curlybars.validate(dependency_tree, source)
+
+            expect(errors).not_to be_empty
+          end
+        end
+      end
+    end
   end
 end

data/spec/integration/node/each_spec.rb

@@ -238,8 +238,6 @@ describe "{{#each collection}}...{{/each}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "without errors" do
       dependency_tree = { a_presenter_collection: [{}] }
 

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'}}
@@ -109,8 +121,6 @@ describe "{{helper context key=value}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "with errors" do
       dependency_tree = {}
 

data/spec/integration/node/if_else_spec.rb

@@ -82,8 +82,6 @@ describe "{{#if}}...{{else}}...{{/if}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "validates without errors the literal condition" do
       dependency_tree = {}
 

data/spec/integration/node/if_spec.rb

@@ -112,8 +112,6 @@ describe "{{#if}}...{{/if}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "validates with errors the condition" do
       dependency_tree = {}
 
@@ -140,7 +138,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 +147,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/output_spec.rb

@@ -51,8 +51,6 @@ describe '{{value}}' do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "validates the path with errors" do
       dependency_tree = {}
 

data/spec/integration/node/partial_spec.rb

@@ -25,8 +25,6 @@ describe "{{> partial}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "validates the path with errors" do
       dependency_tree = {}
 

data/spec/integration/node/path_spec.rb

@@ -123,8 +123,6 @@ describe "{{path}}" do
   end
 
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "without errors" do
       dependency_tree = { sub_context: {}, outer_field: nil }
 

data/spec/integration/node/root_spec.rb

@@ -1,7 +1,5 @@
 describe "root" do
   describe "#validate" do
-    let(:presenter_class) { double(:presenter_class) }
-
     it "without errors if template is empty" do
       dependency_tree = {}
 

data/spec/integration/node/sub_expression_spec.rb

@@ -0,0 +1,426 @@
+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
+    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