blocks 2.8.0 → 3.0.0.rc1

data/lib/blocks/renderers/block_placeholder.rb

@@ -0,0 +1,13 @@
+module Blocks
+  class BlockPlaceholder
+    attr_accessor :block_definition
+
+    def initialize(block_definition)
+      self.block_definition = block_definition
+    end
+
+    def to_s
+      "PLACEHOLDER_FOR_#{block_definition.name} "
+    end
+  end
+end

data/lib/blocks/renderers/block_renderer.rb

@@ -0,0 +1,13 @@
+module Blocks
+  class BlockRenderer < AbstractRenderer
+    def render(*args, runtime_context)
+      render_item = runtime_context.render_item
+      if render_item.is_a?(String)
+        output_buffer << partial_renderer.render(render_item, runtime_context)
+      elsif render_item.is_a?(Proc)
+        args = args + runtime_context.runtime_args
+        output_buffer << capture(*args, runtime_context, &render_item)
+      end
+    end
+  end
+end

data/lib/blocks/renderers/block_with_hooks_renderer.rb

@@ -0,0 +1,35 @@
+module Blocks
+  # TODO: Make this render order customizable
+  class BlockWithHooksRenderer < AbstractRenderer
+    def render(*args, &default_definition)
+      with_output_buffer do
+        runtime_context = RuntimeContext.new(builder, *args, &default_definition)
+        if !runtime_context.skip_completely
+          adjacent_blocks_renderer.render(HookDefinition::BEFORE_ALL, runtime_context)
+          nesting_blocks_renderer.render(HookDefinition::AROUND_ALL, runtime_context) do
+            wrapper_renderer.render(runtime_context.wrap_all, runtime_context) do
+              collection_renderer.render(runtime_context) do |runtime_context|
+                wrapper_renderer.render(runtime_context.wrap_each, runtime_context) do
+                  nesting_blocks_renderer.render(HookDefinition::AROUND, runtime_context) do
+                    adjacent_blocks_renderer.render(HookDefinition::BEFORE, runtime_context)
+                    if !runtime_context.skip_content
+                      wrapper_renderer.render(runtime_context.wrap_with, runtime_context) do
+                        nesting_blocks_renderer.render(HookDefinition::SURROUND, runtime_context) do
+                          adjacent_blocks_renderer.render(HookDefinition::PREPEND, runtime_context)
+                          block_renderer.render(runtime_context)
+                          adjacent_blocks_renderer.render(HookDefinition::APPEND, runtime_context)
+                        end
+                      end
+                    end
+                    adjacent_blocks_renderer.render(HookDefinition::AFTER, runtime_context)
+                  end
+                end
+              end
+            end
+          end
+          adjacent_blocks_renderer.render(HookDefinition::AFTER_ALL, runtime_context)
+        end
+      end
+    end
+  end
+end

data/lib/blocks/renderers/collection_renderer.rb

@@ -0,0 +1,17 @@
+module Blocks
+  class CollectionRenderer < AbstractRenderer
+    def render(runtime_context)
+      collection = runtime_context.collection
+      if collection
+        object_name = runtime_context.as || :object
+        collection.each_with_index do |item, index|
+          item_runtime_context = runtime_context.merge(object_name => item, current_index: index)
+          item_runtime_context.runtime_args = [item] + item_runtime_context.runtime_args
+          yield item_runtime_context
+        end
+      else
+        yield runtime_context
+      end
+    end
+  end
+end

data/lib/blocks/renderers/nesting_blocks_renderer.rb

@@ -0,0 +1,24 @@
+module Blocks
+  class NestingBlocksRenderer < AbstractRenderer
+    def render(hook, runtime_context, &block)
+      block = block_for(runtime_context.block_name)
+      if block
+        content_block = Proc.new { with_output_buffer { yield } }
+        hooks = block.hooks_for(hook)
+
+        renderer = hooks.inject(content_block) do |inner_content, block_definition|
+          hook_runtime_context = runtime_context.extend_to_block_definition(block_definition)
+          Proc.new {
+            with_output_buffer do
+              block_renderer.render(inner_content, hook_runtime_context)
+            end
+          }
+        end
+
+        output_buffer << renderer.call
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/blocks/renderers/partial_renderer.rb

@@ -0,0 +1,18 @@
+module Blocks
+  class PartialRenderer < AbstractRenderer
+    def render(partial, options={}, &block)
+      overrides_and_provided_content = capture(builder, &block) if block_given?
+      locals = options.merge(
+        (options[:builder_variable] || :builder) => builder,
+      ).symbolize_keys
+      locals[:options] = options
+      view.render(layout: partial, locals: locals) do |*args|
+        if overrides_and_provided_content
+          overrides_and_provided_content.to_str.gsub(/PLACEHOLDER_FOR_([\w]+)/) do |s|
+            builder.render $1, *args
+          end.html_safe
+        end
+      end
+    end
+  end
+end

data/lib/blocks/renderers/renderer.rb

@@ -0,0 +1,43 @@
+module Blocks
+  class Renderer
+    attr_accessor :builder
+
+    def initialize(builder)
+      self.builder = builder
+    end
+
+    def render(*args, &block)
+      block_with_hooks_renderer.render(*args, &block)
+    end
+
+    # TODO: this needs to be handled by a new renderer
+    def render_with_overrides(*args, &block)
+      options = args.extract_options!
+      name = args.first
+      if name.is_a?(Symbol) || name.is_a?(String)
+        block_with_hooks_renderer.render(*args, options, &block)
+      elsif options[:partial]
+        partial_renderer.render(options.delete(:partial), options, &block)
+      else
+        # TODO: handle other possible rendering methods such as a custom renderer
+      end
+    end
+
+    # TODO: this needs to be handled by a new renderer
+    #  TODO: also get rid of BlockPlaceholder
+    def deferred_render(*args, &block)
+      block_definition = builder.define(*args, &block)
+      Blocks::BlockPlaceholder.new(block_definition)
+    end
+
+    AbstractRenderer::RENDERERS.each do |klass|
+      name = klass.to_s.demodulize.underscore
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}
+          @#{name} ||= #{klass}.new(self)
+        end
+      RUBY
+    end
+  end
+end

data/lib/blocks/renderers/runtime_context.rb

@@ -0,0 +1,193 @@
+module Blocks
+  class RuntimeContext < HashWithRenderStrategy
+    CONTROL_VARIABLES = {
+      wrap_all: [],
+      wrap_each: [:outer_wrapper],
+      wrap_with: [:wrap, :wrapper, :inner_wrapper],
+      collection: [],
+      as: []
+    }
+
+    attr_accessor(*CONTROL_VARIABLES.keys)
+    attr_accessor :block_name,
+                  :runtime_block,
+                  :builder,
+                  :render_item,
+                  :runtime_args,
+                  :render_options_set,
+                  :block_options_set,
+                  :proxy_options_set,
+                  :parent_options_set,
+                  :merged_options_set
+
+    delegate :skip_content, :skip_completely, to: :block_options_set, allow_nil: true
+
+    delegate :block_definitions, :block_defined?, to: :builder
+
+    delegate :runtime_options,
+             :standard_options,
+             :default_options,
+             :options_set,
+             prefix: :builder,
+             to: :builder
+
+    def initialize(builder, *runtime_args, &runtime_block)
+      super(&nil)
+
+      self.builder = builder
+      self.runtime_block = runtime_block
+      self.proxy_options_set = OptionsSet.new("Proxy Options Set")
+
+      convert_render_options(runtime_args.extract_options!)
+      identify_block(runtime_args.shift)
+
+      self.runtime_args = runtime_args
+      merge_options_and_identify_render_item
+      extract_control_options
+    end
+
+    def extend_to_block_definition(block_definition)
+      RuntimeContext.new(builder, block_definition, parent_options_set: merged_options_set.clone).tap do |rc|
+        rc.runtime_args = self.runtime_args
+      end
+    end
+
+    # TODO: this method needs to be rewritten to output a proper hash
+    def to_s
+      description = []
+      if block_name
+        block_name = self.block_name.to_s
+        if block_name.include?(" ")
+          block_name = ":\"#{block_name}\""
+        else
+          block_name = ":#{block_name}"
+        end
+        description << "Block Name: #{block_name}"
+      end
+
+      if render_item.is_a?(String)
+        description << "Renders with partial \"#{render_item}\""
+      elsif render_item.is_a?(Proc)
+        description << "Renders with block defined at #{render_item.source_location}"
+      end
+
+
+      CONTROL_VARIABLES.each do |control_variable, *|
+        if value = send(control_variable)
+          description << "#{control_variable}: #{value} [#{callers[control_variable]}]"
+        end
+      end
+
+      description << super
+      description.join("\n")
+    end
+
+    private
+
+    def convert_render_options(render_options)
+      if !render_options.is_a?(HashWithIndifferentAccess)
+        render_options = render_options.with_indifferent_access
+      end
+      self.parent_options_set = render_options.delete(:parent_options_set)
+      self.render_options_set = OptionsSet.new(
+        "Render Options",
+        defaults: render_options.delete(:defaults),
+        runtime: render_options
+      )
+    end
+
+    def identify_block(block_identifier)
+      self.block_name, self.block_options_set = if block_identifier.is_a?(OptionsSet)
+        [block_identifier.name, block_identifier]
+      elsif block_defined?(block_identifier)
+        [block_identifier, block_definitions[block_identifier]]
+      elsif block_identifier.is_a?(Proc)
+        # TODO: figure out how to do this
+      else
+        [block_identifier, nil]
+      end
+    end
+
+    def add_proxy_options(proxy_block_name)
+      if block_defined?(proxy_block_name)
+        proxy_block = block_definitions[proxy_block_name]
+
+        proxy_options_set.add_options(proxy_block)
+
+        render_strategy, render_item = proxy_block.current_render_strategy_and_item
+
+        if render_strategy == RENDER_WITH_PROXY
+          add_proxy_options render_item
+        else
+          render_item
+        end
+
+      elsif builder.respond_to?(proxy_block_name)
+        Proc.new do |*args|
+          options = args.extract_options!
+          runtime_block = runtime_block || options[:block]
+          builder.send(proxy_block_name, *args, options, &runtime_block)
+        end
+      end
+    end
+
+    def merge_options_and_identify_render_item
+      determined_render_item = false
+      all_options_sets = [
+        render_options_set,
+        block_options_set,
+        OptionsSet.new("Runtime Block", block: self.runtime_block),
+        builder_options_set,
+        Blocks.global_options_set,
+        parent_options_set
+      ].compact
+
+      options_set_with_render_strategy_index = nil
+      all_options_sets.
+        map(&:render_strategies_and_items).
+        transpose.
+        detect do |options_for_level|
+          options_set_with_render_strategy_index = options_for_level.index(&:present?)
+          if options_set_with_render_strategy_index.present?
+            self.render_strategy, self.render_item =
+              options_for_level[options_set_with_render_strategy_index]
+            true
+          end
+        end
+
+      if self.render_strategy == RENDER_WITH_PROXY
+        self.render_item = add_proxy_options render_item
+      end
+
+      self.merged_options_set = OptionsSet.new("Parent Options Set")
+      [:runtime_options, :standard_options, :default_options].each do |option_level|
+        all_options_sets.each_with_index do |options_set, index|
+          options_for_level = options_set.send(option_level)
+          merged_options_set.send(option_level).add_options(options_for_level)
+          add_options options_for_level
+
+          if index == options_set_with_render_strategy_index
+            options_for_level = proxy_options_set.send(option_level)
+            merged_options_set.send(option_level).add_options(options_for_level)
+            add_options options_for_level
+          end
+        end
+      end
+
+      if render_item.blank?
+        self.render_item = runtime_block
+      end
+    end
+
+    def extract_control_options
+      CONTROL_VARIABLES.each do |control_variable, synonyms|
+        variant = (Array(synonyms) + Array(control_variable)).detect {|variant| key?(variant)}
+        value = delete(variant)
+        callers[control_variable] = callers[variant] if value
+        self.send("#{control_variable}=", value)
+      end
+
+      RENDERING_STRATEGIES.each {|rs| delete(rs) }
+    end
+  end
+end

data/lib/blocks/renderers/wrapper_renderer.rb

@@ -0,0 +1,19 @@
+module Blocks
+  class WrapperRenderer < AbstractRenderer
+    def render(wrapper, runtime_context, &block)
+      content_block = Proc.new { with_output_buffer { yield } }
+      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)
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/blocks/utilities/configurator.rb

@@ -0,0 +1,26 @@
+module Blocks
+  module Configurator
+    extend ActiveSupport::Concern
+
+    included do
+      include DynamicConfiguration
+
+      add_config :builder_class
+      add_config :renderer_class
+      add_config :global_options_set
+      add_config :lookup_caller_location, instance_predicate: true
+      reset_config
+    end
+
+    module ClassMethods
+      def reset_config
+        configure do |config|
+          config.builder_class = Builder
+          config.renderer_class = Renderer
+          config.lookup_caller_location = true
+          config.global_options_set = OptionsSet.new("Global Options")
+        end
+      end
+    end
+  end
+end

data/lib/blocks/utilities/dynamic_configuration.rb

@@ -0,0 +1,71 @@
+module Blocks
+  module DynamicConfiguration
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def add_config(*attrs)
+        options = attrs.extract_options!
+        instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+        instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+        instance_predicate = options.fetch(:instance_predicate, true)
+        default_value = options.fetch(:default, nil)
+
+        attrs.each do |name|
+          define_singleton_method(name) do |value="UNDEFINED"|
+            if value == "UNDEFINED"
+              default_value
+            else
+              public_send("#{name}=", value)
+            end
+          end
+          define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+          ivar = "@#{name}"
+
+          define_singleton_method("#{name}=") do |val|
+            singleton_class.class_eval do
+              remove_possible_method(name)
+              define_method(name) do |value="UNDEFINED"|
+                if value == "UNDEFINED"
+                  val
+                else
+                  public_send("#{name}=", value)
+                end
+              end
+            end
+
+            class_eval do
+              remove_possible_method(name)
+              define_method(name) do
+                if instance_variable_defined? ivar
+                  instance_variable_get ivar
+                else
+                  singleton_class.send name
+                end
+              end
+            end
+            val
+          end
+
+          if instance_reader
+            remove_possible_method name
+            define_method(name) do
+              if instance_variable_defined?(ivar)
+                instance_variable_get ivar
+              else
+                self.class.public_send name
+              end
+            end
+            define_method("#{name}?") { !!public_send(name) } if instance_predicate
+          end
+
+          attr_writer name if instance_writer
+        end
+      end
+
+      def configure
+        yield self
+      end
+    end
+  end
+end