rabl 0.5.4 → 0.5.5.a

data/CHANGELOG.md

@@ -1,6 +1,8 @@
 # CHANGELOG
 
-## 0.5.5 (Unreleased)
+## 0.5.5.a
+
+ * Change engine to only instantiate one builder when rendering a collection
 
 ## 0.5.4
 

data/README.md

@@ -34,7 +34,7 @@ gem 'yajl-ruby'
 
 and run `bundle install` to install the dependency.
 
-If you are using **Rails 2.X, Rails 3 or Padrino**, RABL works without configuration.
+If you are using **Rails 2.X, Rails 3.X or Padrino**, RABL works without configuration.
 
 With Sinatra, or any other tilt-based framework, simply register:
 
@@ -43,7 +43,7 @@ With Sinatra, or any other tilt-based framework, simply register:
 and RABL will be initialized and ready for use. For usage with Sinatra, check out
 the [Sinatra Usage](https://github.com/nesquena/rabl/wiki/Setup-for-Sinatra) guide.
 
-**Note:** Users have reported a few rendering issues with Rails 3.1 and Rails 3.2.
+**Note:** Users have reported a few rendering issues with Rails 3.2.
 The [template handler](https://github.com/nesquena/rabl/blob/master/lib/rabl/template.rb) probably needs
 a patch to properly support Rails 3.2. Hopefully I can get to it soon but patches are welcome.
 

data/lib/rabl/builder.rb

@@ -2,20 +2,28 @@ module Rabl
   class Builder
     include Rabl::Helpers
 
-    # Constructs a new ejs hash based on given object and options
+    # Constructs a new rabl hash based on given object and options
     # options = { :format => "json", :attributes, :root => true,
     #   :child_root => true, :node, :child, :glue, :extends }
-    def initialize(data, options={}, &block)
+    def initialize(options={}, &block)
       @options    = options
       @_scope     = options[:scope]
+    end
+
+    # Given an object and options, returns the hash representation
+    # build(@user, :format => "json", :attributes => { ... })
+    def build(data, options={})
       @_data      = data
       @_object    = data_object(data)
-      @_result    = {}
+      @_result = {}
+      compile_hash(options)
     end
 
+    protected
+
     # Returns a hash representation of the data object
-    # to_hash(:root => true)
-    def to_hash(options={})
+    # compile_hash(:root => true)
+    def compile_hash(options={})
       # Extends
       @options[:extends].each do |settings|
         extends(settings[:file], settings[:options], &settings[:block])
@@ -36,23 +44,22 @@ module Rabl
       @options[:glue].each do |settings|
         glue(settings[:data], &settings[:block])
       end if @options.has_key?(:glue)
-      # Return Hash
-      @_root_name ||= data_name(@_data)
-      (@options[:root] || options[:root]) && @_root_name ? { @_root_name => @_result } : @_result
+
+      # Wrap result in root
+      if @options[:root] || options[:root]
+        @_root_name ||= data_name(@_data)
+      else # no root
+        @_root_name = nil
+      end
+
+      # Return Results
+      @_root_name ? { @_root_name => @_result } : @_result
     end
 
     # Indicates an attribute or method should be included in the json output
     # attribute :foo, :as => "bar"
-    # attribute :foo => :bar
-    def attribute(*args)
-      if args.first.is_a?(Hash)
-        args.first.each_pair { |k,v| self.attribute(k, :as => v) }
-      else # array of attributes
-        options = args.extract_options!
-        args.each do |attribute|
-          @_result[options[:as] || attribute] = @_object.send(attribute) if @_object && @_object.respond_to?(attribute)
-        end
-      end
+    def attribute(name, options={})
+      @_result[options[:as] || name] = @_object.send(name) if @_object && @_object.respond_to?(name)
     end
     alias_method :attributes, :attribute
 

data/lib/rabl/engine.rb

@@ -33,14 +33,15 @@ module Rabl
     def to_hash(options={})
       options = @_options.merge(options)
       data = data_object(@_data)
+      builder = Rabl::Builder.new(options)
       if is_object?(data) || !data # object @user
-        Rabl::Builder.new(@_data, options).to_hash(options)
+        builder.build(@_data, options)
       elsif is_collection?(data) # collection @users
         if options[:root] # only calculate root name if needed
           object_name = data_name(@_data).to_s.singularize # @users => :users
-          data.map { |object| Rabl::Builder.new({ object => object_name }, options).to_hash(options) }
-        else
-          data.map { |object| Rabl::Builder.new(object, options).to_hash(options) }
+          data.map { |object| builder.build({ object => object_name }, options) }
+        else # skip root name
+          data.map { |object| builder.build(object, options) }
         end
       end
     end

data/lib/rabl/version.rb

@@ -1,3 +1,3 @@
 module Rabl
-  VERSION = "0.5.4"
+  VERSION = "0.5.5.a"
 end

data/test/builder_test.rb

@@ -3,19 +3,22 @@ require File.expand_path('../models/user', __FILE__)
 
 context "Rabl::Builder" do
 
-  helper(:builder)    { |obj,opt| Rabl::Builder.new(obj, opt) }
-  helper(:get_result) { |obj| obj.instance_variable_get("@_result") }
-  helper(:get_hash)   { |obj, root| obj.to_hash(:root => root) }
+  helper(:builder)    { |opt| Rabl::Builder.new(opt) }
+  helper(:build_hash) { |obj, opt| builder(opt).build(obj) }
 
   setup do
     @users = [User.new, User.new]
     @user = User.new
-    builder User.new, {}
+    builder({})
   end
 
   context "#initialize" do
-    asserts_topic.assigns :_object
     asserts_topic.assigns :options
+  end
+
+  context "#build" do
+    setup { b = builder({}); b.build(User.new); b }
+    asserts_topic.assigns :_object
     asserts_topic.assigns :_result
   end
 
@@ -23,30 +26,27 @@ context "Rabl::Builder" do
 
     context "when given a simple object" do
 
-      setup { builder User.new, {} }
+      setup { builder({ :attributes => { :name => :name } }) }
       asserts "that the object is set properly" do
-        topic.attribute :name
-        get_hash(topic, true)
+        topic.build(User.new, :root => true)
       end.equivalent_to({ "user" => { :name => "rabl" } })
 
     end
 
     context "when given an object alias" do
 
-     setup { builder({ User.new => "person" }, {}) }
+     setup { builder({ :attributes => { :name => :name } }) }
       asserts "that the object is set properly" do
-        topic.attribute :name
-        get_hash(topic, true)
+        topic.build({ User.new => "person" }, :root => true)
       end.equivalent_to({ "person" => { :name => "rabl" } })
 
     end
 
     context "when specified with no root" do
 
-      setup { builder User.new, {} }
+      setup { builder({ :attributes => { :name => :name } }) }
       asserts "that the object is set properly" do
-        topic.attribute :name
-        get_hash(topic, false)
+        topic.build(User.new, :root => false)
       end.equivalent_to({ :name => "rabl" })
 
     end
@@ -54,146 +54,104 @@ context "Rabl::Builder" do
   end
 
   context "#attribute" do
+    asserts "that the node" do
+      build_hash @user, :attributes => { :name => :name, :city => :city }
+    end.equivalent_to({:name => 'rabl', :city => 'irvine'})
 
-    context "when given an array" do
-
-      asserts "that the node" do
-        topic.attribute :name, :city
-        get_result(topic)
-      end.equivalent_to({:name => 'rabl', :city => 'irvine'})
-
-      asserts "that with a non-existent attribute the node" do
-        topic.attribute :fake
-        get_result(topic)[:fake]
-      end.nil
-
-    end
-
-    context "when given a Hash" do
-
-      asserts "that using :as, the node" do
-        topic.attribute :city, :as => 'foo'
-        get_result(topic)
-      end.equals({'foo'=>'irvine'})
-
-      asserts "with multiple attributes, the node" do
-        topic.attributes :city => :a, :age => :b
-        get_result(topic)
-      end.equivalent_to({:a => 'irvine', :b => 24, 'foo' => 'irvine'})
-
-    end
-
+    asserts "that with a non-existent attribute the node" do
+      build_hash @user, :attributes => { :fake => :fake }
+    end.equals({})
   end
 
-  context "#code" do
 
+  context "#node" do
     asserts "that it has node :foo" do
-      topic.code(:foo) { "bar" }
-      get_result(topic)
+      build_hash @user, :node => [{ :name => :foo, :options => {}, :block => lambda { |u| "bar" } }]
     end.equivalent_to({:foo => 'bar'})
 
     asserts "that using object it has node :boo" do
-      topic.code(:baz) { |u| u.city }
-      get_result(topic)
+      build_hash @user, :node => [
+        { :name => :foo, :options => {}, :block => lambda { |u| "bar" } },
+        { :name => :baz, :options => {}, :block => lambda { |u| u.city } }
+      ]
     end.equivalent_to({:foo => 'bar', :baz => 'irvine'})
   end
 
   context "#child" do
 
-    denies "that it generates if no data present" do
-      topic.child nil
-    end
+    asserts "that it generates if no data present" do
+      builder(:child => []).build(@user)
+    end.equals({})
 
     asserts "that it generates with a hash" do
-      b = builder @user, {}
-      mock(b).object_to_hash({ @user => :user },{ :root => false }).returns('xyz').subject
-
-      b.child(@user => :user) { attribute :name }
-      get_result(b)
-    end.equivalent_to({ :user => 'xyz'})
+      b = builder(:child => [ { :data => { @user => :user }, :options => { }, :block => lambda { |u| attribute :name } } ])
+      b.build(@user)
+    end.equivalent_to({ :user => { :name => "rabl" } })
 
     asserts "that it generates with a hash alias" do
-      b = builder @user, {}
-
-      b.child(@user => :person) { attribute :name }
-      get_result(b)
+      b = builder :child => [{ :data => { @user => :person }, :options => {}, :block => lambda { |u| attribute :name } }]
+      b.build(@user)
     end.equivalent_to({ :person => { :name => "rabl" } })
 
     asserts "that it generates with an object" do
-      b = builder @user, {}
+      b = builder :child => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name } }]
       mock(b).data_name(@user) { :user }
-      mock(b).object_to_hash(@user,{ :root => false }).returns('xyz').subject
-
-      b.child(@user) { attribute :name }
-      get_result(b)
+      mock(b).object_to_hash(@user, { :root => false }).returns('xyz').subject
+      b.build(@user)
     end.equivalent_to({ :user => 'xyz'})
 
     asserts "that it generates with an collection and child_root" do
-      b = builder @user, { :child_root => true }
+      b = builder :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }], :child_root => true
       mock(b).data_name(@users) { :users }
-      mock(b).object_to_hash(@users,{ :root => true, :child_root => true }).returns('xyz').subject
-
-      b.child(@users) { attribute :name }
-      get_result(b)
+      mock(b).object_to_hash(@users, { :root => true, :child_root => true }).returns('xyz').subject
+      b.build(@user)
     end.equivalent_to({ :users => 'xyz'})
 
     asserts "that it generates with an collection and no child root" do
-      b = builder @user, { :child_root => false }
+      b = builder :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }], :child_root => false
       mock(b).data_name(@users) { :users }
-      mock(b).object_to_hash(@users,{ :root => false, :child_root => false }).returns('xyz').subject
-
-      b.child(@users) { attribute :name }
-      get_result(b)
+      mock(b).object_to_hash(@users, { :root => false, :child_root => false }).returns('xyz').subject
+      b.build(@user)
     end.equivalent_to({ :users => 'xyz'})
   end
 
+
   context "#glue" do
 
-    denies "that it generates if no data present" do
-      topic.glue nil
-    end
+    asserts "that it generates if no data present" do
+      builder(:glue => []).build(@user)
+    end.equals({})
 
     asserts "that it generates the glue attributes" do
-      b = builder @user, {}
-      mock(b).object_to_hash(@user,{ :root => false }).returns({:user => 'xyz'}).subject
-
-      b.glue(@user) { attribute :name }
-      get_result(b)
+      b = builder :glue => [{ :data => @user, :block => lambda { |u| attribute :name }}]
+      mock(b).object_to_hash(@user, { :root => false }).returns({:user => 'xyz'}).subject
+      b.build(@user)
     end.equivalent_to({ :user => 'xyz' })
 
     asserts "that it appends the glue attributes to result" do
-      b = builder @user, {}
-
-      b.glue(@user) { attribute :name => :user_name }
-      get_result(b)
+      b = builder :glue => [{ :data => @user, :block => lambda { |u| attribute :name => :user_name }}]
+      b.build(@user)
     end.equivalent_to({ :user_name => 'rabl' })
 
     asserts "that it does not generate new attributes if no glue attributes are present" do
-      b = builder @user, {}
+      b = builder :glue => [{ :data => @user, :block => lambda { |u| attribute :name }}]
       mock(b).object_to_hash(@user,{ :root => false }).returns({}).subject
-
-      b.glue(@user) { attribute :name }
-      get_result(b)
+      b.build(@user)
     end.equals({})
   end
 
   context "#extend" do
 
     asserts "that it does not genereate if no data is present" do
-      b = builder @user, {}
+      b = builder :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
       mock(b).partial('users/show',{ :object => @user}).returns({}).subject
-
-      b.extends('users/show') { attribute :name }
-      get_result(b)
+      b.build(@user)
     end.equals({})
 
     asserts "that it generates if data is present" do
-      b = builder @user, {}
-      mock(b).partial('users/show',{ :object => @user}).returns({:user => 'xyz'}).subject
-
-      b.extends('users/show') { attribute :name }
-      get_result(b)
+      b = builder :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
+      mock(b).partial('users/show', { :object => @user }).returns({:user => 'xyz'}).subject
+      b.build(@user)
     end.equivalent_to({:user => 'xyz'})
   end
-
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: rabl
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.5.4
+  prerelease: 6
+  version: 0.5.5.a
 platform: ruby
 authors: 
 - Nathan Esquenazi
@@ -280,9 +280,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: rabl