rabl 0.13.1 → 0.14.4

data/test.watchr

@@ -1,47 +0,0 @@
-ENV["WATCHR"] = "1"
-system 'clear'
-
-def run(cmd)
-  puts(cmd)
-  system cmd
-end
-
-def run_test_file(file)
-  system('clear')
-  run(%Q(ruby -I"lib:test" -rubygems #{file}))
-end
-
-def run_all_tests
-  system('clear')
-  run('rake test')
-end
-
-def related_test_files(path)
-  Dir['test/**/*.rb'].select { |file| file =~ /#{File.basename(path).split(".").first}_test.rb/ }
-end
-
-watch('test/teststrap\.rb') { run_all_tests }
-watch('test/(.*).*_test\.rb') { |m| run_test_file(m[0]) }
-watch('lib/.*/.*\.rb') { |m| related_test_files(m[0]).map {|tf| run_test_file(tf) } }
-
-# Ctrl-\
-Signal.trap 'QUIT' do
-  puts " --- Running all tests ---\n\n"
-  run_all_tests
-end
-
-@interrupted = false
-
-# Ctrl-C
-Signal.trap 'INT' do
-  if @interrupted then
-    @wants_to_quit = true
-    abort("\n")
-  else
-    puts "Interrupt a second time to quit"
-    @interrupted = true
-    Kernel.sleep 1.5
-    # raise Interrupt, nil # let the run loop catch it
-    run_all_tests
-  end
-end

data/test/bson_engine_test.rb

@@ -1,310 +0,0 @@
-require File.expand_path('../teststrap', __FILE__)
-require 'rabl/template'
-
-context "Rabl::Engine" do
-  helper(:rabl) { |t| RablTemplate.new("code", :format => 'bson') { t } }
-
-  context "with bson defaults" do
-    setup do
-      Rabl.configure do |config|
-        # Comment this line out because include_bson_root is default.
-        #config.include_bson_root = true
-      end
-    end
-
-    context "#object" do
-      asserts "that it sets data source" do
-        template = rabl %q{
-          object @user
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new
-        template.render(scope)
-      end.matches "\x10\x00\x00\x00\x03user\x00\x05\x00\x00\x00\x00\x00"
-
-      asserts "that it can set root node" do
-        template = rabl %q{
-          object @user => :person
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new
-        template.render(scope).split("").sort
-      end.equals "\x12\x00\x00\x00\x03person\x00\x05\x00\x00\x00\x00\x00".split("").sort
-    end
-
-    context "#collection" do
-      asserts "that it sets object to be casted as a simple array" do
-        template = rabl %{
-          collection @users
-        }
-        scope = Object.new
-        scope.instance_variable_set :@users, [User.new, User.new]
-        template.render(scope).split("").sort
-      end.equals "7\x00\x00\x00\x04users\x00+\x00\x00\x00\x030\x00\x10\x00\x00\x00\x03user\x00\x05\x00\x00\x00\x00\x00\x031\x00\x10\x00\x00\x00\x03user\x00\x05\x00\x00\x00\x00\x00\x00\x00".split("").sort
-
-      asserts "that it sets root node for objects" do
-        template = rabl %{
-          collection @users => :people
-        }
-        scope = Object.new
-        scope.instance_variable_set :@users, [User.new, User.new]
-        template.render(scope).split("").sort
-      end.equals "<\x00\x00\x00\x04people\x00/\x00\x00\x00\x030\x00\x12\x00\x00\x00\x03person\x00\x05\x00\x00\x00\x00\x00\x031\x00\x12\x00\x00\x00\x03person\x00\x05\x00\x00\x00\x00\x00\x00\x00".split("").sort
-    end
-
-    context "#attribute" do
-      asserts "that it adds an attribute or method to be included in output" do
-        template = rabl %{
-          object @user
-          attribute :name
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'irvine')
-        template.render(scope).split("").sort
-      end.equals "!\x00\x00\x00\x03user\x00\x16\x00\x00\x00\x02name\x00\a\x00\x00\x00irvine\x00\x00\x00".split("").sort
-
-      asserts "that it can add attribute under a different key name through :as" do
-        template = rabl %{
-          object @user
-          attribute :name, :as => 'city'
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'irvine')
-        template.render(scope).split("").sort
-      end.equals "!\x00\x00\x00\x03user\x00\x16\x00\x00\x00\x02city\x00\a\x00\x00\x00irvine\x00\x00\x00".split("").sort
-
-      asserts "that it can add attribute under a different key name through hash" do
-        template = rabl %{
-          object @user
-          attribute :name => :city
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'irvine')
-        template.render(scope).split("").sort
-      end.equals "!\x00\x00\x00\x03user\x00\x16\x00\x00\x00\x02city\x00\a\x00\x00\x00irvine\x00\x00\x00".split("").sort
-    end
-
-    context "#code" do
-      asserts "that it can create an arbitraty code node" do
-        template = rabl %{
-          code(:foo) { 'bar' }
-        }
-        template.render(Object.new).split("").sort
-      end.equals "\x12\x00\x00\x00\x02foo\x00\x04\x00\x00\x00bar\x00\x00".split("").sort
-
-      asserts "that it can be passed conditionals" do
-        template = rabl %{
-          code(:foo, :if => lambda { |i| false }) { 'bar' }
-        }
-        template.render(Object.new).split("").sort
-      end.equals "\x05\x00\x00\x00\x00".split("").sort
-    end
-
-    context "#child" do
-      asserts "that it can create a child node" do
-        template = rabl %{
-          object @user
-          attribute :name
-          child(@user) { attribute :city }
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'leo', :city => 'LA')
-        template.render(scope).split("").sort
-      end.equals "6\x00\x00\x00\x03user\x00+\x00\x00\x00\x02name\x00\x04\x00\x00\x00leo\x00\x03user\x00\x12\x00\x00\x00\x02city\x00\x03\x00\x00\x00LA\x00\x00\x00\x00".split("").sort
-
-      asserts "that it can create a child node with different key" do
-        template = rabl %{
-          object @user
-          attribute :name
-          child(@user => :person) { attribute :city }
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'leo', :city => 'LA')
-        template.render(scope).split("").sort
-      end.equals "8\x00\x00\x00\x03user\x00-\x00\x00\x00\x02name\x00\x04\x00\x00\x00leo\x00\x03person\x00\x12\x00\x00\x00\x02city\x00\x03\x00\x00\x00LA\x00\x00\x00\x00".split("").sort
-    end
-
-    context "#glue" do
-      asserts "that it glues data from a child node" do
-        template = rabl %{
-          object @user
-          attribute :name
-          glue(@user) { attribute :city }
-          glue(@user) { attribute :age  }
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'leo', :city => 'LA', :age => 12)
-        template.render(scope).split("").sort
-      end.equals "4\x00\x00\x00\x03user\x00)\x00\x00\x00\x02name\x00\x04\x00\x00\x00leo\x00\x02city\x00\x03\x00\x00\x00LA\x00\x10age\x00\f\x00\x00\x00\x00\x00".split("").sort
-    end
-
-    teardown do
-      Rabl.reset_configuration!
-    end
-  end
-
-  context "with bson_engine" do
-    setup do
-      class CustomEncodeEngine
-        def self.serialize string
-          42
-        end
-      end
-
-      Rabl.configure do |config|
-        config.bson_engine = CustomEncodeEngine
-      end
-    end
-
-    asserts 'that it returns process by custom to_json' do
-      template = rabl %q{
-        object @user
-      }
-      scope = Object.new
-      scope.instance_variable_set :@user, User.new
-      template.render(scope)
-    end.equals "42"
-
-    teardown do
-      Rabl.reset_configuration!
-    end
-  end
-
-  context "without bson root" do
-    setup do
-      Rabl.configure do |config|
-        config.include_bson_root = false
-      end
-    end
-
-    context "#object" do
-      asserts "that it sets data source" do
-        template = rabl %q{
-          object @user
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new
-        template.render(scope)
-      end.matches "\x05\x00\x00\x00\x00"
-
-      asserts "that it can set root node" do
-        template = rabl %q{
-          object @user => :person
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new
-        template.render(scope)
-      end.equals "\x05\x00\x00\x00\x00"
-    end
-
-    context "#collection" do
-      asserts "that it sets object to be casted as a simple array" do
-        template = rabl %{
-          collection @users
-        }
-        scope = Object.new
-        scope.instance_variable_set :@users, [User.new, User.new]
-        template.render(scope).split("").sort
-      end.equals "!\x00\x00\x00\x04users\x00\x15\x00\x00\x00\x030\x00\x05\x00\x00\x00\x00\x031\x00\x05\x00\x00\x00\x00\x00\x00".split("").sort
-
-      asserts "that it sets root node for objects" do
-        template = rabl %{
-          collection @users => :person
-        }
-        scope = Object.new
-        scope.instance_variable_set :@users, [User.new, User.new]
-        template.render(scope).split("").sort
-      end.equals "\"\x00\x00\x00\x04person\x00\x15\x00\x00\x00\x030\x00\x05\x00\x00\x00\x00\x031\x00\x05\x00\x00\x00\x00\x00\x00".split("").sort
-    end
-
-    context "#attribute" do
-      asserts "that it adds an attribute or method to be included in output" do
-        template = rabl %{
-          object @user
-          attribute :name
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'irvine')
-        template.render(scope).split("").sort
-      end.equals "\x16\x00\x00\x00\x02name\x00\a\x00\x00\x00irvine\x00\x00".split("").sort
-
-      asserts "that it can add attribute under a different key name through :as" do
-        template = rabl %{
-          object @user
-          attribute :name, :as => 'city'
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'irvine')
-        template.render(scope).split("").sort
-      end.equals "\x16\x00\x00\x00\x02city\x00\a\x00\x00\x00irvine\x00\x00".split("").sort
-
-      asserts "that it can add attribute under a different key name through hash" do
-        template = rabl %{
-          object @user
-          attribute :name => :city
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'irvine')
-        template.render(scope).split("").sort
-      end.equals "\x16\x00\x00\x00\x02city\x00\a\x00\x00\x00irvine\x00\x00".split("").sort
-    end
-
-    context "#code" do
-      asserts "that it can create an arbitraty code node" do
-        template = rabl %{
-          code(:foo) { 'bar' }
-        }
-        template.render(Object.new).split("").sort
-      end.equals "\x12\x00\x00\x00\x02foo\x00\x04\x00\x00\x00bar\x00\x00".split("").sort
-
-      asserts "that it can be passed conditionals" do
-        template = rabl %{
-          code(:foo, :if => lambda { |i| false }) { 'bar' }
-        }
-        template.render(Object.new).split("").sort
-      end.equals "\x05\x00\x00\x00\x00".split("").sort
-    end
-
-    context "#child" do
-      asserts "that it can create a child node" do
-        template = rabl %{
-          object @user
-          attribute :name
-          child(@user) { attribute :city }
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'leo', :city => 'LA')
-        template.render(scope).split("").sort
-      end.equals "+\x00\x00\x00\x02name\x00\x04\x00\x00\x00leo\x00\x03user\x00\x12\x00\x00\x00\x02city\x00\x03\x00\x00\x00LA\x00\x00\x00".split("").sort
-
-      asserts "that it can create a child node with different key" do
-        template = rabl %{
-          object @user
-          attribute :name
-          child(@user => :person) { attribute :city }
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'leo', :city => 'LA')
-        template.render(scope).split("").sort
-      end.equals "-\x00\x00\x00\x02name\x00\x04\x00\x00\x00leo\x00\x03person\x00\x12\x00\x00\x00\x02city\x00\x03\x00\x00\x00LA\x00\x00\x00".split("").sort
-    end
-
-    context "#glue" do
-      asserts "that it glues data from a child node" do
-        template = rabl %{
-          object @user
-          attribute :name
-          glue(@user) { attribute :city }
-          glue(@user) { attribute :age  }
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new(:name => 'leo', :city => 'LA', :age => 12)
-        template.render(scope).split("").sort
-      end.equals ")\x00\x00\x00\x02name\x00\x04\x00\x00\x00leo\x00\x02city\x00\x03\x00\x00\x00LA\x00\x10age\x00\f\x00\x00\x00\x00".split("").sort
-    end
-
-    teardown do
-      Rabl.reset_configuration!
-    end
-  end
-end

data/test/builder_test.rb

@@ -1,362 +0,0 @@
-require File.expand_path('../teststrap',   __FILE__)
-
-context "Rabl::Builder" do
-  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(nil, nil, {:view_path => '/path/to/views'})
-  end
-
-  context "#initialize" do
-    asserts_topic.assigns :options
-    asserts_topic.assigns :_view_path
-  end
-
-  context "#to_hash" do
-    context "when given a simple object" do
-      setup { builder(nil, { :attributes => [ { :name => :name } ] }) }
-      asserts "that the object is set properly" do
-        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(nil, { :attributes => [ { :name => :name, :options => { :as => :foo } } ] }) }
-      asserts "that the object is set properly" do
-        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(nil, { :attributes => [ { :name => :name, :options => { :as => :name } } ] }) }
-      asserts "that the object is set properly" do
-        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(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.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.to_hash(User.new(:name => 10, :twitter => 'twitter'))
-      end.equivalent_to({ :name => 10, :extra => { :twitter => 'twitter' } })
-
-      teardown do
-        Rabl.configuration.replace_nil_values_with_empty_strings = false
-      end
-    end
-
-    context "when empty string values are replaced with nil values" do
-      setup do
-        Rabl.configuration.replace_empty_string_values_with_nil_values = true
-        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.to_hash(User.new(:name => "", :twitter => ''))
-      end.equivalent_to({ :name => nil, :extra => { :twitter => nil } })
-
-      asserts "that it handles existing nil values correctly" do
-        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.to_hash(User.new(:name => 10, :twitter => 'twitter'))
-      end.equivalent_to({ :name => 10, :extra => { :twitter => 'twitter' } })
-
-      teardown do
-        Rabl.configuration.replace_empty_string_values_with_nil_values = false
-      end
-    end
-
-    context "when nil values are excluded" do
-      setup do
-        Rabl.configuration.exclude_nil_values = true
-        builder(nil, { :attributes => [ { :name => :name } ] })
-      end
-      asserts "that an nil attribute is not returned" do
-        topic.to_hash(User.new(:name => nil))
-      end.equivalent_to({ })
-      teardown do
-        Rabl.configuration.exclude_nil_values = false
-      end
-    end
-  end
-
-  context "#attribute" do
-    asserts "that the node" do
-      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
-      context "when non-existent attributes are allowed by the configuration" do
-        setup { stub(Rabl.configuration).raise_on_missing_attribute { false } }
-
-        asserts "the node" do
-          build_hash @user, :attributes => [ { :name => :fake } ]
-        end.equals({})
-      end
-
-      context "when non-existent attributes are forbidden by the configuration" do
-        setup { stub(Rabl.configuration).raise_on_missing_attribute { true } }
-
-        asserts "the node" do
-          build_hash @user, :attributes => [ { :name => :fake } ]
-        end.raises(RuntimeError)
-      end
-    end
-
-    context "that with a string key" do
-      setup { builder(nil, { :attributes => [ { :name => "name" } ] }) }
-      asserts "the node name is converted to a symbol" do
-        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(nil, { :attributes => [ { :name => "name" }, { :name => :name } ] }) }
-      asserts "the nodes aren't duplicated" do
-        topic.to_hash(User.new, :name => "user")
-      end.equivalent_to({ :name => "rabl" })
-    end
-  end
-
-  context "#node" do
-    asserts "that it has node :foo" do
-      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
-      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'})
-
-    asserts "that it converts the node name to a symbol" do
-      build_hash @user, :node => [{ :name => "foo", :options => {}, :block => lambda { |u| "bar" } }]
-    end.equivalent_to({:foo => 'bar'})
-
-    asserts "that the same node names as a string and symbol aren't duplicated" do
-      build_hash @user, :node => [
-        { :name => "foo", :options => {}, :block => lambda { |u| "bar" } },
-        { :name => :foo, :options => {}, :block => lambda { |u| "bar" } }
-      ]
-    end.equivalent_to({:foo => 'bar'})
-  end
-
-  context "#child" do
-    asserts "that it generates if no data present" do
-      builder(nil, :child => []).to_hash(@user)
-    end.equals({})
-
-    asserts "that it generates with a hash" do
-      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 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 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.to_hash(@user)
-    end.equivalent_to({ :user => 'xyz'})
-
-    asserts "that it generates with an collection and child_root" do
-      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.to_hash(@user)
-    end.equivalent_to({ :users => 'xyz'})
-
-    asserts "that it generates with an collection and no child root" do
-      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.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 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.to_hash(@user)
-    end.equivalent_to({ :people => 'xyz'})
-
-    asserts "that it converts the child name to a symbol" do
-      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(nil, :child => [
-        { :data => { @user => "user" }, :options => { }, :block => lambda { |u| attribute :name } },
-        { :data => { @user => :user }, :options => { }, :block => lambda { |u| attribute :name } }
-      ])
-      b.to_hash(@user)
-    end.equivalent_to({ :user => { :name => "rabl" } })
-  end
-
-  context "#glue" do
-    asserts "that it generates if no data present" do
-      builder(nil, :glue => []).to_hash(@user)
-    end.equals({})
-
-    asserts "that it generates the glue attributes" do
-      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.to_hash(@user)
-    end.equivalent_to({ :user => 'xyz' })
-
-    asserts "that it appends the glue attributes to result" do
-      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 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.to_hash(@user)
-    end.equals({})
-  end
-
-  context "#extends" do
-    asserts "that it does not generate if no data is present" do
-      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.to_hash(@user)
-    end.equals({})
-
-    asserts "that it generates if data is present" do
-      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.to_hash(@user)
-    end.equivalent_to({:user => 'xyz'})
-
-    asserts "that it generates if local data is present but object is false" do
-      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.to_hash(false)
-    end.equivalent_to({:user => 'xyz'})
-  end
-
-  context "#resolve_conditionals" do
-    class ArbObj
-      def cool?
-        false
-      end
-
-      def smooth?
-        true
-      end
-    end
-
-    asserts "that it can use symbols on if condition and return false if method returns false" do
-      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(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(ArbObj.new)
-      scope.send :resolve_condition, { :unless => :cool? }
-    end.equals(true)
-
-    asserts "that it can use symbols as unless condition and return false if method returns true" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send :resolve_condition, { :unless => :smooth? }
-    end.equals(false)
-
-    asserts "that it can use :unless and :if at the same time and return true when if is true and unless is false" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send :resolve_condition, { :if => true, :unless => false }
-    end.equals(true)
-
-    asserts "that it can use :unless and :if at the same time and return false when if is false and unless is false" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send :resolve_condition, { :if => false, :unless => false }
-    end.equals(false)
-
-    asserts "that it can use :unless and :if at the same time and return false when if is true and unless is true" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send :resolve_condition, { :if => true, :unless => true }
-    end.equals(false)
-
-    asserts "that it can use :unless and :if at the same time and return false when if is false and unless is true" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send :resolve_condition, { :if => false, :unless => true }
-    end.equals(false)
-
-    asserts "that it can use lambda on if condition and return false if lambda returns false" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send(:resolve_condition, { :if => lambda { |obj| false } })
-    end.equals(false)
-
-    asserts "that it can use lambda on if condition and return true if lambda returns true" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send(:resolve_condition, { :if => lambda { |obj| true } })
-    end.equals(true)
-
-    asserts "that it can use proc on if condition and return false if proc returns false" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send(:resolve_condition, { :if => proc { false } })
-    end.equals(false)
-
-    asserts "that it can use proc on if condition and return true if proc returns true" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send(:resolve_condition, { :if => proc { true } })
-    end.equals(true)
-
-    asserts "that it can use a variable on if condition and return true if variable is truthy" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send(:resolve_condition, { :if => 'Im truthy' })
-    end.equals('Im truthy')
-
-    asserts "that it can use a variable on if condition and return false if variable is falsy" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send(:resolve_condition, { :if => nil })
-    end.equals(nil)
-
-    asserts "that it can use a hash variable on if condition and return true" do
-      scope = Rabl::Builder.new(ArbObj.new)
-      scope.send(:resolve_condition, { :if => { some: 'data' } })
-    end.equals({some: 'data'})
-  end
-end