rabl 0.13.1 → 0.14.4

data/test/integration/users_controller_test.rb

@@ -1,87 +0,0 @@
-# Lives in <rabl>/test/integration/users_controller_test.rb
-# Symlinked to fixture applications
-
-begin # Sinatra
-  require File.expand_path(File.dirname(__FILE__) + '/../../test_config.rb')
-rescue LoadError # Rails
-  require File.expand_path(File.dirname(__FILE__) + '/../test_helper.rb')
-end
-
-context "UsersController" do
-  helper(:json_output) { JSON.parse(last_response.body) }
-
-  setup do
-    create_users!
-  end
-
-  context "for index action" do
-    # Tests `collection @users` extending from 'show' template
-
-    setup do
-      get "/users"
-    end
-
-    # Attributes (regular)
-    asserts("contains user usernames") do
-      json_output.map { |u| u["user"]["username"] }
-    end.equals { @users.map(&:username) }
-    asserts("contains email") do
-      json_output.map { |u| u["user"]["email"] }
-    end.equals { @users.map(&:email) }
-    asserts("contains location") do
-      json_output.map { |u| u["user"]["location"] }
-    end.equals { @users.map(&:location) }
-
-    # Attributes (custom name)
-    asserts("contains registered_at") do
-      json_output.map { |u| u["user"]["registered_at"] }
-    end.equals { @users.map(&:created_at).map(&:iso8601) }
-
-    # Node (renders based on attribute)
-    asserts("contains role") do
-      json_output.map { |u| u["user"]["role"] }
-    end.equals ['normal', 'normal', 'admin']
-
-    # Child (custom collection name)
-    asserts("contains formatted phone numbers") do
-      json_output.map { |u| u["user"]["pnumbers"].map { |n| n["pnumber"]["formatted"] } }
-    end.equals { @users.map { |u| u.phone_numbers.map(&:formatted) } }
-
-    # Node (renders collection partial)
-    asserts("contains formatted node numbers") do
-      json_output.map { |u| u["user"]["node_numbers"].map { |n| n["formatted"] } }
-    end.equals { @users.map { |u| u.phone_numbers.map(&:formatted) } }
-  end # index
-
-  context "for show action" do
-    # Tests `object :user => :person` custom parent node name
-    setup do
-      get "/users/#{@user1.id}"
-    end
-
-    # Attributes (regular)
-    asserts("contains username") { json_output["person"]["username"] }.equals { @user1.username }
-    asserts("contains email") { json_output["person"]["email"] }.equals { @user1.email }
-    asserts("contains location") { json_output["person"]["location"] }.equals { @user1.location }
-    # Attributes (custom name)
-    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.iso8601 }
-    # Node (renders based on attribute)
-    asserts("contains role node") { json_output["person"]["role"] }.equals "normal"
-
-    # Child (custom collection name)
-    asserts("contains first phone number") {
-      json_output["person"]["pnumbers"][0]["pnumber"]["formatted"]
-    }.equals { @user1.phone_numbers[0].formatted }
-    asserts("contains second phone number") {
-      json_output["person"]["pnumbers"][1]["pnumber"]["formatted"]
-    }.equals { @user1.phone_numbers[1].formatted }
-
-    # Node (renders collection partial)
-    asserts("contains first node number") {
-      json_output["person"]["node_numbers"][0]["formatted"]
-    }.equals { @user1.phone_numbers[0].formatted }
-    asserts("contains second node number") {
-      json_output["person"]["node_numbers"][1]["formatted"]
-    }.equals { @user1.phone_numbers[1].formatted }
-  end # show
-end

data/test/models/ormless.rb

@@ -1,3 +0,0 @@
-class Ormless
-  # Nothing here
-end

data/test/models/user.rb

@@ -1,34 +0,0 @@
-unless defined?(User)
-  class User
-    attr_accessor :age, :city, :name, :first, :float, :hobbies, :twitter
-
-    DEFAULT_AGE      = 24
-    DEFAULT_CITY     = 'irvine'
-    DEFAULT_NAME     = 'rabl'
-    DEFAULT_FIRST    = 'bob'
-    DEFAULT_FLOAT    = 1234.56
-    DEFAULT_HOBBIES  = ['Photography']
-    DEFAULT_TWITTER  = 'rablgem'
-
-    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
-      self.hobbies = self.hobbies.map { |h| Hobby.new(h) }
-    end
-  end
-
-  class Hobby
-    attr_accessor :name
-    def initialize(name); @name = name; end
-  end
-end
-
-unless defined?(NestedScope::User)
-  module NestedScope
-    class User
-      def controller; self; end
-      def controller_name; self.class.name.downcase; end
-    end
-  end
-end

data/test/msgpack_engine_test.rb

@@ -1,312 +0,0 @@
-# encoding: iso-8859-1
-
-require File.expand_path('../teststrap', __FILE__)
-require 'rabl/template'
-
-context "Rabl::Engine" do
-  helper(:rabl) { |t| RablTemplate.new("code", :format => 'msgpack') { t } }
-
-  context "with msgpack defaults" do
-    setup do
-      Rabl.configure do |config|
-        # Comment this line out because include_msgpack_root is default.
-        #config.include_msgpack_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
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4user\x80")
-
-      asserts "that it can set root node" do
-        template = rabl %q{
-          object @user => :person
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA6person\x80")
-    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]
-        char_split template.render(scope)
-      end.equals char_split("\x92\x81\xA4user\x80\x81\xA4user\x80")
-
-      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]
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA6person\x92\x81\xA6person\x80\x81\xA6person\x80")
-    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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4user\x81\xA4name\xA6irvine")
-
-      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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4user\x81\xA4city\xA6irvine")
-
-      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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4user\x81\xA4city\xA6irvine")
-    end
-
-    context "#code" do
-      asserts "that it can create an arbitraty code node" do
-        template = rabl %{
-          code(:foo) { 'bar' }
-        }
-        char_split template.render(Object.new)
-      end.equals char_split("\x81\xA3foo\xA3bar")
-
-      asserts "that it can be passed conditionals" do
-        template = rabl %{
-          code(:foo, :if => lambda { |i| false }) { 'bar' }
-        }
-        char_split template.render(Object.new)
-      end.equals char_split("\x80")
-    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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4user\x82\xA4name\xA3leo\xA4user\x81\xA4city\xA2LA")
-
-      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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4user\x82\xA4name\xA3leo\xA6person\x81\xA4city\xA2LA")
-    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)
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4user\x83\xA4name\xA3leo\xA4city\xA2LA\xA3age\f")
-    end
-
-    teardown do
-      Rabl.reset_configuration!
-    end
-  end
-
-  context "with msgpack_engine" do
-    setup do
-      class CustomEncodeEngine
-        def self.pack string
-          42
-        end
-      end
-
-      Rabl.configure do |config|
-        config.msgpack_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 msgpack root" do
-    setup do
-      Rabl.configure do |config|
-        config.include_msgpack_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
-        char_split template.render(scope)
-      end.equals char_split("\x80")
-
-      asserts "that it can set root node" do
-        template = rabl %q{
-          object @user => :person
-        }
-        scope = Object.new
-        scope.instance_variable_set :@user, User.new
-        char_split template.render(scope)
-      end.equals char_split("\x80")
-    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]
-        char_split template.render(scope)
-      end.equals char_split("\x92\x80\x80")
-
-      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]
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA6person\x92\x80\x80")
-    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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4name\xA6irvine")
-
-      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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4city\xA6irvine")
-
-      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')
-        char_split template.render(scope)
-      end.equals char_split("\x81\xA4city\xA6irvine")
-    end
-
-    context "#code" do
-      asserts "that it can create an arbitraty code node" do
-        template = rabl %{
-          code(:foo) { 'bar' }
-        }
-        char_split template.render(Object.new)
-      end.equals char_split("\x81\xA3foo\xA3bar")
-
-      asserts "that it can be passed conditionals" do
-        template = rabl %{
-          code(:foo, :if => lambda { |i| false }) { 'bar' }
-        }
-        char_split template.render(Object.new)
-      end.equals char_split("\x80")
-    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')
-        char_split template.render(scope)
-      end.equals char_split("\x82\xA4name\xA3leo\xA4user\x81\xA4city\xA2LA")
-
-      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')
-        char_split template.render(scope)
-      end.equals char_split("\x82\xA4name\xA3leo\xA6person\x81\xA4city\xA2LA")
-    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)
-        char_split template.render(scope)
-      end.equals char_split("\x83\xA4name\xA3leo\xA4city\xA2LA\xA3age\f")
-    end
-
-    teardown do
-      Rabl.reset_configuration!
-    end
-  end
-end

data/test/multi_builder_test.rb

@@ -1,69 +0,0 @@
-require 'json'
-require File.expand_path('../teststrap', __FILE__)
-require 'rabl/template'
-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(nil, {}) }
-  helper(:engine)        { |object|           Rabl::Engine.new("").apply(nil, :object => object) }
-
-  context "#initialize" do
-    setup do
-      Rabl::MultiBuilder.new([], {})
-    end
-
-    asserts_topic.assigns :options
-    asserts_topic.assigns :data
-    asserts_topic.assigns :engine_to_builder
-    asserts_topic.assigns :cache_key_to_engine
-  end
-
-  context "#to_a" do
-    setup do
-      Rabl::MultiBuilder.new([], {})
-    end
-
-    asserts "returns an array" do
-      topic.to_a
-    end.is_a?(Array)
-  end
-
-  context "#map_cache_key_to_engine" do
-    asserts "maps the cache keys to the engines" do
-      mb = multi_builder [], {}
-      e = engine User.new
-      mock(e).cache_key.returns(['cache key'])
-      mb.send(:map_cache_key_to_engine, e)
-      mb.instance_variable_get('@cache_key_to_engine').values.include?(e)
-    end.equals(true)
-  end
-
-  context "#read_cache_results" do
-    setup do
-      mb = multi_builder [], {}
-      mb.instance_variable_set('@cache_key_to_engine', { 'cache_key' => engine(User.new) })
-      mb
-    end
-
-    asserts "uses read_multi to find all of the cached values with keys" do
-      mock(Rabl.configuration.cache_engine).read_multi('cache_key').returns({})
-      topic.send(:read_cache_results)
-    end
-  end
-
-  context "replace_engines_with_cache_results" do
-    asserts "replaces the builders' engines with the cache results" do
-      mb = multi_builder [], {}
-      e = engine User.new
-      b = builder
-      mb.instance_variable_set('@cache_key_to_engine', { 'cache_key' => e })
-      mb.instance_variable_set('@engine_to_builder', { e => b })
-      b.instance_variable_set('@_engines', [e])
-      mb.instance_variable_set('@cache_results', { 'cache_key' => '{}' })
-
-      mock(b).replace_engine(e, '{}')
-      mb.send(:replace_engines_with_cache_results)
-    end
-  end
-end