curlybars 0.9.13

data/lib/curlybars/node/block_helper_else.rb

@@ -0,0 +1,108 @@
+require 'curlybars/error/compile'
+
+module Curlybars
+  module Node
+    BlockHelperElse = Struct.new(:helper, :arguments, :options, :helper_template, :else_template, :helperclose, :position) do
+      def compile
+        check_open_and_close_elements(helper, helperclose, Curlybars::Error::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
+          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[:fn] = ->(**vars) do
+            variables.push(vars.symbolize_keys)
+            outer_buffer = buffer
+            begin
+              buffer = ::Curlybars::SafeBuffer.new
+              #{helper_template.compile}
+              buffer
+            ensure
+              buffer = outer_buffer
+              variables.pop
+            end
+          end
+
+          options[:inverse] = ->(**vars) do
+            variables.push(vars.symbolize_keys)
+            outer_buffer = buffer
+            begin
+              buffer = ::Curlybars::SafeBuffer.new
+              #{else_template.compile}
+              buffer
+            ensure
+              buffer = outer_buffer
+              variables.pop
+            end
+          end
+
+          options[:this] = contexts.last
+
+          result = rendering.call(helper, #{helper.path.inspect}, helper_position,
+            arguments, options, &options[:fn])
+
+          unless rendering.presenter?(result) || rendering.presenter_collection?(result)
+            buffer.concat(result.to_s)
+          end
+        RUBY
+      end
+
+      def validate(branches)
+        check_open_and_close_elements(helper, helperclose, Curlybars::Error::Validate)
+
+        if helper.leaf?(branches)
+          if arguments.any? || options.any?
+            message = "#{helper.path} doesn't accept any arguments or options"
+            Curlybars::Error::Validate.new('invalid_signature', message, helper.position)
+          end
+        elsif helper.helper?(branches)
+          [
+            helper_template.validate(branches),
+            else_template.validate(branches),
+            arguments.map { |argument| argument.validate_as_value(branches) },
+            options.map { |option| option.validate(branches) }
+          ]
+        else
+          message = "#{helper.path} must be allowed as helper or leaf"
+          Curlybars::Error::Validate.new('invalid_block_helper', message, helper.position)
+        end
+      end
+
+      def cache_key
+        [
+          helper,
+          arguments,
+          options,
+          helper_template,
+          else_template,
+          helperclose
+        ].flatten.map(&:cache_key).push(self.class.name).join("/")
+      end
+
+      private
+
+      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
+    end
+  end
+end

data/lib/curlybars/node/boolean.rb

@@ -0,0 +1,24 @@
+module Curlybars
+  module Node
+    Boolean = Struct.new(:boolean) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          ->() { #{boolean} }
+        RUBY
+      end
+
+      def validate(branches)
+        # Nothing to validate here.
+      end
+
+      def cache_key
+        [
+          boolean.to_s,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/each_else.rb

@@ -0,0 +1,69 @@
+module Curlybars
+  module Node
+    EachElse = Struct.new(:path, :each_template, :else_template, :position) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          collection = rendering.cached_call(#{path.compile})
+
+          if rendering.to_bool(collection)
+            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.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|
+                begin
+                  contexts.push(key_and_presenter[1])
+                  variables.push({
+                    index: index,
+                    key: key_and_presenter[0],
+                    first: index == 0,
+                    last: index == (collection.length - 1),
+                  })
+                  #{each_template.compile}
+                ensure
+                  variables.pop
+                  contexts.pop
+                end
+              end
+            end
+          else
+            #{else_template.compile}
+          end
+        RUBY
+      end
+
+      def validate(branches)
+        resolved = path.resolve_and_check!(branches, check_type: :presenter_collection)
+        sub_tree = resolved.first
+
+        each_template_errors = begin
+          branches.push(sub_tree)
+          each_template.validate(branches)
+        ensure
+          branches.pop
+        end
+
+        else_template_errors = else_template.validate(branches)
+
+        [
+          each_template_errors,
+          else_template_errors
+        ]
+      rescue Curlybars::Error::Validate => path_error
+        path_error
+      end
+
+      def cache_key
+        [
+          path,
+          each_template,
+          else_template
+        ].map(&:cache_key).push(self.class.name).join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/if_else.rb

@@ -0,0 +1,33 @@
+module Curlybars
+  module Node
+    IfElse = Struct.new(:expression, :if_template, :else_template) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          if rendering.to_bool(rendering.cached_call(#{expression.compile}))
+            #{if_template.compile}
+          else
+            #{else_template.compile}
+          end
+        RUBY
+      end
+
+      def validate(branches)
+        [
+          expression.validate(branches),
+          if_template.validate(branches),
+          else_template.validate(branches)
+        ]
+      end
+
+      def cache_key
+        [
+          expression,
+          if_template,
+          else_template
+        ].map(&:cache_key).push(self.class.name).join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/item.rb

@@ -0,0 +1,31 @@
+module Curlybars
+  module Node
+    Item = Struct.new(:item) do
+      def compile
+        # 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, variables, buffer)
+              rendering.check_timeout!
+              #{item.compile}
+            end
+          end.exec(contexts, rendering, variables, buffer)
+        RUBY
+      end
+
+      def validate(branches)
+        catch(:skip_item_validation) do
+          item.validate(branches)
+        end
+      end
+
+      def cache_key
+        [
+          item.cache_key,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/literal.rb

@@ -0,0 +1,28 @@
+module Curlybars
+  module Node
+    Literal = Struct.new(:literal) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          ->() { #{literal} }
+        RUBY
+      end
+
+      def validate(branches)
+        # Nothing to validate here.
+      end
+
+      def validate_as_value(branches)
+        # It is always a value.
+      end
+
+      def cache_key
+        [
+          literal.to_s,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/option.rb

@@ -0,0 +1,25 @@
+module Curlybars
+  module Node
+    Option = Struct.new(:key, :expression) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          { #{key.to_s.inspect} => rendering.cached_call(#{expression.compile}) }
+        RUBY
+      end
+
+      def validate(branches)
+        expression.validate_as_value(branches)
+      end
+
+      def cache_key
+        [
+          key,
+          expression.cache_key,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/output.rb

@@ -0,0 +1,24 @@
+module Curlybars
+  module Node
+    Output = Struct.new(:value) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          buffer.concat(rendering.cached_call(#{value.compile}).to_s)
+        RUBY
+      end
+
+      def validate(branches)
+        value.validate(branches)
+      end
+
+      def cache_key
+        [
+          value.cache_key,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/partial.rb

@@ -0,0 +1,24 @@
+module Curlybars
+  module Node
+    Partial = Struct.new(:path) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          buffer.concat(rendering.cached_call(#{path.compile}).to_s)
+        RUBY
+      end
+
+      def validate(branches)
+        path.validate(branches, check_type: :partial)
+      end
+
+      def cache_key
+        [
+          path.cache_key,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/path.rb

@@ -0,0 +1,137 @@
+module Curlybars
+  module Node
+    Path = Struct.new(:path, :position) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+        rendering.path(
+            #{path.inspect},
+            rendering.position(#{position.line_number}, #{position.line_offset})
+          )
+        RUBY
+      end
+
+      def validate_as_value(branches)
+        validate(branches, check_type: :leaf)
+      end
+
+      def validate(branches, check_type: :anything)
+        resolve_and_check!(branches, check_type: check_type)
+        []
+      rescue Curlybars::Error::Validate => path_error
+        path_error
+      end
+
+      def resolve_and_check!(branches, check_type: :anything)
+        value = resolve(branches)
+
+        check_type_of(branches, check_type)
+
+        value
+      end
+
+      def presenter?(branches)
+        resolve(branches).is_a?(Hash)
+      end
+
+      def presenter_collection?(branches)
+        value = resolve(branches)
+        value.is_a?(Array) && value.first.is_a?(Hash)
+      end
+
+      def leaf?(branches)
+        value = resolve(branches)
+        value.nil?
+      end
+
+      def partial?(branches)
+        resolve(branches) == :partial
+      end
+
+      def helper?(branches)
+        resolve(branches) == :helper
+      end
+
+      def resolve(branches)
+        @value ||= begin
+          return :helper if global_helpers_dependency_tree.key?(path.to_sym)
+
+          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
+
+          throw :skip_item_validation unless base_tree_position > 0
+
+          base_tree_index = base_tree_position - 1
+          base_tree = branches[base_tree_index]
+
+          dotted_path_side = path_split_by_slashes.last
+
+          offset_adjustment = 0
+          dotted_path_side.split(/\./).map(&:to_sym).inject(base_tree) do |sub_tree, step|
+            begin
+              if step == :this
+                next sub_tree
+              elsif step == :length && (sub_tree.is_a?(Array) && sub_tree.first.is_a?(Hash))
+                next nil # :length is synthesised leaf
+              elsif !(sub_tree.is_a?(Hash) && sub_tree.key?(step))
+                message = step.to_s == path ? "'#{path}' does not exist" : "not possible to access `#{step}` in `#{path}`"
+                raise Curlybars::Error::Validate.new('unallowed_path', message, position, offset_adjustment, path: path, step: step)
+              end
+
+              sub_tree[step]
+            ensure
+              offset_adjustment += step.length + 1 # '1' is the length of the dot
+            end
+          end
+        end
+      end
+
+      def cache_key
+        [
+          path,
+          self.class.name
+        ].join("/")
+      end
+
+      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 :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 :anything
+        else
+          raise "invalid type `#{check_type}`"
+        end
+      end
+    end
+  end
+end