curlybars 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2be6d03409f5c575fb33c7ba4ed74117420fd22ddca8272005c5f23e459a0d8e
-  data.tar.gz: ad11b01849c9d28a70b2ae2260615665cc2dc3ca3c380b9dfbc2ab9c91bf1de3
+  metadata.gz: ba4b2799fad2886edfd0bc1c4873d8da9ed80d8885a1868f4b0fa5797fb9e49c
+  data.tar.gz: ee1bfc5d500f2ceee63675c5188d915227f507de7895c6ed2f08e89ddcae122e
 SHA512:
-  metadata.gz: ba6035a72fd5cf75120cc3adfc663192dae68d75132887b801bd29a53c4b655f6be09ed6b8e4a2ee497e708172c38db19258215b5f3b1a9b788371db20eeac3c
-  data.tar.gz: 83961d2f0ef03848c1ffb3feb9db859c866ff90e74d173f116b16c3af5ff4eac710e934cd7b3bb5039749f05169bd4f95e3f19fc208163f3333a6d66ba7261df
+  metadata.gz: 4233c4cd5ed833892d17603776a6db2abae2061cf72dfebe1add84bb7464e99b563cacee499fbcd447f59dd54a1ea3bf3b4aa18010526249aba2ed39a2310b96
+  data.tar.gz: f78754a1adc25de66302116338dd2abf9b4e9f8c2ae3439d1f74beda9065bb634c8fae64c19f65767be4d7389f1362559c0537f36bb438969e151bb93a47612f

data/lib/curlybars.rb

@@ -77,6 +77,13 @@ module Curlybars
       visitor.accept(tree)
     end
 
+    def global_helpers_dependency_tree
+      @global_helpers_dependency_tree ||= begin
+        classes = Curlybars.configuration.global_helpers_provider_classes
+        classes.map(&:dependency_tree).inject({}, :merge)
+      end
+    end
+
     def cache
       @cache ||= ActiveSupport::Cache::MemoryStore.new
     end
@@ -117,6 +124,7 @@ require 'curlybars/configuration'
 require 'curlybars/rendering_support'
 require 'curlybars/parser'
 require 'curlybars/position'
+require 'curlybars/generic'
 require 'curlybars/lexer'
 require 'curlybars/processor/token_factory'
 require 'curlybars/processor/tilde'

data/lib/curlybars/generic.rb

@@ -0,0 +1,36 @@
+require 'curlybars/method_whitelist'
+
+module Curlybars
+  # A base class that can be used to signify that a helper's return type is a sort a generic.
+  #
+  # Examples
+  #
+  #   class GlobalHelperProvider
+  #     extend Curlybars::MethodWhitelist
+  #
+  #     allow_methods slice:     [:helper, [Curlybars::Generic]],
+  #                   translate: [:helper, Curlybars::Generic]
+  #
+  #     def slice(collection, start, length, _)
+  #       collection[start, length]
+  #     end
+  #
+  #     def translate(object, locale)
+  #       object.translate(locale)
+  #     end
+  #   end
+  #
+  #   {{#each (slice articles, 0, 5)}}
+  #     Title: {{title}}
+  #     Body: {{body}}
+  #   {{/each}}
+  #
+  #   {{#with (translate article "en-us")}}
+  #     Title: {{title}}
+  #     Body: {{body}}
+  #   {{/with}}
+  #
+  class Generic
+    extend Curlybars::MethodWhitelist
+  end
+end

data/lib/curlybars/method_whitelist.rb

@@ -1,10 +1,11 @@
 module Curlybars
   module MethodWhitelist
-    # rubocop:disable Style/SoleNestedConditional
     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)
+            next if generic_or_collection_helper?(type)
+
             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
@@ -81,7 +82,15 @@ module Curlybars
           memo[method_name] = if type.respond_to?(:dependency_tree)
             type.dependency_tree(context)
           elsif type.is_a?(Array)
-            [type.first.dependency_tree(context)]
+            if type.first == :helper
+              if type.last.is_a?(Array)
+                [:helper, [type.last.first.dependency_tree(context)]]
+              else
+                [:helper, type.last.dependency_tree(context)]
+              end
+            else
+              [type.first.dependency_tree(context)]
+            end
           else
             type
           end
@@ -92,11 +101,21 @@ module Curlybars
         allowed_methods.include?(method)
       end
     end
-    # rubocop:enable Style/SoleNestedConditional
 
     def self.extended(base)
       # define a default of no method allowed
       base.allow_methods
     end
+
+    private
+
+    def generic_or_collection_helper?(type)
+      return false unless type.size == 2
+      return false unless type.first == :helper
+      return true if type.last.respond_to?(:dependency_tree)
+      return false unless type.last.is_a?(Array) && type.last.size == 1
+
+      type.last.first.respond_to?(:dependency_tree)
+    end
   end
 end

data/lib/curlybars/node/each_else.rb

@@ -11,7 +11,7 @@ module Curlybars
             position = rendering.position(#{position.line_number}, #{position.line_offset})
             template_cache_key = '#{each_template.cache_key}'
 
-            collection = rendering.coerce_to_hash!(collection, #{path.path.inspect}, position)
+            collection = rendering.coerce_to_hash!(collection, #{collection_path.path.inspect}, position)
             collection.each.with_index.map do |key_and_presenter, index|
               rendering.check_timeout!
               rendering.optional_presenter_cache(key_and_presenter[1], template_cache_key, buffer) do |buffer|
@@ -37,7 +37,7 @@ module Curlybars
       end
 
       def validate(branches)
-        resolved = path.resolve_and_check!(branches, check_type: :presenter_collection)
+        resolved = path.resolve_and_check!(branches, check_type: :collectionlike)
         sub_tree = resolved.first
 
         each_template_errors = begin
@@ -57,6 +57,10 @@ module Curlybars
         path_error
       end
 
+      def collection_path
+        path.subexpression? ? path.helper : path
+      end
+
       def cache_key
         [
           path,

data/lib/curlybars/node/path.rb

@@ -35,11 +35,18 @@ module Curlybars
         resolve(branches).is_a?(Hash)
       end
 
-      def presenter_collection?(branches)
-        value = resolve(branches)
+      def presenter_value?(value)
+        value.is_a?(Hash)
+      end
+
+      def collection_value?(value)
         value.is_a?(Array) && value.first.is_a?(Hash)
       end
 
+      def presenter_collection?(branches)
+        collection_value?(resolve(branches))
+      end
+
       def leaf?(branches)
         value = resolve(branches)
         value.nil?
@@ -53,9 +60,41 @@ module Curlybars
         resolve(branches) == :helper
       end
 
+      def generic_helper?(branches)
+        value = resolve(branches)
+        value.is_a?(Array) &&
+          value.first == :helper &&
+          presenter_value?(value.last)
+      end
+
+      def generic_collection_helper?(branches)
+        value = resolve(branches)
+        value.is_a?(Array) &&
+          value.first == :helper &&
+          collection_value?(value.last)
+      end
+
+      def collectionlike?(branches)
+        presenter_collection?(branches) || generic_collection_helper?(branches)
+      end
+
+      def presenterlike?(branches)
+        presenter?(branches) || generic_helper?(branches)
+      end
+
+      def subexpression?
+        false
+      end
+
       def resolve(branches)
         @value ||= begin
-          return :helper if global_helpers_dependency_tree.key?(path.to_sym)
+          if Curlybars.global_helpers_dependency_tree.key?(path.to_sym)
+            dep_node = Curlybars.global_helpers_dependency_tree[path.to_sym]
+
+            return :helper if dep_node.nil?
+
+            return [:helper, dep_node]
+          end
 
           path_split_by_slashes = path.split('/')
           backward_steps_on_branches = path_split_by_slashes.count - 1
@@ -97,14 +136,6 @@ module Curlybars
 
       private
 
-      # TODO: extract me away
-      def global_helpers_dependency_tree
-        @global_helpers_dependency_tree ||= begin
-          classes = Curlybars.configuration.global_helpers_provider_classes
-          classes.map(&:dependency_tree).inject({}, :merge)
-        end
-      end
-
       def check_type_of(branches, check_type)
         case check_type
         when :presenter
@@ -112,6 +143,16 @@ module Curlybars
 
           message = "`#{path}` must resolve to a presenter"
           raise Curlybars::Error::Validate.new('not_a_presenter', message, position)
+        when :presenterlike
+          return if presenterlike?(branches)
+
+          message = "`#{path}` must resolve to a presenter"
+          raise Curlybars::Error::Validate.new('not_presenterlike', message, position)
+        when :collectionlike
+          return if collectionlike?(branches)
+
+          message = "`#{path}` must resolve to a collection of presenters"
+          raise Curlybars::Error::Validate.new('not_collectionlike', message, position)
         when :presenter_collection
           return if presenter_collection?(branches)
 

data/lib/curlybars/node/sub_expression.rb

@@ -1,6 +1,10 @@
 module Curlybars
   module Node
     SubExpression = Struct.new(:helper, :arguments, :options, :position) do
+      def subexpression?
+        true
+      end
+
       def compile
         compiled_arguments = arguments.map do |argument|
           "arguments.push(rendering.cached_call(#{argument.compile}))"
@@ -50,6 +54,48 @@ module Curlybars
         ]
       end
 
+      def resolve_and_check!(branches, check_type: :collectionlike)
+        node = if arguments.first.is_a?(Curlybars::Node::SubExpression)
+          arguments.first
+        else
+          helper
+        end
+
+        type = node.resolve_and_check!(branches, check_type: check_type)
+
+        if helper?(type)
+          if generic_helper?(type)
+            is_collection = type.last.is_a?(Array)
+            return infer_generic_helper_type!(branches, is_collection: is_collection)
+          end
+
+          return type.last
+        end
+
+        type
+      end
+
+      def generic_helper?(type)
+        return false unless type.is_a?(Array)
+        return false unless type.size == 2
+        return false unless type.first == :helper
+
+        type.last == [{}] || type.last == {}
+      end
+
+      def helper?(type)
+        type.first == :helper
+      end
+
+      def infer_generic_helper_type!(branches, is_collection:)
+        if arguments.empty?
+          raise Curlybars::Error::Validate.new('missing_path', "'#{helper.path}' requires a collection as its first argument", helper.position)
+        end
+
+        check_type = is_collection ? :presenter_collection : :presenter
+        arguments.first.resolve_and_check!(branches, check_type: check_type)
+      end
+
       def cache_key
         [
           helper,

data/lib/curlybars/node/with_else.rb

@@ -9,7 +9,7 @@ module Curlybars
 
           if rendering.to_bool(compiled_path)
             position = rendering.position(#{position.line_number}, #{position.line_offset})
-            rendering.check_context_is_presenter(compiled_path, #{path.path.inspect}, position)
+            rendering.check_context_is_presenter(compiled_path, #{presenter_path.path.inspect}, position)
 
             contexts.push(compiled_path)
             begin
@@ -24,7 +24,7 @@ module Curlybars
       end
 
       def validate(branches)
-        sub_tree = path.resolve_and_check!(branches, check_type: :presenter)
+        sub_tree = path.resolve_and_check!(branches, check_type: :presenterlike)
         with_template_errors = begin
           branches.push(sub_tree)
           with_template.validate(branches)
@@ -42,6 +42,10 @@ module Curlybars
         path_error
       end
 
+      def presenter_path
+        path.subexpression? ? path.helper : path
+      end
+
       def cache_key
         [
           path,

data/lib/curlybars/parser.rb

@@ -112,6 +112,12 @@ module Curlybars
         Node::EachElse.new(path, each_template || VOID, VOID, pos(0))
       end
 
+      clause('START HASH EACH .subexpression END
+              .template?
+            START SLASH EACH END') do |subexpression, each_template|
+        Node::EachElse.new(subexpression, each_template || VOID, VOID, pos(0))
+      end
+
       clause('START HASH EACH .path END
                .template?
              START ELSE END
@@ -120,12 +126,26 @@ module Curlybars
         Node::EachElse.new(path, each_template || VOID, else_template || VOID, pos(0))
       end
 
+      clause('START HASH EACH .subexpression END
+               .template?
+             START ELSE END
+               .template?
+             START SLASH EACH END') do |subexpression, each_template, else_template|
+        Node::EachElse.new(subexpression, each_template || VOID, else_template || VOID, pos(0))
+      end
+
       clause('START HASH WITH .path END
                .template?
              START SLASH WITH END') do |path, with_template|
         Node::WithElse.new(path, with_template || VOID, VOID, pos(0))
       end
 
+      clause('START HASH WITH .subexpression END
+              .template?
+            START SLASH WITH END') do |subexpression, with_template|
+        Node::WithElse.new(subexpression, with_template || VOID, VOID, pos(0))
+      end
+
       clause('START HASH WITH .path END
                .template?
              START ELSE END
@@ -134,6 +154,14 @@ module Curlybars
         Node::WithElse.new(path, with_template || VOID, else_template || VOID, pos(0))
       end
 
+      clause('START HASH WITH .subexpression END
+              .template?
+            START ELSE END
+              .template?
+            START SLASH WITH END') do |subexpression, with_template, else_template|
+        Node::WithElse.new(subexpression, with_template || VOID, else_template || VOID, pos(0))
+      end
+
       clause('START GT .path END') do |path|
         Node::Partial.new(path)
       end

data/lib/curlybars/version.rb

@@ -1,3 +1,3 @@
 module Curlybars
-  VERSION = '1.6.0'.freeze
+  VERSION = '1.7.0'.freeze
 end

data/spec/curlybars/method_whitelist_spec.rb

@@ -36,16 +36,20 @@ describe Curlybars::MethodWhitelist do
 
   describe ".allow_methods" do
     before do
-      link_presenter = Class.new
-      article_presenter = Class.new
+      link_presenter = Class.new { extend Curlybars::MethodWhitelist }
+      article_presenter = Class.new { extend Curlybars::MethodWhitelist }
 
       dummy_class.class_eval do
-        allow_methods :cook, link: link_presenter, article: article_presenter
+        allow_methods :cook, link: link_presenter, article: article_presenter,
+                      translate_article: [:helper, article_presenter],
+                      reverse_articles: [:helper, [article_presenter]],
+                      translate: [:helper, Curlybars::Generic],
+                      slice: [:helper, [Curlybars::Generic]]
       end
     end
 
     it "sets the allowed methods" do
-      expect(dummy_class.new.allowed_methods).to eq([:cook, :link, :article])
+      expect(dummy_class.new.allowed_methods).to eq([:cook, :link, :article, :translate_article, :reverse_articles, :translate, :slice])
     end
 
     it "supports adding more methods for validation" do

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")
@@ -198,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/with_spec.rb

@@ -1,5 +1,5 @@
 describe "{{#with presenter}}...{{/with}}" do
-  let(:global_helpers_providers) { [] }
+  let(:global_helpers_providers) { [IntegrationTest::GlobalHelperProvider.new] }
 
   describe "#compile" do
     let(:post) { double("post") }
@@ -31,6 +31,18 @@ describe "{{#with presenter}}...{{/with}}" do
       HTML
     end
 
+    it "allows subexpressions" do
+      template = Curlybars.compile(<<-HBS)
+        {{#with (translate user "sk-SK")}}
+          {{avatar.url}}
+        {{/with}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        http://example.com/foo.png?locale=sk-SK
+      HTML
+    end
+
     it "allows empty with_template" do
       template = Curlybars.compile(<<-HBS)
         {{#with user}}{{/with}}
@@ -39,7 +51,7 @@ describe "{{#with presenter}}...{{/with}}" do
       expect(eval(template)).to resemble("")
     end
 
-    it "renders the else templte if the context is nil" do
+    it "renders the else template if the context is nil" do
       template = Curlybars.compile(<<-HBS)
         {{#with return_nil}}
           text
@@ -87,6 +99,34 @@ describe "{{#with presenter}}...{{/with}}" do
       expect(errors).to be_empty
     end
 
+    it "without errors when a presenter helper is used" do
+      dependency_tree = { translate_article: [:helper, { title: nil }] }
+
+      source = <<-HBS
+        {{#with (translate_article 12345 "en-US")}}
+          {{title}}
+        {{/with}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
+    it "without errors when a generic presenter helper is used" do
+      dependency_tree = { article: { title: nil }, translate: [:helper, {}] }
+
+      source = <<-HBS
+        {{#with (translate article "en-US")}}
+          {{title}}
+        {{/with}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).to be_empty
+    end
+
     it "with errors due to a leaf" do
       dependency_tree = { not_a_presenter: nil }
 
@@ -110,5 +150,29 @@ describe "{{#with presenter}}...{{/with}}" do
 
       expect(errors).not_to be_empty
     end
+
+    it "with errors due collection helpers" do
+      dependency_tree = { reverse_articles: [:helper, [{ title: nil }]] }
+
+      source = <<-HBS
+        {{#with (reverse_articles)}}{{/with}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
+
+    it "with errors due generic collection helpers" do
+      dependency_tree = { articles: [{ title: nil }], slice: [:helper, [{}]] }
+
+      source = <<-HBS
+        {{#with (slice articles 0 4)}}{{/with}}
+      HBS
+
+      errors = Curlybars.validate(dependency_tree, source)
+
+      expect(errors).not_to be_empty
+    end
   end
 end

data/spec/integration/processor/tilde_spec.rb

@@ -30,7 +30,7 @@ describe "tilde operator" do
     it "runs even when 'run_processors' flag is set to false" do
       allow(Curlybars::Processor::Tilde).to receive(:process!)
 
-      Curlybars.validate(presenter, "source", run_processors: false)
+      Curlybars.validate(presenter.dependency_tree, "source", run_processors: false)
 
       expect(Curlybars::Processor::Tilde).to have_received(:process!)
     end

data/spec/integration/processors_spec.rb

@@ -9,19 +9,19 @@ describe "processors" do
 
   describe "validation" do
     it "are run by default" do
-      Curlybars.validate(presenter, "source")
+      Curlybars.validate(presenter.dependency_tree, "source")
 
       expect(processor).to have_received(:process!)
     end
 
-    it "are not run when run_processors is true" do
-      Curlybars.validate(presenter, "source", run_processors: true)
+    it "are run when run_processors is true" do
+      Curlybars.validate(presenter.dependency_tree, "source", run_processors: true)
 
       expect(processor).to have_received(:process!)
     end
 
     it "are not run when run_processors is false" do
-      Curlybars.validate(presenter, "source", run_processors: false)
+      Curlybars.validate(presenter.dependency_tree, "source", run_processors: false)
 
       expect(processor).not_to have_received(:process!)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curlybars
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Libo Cannici
@@ -11,10 +11,11 @@ authors:
 - Luís Almeida
 - Andreas Garnæs
 - Augusto Silva
+- Attila Večerek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2021-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -234,6 +235,7 @@ files:
 - lib/curlybars/error/presenter/not_found.rb
 - lib/curlybars/error/render.rb
 - lib/curlybars/error/validate.rb
+- lib/curlybars/generic.rb
 - lib/curlybars/lexer.rb
 - lib/curlybars/method_whitelist.rb
 - lib/curlybars/node/block_helper_else.rb