representable 0.9.3 → 0.10.0

data/CHANGES.textile

@@ -1,3 +1,10 @@
+h2. 0.10.0
+
+* Wrapping can now be set through @Representable.representation_wrap=@. Possible values are:
+  * @false@: No wrapping. In XML context, this is undefined behaviour. Default in JSON.
+  * @String@: Wrap with provided string.
+  * @true@: compute wrapper from class name.
+
 h2. 0.9.3
 
 * Removed the @:as => [..]@ syntax in favor of @:array => true@.

data/README.rdoc

@@ -1,6 +1,6 @@
 = Representable
 
-<em>Maps representation documents from and to Ruby objects.</em>
+<em>Maps documents to Ruby objects and back.</em>
 
 
 == Introduction
@@ -9,8 +9,18 @@ _Representable_ maps fragments in documents to attributes in Ruby objects and ba
 
 This is especially helpful when implementing REST services and clients and keeps your representation knowledge in one place.
 
+
+== Features
+
+* Bidirectional - rendering and parsing
+* OOP documents
+* Support for JSON and XML
+
+
 == Example
 
+
+
 When writing a REST service you'd have to parse and extract data from an incoming representation document manually. Given the following XML document which represents an order.
 
   <order>

data/lib/representable.rb

@@ -1,18 +1,17 @@
 require 'hooks/inheritable_attribute'
 require 'representable/definition'
-require 'representable/nokogiri_extensions'
-
 
 module Representable
   def self.included(base)
     base.class_eval do
-      extend  ClassMethods::Accessors, ClassMethods::Declarations
+      extend ClassMethods::Declarations
+      extend ClassMethods::Accessors
       
       extend Hooks::InheritableAttribute
       inheritable_attr :representable_attrs
       self.representable_attrs = []
       
-      inheritable_attr :explicit_representation_name  # FIXME: move to Accessors.
+      inheritable_attr :representable_wrap
     end
   end
   
@@ -85,12 +84,20 @@ private
     end
 
     module Accessors
-      def representation_name=(name)
-        self.explicit_representation_name = name
+      def representation_wrap=(name)
+        self.representable_wrap = name
+      end
+      
+      # Returns the wrapper for the representation. Mostly used in XML.
+      def representation_wrap
+        return unless representable_wrap
+        return infer_representation_name if representable_wrap === true
+        representable_wrap
       end
       
-      def representation_name
-        explicit_representation_name or name.split('::').last.
+    private
+      def infer_representation_name
+        name.split('::').last.
          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
          gsub(/([a-z\d])([A-Z])/,'\1_\2').
          downcase

data/lib/representable/bindings/json_bindings.rb

@@ -44,9 +44,9 @@ module Representable
     class ObjectBinding < Binding
       def write(hash, value)
         if definition.array?
-          hash.merge!({definition.from => value.collect {|v| v.to_hash(:wrap => false)}})
+          hash[definition.from] = value.collect {|v| v.to_hash(:wrap => false)}
         else
-          hash.merge! value.to_hash
+          hash[definition.from] = value.to_hash(:wrap => false)
         end
       end
 

data/lib/representable/bindings/xml_bindings.rb

@@ -8,8 +8,6 @@ module Representable
       end
       
       def read(xml)
-        xml = Nokogiri::XML::Node.from(xml) or return default
-        
         value_from_node(xml) or default
       end
       
@@ -22,16 +20,6 @@ module Representable
         definition.from
       end
 
-      def wrap(xml, opts = {:always_create => false})
-        wrap_with = @auto_vals ? auto_wrapper : definition.wrapper
-
-        return xml if !wrap_with || xml.name == wrap_with
-        if !opts[:always_create] && (child = xml.children.find {|c| c.name == wrap_with })
-         return child
-        end
-        xml.add_node(wrap_with.to_s)
-      end
-
       def collect_for(xml)
         nodes = xml.search("./#{xpath}")
         vals  = nodes.collect { |node| yield node }
@@ -44,9 +32,7 @@ module Representable
     # Represents a tag attribute.
     class AttributeBinding < Binding
       def write(xml, values)
-        wrap(xml).tap do |xml|
-          xml[definition.from] = values.to_s
-        end
+        xml[definition.from] = values.to_s
       end
 
     private
@@ -58,21 +44,13 @@ module Representable
     
     # Represents text content in a tag. # FIXME: is this tested???
     class TextBinding < Binding
-      # Updates the text in the given _xml_ block to
-      # the _value_ provided.
       def write(xml, value)
-        wrap(xml).tap do |xml|
-          if definition.content?
-            add(xml, value)
-          elsif definition.name?
-            xml.name = value
-          elsif definition.array?
-            value.each do |v|
-              add(xml.add_node(definition.from), v)
-            end
-          else
-            add(xml.add_node(definition.from), value)
+        if definition.array?
+          value.each do |v|
+            add(xml, definition.from, v)
           end
+        else
+          add(xml, definition.from, value)
         end
       end
 
@@ -82,9 +60,10 @@ module Representable
           node.content
         end
       end
-
-      def add(dest, value)
-        dest.content = value.to_s
+      
+      def add(xml, name, value)
+        child = xml.add_child Nokogiri::XML::Node.new(name, xml.document)
+        child.content = value
       end
     end
     
@@ -93,12 +72,10 @@ module Representable
     class ObjectBinding < Binding
       # Adds the ref's markup to +xml+. 
       def write(xml, value)
-        wrap(xml).tap do |xml|
-          if definition.array?
-            write_collection(xml, value)
-          else
-            write_entity(xml, value)
-          end
+        if definition.array?
+          write_collection(xml, value)
+        else
+          write_entity(xml, value)
         end
       end
 
@@ -107,18 +84,10 @@ module Representable
         []
       end
       
-      def serialize(object)
-        object.to_xml
-      end
-      
-      def deserialize(node_class, xml)
-        node_class.from_xml(xml)
-      end
-      
       # Deserializes the ref's element from +xml+.
       def value_from_node(xml)
         collect_for(xml) do |node|
-          deserialize(definition.sought_type, node)
+          definition.sought_type.from_node(node)
         end
       end
       
@@ -129,7 +98,7 @@ module Representable
       end
       
       def write_entity(xml, entity)
-        xml.add_child(serialize(entity))
+        xml.add_child(entity.to_node)
       end
     end
   end

data/lib/representable/definition.rb

@@ -1,6 +1,7 @@
 module Representable
-  class Definition # :nodoc:
-    attr_reader :name, :sought_type, :wrapper, :from
+  # Created at class compile time. Keeps configuration options for one property.
+  class Definition
+    attr_reader :name, :sought_type, :from
     alias_method :getter, :name
     
     def initialize(sym, options={})
@@ -28,23 +29,10 @@ module Representable
       sought_type.is_a?(Class)
     end
     
-    def name?
-      @name == '*'
-    end
-
-    def content?
-      @name == '.'
-    end
-    
     def array?
       @array
     end
     
-    def cdata?  # FIXME: move to XML!
-      @cdata
-    end
-    
-    
     # Applies the block to +value+ which might also be a collection.
     def apply(value)
       return value unless value # DISCUSS: is that ok here?

data/lib/representable/json.rb

@@ -24,33 +24,26 @@ module Representable
         (BINDING_FOR_TYPE[definition.sought_type] or ObjectBinding).new(definition)
       end
     
-      # Creates a new Ruby object from XML using mapping information declared in the class.
-      #
-      # Example:
-      #  book = Book.from_xml("<book><name>Beyond Java</name></book>")
-      # DISCUSS: assumes shitty wrapping like :article => {:name => ...}
-      def from_json(data, *args, &block)
-        create_from_json.tap do |object|
-          object.from_json(data, *args, &block)
-        end
+      # Creates a new object from the passed JSON document.
+      def from_json(*args, &block)
+        new.from_json(*args, &block)
       end
       
-      def from_hash(data)
-        create_from_json.tap do |object|
-          object.update_properties_from(data)
-        end
-      end
-      
-    private
-      def create_from_json(*args)
-        new(*args)
+      def from_hash(*args, &block)
+        new.from_hash(*args, &block)
       end
     end
     
-    def from_json(data, options={}, &block)
+    # Parses the body as JSON and delegates to #from_hash.
+    def from_json(data, *args, &block)
       data = ::JSON[data]
-      data = data[self.class.representation_name.to_s] unless options[:wrap] == false
-      data ||= {} # FIXME: should we fail here? generate a warning?
+      from_hash(data, *args, &block)
+    end
+    
+    def from_hash(data, options={}, &block)
+      if wrap = options[:wrap] || self.class.representation_wrap
+        data = data[wrap.to_s]
+      end
       
       update_properties_from(data, &block)
     end
@@ -58,8 +51,9 @@ module Representable
     def to_hash(options={})
       hash = create_representation_with({})
       
-      # DISCUSS: where to wrap?
-      options[:wrap] == false ? hash : {self.class.representation_name => hash}
+      return hash unless wrap = options[:wrap] || self.class.representation_wrap
+      
+      {wrap => hash}
     end
     
     # Returns a JSON string representing this object.

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "0.9.3"
+  VERSION = "0.10.0"
 end

data/lib/representable/xml.rb

@@ -1,5 +1,4 @@
 require 'representable'
-require 'representable/nokogiri_extensions'
 require 'representable/bindings/xml_bindings'
 
 module Representable
@@ -13,20 +12,12 @@ module Representable
       base.class_eval do
         include Representable
         extend ClassMethods
+        self.representation_wrap = true # let representable compute it.
       end
     end
     
     
-    class Definition < Representable::Definition
-      # FIXME: extract xml-specific from Definition.
-    end
-    
-    
     module ClassMethods
-      def definition_class
-        Definition
-      end
-      
       def binding_for_definition(definition)
         (BINDING_FOR_TYPE[definition.sought_type] or ObjectBinding).new(definition)
       end
@@ -38,29 +29,34 @@ module Representable
       #
       # Example:
       #   band.from_xml("<band><name>Nofx</name></band>")
-      def from_xml(doc, *args, &block)
-        create_from_xml(*args).tap do |object|
-          object.from_xml(doc, *args, &block)
-        end
+      def from_xml(*args, &block)
+        new.from_xml(*args, &block)
       end
       
-    private
-      def create_from_xml(*args)
-        new(*args)
+      def from_node(*args, &block)
+        new.from_node(*args, &block)
       end
     end
     
+    
     def from_xml(doc, *args, &block)
-      xml = Nokogiri::XML::Node.from(doc)
-      update_properties_from(xml, &block)
+      node = Nokogiri::XML(doc).root
+      from_node(node, *args, &block)
     end
     
+    def from_node(node, options={}, &block)
+      update_properties_from(node, &block)
+    end
     
     # Returns a Nokogiri::XML object representing this object.
-    def to_xml(params={})
-      root_tag = params[:name] || self.class.representation_name
+    def to_node(options={}, &block)
+      root_tag = options[:wrap] || self.class.representation_wrap
       
-      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, Nokogiri::XML::Document.new))
+      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, Nokogiri::XML::Document.new), &block)
+    end
+    
+    def to_xml(*args, &block)
+      to_node(*args, &block).to_s
     end
   end
 end

data/test/bindings_test.rb

@@ -13,7 +13,7 @@ class BindingsTest < MiniTest::Spec
   
   
   describe "TextRef#read" do
-    def parse_xml(xml); Nokogiri::XML::Node.from(xml); end
+    def parse_xml(xml); Nokogiri::XML(xml).root; end
     
     before do
       @ref = Representable::XML::TextBinding.new(Representable::Definition.new(:song))

data/test/json_test.rb

@@ -9,7 +9,6 @@ module JsonTest
     describe "JSON module" do
       before do
         @Band = Class.new(Band) do
-          self.representation_name= :band
           representable_property :label
         end
       end
@@ -42,35 +41,50 @@ module JsonTest
         end
         
         it "accepts json string" do
-          @band.from_json({band: {name: "Nofx", label: "NOFX"}}.to_json)
+          @band.from_json({name: "Nofx", label: "NOFX"}.to_json)
           assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
         end
         
         it "forwards block to #update_properties_from" do
-          @band.from_json({band: {name: "Nofx", label: "NOFX"}}.to_json) do |binding|
+          @band.from_json({name: "Nofx", label: "NOFX"}.to_json) do |binding|
             binding.definition.name == "name"
           end
           
           assert_equal ["Nofx", nil], [@band.name, @band.label]
         end
         
-        it "accepts wrapped properties" do
-          band = Band.new
-          band.from_json({:band => {:name => "This Is A Standoff"}}.to_json)
-          assert_equal "This Is A Standoff", band.name
+        
+        it "doesn't use wrap per default" do
+          @band.from_json({:name => "This Is A Standoff"}.to_json)
+          assert_equal "This Is A Standoff", @band.name
+        end
+        
+        it "respects :wrap option" do
+          @band.from_json({:band => {:name => "This Is A Standoff"}}.to_json, :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 
+          end
+          @band.from_json({:band => {:name => "This Is A Standoff"}}.to_json, :wrap => :band)
+          assert_equal "This Is A Standoff", @band.name
         end
         
-        it "accepts unwrapped properties using the :wrap option" do # DISCUSS: should be default.
-          band = Band.new
-          band.from_json({name: "This Is A Standoff"}.to_json, :wrap => false)
-          assert_equal "This Is A Standoff", band.name
+        it "respects representation_wrap" do
+          @Band.class_eval do
+            self.representation_wrap = :group 
+          end
+          @band.from_json({:group => {:name => "This Is A Standoff"}}.to_json)
+          assert_equal "This Is A Standoff", @band.name
         end
       end
       
       
       describe ".from_json" do
         it "delegates to #from_json after object conception" do
-          band = @Band.from_json({band: {name: "Nofx", label: "NOFX"}}.to_json) do |binding| binding.definition.name == "name" end
+          band = @Band.from_json({name: "Nofx", label: "NOFX"}.to_json) do |binding| binding.definition.name == "name" end
           assert_equal ["Nofx", nil], [band.name, band.label]
         end
         
@@ -95,12 +109,43 @@ module JsonTest
         end
       end
       
+      
       describe ".from_hash" do
         it "accepts unwrapped hash with string keys" do
           band = Band.from_hash("name" => "Bombshell Rocks")
           assert_equal "Bombshell Rocks", band.name
         end
       end
+    
+    
+      describe "#to_json" do
+        before do
+          @band = @Band.new
+          @band.label = "Fat"
+        end
+        
+        it "doesn't wrap per default" do
+          assert_equal "{\"label\":\"Fat\"}", @band.to_json
+        end
+        
+        it "respects :wrap option" do
+          assert_equal "{\"band\":{\"label\":\"Fat\"}}", @band.to_json(:wrap => :band)
+        end
+        
+        it "respects :wrap option over representation_wrap" do
+          @Band.class_eval do
+            self.representation_wrap = :group 
+          end
+          assert_equal "{\"band\":{\"label\":\"Fat\"}}", @band.to_json(:wrap => :band)
+        end
+        
+        it "respects representation_wrap" do
+          @Band.class_eval do
+            self.representation_wrap = :group 
+          end
+          assert_equal "{\"group\":{\"label\":\"Fat\"}}", @band.to_json
+        end
+      end
     end
   end
 
@@ -112,7 +157,7 @@ module JsonTest
       end
       
       it "#from_json creates correct accessors" do
-        band = Band.from_json({:band => {:name => "Bombshell Rocks"}}.to_json)
+        band = Band.from_json({:name => "Bombshell Rocks"}.to_json)
         assert_equal "Bombshell Rocks", band.name
       end
       
@@ -120,7 +165,7 @@ module JsonTest
         band = Band.new
         band.name = "Cigar"
         
-        assert_equal '{"band":{"name":"Cigar"}}', band.to_json
+        assert_equal '{"name":"Cigar"}', band.to_json
       end
     end
     
@@ -136,7 +181,7 @@ module JsonTest
       end
       
       it "#from_json creates one Item instance" do
-        album = Album.from_json('{"album":{"label":{"name":"Fat Wreck"}}}')
+        album = Album.from_json('{"label":{"name":"Fat Wreck"}}')
         assert_equal "Fat Wreck", album.label.name
       end
       
@@ -144,7 +189,23 @@ module JsonTest
         label = Label.new; label.name = "Fat Wreck"
         album = Album.new; album.label = label
         
-        assert_equal '{"album":{"label":{"name":"Fat Wreck"}}}', album.to_json
+        assert_equal '{"label":{"name":"Fat Wreck"}}', album.to_json
+      end
+      
+      describe ":different_name, :as => Label" do
+        before do
+          @Album = Class.new do
+            include Representable::JSON
+            representable_property :seller, :as => Label
+          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)
+        end
       end
     end
     
@@ -155,13 +216,13 @@ module JsonTest
       end
       
       it "respects :from in #from_json" do
-        song = Song.from_json({:song => {:songName => "Run To The Hills"}}.to_json)
+        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 '{"song":{"songName":"Run To The Hills"}}', song.to_json
+        assert_equal '{"songName":"Run To The Hills"}', song.to_json
       end
     end
   end
@@ -175,7 +236,7 @@ module JsonTest
       end
       
       it "#from_json creates correct accessors" do
-        cd = CD.from_json({:cd => {:songs => ["Out in the cold", "Microphone"]}}.to_json)
+        cd = CD.from_json({:songs => ["Out in the cold", "Microphone"]}.to_json)
         assert_equal ["Out in the cold", "Microphone"], cd.songs
       end
     
@@ -183,7 +244,7 @@ module JsonTest
         cd = CD.new
         cd.songs = ["Out in the cold", "Microphone"]
         
-        assert_equal '{"cd":{"songs":["Out in the cold","Microphone"]}}', cd.to_json
+        assert_equal '{"songs":["Out in the cold","Microphone"]}', cd.to_json
       end
     end
     
@@ -204,9 +265,9 @@ module JsonTest
       
       describe "#from_json" do
         it "pushes collection items to array" do
-          cd = Compilation.from_json({:compilation => {:bands => [
+          cd = Compilation.from_json({:bands => [
             {:name => "Cobra Skulls"},
-            {:name => "Diesel Boy"}]}}.to_json)
+            {:name => "Diesel Boy"}]}.to_json)
           assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
         end
         
@@ -220,7 +281,7 @@ module JsonTest
         cd = Compilation.new
         cd.bands = [Band.new("Diesel Boy"), Band.new("Bad Religion")]
         
-        assert_equal '{"compilation":{"bands":[{"name":"Diesel Boy"},{"name":"Bad Religion"}]}}', cd.to_json
+        assert_equal '{"bands":[{"name":"Diesel Boy"},{"name":"Bad Religion"}]}', cd.to_json
       end
     end
     
@@ -232,7 +293,7 @@ module JsonTest
       end
       
       it "respects :from in #from_json" do
-        songs = Songs.from_json({:songs => {:songList => ["Out in the cold", "Microphone"]}}.to_json)
+        songs = Songs.from_json({:songList => ["Out in the cold", "Microphone"]}.to_json)
         assert_equal ["Out in the cold", "Microphone"], songs.tracks
       end
     
@@ -240,7 +301,7 @@ module JsonTest
         songs = Songs.new
         songs.tracks = ["Out in the cold", "Microphone"]
         
-        assert_equal '{"songs":{"songList":["Out in the cold","Microphone"]}}', songs.to_json
+        assert_equal '{"songList":["Out in the cold","Microphone"]}', songs.to_json
       end
     end
   end

data/test/representable_test.rb

@@ -58,7 +58,7 @@ class RepresentableTest < MiniTest::Spec
   end
   
   
-  describe "#representation_name" do
+  describe "#representation_wrap" do
     class SoundSystem
       include Representable
     end
@@ -70,14 +70,24 @@ class RepresentableTest < MiniTest::Spec
     class SoftcoreBand < HardcoreBand
     end
     
-    it "provides the root 'tag' name" do
-      assert_equal "sound_system", SoundSystem.representation_name
+    it "returns false per default" do
+      assert_equal nil, SoundSystem.representation_wrap
+    end
+    
+    
+    it "infers a printable class name if set to true" do
+      HardcoreBand.representation_wrap = true
+      assert_equal "hardcore_band", HardcoreBand.send(:representation_wrap)
+    end
+    
+    it "can be set explicitely" do
+      HardcoreBand.representation_wrap = "breach"
+      assert_equal "breach", HardcoreBand.representation_wrap
     end
     
     it "inherits correctly" do
-      HardcoreBand.representation_name = "breach"
-      assert_equal "breach", HardcoreBand.representation_name
-      assert_equal "breach", SoftcoreBand.representation_name
+      HardcoreBand.representation_wrap = "breach"
+      assert_equal "breach", SoftcoreBand.representation_wrap
     end
   end
   

data/test/xml_test.rb

@@ -10,9 +10,12 @@ class Band
   end
 end
 
-class Label
-  def to_xml
-    "<label>Fat Wreck</label>"
+class Album
+  include Representable::XML
+  representable_property :band, :as => Band
+  
+  def initialize(band=nil)
+    band and self.band = band
   end
 end
   
@@ -25,48 +28,65 @@ class XmlTest < MiniTest::Spec
     before do
       @Band = Class.new do
         include Representable::XML
-        self.representation_name= :band
+        self.representation_wrap = :band
         representable_property :name
         representable_property :label
       end
     end
-      
-    class Band
-      include Representable::XML
-      representable_property :href,   :from => "@href"
-      representable_property :title,  :from => "@title"
+    
+    
+    describe ".from_xml" do
+      it "is delegated to #from_xml" do
+        block = lambda {|bind|}
+        @Band.any_instance.expects(:from_xml).with("{}", "yo") # FIXME: how to expect block?
+        @Band.from_xml("{}", "yo", &block)
+      end
     end
     
-    it "#definition_class returns Definition class" do
-      assert_equal XML::Definition, Band.definition_class
+    
+    describe ".from_node" do
+      it "is delegated to #from_node" do
+        block = lambda {|bind|}
+        @Band.any_instance.expects(:from_node).with("{}", "yo") # FIXME: how to expect block?
+        @Band.from_node("{}", "yo", &block)
+      end
     end
-  
-    describe "#binding_for_definition" do
-      it "returns AttributeBinding" do
-        assert_kind_of XML::AttributeBinding, Band.binding_for_definition(Def.new(:band, :from => "@band"))
+    
+    
+    describe "#from_xml" do
+      before do
+        @band = @Band.new
+        @xml  = %{<band><name>Nofx</name><label>NOFX</label></band>}
       end
       
-      it "returns ObjectBinding" do
-        assert_kind_of XML::ObjectBinding, Band.binding_for_definition(Def.new(:band, :as => Hash))
+      it "parses XML and assigns properties" do
+        @band.from_xml(@xml)
+        assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
       end
       
-      it "returns TextBinding" do
-        assert_kind_of XML::TextBinding, Band.binding_for_definition(Def.new(:band, :from => :content))
+      it "forwards block to #from_node" do
+        @band.from_xml(@xml) do |binding|
+          binding.definition.name == "name"
+        end
+        
+        assert_equal ["Nofx", nil], [@band.name, @band.label]
       end
     end
     
-    describe "#from_xml" do
+    
+    describe "#from_node" do
       before do
         @band = @Band.new
+        @xml  = Nokogiri::XML(%{<band><name>Nofx</name><label>NOFX</label></band>}).root
       end
       
-      it "accepts xml string" do
-        @band.from_xml(%{<band><name>Nofx</name><label>NOFX</label></band>})
+      it "receives Nokogiri node and assigns properties" do
+        @band.from_node(@xml)
         assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
       end
       
       it "forwards block to #update_properties_from" do
-        @band.from_xml(%{<band><name>Nofx</name><label>NOFX</label></band>}) do |binding|
+        @band.from_node(@xml) do |binding|
           binding.definition.name == "name"
         end
         
@@ -74,17 +94,61 @@ class XmlTest < MiniTest::Spec
       end
     end
     
-    describe ".from_xml" do
-      it "passes all args to #from_xml" do
-        block = lambda {|bind|}
-        @Band.any_instance.expects(:from_xml).with("{}", "yo") # FIXME: how to expect block?
-        @Band.from_xml("{}", "yo", &block)
+    
+    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
+      
+      it "forwards block to #to_node" do
+        band = @Band.new
+        band.name  = "The Guinea Pigs"
+        band.label = "n/a"
+        xml = band.to_xml do |binding|
+          binding.definition.name == "name"
+        end
+        
+        assert_xml_equal "<band><name>The Guinea Pigs</name></band>", 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 
+      end
+      
+      it "respects #representation_wrap=" do
+        klass = Class.new(Band)
+        klass.representation_wrap = :group
+        assert_xml_equal "<group><name>Rise Against</name></group>", klass.new("Rise Against").to_node.to_s
+      end
+    end
+    
+    
+    describe "#binding_for_definition" do
+      it "returns AttributeBinding" do
+        assert_kind_of XML::AttributeBinding, @Band.binding_for_definition(Def.new(:band, :from => "@band"))
+      end
+      
+      it "returns ObjectBinding" do
+        assert_kind_of XML::ObjectBinding, @Band.binding_for_definition(Def.new(:band, :as => Hash))
+      end
+      
+      it "returns TextBinding" do
+        assert_kind_of XML::TextBinding, @Band.binding_for_definition(Def.new(:band, :from => :content))
+      end
+    end
   end
 end
 
+
 class AttributesTest < MiniTest::Spec
   describe ":from => @rel" do
     class Link
@@ -105,19 +169,13 @@ class AttributesTest < MiniTest::Spec
       link = Link.new
       link.href = "http://apotomo.de/"
       
-      assert_xml_equal %{<link href="http://apotomo.de/">}, link.to_xml.to_s
+      assert_xml_equal %{<link href="http://apotomo.de/">}, link.to_xml
     end
   end
 end
 
 class TypedPropertyTest < MiniTest::Spec
   describe ":as => Item" do
-    class Album
-      include Representable::XML
-      representable_property :band, :as => Band
-      representable_property :label, :as => Label
-    end
-    
     it "#from_xml creates one Item instance" do
       album = Album.from_xml(%{
         <album>
@@ -129,25 +187,25 @@ class TypedPropertyTest < MiniTest::Spec
     
     describe "#to_xml" do
       it "doesn't escape xml from Band#to_xml" do
-        band = Band.new
-        band.name = "Bad Religion"
-        album = Album.new
-        album.band = band
+        band = Band.new("Bad Religion")
+        album = Album.new(band)
         
         assert_xml_equal %{<album>
          <band>
            <name>Bad Religion</name>
          </band>
-       </album>}, album.to_xml.to_s
+       </album>}, album.to_xml
       end
       
-      it "doesn't escape and wrap string from Label#to_xml" do
-        album = Album.new
-        album.label = Label.new
+      it "doesn't escape and wrap string from Band#to_node" do
+        band = Band.new("Bad Religion")
+        band.instance_eval do
+          def to_node
+            "<band>Baaaad Religion</band>"
+          end
+        end
         
-        assert_xml_equal %{<album>
-          <label>Fat Wreck</label>
-        </album>}, album.to_xml.to_s
+        assert_xml_equal %{<album><band>Baaaad Religion</band></album>}, Album.new(band).to_xml
       end
     end
   end
@@ -155,19 +213,12 @@ end
 
 
 class CollectionTest < MiniTest::Spec
-  describe ":as => [Band], :tag => :band" do
+  describe ":as => Band, :from => :band, :collection => true" do
     class Compilation
       include Representable::XML
       representable_collection :bands, :as => Band, :from => :band
     end
     
-    describe "#representable_collection" do
-      it "declares a collection" do
-        assert Compilation.representable_attrs.first.array?
-      end
-    end
-    
-    
     describe "#from_xml" do
       it "pushes collection items to array" do
         cd = Compilation.from_xml(%{
@@ -195,12 +246,12 @@ class CollectionTest < MiniTest::Spec
       assert_xml_equal %{<compilation>
         <band><name>Diesel Boy</name></band>
         <band><name>Bad Religion</name></band>
-      </compilation>}, cd.to_xml.to_s
+      </compilation>}, cd.to_xml
     end
   end
     
     
-  describe ":as => []" do
+  describe ":from" do
     class Album
       include Representable::XML
       representable_collection :songs, :from => :song

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 9
-  - 3
-  version: 0.9.3
+  - 10
+  - 0
+  version: 0.10.0
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-27 00:00:00 +01:00
+date: 2011-11-29 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -133,7 +133,6 @@ files:
 - lib/representable/bindings/xml_bindings.rb
 - lib/representable/definition.rb
 - lib/representable/json.rb
-- lib/representable/nokogiri_extensions.rb
 - lib/representable/version.rb
 - lib/representable/xml.rb
 - representable.gemspec

data/lib/representable/nokogiri_extensions.rb

@@ -1,19 +0,0 @@
-require 'nokogiri'
-
-Nokogiri::XML::Node.class_eval do
-  def add_node(name)
-    add_child Nokogiri::XML::Node.new(name, document)
-  end
-  
-  # FIXME: remove switch. where is #from used with nodes?
-  def self.from(data)
-    case data
-    when Nokogiri::XML::Node
-      data
-    when Nokogiri::XML::Document
-      data.root
-    else
-      Nokogiri::XML(data).root
-    end
-  end
-end