building-blocks 0.1.1 → 1.0.0

data/README.rdoc

@@ -176,40 +176,40 @@ Then, in a specific view that is rendered using this layout, you can add stylesh
 
 == Blocks as Partials
 
-Using exactly the same syntax for "using" blocks, one can put the code to be rendered in it's own separate file (in a partial). When "blocks.use :some_block" is called, the system will first look for a block defined inline (i.e. one that has been defined using "blocks.define :some_block"). Failing to find that, it will see if a default implementation has been provided for the block and render it if one has been specified. Failing to find that, it will look for a partial by the same name in your current controller's view directory. And failing to find that partial, it will look for a partial in the global blocks' directory (by default, /app/views/blocks). Any parameters passed in as a hash will be initialized in the partial as local variables.
+Using exactly the same syntax for "using" blocks, one can put the code to be rendered in it's own separate file (in a partial). When "blocks.use :some_block" is called, the system will first look for a block defined inline (i.e. one that has been defined using "blocks.define :some_block"). Failing to find that, it will look for a partial by the same name in your current controller's view directory. Failing to find that partial, it will look for a partial in the global blocks' directory (by default, /app/views/blocks). Any parameters passed in as a hash will be initialized in the partial as local variables. And failing to find that, it will see if a default implementation has been provided for the block and render it if one has been specified.
 
 As an example, consider the following code, running in a view for PagesController:
 
   <%= blocks.use :wizard, :step => @step %>
 
   <!-- 1) Check and see if there was a block defined called "wizard" somewhere prior to its use... No? then... -->
-  <!-- 2) Check and see if there is a default definition provided for "wizard", i.e. specified in the "blocks.use" call... No? Then... -->
-  <!-- 3) Check and see if there is a controller-specific partial /app/views/pages/wizard.html.erb. No? Then... -->
-  <!-- 4) Check and see if there is a global partial /app/views/blocks/wizard.html.erb. No? Then render nothing. -->
+  <!-- 2) Check and see if there is a controller-specific partial /app/views/pages/wizard.html.erb. No? Then... -->
+  <!-- 3) Check and see if there is a global partial /app/views/blocks/wizard.html.erb. No? Then... -->
+  <!-- 4) Check and see if there is a default definition provided for "wizard", i.e. specified in the "blocks.use" call... No? Then render nothing -->
 
 Let's look at each example individually, written in the order that BuildingBlocks attempts to render them:
 
-1. Inline definition of a block:
+1) Inline definition of a block:
   <% blocks.define :wizard do |options| %>
     Inline Block Step#<%= options[:step] %>.
   <% end %>
 
   <!-- Elsewhere, you can use the block as follows -->
   <%= blocks.use :wizard, :step => @step %>
-2. Default implementation of a block:
-  <%= blocks.use :wizard, :step => @step do |options| do %>
-    Default Implementation Block Step#<%= options %>.
-  <% end %>
-3. Controller-specific partial:
+2) Controller-specific partial:
   <%= blocks.use :wizard, :step => @step %>
 
   <!-- In /app/views/pages/_wizard.html.erb: -->
   Controller-specific Block Step# <%= step %>.
-4. Global partial:
+3) Global partial:
   <%= blocks.use :wizard, :step => @step %>
 
   <!-- In /app/views/blocks/_wizard.html.erb: -->
   Global Block Step#<%= step %>.
+4) Default implementation of a block:
+  <%= blocks.use :wizard, :step => @step do |options| do %>
+    Default Implementation Block Step#<%= options %>.
+  <% end %>
 
 == Overall Render Order
 
@@ -218,23 +218,24 @@ link:/hunterae/building-blocks/raw/master/blocks_render_order.png
 
 == Templating
 
-The most advanced feature of BuildingBlocks is the ability to utilize it for templating and writing your own DTD specifications for the components you write.
+The most advanced feature of BuildingBlocks is the ability to utilize it for templating and creating your own DTD specifications for the components you write.
 
-As an example, consider {table-for}[https://github.com/hunterae/table-for], a library that was written with minimal codes that provides its user with a very nice, easy-to-use table builder. A sample usage might look something like:
+As an example, consider {table-for}[https://github.com/hunterae/table-for], a gem that was written with minimal codes that provides its user with a very nice, easy-to-use table builder. A sample usage might look something like:
 
-  <%= table_for @users, :row_html => {:class => lambda { cycle('even', 'odd')},
-                                      :id => lambda {|user| "user-#{user.id}"}},
-                        :sortable => true do |table| %>
-    <% table.column :edit %>
-    <% table.column :show %>
-    <% table.column :email, :label => "Email Address" %>
-    <% table.column :name, :header_html => {:style => "background-color:orange"} do |user| %>
+  <%= table_for @users, :table_html => {:style => "border: 1px solid black"},
+                        :sortable => true,
+                        :row_html => {:class => lambda { cycle('even', 'odd')},
+                                      :id => lambda {|user| "user-#{user.id}"}} do |table| %>
+    <%= table.column :edit %>
+    <%= table.column :show %>
+    <%= table.column :email, :label => "Email Address" %>
+    <%= table.column :label => "Full Name", :sortable => false, :header_html => {:style => "color:orange"} do |user| %>
       <%= "#{user.first_name} #{user.last_name}" %>
     <% end %>
-    <% table.column :delete %>
+    <%= table.column :delete %>
   <% end %>
 
-MORE EXPLANATION TO COME
+VIDEO TUTORIAL TO COME
 
 == MORE COMING SOON...
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+1.0.0

data/lib/building-blocks.rb

@@ -1,13 +1,5 @@
 require "action_view"
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
 require "building_blocks/base"
 require "building_blocks/container"
-require "building_blocks/helper_methods"
-
-$LOAD_PATH.shift
-
-if defined?(ActionView::Base)
-  ActionView::Base.send :include, BuildingBlocks::HelperMethods
-end
+require "building_blocks/view_additions"

data/lib/building_blocks/base.rb

@@ -1,4 +1,6 @@
 module BuildingBlocks
+  BUILDING_BLOCKS_TEMPLATE_FOLDER = "blocks"
+
   class Base
     attr_accessor :view
 
@@ -6,7 +8,7 @@ module BuildingBlocks
 
     attr_accessor :block
 
-    # Array of BuildingBlocks::Container objects, storing the order of blocks as they were used
+    # Array of BuildingBlocks::Container objects, storing the order of blocks as they were queued
     attr_accessor :queued_blocks
 
     # counter, used to give unnamed blocks a unique name
@@ -67,25 +69,16 @@ module BuildingBlocks
     end
 
     def use(*args, &block)
-      options = args.extract_options!
-
-      # If the user doesn't specify a block name, we generate an anonymous block name to assure other
-      #  anonymous blocks don't override its definition
-      name = args.first ? args.shift : self.anonymous_block_name
-
-      # self.define_block_container(name, options, &block) if block_given?
-      self.render_block name, args, options, &block
+      name_or_container = args.first ? args.shift : self.anonymous_block_name
+      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
 
     def queue(*args, &block)
-      options = args.extract_options!
-
-      # If the user doesn't specify a block name, we generate an anonymous block name to assure other
-      #  anonymous blocks don't override its definition
-      name = args.first ? args.shift : self.anonymous_block_name
-
-      # Delays rendering this block until the partial has been rendered and all the blocks have had a chance to be defined
-      self.queued_blocks << self.define_block_container(name, options, &block)
+      self.queued_blocks << self.define_block_container(*args, &block)
       nil
     end
 
@@ -100,37 +93,13 @@ module BuildingBlocks
     end
 
     def before(name, options={}, &block)
-      name = "before_#{name.to_s}".to_sym
-
-      block_container = BuildingBlocks::Container.new
-      block_container.name = name
-      block_container.options = options
-      block_container.block = block
-
-      if view.blocks.blocks[name].nil?
-        blocks[name] = [block_container]
-      else
-        blocks[name] << block_container
-      end
-
+      self.queue_block_container("before_#{name.to_s}", options, &block)
       nil
     end
     alias prepend before
 
     def after(name, options={}, &block)
-      name = "after_#{name.to_s}".to_sym
-
-      block_container = BuildingBlocks::Container.new
-      block_container.name = name
-      block_container.options = options
-      block_container.block = block
-
-      if view.blocks.blocks[name].nil?
-        blocks[name] = [block_container]
-      else
-        blocks[name] << block_container
-      end
-
+      self.queue_block_container("after_#{name.to_s}", options, &block)
       nil
     end
     alias append after
@@ -160,7 +129,7 @@ module BuildingBlocks
     protected
 
     def initialize(view, options={}, &block)
-      options[:templates_folder] = "blocks" if options[:templates_folder].nil?
+      options[:templates_folder] = BuildingBlocks::BUILDING_BLOCKS_TEMPLATE_FOLDER if options[:templates_folder].nil?
 
       self.view = view
       self.global_options = options
@@ -172,11 +141,13 @@ module BuildingBlocks
     end
 
     def anonymous_block_name
-      self.anonymous_block_number = self.anonymous_block_number + 1
+      self.anonymous_block_number += 1
       "block_#{anonymous_block_number}"
     end
 
-    def render_block(name_or_container, args, runtime_options={}, &block)
+    def render_block(name_or_container, *args, &block)
+      options = args.extract_options!
+
       buffer = ActiveSupport::SafeBuffer.new
 
       block_options = {}
@@ -187,63 +158,28 @@ module BuildingBlocks
         name = name_or_container.to_sym
       end
 
-      buffer << render_before_blocks(name_or_container, runtime_options)
-
       if blocks[name]
         block_container = blocks[name]
-
-        args.push(global_options.merge(block_container.options).merge(block_options).merge(runtime_options))
-
-        # If the block is taking more than one parameter, we can use *args
-        if block_container.block.arity > 1
-          buffer << view.capture(*args, &block_container.block)
-
-        # However, if the block only takes a single parameter, we do not want ruby to try to cram the args list into that parameter
-        #   as an array
-        else
-          buffer << view.capture(args.first, &block_container.block)
-        end
-      elsif view.blocks.blocks[name]
-        block_container = view.blocks.blocks[name]
-
-        args.push(global_options.merge(block_container.options).merge(block_options).merge(runtime_options))
-
-        # If the block is taking more than one parameter, we can use *args
-        if block_container.block.arity > 1
-          buffer << view.capture(*args, &block_container.block)
-
-        # However, if the block only takes a single parameter, we do not want ruby to try to cram the args list into that parameter
-        #   as an array
-        else
-          buffer << view.capture(args.first, &block_container.block)
-        end
+        args.push(global_options.merge(block_container.options).merge(block_options).merge(options))
+        buffer << view.capture(*(args[0, block_container.block.arity]), &block_container.block)
       else
         begin
-          begin            
-            buffer << view.render("#{name.to_s}", global_options.merge(block_options).merge(runtime_options))
-          rescue ActionView::MissingTemplate            
-            # This partial did not exist in the current controller's view directory; now checking in the default templates folder
-            buffer << view.render("#{self.global_options[:templates_folder]}/#{name.to_s}", global_options.merge(block_options).merge(runtime_options))
+          begin
+            buffer << view.render("#{name.to_s}", global_options.merge(block_options).merge(options))
+          rescue ActionView::MissingTemplate
+            buffer << view.render("#{self.global_options[:templates_folder]}/#{name.to_s}", global_options.merge(block_options).merge(options))
           end
         rescue ActionView::MissingTemplate
-          if block_given?
-            args.push(global_options.merge(runtime_options))
-            if block.arity > 1
-              buffer << view.capture(*args, &block)
-            else
-              buffer << view.capture(args.first, &block)
-            end
-          end
+          args.push(global_options.merge(options))
+          buffer << view.capture(*(args[0, block.arity]), &block) if block_given?
         end
       end
 
-      buffer << render_after_blocks(name_or_container, runtime_options)
-
       buffer
     end
 
-    def render_before_blocks(name_or_container, runtime_options={})
-      options = global_options
+    def render_before_blocks(name_or_container, *args)
+      options = args.extract_options!
 
       block_options = {}
       if (name_or_container.is_a?(BuildingBlocks::Container))
@@ -251,37 +187,34 @@ module BuildingBlocks
         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
-
-      if blocks[name]
-        block_container = blocks[name]
-        options = options.merge(block_container.options)
-      elsif view.blocks.blocks[name]
-        block_container = view.blocks.blocks[name]
-        options = options.merge(block_container.options)
-      end
-
       buffer = ActiveSupport::SafeBuffer.new
 
-      unless blocks[before_name].nil?
+      if blocks[before_name].present?
         blocks[before_name].each do |block_container|
-          buffer << view.capture(options.merge(block_container.options).merge(block_options).merge(runtime_options), &block_container.block)
+          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
-      end
-
-      unless view.blocks.blocks[before_name].nil? || view.blocks.blocks == blocks
-        view.blocks.blocks[before_name].each do |block_container|
-          buffer << view.capture(options.merge(block_container.options).merge(block_options).merge(runtime_options), &block_container.block)
+      else
+        begin
+          begin
+            buffer << view.render("before_#{name.to_s}", global_options.merge(block_options).merge(options))
+          rescue ActionView::MissingTemplate
+            buffer << view.render("#{self.global_options[:templates_folder]}/before_#{name.to_s}", global_options.merge(block_options).merge(options))
+          end
+        rescue ActionView::MissingTemplate
         end
       end
 
       buffer
     end
 
-    def render_after_blocks(name_or_container, runtime_options={})
-      options = global_options
+    def render_after_blocks(name_or_container, *args)
+      options = args.extract_options!
 
       block_options = {}
       if (name_or_container.is_a?(BuildingBlocks::Container))
@@ -289,43 +222,54 @@ module BuildingBlocks
         block_options = name_or_container.options
       else
         name = name_or_container.to_sym
+        block_options = blocks[name].options if blocks[name]
       end
 
       after_name = "after_#{name.to_s}".to_sym
-
-      if blocks[name]
-        block_container = blocks[name]
-
-        options = options.merge(block_container.options)
-      elsif view.blocks.blocks[name]
-        block_container = view.blocks.blocks[name]
-
-        options = options.merge(block_container.options)
-      end
-
       buffer = ActiveSupport::SafeBuffer.new
 
-      unless blocks[after_name].nil?
+      if blocks[after_name].present?
         blocks[after_name].each do |block_container|
-          buffer << view.capture(options.merge(block_container.options).merge(block_options).merge(runtime_options), &block_container.block)
+          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
-      end
-
-      unless view.blocks.blocks[after_name].nil? || view.blocks.blocks == blocks
-        view.blocks.blocks[after_name].each do |block_container|
-          buffer << view.capture(options.merge(block_container.options).merge(block_options).merge(runtime_options), &block_container.block)
+      else
+        begin
+          begin
+            buffer << view.render("after_#{name.to_s}", global_options.merge(block_options).merge(options))
+          rescue ActionView::MissingTemplate
+            buffer << view.render("#{self.global_options[:templates_folder]}/after_#{name.to_s}", global_options.merge(block_options).merge(options))
+          end
+        rescue ActionView::MissingTemplate
         end
       end
 
       buffer
     end
 
-    def define_block_container(name, options, &block)
+    def build_block_container(*args, &block)
+      options = args.extract_options!
+      name = args.first ? args.shift : self.anonymous_block_name
       block_container = BuildingBlocks::Container.new
-      block_container.name = name
+      block_container.name = name.to_sym
       block_container.options = options
       block_container.block = block
-      blocks[name.to_sym] = block_container if blocks[name.to_sym].nil? && block_given?
+      block_container
+    end
+
+    def queue_block_container(*args, &block)
+      block_container = self.build_block_container(*args, &block)
+      if blocks[block_container.name].nil?
+        blocks[block_container.name] = [block_container]
+      else
+        blocks[block_container.name] << block_container
+      end
+    end
+
+    def define_block_container(*args, &block)
+      block_container = self.build_block_container(*args, &block)
+      blocks[block_container.name] = block_container if blocks[block_container.name].nil? && block_given?
       block_container
     end
   end

data/lib/building_blocks/view_additions.rb

@@ -0,0 +1,13 @@
+module BuildingBlocks
+  module ViewAdditions
+    module ClassMethods
+      def blocks
+        @blocks ||= BuildingBlocks::Base.new(self)
+      end
+    end
+  end
+end
+
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, BuildingBlocks::ViewAdditions::ClassMethods
+end

data/spec/building-blocks/base_spec.rb

@@ -2,7 +2,8 @@ require "spec_helper"
 
 describe BuildingBlocks::Base do
   before :each do
-    @builder = BuildingBlocks::Base.new({})
+    @view = ActionView::Base.new
+    @builder = BuildingBlocks::Base.new(@view)
   end
 
   describe "defined? method" do
@@ -10,6 +11,21 @@ describe BuildingBlocks::Base do
       @builder.defined?(:test_block).should be_false
       @builder.define :test_block do end
       @builder.defined?(:test_block).should be_true
+    end
+
+    it "should not care whether the block name was defined with a string or a symbol" do
+      @builder.defined?(:test_block).should be_false
+      @builder.define "test_block" do end
+      @builder.defined?(:test_block).should be_true
+
+      @builder.defined?(:test_block2).should be_false
+      @builder.define :test_block2 do end
+      @builder.defined?(:test_block2).should be_true
+    end
+
+    it "should not care whether the defined? method is passed a string or a symbol" do
+      @builder.defined?("test_block").should be_false
+      @builder.define :test_block do end
       @builder.defined?("test_block").should be_true
     end
   end
@@ -35,12 +51,12 @@ describe BuildingBlocks::Base do
       @builder.define :test_block, :option3 => "value3", :option4 => "value4", &block2
 
       test_block = @builder.blocks[:test_block]
-       test_block.options[:option1].should eql("value1")
-       test_block.options[:option2].should eql("value2")
-       test_block.options[:option3].should be_nil
-       test_block.options[:option4].should be_nil
-       test_block.name.should eql(:test_block)
-       test_block.block.should eql(block1)
+      test_block.options[:option1].should eql("value1")
+      test_block.options[:option2].should eql("value2")
+      test_block.options[:option3].should be_nil
+      test_block.options[:option4].should be_nil
+      test_block.name.should eql(:test_block)
+      test_block.block.should eql(block1)
     end
   end
 
@@ -62,23 +78,406 @@ describe BuildingBlocks::Base do
     end
   end
 
+  describe "queue method" do
+    it "should store all queued blocks in the queued_blocks array" do
+      @builder.queued_blocks.should be_empty
+      @builder.queue :test_block
+      @builder.queued_blocks.length.should eql 1
+      @builder.queued_blocks.map(&:name).first.should eql(:test_block)
+    end
+
+    it "should convert a string block name to a symbol" do
+      @builder.queue "test_block"
+      @builder.queued_blocks.map(&:name).first.should eql(:test_block)
+    end
+
+    it "should queue blocks as BuildingBlocks::Container objects" do
+      @builder.queue :test_block, :a => 1, :b => 2, :c => 3
+      container = @builder.queued_blocks.first
+      container.should be_a(BuildingBlocks::Container)
+      container.name.should eql(:test_block)
+      container.options.should eql(:a => 1, :b => 2, :c => 3)
+    end
+
+    it "should not require a name for the block being queued" do
+      @builder.queue
+      @builder.queue
+      @builder.queued_blocks.length.should eql 2
+      @builder.queued_blocks.map(&:name).first.should eql(:block_1)
+      @builder.queued_blocks.map(&:name).second.should eql(:block_2)
+    end
+
+    it "should anonymously define the name of a block if not specified" do
+      @builder.queue
+      @builder.queue :my_block
+      @builder.queue
+      @builder.queued_blocks.map(&:name).first.should eql(:block_1)
+      @builder.queued_blocks.map(&:name).second.should eql(:my_block)
+      @builder.queued_blocks.map(&:name).third.should eql(:block_2)
+    end
+
+    it "should store queued blocks in the order in which they are queued" do
+      @builder.queue :block1
+      @builder.queue :block3
+      @builder.queue :block2
+      @builder.queued_blocks.map(&:name).first.should eql(:block1)
+      @builder.queued_blocks.map(&:name).second.should eql(:block3)
+      @builder.queued_blocks.map(&:name).third.should eql(:block2)
+    end
+
+    it "should allow a definition to be provided for a queued block" do
+      block = Proc.new do |options| end
+      @builder.queue :test_block, &block
+      container = @builder.queued_blocks.first
+      container.block.should eql block
+    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
+
+    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
+    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 :templates_folder => 'blocks', :template => 'some_template', :blocks => builder }
+      builder.render
+    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
+    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
+    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")
+      view.expects(:render).with { |template, options| options[:blocks].should be_nil }
+      builder.render
+    end
+  end
+
+  describe "before method" do
+    it "should defined 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
+    end
+
+    it "should store a before block in an array" do
+      block = Proc.new { |options| }
+      @builder.before :some_block, &block
+      before_blocks = @builder.blocks[:before_some_block]
+      before_blocks.should be_a(Array)
+    end
+
+    it "should store a before block as a BuildingBlocks::Container" do
+      block = Proc.new { |options| }
+      @builder.before :some_block, :option1 => "some option", &block
+      before_blocks = @builder.blocks[:before_some_block]
+      block_container = before_blocks.first
+      block_container.should be_a(BuildingBlocks::Container)
+      block_container.options.should eql :option1 => "some option"
+      block_container.block.should eql block
+    end
+
+    it "should queue before blocks if there are multiple defined" do
+      block = Proc.new { |options| }
+      block2 = Proc.new { |options| }
+      @builder.before :some_block, &block
+      @builder.before :some_block, &block2
+      before_blocks = @builder.blocks[:before_some_block]
+      before_blocks.length.should eql 2
+    end
+
+    it "should store before blocks in the order in which they are defined" do
+      block = Proc.new { |options| }
+      block2 = Proc.new { |options| }
+      block3 = Proc.new { |options| }
+      @builder.before :some_block, &block
+      @builder.before :some_block, &block2
+      @builder.before :some_block, &block3
+      before_blocks = @builder.blocks[:before_some_block]
+      before_blocks.first.block.should eql block
+      before_blocks.second.block.should eql block2
+      before_blocks.third.block.should eql block3
+    end
+  end
+
+  describe "after method" do
+    it "should defined 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
+    end
+
+    it "should store a after block in an array" do
+      block = Proc.new { |options| }
+      @builder.after :some_block, &block
+      after_blocks = @builder.blocks[:after_some_block]
+      after_blocks.should be_a(Array)
+    end
+
+    it "should store a after block as a BuildingBlocks::Container" do
+      block = Proc.new { |options| }
+      @builder.after :some_block, :option1 => "some option", &block
+      after_blocks = @builder.blocks[:after_some_block]
+      block_container = after_blocks.first
+      block_container.should be_a(BuildingBlocks::Container)
+      block_container.options.should eql :option1 => "some option"
+      block_container.block.should eql block
+    end
+
+    it "should queue after blocks if there are multiple defined" do
+      block = Proc.new { |options| }
+      block2 = Proc.new { |options| }
+      @builder.after :some_block, &block
+      @builder.after :some_block, &block2
+      after_blocks = @builder.blocks[:after_some_block]
+      after_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.after :some_block, &block
+      @builder.after :some_block, &block2
+      @builder.after :some_block, &block3
+      after_blocks = @builder.blocks[:after_some_block]
+      after_blocks.first.block.should eql block
+      after_blocks.second.block.should eql block2
+      after_blocks.third.block.should eql block3
+    end
+  end
+
   describe "use method" do
+    before :each do
+      @builder.expects(:render_before_blocks).at_least_once
+      @builder.expects(:render_after_blocks).at_least_once
+    end
+
     it "should be able to use a defined block by its name" do
-      @builder.expects(:render_block).with(:test_block, [], {})
+      block = Proc.new {"output"}
+      @builder.define :some_block, &block
+      @builder.use(:some_block).should eql "output"
+    end
 
-      block = Proc.new do |options| end
-      @builder.define :test_block, :option1 => "value1", :option2 => "value2", &block
+    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| "Templates folder is #{options[:templates_folder]}"}
+      @builder.define :some_block, &block
+      @builder.use(:some_block).should eql "Templates folder is blocks"
+    end
 
-      @builder.use :test_block
+    it "should be able to use 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.use(:some_block, :param1 => 1, :param2 => "value2").should eql print_hash(:templates_folder => 'blocks', :param1 => 1, :param2 => "value2")
     end
 
-    it "should be able to use a defined block by its name and pass in runtime arguments" do
-      @builder.expects(:render_block).with(:test_block, ["value5"], {:option3 => "value3", :option4 => "value4"})
+    it "should be able to use 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.use(:some_block, 3, 4, :param1 => 1, :param2 => "value2").should eql("first_param: 3, second_param: 4, #{print_hash(:templates_folder => 'blocks', :param1 => 1, :param2 => "value2")}")
+    end
 
-      block = Proc.new do |options| end
-      @builder.define :test_block, :option1 => "value1", :option2 => "value2", &block
+    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"
+
+      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"
+
+      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(:templates_folder => 'blocks', :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", :templates_folder => 'blocks').raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/some_block", :templates_folder => 'blocks').raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @builder.use :some_block
+    end
+
+    it "should first attempt to capture a block's contents when blocks.use is called" do
+      block = Proc.new {|options|}
+      @view.expects(:capture).with(:templates_folder => 'blocks', :value1 => 1, :value2 => 2)
+      @view.expects(:render).with("some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).never
+      @view.expects(:render).with("blocks/some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).never
+      @builder.define :some_block, &block
+      @builder.use :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
+      @view.expects(:capture).with(:templates_folder => 'blocks', :value1 => 1, :value2 => 2).never
+      @view.expects(:render).with("some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).once
+      @view.expects(:render).with("blocks/some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).never
+      @builder.use :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
+      @view.expects(:capture).with(:templates_folder => 'blocks', :value1 => 1, :value2 => 2).never
+      @view.expects(:render).with("some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).once
+      @builder.use :some_block, :value1 => 1, :value2 => 2
+    end
+
+    it "should fourth attempt to render a default block when blocks.use is called" do
+      block = Proc.new {|options|}
+      @view.expects(:render).with("some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/some_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:capture).with(:templates_folder => 'blocks', :value1 => 1, :value2 => 2)
+      @builder.use :some_block, :value1 => 1, :value2 => 2, &block
+    end
+
+    it "should override hash options for a block by merging the runtime options the define default options into the queue level options into the global options" do
+      block = Proc.new {|options|}
+      @builder.global_options.merge!(:param1 => "global level", :param2 => "global level", :param3 => "global level", :param4 => "global level")
+      @builder.queue(:my_before_block, :param1 => "queue level", :param2 => "queue level")
+      @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', :templates_folder => 'blocks', :param2 => 'queue level', :param3 => 'define level')
+      @builder.use 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.should eql "rendered content"
+    end
+  end
+
+  describe "use method - before blocks" do
+    before :each do
+      @builder.expects(:render_block).at_least_once
+      @builder.expects(:render_after_blocks).at_least_once
+    end
+
+    it "should render before blocks when using a block" do
+      block = Proc.new {|value1, value2, options|}
+      @builder.before("my_before_block", &block)
+      @view.expects(:capture).with(1, 2, :templates_folder => 'blocks', :value3 => 3, :value4 => 4)
+      @builder.use :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
+      block = Proc.new {}
+      @view.expects(:capture).never
+      @view.expects(:render).with("before_my_before_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).once
+      @view.expects(:render).with("blocks/before_my_before_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).never
+      @builder.use :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
+      block = Proc.new {}
+      @view.expects(:capture).never
+      @view.expects(:render).with("before_my_before_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/before_my_before_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).once
+      @builder.use :my_before_block, :value1 => 1, :value2 => 2
+    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|}
+      @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', :templates_folder => 'blocks', :param2 => 'before block level', :param3 => 'block level')
+      @builder.use :my_before_block, :param1 => "top level"
+    end
+  end
+  
+  describe "use method - after blocks" do
+    before :each do
+      @builder.expects(:render_block).at_least_once
+      @builder.expects(:render_before_blocks).at_least_once
+    end
+
+    it "should render after blocks when using a block" do
+      block = Proc.new {|value1, value2, options|}
+      @builder.after("my_after_block", &block)
+      @view.expects(:capture).with(1, 2, :templates_folder => 'blocks', :value3 => 3, :value4 => 4)
+      @builder.use :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
+      block = Proc.new {}
+      @view.expects(:capture).never
+      @view.expects(:render).with("after_my_after_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).once
+      @view.expects(:render).with("blocks/after_my_after_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).never
+      @builder.use :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
+      block = Proc.new {}
+      @view.expects(:capture).never
+      @view.expects(:render).with("after_my_after_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).raises(ActionView::MissingTemplate.new([],[],[],[],[]))
+      @view.expects(:render).with("blocks/after_my_after_block", :templates_folder => 'blocks', :value1 => 1, :value2 => 2).once
+      @builder.use :my_after_block, :value1 => 1, :value2 => 2
+    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|}
+      @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', :templates_folder => 'blocks', :param2 => 'after block level', :param3 => 'block level')
+      @builder.use :my_after_block, :param1 => "top level"
+    end
+  end
+
+  describe "method_missing method" do
+    it "should start a new block group if a method is missing" do
+      @builder.some_method
+      queued_blocks = @builder.block_groups[:some_method]
+      queued_blocks.should eql []
+    end
 
-      @builder.use :test_block, "value5", :option3 => "value3", :option4 => "value4"
+    it "should add items to a queue when a new block group is started" do
+      @builder.some_method do
+        @builder.queue :myblock1
+        @builder.queue :myblock2
+      end
+      @builder.some_method2 do
+        @builder.queue :myblock3
+      end
+      queued_blocks = @builder.block_groups[:some_method]
+      queued_blocks.length.should eql 2
+      queued_blocks.first.name.should eql :myblock1
+      queued_blocks.second.name.should eql :myblock2
+      queued_blocks = @builder.block_groups[:some_method2]
+      queued_blocks.length.should eql 1
+      queued_blocks.first.name.should eql :myblock3
+      @builder.queued_blocks.should eql []
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,6 +3,10 @@ require 'bundler/setup'
 
 require 'building-blocks' # and any other gems you need
 
+def print_hash(hash)
+  hash.inject("") { |s, (k, v)| "#{s} #{k}: #{v}." }
+end
+
 RSpec.configure do |config|
   config.mock_with :mocha
   # config.mock_with :flexmock

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: building-blocks
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
-  - 0
-  - 1
   - 1
-  version: 0.1.1
+  - 0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Andrew Hunter
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-27 00:00:00 -05:00
+date: 2012-02-04 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -104,6 +104,34 @@ dependencies:
   prerelease: false
   type: :development
   requirement: *id006
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id007
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  version_requirements: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id008
 description: ""
 email: hunterae@gmail.com
 executables: []
@@ -119,7 +147,7 @@ files:
 - lib/building-blocks.rb
 - lib/building_blocks/base.rb
 - lib/building_blocks/container.rb
-- lib/building_blocks/helper_methods.rb
+- lib/building_blocks/view_additions.rb
 - rails/init.rb
 - spec/building-blocks/base_spec.rb
 - spec/spec_helper.rb

data/lib/building_blocks/helper_methods.rb

@@ -1,7 +0,0 @@
-module BuildingBlocks
-  module HelperMethods
-    def blocks
-      @blocks ||= BuildingBlocks::Base.new(self)
-    end
-  end
-end