representable 2.4.1 → 3.0.0

data/test-with-deprecations/uncategorized_test.rb

@@ -1,67 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,503 +0,0 @@
-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