building-blocks 1.2.3 → 2.0.0

data/CHANGELOG.rdoc

@@ -1,25 +1,43 @@
-1.1.0 (February 4, 2012)
+2.0.0 (October 18, 2012)
+
+* Added ability to render a collection of objects and specify the surrounding elements and the html to apply to those surrounding elements
+  For example: blocks.render :test, :collection => @cuisine_types, :as => :cuisine_type, :surrounding_tag => "div", :surrounding_tag_html => {:class => Proc.new {cycle("even", "odd")}}
+* Added ability to specify "around" blocks, i.e. blocks of view code that render around another block of code, such as:
+  <% blocks.around :test_block do |content_block| %>
+    <h1>
+      <%= content_block.call %>
+    </h1>
+  <% end %> %>
+* Added a util method BuildingBlocks.render_template(self, partial, options={}, &block) that makes the templating feature easier to use
+  (as opposed to calling the long way: BuildingBlocks::Base.new(self, options={}).render_template(partial, &block))
+* Aliased "#blocks" method that is available to views as "#buildingblocks", "#bb", and "#building_blocks"
+* Aliased "#after" method to "#for", so that you can now call <%= blocks.for :block_name %> (should be slightly more familiar to users of content_for with yield)
+* Added a "#setup" method to initialize BuildingBlocks globally (for example: BuildingBlocks.setup do |config| config.template_folder = "shared" end)
+* Cleaned up the organization of the code base and not using autoload instead of require
+* Removed :use_partials_for_before_and_after_hooks option from 1.2.2
 
-* 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
+1.2.3 (February 9, 2012)
 
-1.2.0 (February 5, 2012)
+* Created two new utility methods: evaluated_procs and evaluated_proc that allow parameters for blocks to be Proc objects so long as these methods are called to evaluate them. (These methods have been carried over and renamed from the table-for gem where they were used to be able to dynamically specify table css classes, styles, and ids at runtime).
 
-* 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.
+1.2.2 (February 9, 2012)
+
+* Allow :use_partials and :use_partials_for_before_and_after_hooks to be passed in as initialization options to BuildingBlocks::Base to control whether BuildingBlocks attempts to render partials when "blocks.render" is called.
 
 1.2.1 (February 7, 2012)
 
 * Only try to render "before" and "after" blocks as partials if that BuildingBlocks::USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS is globally set to true (set to false now by default)
 
-1.2.2 (February 9, 2012)
+1.2.0 (February 5, 2012)
 
-* Allow :use_partials and :use_partials_for_before_and_after_hooks to be passed in as initialization options to BuildingBlocks::Base to control whether BuildingBlocks attempts to render partials when "blocks.render" is called.
+* 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.
 
-1.2.3 (February 9, 2012)
+1.1.0 (February 4, 2012)
 
-* Created two new utility methods: evaluated_procs and evaluated_proc that allow parameters for blocks to be Proc objects so long as these methods are called to evaluate them. (These methods have been carried over and renamed from the table-for gem where they were used to be able to dynamically specify table css classes, styles, and ids at runtime).
+* 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

data/README.rdoc

@@ -1,11 +1,18 @@
 = BuildingBlocks
 
-BuildingBlocks is an intricate way of rendering blocks of code, while adding several features that go above and beyond what a simple content_for with yield is capable of doing.
+RDocs[http://rdoc.info/projects/hunterae/building-blocks] | {Screencast Part 1}[https://vimeo.com/36674545]
 
-1. It provides the ability to pass parameters to a defined block of code (something content_for with yield is incapable of doing). 
-2. It provides "before" and "after" hooks that can render code before and after a specified block of code is rendered (this can be particularly useful when you want to specify a dynamic list of javascript or stylesheet includes after your standard includes).
-3. It allows the developer to define a block of code as a global partial, a controller-specific partial, or an inline block of code, all with the same syntax usage.
-4. (Probably the most powerful aspect) It allows the developer to build complex reusable UI components by essentially providing their own DTD (see the separate project {table-for}[https://github.com/hunterae/table-for] for an example of a nice table builder that was created using minimal code by apply BuildingBlocks).
+BuildingBlocks is an intricate way of rendering blocks of code, while combining some of the best features of content blocks and partials, and adding several new features that go above and beyond what a simple content_for with yield or a render :partial is capable of doing.
+
+1. Automatically determines whether you're rendering a content block (i.e. a block of code that you have defined using similar syntax to content_for) or a partial, with exactly the same syntax
+2. Pass parameters into your blocks of code, regardless of whether your block of code is a content block or a partial (something content_for with yield is incapable of doing)
+3. Use "before" and "after" hooks to designate code that should be rendered before and after a block of code that is to be rendered
+4. Define your blocks of code as either a global partial, a controller-specific partial, or an inline block of code
+5. Provides four different ways to define your block of code: as a global partial, a controller-specific partial, or an inline block of code, all with the same syntax usage.
+6. Provides a very powerful way of defining templates to build reusable UI components with minimal code, as was done with {table-for}[https://github.com/hunterae/table-for]
+
+== Author's Note
+To fully appreciate how powerful BuildingBlocks can be, i highly recommend checking out the project {table-for}[https://github.com/hunterae/table-for] first. This is a gem that was built using BuildingBlocks with very few lines of code, and illustrates how easily the templating feature of BuildingBlocks can be used to build extremely useful reusable UI components.
 
 == Installation
 
@@ -240,7 +247,7 @@ there is a table_for partial that gets rendered, but before it is rendered, the
 template (partial) knows what to render, and occasionally, how to render to render it.
 
 As an easier example, consider the following call in a view file:
-  <%= BuildingBlocks::Base.new(self).render_template("blocks/wizard") do |blocks| %>
+  <%= BuildingBlocks.render_template(self, "blocks/wizard") do |blocks| %>
     <% blocks.queue :step1 %>
     <% blocks.queue :step2 do %>
       My Overridden Step 2 |
@@ -279,7 +286,7 @@ Notice the order of the queued blocks was preserved, Step2's definition was succ
 
 This technique could also very easily be used to do something like wrapping content in some complicated markup, such is wrapping code in html tags to display as
 a header container:
-  <%= BuildingBlocks::Base.new(self).render_template("blocks/header_container") do |blocks| %>
+  <%= BuildingBlocks.render_template(self, "blocks/header_container") do |blocks| %>
     My code to wrap
   <% end %>
   
@@ -299,7 +306,7 @@ What will get rendered will be the following:
 
 The code called from the view could easily be extracted in a helper method as follows:
   def header_container(options={}, &block)
-    BuildingBlocks::Base.new(self, options).render_template("blocks/header_container", &block) 
+    BuildingBlocks.render_template(self, "blocks/header_container", options, &block) 
   end
 
 Then it could be called from the view as follows:
@@ -309,6 +316,39 @@ Then it could be called from the view as follows:
 
 VIDEO TUTORIAL TO COME SHOWING HOW TABLE_FOR CAN BE BUILT FROM SCRATCH
 
+== Block Groups
+
+Another advanced feature of BuildingBlocks is the ability to queue up multiple different sets of blocks in different queues, called block groups. It will most often be used in conjunction with the templating feature described above and is best demonstrated with an example:
+
+  <%= BuildingBlocks::Base.new(self).render_template("blocks/my_layout") do |blocks| %>
+    <% blocks.left_column do %>
+      <%= blocks.queue :left_column_block1 %>
+      <%= blocks.queue :left_column_block2 do %>
+        Some random content on the left
+      <% end %>
+    <% end %>
+    <% blocks.right_column do %>
+      <%= blocks.queue :right_column_block1 %>
+      <%= blocks.queue :right_column_block2 do %>
+        Some random content on the right
+      <% end %>
+    <% end %>
+  <% end %>
+
+In this example, two separate block groups are created, one for the left column on the page, one for the right, both of which will contain an ordered list (queue) of blocks. You start a new block group by invoking a method on "blocks" that does not exist, such as :left_column / :right_column. Then, in the template that renders the content, the queue of left and right column blocks can be iterated over and rendered as follows:
+
+  <!-- In /app/views/blocks/_my_layout.html.erb -->
+  <div style="float:left; width: 50%">
+    <% blocks.left_column.each do |block| %>
+      <%= blocks.render block %>
+    <% end %>
+  </div>
+  <div style="float:left; width: 50%">
+    <% blocks.right_column.each do |block| %>
+      <%= blocks.render block %>
+    <% end %>
+  </div>
+
 == Questions or Problems?
 
 If you have any issues with BuildingBlocks which you cannot find the solution to in the documentation, please add an {issue on GitHub}[https://github.com/hunterae/building-blocks/issues] or fork the project and send a pull request.

data/Rakefile

@@ -9,8 +9,8 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "building-blocks"
-    gemspec.summary = ""
-    gemspec.description = ""
+    gemspec.summary = "BuildingBlocks is an intricate way of rendering blocks of code, while combining some of the best features of content blocks and partials, and adding several new features that go above and beyond what a simple content_for with yield or a render :partial is capable of doing."
+    gemspec.description = "BuildingBlocks goes beyond blocks and partials"
     gemspec.email = "hunterae@gmail.com"
     gemspec.homepage = "http://github.com/hunterae/building-blocks"
     gemspec.authors = ["Andrew Hunter"]

data/VERSION

@@ -1 +1 @@
-1.2.3
+2.0.0

data/lib/building-blocks.rb

@@ -1,5 +1 @@
-require "action_view"
-
-require "building_blocks/base"
-require "building_blocks/container"
-require "building_blocks/view_additions"
+require 'building_blocks'

data/lib/building_blocks.rb

@@ -0,0 +1,28 @@
+require "action_view"
+
+module BuildingBlocks
+  autoload :Base,          "building_blocks/base"
+  autoload :Container,     "building_blocks/container"
+  autoload :ViewAdditions, "building_blocks/view_additions"
+
+  mattr_accessor :template_folder
+  @@template_folder = "blocks"
+
+  mattr_accessor :use_partials
+  @@use_partials = true
+
+  mattr_accessor :surrounding_tag_surrounds_before_and_after_blocks
+  @@surrounding_tag_surrounds_before_and_after_blocks = true
+
+  # Shortcut for using the templating feature / rendering templates
+  def self.render_template(view, partial, options={}, &block)
+    BuildingBlocks::Base.new(view, options).render_template(partial, &block)
+  end
+
+  # Default way to setup BuildingBlocks
+  def self.setup
+    yield self
+  end
+end
+
+ActionView::Base.send :include, BuildingBlocks::ViewAdditions::ClassMethods

data/lib/building_blocks/base.rb

@@ -1,8 +1,4 @@
 module BuildingBlocks
-  TEMPLATE_FOLDER = "blocks"
-  USE_PARTIALS = true
-  USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS = false
-
   class Base
     # a pointer to the ActionView that called BuildingBlocks
     attr_accessor :view
@@ -23,7 +19,7 @@ module BuildingBlocks
     attr_accessor :global_options
 
     # The default folder to look in for global partials
-    attr_accessor :templates_folder
+    attr_accessor :template_folder
 
     # The variable to use when rendering the partial for the templating feature (by default, "blocks")
     attr_accessor :variable
@@ -31,8 +27,8 @@ module BuildingBlocks
     # Boolean variable for whether BuildingBlocks should attempt to render blocks as partials if a defined block cannot be found
     attr_accessor :use_partials
 
-    # Boolean variable for whether BuildingBlocks should attempt to render blocks before and after blocks as partials if no before or after blocks exist
-    attr_accessor :use_partials_for_before_and_after_hooks
+    # Boolean variable for whether BuildingBlocks should render before and after blocks inside or outside of a collections' elements' surrounding tags
+    attr_accessor :surrounding_tag_surrounds_before_and_after_blocks
 
     # Checks if a particular block has been defined within the current block scope.
     #   <%= blocks.defined? :some_block_name %>
@@ -57,7 +53,16 @@ module BuildingBlocks
     # [+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)
+      collection = options.delete(:collection)
+
+      if collection
+        collection.each do |object|
+          define(evaluated_proc(name, object, options), options, &block)
+        end
+      else
+        self.define_block_container(name, options, &block)
+      end
+
       nil
     end
 
@@ -84,7 +89,9 @@ module BuildingBlocks
     end
 
     # 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:
+    # any "after" blocks. Additionally, a collection may also be passed in, and BuildingBlocks will render
+    # an the block, along with corresponding before and after blocks for each element of the collection.
+    # 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] %>.
@@ -110,13 +117,63 @@ module BuildingBlocks
     #   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).
+    #   The last argument in the list can be a hash and can include the following special options:
+    #     [:collection]
+    #       The collection of elements to render blocks for
+    #     [:as]
+    #       The variable name to assign the current element in the collection being rendered over
+    #     [:surrounding_tag]
+    #       The content tag to render around a block, which might be particularly useful when rendering a collection of blocks,
+    #       such as for a list or table
+    #     [:surrounding_tag_html]
+    #       The attributes to be applied to the HTML content tag, such as styling or special properties. Please note, any Procs passed
+    #       in will automatically be evaluated (For example: :class => lambda { cycle("even", "odd") })
     # [+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)
+      options = args.extract_options!
+      collection = options.delete(:collection)
+
       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)
+
+      if collection
+        as = options.delete(:as)
+
+        collection.each do |object|
+          cloned_args = args.clone
+          cloned_args.unshift(object)
+          cloned_options = options.clone
+          cloned_options = cloned_options.merge(object.options) if object.is_a?(BuildingBlocks::Container)
+          cloned_args.push(cloned_options)
+
+          block_name = evaluated_proc(name_or_container, *cloned_args)
+          as_name = (as.presence || block_name).to_sym
+          cloned_options[as_name] = object
+
+          buffer << render(block_name, *cloned_args, &block)
+        end
+      else
+        surrounding_tag = options.delete(:surrounding_tag)
+        surrounding_tag_html = options.delete(:surrounding_tag_html)
+
+        args.push(options)
+
+        if surrounding_tag_surrounds_before_and_after_blocks
+          buffer << content_tag(surrounding_tag, surrounding_tag_html, *args) do
+            temp_buffer = ActiveSupport::SafeBuffer.new
+            temp_buffer << render_before_blocks(name_or_container, *args)
+            temp_buffer << render_block_with_around_blocks(name_or_container, *args, &block)
+            temp_buffer << render_after_blocks(name_or_container, *args)
+          end
+        else
+          buffer << render_before_blocks(name_or_container, *args)
+          buffer << content_tag(surrounding_tag, surrounding_tag_html, *args) do
+            render_block_with_around_blocks(name_or_container, *args, &block)
+          end
+          buffer << render_after_blocks(name_or_container, *args)
+        end
+      end
+
       buffer
     end
     alias use render
@@ -222,7 +279,7 @@ module BuildingBlocks
     #     Step 1 (:option1 => <%= options[option1] %>, :option2 => <%= options[option2] %>)<br />
     #   <% end %>
     #
-    #   <%= blocks.use :wizard %>
+    #   <%= blocks.render :wizard %>
     #
     #   <!-- Will render:
     #     Step 0 (:option1 => 3, :option2 => 2)<br />
@@ -261,7 +318,7 @@ module BuildingBlocks
     #     Step 4 (:option1 => <%= options[option1] %>, :option2 => <%= options[option2] %>)<br />
     #   <% end %>
     #
-    #   <%= blocks.use :wizard %>
+    #   <%= blocks.render :wizard %>
     #
     #   <!-- Will render:
     #     Step 2 (:option1 => 1, :option2 => 2)<br />
@@ -283,16 +340,66 @@ module BuildingBlocks
       nil
     end
     alias append after
+    alias for after
+
+    # Add a block to render around another block. This around block will be put into an array so that multiple
+    #  around blocks may be queued. They will render in the order in which they are declared when the
+    #  "blocks#render" method is called, with the last declared around block being rendered as the outer-most code, and
+    #  the first declared around block rendered as the inner-most code. Any options specified to the after block will override any options
+    #  specified in the block definition. The user of an around block must declare a block with at least one parameter and
+    #  should invoke the #call method on that argument.
+    #
+    #   <% blocks.define :my_block do %>
+    #     test
+    #   <% end %>
+    #
+    #   <% blocks.around :my_block do |content_block| %>
+    #     <h1>
+    #       <%= content_block.call %>
+    #     </h1>
+    #   <% end %>
+    #
+    #   <% blocks.around :my_block do |content_block| %>
+    #     <span style="color:red">
+    #       <%= content_block.call %>
+    #     </span>
+    #   <% end %>
+    #
+    #   <%= blocks.render :my_block %>
+    #
+    #   <!-- Will render:
+    #   <h1>
+    #     <span style="color:red">
+    #       test
+    #     </span>
+    #   </h1>
+    #
+    # Options:
+    # [+name+]
+    #   The name of the block to render this code around when that block is rendered
+    # [+options+]
+    #   Any options to specify to the around block when it renders. These will override any options
+    #   specified when the block was defined.
+    # [+block+]
+    #   The block of code to render after another block
+    def around(name, options={}, &block)
+      self.queue_block_container("around_#{name.to_s}", options, &block)
+      nil
+    end
 
     def evaluated_procs(*args)
-      options = args.extract_options!
-      options.inject({}) { |hash, (k, v)| hash[k] = (v.is_a?(Proc) ? v.call(*args) : v); hash} unless options.nil?
+      options = args.shift.presence || {}
+      if options.is_a?(Proc)
+        evaluated_proc(options, *args)
+      else
+        options.inject({}) { |hash, (k, v)| hash[k] = evaluated_proc(v, *args); hash}
+      end
     end
 
     def evaluated_proc(*args)
       return nil unless args.present?
-      v = args.pop
-      v.is_a?(Proc) ? v.call(*args) : v
+      v = args.shift
+      v.is_a?(Proc) ? v.call(*(args[0, v.arity])) : v
     end
 
     protected
@@ -320,7 +427,7 @@ module BuildingBlocks
     end
 
     def initialize(view, options={})
-      self.templates_folder = options[:templates_folder] ? options.delete(:templates_folder) : BuildingBlocks::TEMPLATE_FOLDER
+      self.template_folder = options[:template_folder] ? options.delete(:template_folder) : BuildingBlocks.template_folder
       self.variable = (options[:variable] ? options.delete(:variable) : :blocks).to_sym
       self.view = view
       self.global_options = options
@@ -328,9 +435,8 @@ module BuildingBlocks
       self.blocks = {}
       self.anonymous_block_number = 0
       self.block_groups = {}
-      self.use_partials = options[:use_partials].nil? ? BuildingBlocks::USE_PARTIALS : options.delete(:use_partials)
-      self.use_partials_for_before_and_after_hooks =
-        options[:use_partials_for_before_and_after_hooks] ? options.delete(:use_partials_for_before_and_after_hooks) : BuildingBlocks::USE_PARTIALS_FOR_BEFORE_AND_AFTER_HOOKS
+      self.use_partials = options[:use_partials].nil? ? BuildingBlocks.use_partials : options.delete(:use_partials)
+      self.surrounding_tag_surrounds_before_and_after_blocks = options[:surrounding_tag_surrounds_before_and_after_blocks].nil? ? BuildingBlocks.surrounding_tag_surrounds_before_and_after_blocks : options.delete(:surrounding_tag_surrounds_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)
@@ -339,6 +445,23 @@ module BuildingBlocks
       "block_#{anonymous_block_number}"
     end
 
+    def render_block_with_around_blocks(name_or_container, *args, &block)
+      name = name_or_container.is_a?(BuildingBlocks::Container) ? name_or_container.name.to_sym : name_or_container.to_sym
+      around_name = "around_#{name.to_s}".to_sym
+
+      around_blocks = blocks[around_name].present? ? blocks[around_name].clone : []
+
+      content_block = Proc.new do
+        block_container = around_blocks.shift
+        if block_container
+          view.capture(content_block, *(args[0, block_container.block.arity - 1]), &block_container.block)
+        else
+          render_block(name_or_container, *args, &block)
+        end
+      end
+      content_block.call
+    end
+
     # 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!
@@ -362,7 +485,7 @@ module BuildingBlocks
           begin
             buffer << view.render("#{name.to_s}", global_options.merge(block_options).merge(options))
           rescue ActionView::MissingTemplate
-            buffer << view.render("#{self.templates_folder}/#{name.to_s}", global_options.merge(block_options).merge(options))
+            buffer << view.render("#{self.template_folder}/#{name.to_s}", global_options.merge(block_options).merge(options))
           end
         rescue ActionView::MissingTemplate
           args.push(global_options.merge(options))
@@ -402,22 +525,11 @@ module BuildingBlocks
       before_name = "#{before_or_after}_#{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 use_partials && use_partials_for_before_and_after_hooks
-        begin
-          begin
-            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}/#{before_or_after}_#{name.to_s}", global_options.merge(block_options).merge(options))
-          end
-        rescue ActionView::MissingTemplate
-        end
-      end
+      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 if blocks[before_name].present?
 
       buffer
     end
@@ -451,5 +563,13 @@ module BuildingBlocks
       blocks[block_container.name] = block_container if blocks[block_container.name].nil? && block_given?
       block_container
     end
+
+    def content_tag(tag, tag_html, *args, &block)
+      if tag
+        view.content_tag(tag, block.call, evaluated_procs(tag_html, *args))
+      else
+        block.call
+      end
+    end
   end
 end

data/lib/building_blocks/view_additions.rb

@@ -4,10 +4,9 @@ module BuildingBlocks
       def blocks
         @blocks ||= BuildingBlocks::Base.new(self)
       end
+      alias bb blocks
+      alias buildingblocks blocks
+      alias building_blocks blocks
     end
   end
-end
-
-if defined?(ActionView::Base)
-  ActionView::Base.send :include, BuildingBlocks::ViewAdditions::ClassMethods
 end

data/spec/building-blocks/base_spec.rb

@@ -7,8 +7,7 @@ describe BuildingBlocks::Base do
   end
 
   it "should be able change the default global partials directory" do
-    BuildingBlocks.send(:remove_const, "TEMPLATE_FOLDER")
-    BuildingBlocks.const_set("TEMPLATE_FOLDER", "shared")
+    BuildingBlocks.template_folder = "shared"
     @builder = BuildingBlocks::Base.new(@view)
     @builder.expects(:render_before_blocks).at_least_once
     @builder.expects(:render_after_blocks).at_least_once
@@ -16,8 +15,6 @@ describe BuildingBlocks::Base do
     @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.render :some_block, :value1 => 1, :value2 => 2
-    BuildingBlocks.send(:remove_const, "TEMPLATE_FOLDER")
-    BuildingBlocks.const_set("TEMPLATE_FOLDER", "blocks")
   end
 
   describe "defined? method" do
@@ -185,6 +182,12 @@ describe BuildingBlocks::Base do
   end
 
   describe "before method" 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
       block = Proc.new { |options| }
       @builder.before :some_block, &block
@@ -232,6 +235,16 @@ describe BuildingBlocks::Base do
   end
 
   describe "after method" do
+    it "should be aliased with append and for" do
+      block = Proc.new { |options| }
+      @builder.append :some_block, &block
+      @builder.blocks[:after_some_block].should be_present
+
+      block = Proc.new { |options| }
+      @builder.for :some_block, &block
+      @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
       block = Proc.new { |options| }
       @builder.after :some_block, &block
@@ -279,9 +292,10 @@ describe BuildingBlocks::Base do
   end
 
   describe "render method" do
-    before :each do
-      @builder.expects(:render_before_blocks).at_least_once
-      @builder.expects(:render_after_blocks).at_least_once
+    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
@@ -404,6 +418,101 @@ describe BuildingBlocks::Base do
       buffer = @builder.render :some_block
       buffer.should eql "rendered content"
     end
+
+    describe "with a collection passed in" do
+      it "should render a block for each element of the collection with the name of the block used as the name of the element passed into the block" do
+        block = Proc.new {|item, options| "output#{options[:some_block]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3]).should eql "output1 output2 output3 "
+      end
+
+      it "should render a block for each element of the collection with the 'as' option specifying the name of the element passed into the block" do
+        block = Proc.new {|item, options| "output#{options[:my_block_name]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3], :as => "my_block_name").should eql "output1 output2 output3 "
+      end
+
+      it "should render a block for each element of the collection with a surrounding element if that option is specified" do
+        block = Proc.new {|item, options| "output#{options[:my_block_name]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3], :surrounding_tag => "div").should eql "<div>output </div><div>output </div><div>output </div>"
+      end
+
+      it "should render a block for each element of the collection with a surrounding element and specified html options if those options are specified" do
+        block = Proc.new {|item, options| "output#{options[:my_block_name]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3], :surrounding_tag => "div", :surrounding_tag_html => {:class => lambda { @view.cycle("even", "odd")}, :style => "color:red"}).should eql "<div class=\"even\" style=\"color:red\">output </div><div class=\"odd\" style=\"color:red\">output </div><div class=\"even\" style=\"color:red\">output </div>"
+      end
+
+      it "should be able to render before blocks before each element of a collection" do
+        before_block = Proc.new {|item, options| "before#{options[:some_block]} "}
+        @builder.before :some_block, &before_block
+
+        block = Proc.new {|item, options| "output#{options[:some_block]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3]).should eql "before1 output1 before2 output2 before3 output3 "
+      end
+
+      it "should be able to render after blocks before each element of a collection" do
+        after_block = Proc.new {|item, options| "after#{options[:some_block]} "}
+        @builder.after :some_block, &after_block
+
+        block = Proc.new {|item, options| "output#{options[:some_block]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3]).should eql "output1 after1 output2 after2 output3 after3 "
+      end
+
+      it "should be able to render before and after blocks before each element of a collection" do
+        before_block = Proc.new {|item, options| "before#{options[:some_block]} "}
+        @builder.before :some_block, &before_block
+
+        after_block = Proc.new {|item, options| "after#{options[:some_block]} "}
+        @builder.after :some_block, &after_block
+
+        block = Proc.new {|item, options| "output#{options[:some_block]} "}
+        @builder.define :some_block, &block
+        @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
+        before_block = Proc.new {|item, options| "before#{options[:some_block]} "}
+        @builder.before :some_block, &before_block
+
+        after_block = Proc.new {|item, options| "after#{options[:some_block]} "}
+        @builder.after :some_block, &after_block
+
+        block = Proc.new {|item, options| "output#{options[:some_block]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3], :surrounding_tag => "div").should eql "<div>before1 output1 after1 </div><div>before2 output2 after2 </div><div>before3 output3 after3 </div>"
+      end
+
+      it "should allow the global option to be set to render before and after blocks outside of surrounding elements" do
+        BuildingBlocks.surrounding_tag_surrounds_before_and_after_blocks = false
+        @builder = BuildingBlocks::Base.new(@view)
+        before_block = Proc.new {|item, options| "before#{options[:some_block]} "}
+        @builder.before :some_block, &before_block
+
+        after_block = Proc.new {|item, options| "after#{options[:some_block]} "}
+        @builder.after :some_block, &after_block
+
+        block = Proc.new {|item, options| "output#{options[:some_block]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3], :surrounding_tag => "div").should eql "before1 <div>output1 </div>after1 before2 <div>output2 </div>after2 before3 <div>output3 </div>after3 "
+      end
+
+      it "should allow the option to be set to render before and after blocks outside of surrounding elements to be specified when BuildingBlocks is initialized" do
+        @builder = BuildingBlocks::Base.new(@view, :surrounding_tag_surrounds_before_and_after_blocks => false)
+        before_block = Proc.new {|item, options| "before#{options[:some_block]} "}
+        @builder.before :some_block, &before_block
+
+        after_block = Proc.new {|item, options| "after#{options[:some_block]} "}
+        @builder.after :some_block, &after_block
+
+        block = Proc.new {|item, options| "output#{options[:some_block]} "}
+        @builder.define :some_block, &block
+        @builder.render(:some_block, :collection => [1,2,3], :surrounding_tag => "div").should eql "before1 <div>output1 </div>after1 before2 <div>output2 </div>after2 before3 <div>output3 </div>after3 "
+      end
+    end
   end
 
   describe "render method - before blocks" do
@@ -419,42 +528,6 @@ describe BuildingBlocks::Base do
       @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 and use_partials_for_before_and_after_hooks is set to true" do
-      @builder.use_partials_for_before_and_after_hooks = true
-      block = Proc.new {}
-      @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.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 and use_partials_for_before_and_after_hooks is set to true" do
-      @builder.use_partials_for_before_and_after_hooks = true
-      block = Proc.new {}
-      @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.render :my_before_block, :value1 => 1, :value2 => 2
-    end
-
-    it "should not attempt to render a before block as a partial if use_partials is set to false even if use_partials_for_before_and_after_hooks is set to true" do
-      @builder.use_partials = false
-      @builder.use_partials_for_before_and_after_hooks = true
-      block = Proc.new {}
-      @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.render :my_before_block, :value1 => 1, :value2 => 2
-    end
-
-    it "should not attempt to render a before block as a partial if use_partials_for_before_and_after_hooks is set to false" do
-      block = Proc.new {}
-      @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.render :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")
@@ -464,7 +537,29 @@ describe BuildingBlocks::Base do
       @builder.render :my_before_block, :param1 => "top level"
     end
   end
-  
+
+  describe "render method - around blocks" do
+    it "should be able to render code around another block" do
+      my_block = Proc.new { "test" }
+      around_block = Proc.new { |content_block| "<span>#{content_block.call}</span>" }
+      @builder.define(:my_block, &my_block)
+      @builder.around(:my_block, &around_block)
+      @builder.render(:my_block).should eql("&lt;span&gt;test&lt;/span&gt;")
+    end
+
+    it "should be able to nest multiple around blocks with the last defined around block on the outside" do
+      my_block = Proc.new { "test" }
+      around_block1 = Proc.new { |content_block| "<h1>#{content_block.call}</h1>" }
+      around_block2 = Proc.new { |content_block| "<span style='font-size: 100px'>#{content_block.call}</span>" }
+      around_block3 = Proc.new { |content_block| "<span style='color:red'>#{content_block.call}</span>" }
+      @builder.define(:my_block, &my_block)
+      @builder.around(:my_block, &around_block1)
+      @builder.around(:my_block, &around_block2)
+      @builder.around(:my_block, &around_block3)
+      @builder.render(:my_block).should eql("&lt;h1&gt;&amp;lt;span style='font-size: 100px'&amp;gt;&amp;amp;lt;span style='color:red'&amp;amp;gt;test&amp;amp;lt;/span&amp;amp;gt;&amp;lt;/span&amp;gt;&lt;/h1&gt;")
+    end
+  end
+
   describe "render method - after blocks" do
     before :each do
       @builder.expects(:render_block).at_least_once
@@ -478,42 +573,6 @@ describe BuildingBlocks::Base do
       @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 and use_partials_for_before_and_after_hooks is set to true" do
-      @builder.use_partials_for_before_and_after_hooks = true
-      block = Proc.new {}
-      @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.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 and use_partials_for_before_and_after_hooks is set to true" do
-      @builder.use_partials_for_before_and_after_hooks = true
-      block = Proc.new {}
-      @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.render :my_after_block, :value1 => 1, :value2 => 2
-    end
-
-    it "should not attempt to render a after block as a partial if use_partials is set to false even if use_partials_for_before_and_after_hooks is set to false" do
-      @builder.use_partials = false
-      @builder.use_partials_for_before_and_after_hooks = true
-      block = Proc.new {}
-      @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.render :my_after_block, :value1 => 1, :value2 => 2
-    end
-
-    it "should not attempt to render a after block as a partial if use_partials_for_before_and_after_hooks is set to false" do
-      block = Proc.new {}
-      @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.render :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")
@@ -562,32 +621,34 @@ describe BuildingBlocks::Base do
 
     it "should pass any additional arguments to evaluated procs" do
       proc1 = lambda { |param1, param2| "user_#{param1}_#{param2}"}
-      evaluated_procs = @builder.evaluated_procs(1, 2, :class => proc1)
+      evaluated_procs = @builder.evaluated_procs({:class => proc1}, 1, 2)
       evaluated_procs[:class].should eql "user_1_2"
     end
+  end
 
-    describe "evaluated_proc method" do
-      it "should evaluate a proc" do
-        proc = lambda {@view.cycle("even", "odd")}
-        @builder.evaluated_proc(proc).should eql "even"
-      end
+  describe "evaluated_proc method" do
+    it "should evaluate a proc" do
+      proc = lambda {@view.cycle("even", "odd")}
+      @builder.evaluated_proc(proc).should eql "even"
+      @builder.evaluated_proc(proc).should eql "odd"
+      @builder.evaluated_proc(proc).should eql "even"
+    end
 
-      it "should just return the value if it is not a proc" do
-        @builder.evaluated_proc("1234").should eql "1234"
-      end
+    it "should just return the value if it is not a proc" do
+      @builder.evaluated_proc("1234").should eql "1234"
+    end
 
-      it "should return nil if no arguments are specified" do
-        @builder.evaluated_proc.should be_nil
-      end
+    it "should return nil if no arguments are specified" do
+      @builder.evaluated_proc.should be_nil
+    end
 
-      it "should treat the last argument as the potential proc to evaluate" do
-        @builder.evaluated_proc(1, 2, 3).should eql 3
-      end
+    it "should treat the first argument as the potential proc to evaluate" do
+      @builder.evaluated_proc(1, 2, 3).should eql 1
+    end
 
-      it "should pass any additional arguments to the evaluated proc" do
-        proc1 = lambda { |param1, param2| "user_#{param1}_#{param2}"}
-        @builder.evaluated_proc(1, 2, proc1).should eql "user_1_2"
-      end
+    it "should pass any additional arguments to the evaluated proc" do
+      proc1 = lambda { |param1, param2| "user_#{param1}_#{param2}"}
+      @builder.evaluated_proc(proc1, 1, 2).should eql "user_1_2"
     end
   end
 end

data/spec/building-blocks/building_blocks_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe BuildingBlocks 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)
+    BuildingBlocks::Base.expects(:new).with(view, options).returns(base_mock)
+
+    BuildingBlocks.render_template(view, partial, options, &block)
+  end
+
+  it "should provide a setup method that can be called from an initializer" do
+    BuildingBlocks.template_folder.should eql("blocks")
+    BuildingBlocks.setup do |config|
+      config.should eql(BuildingBlocks)
+      config.template_folder = "shared"
+    end
+    BuildingBlocks.template_folder.should eql("shared")
+  end
+end

data/spec/building-blocks/view_additions_spec.rb

@@ -18,5 +18,16 @@ describe BuildingBlocks::ViewAdditions do
       @view.blocks.should eql "something"
       @view.blocks.should eql "something"
     end
+
+    it "should be aliased as bb, buildingblocks, and building_blocks" do
+      BuildingBlocks::Base.expects(:new).with {|view| view == @view}
+      @view.bb
+
+      BuildingBlocks::Base.expects(:new).with {|view| view == @view}
+      @view.buildingblocks
+
+      BuildingBlocks::Base.expects(:new).with {|view| view == @view}
+      @view.building_blocks
+    end
   end
 end

data/spec/spec_helper.rb

@@ -9,7 +9,10 @@ end
 
 RSpec.configure do |config|
   config.mock_with :mocha
-  # config.mock_with :flexmock
-  # config.mock_with :rr
-  # config.mock_with :rspec
+  
+  config.before :each do
+    BuildingBlocks.template_folder = "blocks"
+    BuildingBlocks.surrounding_tag_surrounds_before_and_after_blocks = true
+  end
 end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: building-blocks
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 15
   prerelease: 
   segments: 
-  - 1
   - 2
-  - 3
-  version: 1.2.3
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Andrew Hunter
@@ -15,11 +15,9 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-09 00:00:00 -05:00
-default_executable: 
+date: 2012-10-18 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: building-blocks
   version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -29,11 +27,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id001
   prerelease: false
+  name: building-blocks
   type: :runtime
-  requirement: *id001
 - !ruby/object:Gem::Dependency 
-  name: rails
   version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -45,11 +43,11 @@ dependencies:
         - 0
         - 0
         version: 3.0.0
+  requirement: *id002
   prerelease: false
+  name: rails
   type: :runtime
-  requirement: *id002
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -59,11 +57,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id003
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id003
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -73,11 +71,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id004
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id004
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -87,11 +85,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id005
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id005
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -101,11 +99,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id006
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id006
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -115,11 +113,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id007
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id007
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -129,11 +127,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id008
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id008
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -143,11 +141,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id009
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id009
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -157,11 +155,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id010
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id010
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -171,11 +169,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id011
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id011
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -185,11 +183,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id012
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id012
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id013 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -199,11 +197,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id013
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id013
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id014 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -213,11 +211,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id014
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id014
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id015 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -227,11 +225,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id015
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id015
 - !ruby/object:Gem::Dependency 
-  name: jeweler
   version_requirements: &id016 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -241,10 +239,25 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  requirement: *id016
   prerelease: false
+  name: jeweler
   type: :development
-  requirement: *id016
-description: ""
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id017 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id017
+  prerelease: false
+  name: jeweler
+  type: :development
+description: BuildingBlocks goes beyond blocks and partials
 email: hunterae@gmail.com
 executables: []
 
@@ -258,14 +271,15 @@ files:
 - Rakefile
 - VERSION
 - lib/building-blocks.rb
+- lib/building_blocks.rb
 - lib/building_blocks/base.rb
 - lib/building_blocks/container.rb
 - lib/building_blocks/view_additions.rb
 - rails/init.rb
 - spec/building-blocks/base_spec.rb
+- spec/building-blocks/building_blocks_spec.rb
 - spec/building-blocks/view_additions_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/hunterae/building-blocks
 licenses: []
 
@@ -295,9 +309,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: ""
+summary: BuildingBlocks is an intricate way of rendering blocks of code, while combining some of the best features of content blocks and partials, and adding several new features that go above and beyond what a simple content_for with yield or a render :partial is capable of doing.
 test_files: []