RubyGems - blocks - Versions diffs - 2.5.1 → 2.6.0 - Mend

blocks 2.5.1 → 2.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/Gemfile +2 -1
data/README.rdoc +94 -4
data/VERSION +1 -1
data/blocks.gemspec +8 -5
data/lib/blocks.rb +7 -14
data/lib/blocks/base.rb +24 -30
data/spec/blocks/base_spec.rb +187 -69
data/spec/blocks/blocks_spec.rb +4 -16
data/spec/blocks/view_additions_spec.rb +1 -1
data/spec/spec_helper.rb +5 -3
metadata +19 -3

data/Gemfile CHANGED

@@ -1,7 +1,8 @@
 source "http://rubygems.org"
 gem "rails", ">= 3.0.0"
-gem "call_with_params"
+gem "call_with_params", "~> 0.0.2"
+gem "hashie"
 group :development do
   gem "bundler", "~> 1.3.5"

data/README.rdoc CHANGED

@@ -1,9 +1,99 @@
 = Blocks
-I AM CURRENTLY IN THE PROCESS OF WRITING THIS DOCUMENTATION OVER AGAIN SINCE A LOT HAS CHANGED SINCE THE DOCUMENTATION WAS ORIGINALLY WRITTEN.
 How do you render your blocks of code?
-The idea of this gem is simple (yet difficult to see the practical application for): blocks of code, regardless of code, whether they are a ruby block or a rails partial, are, or should be, completely interchangeable.
+With blocks, you can:
+1. Easily define named blocks of view-level code, capable of taking parameters as arguments
+2. Render a defined block of view-level code and pass in an arbitrary number of parameters
+3. Provide a default block of code to render if a named block is not found
+4. Specify view-level code to render before, after, or around a particular block of code
+5. Render a collection of elements using a defined block
+== Author's Note
+To fully appreciate how powerful Blocks can be, i highly recommend checking out the
+project {TableFor}[https://github.com/hunterae/table-for] first.
+This is a gem that was built using Blocks and {WithTemplate (an extension of Blocks)}[https://github.com/hunterae/with_template]
+with very few lines of code, and illustrates the power of Blocks and WithTemplate
+and how they can be can be used to build extremely useful reusable UI components.
+== Installation
+In <b>Rails 3</b> or <b>Rails 4</b>, add this to your Gemfile.
+  gem "blocks"
+== Simple Case
+  <% blocks.define :sample do |a, b| %>
+    This is a snippet of code with parameters <%= a %> and <%= b %> passed in<br>
+  <% end %>
+  <% blocks.before :sample do %>
+    This is a snippet of code that will render before the block named :sample<br>
+  <% end %>
+  <% blocks.after :sample do %>
+    This is a snippet of code that will render after the block named :sample<br>
+  <% end %>
+  <%# This is when the code gets rendered %>
+  <%= blocks.render :sample, "1", 2 %>
+  <%# Provide a wrapper element to wrap around the rendered block
+  <%= blocks.render :sample, "1", 2, :wrap_with => {:tag => :div, :id => "sample" } %>
+  <%# Rendering a block that doesn't exist will simply render nothing %>
+  <%= blocks.render :sample2 %>
+  <%# Rendering a block that doesn't exist with a default definition will simply use the default definition %>
+  <%= blocks.render :sample3 do %>
+    This is a snippet that will get rendered if a block named :sample3 is not defined anywhere
+  <% end %>
+== A More Complicated Case
+In this example, @brands will represent a collection of brands fetched from the database
+  <% blocks.define :brand do |brand| %>
+    Brand <%= brand.name %>
+  <% end %>
+  <%= blocks.render :brand,
+                    :collection => @brands,
+                    :wrap_with => { :tag => :ul, :id => "brands", :style => "list-style-type:circle" },
+                    :wrap_each => { :tag => :li,
+                                    :id => Proc.new {|brand| "brand#{brand.id}"},
+                                    :class => Proc.new { cycle("even", "odd") },
+                                    :style => "padding-left: 20px;" }%>
+== A Practical example
+Surround your javascript includes and css includes in your
+template with a named block, and from the view, the included order can easily be changed.
+Note: I use this approach in every single project I setup.
+In layout, such as application.html.erb:
+  <!DOCTYPE html>
+    <head>
+      ...
+      <%= blocks.render :stylesheets do %>
+        <%= stylesheet_link_tag "application", :media => "all" %>
+      <% end %>
+    </head>
+    <body>
+      ...
+      <%= blocks.render :javascripts do %>
+        <%= javascript_include_tag "application" %>
+      <% end %>
+    </body>
+  </html>
-This gem seeks to set an order of precedence for how rails determines how to render a block of code.
+In a view, stylesheets and javascript files can easily be prepended, appended, or replace the existing set of
+includes:
+  <% blocks.before :stylesheets do %>
+    <%= stylesheet_link_tag "SOME_STYLESHEET_TO_INCLUDE_FIRST", :media => "all" %>
+  <% end %>
+  <% blocks.after :stylesheets do %>
+    <%= stylesheet_link_tag "SOME_STYLESHEET_TO_INCLUDE_LAST", :media => "all" %>
+  <% end %>
+  <%# Flat out replaces the javascript includes %>
+  <% blocks.define :javascripts do %>
+    <%= stylesheet_link_tag "MY_JAVASCRIPT_FILES_TO_INCLUDE", :media => "all" %>
+  <% end %>

data/VERSION CHANGED

	@@ -1 +1 @@
1	- 2.5.1
1	+ 2.6.0

data/blocks.gemspec CHANGED

@@ -5,11 +5,11 @@
 Gem::Specification.new do |s|
   s.name = "blocks"
-  s.version = "2.5.1"
+  s.version = "2.6.0"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrew Hunter"]
-  s.date = "2013-10-17"
+  s.date = "2013-11-04"
   s.description = "Blocks goes beyond blocks and partials"
   s.email = "hunterae@gmail.com"
   s.extra_rdoc_files = [
@@ -49,20 +49,23 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<rails>, [">= 3.0.0"])
-      s.add_runtime_dependency(%q<call_with_params>, [">= 0"])
+      s.add_runtime_dependency(%q<call_with_params>, ["~> 0.0.2"])
+      s.add_runtime_dependency(%q<hashie>, [">= 0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.3.5"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
     else
       s.add_dependency(%q<rails>, [">= 3.0.0"])
-      s.add_dependency(%q<call_with_params>, [">= 0"])
+      s.add_dependency(%q<call_with_params>, ["~> 0.0.2"])
+      s.add_dependency(%q<hashie>, [">= 0"])
       s.add_dependency(%q<bundler>, ["~> 1.3.5"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_dependency(%q<simplecov>, [">= 0"])
     end
   else
     s.add_dependency(%q<rails>, [">= 3.0.0"])
-    s.add_dependency(%q<call_with_params>, [">= 0"])
+    s.add_dependency(%q<call_with_params>, ["~> 0.0.2"])
+    s.add_dependency(%q<hashie>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.3.5"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
     s.add_dependency(%q<simplecov>, [">= 0"])

data/lib/blocks.rb CHANGED

@@ -1,6 +1,7 @@
 require "action_view"
 require "action_controller"
 require "call_with_params"
+require "hashie"
 module Blocks
   autoload :Base,          "blocks/base"
@@ -8,23 +9,15 @@ module Blocks
   autoload :ViewAdditions, "blocks/view_additions"
   autoload :ControllerAdditions, "blocks/controller_additions"
-  mattr_accessor :template_folder
-  @@template_folder = "blocks"
-  mattr_accessor :use_partials
-  @@use_partials = false
-  mattr_accessor :wrap_before_and_after_blocks
-  @@wrap_before_and_after_blocks = false
-  # Shortcut for using the templating feature / rendering templates
-  def self.render_template(view, partial, options={}, &block)
-    Blocks::Base.new(view, options).render_template(partial, &block)
-  end
+  mattr_accessor :config
+  @@config = Hashie::Mash.new
+  @@config.wrap_before_and_after_blocks = false
+  @@config.use_partials = false
+  @@config.partials_folder = "blocks"
   # Default way to setup Blocks
   def self.setup
-    yield self
+    yield config
   end
 end

data/lib/blocks/base.rb CHANGED

@@ -1,3 +1,5 @@
+require 'active_support'
 module Blocks
   class Base
     include CallWithParams
@@ -14,18 +16,6 @@ module Blocks
     # These are the options that are passed into the initalize method
     attr_accessor :global_options
-    # The default folder to look in for global partials
-    attr_accessor :template_folder
-    # The variable to use when rendering the partial for the templating feature (by default, "blocks")
-    attr_accessor :variable
-    # Boolean variable for whether Blocks should attempt to render blocks as partials if a defined block cannot be found
-    attr_accessor :use_partials
-    # Boolean variable for whether Blocks should render before and after blocks inside or outside of a collections' elements' wrap_with tags
-    attr_accessor :wrap_before_and_after_blocks
     # Checks if a particular block has been defined within the current block scope.
     #   <%= blocks.defined? :some_block_name %>
     # Options:
@@ -42,10 +32,12 @@ module Blocks
     #
     # Options:
     # [+name+]
-    #   The name of the block being defined (either a string or a symbol)
+    #   The name of the block being defined (either a string or a symbol or a Proc)
     # [+options+]
     #   The default options for the block definition. Any or all of these options may be overrideen by
-    #   whomever calls "blocks.render" on this block.
+    #   whomever calls "blocks.render" on this block. If :collection => some_array,
+    #   Blocks will assume that the first argument is a Proc and define a block for each object in the
+    #   collection
     # [+block+]
     #   The block that is to be rendered when "blocks.render" is called for this block.
     def define(name, options={}, &block)
@@ -184,7 +176,7 @@ module Blocks
       else
         args.push(options)
-        if wrap_before_and_after_blocks
+        if global_options.merge(options)[:wrap_before_and_after_blocks]
           buffer << content_tag_with_block(wrap_with[:tag], wrap_with.except(:tag), *args) do
             temp_buffer = ActiveSupport::SafeBuffer.new
             temp_buffer << render_before_blocks(name_or_container, *args)
@@ -415,14 +407,10 @@ module Blocks
     protected
     def initialize(view, options={})
-      self.template_folder = options[:template_folder] ? options.delete(:template_folder) : Blocks.template_folder
-      self.variable = (options[:variable] ? options.delete(:variable) : :blocks).to_sym
       self.view = view
-      self.global_options = options
+      self.global_options = Blocks.config.merge(options)
       self.blocks = {}
       self.anonymous_block_number = 0
-      self.use_partials = options[:use_partials].nil? ? Blocks.use_partials : options.delete(:use_partials)
-      self.wrap_before_and_after_blocks = options[:wrap_before_and_after_blocks].nil? ? Blocks.wrap_before_and_after_blocks : options.delete(:wrap_before_and_after_blocks)
     end
     # Return a unique name for an anonymously defined block (i.e. a block that has not been given a name)
@@ -450,28 +438,34 @@ module Blocks
     # Render a block, first trying to find a previously defined block with the same name
     def render_block(name_or_container, *args, &block)
-      options = args.extract_options!
       buffer = ActiveSupport::SafeBuffer.new
-      block_options = {}
       if (name_or_container.is_a?(Blocks::Container))
         name = name_or_container.name.to_sym
-        block_options = name_or_container.options
+        block_render_options = name_or_container.options
       else
         name = name_or_container.to_sym
+        block_render_options = {}
+      end
+      block_definition_options = {}
+      if blocks[name]
+        block_container = blocks[name]
+        block_definition_options = block_container.options
       end
+      options = global_options.merge(block_definition_options).merge(block_render_options).merge(args.extract_options!)
       if blocks[name]
         block_container = blocks[name]
-        args.push(global_options.merge(block_container.options).merge(block_options).merge(options))
+        args.push(options)
         buffer << view.capture(*(args[0, block_container.block.arity]), &block_container.block)
-      elsif (use_partials || options[:use_partials]) && !options[:skip_partials]
+      elsif options[:use_partials] && !options[:skip_partials]
         begin
           begin
-            buffer << view.render("#{name.to_s}", global_options.merge(block_options).merge(options))
+            buffer << view.render("#{name.to_s}", options)
           rescue ActionView::MissingTemplate
-            buffer << view.render("#{self.template_folder}/#{name.to_s}", global_options.merge(block_options).merge(options))
+            buffer << view.render("#{options[:partials_folder]}/#{name.to_s}", options)
           end
         rescue ActionView::MissingTemplate
           args.push(global_options.merge(options))
@@ -561,9 +555,9 @@ module Blocks
     def content_tag_with_block(tag, tag_html, *args, &block)
       if tag
-        view.content_tag(tag, block.call, call_each_hash_value_with_params(tag_html, *args))
+        view.content_tag(tag, view.capture(&block), call_each_hash_value_with_params(tag_html, *args))
       else
-        block.call
+        view.capture(&block)
       end
     end
   end

data/spec/blocks/base_spec.rb CHANGED

@@ -7,18 +7,20 @@ describe Blocks::Base do
   end
   it "should be able change the default global partials directory" do
-    Blocks.template_folder = "shared"
-    Blocks.use_partials = true
+    Blocks.setup do |config|
+      config.partials_folder = "shared"
+      config.use_partials = true
+    end
     @builder = Blocks::Base.new(@view)
     @builder.expects(:render_before_blocks).at_least_once
     @builder.expects(:render_after_blocks).at_least_once
-    @view.expects(:capture).with(:value1 => 1, :value2 => 2).never
-    @view.expects(:render).with("some_block", :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
-    @view.expects(:render).with("shared/some_block", :value1 => 1, :value2 => 2).once
+    # @view.expects(:capture).with(:value1 => 1, :value2 => 2).never
+    @view.expects(:render).with("some_block", 'partials_folder' => 'shared', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+    @view.expects(:render).with("shared/some_block", 'partials_folder' => 'shared', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).once
     @builder.render :some_block, :value1 => 1, :value2 => 2
   end
-  describe "defined? method" do
+  describe "#defined?" do
     it "should be able to determine if a block by a specific name is already defined" do
       @builder.defined?(:test_block).should be_false
       @builder.define :test_block do end
@@ -42,7 +44,7 @@ describe Blocks::Base do
     end
   end
-  describe "define method" do
+  describe "#define" do
     it "should be able to define a new block" do
       block = Proc.new { |options| }
@@ -54,7 +56,7 @@ describe Blocks::Base do
       test_block.name.should eql(:test_block)
       test_block.block.should eql(block)
     end
     it "should not replace a defined block with another attempted definition" do
       block1 = Proc.new do |options| end
       @builder.define :test_block, :option1 => "value1", :option2 => "value2", &block1
@@ -70,9 +72,21 @@ describe Blocks::Base do
       test_block.name.should eql(:test_block)
       test_block.block.should eql(block1)
     end
+    it "should be able to define a collection of blocks" do
+      block = Proc.new {}
+      collection = ["block1", "block2", "block3"]
+      @builder.define Proc.new {|block_name| block_name }, :collection => collection, &block
+      @builder.blocks[:block1].should be_present
+      @builder.blocks[:block1].block.should eql block
+      @builder.blocks[:block2].should be_present
+      @builder.blocks[:block2].block.should eql block
+      @builder.blocks[:block3].should be_present
+      @builder.blocks[:block3].block.should eql block
+    end
   end
-  describe "replace method" do
+  describe "#replace" do
     it "should be able to replace a defined block" do
       block1 = Proc.new do |options| end
       @builder.define :test_block, :option1 => "value1", :option2 => "value2", &block1
@@ -90,14 +104,22 @@ describe Blocks::Base do
     end
   end
-  describe "before method" do
+  describe "#skip" do
+    it "should define an empty block" do
+      @builder.skip(:test_block)
+      @builder.blocks[:test_block].should be_present
+      @builder.blocks[:test_block].block.call.should be_nil
+    end
+  end
+  describe "#before" do
     it "should be aliased with prepend" do
       block = Proc.new { |options| }
       @builder.prepend :some_block, &block
       @builder.blocks[:before_some_block].should be_present
     end
-    it "should defined before blocks as the block name with the word 'before_' prepended to it" do
+    it "should define before blocks as the block name with the word 'before_' prepended to it" do
       block = Proc.new { |options| }
       @builder.before :some_block, &block
       @builder.blocks[:before_some_block].should be_present
@@ -143,7 +165,7 @@ describe Blocks::Base do
     end
   end
-  describe "after method" do
+  describe "#after" do
     it "should be aliased with append and for" do
       block = Proc.new { |options| }
       @builder.append :some_block, &block
@@ -154,7 +176,7 @@ describe Blocks::Base do
       @builder.blocks[:after_some_block].should be_present
     end
-    it "should defined after blocks as the block name with the word 'after_' prepended to it" do
+    it "should define after blocks as the block name with the word 'after_' prepended to it" do
       block = Proc.new { |options| }
       @builder.after :some_block, &block
       @builder.blocks[:after_some_block].should be_present
@@ -200,42 +222,103 @@ describe Blocks::Base do
     end
   end
-  describe "render method" do
+  describe "#around" do
+    it "should define around blocks as the block name with the word 'around_' prepended to it" do
+      block = Proc.new { |options| }
+      @builder.around :some_block, &block
+      @builder.blocks[:around_some_block].should be_present
+    end
+    it "should store a around block in an array" do
+      block = Proc.new { |options| }
+      @builder.around :some_block, &block
+      around_blocks = @builder.blocks[:around_some_block]
+      around_blocks.should be_a(Array)
+    end
+    it "should store a around block as a Blocks::Container" do
+      block = Proc.new { |options| }
+      @builder.around :some_block, :option1 => "some option", &block
+      around_blocks = @builder.blocks[:around_some_block]
+      block_container = around_blocks.first
+      block_container.should be_a(Blocks::Container)
+      block_container.options.should eql :option1 => "some option"
+      block_container.block.should eql block
+    end
+    it "should queue around blocks if there are multiple defined" do
+      block = Proc.new { |options| }
+      block2 = Proc.new { |options| }
+      @builder.around :some_block, &block
+      @builder.around :some_block, &block2
+      around_blocks = @builder.blocks[:around_some_block]
+      around_blocks.length.should eql 2
+    end
+    it "should store after blocks in the order in which they are defined" do
+      block = Proc.new { |options| }
+      block2 = Proc.new { |options| }
+      block3 = Proc.new { |options| }
+      @builder.around :some_block, &block
+      @builder.around :some_block, &block2
+      @builder.around :some_block, &block3
+      around_blocks = @builder.blocks[:around_some_block]
+      around_blocks.first.block.should eql block
+      around_blocks.second.block.should eql block2
+      around_blocks.third.block.should eql block3
+    end
+  end
+  describe "#render_with_partials" do
+    it "should trigger the call to #render with :use_partials set to true" do
+      @builder.expects(:render).with(:some_block, :use_partials => true)
+      @builder.render_with_partials(:some_block)
+    end
+  end
+  describe "#render_without_partials" do
+    it "should trigger the call to #render with :skip_partials set to true" do
+      @builder.expects(:render).with(:some_block, :skip_partials => true)
+      @builder.render_without_partials(:some_block)
+    end
+  end
+  describe "#render" do
     it "should alias the render method as use" do
       block = Proc.new {"output"}
       @builder.define :some_block, &block
       @builder.use(:some_block).should eql "output"
     end
-    it "should be able to use a defined block by its name" do
+    it "should be able to render a defined block by its name" do
       block = Proc.new {"output"}
       @builder.define :some_block, &block
       @builder.render(:some_block).should eql "output"
     end
-    it "should automatically pass in an options hash to a defined block that takes one paramter when that block is used" do
-      block = Proc.new {|options| "Options are #{options.inspect}"}
+    it "should automatically pass in an options hash to a defined block that takes one paramter when that block is rendered" do
+      block = Proc.new {|options| print_hash(options) }
       @builder.define :some_block, &block
-      @builder.render(:some_block).should eql "Options are {}"
+      @builder.render(:some_block).should eql print_hash(:wrap_before_and_after_blocks => false, :use_partials => false, :partials_folder => "blocks", )
     end
-    it "should be able to use a defined block by its name and pass in runtime arguments as a hash" do
+    it "should be able to render a defined block by its name and pass in runtime arguments as a hash" do
       block = Proc.new do |options|
         print_hash(options)
       end
       @builder.define :some_block, &block
-      @builder.render(:some_block, :param1 => 1, :param2 => "value2").should eql print_hash(:param1 => 1, :param2 => "value2")
+      @builder.render(:some_block, :param1 => 1, :param2 => "value2").should eql print_hash(:wrap_before_and_after_blocks => false, :use_partials => false, :partials_folder => "blocks", :param1 => 1, :param2 => "value2")
     end
-    it "should be able to use a defined block by its name and pass in runtime arguments one by one" do
+    it "should be able to render a defined block by its name and pass in runtime arguments one by one" do
       block = Proc.new do |first_param, second_param, options|
         "first_param: #{first_param}, second_param: #{second_param}, #{print_hash options}"
       end
       @builder.define :some_block, &block
-      @builder.render(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql("first_param: 3, second_param: 4, #{print_hash(:param1 => 1, :param2 => "value2")}")
+      @builder.render(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql("first_param: 3, second_param: 4, #{print_hash(:wrap_before_and_after_blocks => false, :use_partials => false, :partials_folder => "blocks", :param1 => 1, :param2 => "value2")}")
     end
-    it "should match up the number of arguments to a defined block with the parameters passed when a block is used" do
+    it "should match up the number of arguments to a defined block with the parameters passed when a block is rendered" do
       block = Proc.new {|first_param| "first_param = #{first_param}"}
       @builder.define :some_block, &block
       @builder.render(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql "first_param = 3"
@@ -248,57 +331,68 @@ describe Blocks::Base do
         "first_param: #{first_param}, second_param: #{second_param}, #{print_hash options}"
       end
       @builder.replace :some_block, &block
-      @builder.render(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql("first_param: 3, second_param: 4, #{print_hash(:param1 => 1, :param2 => "value2")}")
+      @builder.render(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql("first_param: 3, second_param: 4, #{print_hash(:wrap_before_and_after_blocks => false, :use_partials => false, :partials_folder => "blocks", :param1 => 1, :param2 => "value2")}")
     end
     it "should not render anything if using a block that has been defined" do
-      @builder.use_partials = true
-      @view.expects(:capture).never
-      @view.expects(:render).with("some_block", {}).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
-      @view.expects(:render).with("blocks/some_block", {}).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      Blocks.setup do |config|
+        config.use_partials = true
+      end
+      @builder = Blocks::Base.new(@view)
+      @view.expects(:render).with("some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
       @builder.render :some_block
     end
     it "should first attempt to capture a block's contents when blocks.render is called" do
       block = Proc.new {|options|}
-      @view.expects(:capture).with(:value1 => 1, :value2 => 2)
-      @view.expects(:render).with("some_block", :value1 => 1, :value2 => 2).never
-      @view.expects(:render).with("blocks/some_block", :value1 => 1, :value2 => 2).never
+      @view.expects(:render).with("some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).never
+      @view.expects(:render).with("blocks/some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).never
       @builder.define :some_block, &block
       @builder.render :some_block, :value1 => 1, :value2 => 2
     end
     it "should second attempt to render a local partial by the block's name when blocks.render is called" do
-      @builder.use_partials = true
-      @view.expects(:capture).with(:value1 => 1, :value2 => 2).never
-      @view.expects(:render).with("some_block", :value1 => 1, :value2 => 2).once
-      @view.expects(:render).with("blocks/some_block", :value1 => 1, :value2 => 2).never
+      Blocks.setup do |config|
+        config.use_partials = true
+      end
+      @builder = Blocks::Base.new(@view)
+      @view.expects(:render).with("some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).once
+      @view.expects(:render).with("blocks/some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).never
       @builder.render :some_block, :value1 => 1, :value2 => 2
     end
     it "should third attempt to render a global partial by the block's name when blocks.render is called" do
-      @builder.use_partials = true
-      @view.expects(:capture).with(:value1 => 1, :value2 => 2).never
-      @view.expects(:render).with("some_block", :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
-      @view.expects(:render).with("blocks/some_block", :value1 => 1, :value2 => 2).once
+      Blocks.setup do |config|
+        config.use_partials = true
+      end
+      @builder = Blocks::Base.new(@view)
+      @view.expects(:render).with("some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).once
       @builder.render :some_block, :value1 => 1, :value2 => 2
     end
     it "should fourth attempt to render a default block when blocks.render is called" do
-      block = Proc.new {|options|}
-      @builder.use_partials = true
-      @view.expects(:render).with("some_block", :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
-      @view.expects(:render).with("blocks/some_block", :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
-      @view.expects(:capture).with(:value1 => 1, :value2 => 2)
+      block = Proc.new do |options|
+        options[:value1].should eql 1
+        options[:value2].should eql 2
+      end
+      Blocks.setup do |config|
+        config.use_partials = true
+      end
+      @builder = Blocks::Base.new(@view)
+      @view.expects(:render).with("some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => true, 'value1' => 1, 'value2' => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
       @builder.render :some_block, :value1 => 1, :value2 => 2, &block
     end
     it "should not attempt to render a partial if use_partials is set to false" do
-      @builder.use_partials = false
-      block = Proc.new {|options|}
-      @view.expects(:render).with("some_block", :value1 => 1, :value2 => 2).never
-      @view.expects(:render).with("blocks/some_block", :value1 => 1, :value2 => 2).never
-      @view.expects(:capture).with(:value1 => 1, :value2 => 2)
+      block = Proc.new do |options|
+        options[:value1].should eql 1
+        options[:value2].should eql 2
+      end
+      @view.expects(:render).with("some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => false, 'value1' => 1, 'value2' => 2).never
+      @view.expects(:render).with("blocks/some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => false, 'value1' => 1, 'value2' => 2).never
       @builder.render :some_block, :value1 => 1, :value2 => 2, &block
     end
@@ -307,19 +401,25 @@ describe Blocks::Base do
       @builder = Blocks::Base.new(@view, :use_partials => false)
       @builder.expects(:render_before_blocks).at_least_once
       @builder.expects(:render_after_blocks).at_least_once
-      block = Proc.new {|options|}
-      @view.expects(:render).with("some_block", :value1 => 1, :value2 => 2).never
-      @view.expects(:render).with("blocks/some_block", :value1 => 1, :value2 => 2).never
-      @view.expects(:capture).with(:value1 => 1, :value2 => 2)
+      block = Proc.new do |options|
+        options[:value1].should eql 1
+        options[:value2].should eql 2
+      end
+      @view.expects(:render).with("some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => false, 'value1' => 1, 'value2' => 2).never
+      @view.expects(:render).with("blocks/some_block", 'partials_folder' => 'blocks', 'wrap_before_and_after_blocks' => false, 'use_partials' => false, 'value1' => 1, 'value2' => 2).never
       @builder.render :some_block, :value1 => 1, :value2 => 2, &block
     end
     it "should override hash options for a block by merging the runtime options into the define default options into the queue level options into the global options" do
-      block = Proc.new {|options|}
+      block = Proc.new do |options|
+        options[:param1].should eql "use level"
+        options[:param2].should eql "queue level"
+        options[:param3].should eql "define level"
+        options[:param4].should eql "global level"
+      end
       @builder.global_options.merge!(:param1 => "global level", :param2 => "global level", :param3 => "global level", :param4 => "global level")
       block_container = @builder.send(:define_block_container, :my_before_block, :param1 => "queue level", :param2 => "queue level")
       @builder.define(:my_before_block, :param1 => "define level", :param2 => "define level", :param3 => "define level", &block)
-      @view.expects(:capture).with(:param1 => 'use level', :param2 => 'queue level', :param3 => 'define level', :param4 => 'global level')
       @builder.render block_container, :param1 => "use level"
     end
@@ -394,7 +494,7 @@ describe Blocks::Base do
         @builder.render(:some_block, :collection => [1,2,3]).should eql "before1 output1 after1 before2 output2 after2 before3 output3 after3 "
       end
-      it "should by default put surrounding elements around before and after blocks" do
+      it "should by default render surrounding elements outside before and after blocks" do
         before_block = Proc.new {|item, options| "before#{options[:some_block]} "}
         @builder.before :some_block, &before_block
@@ -403,11 +503,13 @@ describe Blocks::Base do
         block = Proc.new {|item, options| "output#{options[:some_block]} "}
         @builder.define :some_block, &block
-        @builder.render(:some_block, :collection => [1,2,3], :wrap_each => {:tag => "div"}).should eql "<div>before1 output1 after1 </div><div>before2 output2 after2 </div><div>before3 output3 after3 </div>"
+        @builder.render(:some_block, :collection => [1,2,3], :wrap_each => {:tag => "div"}).should eql "before1 <div>output1 </div>after1 before2 <div>output2 </div>after2 before3 <div>output3 </div>after3 "
       end
-      it "should allow the global option to be set to render before and after blocks outside of surrounding elements" do
-        Blocks.wrap_before_and_after_blocks = false
+      it "should allow the global option to be set to render before and after blocks inside of surrounding elements" do
+        Blocks.setup do |config|
+          config.wrap_before_and_after_blocks = true
+        end
         @builder = Blocks::Base.new(@view)
         before_block = Proc.new {|item, options| "before#{options[:some_block]} "}
         @builder.before :some_block, &before_block
@@ -417,7 +519,7 @@ describe Blocks::Base do
         block = Proc.new {|item, options| "output#{options[:some_block]} "}
         @builder.define :some_block, &block
-        @builder.render(:some_block, :collection => [1,2,3], :wrap_each => {:tag => "div"}).should eql "before1 <div>output1 </div>after1 before2 <div>output2 </div>after2 before3 <div>output3 </div>after3 "
+        @builder.render(:some_block, :collection => [1,2,3], :wrap_each => {:tag => "div"}).should eql "<div>before1 output1 after1 </div><div>before2 output2 after2 </div><div>before3 output3 after3 </div>"
       end
       it "should allow the option to be set to render before and after blocks outside of surrounding elements to be specified when Blocks is initialized" do
@@ -442,7 +544,7 @@ describe Blocks::Base do
         block = Proc.new {|item, options| "output#{options[:some_block]} "}
         @builder.define :some_block, &block
-        @builder.render(:some_block, :collection => [1,2,3], :wrap_each => {:tag => "div"}, :wrap_with => {:tag => "div", :style => "color:red"}).should eql "<div style=\"color:red\"><div>before1 output1 after1 </div><div>before2 output2 after2 </div><div>before3 output3 after3 </div></div>"
+        @builder.render(:some_block, :collection => [1,2,3], :wrap_each => {:tag => "div"}, :wrap_with => {:tag => "div", :style => "color:red"}).should eql "<div style=\"color:red\">before1 <div>output1 </div>after1 before2 <div>output2 </div>after2 before3 <div>output3 </div>after3 </div>"
       end
     end
   end
@@ -454,18 +556,26 @@ describe Blocks::Base do
     end
     it "should render before blocks when using a block" do
-      block = Proc.new {|value1, value2, options|}
+      block = Proc.new do |value1, value2, options|
+        value1.should eql 1
+        value2.should eql 2
+        options[:value3].should eql 3
+        options[:value4].should eql 4
+      end
       @builder.before("my_before_block", &block)
-      @view.expects(:capture).with(1, 2, :value3 => 3, :value4 => 4)
       @builder.render :my_before_block, 1, 2, :value3 => 3, :value4 => 4
     end
     it "should override hash options for before blocks by merging the runtime options into the before block options into the block options into the global options" do
-      block = Proc.new {|options|}
+      block = Proc.new do |options|
+        options[:param1].should eql "top level"
+        options[:param2].should eql "before block level"
+        options[:param3].should eql "block level"
+        options[:param4].should eql "global level"
+      end
       @builder.global_options.merge!(:param1 => "global level", :param2 => "global level", :param3 => "global level", :param4 => "global level")
       @builder.define(:my_before_block, :param1 => "block level", :param2 => "block level", :param3 => "block level", &block)
       @builder.before(:my_before_block, :param1 => "before block level", :param2 => "before block level", &block)
-      @view.expects(:capture).with(:param4 => 'global level', :param1 => 'top level', :param2 => 'before block level', :param3 => 'block level')
       @builder.render :my_before_block, :param1 => "top level"
     end
   end
@@ -499,18 +609,26 @@ describe Blocks::Base do
     end
     it "should render after blocks when using a block" do
-      block = Proc.new {|value1, value2, options|}
+      block = Proc.new do |value1, value2, options|
+        value1.should eql 1
+        value2.should eql 2
+        options[:value3].should eql 3
+        options[:value4].should eql 4
+      end
       @builder.after("my_after_block", &block)
-      @view.expects(:capture).with(1, 2, :value3 => 3, :value4 => 4)
       @builder.render :my_after_block, 1, 2, :value3 => 3, :value4 => 4
     end
     it "should override hash options for after blocks by merging the runtime options into the after block options into the block options into the global options" do
-      block = Proc.new {|options|}
+      block = Proc.new do |options|
+        options[:param1].should eql "top level"
+        options[:param2].should eql "after block level"
+        options[:param3].should eql "block level"
+        options[:param4].should eql "global level"
+      end
       @builder.global_options.merge!(:param1 => "global level", :param2 => "global level", :param3 => "global level", :param4 => "global level")
       @builder.define(:my_after_block, :param1 => "block level", :param2 => "block level", :param3 => "block level", &block)
       @builder.after(:my_after_block, :param1 => "after block level", :param2 => "after block level", &block)
-      @view.expects(:capture).with(:param4 => 'global level', :param1 => 'top level', :param2 => 'after block level', :param3 => 'block level')
       @builder.render :my_after_block, :param1 => "top level"
     end
   end

data/spec/blocks/blocks_spec.rb CHANGED

@@ -1,24 +1,12 @@
 require "spec_helper"
 describe Blocks do
-  it "should provide a util method to render a template" do
-    view = stub
-    options = stub
-    partial = stub
-    block = Proc.new { |options| }
-    base_mock = mock
-    base_mock.expects(:render_template).with(partial)
-    Blocks::Base.expects(:new).with(view, options).returns(base_mock)
-    Blocks.render_template(view, partial, options, &block)
-  end
   it "should provide a setup method that can be called from an initializer" do
-    Blocks.template_folder.should eql("blocks")
+    Blocks.config.partials_folder.should eql("blocks")
     Blocks.setup do |config|
-      config.should eql(Blocks)
-      config.template_folder = "shared"
+      config.should be_a(Hashie::Mash)
+      config.partials_folder = "shared"
     end
-    Blocks.template_folder.should eql("shared")
+    Blocks.config.partials_folder.should eql("shared")
   end
 end

data/spec/blocks/view_additions_spec.rb CHANGED

@@ -7,7 +7,7 @@ describe Blocks::ViewAdditions do
     @view_class.send(:include, Blocks::ViewAdditions::ClassMethods)
   end
-  describe "blocks method" do
+  describe "#blocks" do
     it "should pass the view as the only parameter to Blocks::Base initialization" do
       Blocks::Base.expects(:new).with {|view| view == @view}
       @view.blocks

data/spec/spec_helper.rb CHANGED

@@ -12,9 +12,11 @@ RSpec.configure do |config|
   config.mock_with :mocha
   config.before :each do
-    Blocks.template_folder = "blocks"
-    Blocks.wrap_before_and_after_blocks = true
-    Blocks.use_partials = false
+    Blocks.setup do |config|
+      config.partials_folder = "blocks"
+      config.wrap_before_and_after_blocks = false
+      config.use_partials = false
+    end
   end
 end

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blocks
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 2.6.0
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-10-17 00:00:00.000000000 Z
+date: 2013-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -29,6 +29,22 @@ dependencies:
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: call_with_params
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: hashie
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -134,7 +150,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1089807617590558203
+      hash: -4078634663971351405
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: