representable 3.0.4 → 3.2.0

data/test/private_options_test.rb

@@ -8,11 +8,11 @@ class PrivateOptionsTest < MiniTest::Spec # TODO: move me to separate file.
 
   it "render: doesn't modify options" do
     representer.new(nil).to_hash(options)
-    options.must_equal({exclude: "name"})
+    _(options).must_equal({exclude: "name"})
   end
 
   it "parse: doesn't modify options" do
     representer.new(nil).from_hash(options)
-    options.must_equal({exclude: "name"})
+    _(options).must_equal({exclude: "name"})
   end
 end

data/test/reader_writer_test.rb

@@ -10,10 +10,10 @@ class ReaderWriterTest < BaseTest
   subject { OpenStruct.new(:name => "Disorder And Disarray").extend(representer) }
 
   it "uses :writer when rendering" do
-    subject.to_hash(user_options: {nr: 14}).must_equal({"title" => "14) Disorder And Disarray"})
+    _(subject.to_hash(user_options: {nr: 14})).must_equal({"title" => "14) Disorder And Disarray"})
   end
 
   it "uses :reader when parsing" do
-    subject.from_hash({"title" => "15) The Wars End"}).name.must_equal "The Wars End"
+    _(subject.from_hash({"title" => "15) The Wars End"}).name).must_equal "The Wars End"
   end
 end

data/test/render_nil_test.rb

@@ -8,7 +8,7 @@ class RenderNilTest < MiniTest::Spec
       property :title, render_nil: true
     end
 
-    it { Song.new.extend(representer).to_hash.must_equal({"title"=>nil}) }
+    it { _(Song.new.extend(representer).to_hash).must_equal({"title"=>nil}) }
   end
 
   describe "with :extend it shouldn't extend nil" do
@@ -16,6 +16,6 @@ class RenderNilTest < MiniTest::Spec
       property :title, render_nil: true, extend: Class
     end
 
-    it { Song.new.extend(representer).to_hash.must_equal({"title"=>nil}) }
+    it { _(Song.new.extend(representer).to_hash).must_equal({"title"=>nil}) }
   end
 end

data/test/represent_test.rb

@@ -24,7 +24,7 @@ class RepresentTest < MiniTest::Spec
       }
 
       it { render(representer.represent(songs)).must_equal_document output }
-      it { parse(representer.represent([]), input).must_equal songs }
+      it { _(parse(representer.represent([]), input)).must_equal songs }
     end
 
     # Decorator.represents detects collection.
@@ -40,7 +40,7 @@ class RepresentTest < MiniTest::Spec
       }
 
       it { render(representer.represent(songs)).must_equal_document output }
-      it("ficken") { parse(representer.represent([]), input).must_equal songs }
+      it("ficken") { _(parse(representer.represent([]), input)).must_equal songs }
     end
   end
 
@@ -65,7 +65,7 @@ class RepresentTest < MiniTest::Spec
       }
 
       it { render(representer.represent(song)).must_equal_document output }
-      it { parse(representer.represent(Song.new), input).must_equal song }
+      it { _(parse(representer.represent(Song.new), input)).must_equal song }
     end
 
 
@@ -82,7 +82,7 @@ class RepresentTest < MiniTest::Spec
       }
 
       it { render(representer.represent(song)).must_equal_document output }
-      it { parse(representer.represent(Song.new), input).must_equal song }
+      it { _(parse(representer.represent(Song.new), input)).must_equal song }
     end
   end
 end

data/test/representable_test.rb

@@ -132,8 +132,8 @@ class RepresentableTest < MiniTest::Spec
 
     # test ::inherited.
     it do
-      BaseClass.respond_to?(:other).must_equal false
-      SubClass.respond_to?(:other).must_equal true
+      _(BaseClass.respond_to?(:other)).must_equal false
+      _(SubClass.respond_to?(:other)).must_equal true
     end
 
     module DifferentIncluded
@@ -164,13 +164,13 @@ class RepresentableTest < MiniTest::Spec
     it "doesn't modify options hash" do
       options = {}
       representer.property(:title, options)
-      options.must_equal({})
+      _(options).must_equal({})
     end
 
     representer! {}
 
     it "returns the Definition instance" do
-      representer.property(:name).must_be_kind_of Representable::Definition
+      _(representer.property(:name)).must_be_kind_of Representable::Definition
     end
   end
 
@@ -233,7 +233,7 @@ class RepresentableTest < MiniTest::Spec
 
     it "includes false attributes" do
       @band.from_hash({"groupies"=>false})
-      assert_equal false, @band.groupies
+      refute @band.groupies
     end
 
     it "ignores properties not present in the incoming document" do
@@ -300,14 +300,14 @@ class RepresentableTest < MiniTest::Spec
       end
 
       it "#to_hash propagates to nested objects" do
-        OpenStruct.new(track: OpenStruct.new(nr: 1, length: OpenStruct.new(seconds: nil))).extend(representer).extend(Representable::Debug).
-          to_hash(user_options: {nr: 9}).must_equal({"track"=>{"nr"=>9, "length"=>{seconds: 9}}})
+        _(OpenStruct.new(track: OpenStruct.new(nr: 1, length: OpenStruct.new(seconds: nil))).extend(representer).extend(Representable::Debug).
+          to_hash(user_options: {nr: 9})).must_equal({"track"=>{"nr"=>9, "length"=>{seconds: 9}}})
       end
 
       it "#from_hash propagates to nested objects" do
         song = OpenStruct.new.extend(representer).from_hash({"track"=>{"nr" => "replace me", "length"=>{"seconds"=>"replacing"}}}, user_options: {nr: 9})
-        song.track.nr.must_equal 9
-        song.track.length.seconds.must_equal 9
+        _(song.track.nr).must_equal 9
+        _(song.track.length.seconds).must_equal 9
       end
     end
   end
@@ -364,12 +364,12 @@ class RepresentableTest < MiniTest::Spec
       end
 
       it "executes lambda in represented instance context" do
-        Song.new("Carnage").instance_eval do
+        _(Song.new("Carnage").instance_eval do
           def compute_representer(name)
             UpcaseRepresenter
           end
           self
-        end.extend(representer).to_hash.must_equal({"name" => "CARNAGE"})
+        end.extend(representer).to_hash).must_equal({"name" => "CARNAGE"})
       end
     end
 
@@ -382,8 +382,8 @@ class RepresentableTest < MiniTest::Spec
 
       it "uses object from :instance but still extends it" do
         song = Song.new.extend(representer).from_hash("name" => "Eric's Had A Bad Day")
-        song.name.must_equal obj
-        song.name.must_be_kind_of mod
+        _(song.name).must_equal obj
+        _(song.name).must_be_kind_of mod
       end
     end
 
@@ -398,8 +398,8 @@ class RepresentableTest < MiniTest::Spec
       end
 
       it "uses lambda when parsing" do
-        Song.new.extend(representer).from_hash({"name" => "You Make Me Thick"}).name.must_equal "you make me thick"
-        Song.new.extend(representer).from_hash({"name" => "Stepstranger"}).name.must_equal "stepstranger" # DISCUSS: we compare "".is_a?(UpcaseString)
+        _(Song.new.extend(representer).from_hash({"name" => "You Make Me Thick"}).name).must_equal "you make me thick"
+        _(Song.new.extend(representer).from_hash({"name" => "Stepstranger"}).name).must_equal "stepstranger" # DISCUSS: we compare "".is_a?(UpcaseString)
       end
 
       describe "with :class lambda" do
@@ -410,12 +410,12 @@ class RepresentableTest < MiniTest::Spec
 
         it "creates instance from :class lambda when parsing" do
           song = OpenStruct.new.extend(representer).from_hash({"name" => "Quitters Never Win"})
-          song.name.must_be_kind_of UpcaseString
-          song.name.must_equal "QUITTERS NEVER WIN"
+          _(song.name).must_be_kind_of UpcaseString
+          _(song.name).must_equal "QUITTERS NEVER WIN"
 
           song = OpenStruct.new.extend(representer).from_hash({"name" => "Still Failing?"})
-          song.name.must_be_kind_of String
-          song.name.must_equal "still failing?"
+          _(song.name).must_be_kind_of String
+          _(song.name).must_equal "still failing?"
         end
       end
     end
@@ -427,12 +427,12 @@ class RepresentableTest < MiniTest::Spec
       end
 
       it "uses lambda for each item when rendering" do
-        Album.new([UpcaseString.new("Dean Martin"), "Charlie Still Smirks"]).extend(representer).to_hash.must_equal("songs"=>["DEAN MARTIN", "charlie still smirks"])
+        _(Album.new([UpcaseString.new("Dean Martin"), "Charlie Still Smirks"]).extend(representer).to_hash).must_equal("songs"=>["DEAN MARTIN", "charlie still smirks"])
       end
 
       it "uses lambda for each item when parsing" do
         album = Album.new.extend(representer).from_hash("songs"=>["DEAN MARTIN", "charlie still smirks"])
-        album.songs.must_equal ["dean martin", "charlie still smirks"] # DISCUSS: we compare "".is_a?(UpcaseString)
+        _(album.songs).must_equal ["dean martin", "charlie still smirks"] # DISCUSS: we compare "".is_a?(UpcaseString)
       end
 
       describe "with :class lambda" do
@@ -443,7 +443,7 @@ class RepresentableTest < MiniTest::Spec
 
         it "creates instance from :class lambda for each item when parsing" do
           album = Album.new.extend(representer).from_hash("songs"=>["Still Failing?", "charlie still smirks"])
-          album.songs.must_equal ["still failing?", "CHARLIE STILL SMIRKS"]
+          _(album.songs).must_equal ["still failing?", "CHARLIE STILL SMIRKS"]
         end
       end
     end
@@ -454,7 +454,7 @@ class RepresentableTest < MiniTest::Spec
       let(:songs) { [Song.new("Bloody Mary")] }
 
       it "is aliased to :extend" do
-        Album.new(songs).extend(extend_rpr).to_hash.must_equal Album.new(songs).extend(decorator_rpr).to_hash
+        _(Album.new(songs).extend(extend_rpr).to_hash).must_equal Album.new(songs).extend(decorator_rpr).to_hash
       end
     end
 
@@ -477,15 +477,15 @@ class RepresentableTest < MiniTest::Spec
         it "uses :extend strategy" do
           album_rpr = Module.new { include Representable::Hash; collection :songs, :class => Song, :extend => SongRepresenter}
 
-          album_rpr.prepare(album).to_hash.must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
-          album.must_respond_to :to_hash
+          _(album_rpr.prepare(album).to_hash).must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
+          _(album).must_respond_to :to_hash
         end
       end
 
       describe "Decorator subclass" do
         it "uses :decorate strategy" do
-          AlbumRepresentation.prepare(album).to_hash.must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
-          album.wont_respond_to :to_hash
+          _(AlbumRepresentation.prepare(album).to_hash).must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
+          _(album).wont_respond_to :to_hash
         end
       end
     end

data/test/schema_test.rb

@@ -61,10 +61,10 @@ class SchemaTest < MiniTest::Spec
     let(:label) { OpenStruct.new(:name => "Epitaph", :location => OpenStruct.new(:city => "Sanfran", :name => "DON'T SHOW ME!")) }
 
     # Module does correctly include features in inlines.
-    it { band.extend(Module).to_hash.must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
+    it { _(band.extend(Module).to_hash).must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
 
     # Decorator does correctly include features in inlines.
-    it { Decorator.new(band).to_hash.must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
+    it { _(Decorator.new(band).to_hash).must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
   end
 
 
@@ -84,7 +84,7 @@ class SchemaTest < MiniTest::Spec
   # it { FlatlinersDecorator.new( OpenStruct.new(label: OpenStruct.new) ).
   #   to_hash.must_equal({}) }
   it do
-    Decorator.new(band).to_hash.must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "location"=>{"city"=>"Sanfran"}}})
+    _(Decorator.new(band).to_hash).must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "location"=>{"city"=>"Sanfran"}}})
   end
 
 
@@ -103,7 +103,7 @@ class SchemaTest < MiniTest::Spec
   end
 
   it do
-    InheritDecorator.new(band).to_hash.must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "location"=>{"city"=>"Sanfran"}}})
+    _(InheritDecorator.new(band).to_hash).must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "location"=>{"city"=>"Sanfran"}}})
   end
 
 
@@ -117,7 +117,7 @@ class SchemaTest < MiniTest::Spec
   end
 
   it do
-    InheritFromDecorator.new(band).to_hash.must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "employees"=>[{"name"=>"Mike"}], "location"=>{"city"=>"Sanfran"}}})
+    _(InheritFromDecorator.new(band).to_hash).must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "employees"=>[{"name"=>"Mike"}], "location"=>{"city"=>"Sanfran"}}})
   end
 end
 

data/test/serialize_deserialize_test.rb

@@ -13,7 +13,7 @@ class SerializeDeserializeTest < BaseTest
         }
     end
 
-    it { subject.from_hash({"song" => Object}, user_options: {volume: 9}).song.must_equal "OBJECT Object {:volume=>9}" }
+    it { _(subject.from_hash({"song" => Object}, user_options: {volume: 9}).song).must_equal "OBJECT Object {:volume=>9}" }
   end
 
   describe "serialize" do
@@ -28,6 +28,6 @@ class SerializeDeserializeTest < BaseTest
 
     before { subject.song = "Arrested In Shanghai" }
 
-    it { subject.to_hash(user_options: {volume: 9}).must_equal({"song"=>"Arrested In Shanghai {:volume=>9}"}) }
+    it { _(subject.to_hash(user_options: {volume: 9})).must_equal({"song"=>"Arrested In Shanghai {:volume=>9}"}) }
   end
 end

data/test/skip_test.rb

@@ -24,9 +24,9 @@ class SkipParseTest < MiniTest::Spec
       "airplays" => [{"station" => "JJJ"}]
     }, user_options: { skip?: true })
 
-    song.title.must_equal "Victim Of Fate"
-    song.band.name.must_equal "Mute 98"
-    song.airplays[0].station.must_equal "JJJ"
+    _(song.title).must_equal "Victim Of Fate"
+    _(song.band.name).must_equal "Mute 98"
+    _(song.airplays[0].station).must_equal "JJJ"
   end
 
   # skip parsing.
@@ -39,9 +39,9 @@ class SkipParseTest < MiniTest::Spec
       "airplays" => [{}, {"station" => "JJJ"}, {}],
     }, user_options: { skip?: true })
 
-    song.title.must_be_nil
-    song.band.must_be_nil
-    song.airplays.must_equal [airplay]
+    _(song.title).must_be_nil
+    _(song.band).must_be_nil
+    _(song.airplays).must_equal [airplay]
   end
 end
 
@@ -63,19 +63,19 @@ 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.to_hash(user_options: { skip?: true })).must_equal({"airplays"=>[{"station"=>"JJJ"}, {"station"=>"ABC"}]})
   end
 end

data/test/stringify_hash_test.rb

@@ -17,11 +17,11 @@ describe "#from_hash" do
    end
 
    it "parses symbols, too" do
-     OpenStruct.new.extend(representer).from_hash({:song => {:title => "Der Optimist"}}).song.title.must_equal "Der Optimist"
+     _(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"
+     _(OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Der Optimist"}}).song.title).must_equal "Der Optimist"
    end
 
    describe "with :wrap" do
@@ -33,7 +33,7 @@ describe "#from_hash" do
     end
 
      it "parses symbols, too" do
-       OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title.must_equal "Der Optimist"
+       _(OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title).must_equal "Der Optimist"
      end
    end
  end

data/test/test_helper.rb

@@ -1,13 +1,15 @@
+require 'pry-byebug'
 require 'representable'
 
 require 'minitest/autorun'
 require 'test_xml/mini_test'
 
 require "representable/debug"
+require 'minitest/assertions'
 
 module MiniTest::Assertions
   def assert_equal_xml(text, subject)
-    subject.gsub("\n", "").gsub(/(\s\s+)/, "").must_equal(text.gsub("\n", "").gsub(/(\s\s+)/, ""))
+    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
@@ -47,7 +49,7 @@ module AssertJson
   module Assertions
     def assert_json(expected, actual, msg=nil)
       msg = message(msg, "") { diff expected, actual }
-      assert(expected.split("").sort == actual.split("").sort, msg)
+      assert_equal(expected.split("").sort, actual.split("").sort, msg)
     end
   end
 end

data/test/uncategorized_test.rb

@@ -15,12 +15,12 @@ class StopWhenIncomingObjectFragmentIsNilTest < MiniTest::Spec
 
   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
@@ -35,13 +35,13 @@ class RenderPipelineOptionTest < MiniTest::Spec
     end
   end
 
-  it { representer.new(Album.new).to_hash(user_options: {function: NilToNA}).must_equal({"id"=>"n/a"}) }
-  it { representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA}).must_equal({"id"=>1}) }
+  it { _(representer.new(Album.new).to_hash(user_options: {function: NilToNA})).must_equal({"id"=>"n/a"}) }
+  it { _(representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA})).must_equal({"id"=>1}) }
 
   it "is cached" do
     decorator = representer.new(Album.new)
-    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.
+    _(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
@@ -56,12 +56,12 @@ class ParsePipelineOptionTest < MiniTest::Spec
     end
   end
 
-  it { representer.new(Album.new).from_hash({"id"=>nil}, user_options: {function: NilToNA}).id.must_equal "n/a" }
-  it { representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA}).must_equal({"id"=>1}) }
+  it { _(representer.new(Album.new).from_hash({"id"=>nil}, user_options: {function: NilToNA}).id).must_equal "n/a" }
+  it { _(representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA})).must_equal({"id"=>1}) }
 
   it "is cached" do
     decorator = representer.new(Album.new)
-    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.
+    _(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

data/test/user_options_test.rb

@@ -7,9 +7,9 @@ class UserOptionsTest < Minitest::Spec
     property :title, if: ->(options) { options[:user_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(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).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).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" }
 end
 # Representable.deprecations=false

data/test/wrap_test.rb

@@ -36,13 +36,13 @@ class WrapTest < MiniTest::Spec
       let(:format) { format }
 
       representer!(:module => mod) do
-        self.representation_wrap = lambda { |args| "#{name}#{args[:number]}" }
+        self.representation_wrap = lambda { |number:, **| "#{name}#{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.
+      it { _(parse(band, input, {:number => 182}).genre).must_equal "Poppunk" } # TODO: better test. also, xml parses _any_ wrap.
     end
   end
 end
@@ -69,15 +69,15 @@ class HashDisableWrapTest < MiniTest::Spec
 
   # 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"})
+    _(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"
+    _(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
 
 
@@ -94,11 +94,11 @@ class HashDisableWrapTest < MiniTest::Spec
 
   # 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
-    album.from_hash({"albums" => {"band" => {"name"=>"Rvivr"}}}).band.name.must_equal "Rvivr"
+    _(album.from_hash({"albums" => {"band" => {"name"=>"Rvivr"}}}).band.name).must_equal "Rvivr"
   end
 end
 
@@ -142,7 +142,7 @@ class XMLDisableWrapTest < MiniTest::Spec
   # 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

data/test/xml_namespace_test.rb

@@ -177,7 +177,7 @@ class Namespace2XMLTest < Minitest::Spec
     #:parse-call end
     )
 
-    lib.book.inspect.must_equal %{#<struct Namespace2XMLTest::Model::Book id=\"1\", isbn=\"666\", author=#<struct Namespace2XMLTest::Model::Character name=\"Fowler\", born=nil, qualification=nil>, character=[#<struct Namespace2XMLTest::Model::Character name=\"Frau Java\", born=\"1991\", qualification=\"typed\">]>}
+    _(lib.book.inspect).must_equal %{#<struct Namespace2XMLTest::Model::Book id=\"1\", isbn=\"666\", author=#<struct Namespace2XMLTest::Model::Character name=\"Fowler\", born=nil, qualification=nil>, character=[#<struct Namespace2XMLTest::Model::Character name=\"Frau Java\", born=\"1991\", qualification=\"typed\">]>}
 
     #:parse-res
     lib.book.character[0].name #=> "Frau Java"

data/test/xml_test.rb

@@ -12,8 +12,8 @@ class XmlPublicMethodsTest < Minitest::Spec
 
   let(:data) { %{<data><id>1</id><name>Rancid</name></data>} }
 
-  it { BandRepresenter.new(Band.new).from_xml(data)[:id, :name].must_equal ["1", "Rancid"] }
-  it { BandRepresenter.new(Band.new).parse(data)[:id, :name].must_equal ["1", "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).from_xml(data)[:id, :name]).must_equal ["1", "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).parse(data)[:id, :name]).must_equal ["1", "Rancid"] }
 
   #---
   # to_hash
@@ -468,11 +468,11 @@ class XMLCollectionTest < MiniTest::Spec
         end
 
         it "parses array" do
-          [].extend(representer).from_xml(xml_doc).must_equal songs
+          _([].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
+          _(decorator.new([]).from_xml(xml_doc)).must_equal songs
         end
       end
     end
@@ -505,7 +505,7 @@ class XMLCollectionTest < MiniTest::Spec
 
       describe "#from_json" do
         it "returns hash" do
-          {}.extend(representer).from_xml(xml_doc).must_equal songs
+          _({}.extend(representer).from_xml(xml_doc)).must_equal songs
         end
 
         it "respects :exclude" do
@@ -517,7 +517,7 @@ class XMLCollectionTest < MiniTest::Spec
         end
 
         it "parses hash with decorator" do
-          decorator.new({}).from_xml(xml_doc).must_equal songs
+          _(decorator.new({}).from_xml(xml_doc)).must_equal songs
         end
       end
     end