bldr 0.1.2 → 0.2.0

data/HISTORY.md

@@ -1,3 +1,6 @@
-# 0.1.2 (2011-09-08)
+## 0.2.0 (2011-09-09)
+* Add new `attribute` inferred object syntax (@ihunter)
+
+## 0.1.2 (2011-09-08)
 
 * Return an empty collection when a nil value is passed to `collection` method

data/README.md

@@ -65,8 +65,42 @@ end
 
 ## Examples
 
+### Rendering a basic object
+
+```ruby
+object do
+  attribute :title, "my title"
+end
+```
+
+Output:
+
+```javascript
+{
+  "title": "my title"
+}
+```
+
 ### Rendering a simple list of attributes
 
+```ruby
+object :post do
+  attribute :title, "my title"
+end
+```
+
+Output:
+
+```javascript
+{
+  "post": {
+    "title": "my title"
+  }
+}
+```
+
+### Rendering a simple list of attributes from an object
+
 ```ruby
 object :post => post do
   attributes :title, :body
@@ -79,7 +113,7 @@ Output:
 {
   "post": {
     "title": "my title",
-      "body": "..."
+    "body": "..."
   }
 }
 ```

data/lib/bldr/node.rb

@@ -75,10 +75,13 @@ module Bldr
     #
     # @return [String] returns a json-encoded string of itself and all
     #   descendant nodes.
-    def object(hash = nil, &block)
-      if hash
-        key   = hash.keys.first
-        value = hash.values.first
+    def object(base = nil, &block)
+      if base.kind_of? Hash
+        key   = base.keys.first
+        value = base.values.first
+      else
+        key = base
+        value = nil
       end
 
       node  = Node.new(value, :parent => self, &block)
@@ -135,15 +138,7 @@ module Bldr
     #
     # @return [Nil]
     def attributes(*args, &block)
-      if block_given?
-        if args.size > 1
-          raise(ArgumentError, "You may only pass one argument to #attribute when using the block syntax.")
-        end
-
-        merge_result!(args.first, (block.arity == 1) ? block.call(current_object) : current_object.instance_eval(&block))
-        return nil
-      end
-
+      raise(ArgumentError, "You cannot use #attributes when inferred object is not present.") if current_object.nil?
       args.each do |arg|
         if arg.is_a?(Hash)
           merge_result!(arg.keys.first, current_object.send(arg.values.first))
@@ -153,7 +148,29 @@ module Bldr
       end
       nil
     end
-    alias :attribute :attributes
+
+    def attribute(*args,&block)
+      if block_given?
+        raise(ArgumentError, "You may only pass one argument to #attribute when using the block syntax.") if args.size > 1
+        raise(ArgumentError, "You cannot use a block of arity > 0 if inferred object is not present.") if block.arity > 0 and current_object.nil?
+        merge_result!(args.first, (block.arity == 1) ? block.call(current_object) : current_object.instance_eval(&block))
+      else
+        case args.size
+        when 1 # inferred object
+          raise(ArgumentError, "You cannot pass one argument to #attribute when inferred object is not present.") if current_object.nil?
+          if args[0].is_a?(Hash)
+            merge_result!(args[0].keys.first, current_object.send(args[0].values.first))
+          else
+            merge_result!(args[0], current_object.send(args[0]))
+          end
+        when 2 # static property
+          merge_result!(args[0], args[1])
+        else
+          raise(ArgumentError, "You cannot pass more than two arguments to #attribute.")
+        end
+      end
+      nil
+    end
 
     private
 

data/lib/bldr/version.rb

@@ -1,4 +1,4 @@
 
 module Bldr
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/spec/functional/tilt_template_spec.rb

@@ -36,18 +36,6 @@ describe "evaluating a tilt template" do
     let(:alex) { Person.new('alex', 25) }
     let(:ian) { Person.new('ian', 32) }
 
-    it "returns json for a blank root object " do
-      tpl  = Bldr::Template.new {
-        <<-RUBY
-          object do
-            attribute(:url) {"http://google.com"}
-          end
-        RUBY
-      }
-      result = tpl.render(Bldr::Node.new)
-      result.should == jsonify({'url' => 'http://google.com'})
-    end
-
     it "returns json for a root object" do
       tpl = Bldr::Template.new {
         <<-RUBY

data/spec/spec_helper.rb

@@ -24,4 +24,12 @@ RSpec.configure do |c|
   def jsonify(hash)
     Yajl::Encoder.encode(hash)
   end
+
+  # render the String template and compare to the jsonified hash
+  def it_renders_template_to_hash(template,hash)
+    tpl  = Bldr::Template.new {template}
+    result = tpl.render(Bldr::Node.new)
+    result.should == jsonify(hash)
+  end
+
 end

data/spec/unit/node_spec.rb

@@ -1,56 +1,277 @@
 require 'spec_helper'
 
-describe "Node#attributes" do
-  def wrap(&block)
-    alex = Person.new('alex').tap { |p| p.age = 25; p }
-    Bldr::Node.new do
-      object(:person => alex, &block)
+ERROR_MESSAGES = { :attribute_lambda_one_argument              => "You may only pass one argument to #attribute when using the block syntax.",
+                   :attribute_inferred_missing_one_argument    => "You cannot pass one argument to #attribute when inferred object is not present.",
+                   :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 inferred object is not present.",
+                   :attributes_inferred_missing                => "You cannot use #attributes when inferred object is not present." }
+
+describe "Node#object" do
+
+  context "a zero arg root object node" do
+
+    def wrap(&block)
+      Bldr::Node.new do
+        object(&block)
+      end
     end
-  end
 
-  it "adds attributes of the person to the result hash" do
-    node = wrap { attributes(:name, :age) }
-    node.render!.should == {:person => {:name => 'alex', :age => 25}}
-  end
+    describe "#attribute" do
 
-  it "supports dynamic block attributes with explicit object context" do
-    node = wrap do
-      attribute(:oldness) do |person|
-        "#{person.age} years"
+      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])
+      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])
+      end
+      it "renders 2 arguments statically" do
+        node = wrap { attribute(:name, "alex") }
+        node.render!.should == {:name => 'alex'}
       end
+      it "renders 1 argument and one lambda with zero arity" do
+        node = wrap {
+          attribute(:name) do
+            "alex"
+          end
+        }
+        node.render!.should == {:name => 'alex'}
+      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])
+      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])
+      end
+
     end
 
-    node.render!.should == {:person => {:oldness => "25 years"}}
   end
 
-  it "supports dynamic block attributes with implicit object context" do
-    node = wrap do
-      attribute(:oldness) do
-        "#{age} years"
+  context "a single arg root object node" do
+
+    def wrap(&block)
+      Bldr::Node.new do
+        object(:person, &block)
       end
     end
 
-    node.render!.should == {:person => {:oldness => "25 years"}}
+    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])
+      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])
+      end
+      it "renders 2 arguments statically" do
+        node = wrap { attribute(:name, "alex") }
+        node.render!.should == {:person => {:name => 'alex'}}
+      end
+      it "renders 1 argument and one lambda with zero arity" do
+        node = wrap {
+          attribute(:name) do
+            "alex"
+          end
+        }
+        node.render!.should == {:person => {:name => 'alex'}}
+      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])
+      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])
+      end
+
+    end
+
   end
 
-  it "raises an error when you use the block syntax with more than one attribute" do
-    expect {
-      node_wrap {
-        attributes(:one, :two) do |person|
-          "..."
+  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 "#attribute" do
+
+      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])
+      end
+      it "renders 1 argument to the inferred object" do
+        node = wrap { attribute(:name) }
+        node.render!.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.render!.should == {:person => {:fake => 'alex'}}
+      end
+      it "renders 2 arguments statically" do
+        node = wrap { attribute(:name, "ian") }
+        node.render!.should == {:person => {:name => 'ian'}}
+      end
+      it "renders 1 argument and one lambda with zero arity" do
+        node = wrap { attribute(:name){"ian"} }
+        node.render!.should == {:person => {:name => 'ian'}}
+      end
+      it "renders 1 argument and one lambda with arity 1" do
+        node = wrap { attribute(:name){|person| person.name} }
+        node.render!.should == {:person => {:name => 'alex'}}
+      end
+      it "renders nil attributes" do
+        node = node_wrap do
+          object :person => Person.new('alex') do
+            attribute :age
+          end
         end
-      }
-    }.to raise_error(ArgumentError, "You may only pass one argument to #attribute when using the block syntax.")
-  end
 
-  it "returns nil attributes in the result" do
-    node = node_wrap do
-      object :person => Person.new('alex') do
-        attributes :name, :age
+        node.render!.should == {:person => {:age => nil}}
       end
+
     end
 
-    node.render!.should == {:person => {:name => 'alex', :age => nil}}
+    describe "#attributes" do
+
+      it "errors if the current_object is nil" do
+        expect {
+          node = node_wrap do
+            object(:person => nil) do
+              attributes(:one, :two) do |person|
+                "..."
+              end
+            end
+          end
+        }.to raise_error(ArgumentError, ERROR_MESSAGES[:attributes_inferred_missing])
+      end
+      it "renders each argument against the inferred object" do
+        node = wrap { attributes(:name, :age) }
+        node.render!.should == {:person => {:name => 'alex', :age => 25}}
+      end
+      it "renders nil attributes" do
+        node = node_wrap do
+          object :person => Person.new('alex') do
+            attributes :name, :age
+          end
+        end
+
+        node.render!.should == {:person => {:name => 'alex', :age => nil}}
+      end
+
+    end
+
+  end
+
+  describe "embedded objects" do
+    it "evaluates the block and returns json" do
+      node = Bldr::Node.new
+      result = node.object(:dude => Person.new("alex")) do
+        attributes :name
+
+        object(:bro => Person.new("john")) do
+          attributes :name
+        end
+      end
+
+      result.should == jsonify({
+        :dude => {:name => 'alex', :bro => {:name => 'john'}}
+      })
+    end
   end
 
 end
@@ -123,23 +344,6 @@ describe "Node#render!" do
   end
 end
 
-describe "Node#object" do
-  it "evaluates the block and returns json" do
-    node = Bldr::Node.new
-    result = node.object(:dude => Person.new("alex")) do
-      attributes :name
-
-      object(:bro => Person.new("john")) do
-        attributes :name
-      end
-    end
-
-    result.should == jsonify({
-      :dude => {:name => 'alex', :bro => {:name => 'john'}}
-    })
-  end
-end
-
 describe "Node#to_json" do
   it "recursively returns the result json" do
     node = node_wrap do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bldr
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-09-09 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &2156406360 !ruby/object:Gem::Requirement
+  requirement: &2152503360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.0.3
   type: :runtime
   prerelease: false
-  version_requirements: *2156406360
+  version_requirements: *2152503360
 - !ruby/object:Gem::Dependency
   name: json_pure
-  requirement: &2152301980 !ruby/object:Gem::Requirement
+  requirement: &2152533900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152301980
+  version_requirements: *2152533900
 - !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: &2152301440 !ruby/object:Gem::Requirement
+  requirement: &2152533360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.2.6
   type: :development
   prerelease: false
-  version_requirements: *2152301440
+  version_requirements: *2152533360
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: &2152300940 !ruby/object:Gem::Requirement
+  requirement: &2152532860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.3.2
   type: :development
   prerelease: false
-  version_requirements: *2152300940
+  version_requirements: *2152532860
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &2152300560 !ruby/object:Gem::Requirement
+  requirement: &2152532480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152300560
+  version_requirements: *2152532480
 description: Provides a simple and intuitive templating DSL for serializing objects
   to JSON.
 email: