blocks 3.0.2 → 4.0.0

data/docs/_includes/wip.md

@@ -1,34 +0,0 @@
-<!-- Defining multiple blocks at once -->
-## Multiple Blocks at Once
-
-```haml
-- namer = Proc.new {|i| "block #{i}" }
-blocks.define_each ["a", 1, "b"],
-  namer do |item|
-  ="Hello from #{item}"
-  &br
-
-= blocks.render("block a")
-= blocks.render("block 1")
-= blocks.render("block b")
-```
-
-```ruby
-# where builder is an instance of
-#  Blocks::Builder
-namer = Proc.new {|i| "block #{i}" }
-builder.define_each ["a", 1, "b"],
-  namer do |item|
-  "Hello from #{item}<br>".html_safe
-end
-
-builder.render("block a") +
-builder.render("block 1") +
-builder.render("block b")
-```
-
-Multiple different blocks may be defined at once using the #define_each method.
-
-#define_each expects at least two parameters: the collection and a proc that can be used to calculate the block name. The proc must at least one parameter, the first being the item in the collection.
-
-The method also expects either an options hash designating the render strategy or a Ruby block.

data/lib/blocks/experimental/builder_permissions.rb

@@ -1,52 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-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 defined?(::Haml) && 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/utilities/dynamic_configuration.rb

@@ -1,71 +0,0 @@
-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