representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/uncategorized_test.rb

@@ -0,0 +1,67 @@
+require "test_helper"
+
+class StopWhenIncomingObjectFragmentIsNilTest < MiniTest::Spec
+  Album = Struct.new(:id, :songs)
+  Song  = Struct.new(:title)
+
+  representer!(decorator: true) do
+    property :id
+    collection :songs, class: Song, parse_pipeline: ->(input, options) { # TODO: test if :doc is set for parsing. test if options are ok and contain :user_options!
+                Representable::Pipeline[*parse_functions.insert(3, Representable::StopOnNil)]
+                } do
+      property :title
+    end
+  end
+
+  it do
+    album = Album.new
+    representer.new(album).from_hash({"id"=>1, "songs"=>[{"title"=>"Walkie Talkie"}]}).songs.must_equal [Song.new("Walkie Talkie")]
+  end
+
+  it do
+    album = Album.new(2, ["original"])
+    representer.new(album).from_hash({"id"=>1, "songs"=>nil}).songs.must_equal ["original"]
+  end
+
+end
+
+class RenderPipelineOptionTest < MiniTest::Spec
+  Album   = Struct.new(:id, :songs)
+  NilToNA = ->(input, options) { input.nil? ? "n/a" : input }
+
+  representer!(decorator: true) do
+    property :id, render_pipeline: ->(input, options) do
+      Representable::Pipeline[*render_functions.insert(2, options[:options][:user_options][:function])]
+    end
+  end
+
+  it { representer.new(Album.new).to_hash(function: NilToNA).must_equal({"id"=>"n/a"}) }
+  it { representer.new(Album.new(1)).to_hash(function: NilToNA).must_equal({"id"=>1}) }
+
+  it "is cached" do
+    decorator = representer.new(Album.new)
+    decorator.to_hash(function: NilToNA).must_equal({"id"=>"n/a"})
+    decorator.to_hash(function: nil).must_equal({"id"=>"n/a"}) # non-sense function is not applied.
+  end
+
+end
+
+class ParsePipelineOptionTest < MiniTest::Spec
+  Album   = Struct.new(:id, :songs)
+  NilToNA = ->(input, options) { input.nil? ? "n/a" : input }
+
+  representer!(decorator: true) do
+    property :id, parse_pipeline: ->(input, options) do
+      Representable::Pipeline[*parse_functions.insert(3, options[:options][:user_options][:function])].extend(Representable::Pipeline::Debug)
+    end
+  end
+
+  it { representer.new(Album.new).from_hash({"id"=>nil}, function: NilToNA).id.must_equal "n/a" }
+  it { representer.new(Album.new(1)).to_hash(function: NilToNA).must_equal({"id"=>1}) }
+
+  it "is cached" do
+    decorator = representer.new(Album.new)
+    decorator.from_hash({"id"=>nil}, function: NilToNA).id.must_equal "n/a"
+    decorator.from_hash({"id"=>nil}, function: "nonsense").id.must_equal "n/a" # non-sense function is not applied.
+  end
+end

data/test-with-deprecations/user_options_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+
+class UserOptionsTest < Minitest::Spec
+  Song = Struct.new(:title)
+
+  representer! do
+    property :title, if: ->(options) { options[:visible] }
+  end
+
+  it { Song.new("Run With It").extend(representer).to_hash.must_equal({}) }
+  it { Song.new("Run With It").extend(representer).to_hash(visible: true).must_equal({"title"=>"Run With It"}) }
+  it { Song.new("Run With It").extend(representer).from_hash("title"=>"Business Conduct").title.must_equal "Run With It" }
+  it { Song.new("Run With It").extend(representer).from_hash({"title"=>"Business Conduct"}, visible: true).title.must_equal "Business Conduct" }
+end
+# Representable.deprecations=false

data/test-with-deprecations/wrap_test.rb

@@ -0,0 +1,152 @@
+require "test_helper"
+
+class WrapTest < MiniTest::Spec
+  class HardcoreBand
+    include Representable::Hash
+  end
+
+  class SoftcoreBand < HardcoreBand
+  end
+
+  let (:band) { HardcoreBand.new }
+
+  it "returns false per default" do
+    assert_equal nil, SoftcoreBand.new.send(:representation_wrap)
+  end
+
+  it "infers a printable class name if set to true" do
+    HardcoreBand.representation_wrap = true
+    assert_equal "hardcore_band", band.send(:representation_wrap)
+  end
+
+  it "can be set explicitely" do
+    HardcoreBand.representation_wrap = "breach"
+    assert_equal "breach", band.send(:representation_wrap)
+  end
+
+  for_formats(
+    :hash => [Representable::Hash, {"Blink182"=>{"genre"=>"Pop"}}, {"Blink182"=>{"genre"=>"Poppunk"}}],
+    :json => [Representable::JSON, "{\"Blink182\":{\"genre\":\"Pop\"}}", "{\"Blink182\":{\"genre\":\"Poppunk\"}}"],
+    :xml  => [Representable::XML, "<Blink182><genre>Pop</genre></Blink182>", "<Blink182><genre>Poppunk</genre></Blink182>"],
+    # :yaml => [Representable::YAML, "---\nBlink182:\n"], # TODO: fix YAML.
+  ) do |format, mod, output, input|
+
+    describe "[#{format}] dynamic wrap" do
+      let (:band) { representer.prepare(Struct.new(:name, :genre).new("Blink", "Pop")) }
+      let (:format) { format }
+
+      representer!(:module => mod) do
+        self.representation_wrap = lambda { |args| "#{name}#{args[:number]}" }
+        property :genre
+      end
+
+      it { render(band, {:number => 182}).must_equal_document(output) }
+
+      it { parse(band, input, {:number => 182}).genre.must_equal "Poppunk" } # TODO: better test. also, xml parses _any_ wrap.
+    end
+  end
+end
+
+
+class HashDisableWrapTest < MiniTest::Spec
+  Band  = Struct.new(:name, :label)
+  Album = Struct.new(:band)
+  Label = Struct.new(:name)
+
+  class BandDecorator < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = :bands
+    property :name
+
+    property :label do # this should have a wrap!
+      self.representation_wrap = :important
+      property :name
+    end
+  end
+
+  let (:band) { BandDecorator.prepare(Band.new("Social Distortion")) }
+
+  # direct, local api.
+  it do
+    band.to_hash.must_equal({"bands" => {"name"=>"Social Distortion"}})
+    band.to_hash(wrap: false).must_equal({"name"=>"Social Distortion"})
+    band.to_hash(wrap: :band).must_equal(:band=>{"name"=>"Social Distortion"})
+  end
+
+  it do
+    band.from_hash({"bands" => {"name"=>"Social Distortion"}}).name.must_equal "Social Distortion"
+    band.from_hash({"name"=>"Social Distortion"}, wrap: false).name.must_equal "Social Distortion"
+    band.from_hash({band: {"name"=>"Social Distortion"}}, wrap: :band).name.must_equal "Social Distortion"
+  end
+
+
+  class AlbumDecorator < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = :albums
+
+    property :band, decorator: BandDecorator, wrap: false, class: Band
+  end
+
+
+  let (:album) { AlbumDecorator.prepare(Album.new(Band.new("Social Distortion", Label.new("Epitaph")))) }
+
+  # band has wrap turned off per property definition, however, label still has wrap.
+  it "renders" do
+    album.to_hash.must_equal({"albums" => {"band" => {"name"=>"Social Distortion", "label"=>{"important"=>{"name"=>"Epitaph"}}}}})
+  end
+
+  it "parses" do
+    album.from_hash({"albums" => {"band" => {"name"=>"Rvivr"}}}).band.name.must_equal "Rvivr"
+  end
+end
+
+
+class XMLDisableWrapTest < MiniTest::Spec
+  Band  = Struct.new(:name, :label)
+  Album = Struct.new(:band)
+  Label = Struct.new(:name)
+
+  class BandDecorator < Representable::Decorator
+    include Representable::XML
+
+    self.representation_wrap = :bands # when nested, it uses this.
+    property :name
+
+    # property :label do # this should have a wrap!
+    #   self.representation_wrap = :important
+    #   property :name
+    # end
+  end
+
+  let (:band) { BandDecorator.prepare(Band.new("Social Distortion")) }
+
+  it do
+    band.to_xml.must_equal_xml "<bands><name>Social Distortion</name></bands>"
+    band.to_xml(wrap: "combo").must_equal_xml "<combo><name>Social Distortion</name></combo>"
+  end
+
+
+  class AlbumDecorator < Representable::Decorator
+    include Representable::XML
+
+    self.representation_wrap = :albums
+
+    property :band, decorator: BandDecorator, wrap: "po", class: Band
+  end
+
+
+  let (:album) { AlbumDecorator.prepare(Album.new(Band.new("Social Distortion", Label.new("Epitaph")))) }
+
+  # band has wrap turned of per property definition, however, label still has wrap.
+  it "rendersxx" do
+    skip
+    album.to_xml.must_equal({"albums" => {"band" => {"name"=>"Social Distortion", "label"=>{"important"=>{"name"=>"Epitaph"}}}}})
+  end
+
+  # it "parses" do
+  #   album.from_hash({"albums" => {"band" => {"name"=>"Rvivr"}}}).band.name.must_equal "Rvivr"
+  # end
+end
+

data/test-with-deprecations/xml_bindings_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+require 'representable/json'  # FIXME.
+require 'representable/xml/collection'
+require 'representable/xml/hash'
+
+require 'representable/xml'
+
+class XMLBindingTest < MiniTest::Spec
+  module SongRepresenter
+    include Representable::XML
+    property :name
+    self.representation_wrap = :song
+  end
+
+  class SongWithRepresenter < ::Song
+    include Representable
+    include SongRepresenter
+    self.representation_wrap = :song
+  end
+
+  before do
+    @doc  = Nokogiri::XML::Document.new
+    @song = SongWithRepresenter.new("Thinning the Herd")
+  end
+
+
+
+
+  describe "AttributeBinding" do
+    describe "with plain text items" do
+      before do
+        @property = Representable::XML::Binding::Attribute.new(Representable::Definition.new(:name, :attribute => true))
+      end
+
+      it "extracts with #read" do
+        assert_equal "The Gargoyle", @property.read(Nokogiri::XML("<song name=\"The Gargoyle\" />").root, "name")
+      end
+
+      it "inserts with #write" do
+        parent = Nokogiri::XML::Node.new("song", @doc)
+        @property.write(parent, "The Gargoyle", "name")
+        assert_xml_equal("<song name=\"The Gargoyle\" />", parent.to_s)
+      end
+    end
+  end
+
+  describe "ContentBinding" do
+    before do
+      @property = Representable::XML::Binding::Content.new(Representable::Definition.new(:name, :content => true))
+    end
+
+    it "extracts with #read" do
+      assert_equal "The Gargoyle", @property.read(Nokogiri::XML("<song>The Gargoyle</song>").root, "song")
+    end
+
+    it "inserts with #write" do
+      parent = Nokogiri::XML::Node.new("song", @doc)
+      @property.write(parent, "The Gargoyle", "song")
+      assert_xml_equal("<song>The Gargoyle</song>", parent.to_s)
+    end
+  end
+end

data/test-with-deprecations/xml_test.rb

@@ -0,0 +1,503 @@
+require 'test_helper'
+require 'representable/xml'
+
+class Band
+  include Representable::XML
+  property :name
+  attr_accessor :name
+
+  def initialize(name=nil)
+    name and self.name = name
+  end
+end
+
+class Album
+  attr_accessor :songs
+end
+
+
+class XmlTest < MiniTest::Spec
+  XML = Representable::XML
+  Def = Representable::Definition
+
+  describe "Xml module" do
+    before do
+      @Band = Class.new do
+        include Representable::XML
+        self.representation_wrap = :band
+        property :name
+        property :label
+        attr_accessor :name, :label
+      end
+
+      @band = @Band.new
+    end
+
+
+    describe "#from_xml" do
+      before do
+        @band = @Band.new
+        @xml  = %{<band><name>Nofx</name><label>NOFX</label></band>}
+      end
+
+      it "parses XML and assigns properties" do
+        @band.from_xml(@xml)
+        assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+      end
+    end
+
+    describe "#from_xml with remove_namespaces! and xmlns present" do
+      before do
+        @Band.remove_namespaces!
+        @band = @Band.new
+        @xml = %{<band xmlns="exists"><name>Nofx</name><label>NOFX</label></band>}
+      end
+
+      it "parses with xmlns present" do
+        @band.from_xml(@xml)
+        assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+      end
+    end
+
+    describe "#from_node" do
+      before do
+        @band = @Band.new
+        @xml  = Nokogiri::XML(%{<band><name>Nofx</name><label>NOFX</label></band>}).root
+      end
+
+      it "receives Nokogiri node and assigns properties" do
+        @band.from_node(@xml)
+        assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+      end
+    end
+
+
+    describe "#to_xml" do
+      it "delegates to #to_node and returns string" do
+        assert_xml_equal "<band><name>Rise Against</name></band>", Band.new("Rise Against").to_xml
+      end
+    end
+
+
+    describe "#to_node" do
+      it "returns Nokogiri node" do
+        node = Band.new("Rise Against").to_node
+        assert_kind_of Nokogiri::XML::Element, node
+      end
+
+      it "wraps with infered class name per default" do
+        node = Band.new("Rise Against").to_node
+        assert_xml_equal "<band><name>Rise Against</name></band>", node.to_s
+      end
+
+      it "respects #representation_wrap=" do
+        klass = Class.new(Band) do
+          include Representable
+          property :name
+        end
+
+        klass.representation_wrap = :group
+        assert_xml_equal "<group><name>Rise Against</name></group>", klass.new("Rise Against").to_node.to_s
+      end
+    end
+
+
+    describe "XML::Binding#build_for" do
+      it "returns AttributeBinding" do
+        assert_kind_of XML::Binding::Attribute, XML::Binding.build_for(Def.new(:band, :as => "band", :attribute => true))
+      end
+
+      it "returns Binding" do
+        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :class => Hash))
+        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :as => :content))
+      end
+
+      it "returns CollectionBinding" do
+        assert_kind_of XML::Binding::Collection, XML::Binding.build_for(Def.new(:band, :collection => :true))
+      end
+
+      it "returns HashBinding" do
+        assert_kind_of XML::Binding::Hash, XML::Binding.build_for(Def.new(:band, :hash => :true))
+      end
+    end
+
+
+    describe "DCI" do
+      module SongRepresenter
+        include Representable::XML
+        property :name
+        representation_wrap = :song
+      end
+
+      module AlbumRepresenter
+        include Representable::XML
+        property :best_song, :class => Song, :extend => SongRepresenter
+        collection :songs, :class => Song, :as => :song, :extend => SongRepresenter
+        representation_wrap = :album
+      end
+
+
+      it "allows adding the representer by using #extend" do
+        module BandRepresenter
+          include Representable::XML
+          property :name
+        end
+
+        civ = Object.new
+        civ.instance_eval do
+          def name; "CIV"; end
+          def name=(v)
+            @name = v
+          end
+        end
+
+        civ.extend(BandRepresenter)
+        assert_xml_equal "<object><name>CIV</name></object>", civ.to_xml
+      end
+
+      it "extends contained models when serializing" do
+        @album = Album.new([Song.new("I Hate My Brain"), mr=Song.new("Mr. Charisma")], mr)
+        @album.extend(AlbumRepresenter)
+
+        assert_xml_equal "<album>
+  <song><name>Mr. Charisma</name></song>
+  <song><name>I Hate My Brain</name></song>
+  <song><name>Mr. Charisma</name></song>
+</album>", @album.to_xml
+      end
+
+      it "extends contained models when deserializing" do
+        @album = Album.new
+        @album.extend(AlbumRepresenter)
+
+        @album.from_xml("<album><best_song><name>Mr. Charisma</name></best_song><song><name>I Hate My Brain</name></song><song><name>Mr. Charisma</name></song></album>")
+        assert_equal "Mr. Charisma", @album.best_song.name
+      end
+    end
+  end
+end
+
+
+class AttributesTest < MiniTest::Spec
+  describe ":as => rel, :attribute => true" do
+    class Link
+      include Representable::XML
+      property :href,   :as => "href",  :attribute => true
+      property :title,  :as => "title", :attribute => true
+      attr_accessor :href, :title
+    end
+
+    it "#from_xml creates correct accessors" do
+      link = Link.new.from_xml(%{
+        <a href="http://apotomo.de" title="Home, sweet home" />
+      })
+      assert_equal "http://apotomo.de", link.href
+      assert_equal "Home, sweet home",  link.title
+    end
+
+    it "#to_xml serializes correctly" do
+      link = Link.new
+      link.href = "http://apotomo.de/"
+
+      assert_xml_equal %{<link href="http://apotomo.de/">}, link.to_xml
+    end
+  end
+end
+
+
+class CDataBand
+  class CData < Representable::XML::Binding
+    def serialize_node(parent, value)
+      parent << Nokogiri::XML::CDATA.new(parent, represented.name)
+    end
+  end
+
+  include Representable::XML
+  property :name, :binding => lambda { |*args| CData.new(*args) }#getter: lambda { |opt| Nokogiri::XML::CDATA.new(opt[:doc], name) }
+  attr_accessor :name
+
+  def initialize(name=nil)
+    name and self.name = name
+  end
+end
+
+class TypedPropertyTest < MiniTest::Spec
+  module AlbumRepresenter
+    include Representable::XML
+    property :band, :class => Band
+  end
+
+  class Album
+    attr_accessor :band
+    def initialize(band=nil)
+      @band = band
+    end
+  end
+
+  # TODO:property :group, :class => Band
+  # :class
+  # where to mixin DCI?
+  describe ":class => Item" do
+    it "#from_xml creates one Item instance" do
+      album = Album.new.extend(AlbumRepresenter).from_xml(%{
+        <album>
+          <band><name>Bad Religion</name></band>
+        </album>
+      })
+      assert_equal "Bad Religion", album.band.name
+    end
+
+    describe "#to_xml" do
+      it "doesn't escape xml from Band#to_xml" do
+        band = Band.new("Bad Religion")
+        album = Album.new(band).extend(AlbumRepresenter)
+
+        assert_xml_equal %{<album>
+         <band>
+           <name>Bad Religion</name>
+         </band>
+       </album>}, album.to_xml
+      end
+
+      it "doesn't escape and wrap string from Band#to_node" do
+        band = Band.new("Bad Religion")
+        band.instance_eval do
+          def to_node(*)
+            "<band>Baaaad Religion</band>"
+          end
+        end
+
+        assert_xml_equal %{<album><band>Baaaad Religion</band></album>}, Album.new(band).extend(AlbumRepresenter).to_xml
+      end
+    end
+
+    describe "#to_xml with CDATA" do
+      it "wraps Band name in CDATA#to_xml" do
+        band = CDataBand.new("Bad Religion")
+        album = Album.new(band).extend(AlbumRepresenter)
+
+        assert_xml_equal %{<album>
+         <c_data_band>
+           <name><![CDATA[Bad Religion]]></name>
+         </c_data_band>
+       </album>}, album.to_xml
+      end
+    end
+  end
+end
+
+
+class CollectionTest < MiniTest::Spec
+  describe ":class => Band, :as => :band, :collection => true" do
+    class Compilation
+      include Representable::XML
+      collection :bands, :class => Band, :as => :band
+      attr_accessor :bands
+    end
+
+    describe "#from_xml" do
+      it "pushes collection items to array" do
+        cd = Compilation.new.from_xml(%{
+          <compilation>
+            <band><name>Diesel Boy</name></band>
+            <band><name>Cobra Skulls</name></band>
+          </compilation>
+        })
+        assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
+      end
+    end
+
+    it "responds to #to_xml" do
+      cd = Compilation.new
+      cd.bands = [Band.new("Diesel Boy"), Band.new("Bad Religion")]
+
+      assert_xml_equal %{<compilation>
+        <band><name>Diesel Boy</name></band>
+        <band><name>Bad Religion</name></band>
+      </compilation>}, cd.to_xml
+    end
+  end
+
+
+  describe ":as" do
+    let(:xml_doc) {
+      Module.new do
+        include Representable::XML
+        collection :songs, :as => :song
+      end }
+
+    it "collects untyped items" do
+      album = Album.new.extend(xml_doc).from_xml(%{
+        <album>
+          <song>Two Kevins</song>
+          <song>Wright and Rong</song>
+          <song>Laundry Basket</song>
+        </album>
+      })
+      assert_equal ["Laundry Basket", "Two Kevins", "Wright and Rong"].sort, album.songs.sort
+    end
+  end
+
+
+  describe ":wrap" do
+    let (:album) { Album.new.extend(xml_doc) }
+    let (:xml_doc) {
+      Module.new do
+        include Representable::XML
+        collection :songs, :as => :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'
+  class LonelyRepresenterTest < MiniTest::Spec
+    # TODO: where is the XML::Hash test?
+    module SongRepresenter
+      include Representable::XML
+      property :name
+      self.representation_wrap = :song
+    end
+
+    let (:decorator) { rpr = representer; Class.new(Representable::Decorator) { include Representable::XML; include rpr } }
+
+    describe "XML::Collection" do
+      describe "with contained objects" do
+        representer!(:module => Representable::XML::Collection)  do
+          items :class => Song, :extend => SongRepresenter
+          self.representation_wrap= :songs
+        end
+
+        let (:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
+        let (:xml_doc)   { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
+
+        it "renders array" do
+          songs.extend(representer).to_xml.must_equal_xml xml_doc
+        end
+
+        it "renders array with decorator" do
+          decorator.new(songs).to_xml.must_equal_xml xml_doc
+        end
+
+        it "parses array" do
+          [].extend(representer).from_xml(xml_doc).must_equal songs
+        end
+
+        it "parses array with decorator" do
+          decorator.new([]).from_xml(xml_doc).must_equal songs
+        end
+      end
+    end
+
+    describe "XML::AttributeHash" do  # TODO: move to HashTest.
+      representer!(:module => Representable::XML::AttributeHash) do
+        self.representation_wrap= :songs
+      end
+
+      let (:songs) { {"one" => "Graveyards", "two" => "Can't Take Them All"} }
+      let (:xml_doc)   { "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
+
+      describe "#to_xml" do
+        it "renders hash" do
+          songs.extend(representer).to_xml.must_equal_xml xml_doc
+        end
+
+        it "respects :exclude" do
+          assert_xml_equal "<favs two=\"Can't Take Them All\" />", songs.extend(representer).to_xml(:exclude => [:one])
+        end
+
+        it "respects :include" do
+          assert_xml_equal "<favs two=\"Can't Take Them All\" />", songs.extend(representer).to_xml(:include => [:two])
+        end
+
+        it "renders hash with decorator" do
+          decorator.new(songs).to_xml.must_equal_xml xml_doc
+        end
+      end
+
+      describe "#from_json" do
+        it "returns hash" do
+          {}.extend(representer).from_xml(xml_doc).must_equal songs
+        end
+
+        it "respects :exclude" do
+          assert_equal({"two" => "Can't Take Them All"}, {}.extend(representer).from_xml(xml_doc, :exclude => [:one]))
+        end
+
+        it "respects :include" do
+          assert_equal({"one" => "Graveyards"}, {}.extend(representer).from_xml(xml_doc, :include => [:one]))
+        end
+
+        it "parses hash with decorator" do
+          decorator.new({}).from_xml(xml_doc).must_equal songs
+        end
+      end
+    end
+  end
+end
+
+class XmlHashTest < MiniTest::Spec
+  # scalar, no object
+  describe "plain text" do
+    representer!(module: Representable::XML) do
+      hash :songs
+    end
+
+    let (:doc) { "<open_struct><first>The Gargoyle</first><second>Bronx</second></open_struct>" }
+
+    # to_xml
+    it { OpenStruct.new(songs: {"first" => "The Gargoyle", "second" => "Bronx"}).extend(representer).to_xml.must_equal_xml(doc) }
+    # FIXME: this NEVER worked!
+    # it { OpenStruct.new.extend(representer).from_xml(doc).songs.must_equal({"first" => "The Gargoyle", "second" => "Bronx"}) }
+  end
+
+  describe "with objects" do
+    representer!(module: Representable::XML) do
+      hash :songs, class: OpenStruct do
+        property :title
+      end
+    end
+
+    let (:doc) { "<open_struct>
+  <open_struct>
+    <title>The Gargoyle</title>
+  </open_struct>
+  <open_struct>
+    <title>Bronx</title>
+  </open_struct>
+</open_struct>" }
+
+    # to_xml
+    it { OpenStruct.new(songs: {"first" => OpenStruct.new(title: "The Gargoyle"), "second" => OpenStruct.new(title: "Bronx")}).extend(representer).to_xml.must_equal_xml(doc) }
+    # FIXME: this NEVER worked!
+    # it { OpenStruct.new.extend(representer).from_xml(doc).songs.must_equal({"first" => "The Gargoyle", "second" => "Bronx"}) }
+  end
+end