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

blocks 2.5.1 → 2.6.0

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: