representable 1.2.3 → 1.2.4

data/.gitignore

@@ -5,3 +5,8 @@ doc
 Rake.config
 pkg
 .project
+.bundle
+Gemfile.lock
+*.swp
+*.swo
+bin

data/.travis.yml

@@ -1,3 +1,9 @@
-rvm: 1.9.2
 notifications:
   irc: "irc.freenode.org#cells"
+matrix:
+  include:
+    - rvm: 1.8.7
+      gemfile: gemfiles/Gemfile.mongoid-2.4
+    - rvm: 1.9.3
+      gemfile: Gemfile
+    

data/CHANGES.textile

@@ -1,3 +1,8 @@
+h2. 1.2.4
+
+* ObjectBinding no longer tries to extend nil values when rendering and @:render_nil@ is set.
+* In XML you can now use @:wrap@ to define an additional container tag around properties and collections.
+
 h2. 1.2.3
 
 * Using virtus for coercion now works in both classes and modules. Thanks to @solnic for a great collaboration. Open-source rocks!

data/README.rdoc

@@ -15,7 +15,7 @@ This keeps your representation knowledge in one place when implementing REST ser
 * Bidirectional - rendering and parsing
 * OOP access to documents
 * Support for JSON and XML
-* Coercion support with virtus[https://github.com/solnic/virtus.]
+* Coercion support with virtus[https://github.com/solnic/virtus]
 
 
 == Example
@@ -317,6 +317,26 @@ You can also map properties to tag attributes in representable.
 
 Naturally, this works for both ways.
 
+=== Wrapping collections
+
+It is sometimes unavoidable to wrap tag lists in a container tag.
+
+  module AlbumRepresenter
+    include Representable::XML
+
+    collection :songs, :from => :song, :wrap => :songs
+  end
+
+Note that +:wrap+ defines the container tag name.
+
+  Album.new.to_xml #=> 
+    <album>
+      <songs>
+        <song>Laundry Basket</song>
+        <song>Two Kevins</song>
+        <song>Wright and Rong</song>
+      </songs>
+    </album>
 
 == Coercion
 

data/gemfiles/Gemfile.mongoid-2.4

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in roar-rails.gemspec
+gemspec :path => '../'
+
+gem 'mongoid', '~> 2.4.0'

data/lib/representable/binding.rb

@@ -44,5 +44,25 @@ module Representable
         object
       end
     end
+    
+    module Object
+      include Binding::Extend  # provides #serialize/#deserialize with extend.
+      
+      def serialize(object)
+        return object if object.nil?
+        
+        super(object).send(serialize_method, :wrap => false)
+      end
+      
+      def deserialize(data) 
+        # DISCUSS: does it make sense to skip deserialization of nil-values here?
+        super(create_object).send(deserialize_method, data)
+      end
+      
+      def create_object
+        definition.sought_type.new
+      end
+    end
+    
   end
 end

data/lib/representable/bindings/json_bindings.rb

@@ -3,19 +3,14 @@ require 'representable/binding'
 module Representable
   module JSON
     module ObjectBinding
-      # TODO: provide a base ObjectBinding for XML/JSON/MP.
-      include Binding::Extend  # provides #serialize/#deserialize with extend.
+      include Binding::Object
       
-      def serialize(object)
-        super(object).to_hash(:wrap => false)
+      def serialize_method
+        :to_hash
       end
       
-      def deserialize(hash)
-        super(create_object).from_hash(hash)
-      end
-      
-      def create_object
-        definition.sought_type.new
+      def deserialize_method
+        :from_hash
       end
     end
     

data/lib/representable/bindings/xml_bindings.rb

@@ -3,15 +3,14 @@ require 'representable/binding'
 module Representable
   module XML
     module ObjectBinding
-      # TODO: provide a base ObjectBinding for XML/JSON/MP.
-      include Binding::Extend  # provides #serialize/#deserialize with extend.
+      include Binding::Object
       
-      def serialize(object)
-        super(object).to_node(:wrap => false)
+      def serialize_method
+        :to_node
       end
       
-      def deserialize(hash)
-        super(create_object).from_node(hash)
+      def deserialize_method
+        :from_node
       end
       
       def deserialize_node(node)
@@ -21,10 +20,6 @@ module Representable
       def serialize_node(node, value)
         serialize(value)
       end
-      
-      def create_object
-        definition.sought_type.new
-      end
     end
     
     
@@ -35,11 +30,20 @@ module Representable
       end
       
       def write(parent, value)
-        parent << serialize_for(value, parent)
+        wrap_node = parent
+        
+        if wrap = definition.options[:wrap]
+          parent << wrap_node = node_for(parent, wrap)
+        end
+
+        wrap_node << serialize_for(value, parent)
       end
       
       def read(node)
-        nodes = node.search("./#{xpath}")
+        selector  = "./#{xpath}"
+        selector  = "./#{definition.options[:wrap]}/#{xpath}" if definition.options[:wrap]
+        nodes     = node.search(selector)
+
         return FragmentNotFound if nodes.size == 0 # TODO: write dedicated test!
         
         deserialize_from(nodes)
@@ -48,7 +52,7 @@ module Representable
       # Creates wrapped node for the property.
       def serialize_for(value, parent)
       #def serialize_for(value, parent, tag_name=definition.from)
-        node =  Nokogiri::XML::Node.new(definition.from, parent.document)
+        node = node_for(parent, definition.from)
         serialize_node(node, value)
       end
       
@@ -70,19 +74,16 @@ module Representable
       def xpath
         definition.from
       end
+
+      def node_for(parent, name)
+        Nokogiri::XML::Node.new(name.to_s, parent.document)
+      end
     end
     
     class CollectionBinding < PropertyBinding
-      def write(parent, value)
-        serialize_items(value, parent).each do |node|
-          parent << node
-        end
-      end
-      
-      def serialize_items(value, parent)
-        value.collect do |obj|
-          serialize_for(obj, parent)
-        end
+      def serialize_for(value, parent)
+        # return NodeSet so << works.
+        set_for(parent, value.collect { |item| super(item, parent) })
       end
       
       def deserialize_from(nodes)
@@ -90,15 +91,20 @@ module Representable
           deserialize_node(item)
         end
       end
+
+    private
+      def set_for(parent, nodes)
+        Nokogiri::XML::NodeSet.new(parent.document, nodes)
+      end
     end
     
     
     class HashBinding < CollectionBinding
-      def serialize_items(value, parent)
-        value.collect do |k, v|
-          node = Nokogiri::XML::Node.new(k, parent.document)
+      def serialize_for(value, parent)
+        set_for(parent, value.collect do |k, v|
+          node = node_for(parent, k)
           serialize_node(node, v)
-        end
+        end)
       end
       
       def deserialize_from(nodes)

data/lib/representable/json/hash.rb

@@ -4,24 +4,24 @@ module Representable::JSON
   module Hash
     include Representable::JSON
     include HashMethods
-    
+
     def self.included(base)
       base.class_eval do
         include Representable
         extend ClassMethods
       end
     end
-    
-    
+
+
     module ClassMethods
       def values(options)
         hash :_self, options
       end
     end
-    
-    
+
+
     def definition_opts
-      [:_self, :hash => true, :use_attributes => true]
+      [:_self, {:hash => true, :use_attributes => true}]
     end
   end
 end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "1.2.3"
+  VERSION = "1.2.4"
 end

data/lib/representable/xml/hash.rb

@@ -4,48 +4,48 @@ module Representable::XML
   module AttributeHash
     include Representable::XML
     include Representable::HashMethods
-    
+
     def self.included(base)
       base.class_eval do
         include Representable
         extend ClassMethods
       end
     end
-    
-    
+
+
     module ClassMethods
       def values(options)
         hash :_self, options.merge!(:use_attributes => true)
       end
     end
-    
-    
+
+
     def definition_opts
-      [:_self, :hash => true, :use_attributes => true]
+      [:_self, {:hash => true, :use_attributes => true}]
     end
   end
-  
+
   module Hash
     include Representable::XML
     include HashMethods
-    
+
     def self.included(base)
       base.class_eval do
         include Representable
         extend ClassMethods
       end
     end
-    
-    
+
+
     module ClassMethods
       def values(options)
         hash :_self, options
       end
     end
-    
-    
+
+
    def definition_opts
-      [:_self, :hash => true]
+      [:_self, {:hash => true}]
     end
   end
 end

data/test/json_test.rb

@@ -4,7 +4,7 @@ module JsonTest
   class APITest < MiniTest::Spec
     Json = Representable::JSON
     Def = Representable::Definition
-    
+
     describe "JSON module" do
       before do
         @Band = Class.new do
@@ -12,23 +12,23 @@ module JsonTest
           property :name
           property :label
           attr_accessor :name, :label
-          
+
           def initialize(name=nil)
             self.name = name if name
           end
         end
-        
+
         @band = @Band.new
       end
-    
-    
+
+
       describe ".from_json" do
         it "is delegated to #from_json" do
           block = lambda {|*args|}
           @Band.any_instance.expects(:from_json).with("{document}", "options") # FIXME: how to NOT expect block?
           @Band.from_json("{document}", "options", &block)
         end
-        
+
         it "yields new object and options to block" do
           @Band.class_eval { attr_accessor :new_name }
           @band = @Band.from_json("{}", :new_name => "Diesel Boy") do |band, options|
@@ -37,113 +37,113 @@ module JsonTest
           assert_equal "Diesel Boy", @band.new_name
         end
       end
-      
-      
+
+
       describe ".from_hash" do
         it "is delegated to #from_hash not passing the block" do
           block = lambda {|*args|}
           @Band.any_instance.expects(:from_hash).with("{document}", "options") # FIXME: how to NOT expect block?
           @Band.from_hash("{document}", "options", &block)
         end
-        
+
         it "yields new object and options to block" do
           @Band.class_eval { attr_accessor :new_name }
           @band = @Band.from_hash({}, :new_name => "Diesel Boy") do |band, options|
             band.new_name= options[:new_name]
           end
-          
+
           assert_equal "Diesel Boy", @band.new_name
         end
       end
-      
-      
+
+
       describe "#from_json" do
         before do
           @band = @Band.new
           @json  = {:name => "Nofx", :label => "NOFX"}.to_json
         end
-        
+
         it "parses JSON and assigns properties" do
           @band.from_json(@json)
           assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
         end
       end
-      
-      
+
+
       describe "#from_hash" do
         before do
           @band = @Band.new
           @hash  = {"name" => "Nofx", "label" => "NOFX"}
         end
-        
+
         it "receives hash and assigns properties" do
           @band.from_hash(@hash)
           assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
         end
-        
+
         it "respects :wrap option" do
           @band.from_hash({"band" => {"name" => "This Is A Standoff"}}, :wrap => :band)
           assert_equal "This Is A Standoff", @band.name
         end
-          
+
         it "respects :wrap option over representation_wrap" do
           @Band.class_eval do
-            self.representation_wrap = :group 
+            self.representation_wrap = :group
           end
           @band.from_hash({"band" => {"name" => "This Is A Standoff"}}, :wrap => :band)
           assert_equal "This Is A Standoff", @band.name
         end
       end
-      
-      
+
+
       describe "#to_json" do
         it "delegates to #to_hash and returns string" do
-          assert_equal "{\"name\":\"Rise Against\"}", @Band.new("Rise Against").to_json
+          assert_json "{\"name\":\"Rise Against\"}", @Band.new("Rise Against").to_json
         end
       end
-      
-      
+
+
       describe "#to_hash" do
         it "returns unwrapped hash" do
           hash = @Band.new("Rise Against").to_hash
           assert_equal({"name"=>"Rise Against"}, hash)
         end
-        
+
         it "respects #representation_wrap=" do
           @Band.representation_wrap = :group
           assert_equal({:group=>{"name"=>"Rise Against"}}, @Band.new("Rise Against").to_hash)
         end
-        
+
         it "respects :wrap option" do
           assert_equal({:band=>{"name"=>"NOFX"}}, @Band.new("NOFX").to_hash(:wrap => :band))
         end
-          
+
         it "respects :wrap option over representation_wrap" do
           @Band.class_eval do
-            self.representation_wrap = :group 
+            self.representation_wrap = :group
           end
           assert_equal({:band=>{"name"=>"Rise Against"}}, @Band.new("Rise Against").to_hash(:wrap => :band))
         end
       end
-        
+
       describe "#binding_for_definition" do
         it "returns ObjectBinding" do
           assert_kind_of Json::ObjectBinding, Json.binding_for_definition(Def.new(:band, :class => Hash))
         end
-        
+
         it "returns TextBinding" do
           assert_kind_of Json::PropertyBinding, Json.binding_for_definition(Def.new(:band))
         end
-        
+
         it "returns HashBinding" do
           assert_kind_of Json::HashBinding, Json.binding_for_definition(Def.new(:band, :hash => true))
         end
-        
+
         it "returns CollectionBinding" do
           assert_kind_of Json::CollectionBinding, Json.binding_for_definition(Def.new(:band, :collection => true))
         end
       end
-      
+
       describe "#representable_bindings" do
         it "returns bindings for each property" do
           assert_equal 2, @band.send(:representable_bindings_for, Json).size
@@ -151,27 +151,27 @@ module JsonTest
         end
       end
     end
-    
-    
+
+
     describe "DCI" do
       module SongRepresenter
         include Representable::JSON
         property :name
       end
-      
+
       module AlbumRepresenter
         include Representable::JSON
         property :best_song, :class => Song, :extend => SongRepresenter
         collection :songs, :class => Song, :extend => [SongRepresenter]
       end
-      
-      
+
+
       it "allows adding the representer by using #extend" do
         module BandRepresenter
           include Representable::JSON
           property :name
         end
-        
+
         civ = Object.new
         civ.instance_eval do
           def name; "CIV"; end
@@ -179,30 +179,30 @@ module JsonTest
             @name = v
           end
         end
-        
+
         civ.extend(BandRepresenter)
-        assert_equal "{\"name\":\"CIV\"}", civ.to_json
+        assert_json "{\"name\":\"CIV\"}", civ.to_json
       end
-      
+
       it "extends contained models when serializing" do
         @album = Album.new(Song.new("I Hate My Brain"), Song.new("Mr. Charisma"))
         @album.extend(AlbumRepresenter)
-        
-        assert_equal "{\"best_song\":{\"name\":\"Mr. Charisma\"},\"songs\":[{\"name\":\"I Hate My Brain\"},{\"name\":\"Mr. Charisma\"}]}", @album.to_json
+
+        assert_json "{\"best_song\":{\"name\":\"Mr. Charisma\"},\"songs\":[{\"name\":\"I Hate My Brain\"},{\"name\":\"Mr. Charisma\"}]}", @album.to_json
       end
-      
+
       it "extends contained models when deserializing" do
         #@album = Album.new(Song.new("I Hate My Brain"), Song.new("Mr. Charisma"))
         @album = Album.new
         @album.extend(AlbumRepresenter)
-        
+
         @album.from_json("{\"best_song\":{\"name\":\"Mr. Charisma\"},\"songs\":[{\"name\":\"I Hate My Brain\"},{\"name\":\"Mr. Charisma\"}]}")
         assert_equal "Mr. Charisma", @album.best_song.name
       end
     end
   end
-  
-  
+
+
   class PropertyTest < MiniTest::Spec
     describe "property :name" do
       class Band
@@ -210,45 +210,45 @@ module JsonTest
         property :name
         attr_accessor :name
       end
-      
+
       it "#from_json creates correct accessors" do
         band = Band.from_json({:name => "Bombshell Rocks"}.to_json)
         assert_equal "Bombshell Rocks", band.name
       end
-      
+
       it "#to_json serializes correctly" do
         band = Band.new
         band.name = "Cigar"
-        
-        assert_equal '{"name":"Cigar"}', band.to_json
+
+        assert_json '{"name":"Cigar"}', band.to_json
       end
     end
-    
+
     describe ":class => Item" do
       class Label
         include Representable::JSON
         property :name
         attr_accessor :name
       end
-      
+
       class Album
         include Representable::JSON
         property :label, :class => Label
         attr_accessor :label
       end
-      
+
       it "#from_json creates one Item instance" do
         album = Album.from_json('{"label":{"name":"Fat Wreck"}}')
         assert_equal "Fat Wreck", album.label.name
       end
-      
+
       it "#to_json serializes" do
         label = Label.new; label.name = "Fat Wreck"
         album = Album.new; album.label = label
-        
-        assert_equal '{"label":{"name":"Fat Wreck"}}', album.to_json
+
+        assert_json '{"label":{"name":"Fat Wreck"}}', album.to_json
       end
-      
+
       describe ":different_name, :class => Label" do
         before do
           @Album = Class.new do
@@ -257,34 +257,34 @@ module JsonTest
             attr_accessor :seller
           end
         end
-        
+
         it "#to_xml respects the different name" do
           label = Label.new; label.name = "Fat Wreck"
           album = @Album.new; album.seller = label
-          
-          assert_equal "{\"seller\":{\"name\":\"Fat Wreck\"}}", album.to_json(:wrap => false)
+
+          assert_json "{\"seller\":{\"name\":\"Fat Wreck\"}}", album.to_json(:wrap => false)
         end
       end
     end
-    
+
     describe ":from => :songName" do
       class Song
         include Representable::JSON
         property :name, :from => :songName
         attr_accessor :name
       end
-      
+
       it "respects :from in #from_json" do
         song = Song.from_json({:songName => "Run To The Hills"}.to_json)
         assert_equal "Run To The Hills", song.name
       end
-      
+
       it "respects :from in #to_json" do
         song = Song.new; song.name = "Run To The Hills"
-        assert_equal '{"songName":"Run To The Hills"}', song.to_json
+        assert_json '{"songName":"Run To The Hills"}', song.to_json
       end
     end
-    
+
     describe ":default => :value" do
       before do
         @Album = Class.new do
@@ -293,39 +293,39 @@ module JsonTest
         attr_accessor :name
       end
     end
-      
+
     describe "#from_json" do
       it "uses default when property nil in doc" do
         album = @Album.from_json({}.to_json)
         assert_equal "30 Years Live", album.name
       end
-      
+
       it "uses value from doc when present" do
         album = @Album.from_json({:name => "Live At The Wireless"}.to_json)
         assert_equal "Live At The Wireless", album.name
       end
-      
+
       it "uses value from doc when empty string" do
         album = @Album.from_json({:name => ""}.to_json)
         assert_equal "", album.name
       end
     end
-    
+
     describe "#to_json" do
       it "uses default when not available in object" do
-        assert_equal "{\"name\":\"30 Years Live\"}", @Album.new.to_json
+        assert_json "{\"name\":\"30 Years Live\"}", @Album.new.to_json
       end
-      
+
       it "uses value from represented object when present" do
         album = @Album.new
         album.name = "Live At The Wireless"
-        assert_equal "{\"name\":\"Live At The Wireless\"}", album.to_json
+        assert_json "{\"name\":\"Live At The Wireless\"}", album.to_json
       end
-      
+
       it "uses value from represented object when emtpy string" do
         album = @Album.new
         album.name = ""
-        assert_equal "{\"name\":\"\"}", album.to_json
+        assert_json "{\"name\":\"\"}", album.to_json
       end
     end
   end
@@ -339,37 +339,37 @@ end
         collection :songs
         attr_accessor :songs
       end
-      
+
       it "#from_json creates correct accessors" do
         cd = CD.from_json({:songs => ["Out in the cold", "Microphone"]}.to_json)
         assert_equal ["Out in the cold", "Microphone"], cd.songs
       end
-    
+
       it "#to_json serializes correctly" do
         cd = CD.new
         cd.songs = ["Out in the cold", "Microphone"]
-        
-        assert_equal '{"songs":["Out in the cold","Microphone"]}', cd.to_json
+
+        assert_json '{"songs":["Out in the cold","Microphone"]}', cd.to_json
       end
     end
-    
+
     describe "collection :name, :class => Band" do
       class Band
         include Representable::JSON
         property :name
         attr_accessor :name
-        
+
         def initialize(name="")
           self.name = name
         end
       end
-      
+
       class Compilation
         include Representable::JSON
         collection :bands, :class => Band
         attr_accessor :bands
       end
-      
+
       describe "#from_json" do
         it "pushes collection items to array" do
           cd = Compilation.from_json({:bands => [
@@ -377,43 +377,43 @@ end
             {:name => "Diesel Boy"}]}.to_json)
           assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
         end
-        
+
         it "creates emtpy array from default if configured" do
           cd = Compilation.from_json({}.to_json)
           assert_equal [], cd.bands
         end
       end
-      
+
       it "responds to #to_json" do
         cd = Compilation.new
         cd.bands = [Band.new("Diesel Boy"), Band.new("Bad Religion")]
-        
-        assert_equal '{"bands":[{"name":"Diesel Boy"},{"name":"Bad Religion"}]}', cd.to_json
+
+        assert_json '{"bands":[{"name":"Diesel Boy"},{"name":"Bad Religion"}]}', cd.to_json
       end
     end
-    
-    
+
+
     describe ":from => :songList" do
       class Songs
         include Representable::JSON
         collection :tracks, :from => :songList
         attr_accessor :tracks
       end
-      
+
       it "respects :from in #from_json" do
         songs = Songs.from_json({:songList => ["Out in the cold", "Microphone"]}.to_json)
         assert_equal ["Out in the cold", "Microphone"], songs.tracks
       end
-    
+
       it "respects option in #to_json" do
         songs = Songs.new
         songs.tracks = ["Out in the cold", "Microphone"]
-        
-        assert_equal '{"songList":["Out in the cold","Microphone"]}', songs.to_json
+
+        assert_json '{"songList":["Out in the cold","Microphone"]}', songs.to_json
       end
     end
   end
-  
+
   class HashTest < MiniTest::Spec
     describe "hash :songs" do
       before do
@@ -421,34 +421,34 @@ end
           include Representable::JSON
           hash :songs
         end
-        
+
         class SongList
           attr_accessor :songs
         end
-        
+
         @list = SongList.new.extend(representer)
       end
-      
+
       it "renders with #to_json" do
         @list.songs = {:one => "65", :two => "Emo Boy"}
-        assert_equal "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}", @list.to_json
+        assert_json "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}", @list.to_json
       end
-      
+
       it "parses with #from_json" do
         assert_equal({"one" => "65", "two" => ["Emo Boy"]}, @list.from_json("{\"songs\":{\"one\":\"65\",\"two\":[\"Emo Boy\"]}}").songs)
       end
     end
-    
+
   end
-  
-  
+
+
   require 'representable/json/collection'
   class CollectionRepresenterTest < MiniTest::Spec
     module SongRepresenter
       include Representable::JSON
       property :name
     end
-    
+
     describe "JSON::Collection" do
       describe "with contained objects" do
         before do
@@ -457,42 +457,42 @@ end
             items :class => Song, :extend => SongRepresenter
           end
         end
-        
+
         it "renders objects with #to_json" do
-          assert_equal "[{\"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
+          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
         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\"}]")
         end
       end
-      
+
       describe "with contained text" do
         before do
           @songs_representer = Module.new do
             include Representable::JSON::Collection
           end
         end
-        
+
         it "renders contained items #to_json" do
-          assert_equal "[\"Days Go By\",\"Can't Take Them All\"]", ["Days Go By", "Can't Take Them All"].extend(@songs_representer).to_json
+          assert_json "[\"Days Go By\",\"Can't Take Them All\"]", ["Days Go By", "Can't Take Them All"].extend(@songs_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\"]")
         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
@@ -501,47 +501,47 @@ end
             values :class => Song, :extend => SongRepresenter
           end
         end
-        
+
         describe "#to_json" do
           it "renders objects" do
-            assert_equal "{\"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
+            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
           end
-          
+
           it "respects :exclude" do
-            assert_equal "{\"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(@songs_representer).to_json(:exclude => [:one])
           end
-          
+
           it "respects :include" do
-            assert_equal "{\"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(@songs_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\"}}"))
           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]))
           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]))
           end
         end
       end
-      
+
       describe "with contained text" do
         before do
           @songs_representer = Module.new do
             include Representable::JSON::Collection
           end
         end
-        
+
         it "renders contained items #to_json" do
-          assert_equal "[\"Days Go By\",\"Can't Take Them All\"]", ["Days Go By", "Can't Take Them All"].extend(@songs_representer).to_json
+          assert_json "[\"Days Go By\",\"Can't Take Them All\"]", ["Days Go By", "Can't Take Them All"].extend(@songs_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\"]")
         end

data/test/representable_test.rb

@@ -63,7 +63,7 @@ class RepresentableTest < MiniTest::Spec
         end.new
         vd.name        = "Vention Dention"
         vd.street_cred = 1
-        assert_equal "{\"name\":\"Vention Dention\",\"street_cred\":1}", vd.to_json
+        assert_json "{\"name\":\"Vention Dention\",\"street_cred\":1}", vd.to_json
       end
       
       #it "allows including the concrete representer module only" do
@@ -113,7 +113,7 @@ class RepresentableTest < MiniTest::Spec
       band = Bodyjar.new
       band.name = "Bodyjar"
       
-      assert_equal "{\"band\":{\"name\":\"Bodyjar\"}}", band.to_json
+      assert_json "{\"band\":{\"name\":\"Bodyjar\"}}", band.to_json
       assert_xml_equal "<band><name>Bodyjar</name></band>", band.to_xml
     end
     
@@ -130,7 +130,7 @@ class RepresentableTest < MiniTest::Spec
       
       @song = Song.new("Days Go By")
       assert_xml_equal "<song name=\"Days Go By\"/>", @song.extend(SongXmlRepresenter).to_xml
-      assert_equal "{\"name\":\"Days Go By\"}", @song.extend(SongJsonRepresenter).to_json
+      assert_json "{\"name\":\"Days Go By\"}", @song.extend(SongJsonRepresenter).to_json
     end
   end
   
@@ -310,17 +310,32 @@ class RepresentableTest < MiniTest::Spec
       assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.send(:create_representation_with, {}, {}, Representable::JSON))
     end
     
-    it "includes nil attribute when :render_nil is true" do
-      mod = Module.new do
-        include Representable::JSON
-        property :name
-        property :groupies, :render_nil => true
+    describe "when :render_nil is true" do
+      it "includes nil attribute" do
+        mod = Module.new do
+          include Representable::JSON
+          property :name
+          property :groupies, :render_nil => true
+        end
+        
+        @band.extend(mod) # FIXME: use clean object.
+        @band.groupies = nil
+        hash = @band.send(:create_representation_with, {}, {}, Representable::JSON)
+        assert_equal({"name"=>"No One's Choice", "groupies" => nil}, hash)
       end
       
-      @band.extend(mod) # FIXME: use clean object.
-      @band.groupies = nil
-      hash = @band.send(:create_representation_with, {}, {}, Representable::JSON)
-      assert_equal({"name"=>"No One's Choice", "groupies" => nil}, hash)
+      it "includes nil attribute without extending" do
+        mod = Module.new do
+          include Representable::JSON
+          property :name
+          property :groupies, :render_nil => true, :extend => BandRepresentation
+        end
+        
+        @band.extend(mod) # FIXME: use clean object.
+        @band.groupies = nil
+        hash = @band.send(:create_representation_with, {}, {}, Representable::JSON)
+        assert_equal({"name"=>"No One's Choice", "groupies" => nil}, hash)
+      end
     end
   end
   

data/test/test_helper.rb

@@ -24,7 +24,7 @@ class Song
   def initialize(name=nil)
     @name = name
   end
-  
+
   def ==(other)
     name == other.name
   end
@@ -36,6 +36,16 @@ module XmlHelper
   end
 end
 
+module AssertJson
+  module Assertions
+    def assert_json(expected, actual, msg=nil)
+      msg = message(msg, "") { diff expected, actual }
+      assert(expected.split("").sort == actual.split("").sort, msg)
+    end
+  end
+end
+
 MiniTest::Spec.class_eval do
+  include AssertJson::Assertions
   include XmlHelper
 end

data/test/test_helper_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class TestHelperTest < MiniTest::Spec
+  describe "#assert_json" do
+    it "tests for equality" do
+      assert_json "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}", "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}"
+    end
+    
+    it "allows different key orders" do
+      assert_json "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}", "{\"songs\":{\"two\":\"Emo Boy\",\"one\":\"65\"}}"
+    end
+    
+    it "complains when expected hash is subset" do
+      assert_raises MiniTest::Assertion do
+        assert_json "{\"songs\":{\"one\":\"65\"}}", "{\"songs\":{\"two\":\"Emo Boy\",\"one\":\"65\"}}"
+      end
+    end
+    
+    it "complains when source hash is subset" do
+      assert_raises MiniTest::Assertion do
+        assert_json "{\"songs\":{\"two\":\"Emo Boy\",\"one\":\"65\"}}", "{\"songs\":{\"one\":\"65\"}}"
+      end
+    end
+  end
+end

data/test/xml_test.rb

@@ -11,7 +11,9 @@ class Band
   end
 end
 
-
+class Album
+  attr_accessor :songs
+end
   
   
 class XmlTest < MiniTest::Spec
@@ -319,14 +321,14 @@ class CollectionTest < MiniTest::Spec
     
     
   describe ":from" do
-    class Album
-      include Representable::XML
-      collection :songs, :from => :song
-      attr_accessor :songs
-    end
+    let(:xml) { 
+      Module.new do
+        include Representable::XML
+        collection :songs, :from => :song
+      end }
 
     it "collects untyped items" do
-      album = Album.from_xml(%{
+      album = Album.new.extend(xml).from_xml(%{
         <album>
           <song>Two Kevins</song>
           <song>Wright and Rong</song>
@@ -336,6 +338,46 @@ class CollectionTest < MiniTest::Spec
       assert_equal ["Laundry Basket", "Two Kevins", "Wright and Rong"].sort, album.songs.sort
     end
   end
+
+
+  describe ":wrap" do
+    let (:album) { Album.new.extend(xml) }
+    let (:xml) {
+      Module.new do
+        include Representable::XML
+        collection :songs, :from => :song, :wrap => :songs
+      end }
+
+    describe "#from_xml" do
+      it "finds items in wrapped collection" do
+        album.from_xml(%{
+          <album>
+            <songs>
+              <song>Two Kevins</song>
+              <song>Wright and Rong</song>
+              <song>Laundry Basket</song>
+            </songs>
+          </album>
+        })
+        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"]
+        assert_xml_equal %{
+          <album>
+            <songs>
+              <song>Laundry Basket</song>
+              <song>Two Kevins</song>
+              <song>Wright and Rong</song>
+            </songs>
+          </album>
+        }, album.to_xml
+      end
+    end
+  end
   
   require 'representable/xml/hash'
   describe "XML::AttributeHash" do  # TODO: move to HashTest.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: representable
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-09 00:00:00.000000000 Z
+date: 2012-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -155,6 +155,7 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
+- gemfiles/Gemfile.mongoid-2.4
 - lib/representable.rb
 - lib/representable/binding.rb
 - lib/representable/bindings/json_bindings.rb
@@ -179,6 +180,7 @@ files:
 - test/polymorphic_test.rb
 - test/representable_test.rb
 - test/test_helper.rb
+- test/test_helper_test.rb
 - test/xml_bindings_test.rb
 - test/xml_test.rb
 homepage: http://representable.apotomo.de