building-blocks 1.1.0 → 1.2.0

data/CHANGELOG.rdoc

@@ -3,4 +3,11 @@
 * Ability to disable use of partials when rendering a block
 * Ability to disable use of partials for before and after hooks
 * Complete test coverage
-* :template_folder and :variable options are no longer being passed in as part of the options hash to defined blocks and partials
+* :template_folder and :variable options are no longer being passed in as part of the options hash to defined blocks and partials
+
+1.2.0 (February 5, 2012)
+
+* Changed prototype for "use" method, such that the name of the block being rendered is now a required parameter.
+* Documented BuildingBlocks::Base more thoroughly
+* Changed the blocks.use method to blocks.render (blocks.use is still available for legacy purposes)
+* Removed the original render method and replaced with render_template that takes the partial and block to render as arguments.

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.0

data/lib/building_blocks/base.rb

@@ -10,9 +10,6 @@ module BuildingBlocks
     # Hash of block names to BuildingBlocks::Container objects
     attr_accessor :blocks
 
-    # the block that is passed in for the templating feature
-    attr_accessor :block
-
     # Array of BuildingBlocks::Container objects, storing the order of blocks as they were queued
     attr_accessor :queued_blocks
 
@@ -50,9 +47,9 @@ module BuildingBlocks
     #   The name of the block being defined (either a string or a symbol)
     # [+options+]
     #   The default options for the block definition. Any or all of these options may be overrideen by
-    #   whomever calls "blocks.use" on this block.
+    #   whomever calls "blocks.render" on this block.
     # [+block+]
-    #   The block that is to be rendered when "blocks.use" is called for this block.
+    #   The block that is to be rendered when "blocks.render" is called for this block.
     def define(name, options={}, &block)
       self.define_block_container(name, options, &block)
       nil
@@ -71,37 +68,101 @@ module BuildingBlocks
     #   The name of the block being defined (either a string or a symbol)
     # [+options+]
     #   The default options for the block definition. Any or all of these options may be overrideen by
-    #   whomever calls "blocks.use" on this block.
+    #   whomever calls "blocks.render" on this block.
     # [+block+]
-    #   The block that is to be rendered when "blocks.use" is called for this block.
+    #   The block that is to be rendered when "blocks.render" is called for this block.
     def replace(name, options={}, &block)
       blocks[name.to_sym] = nil
       self.define_block_container(name, options, &block)
       nil
     end
 
-    def use(*args, &block)
-      name_or_container = args.first ? args.shift : self.anonymous_block_name
+    # Render a block, first rendering any "before" blocks, then rendering the block itself, then rendering
+    # any "after" blocks. BuildingBlocks will make four different attempts to render block:
+    #   1) Look for a block that has been defined inline elsewhere, using the blocks.define method:
+    #      <% blocks.define :wizard do |options| %>
+    #        Inline Block Step#<%= options[:step] %>.
+    #      <% end %>
+    #
+    #      <%= blocks.render :wizard, :step => @step %>
+    #   2) Look for a partial within the current controller's view directory:
+    #      <%= blocks.render :wizard, :step => @step %>
+    #
+    #      <!-- In /app/views/pages/_wizard.html.erb (assuming it is the pages controller running): -->
+    #      Controller-specific Block Step# <%= step %>.
+    #   3) Look for a partial with the global blocks view directory (by default /app/views/blocks/):
+    #      <%= blocks.render :wizard, :step => @step %>
+    #
+    #      <!-- In /app/views/blocks/_wizard.html.erb: -->
+    #      Global Block Step#<%= step %>.
+    #   4) Render the default implementation for the block if provided to the blocks.render call:
+    #      <%= blocks.render :wizard, :step => @step do |options| do %>
+    #        Default Implementation Block Step#<%= options %>.
+    #      <% end %>
+    # Options:
+    # [+name+]
+    #   The name of the block to render (either a string or a symbol)
+    # [+*args+]
+    #   Any arguments to pass to the block to be rendered (and also to be passed to any "before" and "after" blocks).
+    # [+block+]
+    #   The default block to render if no such block block that is to be rendered when "blocks.render" is called for this block.
+    def render(name_or_container, *args, &block)
       buffer = ActiveSupport::SafeBuffer.new
       buffer << render_before_blocks(name_or_container, *args)
       buffer << render_block(name_or_container, *args, &block)
       buffer << render_after_blocks(name_or_container, *args)
       buffer
     end
-
+    alias use render
+
+    # Queue a block for later rendering, such as within a template.
+    #   <%= BuildingBlocks::Base.new(self).render_template("shared/wizard") do |blocks| %>
+    #     <% blocks.queue :step1 %>
+    #     <% blocks.queue :step2 do %>
+    #       My overridden Step 2 |
+    #     <% end %>
+    #     <% blocks.queue :step3 %>
+    #     <% blocks.queue do %>
+    #       | Anonymous Step 4
+    #     <% end %>
+    #   <% end %>
+    #
+    #   <!-- In /app/views/shared/wizard -->
+    #   <% blocks.define :step1 do %>
+    #     Step 1 |
+    #   <% end %>
+    #
+    #   <% blocks.define :step2 do %>
+    #     Step 2 |
+    #   <% end %>
+    #
+    #   <% blocks.define :step3 do %>
+    #     Step 3
+    #   <% end %>
+    #
+    #   <% blocks.queued_blocks.each do |block| %>
+    #     <%= blocks.render block %>
+    #   <% end %>
+    #
+    #   <!-- Will render: Step 1 | My overridden Step 2 | Step 3 | Anonymous Step 4-->
+    # Options:
+    # [+*args+]
+    #   The options to pass in when this block is rendered. These will override any options provided to the actual block
+    #   definition. Any or all of these options may be overriden by whoever calls "blocks.render" on this block.
+    #   Usually the first of these args will be the name of the block being queued (either a string or a symbol)
+    # [+block+]
+    #   The optional block definition to render when the queued block is rendered
     def queue(*args, &block)
       self.queued_blocks << self.define_block_container(*args, &block)
       nil
     end
 
-    def render
-      raise "Must specify :template parameter in order to render" unless global_options[:template]
-
+    def render_template(partial, &block)
       render_options = global_options.clone
       render_options[self.variable] = self
-      render_options[:captured_block] = view.capture(self, &self.block) if self.block
+      render_options[:captured_block] = view.capture(self, &block) if block_given?
 
-      view.render global_options[:template], render_options
+      view.render partial, render_options
     end
 
     def before(name, options={}, &block)
@@ -116,6 +177,8 @@ module BuildingBlocks
     end
     alias append after
 
+    protected
+
     # If a method is missing, we'll assume the user is starting a new block group by that missing method name
     def method_missing(m, *args, &block)
       options = args.extract_options!
@@ -130,7 +193,7 @@ module BuildingBlocks
       self.queued_blocks = []
       self.block_groups[m] = self.queued_blocks
 
-      # Capture the contents of the block group (this will only capture block definitions and block uses)
+      # Capture the contents of the block group (this will only capture block definitions and block renders; it will ignore anything else)
       view.capture(global_options.merge(options), &block) if block_given?
 
       # restore the original block positions array
@@ -138,14 +201,11 @@ module BuildingBlocks
       nil
     end
 
-    protected
-
-    def initialize(view, options={}, &block)
+    def initialize(view, options={})
       self.templates_folder = options[:templates_folder] ? options.delete(:templates_folder) : BuildingBlocks::TEMPLATE_FOLDER
       self.variable = (options[:variable] ? options.delete(:variable) : :blocks).to_sym
       self.view = view
       self.global_options = options
-      self.block = block
       self.queued_blocks = []
       self.blocks = {}
       self.anonymous_block_number = 0
@@ -194,41 +254,14 @@ module BuildingBlocks
     end
 
     def render_before_blocks(name_or_container, *args)
-      options = args.extract_options!
-
-      block_options = {}
-      if (name_or_container.is_a?(BuildingBlocks::Container))
-        name = name_or_container.name.to_sym
-        block_options = name_or_container.options
-      else
-        name = name_or_container.to_sym
-        block_options = blocks[name].options if blocks[name]
-      end
-
-      before_name = "before_#{name.to_s}".to_sym
-      buffer = ActiveSupport::SafeBuffer.new
-
-      if blocks[before_name].present?
-        blocks[before_name].each do |block_container|
-          args_clone = args.clone
-          args_clone.push(global_options.merge(block_options).merge(block_container.options).merge(options))
-          buffer << view.capture(*(args_clone[0, block_container.block.arity]), &block_container.block)
-        end
-      elsif BuildingBlocks::USE_PARTIALS && BuildingBlocks::USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS
-        begin
-          begin
-            buffer << view.render("before_#{name.to_s}", global_options.merge(block_options).merge(options))
-          rescue ActionView::MissingTemplate
-            buffer << view.render("#{self.templates_folder}/before_#{name.to_s}", global_options.merge(block_options).merge(options))
-          end
-        rescue ActionView::MissingTemplate
-        end
-      end
-
-      buffer
+      render_before_or_after_blocks(name_or_container, "before", *args)
     end
 
     def render_after_blocks(name_or_container, *args)
+      render_before_or_after_blocks(name_or_container, "after", *args)
+    end
+
+    def render_before_or_after_blocks(name_or_container, before_or_after, *args)
       options = args.extract_options!
 
       block_options = {}
@@ -240,11 +273,11 @@ module BuildingBlocks
         block_options = blocks[name].options if blocks[name]
       end
 
-      after_name = "after_#{name.to_s}".to_sym
+      before_name = "#{before_or_after}_#{name.to_s}".to_sym
       buffer = ActiveSupport::SafeBuffer.new
 
-      if blocks[after_name].present?
-        blocks[after_name].each do |block_container|
+      if blocks[before_name].present?
+        blocks[before_name].each do |block_container|
           args_clone = args.clone
           args_clone.push(global_options.merge(block_options).merge(block_container.options).merge(options))
           buffer << view.capture(*(args_clone[0, block_container.block.arity]), &block_container.block)
@@ -252,9 +285,9 @@ module BuildingBlocks
       elsif BuildingBlocks::USE_PARTIALS && BuildingBlocks::USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS
         begin
           begin
-            buffer << view.render("after_#{name.to_s}", global_options.merge(block_options).merge(options))
+            buffer << view.render("#{before_or_after}_#{name.to_s}", global_options.merge(block_options).merge(options))
           rescue ActionView::MissingTemplate
-            buffer << view.render("#{self.templates_folder}/after_#{name.to_s}", global_options.merge(block_options).merge(options))
+            buffer << view.render("#{self.templates_folder}/#{before_or_after}_#{name.to_s}", global_options.merge(block_options).merge(options))
           end
         rescue ActionView::MissingTemplate
         end

data/spec/building-blocks/base_spec.rb

@@ -15,7 +15,7 @@ describe BuildingBlocks::Base do
     @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
-    @builder.use :some_block, :value1 => 1, :value2 => 2
+    @builder.render :some_block, :value1 => 1, :value2 => 2
     BuildingBlocks.send(:remove_const, "TEMPLATE_FOLDER")
     BuildingBlocks.const_set("TEMPLATE_FOLDER", "blocks")
   end
@@ -147,46 +147,40 @@ describe BuildingBlocks::Base do
     end
   end
 
-  describe "render method" do
-    it "should raise an exception if no :template parameter is specified in the options hash" do
-      view = mock()
-      builder = BuildingBlocks::Base.new(view)
-      lambda { builder.render }.should raise_error("Must specify :template parameter in order to render")
-    end
-
+  describe "render_template method" do
     it "should attempt to render a partial specified as the :template parameter" do
       view = mock()
-      builder = BuildingBlocks::Base.new(view, :template => "my_template")
-      view.expects(:render).with{ |template, options| template.should eql "my_template"}
-      builder.render
+      builder = BuildingBlocks::Base.new(view)
+      view.expects(:render).with{ |template, options| template == "my_template"}
+      builder.render_template("my_template")
     end
 
     it "should set all of the global options as local variables to the partial it renders" do
       view = mock()
-      builder = BuildingBlocks::Base.new(view, :template => "some_template")
-      view.expects(:render).with { |template, options| options.should eql :template => 'some_template', :blocks => builder }
-      builder.render
+      builder = BuildingBlocks::Base.new(view)
+      view.expects(:render).with { |template, options| template == 'some_template' && options[:blocks] == builder }
+      builder.render_template("some_template")
     end
 
     it "should capture the data of a block if a block has been specified" do
       block = Proc.new { |options| "my captured block" }
-      builder = BuildingBlocks::Base.new(@view, :template => "template", &block)
-      @view.expects(:render).with { |tempate, options| options[:captured_block].should eql("my captured block") }
-      builder.render
+      builder = BuildingBlocks::Base.new(@view)
+      @view.expects(:render).with { |tempate, options| options[:captured_block] == "my captured block" }
+      builder.render_template("template", &block)
     end
 
     it "should by default add a variable to the partial called 'blocks' as a pointer to the BuildingBlocks::Base instance" do
       view = mock()
-      builder = BuildingBlocks::Base.new(view, :template => "some_template")
-      view.expects(:render).with { |template, options| options[:blocks].should eql(builder) }
-      builder.render
+      builder = BuildingBlocks::Base.new(view)
+      view.expects(:render).with { |template, options| options[:blocks] == builder }
+      builder.render_template("some_template")
     end
 
     it "should allow the user to override the local variable passed to the partial as a pointer to the BuildingBlocks::Base instance" do
       view = mock()
-      builder = BuildingBlocks::Base.new(view, :variable => "my_variable", :template => "some_template")
+      builder = BuildingBlocks::Base.new(view, :variable => "my_variable")
       view.expects(:render).with { |template, options| options[:blocks].should be_nil }
-      builder.render
+      builder.render_template("some_template")
     end
   end
 
@@ -293,13 +287,13 @@ describe BuildingBlocks::Base do
     it "should be able to use a defined block by its name" do
       block = Proc.new {"output"}
       @builder.define :some_block, &block
-      @builder.use(:some_block).should eql "output"
+      @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}"}
       @builder.define :some_block, &block
-      @builder.use(:some_block).should eql "Options are {}"
+      @builder.render(:some_block).should eql "Options are {}"
     end
 
     it "should be able to use a defined block by its name and pass in runtime arguments as a hash" do
@@ -307,7 +301,7 @@ describe BuildingBlocks::Base do
         print_hash(options)
       end
       @builder.define :some_block, &block
-      @builder.use(: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(: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
@@ -315,61 +309,61 @@ describe BuildingBlocks::Base do
         "first_param: #{first_param}, second_param: #{second_param}, #{print_hash options}"
       end
       @builder.define :some_block, &block
-      @builder.use(: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(: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
       block = Proc.new {|first_param| "first_param = #{first_param}"}
       @builder.define :some_block, &block
-      @builder.use(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql "first_param = 3"
+      @builder.render(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql "first_param = 3"
 
       block = Proc.new {|first_param, second_param| "first_param = #{first_param}, second_param = #{second_param}"}
       @builder.replace :some_block, &block
-      @builder.use(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql "first_param = 3, second_param = 4"
+      @builder.render(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql "first_param = 3, second_param = 4"
 
       block = Proc.new do |first_param, second_param, options|
         "first_param: #{first_param}, second_param: #{second_param}, #{print_hash options}"
       end
       @builder.replace :some_block, &block
-      @builder.use(: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(:param1 => 1, :param2 => "value2")}")
     end
 
     it "should not render anything if using a block that has been defined" do
       @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([],[],[],[],[]))
-      @builder.use :some_block
+      @builder.render :some_block
     end
 
-    it "should first attempt to capture a block's contents when blocks.use is called" do
+    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
       @builder.define :some_block, &block
-      @builder.use :some_block, :value1 => 1, :value2 => 2
+      @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.use is called" do
+    it "should second attempt to render a local partial by the block's name when blocks.render is called" do
       @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
-      @builder.use :some_block, :value1 => 1, :value2 => 2
+      @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.use is called" do
+    it "should third attempt to render a global partial by the block's name when blocks.render is called" do
       @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
-      @builder.use :some_block, :value1 => 1, :value2 => 2
+      @builder.render :some_block, :value1 => 1, :value2 => 2
     end
 
-    it "should fourth attempt to render a default block when blocks.use is called" do
+    it "should fourth attempt to render a default block when blocks.render is called" do
       block = Proc.new {|options|}
       @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)
-      @builder.use :some_block, :value1 => 1, :value2 => 2, &block
+      @builder.render :some_block, :value1 => 1, :value2 => 2, &block
     end
 
     it "should not attempt to render a partial if BuildingBlocks::USE_PARTIALS is set to false" do
@@ -379,7 +373,7 @@ describe BuildingBlocks::Base do
       @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)
-      @builder.use :some_block, :value1 => 1, :value2 => 2, &block
+      @builder.render :some_block, :value1 => 1, :value2 => 2, &block
       BuildingBlocks.send(:remove_const, "USE_PARTIALS")
       BuildingBlocks.const_set("USE_PARTIALS", true)
     end
@@ -391,14 +385,14 @@ describe BuildingBlocks::Base do
       @builder.define(:my_before_block, :param1 => "define level", :param2 => "define level", :param3 => "define level", &block)
       block_container = @builder.queued_blocks.first
       @view.expects(:capture).with(:param4 => 'global level', :param1 => 'use level', :param2 => 'queue level', :param3 => 'define level')
-      @builder.use block_container, :param1 => "use level"
+      @builder.render block_container, :param1 => "use level"
     end
 
     it "should render the contents of a defined block when that block is used" do
       block = Proc.new {}
       @view.expects(:capture).with(nil).returns("rendered content")
       @builder.define :some_block, &block
-      buffer = @builder.use :some_block
+      buffer = @builder.render :some_block
       buffer.should eql "rendered content"
     end
   end
@@ -413,7 +407,7 @@ describe BuildingBlocks::Base do
       block = Proc.new {|value1, value2, options|}
       @builder.before("my_before_block", &block)
       @view.expects(:capture).with(1, 2, :value3 => 3, :value4 => 4)
-      @builder.use :my_before_block, 1, 2, :value3 => 3, :value4 => 4
+      @builder.render :my_before_block, 1, 2, :value3 => 3, :value4 => 4
     end
 
     it "should try and render a before block as a local partial if no before blocks are specified" do
@@ -421,7 +415,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("before_my_before_block", :value1 => 1, :value2 => 2).once
       @view.expects(:render).with("blocks/before_my_before_block", :value1 => 1, :value2 => 2).never
-      @builder.use :my_before_block, :value1 => 1, :value2 => 2
+      @builder.render :my_before_block, :value1 => 1, :value2 => 2
     end
 
     it "should try and render a before block as a global partial if no after blocks are specified and the local partial does not exist" do
@@ -429,7 +423,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("before_my_before_block", :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
       @view.expects(:render).with("blocks/before_my_before_block", :value1 => 1, :value2 => 2).once
-      @builder.use :my_before_block, :value1 => 1, :value2 => 2
+      @builder.render :my_before_block, :value1 => 1, :value2 => 2
     end
 
     it "should not attempt to render a before block as a partial if BuildingBlocks::USE_PARTIALS is set to false" do
@@ -439,7 +433,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("before_my_before_block", :value1 => 1, :value2 => 2).never
       @view.expects(:render).with("blocks/before_my_before_block", :value1 => 1, :value2 => 2).never
-      @builder.use :my_before_block, :value1 => 1, :value2 => 2
+      @builder.render :my_before_block, :value1 => 1, :value2 => 2
       BuildingBlocks.send(:remove_const, "USE_PARTIALS")
       BuildingBlocks.const_set("USE_PARTIALS", true)
     end
@@ -451,7 +445,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("before_my_before_block", :value1 => 1, :value2 => 2).never
       @view.expects(:render).with("blocks/before_my_before_block", :value1 => 1, :value2 => 2).never
-      @builder.use :my_before_block, :value1 => 1, :value2 => 2
+      @builder.render :my_before_block, :value1 => 1, :value2 => 2
       BuildingBlocks.send(:remove_const, "USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS")
       BuildingBlocks.const_set("USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS", true)
     end
@@ -462,7 +456,7 @@ describe BuildingBlocks::Base do
       @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.use :my_before_block, :param1 => "top level"
+      @builder.render :my_before_block, :param1 => "top level"
     end
   end
   
@@ -476,7 +470,7 @@ describe BuildingBlocks::Base do
       block = Proc.new {|value1, value2, options|}
       @builder.after("my_after_block", &block)
       @view.expects(:capture).with(1, 2, :value3 => 3, :value4 => 4)
-      @builder.use :my_after_block, 1, 2, :value3 => 3, :value4 => 4
+      @builder.render :my_after_block, 1, 2, :value3 => 3, :value4 => 4
     end
 
     it "should try and render a after block as a local partial if no after blocks are specified" do
@@ -484,7 +478,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("after_my_after_block", :value1 => 1, :value2 => 2).once
       @view.expects(:render).with("blocks/after_my_after_block", :value1 => 1, :value2 => 2).never
-      @builder.use :my_after_block, :value1 => 1, :value2 => 2
+      @builder.render :my_after_block, :value1 => 1, :value2 => 2
     end
 
     it "should try and render a after block as a global partial if no after blocks are specified and the local partial does not exist" do
@@ -492,7 +486,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("after_my_after_block", :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
       @view.expects(:render).with("blocks/after_my_after_block", :value1 => 1, :value2 => 2).once
-      @builder.use :my_after_block, :value1 => 1, :value2 => 2
+      @builder.render :my_after_block, :value1 => 1, :value2 => 2
     end
 
     it "should not attempt to render a after block as a partial if BuildingBlocks::USE_PARTIALS is set to false" do
@@ -502,7 +496,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("after_my_after_block", :value1 => 1, :value2 => 2).never
       @view.expects(:render).with("blocks/after_my_after_block", :value1 => 1, :value2 => 2).never
-      @builder.use :my_after_block, :value1 => 1, :value2 => 2
+      @builder.render :my_after_block, :value1 => 1, :value2 => 2
       BuildingBlocks.send(:remove_const, "USE_PARTIALS")
       BuildingBlocks.const_set("USE_PARTIALS", true)
     end
@@ -514,7 +508,7 @@ describe BuildingBlocks::Base do
       @view.expects(:capture).never
       @view.expects(:render).with("after_my_after_block", :value1 => 1, :value2 => 2).never
       @view.expects(:render).with("blocks/after_my_after_block", :value1 => 1, :value2 => 2).never
-      @builder.use :my_after_block, :value1 => 1, :value2 => 2
+      @builder.render :my_after_block, :value1 => 1, :value2 => 2
       BuildingBlocks.send(:remove_const, "USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS")
       BuildingBlocks.const_set("USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS", true)
     end
@@ -525,7 +519,7 @@ describe BuildingBlocks::Base do
       @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.use :my_after_block, :param1 => "top level"
+      @builder.render :my_after_block, :param1 => "top level"
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: building-blocks
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 31
   prerelease: 
   segments: 
   - 1
-  - 1
+  - 2
   - 0
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Andrew Hunter
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-04 00:00:00 -05:00
+date: 2012-02-05 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -160,6 +160,48 @@ dependencies:
   prerelease: false
   type: :development
   requirement: *id010
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  version_requirements: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id011
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  version_requirements: &id012 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id012
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  version_requirements: &id013 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id013
 description: ""
 email: hunterae@gmail.com
 executables: []