blocks 3.0.4 → 4.0.0.rc1

data/lib/blocks/renderers/wrapper_renderer.rb

@@ -1,18 +1,29 @@
+# frozen_string_literal: true
+
 module Blocks
-  class WrapperRenderer < AbstractRenderer
-    def render(wrapper, runtime_context)
-      content_block = Proc.new { with_output_buffer { yield } }
+  class WrapperRenderer
+    def self.render(wrapper, wrapper_type, runtime_context)
+      output_buffer = runtime_context.output_buffer
+
       if wrapper.nil?
         yield
+
       elsif wrapper.is_a?(Proc)
-        output_buffer << capture(content_block, *(runtime_context.runtime_args), runtime_context, &wrapper)
-      elsif block_definition = block_for(wrapper)
-        runtime_context = runtime_context.extend_to_block_definition(block_definition)
-        block_renderer.render(content_block, runtime_context)
-      elsif builder.respond_to?(wrapper)
-        output_buffer << builder.send(wrapper, runtime_context, &content_block)
+        output_buffer << runtime_context.capture(
+          Proc.new { runtime_context.with_output_buffer { yield } },
+          *(runtime_context.runtime_args),
+          runtime_context.to_hash.merge(wrapper_type: wrapper_type),
+          &wrapper
+        )
+
       else
-        yield
+        wrapper_runtime_context = runtime_context.extend_from_definition(
+          wrapper,
+          wrapper_type: wrapper_type
+        ) do
+          runtime_context.with_output_buffer { yield }
+        end
+        output_buffer << BlockWithHooksRenderer.render(wrapper_runtime_context)
       end
     end
   end

data/lib/blocks/utilities/configurator.rb

@@ -1,14 +1,27 @@
+# frozen_string_literal: true
+
 module Blocks
   module Configurator
     extend ActiveSupport::Concern
 
     included do
-      include DynamicConfiguration
+      mattr_accessor :builder_class
+      mattr_accessor :renderer_class
+      mattr_accessor :global_options
+      mattr_accessor :lookup_caller_location
+      mattr_accessor :track_caller
+      # TODO: add default_defintions option
+      # TODO: add submodules / extensions option
+      # TODO: add option to specify render order for nesting hooks
+
+      # Specifies whether the default options specified for a render call will take priority over ones specified as block default options
+      #  Legacy versions of Blocks had default render options always take precedence over block-level default options
+      mattr_accessor :default_render_options_take_precedence_over_block_defaults
+
+      # Specifies whether a block defined with a proc will receive a collection item as its first argument when rendering collections
+      #  Legacy versions of Blocks assumed that the collection item would be the first argument
+      mattr_accessor :collection_item_passed_to_block_as_first_arg
 
-      add_config :builder_class
-      add_config :renderer_class
-      add_config :global_options_set
-      add_config :lookup_caller_location, instance_predicate: true
       reset_config
     end
 
@@ -18,7 +31,18 @@ module Blocks
           config.builder_class = Builder
           config.renderer_class = Renderer
           config.lookup_caller_location = false
-          config.global_options_set = OptionsSet.new("Global Options")
+          config.track_caller = false
+          config.global_options = nil
+          config.default_render_options_take_precedence_over_block_defaults = false
+          config.collection_item_passed_to_block_as_first_arg = false
+        end
+      end
+
+      def configure
+        yield self
+        self.track_caller = true if lookup_caller_location
+        if track_caller
+          HashWithRenderStrategy.send(:prepend, HashWithCaller)
         end
       end
     end

data/lib/blocks/utilities/hash_with_caller.rb

@@ -1,41 +1,49 @@
+# frozen_string_literal: true
+
 module Blocks
-  class HashWithCaller < HashWithIndifferentAccess
+  module HashWithCaller
     attr_accessor :callers
 
     def initialize(*args)
-      self.callers = HashWithIndifferentAccess.new
-      options = args.extract_options!
-      add_options(args.first, options)
-      super &nil
+      self.callers = {}
+      super
     end
 
-    def to_s
-      description = []
-
-      description << "{"
-      description << map do |key, value|
-        value_display = case value
-        when Symbol
-          ":#{value}"
-        when String
-          "\"#{value}\""
-        when Proc
-          "Proc"
-        else
-          value
-        end
-        "\"#{key}\" => #{value_display}, # [#{callers[key]}]"
-      end.join(",\n")
-      description << "}"
-      description.join("\n")
+    def initialize_copy(original)
+      super
+      self.callers = original.callers.clone
     end
 
-    def add_options(*args)
+    # TODO: implement inspect
+
+    # TODO: fix and test this implementation
+    # def to_s
+    #   description = []
+    #
+    #   description << "{"
+    #   description << map do |key, value|
+    #     value_display = case value
+    #     when Symbol
+    #       ":#{value}"
+    #     when String
+    #       "\"#{value}\""
+    #     when Proc
+    #       "Proc"
+    #     else
+    #       value
+    #     end
+    #     "\"#{key}\" => #{value_display}, # [#{callers[key]}]"
+    #   end.join(",\n")
+    #   description << "}"
+    #   description.join("\n")
+    # end
+
+    def reverse_merge!(*args)
       options = args.extract_options!
 
       caller_id = args.first.to_s.presence || ""
 
-      if !options.is_a?(HashWithCaller) && Blocks.lookup_caller_location?
+      if !options.is_a?(HashWithCaller) && Blocks.lookup_caller_location
         caller_location = caller.detect do |c|
           !c.include?("/lib/blocks") &&
           !c.include?("/lib/ruby") &&
@@ -55,19 +63,15 @@ module Blocks
         end
 
         if !self.key?(key)
-          self[key] = value
           callers[key] = setter
 
         elsif current_value.is_a?(Hash) && value.is_a?(Hash)
-          self[key] = value.deep_merge(current_value)
+          # self[key] = value.deep_merge(current_value)
           callers[key] = "#{callers[key]}, #{setter}"
-          # TODO: handle attribute merges here
         end
       end
-    end
 
-    def nested_under_indifferent_access
-      self
+      super options
     end
   end
 end

data/lib/blocks/utilities/hash_with_render_strategy.rb

@@ -1,36 +1,35 @@
+# frozen_string_literal: true
+
 module Blocks
-  class HashWithRenderStrategy < HashWithCaller
+  class HashWithRenderStrategy < Hash
     attr_accessor :render_strategy
 
     RENDER_WITH_PROXY = :with
     RENDER_WITH_BLOCK = :block
     RENDER_WITH_PARTIAL = :partial
 
-    RENDERING_STRATEGIES = [RENDER_WITH_PROXY, RENDER_WITH_BLOCK, RENDER_WITH_PARTIAL]
+    RENDERING_STRATEGIES = [RENDER_WITH_PROXY, RENDER_WITH_PARTIAL, RENDER_WITH_BLOCK]
 
-    def initialize_copy(original)
-      super
-      self.callers = original.callers.clone
-      self.render_strategy = nil
-      RENDERING_STRATEGIES.each do |rs|
-        self.delete(rs)
-      end
+    def initialize(*args, &block)
+      super &nil
+      options = args.extract_options!
+      reverse_merge!(args.first, options, &block)
     end
 
-    alias_method :dup, :clone
+    def to_hash
+      {}.update(self)
+    end
 
-    def reverse_merge(options)
-      self.clone.tap {|cloned| cloned.add_options(options) }
+    def slice(*keys)
+      self.class.new(super)
     end
 
-    # TODO: need to implement either merge or update to update
-    #  both the hash and the callers hash
+    def except(*keys)
+      slice(*self.keys - keys)
+    end
 
-    def add_options(*args, &block)
+    def reverse_merge!(*args, &block)
       options = args.extract_options!
-      if !options.is_a?(HashWithIndifferentAccess)
-        options = options.with_indifferent_access
-      end
       options[:block] = block if block
       if render_strategy.nil?
         self.render_strategy = if options.is_a?(HashWithRenderStrategy)
@@ -40,11 +39,60 @@ module Blocks
         end
       end
 
-      super(*args, options)
+      options.each do |key, value|
+        current_value = self[key]
+
+        if !self.key?(key)
+          self[key] = value
+        elsif current_value.is_a?(Hash) && value.is_a?(Hash)
+          # TODO: handle attribute merges here
+          self[key] = value.deep_merge(current_value)
+        end
+      end
     end
 
     def render_strategy_and_item
       [render_strategy, self[render_strategy]] if render_strategy
     end
+
+    def render_strategy_item
+      self[render_strategy] if render_strategy
+    end
+
+    def renders_with_proxy?
+      render_strategy == RENDER_WITH_PROXY
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
+    # this class.
+    def extractable_options?
+      true
+    end
+
+    def to_s
+      description = []
+
+      description << "{"
+      description << map do |key, value|
+        value_display = case value
+        when Symbol
+          ":#{value}"
+        when String
+          "\"#{value}\""
+        when Proc
+          "Proc"
+        else
+          value
+        end
+        # "\"#{key}\" => #{value_display}, # [#{callers[key]}]"
+        "\"#{key}\" => #{value_display}"
+      end.join(",\n")
+      description << "}"
+      description.join("\n")
+    end
   end
 end

data/lib/blocks/utilities/options_set.rb

@@ -1,95 +1,70 @@
+# frozen_string_literal: true
+
 module Blocks
-  class OptionsSet < HashWithIndifferentAccess
+  class OptionsSet < HashWithRenderStrategy
     attr_accessor :name
-
-    attr_accessor :runtime_options
-    attr_accessor :standard_options
     attr_accessor :default_options
 
     def initialize(*args, &block)
-      options = args.extract_options!
-      self.name = args.first
-      reset
-      add_options options, &block
-      super(&nil)
-    end
-
-    def initialize_copy(original)
       super
-      control_fields = (
-        RuntimeContext::CONTROL_VARIABLES.keys +
-        RuntimeContext::CONTROL_VARIABLES.values
-      ).flatten.compact
-      self.runtime_options = original.runtime_options.clone.except(*control_fields)
-      self.default_options = original.default_options.clone.except(*control_fields)
-      self.standard_options = original.standard_options.clone.except(*control_fields)
-    end
-
-    def to_s
-      description = []
-      description << "Block Name: #{name}"
-      description << "------------------------------"
-      description << "Runtime Options:"
-      description << runtime_options.to_s
-      description << "------------------------------"
-      description << "Standard Options:"
-      description << standard_options.to_s
-      description << "------------------------------"
-      description << "Default Options:"
-      description << default_options.to_s
-      description.join("\n")
+      self.name = args.first
     end
 
+    # def to_s
+    #   description = []
+    #   description << "Block Name: #{name}"
+    #   description << "------------------------------"
+    #   description << "Standard Options:"
+    #   description << standard_options.to_s
+    #   description << "------------------------------"
+    #   description << "Default Options:"
+    #   description << default_options.to_s
+    #   description.join("\n")
+    # end
+    #
     def inspect
-      hash = standard_options.to_hash
-      hash[:defaults] = default_options if default_options.present?
-      hash[:runtime] = runtime_options if runtime_options.present?
+      hash = to_hash
+      hash[:defaults] = default_options.to_hash if default_options.present?
       hash
     end
 
-    def add_options(*args, &block)
+    def reverse_merge!(*args, &block)
       options = args.extract_options!
       caller_id = args.first
 
-      runtime, defaults, standard = if options.is_a?(OptionsSet)
+      defaults, standard = if options.is_a?(OptionsSet)
         caller_id ||= options.name
-        [options.runtime_options, options.default_options, options.standard_options]
+        [options.default_options, options]
       else
-        if !options.is_a?(HashWithIndifferentAccess)
-          options = options.with_indifferent_access
-        end
-        [options.delete(:runtime), options.delete(:defaults), options]
+        [options.delete(:defaults), options]
       end
 
       caller_id ||= self.name
 
-      runtime_options.add_options caller_id, runtime
-      standard_options.add_options caller_id, standard, &block
-      default_options.add_options caller_id, defaults
+      if standard.present? || block
+        super caller_id, standard, &block
+      end
 
-      self
-    end
+      if defaults.present?
+        if !default_options
+          self.default_options = HashWithRenderStrategy.new "#{name} Default Options"
+        end
+        default_options.reverse_merge! caller_id, defaults
+      end
 
-    def reset
-      self.runtime_options = HashWithRenderStrategy.new "#{name} Runtime Options"
-      self.standard_options = HashWithRenderStrategy.new "#{name} Standard Options"
-      self.default_options = HashWithRenderStrategy.new "#{name} Default Options"
+      self
     end
 
-    def current_render_strategy_and_item
-      render_strategies_and_items.compact.first
+    def renders_with_proxy?
+      render_strategy == HashWithRenderStrategy::RENDER_WITH_PROXY
     end
 
-    def render_strategies_and_items
-      [
-        runtime_options.render_strategy_and_item,
-        standard_options.render_strategy_and_item,
-        default_options.render_strategy_and_item
-      ]
+    def render_strategy
+      super || default_options.try(:render_strategy)
     end
 
-    def nested_under_indifferent_access
-      self
+    def render_strategy_item
+      super || default_options.try(:render_strategy_item)
     end
   end
 end

data/lib/blocks/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Blocks
-  VERSION = "3.0.4"
+  VERSION = "4.0.0.rc1"
 end