representable 0.9.0 → 0.9.1

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm: 1.9.2
+notifications:
+  irc: "irc.freenode.org#cells"

data/CHANGES.textile

@@ -1,3 +1,8 @@
+h2. 0.9.1
+
+* Extracted common serialization into @Representable#create_representation_with@ and deserialization into @#update_properties_from@.
+* Both serialization and deserialization now accept a block to make them skip elements while iterating the property definitions.
+  
 h2. 0.9.0
 
 h3. Changes

data/lib/representable.rb

@@ -1,5 +1,4 @@
 require 'hooks/inheritable_attribute'
-
 require 'representable/definition'
 require 'representable/nokogiri_extensions'
 
@@ -17,13 +16,41 @@ module Representable
     end
   end
   
+  # Reads values from +doc+ and sets properties accordingly.
+  def update_properties_from(doc)
+    self.class.representable_bindings.each do |ref|
+      next if block_given? and not yield ref # skip if block is false. # DISCUSS: will we keep that?
+      
+      value = ref.read(doc)
+      send(ref.definition.setter, value)
+    end
+    self
+  end
+  
+private
+  # Compiles the document going through all properties.
+  def create_representation_with(doc)
+    self.class.representable_bindings.each do |ref|
+      next if block_given? and not yield ref # skip if block is false. # DISCUSS: will we keep that?
+      
+      value = public_send(ref.definition.getter) # DISCUSS: eventually move back to Ref.
+      ref.write(doc, value) if value
+    end
+    doc
+  end
+  
+  
   module ClassMethods # :nodoc:
     module Declarations
       def definition_class
         Definition
       end
       
-
+      # Returns bindings for all properties.
+      def representable_bindings
+        representable_attrs.map {|attr| binding_for_definition(attr) }
+      end
+      
       # Declares a reference to a certain xml element, whether an attribute, a node,
       # or a typed collection of nodes.  This method does not add a corresponding accessor
       # to the object.  For that behavior see the similar methods: .xml_reader and .xml_accessor.
@@ -183,9 +210,9 @@ module Representable
       # [:to_xml] this proc is applied to the attributes value outputting the instance via #to_xml
       #
       def representable_property(*args) # TODO: make it accept 1-n props.
-        attr = representable_attr(*args)
-        add_reader(attr)
-        attr_writer(attr.accessor)
+        attr = add_representable_property(*args)
+        attr_reader(attr.getter)
+        attr_writer(attr.getter)
       end
       
       def representable_collection(name, options={})
@@ -194,23 +221,11 @@ module Representable
       end
       
     private
-      def representable_attr(name, options={})
-        definition_class.new(name, options).tap do |attr|
+      def add_representable_property(*args)
+        definition_class.new(*args).tap do |attr|
           representable_attrs << attr
         end
       end
-      
-      def representable_reader(*syms, &block)
-        representable_attr(*syms, &block).each do |attr|
-          add_reader(attr)
-        end
-      end
-      
-      def add_reader(attr)
-        define_method(attr.accessor) do
-          instance_variable_get(attr.instance_variable_name)
-        end
-      end
     end
 
     module Accessors

data/lib/representable/bindings/json_bindings.rb

@@ -2,13 +2,12 @@ module Representable
   module JSON
     class Binding
       attr_reader :definition
-      #delegate :required?, :array?, :accessor, :from, :to => :definition
 
       def initialize(definition)
         @definition = definition
       end
       
-      def value_in(hash)
+      def read(hash)
         value_from_hash(hash) or default
       end
       
@@ -29,7 +28,7 @@ module Representable
     
     # Represents plain key-value.
     class TextBinding < Binding
-      def update_json(hash, value)
+      def write(hash, value)
         hash[definition.from] = value
       end
 
@@ -43,9 +42,7 @@ module Representable
   
     # Represents a tag with object binding.
     class ObjectBinding < Binding
-      #delegate :sought_type, :to => :definition
-      
-      def update_json(hash, value)
+      def write(hash, value)
         if definition.array?
           hash.merge! ({definition.from => value.collect {|v| v.to_hash(:wrap => false)}}) # hier name=> wech.
         else
@@ -58,9 +55,9 @@ module Representable
         []
       end
       
-      def value_from_hash(xml)
-        collect_for(xml) do |node|
-          definition.sought_type.from_json(node, :wrap => false) # hier name=> wech.
+      def value_from_hash(hash)
+        collect_for(hash) do |node|
+          definition.sought_type.from_hash(node)  # call #from_hash as it's already deserialized.
         end
       end
       

data/lib/representable/bindings/xml_bindings.rb

@@ -7,7 +7,7 @@ module Representable
         @definition = definition
       end
       
-      def value_in(xml)
+      def read(xml)
         xml = Nokogiri::XML::Node.from(xml) or return default
         
         value_from_node(xml) or default
@@ -43,7 +43,7 @@ module Representable
     
     # Represents a tag attribute.
     class AttributeBinding < Binding
-      def update_xml(xml, values)
+      def write(xml, values)
         wrap(xml).tap do |xml|
           xml[definition.from] = values.to_s
         end
@@ -60,7 +60,7 @@ module Representable
     class TextBinding < Binding
       # Updates the text in the given _xml_ block to
       # the _value_ provided.
-      def update_xml(xml, value)
+      def write(xml, value)
         wrap(xml).tap do |xml|
           if definition.content?
             add(xml, value)
@@ -92,12 +92,12 @@ module Representable
     # Represents a tag with object binding.
     class ObjectBinding < Binding
       # Adds the ref's markup to +xml+. 
-      def update_xml(xml, value)
+      def write(xml, value)
         wrap(xml).tap do |xml|
           if definition.array?
-            update_xml_for_collection(xml, value)
+            write_collection(xml, value)
           else
-            update_xml_for_entity(xml, value)
+            write_entity(xml, value)
           end
         end
       end
@@ -122,13 +122,13 @@ module Representable
         end
       end
       
-      def update_xml_for_collection(xml, collection)
+      def write_collection(xml, collection)
         collection.each do |item|
-          update_xml_for_entity(xml, item)
+          write_entity(xml, item)
         end
       end
       
-      def update_xml_for_entity(xml, entity)
+      def write_entity(xml, entity)
         xml.add_child(serialize(entity))
       end
     end

data/lib/representable/definition.rb

@@ -1,10 +1,10 @@
 module Representable
   class Definition # :nodoc:
-    attr_reader :name, :sought_type, :wrapper, :accessor, :from
-    
+    attr_reader :name, :sought_type, :wrapper, :from
+    alias_method :getter, :name
     
     def initialize(sym, opts={})
-      @accessor = @name = sym.to_s
+      @name = sym.to_s
       
       @array        = true if opts[:as].is_a?(Array) # DISCUSS: move to ArrayDefinition.
       @from         = (opts[:from] || name).to_s
@@ -25,11 +25,11 @@ module Representable
     end
 
     def instance_variable_name
-      :"@#{accessor}"
+      :"@#{name}"
     end
 
     def setter
-      :"#{accessor}="
+      :"#{name}="
     end
     
     def typed?

data/lib/representable/json.rb

@@ -6,39 +6,34 @@ module Representable
     BINDING_FOR_TYPE = {  # TODO: refactor #representable_accessor for better extendability.
       :text     => TextBinding,
     }
-    def self.binding_for_definition(definition)
-      (BINDING_FOR_TYPE[definition.sought_type] or ObjectBinding).new(definition)
-    end
     
     def self.included(base)
       base.class_eval do
         include Representable
-        include InstanceMethods
+        extend ClassMethods
       end
-      base.extend ClassMethods  # DISCUSS: do that dynamically?
     end
     
+    
     module ClassMethods
+      def binding_for_definition(definition)
+        (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>")
-      def from_json(data, options={})
-        # DISCUSS: extract #from_json call in Bindings to this place.
-        data = ::JSON[data] if data.is_a?(String) # DISCUSS: #from_json sometimes receives a string (in nestings).
-        data ||= {} # DISCUSS: is this needed?
-        data = data[representation_name.to_s] unless options[:wrap] == false
-        data ||= {} # FIXME: should we fail here? generate a warning?
-        
-        
-        create_from_json.tap do |inst|
-          refs = representable_attrs.map {|attr| JSON.binding_for_definition(attr) }
-          
-          refs.each do |ref|
-            value = ref.value_in(data)
-            
-            inst.send(ref.definition.setter, value)
-          end
+      # DISCUSS: assumes shitty wrapping like :article => {:name => ...}
+      def from_json(data, options={}, &block)
+        create_from_json.tap do |object|
+          object.from_json(data, &block)
+        end
+      end
+      
+      def from_hash(data)
+        create_from_json.tap do |object|
+          object.update_properties_from(data)
         end
       end
       
@@ -48,25 +43,24 @@ module Representable
       end
     end
     
-    module InstanceMethods # :nodoc:
-      def to_hash(options={})
-        hash = {}.tap do |attrs|
-          refs = self.class.representable_attrs.map {|attr| JSON.binding_for_definition(attr) }
-          
-          refs.each do |ref|
-            value = public_send(ref.definition.accessor) # DISCUSS: eventually move back to Ref.
-            ref.update_json(attrs, value) if value
-          end
-        end
-        
-        # DISCUSS: where to wrap?
-        options[:wrap] == false ? hash : {self.class.representation_name => hash}
-      end
+    def from_json(data, options={}, &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?
       
-      # Returns a Nokogiri::XML object representing this object.
-      def to_json(options={})
-        to_hash(options).to_json
-      end
+      update_properties_from(data, &block)
+    end
+    
+    def to_hash(options={})
+      hash = create_representation_with({})
+      
+      # DISCUSS: where to wrap?
+      options[:wrap] == false ? hash : {self.class.representation_name => hash}
+    end
+    
+    # Returns a JSON string representing this object.
+    def to_json(options={})
+      to_hash(options).to_json
     end
   end
 end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

data/lib/representable/xml.rb

@@ -8,42 +8,41 @@ module Representable
       :text     => TextBinding,
     }
     
-    def self.binding_for_definition(definition)
-      (BINDING_FOR_TYPE[definition.sought_type] or ObjectBinding).new(definition)
-    end
-    
     def self.included(base)
       base.class_eval do
         include Representable
-        include InstanceMethods
         extend ClassMethods
+        alias_method :from_xml, :update_properties_from
       end
     end
     
+    
     class Definition < Representable::Definition
       # FIXME: extract xml-specific from Definition.
     end
     
-    module ClassMethods
-    def definition_class
-      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
+      
       # Creates a new Ruby object from XML using mapping information declared in the class.
       #
+      # Accepts a block yielding the currently iterated Definition. If the block returns false 
+      # the property is skipped.
+      #
       # Example:
-      #  book = Book.from_xml("<book><name>Beyond Java</name></book>")
+      #   band.from_xml("<band><name>Nofx</name></band>")
       def from_xml(data, *args)
         xml = Nokogiri::XML::Node.from(data)
 
-        create_from_xml(*args).tap do |inst|
-          refs = representable_attrs.map {|attr| XML.binding_for_definition(attr) }
-          
-          refs.each do |ref|
-            value = ref.value_in(xml)
-            
-            inst.send(ref.definition.setter, value)
-          end
+        create_from_xml(*args).tap do |object|
+          object.update_properties_from(xml)
         end
       end
       
@@ -53,20 +52,11 @@ module Representable
       end
     end
     
-    module InstanceMethods # :nodoc:
-      # Returns a Nokogiri::XML object representing this object.
-      def to_xml(params={})
-        params[:name] ||= self.class.representation_name
-        
-        Nokogiri::XML::Node.new(params[:name].to_s, Nokogiri::XML::Document.new).tap do |root|
-          refs = self.class.representable_attrs.map {|attr| XML.binding_for_definition(attr) }
-          
-          refs.each do |ref|
-            value = public_send(ref.definition.accessor) # DISCUSS: eventually move back to Ref.
-            ref.update_xml(root, value) if value
-          end
-        end
-      end
+    # Returns a Nokogiri::XML object representing this object.
+    def to_xml(params={})
+      root_tag = params[:name] || self.class.representation_name
+      
+      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, Nokogiri::XML::Document.new))
     end
-  end # Xml
+  end
 end

data/representable.gemspec

@@ -24,6 +24,6 @@ Gem::Specification.new do |s|
   s.add_dependency "json"
   
   s.add_development_dependency "rake"
-  s.add_development_dependency "rspec"
   s.add_development_dependency "test_xml"
+  s.add_development_dependency "minitest", "~>2.8"
 end

data/test/bindings_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ReferenceTest < MiniTest::Spec
+class BindingsTest < MiniTest::Spec
   describe "ObjectRef with []" do
     before do
       @ref = Representable::XML::ObjectBinding.new(Representable::Definition.new(:songs, :as => [Hash]))
@@ -12,7 +12,7 @@ class ReferenceTest < MiniTest::Spec
   end
   
   
-  describe "TextRef#value_in" do
+  describe "TextRef#read" do
     def parse_xml(xml); Nokogiri::XML::Node.from(xml); end
     
     before do
@@ -20,95 +20,8 @@ class ReferenceTest < MiniTest::Spec
     end
     
     it "returns found value" do
-      assert_equal "Unkoil", @ref.value_in(parse_xml("<a><song>Unkoil</song></a>"))
+      assert_equal "Unkoil", @ref.read(parse_xml("<a><song>Unkoil</song></a>"))
     end
   end
 end
 
-class DefinitionTest < MiniTest::Spec
-  describe "generic API" do
-    before do
-      @def = Representable::Definition.new(:songs)
-    end
-    
-    it "responds to #typed?" do
-      assert ! @def.typed?
-      assert Representable::Definition.new(:songs, :as => Hash).typed?
-      assert Representable::Definition.new(:songs, :as => [Hash]).typed?
-    end
-    
-    it "responds to #accessor" do
-      assert_equal "songs", @def.accessor
-    end
-    
-    it "responds to #name" do
-      assert_equal "songs", @def.name 
-    end
-    
-    it "responds to #instance_variable_name" do
-      assert_equal :"@songs", @def.instance_variable_name
-    end
-    
-    it "responds to #setter" do
-      assert_equal :"songs=", @def.setter
-    end
-    
-    it "responds to #sought_type" do
-      assert_equal :text, @def.sought_type
-    end
-  end
-  
-  
-  describe "#apply" do
-    it "works with a single item" do
-      @d = Representable::Definition.new(:song)
-      assert_equal 2, @d.apply(1) { |v| v+1 }
-    end
-    
-    it "works with collection" do
-      @d = Representable::Definition.new(:song, :as => [])
-      assert_equal [2,3,4], @d.apply([1,2,3]) { |v| v+1 }
-    end
-    
-    it "skips with collection and nil" do
-      @d = Representable::Definition.new(:song, :as => [])
-      assert_equal nil, @d.apply(nil) { |v| v+1 }
-    end
-  end
-    
-  describe ":as => []" do
-    before do
-      @def = Representable::Definition.new(:songs, :as => [], :tag => :song)
-    end
-    
-    it "responds to #array?" do
-      assert @def.array?
-    end
-    
-    it "responds to #sought_type" do
-      assert_equal :text, @def.sought_type
-    end
-  end
-    
-    
-  describe ":as => [Item]" do
-    before do
-      @def = Representable::Definition.new(:songs, :as => [Hash])
-    end
-    
-    it "responds to #sought_type" do
-      assert_equal Hash, @def.sought_type
-    end
-  end
-  
-  
-  describe ":as => Item" do
-    before do
-      @def = Representable::Definition.new(:songs, :as => Hash)
-    end
-    
-    it "responds to #sought_type" do
-      assert_equal Hash, @def.sought_type
-    end
-  end
-end

data/test/definition_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+class DefinitionTest < MiniTest::Spec
+  describe "generic API" do
+    before do
+      @def = Representable::Definition.new(:songs)
+    end
+    
+    it "responds to #typed?" do
+      assert ! @def.typed?
+      assert Representable::Definition.new(:songs, :as => Hash).typed?
+      assert Representable::Definition.new(:songs, :as => [Hash]).typed?
+    end
+    
+    it "responds to #getter and returns string" do
+      assert_equal "songs", @def.getter
+    end
+    
+    it "responds to #name" do
+      assert_equal "songs", @def.name 
+    end
+    
+    it "responds to #instance_variable_name" do
+      assert_equal :"@songs", @def.instance_variable_name
+    end
+    
+    it "responds to #setter" do
+      assert_equal :"songs=", @def.setter
+    end
+    
+    it "responds to #sought_type" do
+      assert_equal :text, @def.sought_type
+    end
+  end
+  
+  
+  describe "#apply" do
+    it "works with a single item" do
+      @d = Representable::Definition.new(:song)
+      assert_equal 2, @d.apply(1) { |v| v+1 }
+    end
+    
+    it "works with collection" do
+      @d = Representable::Definition.new(:song, :as => [])
+      assert_equal [2,3,4], @d.apply([1,2,3]) { |v| v+1 }
+    end
+    
+    it "skips with collection and nil" do
+      @d = Representable::Definition.new(:song, :as => [])
+      assert_equal nil, @d.apply(nil) { |v| v+1 }
+    end
+  end
+    
+  describe ":as => []" do
+    before do
+      @def = Representable::Definition.new(:songs, :as => [], :tag => :song)
+    end
+    
+    it "responds to #array?" do
+      assert @def.array?
+    end
+    
+    it "responds to #sought_type" do
+      assert_equal :text, @def.sought_type
+    end
+  end
+    
+    
+  describe ":as => [Item]" do
+    before do
+      @def = Representable::Definition.new(:songs, :as => [Hash])
+    end
+    
+    it "responds to #sought_type" do
+      assert_equal Hash, @def.sought_type
+    end
+  end
+  
+  
+  describe ":as => Item" do
+    before do
+      @def = Representable::Definition.new(:songs, :as => Hash)
+    end
+    
+    it "responds to #sought_type" do
+      assert_equal Hash, @def.sought_type
+    end
+  end
+end

data/test/json_test.rb

@@ -7,21 +7,74 @@ module JsonTest
     Def = Representable::Definition
     
     describe "JSON module" do
+      before do
+        @Band = Class.new(Band) do
+          self.representation_name= :band
+          representable_property :label
+        end
+      end
+      
+      class Band
+        include Representable::JSON
+        representable_property :name
+      end
+        
       describe "#binding_for_definition" do
         it "returns ObjectBinding" do
-          assert_kind_of Json::ObjectBinding, Json.binding_for_definition(Def.new(:band, :as => Hash))
+          assert_kind_of Json::ObjectBinding, Band.binding_for_definition(Def.new(:band, :as => Hash))
         end
         
         it "returns TextBinding" do
-          assert_kind_of Json::TextBinding, Json.binding_for_definition(Def.new(:band))
+          assert_kind_of Json::TextBinding, Band.binding_for_definition(Def.new(:band))
+        end
+      end
+      
+      describe "#representable_bindings" do
+        it "returns bindings for each property" do
+          assert_equal 1, Band.representable_bindings.size
+          assert_equal "name", Band.representable_bindings.first.definition.name
         end
       end
       
       describe "#from_json" do
-        class Band
-          include Json
+        before do
+          @band = @Band.new
+        end
+        
+        it "accepts json string" do
+          @band.from_json({band: {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|
+            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
+        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
+        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
+          assert_equal ["Nofx", nil], [band.name, band.label]
+        end
+        
+        # TODO: move following tests to #from_json test.
         it "raises error with emtpy string" do
           assert_raises JSON::ParserError do
             Band.from_json("")
@@ -33,10 +86,15 @@ module JsonTest
         end
         
         it "generates warning with inappropriate hash in debugging mode" do
-          
         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
     end
   end
 
@@ -52,11 +110,6 @@ module JsonTest
         assert_equal "Bombshell Rocks", band.name
       end
       
-      it "#from_json accepts hash, too" do
-        band = Band.from_json({"band" => {"name" => "Bombshell Rocks"}})
-        assert_equal "Bombshell Rocks", band.name
-      end
-      
       it "#to_json serializes correctly" do
         band = Band.new
         band.name = "Cigar"
@@ -77,8 +130,8 @@ module JsonTest
       end
       
       it "#from_json creates one Item instance" do
-        album = Album.from_json({:album => {:label => "Fat Wreck"}}.to_json)
-        assert_equal "Bad Religion", album.label.name
+        album = Album.from_json('{"album":{"label":{"name":"Fat Wreck"}}}')
+        assert_equal "Fat Wreck", album.label.name
       end
       
       it "#to_json serializes" do

data/test/representable_test.rb

@@ -25,7 +25,6 @@ class RepresentableTest < MiniTest::Spec
   end
   
   
-  
   describe "#representable_property" do
     it "creates accessors for the attribute" do
       @band = PunkBand.new
@@ -87,6 +86,53 @@ class RepresentableTest < MiniTest::Spec
     it "returns Definition class" do
       assert_equal Representable::Definition, Band.definition_class
     end
+  end
+
+  
+  require 'representable/json'  # DISCUSS: i don't like the JSON requirement here, what about some generic test module?
+  class PopBand
+    include Representable::JSON
+    representable_property :name
+    representable_property :groupies
+  end
+
+  describe "#update_properties_from" do
+    it "copies values from document to object" do
+      band = PopBand.new
+      band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2})
+      assert_equal "No One's Choice", band.name
+      assert_equal 2, band.groupies
+    end
+    
+    it "skips elements when block returns false" do
+      band = PopBand.new
+      band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}) do |binding|
+        binding.definition.name == "name"
+      end
+      assert_equal "No One's Choice", band.name
+      assert_equal nil, band.groupies
+    end
+    
+    it "always returns self" do
+      band = PopBand.new
+      assert_equal band, band.update_properties_from({"name"=>"Nofx"})
+    end
+  end
+  
+  describe "#create_representation_with" do
+    before do
+      @band = PopBand.new
+      @band.name = "No One's Choice"
+      @band.groupies = 2
+    end
+    
+    it "compiles document from properties in object" do
+      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.send(:create_representation_with, {}))
+    end
     
+    it "skips elements when block returns false" do
+      assert_equal({"name"=>"No One's Choice"}, @band.send(:create_representation_with, {}) do |binding| binding.definition.name == "name" end)
+    end
   end
+  
 end

data/test/xml_test.rb

@@ -22,6 +22,15 @@ class XmlTest < MiniTest::Spec
   Def = Representable::Definition
   
   describe "Xml module" do
+    before do
+      @Band = Class.new do
+        include Representable::XML
+        self.representation_name= :band
+        representable_property :name
+        representable_property :label
+      end
+    end
+      
     class Band
       include Representable::XML
       representable_property :href,   :from => "@href"
@@ -34,19 +43,34 @@ class XmlTest < MiniTest::Spec
   
     describe "#binding_for_definition" do
       it "returns AttributeBinding" do
-        assert_kind_of XML::AttributeBinding, XML.binding_for_definition(Def.new(:band, :from => "@band"))
+        assert_kind_of XML::AttributeBinding, Band.binding_for_definition(Def.new(:band, :from => "@band"))
       end
       
       it "returns ObjectBinding" do
-        assert_kind_of XML::ObjectBinding, XML.binding_for_definition(Def.new(:band, :as => Hash))
+        assert_kind_of XML::ObjectBinding, Band.binding_for_definition(Def.new(:band, :as => Hash))
       end
       
-      #it "returns NamespaceBinding" do
-      #  assert_kind_of Xml::AttributeBinding, Xml.binding_for_definition(Def.new(:band, :from => "@band"))
-      #end
-      
       it "returns TextBinding" do
-        assert_kind_of XML::TextBinding, XML.binding_for_definition(Def.new(:band, :from => :content))
+        assert_kind_of XML::TextBinding, Band.binding_for_definition(Def.new(:band, :from => :content))
+      end
+    end
+    
+    describe "#from_xml" do
+      before do
+        @band = @Band.new
+      end
+      
+      it "accepts xml string" do
+        @band.from_xml(%{<band><name>Nofx</name><label>NOFX</label></band>})
+        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|
+          binding.definition.name == "name"
+        end
+        
+        assert_equal ["Nofx", nil], [@band.name, @band.label]
       end
     end
   end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 0
-  version: 0.9.0
+  - 1
+  version: 0.9.1
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-05 00:00:00 +02:00
+date: 2011-11-22 00:00:00 -02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,7 +70,7 @@ dependencies:
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: test_xml
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
@@ -83,16 +83,17 @@ dependencies:
   type: :development
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: test_xml
+  name: minitest
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
-        - 0
-        version: "0"
+        - 2
+        - 8
+        version: "2.8"
   type: :development
   version_requirements: *id006
 description: Maps representation documents from and to Ruby objects. Includes XML and JSON support, plain properties and compositions.
@@ -108,6 +109,7 @@ files:
 - .gitignore
 - .gitmodules
 - .rspec
+- .travis.yml
 - CHANGES.textile
 - Gemfile
 - LICENSE
@@ -123,6 +125,7 @@ files:
 - lib/representable/xml.rb
 - representable.gemspec
 - test/bindings_test.rb
+- test/definition_test.rb
 - test/json_test.rb
 - test/representable_test.rb
 - test/test_helper.rb