curlybars 1.1.4 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d425b234907702e06326b091a5dd9bea96d8a5494796e122ee77c56a79dd63ae
-  data.tar.gz: c23f25a52b8c252ebb5aae349c01faefb7daff9e3e8a112e12f676249ad21f23
+  metadata.gz: 92b6cb3082b3fc52f509b72511b93937529f57170d4f8751f989e17727418889
+  data.tar.gz: cbe9843e0852ccdb2bd9aabcb4c77e4856de40e60bbc01f6dc10d17e3987754a
 SHA512:
-  metadata.gz: 63657e140e3377cea321adfb20ff4ff1445e1bb00901e49e5f9b095f65b25b6d89cd2ef814e425f9abc7b0ed62d4d003c52459f8f7810943359f9160a9c64b7a
-  data.tar.gz: 077401e926e847f7ee34df7ebce3a0323ae57c9ce6daa8454b67bc6ce6785807cfe96dfcdf406f8a7928f2d2ba992e344d8a7a8581f32c55e3f0459a82dd1f94
+  metadata.gz: 8a3cb40974bd6568a73b5640452403da9b40e63da6bc152fadd4ea375961cb8c5de21d561f094f5b181359c791ddf4237a0a58022ae2bd3b38d012748ae9eb6b
+  data.tar.gz: 4bd84f5a24ee7fcb3f59fac17844d65638f496f22c263fc1e94c47aac65c84e848718f1695a20421ade814c9e7e98f17b0e10d58b14920fccb33d92987606e6b

data/lib/curlybars.rb

@@ -28,12 +28,7 @@ module Curlybars
       cache_key = ["Curlybars.compile", identifier, Digest::SHA256.hexdigest(source)]
 
       cache.fetch(cache_key) do
-        transformers = Curlybars.configuration.compiler_transformers
-        transformed_source = transformers.inject(source) do |memo, transformer|
-          transformer.transform(memo, identifier)
-        end
-
-        ast(transformed_source, identifier, run_processors: true).compile
+        ast(transformed_source(source), identifier, run_processors: true).compile
       end
     end
 
@@ -72,6 +67,16 @@ module Curlybars
       errors.empty?
     end
 
+    # Visit nodes in the AST.
+    #
+    # visitor - An instance of a subclass of `Curlybars::Visitor`.
+    # source - The source HBS String used to generate an AST.
+    # identifier - The the file name of the template being checked (defaults to `nil`).
+    def visit(visitor, source, identifier = nil)
+      tree = ast(transformed_source(source), identifier, run_processors: true)
+      visitor.accept(tree)
+    end
+
     def cache
       @cache ||= ActiveSupport::Cache::MemoryStore.new
     end
@@ -80,6 +85,13 @@ module Curlybars
 
     private
 
+    def transformed_source(source)
+      transformers = Curlybars.configuration.compiler_transformers
+      transformers.inject(source) do |memo, transformer|
+        transformer.transform(memo, identifier)
+      end
+    end
+
     def ast(source, identifier, run_processors:)
       tokens = Curlybars::Lexer.lex(source, identifier)
 
@@ -118,3 +130,4 @@ require 'curlybars/template_handler'
 require 'curlybars/railtie' if defined?(Rails)
 require 'curlybars/presenter'
 require 'curlybars/method_whitelist'
+require 'curlybars/visitor'

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/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/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.1.4'.freeze
+  VERSION = '1.4.0'.freeze
 end

data/lib/curlybars/visitor.rb

@@ -0,0 +1,100 @@
+require 'active_support/core_ext/string/inflections'
+
+module Curlybars
+  class Visitor
+    attr_accessor :context
+
+    def initialize(context)
+      @context = context
+    end
+
+    def accept(node)
+      visit(node)
+      context
+    end
+
+    private
+
+    def visit(node)
+      class_name = node.class.name.to_s
+      return unless class_name.start_with?('Curlybars::Node')
+
+      method_name = class_name.demodulize.underscore
+      send("visit_#{method_name}", node)
+    end
+
+    def visit_block_helper_else(node)
+      node.arguments.each { |arg| visit(arg) }
+      node.options.each { |opt| visit(opt) }
+      visit(node.helper)
+      visit(node.helper_template)
+      visit(node.else_template)
+    end
+
+    def visit_boolean(_node)
+    end
+
+    def visit_each_else(node)
+      visit(node.path)
+      visit(node.each_template)
+      visit(node.else_template)
+    end
+
+    def visit_if_else(node)
+      visit(node.expression)
+      visit(node.if_template)
+      visit(node.else_template)
+    end
+
+    def visit_item(node)
+      visit(node.item)
+    end
+
+    def visit_literal(_node)
+    end
+
+    def visit_option(node)
+      visit(node.expression)
+    end
+
+    def visit_output(node)
+      visit(node.value)
+    end
+
+    def visit_partial(node)
+      visit(node.path)
+    end
+
+    def visit_path(_node)
+    end
+
+    def visit_root(node)
+      visit(node.template)
+    end
+
+    def visit_string(_node)
+    end
+
+    def visit_template(node)
+      node.items.each { |item| visit(item) }
+    end
+
+    def visit_text(_node)
+    end
+
+    def visit_unless_else(node)
+      visit(node.expression)
+      visit(node.unless_template)
+      visit(node.else_template)
+    end
+
+    def visit_variable(_node)
+    end
+
+    def visit_with_else(node)
+      visit(node.path)
+      visit(node.with_template)
+      visit(node.else_template)
+    end
+  end
+end

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

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

data/spec/integration/visitor_spec.rb

@@ -0,0 +1,146 @@
+describe "visitor" do
+  let(:source) do
+    <<-HBS
+      {{#print_args_and_options 'first' 'second' key='value'}}
+      {{/print_args_and_options}}
+
+      {{#render_inverse}}
+        fn
+      {{else}}
+        inverse
+        {{@variable}}
+      {{/render_inverse}}
+
+      {{#each foo}}
+        top
+        {{#each bar}}
+          middle
+          {{#each baz}}
+            inner
+          {{else}}
+            inner inverse
+          {{/each}}
+        {{/each}}
+      {{/each}}
+
+      {{#if valid}}
+        if_template
+        {{#if bar}}
+          foo
+        {{else}}
+          qux
+        {{/if}}
+      {{/if}}
+
+      {{#if baz}}
+        qux
+      {{/if}}
+
+      {{> partial}}
+
+      {{user.avatar.url}}
+      {{#with this}}
+        {{user.avatar.url}}
+      {{/with}}
+
+      {{#unless things}}
+        hi
+      {{/unless}}
+    HBS
+  end
+
+  describe ".visit" do
+    it "visits BlockHelperElse nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::BlockHelperElse)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(4)
+    end
+
+    it "visits EachElse nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::EachElse)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(3)
+    end
+
+    it "visits IfElse nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::IfElse)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(3)
+    end
+
+    it "visits Item nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Item)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(42)
+    end
+
+    it "visits Literal nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Literal)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(3)
+    end
+
+    it "visits Option nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Option)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(1)
+    end
+
+    it "visits Partial nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Partial)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(1)
+    end
+
+    it "visits Path nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Path)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(13)
+    end
+
+    it "visits Root nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Root)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(1)
+    end
+
+    it "visits Template nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Template)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(14)
+    end
+
+    it "visits Text nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Text)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(28)
+    end
+
+    it "visits UnlessElse nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::UnlessElse)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(1)
+    end
+
+    it "visits Variable nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::Variable)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(1)
+    end
+
+    it "visits WithElse nodes" do
+      visitor = counting_visitor_for(Curlybars::Node::WithElse)
+      output = Curlybars.visit(visitor, source)
+      expect(output).to eq(1)
+    end
+  end
+
+  def counting_visitor_for(klass)
+    Class.new(Curlybars::Visitor) do
+      define_method "visit_#{klass.name.demodulize.underscore}" do |node|
+        self.context += 1
+        super(node)
+      end
+    end.new(0)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curlybars
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.4.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: 2018-10-25 00:00:00.000000000 Z
+date: 2020-09-29 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: []
@@ -234,6 +235,7 @@ files:
 - lib/curlybars/safe_buffer.rb
 - lib/curlybars/template_handler.rb
 - lib/curlybars/version.rb
+- lib/curlybars/visitor.rb
 - spec/acceptance/application_layout_spec.rb
 - spec/acceptance/collection_blocks_spec.rb
 - spec/acceptance/global_helper_spec.rb
@@ -270,6 +272,7 @@ files:
 - spec/integration/node/with_spec.rb
 - spec/integration/processor/tilde_spec.rb
 - spec/integration/processors_spec.rb
+- spec/integration/visitor_spec.rb
 homepage: https://github.com/zendesk/curlybars
 licenses:
 - Apache-2.0
@@ -290,8 +293,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Create your views using Handlebars templates!
@@ -312,6 +314,7 @@ test_files:
 - spec/integration/processor/tilde_spec.rb
 - spec/integration/exception_spec.rb
 - spec/integration/processors_spec.rb
+- spec/integration/visitor_spec.rb
 - spec/integration/node/escape_spec.rb
 - spec/integration/node/unless_else_spec.rb
 - spec/integration/node/output_spec.rb