representable 1.5.0 → 1.5.1

data/CHANGES.textile

@@ -1,3 +1,7 @@
+h2. 1.5.1
+
+* Make lonely collections and hashes work with decorators.
+
 h2. 1.5.0
 
 * All lambdas now receive user options, too. Note that this might break your existing lambdas (especially with `:extend` or `:class`) raising an `ArgumentError: wrong number of arguments (2 for 1)`. Fix this by declaring your block params correctly, e.g. `lambda { |name, *|`. Internally, this happens by running all lambdas through the new `Binding#represented_exec_for`.

data/README.md

@@ -64,7 +64,7 @@ song = Song.new.extend(SongRepresenter).from_json(%{ {"title":"Roxanne"} })
 
 ## Extend vs. Decorator
 
-If you don't want representer modules to be mixed into your objects (using `#extend`) you can use the `Decorator` strategy [described below](https://github.com/apotonick/representable#decorator-vs-extend). Decorating instead of extending was introduced in 1.4.
+If you don't want representer modules to be mixed into your objects (using `#extend`) you can use the `Decorator` strategy [described below](#decorator-vs-extend). Decorating instead of extending was introduced in 1.4.
 
 
 ## Aliasing
@@ -205,6 +205,29 @@ class AlbumRepresentation < Representable::Decorator
 end
 ```
 
+### Helpers In Decorators
+
+In module representers you can add methods for properties.
+
+```ruby
+module SongRepresenter
+  property :title
+
+  def title
+    @name
+  end
+```
+
+That works as the method is mixed into the represented object. Of course, this doesn't work with decorators.
+
+Use `:getter` or `:setter` to dynamically add a method for the represented object.
+
+```ruby
+class SongRepresenter < Representable::Decorator
+  property :title, getter: lambda { |*| @name }
+```
+As always, the block is executed in the represented object's context.
+
 ## XML Support
 
 While representable does a great job with JSON, it also features support for XML, YAML and pure ruby hashes.

data/TODO

@@ -25,4 +25,7 @@ module ReaderWriter
   end
 => do that for all "features" (what parts would that be?: getter/setter, reader/writer, readable/writeable )?
 
-* make lambda options optional (arity == 0)
+* make lambda options optional (arity == 0)
+
+* use `representer_exec` not only for lambdas, but also for methods
+	property :title # => calls decorator.title

data/lib/representable/binding.rb

@@ -12,10 +12,6 @@ module Representable
       build_for(definition, *args)
     end
 
-    def definition  # TODO: remove in 1.4.
-      raise "Binding#definition is no longer supported as all Definition methods are now delegated automatically."
-    end
-
     def initialize(definition, represented, user_options={}, lambda_context=represented)  # TODO: remove default arg for user options. # DISCUSS: make lambda_context an options hash?
       super(definition)
       @represented    = represented

data/lib/representable/decorator.rb

@@ -1,6 +1,7 @@
 module Representable
   class Decorator
     attr_reader :represented
+    alias_method :decorated, :represented
 
     def self.prepare(represented)
       new(represented)  # was: PrepareStrategy::Decorate.

data/lib/representable/hash.rb

@@ -1,6 +1,5 @@
 require 'representable'
 require 'representable/bindings/hash_bindings'
-require 'json'
 
 module Representable
   # The generic representer. Brings #to_hash and #from_hash to your object.
@@ -13,28 +12,28 @@ module Representable
         extend ClassMethods # DISCUSS: do that only for classes?
       end
     end
-    
-    
+
+
     module ClassMethods
       def from_hash(*args, &block)
         create_represented(*args, &block).from_hash(*args)
       end
     end
-    
-    
+
+
     def from_hash(data, options={}, binding_builder=PropertyBinding)
       if wrap = options[:wrap] || representation_wrap
         data = data[wrap.to_s]
       end
-      
+
       update_properties_from(data, options, binding_builder)
     end
-    
+
     def to_hash(options={}, binding_builder=PropertyBinding)
       hash = create_representation_with({}, options, binding_builder)
-      
+
       return hash unless wrap = options[:wrap] || representation_wrap
-      
+
       {wrap => hash}
     end
   end

data/lib/representable/hash_methods.rb

@@ -6,21 +6,20 @@ module Representable
       attrs << Definition.new(*definition_opts) if attrs.size == 0
       attrs
     end
-    
+
     def create_representation_with(doc, options, format)
       bin   = representable_bindings_for(format, options).first
-      hash  = filter_keys_for(self, options)
+      hash  = filter_keys_for(represented, options)
       bin.write(doc, hash)
     end
-    
+
     def update_properties_from(doc, options, format)
       bin   = representable_bindings_for(format, options).first
       hash  = filter_keys_for(doc, options)
       value = bin.deserialize_from(hash)
-      replace(value)
-      self
+      represented.replace(value)
     end
-    
+
   private
     def filter_keys_for(hash, options)
       return hash unless props = options[:exclude] || options[:include]

data/lib/representable/json/collection.rb

@@ -1,33 +1,33 @@
 module Representable::JSON
   module Collection
     include Representable::JSON
-    
+
     def self.included(base)
       base.class_eval do
         include Representable
         extend ClassMethods
       end
     end
-    
-    
+
+
     module ClassMethods
       def items(options)
         collection :_self, options
       end
     end
-    
-    
+
+
     def create_representation_with(doc, options, format)
       bin   = representable_bindings_for(format, options).first
-      bin.serialize_for(self)
+      bin.serialize_for(represented)
     end
-    
+
     def update_properties_from(doc, options, format)
       bin   = representable_bindings_for(format, options).first
       value = bin.deserialize_from(doc)
-      replace(value)
+      represented.replace(value)
     end
-    
+
     # FIXME: refactor Definition so we can simply add options in #items to existing definition.
     def representable_attrs
       attrs = super

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "1.5.0"
+  VERSION = "1.5.1"
 end

data/lib/representable/xml/collection.rb

@@ -1,33 +1,33 @@
 module Representable::XML
   module Collection
     include Representable::XML
-    
+
     def self.included(base)
       base.class_eval do
         include Representable
         extend ClassMethods
       end
     end
-    
-    
+
+
     module ClassMethods
       def items(options)
         collection :_self, options
       end
     end
-    
-    
+
+
     def create_representation_with(doc, options, format)
       bin   = representable_bindings_for(format, options).first
-      bin.write(doc, self)
+      bin.write(doc, represented)
     end
-    
+
     def update_properties_from(doc, options, format)
       bin   = representable_bindings_for(format, options).first
       value = bin.deserialize_from(doc.search("./*")) # FIXME: use Binding#read.
-      replace(value)
+      represented.replace(value)
     end
-    
+
     # FIXME: refactor Definition so we can simply add options in #items to existing definition.
     def representable_attrs
       attrs = super

data/representable.gemspec

@@ -23,8 +23,8 @@ Gem::Specification.new do |s|
   s.add_dependency "multi_json"
 
   s.add_development_dependency "rake"
-  s.add_development_dependency "test_xml"
-  s.add_development_dependency "minitest", ">= 2.8.1"
+  s.add_development_dependency "test_xml", ">= 0.1.6"
+  s.add_development_dependency "minitest", "~> 5.0.0"
   s.add_development_dependency "mocha", ">= 0.13.0"
   s.add_development_dependency "mongoid"
   s.add_development_dependency "virtus", "~> 0.5.0"

data/test/json_test.rb

@@ -478,90 +478,107 @@ end
 
 
   require 'representable/json/collection'
-  class CollectionRepresenterTest < MiniTest::Spec
+  require 'representable/json/hash'
+  class LonelyRepresenterTest < MiniTest::Spec
     module SongRepresenter
       include Representable::JSON
       property :name
     end
 
+    let (:decorator) { rpr = representer; Class.new(Representable::Decorator) { include rpr } }
+
     describe "JSON::Collection" do
       describe "with contained objects" do
-        before do
-          @songs_representer = Module.new do
+        let (:representer) {
+          Module.new do
             include Representable::JSON::Collection
             items :class => Song, :extend => SongRepresenter
           end
+        }
+        let (:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
+        let (:json)  { "[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]" }
+
+        it "renders array" do
+          assert_json json, songs.extend(representer).to_json
         end
 
-        it "renders objects with #to_json" do
-          assert_json "[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]", [Song.new("Days Go By"), Song.new("Can't Take Them All")].extend(@songs_representer).to_json
+        it "renders array with decorator" do
+          assert_json json, decorator.new(songs).to_json
         end
 
-        it "returns objects array from #from_json" do
-          assert_equal [Song.new("Days Go By"), Song.new("Can't Take Them All")], [].extend(@songs_representer).from_json("[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]")
+        it "parses array" do
+          [].extend(representer).from_json(json).must_equal songs
+        end
+
+        it "parses array with decorator" do
+          decorator.new([]).from_json(json).must_equal songs
         end
       end
 
       describe "with contained text" do
-        before do
-          @songs_representer = Module.new do
+        let (:representer) {
+          Module.new do
             include Representable::JSON::Collection
           end
-        end
+        }
+        let (:songs) { ["Days Go By", "Can't Take Them All"] }
+        let (:json)  { "[\"Days Go By\",\"Can't Take Them All\"]" }
 
         it "renders contained items #to_json" do
-          assert_json "[\"Days Go By\",\"Can't Take Them All\"]", ["Days Go By", "Can't Take Them All"].extend(@songs_representer).to_json
+          assert_json json, songs.extend(representer).to_json
         end
 
         it "returns objects array from #from_json" do
-          assert_equal ["Days Go By", "Can't Take Them All"], [].extend(@songs_representer).from_json("[\"Days Go By\",\"Can't Take Them All\"]")
+          [].extend(representer).from_json(json).must_equal songs
         end
       end
     end
-  end
 
 
-  require 'representable/json/hash'
-  class HashRepresenterTest < MiniTest::Spec
-    module SongRepresenter
-      include Representable::JSON
-      property :name
-    end
-
     describe "JSON::Hash" do  # TODO: move to HashTest.
       describe "with contained objects" do
-        before do
-          @songs_representer = Module.new do
+        let (:representer) {
+          Module.new do
             include Representable::JSON::Hash
             values :class => Song, :extend => SongRepresenter
           end
-        end
+        }
+        let (:json)  { "{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}" }
+        let (:songs) { {"one" => Song.new("Days Go By"), "two" => Song.new("Can't Take Them All")} }
 
         describe "#to_json" do
-          it "renders objects" do
-            assert_json "{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(@songs_representer).to_json
+          it "renders hash" do
+            songs.extend(representer).to_json.must_equal json
+          end
+
+          it "renders hash with decorator" do
+            decorator.new(songs).to_json.must_equal json
           end
 
           it "respects :exclude" do
-            assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(@songs_representer).to_json(:exclude => [:one])
+            assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:exclude => [:one])
           end
 
           it "respects :include" do
-            assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(@songs_representer).to_json(:include => [:two])
+            assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:include => [:two])
           end
         end
 
         describe "#from_json" do
           it "returns objects array" do
-            assert_equal({"one" => Song.new("Days Go By"), "two" => Song.new("Can't Take Them All")}, {}.extend(@songs_representer).from_json("{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}"))
+            {}.extend(representer).from_json(json).must_equal songs
+          end
+
+          it "parses hash with decorator" do
+            decorator.new({}).from_json(json).must_equal songs
           end
 
           it "respects :exclude" do
-            assert_equal({"two" => Song.new("Can't Take Them All")}, {}.extend(@songs_representer).from_json("{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}", :exclude => [:one]))
+            assert_equal({"two" => Song.new("Can't Take Them All")}, {}.extend(representer).from_json(json, :exclude => [:one]))
           end
 
           it "respects :include" do
-            assert_equal({"one" => Song.new("Days Go By")}, {}.extend(@songs_representer).from_json("{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}", :include => [:one]))
+            assert_equal({"one" => Song.new("Days Go By")}, {}.extend(representer).from_json(json, :include => [:one]))
           end
         end
       end

data/test/representable_test.rb

@@ -752,6 +752,12 @@ class RepresentableTest < MiniTest::Spec
         album.wont_respond_to :to_hash
         song.wont_respond_to :to_hash # DISCUSS: weak test, how to assert blank slate?
       end
+
+      describe "#decorated" do
+        it "is aliased to #represented" do
+          AlbumRepresentation.prepare(album).decorated.must_equal album
+        end
+      end
     end
 
     describe "::prepare" do

data/test/test_helper.rb

@@ -1,8 +1,6 @@
 require 'representable'
 require 'representable/json'
 require 'representable/xml'
-require 'test/unit'
-require 'minitest/spec'
 require 'minitest/autorun'
 require 'test_xml/mini_test'
 require 'mocha/setup'

data/test/xml_test.rb

@@ -5,7 +5,7 @@ class Band
   include Representable::XML
   property :name
   attr_accessor :name
-  
+
   def initialize(name=nil)
     name and self.name = name
   end
@@ -14,12 +14,12 @@ end
 class Album
   attr_accessor :songs
 end
-  
-  
+
+
 class XmlTest < MiniTest::Spec
   XML = Representable::XML
   Def = Representable::Definition
-  
+
   describe "Xml module" do
     before do
       @Band = Class.new do
@@ -29,18 +29,18 @@ class XmlTest < MiniTest::Spec
         property :label
         attr_accessor :name, :label
       end
-      
+
       @band = @Band.new
     end
-    
-    
+
+
     describe ".from_xml" do
       it "is delegated to #from_xml" do
         block = lambda {|*args|}
         @Band.any_instance.expects(:from_xml).with("<document>", "options") # FIXME: how to NOT expect block?
         @Band.from_xml("<document>", "options", &block)
       end
-      
+
       it "yields new object and options to block" do
         @Band.class_eval { attr_accessor :new_name }
         @band = @Band.from_xml("<band/>", :new_name => "Diesel Boy") do |band, options|
@@ -49,15 +49,15 @@ class XmlTest < MiniTest::Spec
         assert_equal "Diesel Boy", @band.new_name
       end
     end
-    
-    
+
+
     describe ".from_node" do
       it "is delegated to #from_node" do
         block = lambda {|*args|}
         @Band.any_instance.expects(:from_node).with("<document>", "options") # FIXME: how to expect block?
         @Band.from_node("<document>", "options", &block)
       end
-      
+
       it "yields new object and options to block" do
         @Band.class_eval { attr_accessor :new_name }
         @band = @Band.from_node(Nokogiri::XML("<band/>"), :new_name => "Diesel Boy") do |band, options|
@@ -66,105 +66,105 @@ class XmlTest < MiniTest::Spec
         assert_equal "Diesel Boy", @band.new_name
       end
     end
-    
-    
+
+
     describe "#from_xml" do
       before do
         @band = @Band.new
         @xml  = %{<band><name>Nofx</name><label>NOFX</label></band>}
       end
-      
+
       it "parses XML and assigns properties" do
         @band.from_xml(@xml)
         assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
       end
     end
-    
-    
+
+
     describe "#from_node" do
       before do
         @band = @Band.new
         @xml  = Nokogiri::XML(%{<band><name>Nofx</name><label>NOFX</label></band>}).root
       end
-      
+
       it "receives Nokogiri node and assigns properties" do
         @band.from_node(@xml)
         assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
       end
     end
-    
-    
+
+
     describe "#to_xml" do
       it "delegates to #to_node and returns string" do
         assert_xml_equal "<band><name>Rise Against</name></band>", Band.new("Rise Against").to_xml
       end
     end
-    
-    
+
+
     describe "#to_node" do
       it "returns Nokogiri node" do
         node = Band.new("Rise Against").to_node
         assert_kind_of Nokogiri::XML::Element, node
       end
-      
+
       it "wraps with infered class name per default" do
         node = Band.new("Rise Against").to_node
-        assert_xml_equal "<band><name>Rise Against</name></band>", node.to_s 
+        assert_xml_equal "<band><name>Rise Against</name></band>", node.to_s
       end
-      
+
       it "respects #representation_wrap=" do
         klass = Class.new(Band) do
           include Representable
           property :name
         end
-        
+
         klass.representation_wrap = :group
         assert_xml_equal "<group><name>Rise Against</name></group>", klass.new("Rise Against").to_node.to_s
       end
     end
-    
-    
+
+
     describe "XML::Binding#build_for" do
       it "returns AttributeBinding" do
         assert_kind_of XML::AttributeBinding, XML::PropertyBinding.build_for(Def.new(:band, :from => "band", :attribute => true), nil)
       end
-      
+
       it "returns PropertyBinding" do
         assert_kind_of XML::PropertyBinding, XML::PropertyBinding.build_for(Def.new(:band, :class => Hash), nil)
         assert_kind_of XML::PropertyBinding, XML::PropertyBinding.build_for(Def.new(:band, :from => :content), nil)
       end
-      
+
       it "returns CollectionBinding" do
         assert_kind_of XML::CollectionBinding, XML::PropertyBinding.build_for(Def.new(:band, :collection => :true), nil)
       end
-      
+
       it "returns HashBinding" do
         assert_kind_of XML::HashBinding, XML::PropertyBinding.build_for(Def.new(:band, :hash => :true), nil)
       end
     end
-    
-    
+
+
     describe "DCI" do
       module SongRepresenter
         include Representable::XML
         property :name
         representation_wrap = :song
       end
-      
+
       module AlbumRepresenter
         include Representable::XML
         property :best_song, :class => Song, :extend => SongRepresenter
         collection :songs, :class => Song, :from => :song, :extend => SongRepresenter
         representation_wrap = :album
       end
-      
-      
+
+
       it "allows adding the representer by using #extend" do
         module BandRepresenter
           include Representable::XML
           property :name
         end
-        
+
         civ = Object.new
         civ.instance_eval do
           def name; "CIV"; end
@@ -172,26 +172,26 @@ class XmlTest < MiniTest::Spec
             @name = v
           end
         end
-        
+
         civ.extend(BandRepresenter)
         assert_xml_equal "<object><name>CIV</name></object>", civ.to_xml
       end
-      
+
       it "extends contained models when serializing" do
         @album = Album.new([Song.new("I Hate My Brain"), mr=Song.new("Mr. Charisma")], mr)
         @album.extend(AlbumRepresenter)
-        
+
         assert_xml_equal "<album>
   <song><name>Mr. Charisma</name></song>
   <song><name>I Hate My Brain</name></song>
   <song><name>Mr. Charisma</name></song>
 </album>", @album.to_xml
       end
-      
+
       it "extends contained models when deserializing" do
         @album = Album.new
         @album.extend(AlbumRepresenter)
-        
+
         @album.from_xml("<album><best_song><name>Mr. Charisma</name></best_song><song><name>I Hate My Brain</name></song><song><name>Mr. Charisma</name></song></album>")
         assert_equal "Mr. Charisma", @album.best_song.name
       end
@@ -208,7 +208,7 @@ class AttributesTest < MiniTest::Spec
       property :title,  :from => "title", :attribute => true
       attr_accessor :href, :title
     end
-    
+
     it "#from_xml creates correct accessors" do
       link = Link.from_xml(%{
         <a href="http://apotomo.de" title="Home, sweet home" />
@@ -216,11 +216,11 @@ class AttributesTest < MiniTest::Spec
       assert_equal "http://apotomo.de", link.href
       assert_equal "Home, sweet home",  link.title
     end
-  
+
     it "#to_xml serializes correctly" do
       link = Link.new
       link.href = "http://apotomo.de/"
-      
+
       assert_xml_equal %{<link href="http://apotomo.de/">}, link.to_xml
     end
   end
@@ -231,15 +231,15 @@ class TypedPropertyTest < MiniTest::Spec
     include Representable::XML
     property :band, :class => Band
   end
-  
-  
+
+
   class Album
     attr_accessor :band
     def initialize(band=nil)
       @band = band
     end
   end
-  
+
   # TODO:property :group, :class => Band
   # :class
   # where to mixin DCI?
@@ -252,19 +252,19 @@ class TypedPropertyTest < MiniTest::Spec
       })
       assert_equal "Bad Religion", album.band.name
     end
-    
+
     describe "#to_xml" do
       it "doesn't escape xml from Band#to_xml" do
         band = Band.new("Bad Religion")
         album = Album.new(band).extend(AlbumRepresenter)
-        
+
         assert_xml_equal %{<album>
          <band>
            <name>Bad Religion</name>
          </band>
        </album>}, album.to_xml
       end
-      
+
       it "doesn't escape and wrap string from Band#to_node" do
         band = Band.new("Bad Religion")
         band.instance_eval do
@@ -272,7 +272,7 @@ class TypedPropertyTest < MiniTest::Spec
             "<band>Baaaad Religion</band>"
           end
         end
-        
+
         assert_xml_equal %{<album><band>Baaaad Religion</band></album>}, Album.new(band).extend(AlbumRepresenter).to_xml
       end
     end
@@ -287,7 +287,7 @@ class CollectionTest < MiniTest::Spec
       collection :bands, :class => Band, :from => :band
       attr_accessor :bands
     end
-    
+
     describe "#from_xml" do
       it "pushes collection items to array" do
         cd = Compilation.from_xml(%{
@@ -298,7 +298,7 @@ class CollectionTest < MiniTest::Spec
         })
         assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
       end
-      
+
       it "collections can be empty when default set" do
         cd = Compilation.from_xml(%{
           <compilation>
@@ -307,21 +307,21 @@ class CollectionTest < MiniTest::Spec
         assert_equal [], cd.bands
       end
     end
-    
+
     it "responds to #to_xml" do
       cd = Compilation.new
       cd.bands = [Band.new("Diesel Boy"), Band.new("Bad Religion")]
-      
+
       assert_xml_equal %{<compilation>
         <band><name>Diesel Boy</name></band>
         <band><name>Bad Religion</name></band>
       </compilation>}, cd.to_xml
     end
   end
-    
-    
+
+
   describe ":from" do
-    let(:xml) { 
+    let(:xml) {
       Module.new do
         include Representable::XML
         collection :songs, :from => :song
@@ -362,7 +362,7 @@ class CollectionTest < MiniTest::Spec
         assert_equal ["Laundry Basket", "Two Kevins", "Wright and Rong"].sort, album.songs.sort
       end
     end
-    
+
     describe "#to_xml" do
       it "wraps items" do
         album.songs = ["Laundry Basket", "Two Kevins", "Wright and Rong"]
@@ -380,12 +380,16 @@ class CollectionTest < MiniTest::Spec
   end
 
   require 'representable/xml/collection'
-  class CollectionRepresenterTest < MiniTest::Spec
+  require 'representable/xml/hash'
+  class LonelyRepresenterTest < MiniTest::Spec
+    # TODO: where is the XML::Hash test?
     module SongRepresenter
       include Representable::XML
       property :name
     end
 
+    let (:decorator) { rpr = representer; Class.new(Representable::Decorator) { include rpr; self.representation_wrap= :songs } } # FIXME: why isn't representation wrap inherited properly?
+
     describe "XML::Collection" do
       describe "with contained objects" do
         representer!(Representable::XML::Collection)  do
@@ -393,48 +397,69 @@ class CollectionTest < MiniTest::Spec
           self.representation_wrap= :songs
         end
 
-        it "renders objects with #to_xml" do
-          assert_xml_equal "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>", [Song.new("Days Go By"), Song.new("Can't Take Them All")].extend(representer).to_xml
+        let (:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
+        let (:xml)   { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
+
+        it "renders array" do
+          songs.extend(representer).to_xml.must_equal_xml xml
         end
 
-        it "returns objects array from #from_xml" do
-          assert_equal [Song.new("Days Go By"), Song.new("Can't Take Them All")], [].extend(representer).from_xml("<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>")
+        it "renders array with decorator" do
+          decorator.new(songs).to_xml.must_equal_xml xml
+        end
+
+        it "parses array" do
+          [].extend(representer).from_xml(xml).must_equal songs
+        end
+
+        it "parses array with decorator" do
+          decorator.new([]).from_xml(xml).must_equal songs
         end
       end
     end
-  end
 
-  require 'representable/xml/hash'
-  describe "XML::AttributeHash" do  # TODO: move to HashTest.
-    representer!(Representable::XML::AttributeHash) do
-      self.representation_wrap= :favs
-    end
-    
-    describe "#to_xml" do
-      it "renders values into attributes converting values to strings" do
-        assert_xml_equal "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />", {:one => :Graveyards, :two => "Can't Take Them All"}.extend(representer).to_xml
-      end
-      
-      it "respects :exclude" do
-        assert_xml_equal "<favs two=\"Can't Take Them All\" />", {:one => :Graveyards, :two => "Can't Take Them All"}.extend(representer).to_xml(:exclude => [:one])
+    describe "XML::AttributeHash" do  # TODO: move to HashTest.
+      representer!(Representable::XML::AttributeHash) do
+        self.representation_wrap= :songs
       end
-      
-      it "respects :include" do
-        assert_xml_equal "<favs two=\"Can't Take Them All\" />", {:one => :Graveyards, :two => "Can't Take Them All"}.extend(representer).to_xml(:include => [:two])
+
+      let (:songs) { {"one" => "Graveyards", "two" => "Can't Take Them All"} }
+      let (:xml)   { "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
+
+      describe "#to_xml" do
+        it "renders hash" do
+          songs.extend(representer).to_xml.must_equal_xml xml
+        end
+
+        it "respects :exclude" do
+          assert_xml_equal "<favs two=\"Can't Take Them All\" />", songs.extend(representer).to_xml(:exclude => [:one])
+        end
+
+        it "respects :include" do
+          assert_xml_equal "<favs two=\"Can't Take Them All\" />", songs.extend(representer).to_xml(:include => [:two])
+        end
+
+        it "renders hash with decorator" do
+          decorator.new(songs).to_xml.must_equal_xml xml
+        end
       end
-    end
-    
-    describe "#from_json" do
-      it "returns hash" do
-        assert_equal({"one" => "Graveyards", "two" => "Can't Take Them All"}, {}.extend(representer).from_xml("<favs one=\"Graveyards\" two=\"Can't Take Them All\" />"))
-      end
-    
-      it "respects :exclude" do
-        assert_equal({"two" => "Can't Take Them All"}, {}.extend(representer).from_xml("<favs one=\"Graveyards\" two=\"Can't Take Them All\" />", :exclude => [:one]))
-      end
-      
-      it "respects :include" do
-        assert_equal({"one" => "Graveyards"}, {}.extend(representer).from_xml("<favs one=\"Graveyards\" two=\"Can't Take Them All\" />", :include => [:one]))
+
+      describe "#from_json" do
+        it "returns hash" do
+          {}.extend(representer).from_xml(xml).must_equal songs
+        end
+
+        it "respects :exclude" do
+          assert_equal({"two" => "Can't Take Them All"}, {}.extend(representer).from_xml(xml, :exclude => [:one]))
+        end
+
+        it "respects :include" do
+          assert_equal({"one" => "Graveyards"}, {}.extend(representer).from_xml(xml, :include => [:one]))
+        end
+
+        it "parses hash with decorator" do
+          decorator.new({}).from_xml(xml).must_equal songs
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: representable
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-04 00:00:00.000000000 Z
+date: 2013-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -66,7 +66,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -74,23 +74,23 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.6
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.1
+        version: 5.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.1
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement