bldr 0.6.0 → 0.7.0

data/spec/integration/sinatra_spec.rb

@@ -55,6 +55,26 @@ describe "Using Bldr with a sinatra app" do
     get '/root_partial' do
       bldr :'fixtures/root_partial'
     end
+
+    get '/ivar' do
+      @person = Person.new('bert', 99)
+      bldr :'fixtures/ivar'
+    end
+
+    get '/nested_ivars' do
+      @person = Person.new('bert', 99)
+      bldr :'fixtures/nested_ivars'
+    end
+  end
+
+  it 'passes ivars through to the template' do
+    response = Rack::MockRequest.new(TestApp).get('/ivar')
+    decode(response.body).should == {'person' => {'name' => 'bert', 'age' => 99}}
+  end
+
+  it 'makes ivars available in nested objects' do
+    response = Rack::MockRequest.new(TestApp).get('/nested_ivars')
+    decode(response.body).should == {'person' => {'name' => 'bert', 'age' => 99}}
   end
 
   it "properly renders a template that only contains a template call" do
@@ -118,4 +138,4 @@ describe "access to the locals hash inside sinatra bldr templates" do
     response = Rack::MockRequest.new(Locals).get('/')
     MultiJson.decode(response.body)['locals']['key'].should == 'val'
   end
-end
+end

data/spec/models/song.rb

@@ -0,0 +1,6 @@
+class Song
+  attr_accessor :name
+  def initialize(name)
+    @name = name
+  end
+end

data/spec/spec_helper.rb

@@ -30,6 +30,7 @@ RSpec.configure do |c|
   def parse_json(str)
     Yajl::Parser.parse(str)
   end
+  alias :decode :parse_json
 
   # Jsonify a ruby object
   def jsonify(hash)

data/spec/unit/node_spec.rb

@@ -1,176 +1,157 @@
 require 'spec_helper'
 
 ERROR_MESSAGES = { :attribute_lambda_one_argument              => "You may only pass one argument to #attribute when using the block syntax.",
-                   :attribute_inferred_missing_one_argument    => "#attribute can't be used when there is no current_object.",
-                   :attribute_more_than_two_arg                => "You cannot pass more than two arguments to #attribute.",
-                   :attribute_inferred_missing_arity_too_large => "You cannot use a block of arity > 0 if current_object is not present.",
-                   :attributes_inferred_missing                => "No current_object to apply #attributes to." }
-
-describe "Node#attributes" do
-  let(:person) {
-    Person.new('john', 25)
-  }
-  let(:node) { Bldr::Node.new(person) }
-
-  it "returns stuff" do
-    node.attribute(:age).should == node
-  end
-end
+  :attribute_inferred_missing_one_argument    => "#attribute can't be used when there is no current_object.",
+  :attribute_more_than_two_arg                => "You cannot pass more than two arguments to #attribute.",
+  :attribute_inferred_missing_arity_too_large => "You cannot use a block of arity > 0 if current_object is not present.",
+  :attributes_inferred_missing                => "No current_object to apply #attributes to." }
+
+module Bldr
+  describe Node, "#attributes" do
+    let(:person) {
+      Person.new('john', 25)
+    }
+    let(:node) { Bldr::Node.new(person) }
 
-describe "Node#object" do
-  context "rendering an object exactly as it exists" do
-    it "renders the object exactly as it appears when passed an object with no block" do
-      obj = {'key' => 'val', 'nested' => {'key' => 'val'}}
-      node = node_wrap do
-        object obj
-      end
-      node.result.should == obj
+    it "returns stuff" do
+      node.attribute(:age).should == node
     end
   end
 
-  context "a zero arg root object node" do
+  describe Node, "#attribute" do
+    it "raises an exception when passed more than one argument and a block" do
+      expect {
+        Node.new {
+          attribute(:one, :two) do |person|
+            "..."
+          end
+        }
+      }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_lambda_one_argument])
+    end
 
-    def wrap(&block)
-      Bldr::Node.new do
-        object(&block)
-      end
+    it "raises an exception when passed more than two args" do
+      expect {
+        Node.new {
+          attribute(:one, :two, :three)
+        }
+      }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_more_than_two_arg])
     end
 
-    describe "#attribute" do
-      it "errors on a single argument" do
-        expect {
-          node_wrap {
-            attribute(:one, :two) do |person|
-              "..."
-            end
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_lambda_one_argument])
+    it "errors on 1 argument since there is no inferred object" do
+      expect {
+        Node.new {
+          attribute(:one)
+        }
+      }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_inferred_missing_one_argument])
+    end
+
+    describe "wrapped in an object block" do
+      it "renders 2 arguments statically" do
+        node = Node.new do
+          object :person do
+            attribute(:name, "alex")
+          end
+        end
+        node.result.should == {:person => {:name => 'alex'}}
       end
 
-      it "errors on 3 arguments" do
-        expect {
-          node_wrap {
-            attribute(:one, :two, :three)
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_more_than_two_arg])
+      it "renders 1 argument and one lambda with zero arity" do
+        node = Node.new do
+          object :person do
+            attribute(:name) { "alex" }
+          end
+        end
+        node.result.should == {:person => {:name => 'alex'}}
       end
 
-      it "errors on 2 arguments and a lambda" do
-        expect {
-          node_wrap {
-            attribute(:one, :two) do |person|
-              "..."
-            end
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_lambda_one_argument])
+      it "renders 1 argument to the inferred object" do
+        node = Node.new do
+          object :person => Person.new('alex', 25) do
+            attribute(:name)
+          end
+        end
+        node.result.should == {:person => {:name => 'alex'}}
       end
 
-      it "errors on 1 argument since there is no inferred object" do
-        expect {
-          node_wrap {
-            attribute(:one)
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_inferred_missing_one_argument])
+      it "renders 1 argument hash to the inferred object as the different key" do
+        node = Node.new do
+          object :person => Person.new('alex', 25) do
+            attribute(:fake => :name)
+          end
+        end
+        node.result.should == {:person => {:fake => 'alex'}}
       end
 
       it "renders 2 arguments statically" do
-        node = wrap { attribute(:name, "alex") }
-        node.result.should == {:name => 'alex'}
+        node = Node.new do
+          object :person => Person.new('alex', 25) do
+            attribute(:name, 'ian')
+          end
+        end
+        node.result.should == {:person => {:name => 'ian'}}
       end
 
       it "renders 1 argument and one lambda with zero arity" do
-        node = wrap {
-          attribute(:name) do
-            "alex"
+        node = Node.new do
+          object :person => Person.new('alex', 25) do
+            attribute(:name) { 'ian' }
           end
-        }
-        node.result.should == {:name => 'alex'}
-      end
+        end
 
-      it "errors on 1 argument and one lambda with arity 1" do
-        expect {
-          node_wrap {
-            attribute(:name) do |name|
-              name
-            end
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_inferred_missing_arity_too_large])
+        node.result.should == {:person => {:name => 'ian'}}
       end
 
-      it "should render null attributes to null, not 'null'" do
-        node = wrap { attribute(:name, nil) }
-        node.result.should == {:name => nil}
-      end
-    end
+      it "renders 1 argument and one lambda with arity 1" do
+        node = Node.new do
+          object :person => Person.new('alex', 25) do
+            attribute(:name) { |person| person.name }
+          end
+        end
 
-    describe "#attributes" do
-      it "errors since current_object is nil" do
-        expect {
-          node_wrap {
-            attributes(:name)
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attributes_inferred_missing])
+        node.result.should == {:person => {:name => 'alex'}}
       end
-    end
-  end
 
-  context "a single arg root object node" do
+      it "renders nil attributes" do
+        node = Node.new do
+          object :person => Person.new('alex') do
+            attribute :age
+          end
+        end
 
-    def wrap(&block)
-      Bldr::Node.new do
-        object(:person, &block)
+        node.result.should == {:person => {:age => nil}}
       end
     end
 
-    describe "#attribute" do
-
-      it "errors on a single argument" do
-        expect {
-          node_wrap {
-            attribute(:one, :two) do |person|
-              "..."
-            end
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_lambda_one_argument])
-      end
-      it "errors on 3 arguments" do
-        expect {
-          node_wrap {
-            attribute(:one, :two, :three)
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_more_than_two_arg])
-      end
-      it "errors on 2 arguments and a lambda" do
-        expect {
-          node_wrap {
-            attribute(:one, :two) do |person|
-              "..."
-            end
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_lambda_one_argument])
+    describe 'when in static key-value form (with two arguments)' do
+      it "renders 2 arguments statically as key, value" do
+        node = Node.new { attribute(:name, "alex") }
+        node.result.should == {:name => 'alex'}
       end
-      it "errors on 1 argument since there is no inferred object" do
-        expect {
-          node_wrap {
-            attribute(:one)
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_inferred_missing_one_argument])
+
+      it "renders null attributes to null, not 'null'" do
+        node = Node.new { attribute(:name, nil) }
+        node.result.should == {:name => nil}
       end
-      it "renders 2 arguments statically" do
-        node = wrap { attribute(:name, "alex") }
-        node.result.should == {:person => {:name => 'alex'}}
+    end
+
+    describe 'when in dynamic block form (with 1 argument and a block)' do
+      it 'sets the attribute default context to bldr node' do
+        node = Node.new { attribute(:key) { self.class } }
+        node.result[:key].should == ::Bldr::Node
       end
-      it "renders 1 argument and one lambda with zero arity" do
-        node = wrap {
+
+      it "uses the argument as the key and the block result as the value" do
+        node = Node.new {
           attribute(:name) do
             "alex"
           end
         }
-        node.result.should == {:person => {:name => 'alex'}}
+        node.result.should == {:name => 'alex'}
       end
+
       it "errors on 1 argument and one lambda with arity 1" do
         expect {
-          node_wrap {
+          Node.new {
             attribute(:name) do |name|
               name
             end
@@ -179,520 +160,550 @@ describe "Node#object" do
       end
     end
 
-    describe "#attributes" do
+  end
 
-      it "errors since current_object is nil" do
-        expect {
-          node_wrap {
-            attributes(:name)
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attributes_inferred_missing])
+  describe Node, "#object" do
+    it 'is passes block the block variable to the block' do
+      denver = Person.new('John Denver')
+      node = Node.new do
+        object :person => denver do |jd|
+          attribute(:name) { jd.name }
+        end
       end
 
+      node.result.should == {:person => {:name => 'John Denver'}}
     end
 
-  end
+    context "rendering an object exactly as it exists" do
+      it "renders the object exactly as it appears when passed an object with no block" do
+        obj = {'key' => 'val', 'nested' => {'key' => 'val'}}
+        node = node_wrap do
+          object obj
+        end
+        node.result.should == obj
+      end
+    end
+
+    context "a zero arg root object node" do
 
-  context "a hash-arg root object node" do
+      def wrap(&block)
+        Bldr::Node.new do
+          object(&block)
+        end
+      end
 
-    def wrap(&block)
-      alex = Person.new('alex').tap { |p| p.age = 25; p }
-      Bldr::Node.new do
-        object(:person => alex, &block)
+      describe "#attributes" do
+        it "errors since current_object is nil" do
+          expect {
+            node_wrap {
+              attributes(:name)
+            }
+          }.to raise_error(ArgumentError, ERROR_MESSAGES[:attributes_inferred_missing])
+        end
       end
     end
 
-    describe "#attribute" do
-      it "works at the root level" do
-        node_wrap {
-          attribute(:foo) { "bar" }
-        }.result.should == {:foo => 'bar'}
+    context "a single arg root object node" do
+
+      def wrap(&block)
+        Bldr::Node.new do
+          object(:person, &block)
+        end
       end
 
-      it "errors on 3 arguments" do
-        expect {
-          node_wrap {
-            attribute(:one, :two, :three)
-          }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_more_than_two_arg])
+      describe "#attributes" do
+
+        it "errors since current_object is nil" do
+          expect {
+            node_wrap {
+              attributes(:name)
+            }
+          }.to raise_error(ArgumentError, ERROR_MESSAGES[:attributes_inferred_missing])
+        end
       end
-      it "errors on 2 arguments and a lambda" do
-        expect {
-          node_wrap {
-            attribute(:one, :two) do |person|
-              "..."
+    end
+
+    context "a hash-arg root object node" do
+      def wrap(&block)
+        alex = Person.new('alex').tap { |p| p.age = 25; p }
+        Bldr::Node.new do
+          object(:person => alex, &block)
+        end
+      end
+
+
+      describe "#attributes" do
+        describe "when an object key is passed a null value" do
+          subject {
+            node = node_wrap do
+              object(:person => nil) do
+                attributes(:one, :two) do |person|
+                  "..."
+                end
+              end
             end
           }
-        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attribute_lambda_one_argument])
-      end
-      it "renders 1 argument to the inferred object" do
-        node = wrap { attribute(:name) }
-        node.result.should == {:person => {:name => 'alex'}}
-      end
-      it "renders 1 argument hash to the inferred object as the different key" do
-        node = wrap { attribute(:fake => :name) }
-        node.result.should == {:person => {:fake => 'alex'}}
-      end
-      it "renders 2 arguments statically" do
-        node = wrap { attribute(:name, "ian") }
-        node.result.should == {:person => {:name => 'ian'}}
-      end
-      it "renders 1 argument and one lambda with zero arity" do
-        node = wrap { attribute(:name){"ian"} }
-        node.result.should == {:person => {:name => 'ian'}}
-      end
-      it "renders 1 argument and one lambda with arity 1" do
-        node = wrap { attribute(:name){|person| person.name} }
-        node.result.should == {:person => {:name => 'alex'}}
-      end
-      it "renders nil attributes" do
-        node = node_wrap do
-          object :person => Person.new('alex') do
-            attribute :age
-          end
-        end
 
-        node.result.should == {:person => {:age => nil}}
-      end
+          it "does not raise an inferred object error" do
+            expect {
+              subject
+            }.not_to raise_error(ArgumentError, ERROR_MESSAGES[:attributes_inferred_missing])
+          end
 
-    end
+          its(:result) { should == {} }
+        end
 
-    describe "#attributes" do
-      describe "when an object key is passed a null value" do
-        subject {
+        it "renders each argument against the inferred object" do
+          node = wrap { attributes(:name, :age) }
+          node.result.should == {:person => {:name => 'alex', :age => 25}}
+        end
+        it "renders nil attributes" do
           node = node_wrap do
-            object(:person => nil) do
-              attributes(:one, :two) do |person|
-                "..."
-              end
+            object :person => Person.new('alex') do
+              attributes :name, :age
             end
           end
-        }
 
-        it "does not raise an inferred object error" do
-          expect {
-            subject
-          }.not_to raise_error(ArgumentError, ERROR_MESSAGES[:attributes_inferred_missing])
+          node.result.should == {:person => {:name => 'alex', :age => nil}}
         end
 
-        its(:result) { should == {} }
       end
 
-      it "renders each argument against the inferred object" do
-        node = wrap { attributes(:name, :age) }
-        node.result.should == {:person => {:name => 'alex', :age => 25}}
-      end
-      it "renders nil attributes" do
+    end
+
+    describe "embedded objects" do
+      it "evaluates the block and returns json" do
         node = node_wrap do
-          object :person => Person.new('alex') do
-            attributes :name, :age
+          object(:dude => Person.new("alex")) do
+            attributes :name
+
+            object(:bro => Person.new("john")) do
+              attributes :name
+            end
           end
         end
 
-        node.result.should == {:person => {:name => 'alex', :age => nil}}
+        node.result.should == {:dude => {:name => 'alex', :bro => {:name => 'john'}}}
       end
-
     end
 
   end
 
-  describe "embedded objects" do
-    it "evaluates the block and returns json" do
+  describe "Node#result" do
+    it "returns an empty hash when not passed an object" do
+      Bldr::Node.new.result.should == {}
+    end
+
+    it "a document with a single node with no nesting" do
       node = node_wrap do
-        object(:dude => Person.new("alex")) do
+        object :person => Person.new('alex') do
           attributes :name
-
-          object(:bro => Person.new("john")) do
-            attributes :name
-          end
         end
       end
 
-      node.result.should == {:dude => {:name => 'alex', :bro => {:name => 'john'}}}
+      node.result.should == {:person => {:name => 'alex'}}
     end
-  end
 
-end
+    it "works for multiple top-level objects" do
+      alex, john = Person.new("alex"), Person.new("john")
 
-describe "Node#result" do
-  it "returns an empty hash when not passed an object" do
-    Bldr::Node.new.result.should == {}
-  end
+      node = node_wrap do
+        object(:alex => alex) do
+          attributes :name
+        end
 
-  it "a document with a single node with no nesting" do
-    node = node_wrap do
-      object :person => Person.new('alex') do
-        attributes :name
+        object(:john => john) do
+          attributes :name
+        end
       end
-    end
 
-    node.result.should == {:person => {:name => 'alex'}}
-  end
+      node.result.should == {:alex => {:name => 'alex'}, :john => {:name => 'john'}}
+    end
 
-  it "works for multiple top-level objects" do
-    alex, john = Person.new("alex"), Person.new("john")
+    it "recursively renders nested objects" do
+      node = node_wrap do
+        object :alex => Person.new("alex") do
+          attributes :name
 
-    node = node_wrap do
-      object(:alex => alex) do
-        attributes :name
+          object :friend => Person.new("john") do
+            attributes :name
+          end
+        end
       end
 
-      object(:john => john) do
-        attributes :name
-      end
+      node.result.should == {
+        :alex => {
+          :name => 'alex', :friend => {:name => 'john'}
+        }
+      }
     end
 
-    node.result.should == {:alex => {:name => 'alex'}, :john => {:name => 'john'}}
-  end
-
-  it "recursively renders nested objects" do
-    node = node_wrap do
-      object :alex => Person.new("alex") do
-        attributes :name
+    describe "#attributes syntax" do
+      it "allows a hash to be sent where the keys are the result keys" do
+        alex = Person.new("alex").tap do |p|
+          p.age = 25
+          p
+        end
 
-        object :friend => Person.new("john") do
-          attributes :name
+        node = node_wrap do
+          object(:person => alex) do
+            attributes({:surname => :name}, :age)
+          end
         end
+
+        node.result.should == {:person => {:surname => 'alex', :age => 25}}
       end
     end
-
-    node.result.should == {
-      :alex => {
-        :name => 'alex',
-        :friend => {:name => 'john'}
-      }
-    }
   end
 
-  describe "#attributes syntax" do
-    it "allows a hash to be sent where the keys are the result keys" do
-      alex = Person.new("alex").tap do |p|
-        p.age = 25
-        p
-      end
-
+  describe Node, "#to_json" do
+    it "recursively returns the result json" do
       node = node_wrap do
-        object(:person => alex) do
-          attributes({:surname => :name}, :age)
+        object :person => Person.new("alex") do
+          attributes :name
+
+          object :friend => Person.new("pete", 30) do
+            attributes :name, :age
+          end
         end
       end
 
-      node.result.should == {:person => {:surname => 'alex', :age => 25}}
+      node.result.should == {
+        :person => {
+          :name => 'alex',
+          :friend => {:name => 'pete', :age => 30}
+        }
+      }
     end
-  end
-end
 
-describe "Node#to_json" do
-  it "recursively returns the result json" do
-    node = node_wrap do
-      object :person => Person.new("alex") do
-        attributes :name
-
-        object :friend => Person.new("pete", 30) do
+    it "returns null values for nil attributes" do
+      node = node_wrap do
+        object :person => Person.new('alex') do
           attributes :name, :age
         end
       end
-    end
 
-    node.result.should == {
-      :person => {
-        :name => 'alex',
-        :friend => {:name => 'pete', :age => 30}
-      }
-    }
+      node.result[:person].should have_key(:age)
+      node.result[:person][:age].should be_nil
+    end
   end
 
-  it "returns null values for nil attributes" do
-    node = node_wrap do
-      object :person => Person.new('alex') do
-        attributes :name, :age
+  describe Node, "#collection" do
+    context "when passed an object with no block" do
+      it "renders the object exactly as it exists" do
+        coll = [{'key' => 'val'}]
+        node = node_wrap do
+          collection coll
+        end
+
+        node.result.should == coll
       end
-    end
 
-    node.result[:person].should have_key(:age)
-    node.result[:person][:age].should be_nil
-  end
-end
+      it "renders complex collection objects correctly" do
+        hobbies = [{'name' => "Gym"}, {'name' => "Tan"}, {'name' => "Laundry"}]
 
-describe "Node#collection" do
-  context "when passed an object with no block" do
-    it "renders the object exactly as it exists" do
-      coll = [{'key' => 'val'}]
-      node = node_wrap do
-        collection coll
-      end
+        node = node_wrap do
+          object 'person' => Person.new("Alex") do
+            attribute :name
+            collection 'hobbies' => hobbies
+          end
+        end
 
-      node.result.should == coll
+        node.result.should == {'person' => {:name => "Alex", 'hobbies' => hobbies}}
+      end
     end
 
-    it "renders complex collection objects correctly" do
-      hobbies = [{'name' => "Gym"}, {'name' => "Tan"}, {'name' => "Laundry"}]
+    it "iterates through the collection and passes each item as a block variable" do
+      denver = Person.new('John Denver')
+      songs = [Song.new('Rocky Mountain High'), Song.new('Take Me Home, Country Roads')]
 
-      node = node_wrap do
-        object 'person' => Person.new("Alex") do
+      node = Node.new do
+        object :artist => denver do
           attribute :name
-          collection 'hobbies' => hobbies
+
+          collection :songs => songs do |song|
+            attribute(:name) { song.name }
+          end
         end
       end
 
-      node.result.should == {'person' => {:name => "Alex", 'hobbies' => hobbies}}
+      node.result.should == {
+        :artist => {:name => 'John Denver',
+          :songs => [{:name => 'Rocky Mountain High'},
+            {:name => 'Take Me Home, Country Roads'}
+          ]
+        }
+      }
     end
-  end
-
-  it "iterates through the collection and renders them as nodes" do
-    node = node_wrap do
-      object :person => Person.new('alex', 26) do
-        attributes :name, :age
 
-        collection :friends => [Person.new('john', 24), Person.new('jeff', 25)] do
+    it "iterates through the collection and renders them as nodes" do
+      node = node_wrap do
+        object :person => Person.new('alex', 26) do
           attributes :name, :age
+
+          collection :friends => [Person.new('john', 24), Person.new('jeff', 25)] do
+            attributes :name, :age
+          end
         end
       end
-    end
 
-    node.result.should == {
-      :person => {
-        :name => 'alex', :age => 26,
-        :friends => [{:name => 'john', :age => 24}, {:name => 'jeff', :age => 25}]
+      node.result.should == {
+        :person => {
+          :name => 'alex', :age => 26,
+          :friends => [
+            {:name => 'john', :age => 24},
+            {:name => 'jeff', :age => 25}]
+        }
       }
-    }
-  end
-
-  # @todo fix this
-  it "renders properly when a collection is the named root node" do
-    nodes = node_wrap do
-      collection :people => [Person.new('bert'), Person.new('ernie')] do
-        attributes :name
-      end
     end
 
-    nodes.result.should == {:people => [{:name => 'bert'}, {:name => 'ernie'}]}
-  end
-
-  it "renders properly when a collection is the root node" do
-    nodes = node_wrap do
-      collection [Person.new('bert'), Person.new('ernie')] do
-        attributes :name
+    # @todo fix this
+    it "renders properly when a collection is the named root node" do
+      nodes = node_wrap do
+        collection :people => [Person.new('bert'), Person.new('ernie')] do
+          attributes :name
+        end
       end
-    end
-
-    nodes.result.should == [{:name => 'bert'}, {:name => 'ernie'}]
-  end
 
-  it "gracefully handles empty collections" do
-    nodes = node_wrap do
-      collection :people => [] do
-        attributes :name
-      end
+      nodes.result.should == {:people => [{:name => 'bert'}, {:name => 'ernie'}]}
     end
 
-    nodes.result.should == {:people => []}
-  end
-
-  it "gracefully handles nil collections" do
-    nodes = node_wrap do
-      collection :people => nil do
-        attributes :name
+    it "renders properly when a collection is the root node" do
+      nodes = node_wrap do
+        collection [Person.new('bert'), Person.new('ernie')] do
+          attributes :name
+        end
       end
-    end
 
-    nodes.result.should == {:people => []}
-  end
+      nodes.result.should == [{:name => 'bert'}, {:name => 'ernie'}]
+    end
 
-  it "renders nested collections properly" do
-    post = Post.new("my post")
-    post.comments << Comment.new('my comment')
+    it "gracefully handles empty collections" do
+      nodes = node_wrap do
+        collection :people => [] do
+          attributes :name
+        end
+      end
 
-    nodes = node_wrap do
-      collection :posts => [post] do
-        attributes :title
-        attribute(:comment_count) { |post| post.comments.count }
+      nodes.result.should == {:people => []}
+    end
 
-        collection :comments => current_object.comments do
-          attributes :body
+    it "gracefully handles nil collections" do
+      nodes = node_wrap do
+        collection :people => nil do
+          attributes :name
         end
       end
-    end
 
-    nodes.result.should == {
-      :posts => [
-        {:title => 'my post', :comment_count => 1, :comments => [{:body => 'my comment'}]}
-      ]
-    }
-  end
+      nodes.result.should == {:people => []}
+    end
 
-  it "renders objects nested in collections properly" do
-    post = Post.new 'foo'
-    post.author = Author.new('John Doe')
-    posts = [post]
+    it "renders nested collections properly" do
+      post = Post.new("my post")
+      post.comments << Comment.new('my comment')
 
-    nodes = node_wrap do
-      collection :data => posts do
-        attributes :title
+      nodes = node_wrap do
+        collection :posts => [post] do |post|
+          attributes :title
+          attribute(:comment_count) { |post| post.comments.count }
 
-        object :author => current_object.author do
-          attributes :name
+          collection :comments => post.comments do
+            attributes :body
+          end
         end
       end
-    end
 
-    nodes.result.should == {
-      :data => [
-        {:title => 'foo', :author => {:name => 'John Doe'}}
-      ]
-    }
-  end
+      nodes.result.should == {
+        :posts => [
+          {:title => 'my post', :comment_count => 1, :comments => [{:body => 'my comment'}]}
+        ]
+      }
+    end
 
-  it "renders nested collections with dynamic property values correctly" do
-    post1 = Post.new("post 1")
-    post2 = Post.new("post 2")
-    post1.comments << Comment.new('post 1 comment')
-    post2.comments << Comment.new('post 2 first comment')
-    post2.comments << Comment.new('post 2 second comment')
+    it "renders objects nested in collections properly" do
+      post = Post.new 'foo'
+      post.author = Author.new('John Doe')
+      posts = [post]
 
-    nodes = node_wrap do
-      collection :posts => [post1, post2] do
-        attributes :title
-        attribute(:comment_count) { |post| post.comments.count }
+      nodes = node_wrap do
+        collection :data => posts do |post|
+          attributes :title
 
-        collection :comments => current_object.comments do
-          attributes :body
+          object :author => post.author do
+            attributes :name
+          end
         end
       end
+
+      nodes.result.should == {
+        :data => [
+          {:title => 'foo', :author => {:name => 'John Doe'}}
+        ]
+      }
     end
 
-    nodes.result.should == {
-      :posts => [
-        {
-          :title => 'post 1',
-          :comment_count => 1,
-          :comments => [{:body => 'post 1 comment'}]
-        },
-        {
-          :title => 'post 2',
-          :comment_count => 2,
-          :comments => [{:body => 'post 2 first comment'}, {:body => 'post 2 second comment'}]
-        }
-      ]
-    }
-  end
+    it "renders nested collections with dynamic property values correctly" do
+      post1 = Post.new("post 1")
+      post2 = Post.new("post 2")
+      post1.comments << Comment.new('post 1 comment')
+      post2.comments << Comment.new('post 2 first comment')
+      post2.comments << Comment.new('post 2 second comment')
 
-  it "allows root level attributes using local variables" do
-    node = node_wrap do
-      name = "john doe"
-      age  = 25
+      nodes = node_wrap do
+        collection :posts => [post1, post2] do |post|
+          attributes :title
+          attribute(:comment_count) { |post| post.comments.count }
 
-      object do
-        attribute(:name) { name }
-        attribute(:age) { age }
+          collection :comments => post.comments do
+            attributes :body
+          end
+        end
       end
+
+      nodes.result.should == {
+        :posts => [
+          {
+            :title => 'post 1',
+            :comment_count => 1,
+            :comments => [{:body => 'post 1 comment'}]
+          },
+          {
+            :title => 'post 2',
+            :comment_count => 2,
+            :comments => [{:body => 'post 2 first comment'}, {:body => 'post 2 second comment'}]
+          }
+        ]
+      }
     end
 
-    node.result.should == {:name => 'john doe', :age => 25}
-  end
+    it "allows root level attributes using local variables" do
+      node = node_wrap do
+        name = "john doe"
+        age  = 25
 
-end
+        object do
+          attribute(:name) { name }
+          attribute(:age) { age }
+        end
+      end
 
-describe "Node#template" do
-  it "includes the partial as a top level" do
-    nodes = node_wrap do
-      template "spec/fixtures/partial.json.bldr"
+      node.result.should == {:name => 'john doe', :age => 25}
     end
 
-    nodes.result.should == {:foo => "bar"}
   end
-  
-  it "includes the partial on a top level object" do
-    nodes = node_wrap do
-      object :container do
-        attribute(:blah) { "baz" }
-        template "spec/fixtures/partial.json.bldr"
-      end
-    end
 
-    nodes.result.should == {:container => {:blah => "baz", :foo => "bar"}}
-  end
-  
-  it "includes the partial on a top level collection" do
-    nodes = node_wrap do
-      collection :people => [Person.new('bert'), Person.new('ernie')] do
-        attribute(:blah) { "baz" }
+  describe Node, "#template" do
+    it "includes the partial as a top level" do
+      nodes = node_wrap do
         template "spec/fixtures/partial.json.bldr"
       end
+
+      nodes.result.should == {:foo => "bar"}
     end
 
-    nodes.result.should == {:people => [{:blah => "baz", :foo => 'bar'}, {:blah => "baz", :foo => 'bar'}]}
-  end
-  
-  it "includes the partial on a sub object" do
-    nodes = node_wrap do
-      object :container do
-        object :sub do
+    it "includes the partial on a top level object" do
+      nodes = node_wrap do
+        object :container do
           attribute(:blah) { "baz" }
           template "spec/fixtures/partial.json.bldr"
         end
       end
+
+      nodes.result.should == {:container => {:blah => "baz", :foo => "bar"}}
     end
 
-    nodes.result.should == {:container => {:sub => {:blah => "baz", :foo => "bar"}}}
-  end
-  
-  it "includes the partial on a sub collection" do
-    nodes = node_wrap do
-      object :container do
+    it "includes the partial on a top level collection" do
+      nodes = node_wrap do
         collection :people => [Person.new('bert'), Person.new('ernie')] do
           attribute(:blah) { "baz" }
           template "spec/fixtures/partial.json.bldr"
         end
       end
+
+      nodes.result.should == {:people => [{:blah => "baz", :foo => 'bar'}, {:blah => "baz", :foo => 'bar'}]}
     end
 
-    nodes.result.should == {:container => {:people => [{:blah => "baz", :foo => 'bar'}, {:blah => "baz", :foo => 'bar'}]}}
-  end
-  
-  it "includes both the partials" do
-    nodes = node_wrap do
-      object :container do
-        template "spec/fixtures/partial.json.bldr"
-        object :sub do
-          attribute(:blah) { "baz" }
-          template "spec/fixtures/partial.json.bldr"
+    it "includes the partial on a sub object" do
+      nodes = node_wrap do
+        object :container do
+          object :sub do
+            attribute(:blah) { "baz" }
+            template "spec/fixtures/partial.json.bldr"
+          end
         end
       end
+
+      nodes.result.should == {:container => {:sub => {:blah => "baz", :foo => "bar"}}}
     end
 
-    nodes.result.should == {:container => {:foo => "bar", :sub => {:blah => "baz", :foo => "bar"}}}
-  end
-  
-  it "includes the partial with the locals" do
-    Obj = Struct.new(:foo)
-    nodes = node_wrap do
-      template "spec/fixtures/partial_with_locals.json.bldr", :locals => {:obj => Obj.new('test')}
+    it "includes the partial on a sub collection" do
+      nodes = node_wrap do
+        object :container do
+          collection :people => [Person.new('bert'), Person.new('ernie')] do
+            attribute(:blah) { "baz" }
+            template "spec/fixtures/partial.json.bldr"
+          end
+        end
+      end
+
+      nodes.result.should == {:container => {:people => [{:blah => "baz", :foo => 'bar'}, {:blah => "baz", :foo => 'bar'}]}}
     end
 
-    nodes.result.should == {:name => {:foo => 'test'}}
-  end
-  
-  it "raises an error when the partial isn't found" do
-    expect {
+    it "includes both the partials" do
+      nodes = node_wrap do
+        object :container do
+          template "spec/fixtures/partial.json.bldr"
+          object :sub do
+            attribute(:blah) { "baz" }
+            template "spec/fixtures/partial.json.bldr"
+          end
+        end
+      end
+
+      nodes.result.should == {:container => {:foo => "bar", :sub => {:blah => "baz", :foo => "bar"}}}
+    end
+
+    it "includes the partial with the locals" do
+      Obj = Struct.new(:foo)
       nodes = node_wrap do
-        template "unknown/path"
+        template "spec/fixtures/partial_with_locals.json.bldr", :locals => {:obj => Obj.new('test')}
       end
-    }.to raise_error(Errno::ENOENT)
-  end
-  
-  it "doesn't raise an error when with a base path option specified and the right file" do
-    nodes = node_wrap nil, :views => 'spec/fixtures/some' do
-      object :foo do
-        template "include"
+
+      nodes.result.should == {:name => {:foo => 'test'}}
+    end
+
+    it "raises an error when the partial isn't found" do
+      expect {
+        nodes = node_wrap do
+          template "unknown/path"
+        end
+      }.to raise_error(Errno::ENOENT)
+    end
+
+    it "doesn't raise an error when with a base path option specified and the right file" do
+      nodes = node_wrap nil, :views => 'spec/fixtures/some' do
+        object :foo do
+          template "include"
+        end
       end
     end
   end
-end
 
-describe "Node#locals" do
-  let(:node) { Bldr::Node.new({:foo => 'bar'}, :locals => {:key => 'val'})}
-  subject { node.locals }
+  describe Node, "#locals" do
+    let(:node) { Bldr::Node.new({:foo => 'bar'}, :locals => {:key => 'val'})}
+    subject { node.locals }
 
-  it { should == {:key => 'val'} }
+    it { should == {:key => 'val'} }
+  end
+
+  describe Node, '#current_object' do
+    it 'returns the node value' do
+      Node.new('hey').current_object.should == 'hey'
+    end
+
+    it 'displays a deprecation warning' do
+      Object.any_instance.should_receive(:warn).with("[DEPRECATION] `current_object` is deprecated. Please use object or collection block varibles instead.")
+      Node.new.current_object
+    end
+  end
 end