oat 0.1.2 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf0df88db08a4e8499e855c3297040d5a5624bb1
-  data.tar.gz: 52a898fa03b0a1e043da33169334a3c40ce981e0
+  metadata.gz: 6b724a91b70428b2d8119bb6bdd9a30c814ac10d
+  data.tar.gz: 043edf3fd0dcb99075cf01660851e8a183270d1f
 SHA512:
-  metadata.gz: 76dc4f30fabc30a43962e608895c1036cc627923e95c0a4dda092b3e5a83c4e0f1b625d14975fd81b2df382d9615e9b8b302abeb8c040a6cbeca061acc0c677c
-  data.tar.gz: 7b9e468b4ca49e14b54d98d8342fa92254809600e0c93b22fece7ba88bf424c4bd61b36d07e9ea4c86bdb6d2cfd5f0f48fa3227b41c77c8bd1318deabe86aa78
+  metadata.gz: 7662b374492e8c20c8e3fbe030d1b08bbcd27665cb4230a4c696142b1e80d6d298eb4870977943ac99d12d20517792c97240d88602b28f29c2bd0974f3bf7455
+  data.tar.gz: a4887962d0788adfcb7992a79e21c884ddb92734c690b99f77c9541278003db4c7fbe5c5f1ffae2696c114c58a7236ce621a619ac9c44b3c8d151b4eafee6b47

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
+gemfiles/Gemfile*.lock
 InstalledFiles
 _yardoc
 coverage

data/.travis.yml

@@ -1,3 +1,30 @@
 language: ruby
 rvm:
   - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7
+
+gemfile:
+  - gemfiles/Gemfile.as-2.3.x
+  - gemfiles/Gemfile.as-3.0.x
+  - gemfiles/Gemfile.as-3.1.x
+  - gemfiles/Gemfile.as-3.2.x
+  - gemfiles/Gemfile.as-4.0.x
+
+matrix:
+  include:
+    - gemfile: gemfiles/Gemfile.as-1.4.4
+      rvm: 1.8.7
+  exclude:
+    - gemfile: gemfiles/Gemfile.as-2.3.x
+      rvm: 2.0.0
+    - gemfile: gemfiles/Gemfile.as-4.0.x
+      rvm: 1.8.7
+    - gemfile: gemfiles/Gemfile.as-4.0.x
+      rvm: 1.9.2
+  allow_failures:
+    - gemfile: gemfiles/Gemfile.as-3.0.x
+      rvm: 1.8.7
+    - gemfile: gemfiles/Gemfile.as-1.4.4
+      rvm: 1.8.7

data/README.md

@@ -46,7 +46,7 @@ Serializers require a single object as argument, which can be a model instance,
 The full serializer signature is `item`, `context`, `adapter_class`.
 
 * `item` a model or presenter instance. It is available in your serializer's schema as `item`.
-* `context` (optional) a context object or hash that is passed to the serializer and sub-serializers as the `context` variable. Useful if you need to pass request-specific data.
+* `context` (optional) a context hash that is passed to the serializer and sub-serializers as the `context` variable. Useful if you need to pass request-specific data.
 * `adapter_class` (optional) A serializer's adapter can be configured at class-level or passed here to the initializer. Useful if you want to switch adapters based on request data. More on this below.
 
 ### Defining Properties
@@ -350,32 +350,52 @@ end
 
 In frameworks like Rails, you'll probably want to use the URL helpers created by the `routes.rb` file. Two options:
 
-### Pass a context object to serializers
+### Pass a context hash to serializers
 
-You can pass a context object as second argument to serializers. This object will be passed to nested serializers too. For example, you can pass the controller instance itself.
+You can pass a context hash as second argument to serializers. This object will be passed to nested serializers too. For example, you can pass the controller instance itself.
 
 ```ruby
 # users_controller.rb
 
 def show
   user = User.find(params[:id])
-  render json: UserSerializer.new(user, self)
+  render json: UserSerializer.new(user, controller: self)
 end
 ```
 
 Then, in the `UserSerializer`:
+
 ```ruby
 class ProductSerializer < Oat::Serializer
   adapter Oat::Adapters::HAL
 
   schema do
-    # `context` is the controller, which responds to URL helpers.
-    link :self, href: context.product_url(item)
+    # `context[:controller]` is the controller, which responds to URL helpers.
+    link :self, href: context[:controller].product_url(item)
     ...
   end
 end
 ```
 
+The context hash is passed down to each nested serializer called by a parent. In some cases, you might want to include extra context information for one or more nested serializers. This can be done by passing options into your call to `entity` or `entities`.
+
+```ruby
+class CategorySerializer < Oat::Serializer
+  adapter Oat::Adapters::HAL
+
+  schema do
+    map_properties :id, :name
+
+    # category entities
+    # passing this option ensures that only direct children are embedded within
+    # the parent serialized category
+    entities :subcategories, item.subcategories, CategorySerializer, embedded: true if context[:embedded]
+  end
+end
+```
+
+The additional options are merged into the current context before being passed down to the nested serializer.
+
 ### Mixin Rails' routing module
 
 Alternatively, you can mix in Rails routing helpers directly into your serializers.

data/gemfiles/Gemfile.as-1.4.4

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oat.gemspec
+gem 'activesupport', '1.4.4'
+gemspec :path => "../"

data/gemfiles/Gemfile.as-2.3.x

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oat.gemspec
+gem 'activesupport', '~>2.3.18'
+gemspec :path => "../"

data/gemfiles/Gemfile.as-3.0.x

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oat.gemspec
+gem 'activesupport', '~>3.0.20'
+gem 'i18n'
+gemspec :path => "../"

data/gemfiles/Gemfile.as-3.1.x

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oat.gemspec
+gem 'activesupport', '~>3.1.12'
+gem 'i18n'
+gemspec :path => "../"

data/gemfiles/Gemfile.as-3.2.x

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oat.gemspec
+gem 'activesupport', '~>3.2.16'
+gemspec :path => "../"

data/gemfiles/Gemfile.as-4.0.x

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oat.gemspec
+gem 'activesupport', '~>4.0.2'
+gemspec :path => "../"

data/lib/oat/adapter.rb

@@ -21,17 +21,17 @@ module Oat
       props.to_hash
     end
 
-    def serializer_from_block_or_class(obj, serializer_class = nil, &block)
+    def serializer_from_block_or_class(obj, serializer_class = nil, context_options = {}, &block)
       return nil if obj.nil?
 
       if block_given?
         serializer_class = Class.new(serializer.class)
         serializer_class.adapter self.class
-        s = serializer_class.new(obj, serializer.context, serializer.adapter_class, serializer.top)
+        s = serializer_class.new(obj, serializer.context.merge(context_options), serializer.adapter_class, serializer.top)
         serializer.top.instance_exec(obj, s, &block)
         s.to_hash
       else
-        serializer_class.new(obj, serializer.context, serializer.adapter_class).to_hash
+        serializer_class.new(obj, serializer.context.merge(context_options), serializer.adapter_class).to_hash
       end
     end
   end

data/lib/oat/adapters/hal.rb

@@ -14,13 +14,13 @@ module Oat
         data[key] = value
       end
 
-      def entity(name, obj, serializer_class = nil, &block)
-        data[:_embedded][name] = serializer_from_block_or_class(obj, serializer_class, &block)
+      def entity(name, obj, serializer_class = nil, context_options = {}, &block)
+        data[:_embedded][name] = serializer_from_block_or_class(obj, serializer_class, context_options, &block)
       end
 
-      def entities(name, collection, serializer_class = nil, &block)
+      def entities(name, collection, serializer_class = nil, context_options = {}, &block)
         data[:_embedded][name] = collection.map do |obj|
-          serializer_from_block_or_class(obj, serializer_class, &block)
+          serializer_from_block_or_class(obj, serializer_class, context_options, &block)
         end
       end
 

data/lib/oat/adapters/json_api.rb

@@ -1,5 +1,12 @@
 # http://jsonapi.org/format/#url-based-json-api
+require 'active_support/inflector'
 require 'active_support/core_ext/string/inflections'
+unless defined?(String.new.pluralize)
+  class String
+    include ActiveSupport::CoreExtensions::String::Inflections
+  end
+end
+
 module Oat
   module Adapters
     class JsonAPI < Oat::Adapter
@@ -25,22 +32,22 @@ module Oat
         data[key] = value
       end
 
-      def entity(name, obj, serializer_class = nil, &block)
+      def entity(name, obj, serializer_class = nil, context_options = {}, &block)
         @entities[name.to_s.pluralize.to_sym] ||= []
-        ent = entity_without_root(obj, serializer_class, &block)
+        ent = entity_without_root(obj, serializer_class, context_options, &block)
         if ent
           link name, :href => ent[:id]
           @entities[name.to_s.pluralize.to_sym] << ent
         end
       end
 
-      def entities(name, collection, serializer_class = nil, &block)
+      def entities(name, collection, serializer_class = nil, context_options = {}, &block)
         link_name = name.to_s.pluralize.to_sym
         data[:links][link_name] = []
 
         collection.each do |obj|
           @entities[link_name] ||= []
-          ent = entity_without_root(obj, serializer_class, &block)
+          ent = entity_without_root(obj, serializer_class, context_options, &block)
           if ent
             data[:links][link_name] << ent[:id]
             @entities[link_name] << ent
@@ -59,8 +66,8 @@ module Oat
 
       attr_reader :root_name
 
-      def entity_without_root(obj, serializer_class = nil, &block)
-        ent = serializer_from_block_or_class(obj, serializer_class, &block)
+      def entity_without_root(obj, serializer_class = nil, context_options = {}, &block)
+        ent = serializer_from_block_or_class(obj, serializer_class, context_options, &block)
         ent.values.first.first if ent
       end
 

data/lib/oat/adapters/siren.rb

@@ -26,14 +26,14 @@ module Oat
         data[:properties][key] = value
       end
 
-      def entity(name, obj, serializer_class = nil, &block)
-        ent = serializer_from_block_or_class(obj, serializer_class, &block)
+      def entity(name, obj, serializer_class = nil, context_options = {}, &block)
+        ent = serializer_from_block_or_class(obj, serializer_class, context_options, &block)
         data[:entities] << ent if ent
       end
 
-      def entities(name, collection, serializer_class = nil, &block)
+      def entities(name, collection, serializer_class = nil, context_options = {}, &block)
         collection.each do |obj|
-          entity name, obj, serializer_class, &block
+          entity name, obj, serializer_class, context_options, &block
         end
       end
 

data/lib/oat/serializer.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/class/attribute'
+require 'support/class_attribute'
 module Oat
   class Serializer
 
@@ -20,7 +20,7 @@ module Oat
 
     attr_reader :item, :context, :adapter_class, :adapter
 
-    def initialize(item, context = nil, _adapter_class = nil, parent_serializer = nil)
+    def initialize(item, context = {}, _adapter_class = nil, parent_serializer = nil)
       @item, @context = item, context
       @parent_serializer = parent_serializer
       @adapter_class = _adapter_class || self.class.adapter

data/lib/oat/version.rb

@@ -1,3 +1,3 @@
 module Oat
-  VERSION = "0.1.2"
+  VERSION = "0.2.2"
 end

data/lib/support/class_attribute.rb

@@ -0,0 +1,68 @@
+begin
+  require 'active_support/core_ext/class/attribute'
+rescue LoadError
+  module Kernel
+    # Returns the object's singleton class.
+    def singleton_class
+      class << self
+        self
+      end
+    end unless respond_to?(:singleton_class) # exists in 1.9.2
+
+    # class_eval on an object acts like singleton_class.class_eval.
+    def class_eval(*args, &block)
+      singleton_class.class_eval(*args, &block)
+    end
+  end
+
+  class Module
+    def remove_possible_method(method)
+      if method_defined?(method) || private_method_defined?(method)
+        remove_method(method)
+      end
+    rescue NameError
+      # If the requested method is defined on a superclass or included module,
+      # method_defined? returns true but remove_method throws a NameError.
+      # Ignore this.
+    end
+
+    def redefine_method(method, &block)
+      remove_possible_method(method)
+      define_method(method, &block)
+    end
+  end
+
+  class Class
+    def class_attribute(*attrs)
+      attrs.each do |name|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.#{name}() nil end
+          def self.#{name}?() !!#{name} end
+
+          def self.#{name}=(val)
+            singleton_class.class_eval do
+              remove_possible_method(:#{name})
+              define_method(:#{name}) { val }
+            end
+
+            if singleton_class?
+              class_eval do
+                remove_possible_method(:#{name})
+                def #{name}
+                  defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+                end
+              end
+            end
+            val
+          end
+        RUBY
+
+      end
+    end
+
+    private
+    def singleton_class?
+      ancestors.first != self
+    end
+  end
+end

data/oat.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport", ">= 4.0"
+  spec.add_dependency "activesupport"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/spec/adapters/hal_spec.rb

@@ -5,63 +5,78 @@ describe Oat::Adapters::HAL do
 
   include Fixtures
 
-  subject{ serializer_class.new(user, {:name => 'some_controller'}, Oat::Adapters::HAL) }
+  let(:serializer) { serializer_class.new(user, {:name => 'some_controller'}, Oat::Adapters::HAL) }
+  let(:hash) { serializer.to_hash }
 
   describe '#to_hash' do
     it 'produces a HAL-compliant hash' do
-      subject.to_hash.tap do |h|
+      expect(hash).to include(
         # properties
-        h[:id].should == user.id
-        h[:name].should == user.name
-        h[:age].should == user.age
-        h[:controller_name].should == 'some_controller'
-        # links
-        h[:_links][:self][:href].should == "http://foo.bar.com/#{user.id}"
-        # HAL Spec says href is REQUIRED
-        h[:_links].should_not include(:empty)
-        # embedded manager
-        h[:_embedded][:manager].tap do |m|
-          m[:id].should == manager.id
-          m[:name].should == manager.name
-          m[:age].should  == manager.age
-          m[:_links][:self][:href].should == "http://foo.bar.com/#{manager.id}"
-        end
-        # embedded friends
-        h[:_embedded][:friends].size.should == 1
-        h[:_embedded][:friends][0].tap do |f|
-          f[:id].should == friend.id
-          f[:name].should == friend.name
-          f[:age].should == friend.age
-          f[:controller_name].should == 'some_controller'
-          f[:_links][:self][:href].should == "http://foo.bar.com/#{friend.id}"
-        end
-      end
+        :id => user.id,
+        :name => user.name,
+        :age => user.age,
+        :controller_name => 'some_controller',
+        :message_from_above => nil
+      )
+
+      # links
+      expect(hash.fetch(:_links)).to include(:self => { :href => "http://foo.bar.com/#{user.id}" })
+
+      # HAL Spec says href is REQUIRED
+      expect(hash.fetch(:_links)).not_to include(:empty)
+      expect(hash.fetch(:_embedded)).to include(:manager, :friends)
+
+      # embedded manager
+      expect(hash.fetch(:_embedded).fetch(:manager)).to include(
+        :id => manager.id,
+        :name => manager.name,
+        :age => manager.age,
+        :_links => { :self => { :href => "http://foo.bar.com/#{manager.id}" } }
+      )
+
+      # embedded friends
+      expect(hash.fetch(:_embedded).fetch(:friends).size).to be 1
+      expect(hash.fetch(:_embedded).fetch(:friends).first).to include(
+        :id => friend.id,
+        :name => friend.name,
+        :age => friend.age,
+        :controller_name => 'some_controller',
+        :message_from_above => "Merged into parent's context",
+        :_links => { :self => { :href => "http://foo.bar.com/#{friend.id}" } }
+      )
     end
 
     context 'with a nil entity relationship' do
       let(:manager) { nil }
 
       it 'produces a HAL-compliant hash' do
-        subject.to_hash.tap do |h|
-          # properties
-          h[:id].should == user.id
-          h[:name].should == user.name
-          h[:age].should == user.age
-          h[:controller_name].should == 'some_controller'
-          # links
-          h[:_links][:self][:href].should == "http://foo.bar.com/#{user.id}"
-          # embedded manager
-          h[:_embedded].fetch(:manager).should be_nil
-          # embedded friends
-          h[:_embedded][:friends].size.should == 1
-          h[:_embedded][:friends][0].tap do |f|
-            f[:id].should == friend.id
-            f[:name].should == friend.name
-            f[:age].should == friend.age
-            f[:controller_name].should == 'some_controller'
-            f[:_links][:self][:href].should == "http://foo.bar.com/#{friend.id}"
-          end
-        end
+        # properties
+        expect(hash).to include(
+          :id => user.id,
+          :name => user.name,
+          :age => user.age,
+          :controller_name => 'some_controller',
+          :message_from_above => nil
+        )
+
+        expect(hash.fetch(:_links)).to include(:self => { :href => "http://foo.bar.com/#{user.id}" })
+
+        # HAL Spec says href is REQUIRED
+        expect(hash.fetch(:_links)).not_to include(:empty)
+        expect(hash.fetch(:_embedded)).to include(:manager, :friends)
+
+        expect(hash.fetch(:_embedded).fetch(:manager)).to be_nil
+
+        # embedded friends
+        expect(hash.fetch(:_embedded).fetch(:friends).size).to be 1
+        expect(hash.fetch(:_embedded).fetch(:friends).first).to include(
+          :id => friend.id,
+          :name => friend.name,
+          :age => friend.age,
+          :controller_name => 'some_controller',
+          :message_from_above => "Merged into parent's context",
+          :_links => { :self => { :href => "http://foo.bar.com/#{friend.id}" } }
+        )
       end
     end
   end

data/spec/adapters/json_api_spec.rb

@@ -5,69 +5,97 @@ describe Oat::Adapters::JsonAPI do
 
   include Fixtures
 
-  subject{ serializer_class.new(user, {:name => 'some_controller'}, Oat::Adapters::JsonAPI) }
+  let(:serializer) { serializer_class.new(user, {:name => 'some_controller'}, Oat::Adapters::JsonAPI) }
+  let(:hash) { serializer.to_hash }
 
   describe '#to_hash' do
     it 'produces a JSON-API compliant hash' do
-      payload = subject.to_hash
+      # the user being serialized
+      users = hash.fetch(:users)
+      expect(users.size).to be 1
+      expect(users.first).to include(
+        :id => user.id,
+        :name => user.name,
+        :age => user.age,
+        :controller_name => 'some_controller',
+        :message_from_above => nil
+      )
+
+      expect(users.first.fetch(:links)).to include(
+        :self => "http://foo.bar.com/#{user.id}",
+        # these links are added by embedding entities
+        :manager => manager.id,
+        :friends => [friend.id]
+      )
+
       # embedded friends
-      payload[:linked][:friends][0].tap do |f|
-        f[:id].should == friend.id
-        f[:name].should == friend.name
-        f[:age].should == friend.age
-        f[:controller_name].should == 'some_controller'
-        f[:links][:self].should == "http://foo.bar.com/#{friend.id}"
-      end
+      linked_friends = hash.fetch(:linked).fetch(:friends)
+      expect(linked_friends.size).to be 1
+      expect(linked_friends.first).to include(
+        :id => friend.id,
+        :name => friend.name,
+        :age => friend.age,
+        :controller_name => 'some_controller',
+        :message_from_above => "Merged into parent's context"
+      )
 
-      # embedded manager
-      payload[:linked][:managers][0].tap do |m|
-        m[:id].should == manager.id
-        m[:name].should == manager.name
-        m[:age].should  == manager.age
-        m[:links][:self].should == "http://foo.bar.com/#{manager.id}"
-      end
+      expect(linked_friends.first.fetch(:links)).to include(
+        :self => "http://foo.bar.com/#{friend.id}",
+        :empty => nil,
+        :friends => []
+      )
 
-      payload[:users][0].tap do |h|
-        h[:id].should == user.id
-        h[:name].should == user.name
-        h[:age].should == user.age
-        h[:controller_name].should == 'some_controller'
-        # links
-        h[:links][:self].should == "http://foo.bar.com/#{user.id}"
-        # these links are added by embedding entities
-        h[:links][:manager].should == manager.id
-        h[:links][:friends].should == [friend.id]
-      end
+      # embedded manager
+      linked_managers = hash.fetch(:linked).fetch(:managers)
+      expect(linked_managers.size).to be 1
+      expect(linked_managers.first).to include(
+        :id => manager.id,
+        :name => manager.name,
+        :age => manager.age,
+        :links => { :self => "http://foo.bar.com/#{manager.id}" }
+      )
     end
 
     context 'with a nil entity relationship' do
       let(:manager) { nil }
 
       it 'produces a JSON-API compliant hash' do
-        payload = subject.to_hash
+        # the user being serialized
+        users = hash.fetch(:users)
+        expect(users.size).to be 1
+        expect(users.first).to include(
+          :id => user.id,
+          :name => user.name,
+          :age => user.age,
+          :controller_name => 'some_controller',
+          :message_from_above => nil
+        )
+
+        expect(users.first.fetch(:links)).not_to include(:manager)
+        expect(users.first.fetch(:links)).to include(
+          :self => "http://foo.bar.com/#{user.id}",
+          # these links are added by embedding entities
+          :friends => [friend.id]
+        )
         # embedded friends
-        payload[:linked][:friends][0].tap do |f|
-          f[:id].should == friend.id
-          f[:name].should == friend.name
-          f[:age].should == friend.age
-          f[:controller_name].should == 'some_controller'
-          f[:links][:self].should == "http://foo.bar.com/#{friend.id}"
-        end
+        linked_friends = hash.fetch(:linked).fetch(:friends)
+        expect(linked_friends.size).to be 1
+        expect(linked_friends.first).to include(
+          :id => friend.id,
+          :name => friend.name,
+          :age => friend.age,
+          :controller_name => 'some_controller',
+          :message_from_above => "Merged into parent's context"
+        )
 
-        # embedded manager
-        payload[:linked].fetch(:managers).should be_empty
+        expect(linked_friends.first.fetch(:links)).to include(
+          :self => "http://foo.bar.com/#{friend.id}",
+          :empty => nil,
+          :friends => []
+        )
 
-        payload[:users][0].tap do |h|
-          h[:id].should == user.id
-          h[:name].should == user.name
-          h[:age].should == user.age
-          h[:controller_name].should == 'some_controller'
-          # links
-          h[:links][:self].should == "http://foo.bar.com/#{user.id}"
-          # these links are added by embedding entities
-          h[:links].should_not include(:manager)
-          h[:links][:friends].should == [friend.id]
-        end
+        # embedded manager
+        hash.fetch(:linked).fetch(:managers).should be_empty
       end
     end
   end

data/spec/adapters/siren_spec.rb

@@ -5,82 +5,110 @@ describe Oat::Adapters::Siren do
 
   include Fixtures
 
-  subject{ serializer_class.new(user, {:name => 'some_controller'}, Oat::Adapters::Siren) }
+  let(:serializer) { serializer_class.new(user, {:name => 'some_controller'}, Oat::Adapters::Siren) }
+  let(:hash) { serializer.to_hash }
 
   describe '#to_hash' do
     it 'produces a Siren-compliant hash' do
-      subject.to_hash.tap do |h|
-        #siren class
-        h[:class].should == ['user']
-        # properties
-        h[:properties][:id].should == user.id
-        h[:properties][:name].should == user.name
-        h[:properties][:age].should == user.age
-        h[:properties][:controller_name].should == 'some_controller'
-        # links
-        h[:links][0][:rel].should == [:self]
-        h[:links][0][:href].should == "http://foo.bar.com/#{user.id}"
-        # embedded manager
-        h[:entities][1].tap do |m|
-          m[:class].should == ['manager']
-          m[:properties][:id].should == manager.id
-          m[:properties][:name].should == manager.name
-          m[:properties][:age].should  == manager.age
-          m[:links][0][:rel].should == [:self]
-          m[:links][0][:href].should == "http://foo.bar.com/#{manager.id}"
-        end
-        # embedded friends
-        h[:entities][0].tap do |f|
-          f[:class].should == ['user']
-          f[:properties][:id].should == friend.id
-          f[:properties][:name].should == friend.name
-          f[:properties][:age].should == friend.age
-          f[:properties][:controller_name].should == 'some_controller'
-          f[:links][0][:rel].should == [:self]
-          f[:links][0][:href].should == "http://foo.bar.com/#{friend.id}"
-        end
-        # action close_account
-        h[:actions][0].tap do |a|
-          a[:name].should == :close_account
-          a[:href].should == "http://foo.bar.com/#{user.id}/close_account"
-          a[:class].should == ['danger', 'irreversible']
-          a[:method].should == 'DELETE'
-          a[:fields][0].tap do |f|
-            f[:name].should == :current_password
-            f[:type].should == :password
-          end
-        end
-      end
+      expect(hash.fetch(:class)).to match_array(['user'])
+
+      expect(hash.fetch(:properties)).to include(
+        :id => user.id,
+        :name => user.name,
+        :age => user.age,
+        :controller_name => 'some_controller',
+        :message_from_above => nil
+      )
+
+      expect(hash.fetch(:links).size).to be 2
+      expect(hash.fetch(:links)).to include(
+        { :rel => [:self], :href => "http://foo.bar.com/#{user.id}" },
+        { :rel => [:empty], :href => nil }
+      )
+
+      expect(hash.fetch(:entities).size).to be 2
+
+      # embedded friends
+      embedded_friends = hash.fetch(:entities).select{ |o| o[:class].include? "user" }
+      expect(embedded_friends.size).to be 1
+      expect(embedded_friends.first.fetch(:properties)).to include(
+        :id => friend.id,
+        :name => friend.name,
+        :age => friend.age,
+        :controller_name => 'some_controller',
+        :message_from_above => "Merged into parent's context"
+      )
+      expect(embedded_friends.first.fetch(:links).first).to include(
+        :rel => [:self],
+        :href => "http://foo.bar.com/#{friend.id}"
+      )
+
+      embedded_managers = hash.fetch(:entities).select{ |o| o[:class].include? "manager" }
+      expect(embedded_managers.size).to be 1
+      expect(embedded_managers.first.fetch(:properties)).to include(
+        :id => manager.id,
+        :name => manager.name,
+        :age => manager.age
+      )
+      expect(embedded_managers.first.fetch(:links).first).to include(
+        :rel => [:self],
+        :href => "http://foo.bar.com/#{manager.id}"
+      )
+
+      # action close_account
+      actions = hash.fetch(:actions)
+      expect(actions.size).to be 1
+      expect(actions.first).to include(
+        :name => :close_account,
+        :href => "http://foo.bar.com/#{user.id}/close_account",
+        :class => ['danger', 'irreversible'],
+        :method => 'DELETE'
+      )
+      expect(actions.first.fetch(:fields)).to include(
+        :name => :current_password,
+        :type => :password
+      )
     end
 
     context 'with a nil entity relationship' do
       let(:manager) { nil }
 
       it 'produces a Siren-compliant hash' do
-        subject.to_hash.tap do |h|
-          #siren class
-          h[:class].should == ['user']
-          # properties
-          h[:properties][:id].should == user.id
-          h[:properties][:name].should == user.name
-          h[:properties][:age].should == user.age
-          h[:properties][:controller_name].should == 'some_controller'
-          # links
-          h[:links][0][:rel].should == [:self]
-          h[:links][0][:href].should == "http://foo.bar.com/#{user.id}"
-          # embedded manager
-          h[:entities].any?{|o| o[:class].include?("manager")}.should be_false
-          # embedded friends
-          h[:entities][0].tap do |f|
-            f[:class].should == ['user']
-            f[:properties][:id].should == friend.id
-            f[:properties][:name].should == friend.name
-            f[:properties][:age].should == friend.age
-            f[:properties][:controller_name].should == 'some_controller'
-            f[:links][0][:rel].should == [:self]
-            f[:links][0][:href].should == "http://foo.bar.com/#{friend.id}"
-          end
-        end
+        expect(hash.fetch(:class)).to match_array(['user'])
+
+        expect(hash.fetch(:properties)).to include(
+          :id => user.id,
+          :name => user.name,
+          :age => user.age,
+          :controller_name => 'some_controller',
+          :message_from_above => nil
+        )
+
+        expect(hash.fetch(:links).size).to be 2
+        expect(hash.fetch(:links)).to include(
+          { :rel => [:self], :href => "http://foo.bar.com/#{user.id}" },
+          { :rel => [:empty], :href => nil }
+        )
+
+        expect(hash.fetch(:entities).size).to be 1
+
+        # embedded friends
+        embedded_friends = hash.fetch(:entities).select{ |o| o[:class].include? "user" }
+        expect(embedded_friends.size).to be 1
+        expect(embedded_friends.first.fetch(:properties)).to include(
+          :id => friend.id,
+          :name => friend.name,
+          :age => friend.age,
+          :controller_name => 'some_controller',
+          :message_from_above => "Merged into parent's context"
+        )
+        expect(embedded_friends.first.fetch(:links).first).to include(
+          :rel => [:self],
+          :href => "http://foo.bar.com/#{friend.id}"
+        )
+
+        embedded_managers = hash.fetch(:entities).select{ |o| o[:class].include? "manager" }
+        expect(embedded_managers.size).to be 0
       end
     end
   end

data/spec/fixtures.rb

@@ -18,9 +18,10 @@ module Fixtures
           map_properties :name, :age
           properties do |attrs|
             attrs.controller_name context[:name]
+            attrs.message_from_above context[:message]
           end
 
-          entities :friends, item.friends, klass
+          entities :friends, item.friends, klass, :message => "Merged into parent's context"
 
           entity :manager, item.manager do |manager, s|
             s.type 'manager'

data/spec/serializer_spec.rb

@@ -52,17 +52,31 @@ describe Oat::Serializer do
     Oat::VERSION.should_not be_nil
   end
 
+  describe "#context" do
+    it "is a hash by default" do
+      expect(@sc.new(user1).context).to be_a Hash
+    end
+
+    it "can be set like an options hash" do
+      serializer = @sc.new(user1, :controller => double(:name => "Fancy"))
+      expect(serializer.context.fetch(:controller).name).to eq "Fancy"
+    end
+  end
+
   describe '#to_hash' do
     it 'builds Hash from item and context with attributes as defined in adapter' do
       serializer = @sc.new(user1, :name => 'some_controller')
-      serializer.to_hash.tap do |h|
-        h[:attributes][:special].should == 'Hello'
-        h[:attributes][:id].should == user1.id
-        h[:attributes][:name].should == user1.name
-        h[:attributes][:age].should == user1.age
-        h[:attributes][:controller_name].should == 'some_controller'
-        h[:links][:self].should == "http://foo.bar.com/#{user1.id}"
-      end
+      expect(serializer.to_hash.fetch(:attributes)).to include(
+        :special => 'Hello',
+        :id => user1.id,
+        :name => user1.name,
+        :age => user1.age,
+        :controller_name => 'some_controller'
+      )
+
+      expect(serializer.to_hash.fetch(:links)).to include(
+        :self => "http://foo.bar.com/#{user1.id}"
+      )
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oat
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.2
 platform: ruby
 authors:
 - Ismael Celis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-13 00:00:00.000000000 Z
+date: 2014-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +83,12 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- gemfiles/Gemfile.as-1.4.4
+- gemfiles/Gemfile.as-2.3.x
+- gemfiles/Gemfile.as-3.0.x
+- gemfiles/Gemfile.as-3.1.x
+- gemfiles/Gemfile.as-3.2.x
+- gemfiles/Gemfile.as-4.0.x
 - lib/oat.rb
 - lib/oat/adapter.rb
 - lib/oat/adapters/hal.rb
@@ -91,6 +97,7 @@ files:
 - lib/oat/props.rb
 - lib/oat/serializer.rb
 - lib/oat/version.rb
+- lib/support/class_attribute.rb
 - oat.gemspec
 - spec/adapters/hal_spec.rb
 - spec/adapters/json_api_spec.rb