curlybars 1.3.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f83af0f1fc951b9a35dd68ae1b3bd181799031cf37913100574c65d98de5e870
-  data.tar.gz: 954af845f827c80b1fced94ad10ed5f1bcaf99dc872f3b54435ab9e23c3d82e3
+  metadata.gz: ba4b2799fad2886edfd0bc1c4873d8da9ed80d8885a1868f4b0fa5797fb9e49c
+  data.tar.gz: ee1bfc5d500f2ceee63675c5188d915227f507de7895c6ed2f08e89ddcae122e
 SHA512:
-  metadata.gz: f75d2a62e3c4dec26b01bf04928d624e70a0b807cf99c40ac0b5b6a03e421e5f296f6a5eaed609bb7bd4679bbe402ebfd0e8626c6f2527a8118afd71aa937522
-  data.tar.gz: 748d32d09437bdf7bd02b5d607aee846cabd02ab015a837ec95ccc00e451099f21cf71f3b5a7cb305e8d4f8bfe18145b7401531db55cb8ba4fc0ad66906e259e
+  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,8 +124,8 @@ require 'curlybars/configuration'
 require 'curlybars/rendering_support'
 require 'curlybars/parser'
 require 'curlybars/position'
+require 'curlybars/generic'
 require 'curlybars/lexer'
-require 'curlybars/parser'
 require 'curlybars/processor/token_factory'
 require 'curlybars/processor/tilde'
 require 'curlybars/error/lex'

data/lib/curlybars/configuration.rb

@@ -16,15 +16,7 @@ module Curlybars
   end
 
   class Configuration
-    attr_accessor :presenters_namespace
-    attr_accessor :nesting_limit
-    attr_accessor :traversing_limit
-    attr_accessor :output_limit
-    attr_accessor :rendering_timeout
-    attr_accessor :custom_processors
-    attr_accessor :compiler_transformers
-    attr_accessor :global_helpers_provider_classes
-    attr_accessor :cache
+    attr_accessor :presenters_namespace, :nesting_limit, :traversing_limit, :output_limit, :rendering_timeout, :custom_processors, :compiler_transformers, :global_helpers_provider_classes, :cache
 
     def initialize
       @presenters_namespace = ''

data/lib/curlybars/error/base.rb

@@ -8,8 +8,10 @@ module Curlybars
         @id = id
         @position = position
         @metadata = metadata
+
         return if position.nil?
         return if position.file_name.nil?
+
         location = "%s:%d:%d" % [position.file_name, position.line_number, position.line_offset]
         set_backtrace([location])
       end

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

@@ -32,6 +32,9 @@ module Curlybars
     r(/{{/) { push_state :curly; :START }
     r(/}}/, :curly) { pop_state; :END }
 
+    r(/\(/, :curly) { push_state :curly; :LPAREN }
+    r(/\)/, :curly) { pop_state; :RPAREN }
+
     r(/#/, :curly) { :HASH }
     r(/\//, :curly) { :SLASH }
     r(/>/, :curly) { :GT }

data/lib/curlybars/method_whitelist.rb

@@ -4,6 +4,8 @@ module Curlybars
       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
@@ -49,8 +51,8 @@ module Curlybars
           memo[method] = nil
         end
 
-        methods_with_type_resolved = all_methods_with_type.each_with_object({}) do |(method_name, type), memo|
-          memo[method_name] = if type.respond_to?(:call)
+        methods_with_type_resolved = all_methods_with_type.transform_values do |type|
+          if type.respond_to?(:call)
             type.call(context)
           else
             type
@@ -65,6 +67,7 @@ module Curlybars
         # Included modules
         included_modules.each do |mod|
           next unless mod.respond_to?(:methods_schema)
+
           schema.merge!(mod.methods_schema(context))
         end
 
@@ -79,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
@@ -95,5 +106,16 @@ module Curlybars
       # 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/block_helper_else.rb

@@ -100,6 +100,7 @@ module Curlybars
 
       def check_open_and_close_elements(helper, helperclose, error_class)
         return unless helper.path != helperclose.path
+
         message = "block `#{helper.path}` cannot be closed by `#{helperclose.path}`"
         raise error_class.new('closing_tag_mismatch', message, helperclose.position)
       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/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/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,38 +136,46 @@ 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
           return if presenter?(branches)
+
           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)
+
           message = "`#{path}` must resolve to a collection of presenters"
           raise Curlybars::Error::Validate.new('not_a_presenter_collection', message, position)
         when :leaf
           return if leaf?(branches)
+
           message = "`#{path}` cannot resolve to a component"
           raise Curlybars::Error::Validate.new('not_a_leaf', message, position)
         when :partial
           return if partial?(branches)
+
           message = "`#{path}` cannot resolve to a partial"
           raise Curlybars::Error::Validate.new('not_a_partial', message, position)
         when :helper
           return if helper?(branches)
+
           message = "`#{path}` cannot resolve to a helper"
           raise Curlybars::Error::Validate.new('not_a_helper', message, position)
         when :not_helper
           return unless helper?(branches)
+
           message = "`#{path}` resolves to a helper"
           raise Curlybars::Error::Validate.new('is_a_helper', message, position)
         when :anything

data/lib/curlybars/node/sub_expression.rb

@@ -0,0 +1,108 @@
+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}))"
+        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 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,
+          arguments,
+          options
+        ].flatten.map(&:cache_key).push(self.class.name).join("/")
+      end
+    end
+  end
+end