blocks 2.8.0 → 3.0.0.rc1

data/lib/blocks/action_view_extensions/view_extensions.rb

@@ -0,0 +1,26 @@
+require 'action_view'
+
+module Blocks
+  module ViewExtensions
+    def blocks
+      @blocks ||= Blocks.builder_class.new(self)
+    end
+
+    def render_with_overrides(*args, &block)
+      options = args.extract_options!.with_indifferent_access
+      partial = options.delete(:partial) || options.delete(:template) || args.first
+      if builder = options.delete(:builder)
+        builder.view = self
+        # builder = builder.clone
+        # TODO: figure out what to do here
+      else
+        builder = Blocks.builder_class.new(self, options)
+      end
+      builder.render_with_overrides(options.merge(partial: partial), &block)
+    end
+    alias_method :with_template, :render_with_overrides
+
+  end
+end
+
+ActionView::Base.send :include, Blocks::ViewExtensions

data/lib/blocks/builders/block_definition.rb

@@ -0,0 +1,71 @@
+module Blocks
+  class BlockDefinition < OptionsSet
+    attr_accessor :options_set,
+                  :skip_content,
+                  :skip_completely,
+                  *HookDefinition::HOOKS.map {|hook| "#{hook}_hooks" }
+
+
+    def initialize(*args, &block)
+      super
+    end
+
+    def skip(completely=false)
+      self.skip_content = true
+      self.skip_completely = completely
+    end
+
+    def skip_content?
+      !!skip_content
+    end
+
+    def skip_completely?
+      !!skip_completely
+    end
+
+    def hooks_for(hook_name)
+      self.send("#{hook_name}_hooks")
+    end
+
+    HookDefinition::HOOKS.each do |hook|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{hook}_hooks
+          @#{hook}_hooks ||= []
+        end
+      RUBY
+
+      define_method(hook) do |*args, &block|
+        HookDefinition.new(self, hook, *args, &block).tap do |definition|
+          hooks_for(hook) << definition
+        end
+      end
+    end
+
+    def to_s
+      description = []
+      description << super
+      options = [
+        runtime_options,
+        standard_options,
+        default_options
+      ].detect(&:render_strategy)
+
+      strategy = options.try(:render_strategy)
+      render_strategy_name = if strategy == HashWithRenderStrategy::RENDER_WITH_PROXY
+        caller_id = options.callers[HashWithRenderStrategy::RENDER_WITH_PROXY]
+        "proxy block \"#{options[strategy]}\""
+      elsif strategy == HashWithRenderStrategy::RENDER_WITH_BLOCK
+        caller_id = options.callers[HashWithRenderStrategy::RENDER_WITH_BLOCK]
+        "block defined at #{options[strategy].source_location}"
+      elsif strategy == HashWithRenderStrategy::RENDER_WITH_PARTIAL
+        caller_id = options.callers[HashWithRenderStrategy::RENDER_WITH_PARTIAL]
+        "partial \"#{options[strategy]}\""
+      end
+      if render_strategy_name
+        description << "Renders with #{render_strategy_name} [#{caller_id}]"
+      end
+
+      description.join("\n")
+    end
+  end
+end

data/lib/blocks/builders/builder.rb

@@ -0,0 +1,159 @@
+require 'call_with_params'
+
+module Blocks
+  class Builder
+    include CallWithParams
+
+    # A pointer to the view context
+    attr_accessor :view
+
+    # A HashWithIndifferentAccess of block names to BlockDefinition mappings
+    attr_accessor :block_definitions
+
+    # Options provided during initialization of builder
+    attr_accessor :options_set
+
+    delegate :content_tag, to: :view
+
+    delegate :render,
+             :render_with_overrides,
+             :deferred_render,
+             to: :renderer
+
+    delegate :runtime_options,
+             :standard_options,
+             :default_options,
+             to: :options_set
+
+    CONTENT_TAG_WRAPPER_BLOCK = :content_tag_wrapper
+
+    def initialize(view, options={})
+      self.view = view
+      self.block_definitions = HashWithIndifferentAccess.new do |hash, key|
+        hash[key] = BlockDefinition.new(key); hash[key]
+      end
+      self.options_set = OptionsSet.new("Builder Options", options)
+      define_helper_blocks
+    end
+
+    def renderer
+      @renderer ||= Blocks.renderer_class.new(self)
+    end
+
+    def block_for(block_name)
+      block_definitions[block_name] if block_defined?(block_name)
+    end
+
+    def block_defined?(block_name)
+      block_definitions.key?(block_name)
+    end
+
+    def define_each(collection, block_name_proc, *args, &block)
+      collection.map do |object|
+        define(call_with_params(block_name_proc, object, *args), object, *args, &block)
+      end
+    end
+
+    # Define a block, unless a block by the same name is already defined.
+    #   <%= blocks.define :some_block_name, :parameter1 => "1", :parameter2 => "2" do |options| %>
+    #     <%= options[:parameter1] %> and <%= options[:parameter2] %>
+    #   <% end %>
+    #
+    # Options:
+    # [+name+]
+    #   The name of the block being defined (either a string or a symbol)
+    # [+options+]
+    #   The default options for the block definition. Any or all of these options may be overridden by
+    #   whomever calls "blocks.render" on this block.
+    # [+block+]
+    #   The block that is to be rendered when "blocks.render" is called for this block.
+    def define(*args, &block)
+      options = args.extract_options!
+
+      if args.first
+        name = args.shift
+        block_definitions[name].tap do |block_definition|
+          block_definition.add_options options, &block
+        end
+      else
+        BlockDefinition.new(options, &block)
+      end
+    end
+
+    # Define a block, replacing an existing block by the same name if it is already defined.
+    #   <%= blocks.define :some_block_name, :parameter1 => "1", :parameter2 => "2" do |options| %>
+    #     <%= options[:parameter1] %> and <%= options[:parameter2] %>
+    #   <% end %>
+    #
+    #   <%= blocks.replace :some_block_name, :parameter3 => "3", :parameter4 => "4" do |options| %>
+    #     <%= options[:parameter3] %> and <%= options[:parameter4] %>
+    #   <% end %>
+    # Options:
+    # [+name+]
+    #   The name of the block being defined (either a string or a symbol)
+    # [+options+]
+    #   The default options for the block definition. Any or all of these options may be overridden by
+    #   whomever calls "blocks.render" on this block.
+    # [+block+]
+    #   The block that is to be rendered when "blocks.render" is called for this block.
+    def replace(name, options={}, &block)
+      block_definitions.delete(name)
+      define(name, options, &block)
+    end
+
+    def skip(name, completely=false)
+      block_definitions[name].skip(completely)
+    end
+
+    def skip_completely(name)
+      skip(name, true)
+    end
+
+    HookDefinition::HOOKS.each do |hook|
+      define_method(hook) do |name, options={}, &block|
+        block_definitions[name].send(hook, options, &block)
+      end
+    end
+
+    # TODO: move this logic elsewhere
+    def concatenating_merge(options, options2, *args)
+      options = call_each_hash_value_with_params(options, *args) || {}
+      options2 = call_each_hash_value_with_params(options2, *args) || {}
+
+
+      options.symbolize_keys.merge(options2.symbolize_keys) do |key, v1, v2|
+        if v1.is_a?(String) && v2.is_a?(String)
+          "#{v1} #{v2}"
+        else
+          v2
+        end
+      end
+    end
+
+    protected
+
+    # TODO: move this logic elsewhere
+    def define_helper_blocks
+      define CONTENT_TAG_WRAPPER_BLOCK, defaults: { wrapper_tag: :div } do |content_block, *args|
+        options = args.extract_options!
+        wrapper_options = if options[:wrapper_html_option]
+          if options[:wrapper_html_option].is_a?(Array)
+            wrapper_attribute = nil
+            options[:wrapper_html_option].each do |attribute|
+              if options[attribute].present?
+                wrapper_attribute = attribute
+                break
+              end
+            end
+            options[wrapper_attribute]
+          else
+            options[options[:wrapper_html_option]]
+          end
+        end
+        content_tag options[:wrapper_tag],
+          concatenating_merge(options[:wrapper_html], wrapper_options, *args, options),
+          &content_block
+      end
+    end
+  end
+end

data/lib/blocks/builders/hook_definition.rb

@@ -0,0 +1,25 @@
+module Blocks
+  class HookDefinition < OptionsSet
+    BEFORE_ALL = :before_all
+    AROUND_ALL = :around_all
+    BEFORE = :before
+    AROUND = :around
+    SURROUND = :surround
+    PREPEND = :prepend
+    APPEND = :append
+    AFTER = :after
+    AFTER_ALL = :after_all
+
+    HOOKS = [BEFORE_ALL, BEFORE, PREPEND,
+             AROUND_ALL, AROUND, SURROUND,
+             APPEND, AFTER, AFTER_ALL]
+
+    attr_accessor :block_definition, :hook_type
+
+    def initialize(block_definition, hook_type, *args, &block)
+      self.block_definition = block_definition
+      self.hook_type = hook_type
+      super "#{hook_type} #{block_definition.name} options", *args, &block
+    end
+  end
+end

data/lib/blocks/experimental/builder_permissions.rb

@@ -0,0 +1,52 @@
+# WIP
+module Blocks
+  module BuilderPermissions
+    extend ActiveSupport::Concern
+
+    METHODS_TO_PROTECT = [:render, :define, :deferred_render, :replace, :skip]
+
+    included do
+      attr_writer :permitted_blocks
+      attr_accessor :allow_all_blocks
+      attr_accessor :allow_anonymous_blocks
+
+      METHODS_TO_PROTECT.each do |method_name|
+        alias_method "original_#{method_name}", method_name
+        define_method(method_name) do |*args, &block|
+          if permitted?(args.first)
+            self.send("original_#{method_name}", *args, &block)
+          else
+            InvalidPermissionsHandler.build(method_name, args.first)
+          end
+        end
+      end
+    end
+
+    def restrict_blocks
+      self.allow_all_blocks = false
+    end
+
+    def permitted_blocks
+      @permitted_blocks ||= []
+    end
+
+    def permit(*names)
+      self.permitted_blocks += names
+    end
+
+    def permit_all
+      self.allow_all_blocks = true
+    end
+
+    def permit_anonymous_blocks
+      self.allow_anonymous_blocks = true
+    end
+
+    def permitted?(name)
+      allow_all_blocks ||
+      (block_definitions[name].try(:anonymous) && allow_anonymous_blocks) ||
+      !name.respond_to?(:to_sym) ||
+      permitted_blocks.any? {|e| e.to_sym == name.to_sym }
+    end
+  end
+end

data/lib/blocks/experimental/invalid_permissions_handler.rb

@@ -0,0 +1,27 @@
+# WIP
+module Blocks
+  class InvalidPermissionsHandler
+    LOG = :log
+    RAISE = :raise
+
+    def self.build(method_name, block_name)
+      message = "Cannot #{method_name} #{block_name}; #{block_name} is not in the permitted_blocks list"
+      new(message)
+      nil
+    end
+
+    def initialize(message)
+      send("handle_#{Blocks.invalid_permissions_approach}", message)
+    end
+
+    private
+
+    def handle_log(message)
+      Rails.logger.info message
+    end
+
+    def handle_raise(message)
+      raise message
+    end
+  end
+end

data/lib/blocks/renderers/abstract_renderer.rb

@@ -0,0 +1,69 @@
+module Blocks
+  class AbstractRenderer
+    RENDERERS = [
+      AdjacentBlocksRenderer,
+      BlockRenderer,
+      BlockWithHooksRenderer,
+      CollectionRenderer,
+      PartialRenderer,
+      NestingBlocksRenderer,
+      WrapperRenderer
+    ]
+
+    attr_accessor :main_renderer
+
+    delegate :builder, *(RENDERERS.map {|r| r.to_s.demodulize.underscore }), to: :main_renderer
+    delegate :block_definitions, :block_for, :view, to: :builder
+    delegate :with_output_buffer, :output_buffer, to: :view
+
+    def initialize(main_renderer=nil)
+      self.main_renderer = main_renderer
+    end
+
+    def render(*args)
+      raise NotImplementedError
+    end
+
+    def capture(*args, &block)
+      without_haml_interference do
+        if block.arity > 0
+          args = args[0, block.arity]
+        end
+
+        with_output_buffer do
+          output_buffer << view.capture(*args, &block)
+        end
+      end
+    end
+
+    protected
+
+    # Complete hack to get around issues with Haml
+    #  Haml does some hacking to ActionView's with_output_buffer and
+    #  output_buffer. In doing so, they make certain assumptions about
+    #  the layout and the view template. The Blocks gem doesn't capture
+    #  blocks immediately but rather stores them for later capturing.
+    #  This can produce an issue if a block that is stored was in Haml
+    #  but the Layout is in ERB. Haml will think that any blocks it
+    #  captures while rendering the layout will be in ERB format. However,
+    #  the block would need to be captured in Haml using a Haml buffer.
+    #  This workaround accomplishes that.
+    def without_haml_interference(&block)
+      if view.instance_variables.include?(:@haml_buffer)
+        haml_buffer = view.instance_variable_get(:@haml_buffer)
+        if haml_buffer
+          was_active = haml_buffer.active?
+          haml_buffer.active = false
+        else
+          haml_buffer = Haml::Buffer.new(nil, Haml::Options.new.for_buffer)
+          haml_buffer.active = false
+          kill_buffer = true
+          view.instance_variable_set(:@haml_buffer, haml_buffer)
+        end
+      end
+      yield
+    ensure
+      haml_buffer.active = was_active if haml_buffer
+    end
+  end
+end

data/lib/blocks/renderers/adjacent_blocks_renderer.rb

@@ -0,0 +1,15 @@
+module Blocks
+  class AdjacentBlocksRenderer < AbstractRenderer
+    def render(hook, runtime_context)
+      block = block_for(runtime_context.block_name)
+      if block
+        hooks = block.hooks_for hook
+        hooks = hooks.reverse if hook.to_s.index("before") == 0 || hook.to_s.index("prepend") == 0
+        hooks.each do |block_definition|
+          hook_runtime_context = runtime_context.extend_to_block_definition(block_definition)
+          block_renderer.render(hook_runtime_context)
+        end
+      end
+    end
+  end
+end