rabl 0.11.1 → 0.11.2

data/lib/rabl/template.rb

@@ -11,8 +11,8 @@ if defined?(Tilt)
       @engine = ::Rabl::Engine.new(data, options)
     end
 
-    def evaluate(scope, locals, &block)
-      @engine.apply(scope, locals, &block).render
+    def evaluate(context_scope, locals, &block)
+      @engine.apply(context_scope, locals, &block).render
     end
   end
 

data/lib/rabl/version.rb

@@ -1,3 +1,3 @@
 module Rabl
-  VERSION = "0.11.1"
+  VERSION = "0.11.2"
 end

data/test/builder_test.rb

@@ -1,13 +1,13 @@
 require File.expand_path('../teststrap',   __FILE__)
 
 context "Rabl::Builder" do
-  helper(:builder)    { |opt| Rabl::Builder.new(opt) }
-  helper(:build_hash) { |obj, opt| builder(opt).build(obj) }
+  helper(:builder)    { |*args| Rabl::Builder.new(*args) }
+  helper(:build_hash) { |*args| builder(*args).to_hash }
 
   setup do
     @users = [User.new, User.new]
     @user = User.new
-    builder({:view_path => '/path/to/views'})
+    builder(nil, nil, {:view_path => '/path/to/views'})
   end
 
   context "#initialize" do
@@ -15,46 +15,40 @@ context "Rabl::Builder" do
     asserts_topic.assigns :_view_path
   end
 
-  context "#build" do
-    setup { b = builder({}); b.build(User.new); b }
-    asserts_topic.assigns :_object
-    asserts_topic.assigns :_result
-  end
-
   context "#to_hash" do
     context "when given a simple object" do
-      setup { builder({ :attributes => { :name => {} } }) }
+      setup { builder(nil, { :attributes => [ { :name => :name } ] }) }
       asserts "that the object is set properly" do
-        topic.build(User.new, :root_name => "user")
+        topic.to_hash(User.new, nil, :root_name => "user")
       end.equivalent_to({ "user" => { :name => "rabl" } })
     end
 
     context "when given an object alias" do
-     setup { builder({ :attributes => { :name => { :as => :foo } } }) }
+     setup { builder(nil, { :attributes => [ { :name => :name, :options => { :as => :foo } } ] }) }
       asserts "that the object is set properly" do
-        topic.build(User.new, :root_name => "person")
+        topic.to_hash(User.new, nil, :root_name => "person")
       end.equivalent_to({ "person" => { :foo => "rabl" } })
     end
 
     context "when specified with no root" do
-      setup { builder({ :attributes => { :name => { :as => :name } } }) }
+      setup { builder(nil, { :attributes => [ { :name => :name, :options => { :as => :name } } ] }) }
       asserts "that the object is set properly" do
-        topic.build(User.new, :root => false)
+        topic.to_hash(User.new, nil, :root => false)
       end.equivalent_to({ :name => "rabl" })
     end
 
     context "when nil values are replaced with empty strings" do
       setup do
         Rabl.configuration.replace_nil_values_with_empty_strings = true
-        builder({ :attributes => { :name => {} }, :node => [{ :name => :extra, :options => {}, :block => lambda { |u| { :twitter => u.twitter } } }] })
+        builder(nil, { :attributes => [ { :name => :name } ], :node => [{ :name => :extra, :options => {}, :block => lambda { |u| { :twitter => u.twitter } } }] })
       end
 
       asserts "that an empty string is returned as the value" do
-        topic.build(User.new(:name => nil, :twitter => nil))
+        topic.to_hash(User.new(:name => nil, :twitter => nil))
       end.equivalent_to({ :name => '', :extra => { :twitter => '' } })
 
       asserts "that it handles existing non nil values correctly" do
-        topic.build(User.new(:name => 10, :twitter => 'twitter'))
+        topic.to_hash(User.new(:name => 10, :twitter => 'twitter'))
       end.equivalent_to({ :name => 10, :extra => { :twitter => 'twitter' } })
 
       teardown do
@@ -65,19 +59,19 @@ context "Rabl::Builder" do
     context "when empty string values are replaced with nil values" do
       setup do
         Rabl.configuration.replace_empty_string_values_with_nil_values = true
-        builder({ :attributes => { :name => {} }, :node => [{ :name => :extra, :options => {}, :block => lambda { |u| { :twitter => u.twitter } } }] })
+        builder(nil, { :attributes => [ { :name => :name } ], :node => [{ :name => :extra, :options => {}, :block => lambda { |u| { :twitter => u.twitter } } }] })
       end
 
       asserts "that nil is returned as the value" do
-        topic.build(User.new(:name => "", :twitter => ''))
+        topic.to_hash(User.new(:name => "", :twitter => ''))
       end.equivalent_to({ :name => nil, :extra => { :twitter => nil } })
 
       asserts "that it handles existing nil values correctly" do
-        topic.build(User.new(:name => nil, :twitter => nil))
+        topic.to_hash(User.new(:name => nil, :twitter => nil))
       end.equivalent_to({ :name => nil, :extra => { :twitter => nil } })
 
       asserts "that it handles existing non nil values correctly" do
-        topic.build(User.new(:name => 10, :twitter => 'twitter'))
+        topic.to_hash(User.new(:name => 10, :twitter => 'twitter'))
       end.equivalent_to({ :name => 10, :extra => { :twitter => 'twitter' } })
 
       teardown do
@@ -88,10 +82,10 @@ context "Rabl::Builder" do
     context "when nil values are excluded" do
       setup do
         Rabl.configuration.exclude_nil_values = true
-        builder({ :attributes => { :name => {} } })
+        builder(nil, { :attributes => [ { :name => :name } ] })
       end
       asserts "that an nil attribute is not returned" do
-        topic.build(User.new(:name => nil))
+        topic.to_hash(User.new(:name => nil))
       end.equivalent_to({ })
       teardown do
         Rabl.configuration.exclude_nil_values = false
@@ -101,7 +95,7 @@ context "Rabl::Builder" do
 
   context "#attribute" do
     asserts "that the node" do
-      build_hash @user, :attributes => { :name => {}, :city => { :as => :city } }
+      build_hash @user, :attributes => [ { :name => :name }, { :name => :city, :options => { :as => :city } } ]
     end.equivalent_to({:name => 'rabl', :city => 'irvine'})
 
     context "that with a non-existent attribute" do
@@ -109,7 +103,7 @@ context "Rabl::Builder" do
         setup { stub(Rabl.configuration).raise_on_missing_attribute { false } }
 
         asserts "the node" do
-          build_hash @user, :attributes => { :fake => :fake }
+          build_hash @user, :attributes => [ { :name => :fake } ]
         end.equals({})
       end
 
@@ -117,22 +111,22 @@ context "Rabl::Builder" do
         setup { stub(Rabl.configuration).raise_on_missing_attribute { true } }
 
         asserts "the node" do
-          build_hash @user, :attributes => { :fake => :fake }
+          build_hash @user, :attributes => [ { :name => :fake } ]
         end.raises(RuntimeError)
       end
     end
 
     context "that with a string key" do
-      setup { builder({ :attributes => { "name" => {} } }) }
+      setup { builder(nil, { :attributes => [ { :name => "name" } ] }) }
       asserts "the node name is converted to a symbol" do
-        topic.build(User.new, :name => "user")
+        topic.to_hash(User.new, :name => "user")
       end.equivalent_to({ :name => "rabl" })
     end
 
     context "that with the same node names as strings and symbols" do
-      setup { builder({ :attributes => { "name" => {}, :name => {} } }) }
+      setup { builder(nil, { :attributes => [ { :name => "name" }, { :name => :name } ] }) }
       asserts "the nodes aren't duplicated" do
-        topic.build(User.new, :name => "user")
+        topic.to_hash(User.new, :name => "user")
       end.equivalent_to({ :name => "rabl" })
     end
   end
@@ -163,119 +157,119 @@ context "Rabl::Builder" do
 
   context "#child" do
     asserts "that it generates if no data present" do
-      builder(:child => []).build(@user)
+      builder(nil, :child => []).to_hash(@user)
     end.equals({})
 
     asserts "that it generates with a hash" do
-      b = builder(:child => [ { :data => { @user => :user }, :options => { }, :block => lambda { |u| attribute :name } } ])
-      b.build(@user)
+      b = builder(nil, :child => [ { :data => { @user => :user }, :options => { }, :block => lambda { |u| attribute :name } } ])
+      b.to_hash(@user)
     end.equivalent_to({ :user => { :name => "rabl" } })
 
     asserts "that it generates with a hash alias" do
-      b = builder :child => [{ :data => { @user => :person }, :options => {}, :block => lambda { |u| attribute :name } }]
-      b.build(@user)
+      b = builder nil, :child => [{ :data => { @user => :person }, :options => {}, :block => lambda { |u| attribute :name } }]
+      b.to_hash(@user)
     end.equivalent_to({ :person => { :name => "rabl" } })
 
     asserts "that it generates with an object" do
-      b = builder :child => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name } }]
+      b = builder nil, :child => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name } }]
       e = Rabl::Engine.new('')
       mock(b).data_name(@user) { :user }
       mock(e).render.returns('xyz')
       mock(b).object_to_engine(@user, { :root => false }).returns(e).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equivalent_to({ :user => 'xyz'})
 
     asserts "that it generates with an collection and child_root" do
-      b = builder :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }], :child_root => true
+      b = builder nil, { :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }] }, { :child_root => true }
       e = Rabl::Engine.new('')
       mock(b).data_name(@users) { :users }
       mock(e).render.returns('xyz')
       mock(b).object_to_engine(@users, { :root => true, :child_root => true }).returns(e).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equivalent_to({ :users => 'xyz'})
 
     asserts "that it generates with an collection and no child root" do
-      b = builder :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }], :child_root => false
+      b = builder nil, { :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }] }, { :child_root => false }
       e = Rabl::Engine.new('')
       mock(b).data_name(@users) { :users }
       mock(e).render.returns('xyz')
       mock(b).object_to_engine(@users, { :root => false, :child_root => false }).returns(e).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equivalent_to({ :users => 'xyz'})
 
     asserts "that it generates with an collection and a specified object_root_name and root" do
       ops = { :object_root => "person", :root => :people }
-      b = builder :child => [{ :data => @users, :options => ops, :block => lambda { |u| attribute :name } }], :child_root => true
+      b = builder nil, { :child => [{ :data => @users, :options => ops, :block => lambda { |u| attribute :name } }] }, { :child_root => true }
       e = Rabl::Engine.new('')
       mock(e).render.returns('xyz')
       mock(b).object_to_engine(@users, { :root => "person", :object_root_name => "person", :child_root => true }).returns(e).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equivalent_to({ :people => 'xyz'})
 
     asserts "that it converts the child name to a symbol" do
-      b = builder(:child => [ { :data => { @user => "user" }, :options => { }, :block => lambda { |u| attribute :name } } ])
-      b.build(@user)
+      b = builder(nil, :child => [ { :data => { @user => "user" }, :options => { }, :block => lambda { |u| attribute :name } } ])
+      b.to_hash(@user)
     end.equivalent_to({ :user => { :name => "rabl" } })
 
     asserts "that it does't duplicate childs with the same name as a string and symbol" do
-      b = builder(:child => [
+      b = builder(nil, :child => [
         { :data => { @user => "user" }, :options => { }, :block => lambda { |u| attribute :name } },
         { :data => { @user => :user }, :options => { }, :block => lambda { |u| attribute :name } }
       ])
-      b.build(@user)
+      b.to_hash(@user)
     end.equivalent_to({ :user => { :name => "rabl" } })
   end
 
   context "#glue" do
     asserts "that it generates if no data present" do
-      builder(:glue => []).build(@user)
+      builder(nil, :glue => []).to_hash(@user)
     end.equals({})
 
     asserts "that it generates the glue attributes" do
-      b = builder :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name }}]
+      b = builder nil, :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name }}]
       e = Rabl::Engine.new('')
       mock(e).render.returns({:user => 'xyz'})
       mock(b).object_to_engine(@user, { :root => false }).returns(e).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equivalent_to({ :user => 'xyz' })
 
     asserts "that it appends the glue attributes to result" do
-      b = builder :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name => :user_name }}]
-      b.build(@user)
+      b = builder nil, :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name => :user_name }}]
+      b.to_hash(@user)
     end.equivalent_to({ :user_name => 'rabl' })
 
     asserts "that it does not generate new attributes if no glue attributes are present" do
-      b = builder :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name }}]
+      b = builder nil, :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name }}]
       e = Rabl::Engine.new('')
       mock(e).render.returns({})
       mock(b).object_to_engine(@user,{ :root => false }).returns(e).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equals({})
   end
 
   context "#extends" do
     asserts "that it does not generate if no data is present" do
-      b = builder :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
+      b = builder nil, :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
       e = Rabl::Engine.new('users/show')
       mock(b).partial_as_engine('users/show',{ :object => @user}).returns(e)
       mock(e).render.returns({}).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equals({})
 
     asserts "that it generates if data is present" do
-      b = builder :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
+      b = builder nil, :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
       e = Rabl::Engine.new('users/show')
       mock(b).partial_as_engine('users/show',{ :object => @user}).returns(e)
       mock(e).render.returns({:user => 'xyz'}).subject
-      b.build(@user)
+      b.to_hash(@user)
     end.equivalent_to({:user => 'xyz'})
 
     asserts "that it generates if local data is present but object is false" do
-      b = builder :extends => [{ :file => 'users/show', :options => { :object => @user }, :block => lambda { |u| attribute :name  }}]
+      b = builder nil, :extends => [{ :file => 'users/show', :options => { :object => @user }, :block => lambda { |u| attribute :name  }}]
       e = Rabl::Engine.new('users/show')
       mock(b).partial_as_engine('users/show',{ :object => @user}).returns(e)
       mock(e).render.returns({:user => 'xyz'}).subject
-      b.build(false)
+      b.to_hash(false)
     end.equivalent_to({:user => 'xyz'})
   end
 
@@ -291,26 +285,22 @@ context "Rabl::Builder" do
     end
 
     asserts "that it can use symbols on if condition and return false if method returns false" do
-      scope = Rabl::Builder.new
-      scope.instance_variable_set(:@_object, ArbObj.new)
+      scope = Rabl::Builder.new(ArbObj.new)
       scope.send(:resolve_condition, { :if => :cool? })
     end.equals(false)
 
     asserts "that it can use symbols on if condition and return true if method returns true" do
-      scope = Rabl::Builder.new
-      scope.instance_variable_set(:@_object, ArbObj.new)
+      scope = Rabl::Builder.new(ArbObj.new)
       scope.send :resolve_condition, { :if => :smooth? }
     end.equals(true)
 
     asserts "that it can use symbols as unless condition and return true if method returns false" do
-      scope = Rabl::Builder.new
-      scope.instance_variable_set(:@_object, ArbObj.new)
+      scope = Rabl::Builder.new(ArbObj.new)
       scope.send :resolve_condition, { :unless => :cool? }
     end.equals(true)
 
     asserts "that it can use symbols as unmless condition and return false if method returns true" do
-      scope = Rabl::Builder.new
-      scope.instance_variable_set(:@_object, ArbObj.new)
+      scope = Rabl::Builder.new(ArbObj.new)
       scope.send :resolve_condition, { :unless => :smooth? }
     end.equals(false)
   end

data/test/engine_test.rb

@@ -57,7 +57,7 @@ context "Rabl::Engine" do
         template.instance_eval('@engine')
       end
 
-      asserts_topic.assigns(:_cache) { ['foo', nil] }
+      asserts_topic.assigns(:_cache_key) { 'foo' }
     end
 
     context "with cache and options" do
@@ -69,7 +69,8 @@ context "Rabl::Engine" do
         template.instance_eval('@engine')
       end
 
-      asserts_topic.assigns(:_cache) { ['foo', { :expires_in => 'bar' }] }
+      asserts_topic.assigns(:_cache_key) { 'foo' }
+      asserts_topic.assigns(:_cache_options) { { :expires_in => 'bar' } }
     end
 
     context "without cache" do
@@ -79,7 +80,7 @@ context "Rabl::Engine" do
         template.instance_eval('@engine')
       end
 
-      denies(:instance_variable_defined?, :@_cache)
+      denies(:instance_variable_defined?, :@_cache_key)
     end
   end
 

data/test/models/user.rb

@@ -10,7 +10,7 @@ unless defined?(User)
     DEFAULT_HOBBIES  = ['Photography']
     DEFAULT_TWITTER  = 'rablgem'
 
-    def initialize(attributes={})
+    def initialize(attributes = {})
       %w(age city name first float hobbies twitter).each do |attr|
         self.send "#{attr}=", (attributes.has_key?(attr.to_sym) ? attributes[attr.to_sym] : self.class.const_get("DEFAULT_#{attr.upcase}"))
       end

data/test/multi_builder_test.rb

@@ -5,7 +5,7 @@ require File.expand_path('../models/ormless', __FILE__)
 
 context "Rabl::MultiBuilder" do
   helper(:multi_builder) { |objects, options| Rabl::MultiBuilder.new(objects, options) }
-  helper(:builder)       {                    Rabl::Builder.new({}) }
+  helper(:builder)       {                    Rabl::Builder.new(nil, {}) }
   helper(:engine)        { |object|           Rabl::Engine.new("").apply(nil, :object => object) }
 
   context "#initialize" do
@@ -32,7 +32,6 @@ context "Rabl::MultiBuilder" do
   context "#map_cache_key_to_engine" do
     asserts "maps the cache keys to the engines" do
       mb = multi_builder [], {}
-      b = builder
       e = engine User.new
       mock(e).cache_key.returns(['cache key'])
       mb.send(:map_cache_key_to_engine, e)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabl
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.11.2
 platform: ruby
 authors:
 - Nathan Esquenazi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-20 00:00:00.000000000 Z
+date: 2014-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -419,6 +419,7 @@ files:
 - lib/rabl/partials.rb
 - lib/rabl/railtie.rb
 - lib/rabl/renderer.rb
+- lib/rabl/sources.rb
 - lib/rabl/template.rb
 - lib/rabl/tracker.rb
 - lib/rabl/version.rb