representable 3.2.0 → 3.3.0

data/test/skip_test.rb

@@ -1,16 +1,18 @@
-require 'test_helper'
+require "test_helper"
 
-class SkipParseTest < MiniTest::Spec
+class SkipParseTest < Minitest::Spec
   representer! do
-    property :title, skip_parse: lambda { |options| options[:user_options][:skip?] and options[:fragment] == "skip me" }
+    property :title, skip_parse: ->(options) { options[:user_options][:skip?] and options[:fragment] == "skip me" }
     property :band,
-      skip_parse: lambda { |options| options[:user_options][:skip?] and options[:fragment]["name"].nil? }, class: OpenStruct do
-        property :name
+             skip_parse: ->(options) { options[:user_options][:skip?] and options[:fragment]["name"].nil? }, class: OpenStruct do
+      property :name
     end
 
     collection :airplays,
-      skip_parse: lambda { |options| options[:user_options][:skip?] and options[:fragment]["station"].nil? }, class: OpenStruct do
-        property :station
+               skip_parse: ->(options) {
+                             options[:user_options][:skip?] and options[:fragment]["station"].nil?
+                           }, class: OpenStruct do
+      property :station
     end
   end
 
@@ -18,11 +20,13 @@ class SkipParseTest < MiniTest::Spec
 
   # do parse.
   it do
-    song.from_hash({
-      "title"    => "Victim Of Fate",
-      "band"     => {"name" => "Mute 98"},
-      "airplays" => [{"station" => "JJJ"}]
-    }, user_options: { skip?: true })
+    song.from_hash(
+      {
+        "title"    => "Victim Of Fate",
+        "band"     => {"name" => "Mute 98"},
+        "airplays" => [{"station" => "JJJ"}]
+      }, user_options: {skip?: true}
+    )
 
     _(song.title).must_equal "Victim Of Fate"
     _(song.band.name).must_equal "Mute 98"
@@ -33,11 +37,13 @@ class SkipParseTest < MiniTest::Spec
   let(:airplay) { OpenStruct.new(station: "JJJ") }
 
   it do
-    song.from_hash({
-      "title"    => "skip me",
-      "band"     => {},
-      "airplays" => [{}, {"station" => "JJJ"}, {}],
-    }, user_options: { skip?: true })
+    song.from_hash(
+      {
+        "title"    => "skip me",
+        "band"     => {},
+        "airplays" => [{}, {"station" => "JJJ"}, {}]
+      }, user_options: {skip?: true}
+    )
 
     _(song.title).must_be_nil
     _(song.band).must_be_nil
@@ -45,17 +51,17 @@ class SkipParseTest < MiniTest::Spec
   end
 end
 
-class SkipRenderTest < MiniTest::Spec
+class SkipRenderTest < Minitest::Spec
   representer! do
     property :title
     property :band,
-      skip_render: lambda { |options| options[:user_options][:skip?] and options[:input].name == "Rancid" } do
-        property :name
+             skip_render: ->(options) { options[:user_options][:skip?] and options[:input].name == "Rancid" } do
+      property :name
     end
 
     collection :airplays,
-      skip_render: lambda { |options| options[:user_options][:skip?] and options[:input].station == "Radio Dreyeckland" } do
-        property :station
+               skip_render: ->(options) { options[:user_options][:skip?] and options[:input].station == "Radio Dreyeckland" } do
+      property :station
     end
   end
 
@@ -63,19 +69,24 @@ class SkipRenderTest < MiniTest::Spec
   let(:skip_song) { OpenStruct.new(title: "Time Bomb",   band: OpenStruct.new(name: "Rancid")).extend(representer) }
 
   # do render.
-  it { _(song.to_hash(user_options: { skip?: true })).must_equal({"title"=>"Black Night", "band"=>{"name"=>"Time Again"}}) }
+  it { _(song.to_hash(user_options: {skip?: true})).must_equal({"title" => "Black Night", "band" => {"name"=>"Time Again"}}) }
   # skip.
-  it { _(skip_song.to_hash(user_options: { skip?: true })).must_equal({"title"=>"Time Bomb"}) }
+  it { _(skip_song.to_hash(user_options: {skip?: true})).must_equal({"title"=>"Time Bomb"}) }
 
   # do render all collection items.
   it do
     song = OpenStruct.new(airplays: [OpenStruct.new(station: "JJJ"), OpenStruct.new(station: "ABC")]).extend(representer)
-    _(song.to_hash(user_options: { skip?: true })).must_equal({"airplays"=>[{"station"=>"JJJ"}, {"station"=>"ABC"}]})
+    _(song.to_hash(user_options: {skip?: true})).must_equal({"airplays"=>[{"station"=>"JJJ"}, {"station"=>"ABC"}]})
   end
 
   # skip middle item.
   it do
-    song = OpenStruct.new(airplays: [OpenStruct.new(station: "JJJ"), OpenStruct.new(station: "Radio Dreyeckland"), OpenStruct.new(station: "ABC")]).extend(representer)
-    _(song.to_hash(user_options: { skip?: true })).must_equal({"airplays"=>[{"station"=>"JJJ"}, {"station"=>"ABC"}]})
+    song = OpenStruct.new(
+      airplays: [
+        OpenStruct.new(station: "JJJ"), OpenStruct.new(station: "Radio Dreyeckland"),
+        OpenStruct.new(station: "ABC")
+      ]
+    ).extend(representer)
+    _(song.to_hash(user_options: {skip?: true})).must_equal({"airplays"=>[{"station"=>"JJJ"}, {"station"=>"ABC"}]})
   end
-end
+end

data/test/stringify_hash_test.rb

@@ -1,41 +1,39 @@
-require 'test_helper'
+require "test_helper"
 
-class StringifyHashTest < MiniTest::Spec
-describe "#from_hash" do
-  representer!(:name => :song_representer) do
-
-    include Representable::Hash
-    include Representable::Hash::AllowSymbols
-
-    property :title
-  end
-
-  representer!(:inject => :song_representer) do
-    include Representable::Hash::AllowSymbols
-
-    property :song, :extend => song_representer, :class => OpenStruct
-   end
-
-   it "parses symbols, too" do
-     _(OpenStruct.new.extend(representer).from_hash({:song => {:title => "Der Optimist"}}).song.title).must_equal "Der Optimist"
-   end
+class StringifyHashTest < Minitest::Spec
+  describe "#from_hash" do
+    representer!(:name => :song_representer) do
+      include Representable::Hash
+      include Representable::Hash::AllowSymbols
 
-   it "still parses strings" do
-     _(OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Der Optimist"}}).song.title).must_equal "Der Optimist"
-   end
+      property :title
+    end
 
-   describe "with :wrap" do
     representer!(:inject => :song_representer) do
       include Representable::Hash::AllowSymbols
 
-      self.representation_wrap = :album
       property :song, :extend => song_representer, :class => OpenStruct
     end
 
-     it "parses symbols, too" do
-       _(OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title).must_equal "Der Optimist"
-     end
-   end
- end
+    it "parses symbols, too" do
+      _(OpenStruct.new.extend(representer).from_hash({:song => {:title => "Der Optimist"}}).song.title).must_equal "Der Optimist"
+    end
+
+    it "still parses strings" do
+      _(OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Der Optimist"}}).song.title).must_equal "Der Optimist"
+    end
+
+    describe "with :wrap" do
+      representer!(:inject => :song_representer) do
+        include Representable::Hash::AllowSymbols
 
-end
+        self.representation_wrap = :album
+        property :song, :extend => song_representer, :class => OpenStruct
+      end
+
+      it "parses symbols, too" do
+        _(OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title).must_equal "Der Optimist"
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,23 +1,26 @@
-require 'pry-byebug'
-require 'representable'
+require "ostruct"
+require "representable"
 
-require 'minitest/autorun'
-require 'test_xml/mini_test'
+require "minitest/autorun"
 
 require "representable/debug"
-require 'minitest/assertions'
+require "minitest/assertions"
+require "xml_assertions"
 
-module MiniTest::Assertions
-  def assert_equal_xml(text, subject)
-    assert_equal (text.gsub("\n", "").gsub(/(\s\s+)/, "")), subject.gsub("\n", "").gsub(/(\s\s+)/, "")
+module Minitest::Assertions
+  include XmlAssertions
+
+  # Arguments read (asserted, expected), the assertion order used throughout this suite.
+  def assert_equal_xml(subject, text)
+    assert_equal text.gsub("\n", "").gsub(/(\s\s+)/, ""), subject.gsub("\n", "").gsub(/(\s\s+)/, "")
   end
 end
-String.infect_an_assertion :assert_equal_xml, :must_xml
 
 # TODO: delete all that in 4.0:
 class Album
   attr_accessor :songs, :best_song
-  def initialize(songs=nil, best_song=nil)
+
+  def initialize(songs = nil, best_song = nil)
     @songs      = songs
     @best_song  = best_song
   end
@@ -29,7 +32,8 @@ end
 
 class Song
   attr_accessor :name, :track # never change this, track rendered with Rails#to_json.
-  def initialize(name=nil, track=nil)
+
+  def initialize(name = nil, track = nil)
     @name   = name
     @track  = track
   end
@@ -47,14 +51,14 @@ end
 
 module AssertJson
   module Assertions
-    def assert_json(expected, actual, msg=nil)
+    def assert_json(expected, actual, msg = nil)
       msg = message(msg, "") { diff expected, actual }
       assert_equal(expected.split("").sort, actual.split("").sort, msg)
     end
   end
 end
 
-MiniTest::Spec.class_eval do
+Minitest::Spec.class_eval do
   include AssertJson::Assertions
   include XmlHelper
 
@@ -66,7 +70,7 @@ MiniTest::Spec.class_eval do
   end
 
   def render(object, *args)
-    AssertableDocument.new(object.send("to_#{format}", *args), format)
+    AssertableDocument.new(object.send("to_#{format}", *args), format, self)
   end
 
   def parse(object, input, *args)
@@ -76,17 +80,20 @@ MiniTest::Spec.class_eval do
   class AssertableDocument
     attr_reader :document
 
-    def initialize(document, format)
-      @document, @format = document, format
+    def initialize(document, format, test)
+      @document = document
+      @format = format
+      @test = test
     end
 
-    def must_equal_document(*args)
-      return document.must_equal_xml(*args) if @format == :xml
-      document.must_equal(*args)
+    def must_equal_document(expected, *rest)
+      return @test.assert_xml_equal(document, expected, *rest) if @format == :xml
+
+      @test.assert_equal(expected, document, *rest)
     end
   end
 
-  def self.representer!(options={}, &block)
+  def self.representer!(options = {}, &block)
     fmt = options # we need that so the 2nd call to ::let(within a ::describe) remembers the right format.
 
     name   = options[:name]   || :representer
@@ -119,7 +126,7 @@ MiniTest::Spec.class_eval do
   end
 
   module TestMethods
-    def representer_for(modules=[Representable::Hash], &block)
+    def representer_for(modules = [Representable::Hash], &block)
       Module.new do
         extend TestMethods
         include(*modules)
@@ -127,17 +134,16 @@ MiniTest::Spec.class_eval do
       end
     end
 
-    alias_method :representer!, :representer_for
+    alias representer! representer_for
   end
   include TestMethods
 end
 
-class BaseTest < MiniTest::Spec
+class BaseTest < Minitest::Spec
   let(:new_album)  { OpenStruct.new.extend(representer) }
   let(:album)      { OpenStruct.new(:songs => ["Fuck Armageddon"]).extend(representer) }
   let(:song) { OpenStruct.new(:title => "Resist Stance") }
-  let(:song_representer) { Module.new do include Representable::Hash; property :title end  }
-
+  let(:song_representer) { Module.new { include Representable::Hash; property :title } }
 end
 
 Band = Struct.new(:id, :name) do

data/test/test_helper_test.rb

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

data/test/uncategorized_test.rb

@@ -1,36 +1,42 @@
 require "test_helper"
 
-class StopWhenIncomingObjectFragmentIsNilTest < MiniTest::Spec
+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
+    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")]
+    _(
+      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"]
+    _(representer.new(album).from_hash({"id" => 1, "songs" => nil}).songs).must_equal ["original"]
   end
-
 end
 
-class RenderPipelineOptionTest < MiniTest::Spec
+class RenderPipelineOptionTest < Minitest::Spec
   Album   = Struct.new(:id, :songs)
-  NilToNA = ->(input, options) { input.nil? ? "n/a" : input }
+  NilToNA = ->(input, _options) { input.nil? ? "n/a" : input }
 
   representer!(decorator: true) do
-    property :id, render_pipeline: ->(input, options) do
+    property :id, render_pipeline: ->(_input, options) do
       Representable::Pipeline[*render_functions.insert(2, options[:options][:user_options][:function])]
     end
   end
@@ -43,15 +49,14 @@ class RenderPipelineOptionTest < MiniTest::Spec
     _(decorator.to_hash(user_options: {function: NilToNA})).must_equal({"id"=>"n/a"})
     _(decorator.to_hash(user_options: {function: nil})).must_equal({"id"=>"n/a"}) # non-sense function is not applied.
   end
-
 end
 
-class ParsePipelineOptionTest < MiniTest::Spec
+class ParsePipelineOptionTest < Minitest::Spec
   Album   = Struct.new(:id, :songs)
-  NilToNA = ->(input, options) { input.nil? ? "n/a" : input }
+  NilToNA = ->(input, _options) { input.nil? ? "n/a" : input }
 
   representer!(decorator: true) do
-    property :id, parse_pipeline: ->(input, options) 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
@@ -64,4 +69,4 @@ class ParsePipelineOptionTest < MiniTest::Spec
     _(decorator.from_hash({"id"=>nil}, user_options: {function: NilToNA}).id).must_equal "n/a"
     _(decorator.from_hash({"id"=>nil}, user_options: {function: "nonsense"}).id).must_equal "n/a" # non-sense function is not applied.
   end
-end
+end

data/test/user_options_test.rb

@@ -8,8 +8,17 @@ class UserOptionsTest < Minitest::Spec
   end
 
   it { _(Song.new("Run With It").extend(representer).to_hash).must_equal({}) }
-  it { _(Song.new("Run With It").extend(representer).to_hash(user_options: {visible: true})).must_equal({"title"=>"Run With It"}) }
+  it {
+    _(Song.new("Run With It").extend(representer).to_hash(user_options: {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"}, user_options: {visible: true}).title).must_equal "Business Conduct" }
+  it {
+    _(
+      Song.new("Run With It").extend(representer).from_hash(
+        {"title"=>"Business Conduct"},
+        user_options: {visible: true}
+      ).title
+    ).must_equal "Business Conduct"
+  }
 end
-# Representable.deprecations=false
+# Representable.deprecations=false

data/test/wrap_test.rb

@@ -1,6 +1,6 @@
 require "test_helper"
 
-class WrapTest < MiniTest::Spec
+class WrapTest < Minitest::Spec
   class HardcoreBand
     include Representable::Hash
   end
@@ -27,16 +27,15 @@ class WrapTest < MiniTest::Spec
   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>"],
+    :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 { |number:, **| "#{name}#{number}" }
+        self.representation_wrap = ->(number:, **) { "#{name}#{number}" }
         property :genre
       end
 
@@ -47,8 +46,7 @@ class WrapTest < MiniTest::Spec
   end
 end
 
-
-class HashDisableWrapTest < MiniTest::Spec
+class HashDisableWrapTest < Minitest::Spec
   Band  = Struct.new(:name, :label)
   Album = Struct.new(:band)
   Label = Struct.new(:name)
@@ -80,7 +78,6 @@ class HashDisableWrapTest < MiniTest::Spec
     _(band.from_hash({band: {"name"=>"Social Distortion"}}, wrap: :band).name).must_equal "Social Distortion"
   end
 
-
   class AlbumDecorator < Representable::Decorator
     include Representable::Hash
 
@@ -89,12 +86,20 @@ class HashDisableWrapTest < MiniTest::Spec
     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"}}}}})
+    _(album.to_hash).must_equal(
+      {
+        "albums" => {
+          "band" => {
+            "name"  => "Social Distortion",
+            "label" => {"important"=>{"name"=>"Epitaph"}}
+          }
+        }
+      }
+    )
   end
 
   it "parses" do
@@ -102,8 +107,7 @@ class HashDisableWrapTest < MiniTest::Spec
   end
 end
 
-
-class XMLDisableWrapTest < MiniTest::Spec
+class XMLDisableWrapTest < Minitest::Spec
   Band  = Struct.new(:name, :label)
   Album = Struct.new(:band)
   Label = Struct.new(:name)
@@ -123,11 +127,10 @@ class XMLDisableWrapTest < MiniTest::Spec
   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>"
+    assert_xml_equal(band.to_xml, "<bands><name>Social Distortion</name></bands>")
+    assert_xml_equal(band.to_xml(wrap: "combo"), "<combo><name>Social Distortion</name></combo>")
   end
 
-
   class AlbumDecorator < Representable::Decorator
     include Representable::XML
 
@@ -136,17 +139,24 @@ class XMLDisableWrapTest < MiniTest::Spec
     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"}}}}})
+    _(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/xml_assertions.rb

@@ -0,0 +1,29 @@
+require "nokogiri"
+
+# Order-insensitive XML comparison: attributes are sorted by name and sibling
+# elements by their own canonical form, then both documents are compared as
+# strings.
+module XmlAssertions
+  def self.canonicalize(xml, indent = 0)
+    node = xml.is_a?(String) ? Nokogiri::XML.parse(xml).root : xml
+    return "(unparsable xml)\n#{xml}" if node.nil?
+
+    pad      = "  " * indent
+    attrs    = node.attribute_nodes.map { |a| " #{a.name}=#{a.value.inspect}" }.sort.join
+    children = node.elements
+
+    if children.empty?
+      "#{pad}<#{node.name}#{attrs}>#{node.text.strip}</#{node.name}>\n"
+    else
+      body = children.map { |child| canonicalize(child, indent + 1) }.sort.join
+      "#{pad}<#{node.name}#{attrs}>\n#{body}#{pad}</#{node.name}>\n"
+    end
+  end
+
+  # Arguments read (asserted, expected), the assertion order used throughout this suite.
+  def assert_xml_equal(actual, expected, msg = nil)
+    assert_equal XmlAssertions.canonicalize(expected),
+                 XmlAssertions.canonicalize(actual),
+                 msg
+  end
+end

data/test/xml_bindings_test.rb

@@ -1,7 +1,7 @@
-require 'test_helper'
-require 'representable/xml/hash'
+require "test_helper"
+require "representable/xml/hash"
 
-class XMLBindingTest < MiniTest::Spec
+class XMLBindingTest < Minitest::Spec
   module SongRepresenter
     include Representable::XML
     property :name
@@ -19,9 +19,6 @@ class XMLBindingTest < MiniTest::Spec
     @song = SongWithRepresenter.new("Thinning the Herd")
   end
 
-
-
-
   describe "AttributeBinding" do
     describe "with plain text items" do
       before do
@@ -35,7 +32,7 @@ class XMLBindingTest < MiniTest::Spec
       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)
+        assert_xml_equal(parent.to_s, "<song name=\"The Gargoyle\" />")
       end
     end
   end
@@ -52,7 +49,7 @@ class XMLBindingTest < MiniTest::Spec
     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)
+      assert_xml_equal(parent.to_s, "<song>The Gargoyle</song>")
     end
   end
 end