representable 3.0.4 → 3.2.0

data/test/generic_test.rb

@@ -14,13 +14,13 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
 
     it "doesn't initialize property" do
       new_album.from_hash({})
-      new_album.songs.must_be_nil
+      _(new_album.songs).must_be_nil
     end
 
     it "leaves properties untouched" do
       album.from_hash({})
       # TODO: test property.
-      album.songs.must_equal ["Fuck Armageddon"] # when the collection is not present in the incoming hash, this propery stays untouched.
+      _(album.songs).must_equal ["Fuck Armageddon"] # when the collection is not present in the incoming hash, this propery stays untouched.
     end
 
 
@@ -109,7 +109,7 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
       end
 
       it "doesn't change represented object" do
-        song.extend(representer).send("from_#{format}", input).title.must_equal "Resist Stance"
+        _(song.extend(representer).send("from_#{format}", input).title).must_equal "Resist Stance"
       end
     end
   end

data/test/getter_setter_test.rb

@@ -3,19 +3,19 @@ require 'test_helper'
 class GetterSetterTest < BaseTest
   representer! do
     property :name, # key under :name.
-      :getter => lambda { |options| "#{options[:user_options][:welcome]} #{song_name}" },
-      :setter => lambda { |options| self.song_name = "#{options[:user_options][:welcome]} #{options[:input]}" }
+      :getter => lambda { |user_options:, **| "#{user_options[:welcome]} #{song_name}" },
+      :setter => lambda { |user_options:, input:, **| self.song_name = "#{user_options[:welcome]} #{input}" }
   end
 
   subject { Struct.new(:song_name).new("Mony Mony").extend(representer) }
 
   it "uses :getter when rendering" do
     subject.instance_eval { def name; raise; end }
-    subject.to_hash(user_options: {welcome: "Hi"}).must_equal({"name" => "Hi Mony Mony"})
+    _(subject.to_hash(user_options: {welcome: "Hi"})).must_equal({"name" => "Hi Mony Mony"})
   end
 
   it "uses :setter when parsing" do
     subject.instance_eval { def name=(*); raise; end; self }
-    subject.from_hash({"name" => "Eyes Without A Face"}, user_options: {welcome: "Hello"}).song_name.must_equal "Hello Eyes Without A Face"
+    _(subject.from_hash({"name" => "Eyes Without A Face"}, user_options: {welcome: "Hello"}).song_name).must_equal "Hello Eyes Without A Face"
   end
-end
+end

data/test/hash_test.rb

@@ -11,15 +11,15 @@ class HashPublicMethodsTest < Minitest::Spec
 
   let(:data) { {"id"=>1,"name"=>"Rancid"} }
 
-  it { BandRepresenter.new(Band.new).from_hash(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_hash(data)[:id, :name]).must_equal [1, "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).parse(data)[:id, :name]).must_equal [1, "Rancid"] }
 
   #---
   # to_hash
   let(:band) { Band.new(1, "Rancid") }
 
-  it { BandRepresenter.new(band).to_hash.must_equal data }
-  it { BandRepresenter.new(band).render.must_equal data }
+  it { _(BandRepresenter.new(band).to_hash).must_equal data }
+  it { _(BandRepresenter.new(band).render).must_equal data }
 end
 
 class HashWithScalarPropertyTest < MiniTest::Spec
@@ -33,20 +33,20 @@ class HashWithScalarPropertyTest < MiniTest::Spec
 
   describe "#to_hash" do
     it "renders plain property" do
-      album.extend(representer).to_hash.must_equal("title" => "Liar")
+      _(album.extend(representer).to_hash).must_equal("title" => "Liar")
     end
   end
 
 
   describe "#from_hash" do
     it "parses plain property" do
-      album.extend(representer).from_hash("title" => "This Song Is Recycled").title.must_equal "This Song Is Recycled"
+      _(album.extend(representer).from_hash("title" => "This Song Is Recycled").title).must_equal "This Song Is Recycled"
     end
 
     # Fixes issue #115
     it "allows nil value in the incoming document and corresponding nil value for the represented" do
       album = Album.new
-      album.title.must_be_nil
+      _(album.title).must_be_nil
       album.extend(representer).from_hash("title" => nil)
     end
   end
@@ -66,35 +66,35 @@ class HashWithTypedPropertyTest < MiniTest::Spec
 
   describe "#to_hash" do
     it "renders embedded typed property" do
-      album.extend(representer).to_hash.must_equal("best_song" => {"name" => "Liar"})
+      _(album.extend(representer).to_hash).must_equal("best_song" => {"name" => "Liar"})
     end
   end
 
   describe "#from_hash" do
     it "parses embedded typed property" do
       album.extend(representer).from_hash("best_song" => {"name" => "Go With Me"})
-      album.best_song.name.must_equal "Go With Me"
+      _(album.best_song.name).must_equal "Go With Me"
     end
 
     # nested nil removes nested object.
     it do
       album = Album.new(Song.new("Pre-medicated Murder"))
       album.extend(representer).from_hash("best_song" => nil)
-      album.best_song.must_be_nil
+      _(album.best_song).must_be_nil
     end
 
     # nested blank hash creates blank object when not populated.
     it do
       album = Album.new#(Song.new("Pre-medicated Murder"))
       album.extend(representer).from_hash("best_song" => {})
-      album.best_song.name.must_be_nil
+      _(album.best_song.name).must_be_nil
     end
 
     # Fixes issue #115
     it "allows nil value in the incoming document and corresponding nil value for the represented" do
       album = Album.new
       album.extend(representer).from_hash("best_song" => nil)
-      album.best_song.must_be_nil
+      _(album.best_song).must_be_nil
     end
   end
 end
@@ -109,8 +109,8 @@ class HashWithTypedPropertyAndAs < MiniTest::Spec
 
   let(:album) { OpenStruct.new(:song => Song.new("Liar")).extend(representer) }
 
-  it { album.to_hash.must_equal("hit" => {"name" => "Liar"}) }
-  it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
+  it { _(album.to_hash).must_equal("hit" => {"name" => "Liar"}) }
+  it { _(album.from_hash("hit" => {"name" => "Go With Me"})).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
 end
   #   # describe "FIXME COMBINE WITH ABOVE with :extend and :as" do
   #   #   hash_song = Module.new do
@@ -148,14 +148,14 @@ class HashWithTypedCollectionTest < MiniTest::Spec
 
   describe "#to_hash" do
     it "renders collection of typed property" do
-      album.extend(representer).to_hash.must_equal("songs" => [{"name" => "Liar", "track" => 1}, {"name" => "What I Know", "track" => 2}])
+      _(album.extend(representer).to_hash).must_equal("songs" => [{"name" => "Liar", "track" => 1}, {"name" => "What I Know", "track" => 2}])
     end
   end
 
   describe "#from_hash" do
     it "parses collection of typed property" do
-      album.extend(representer).from_hash("songs" => [{"name" => "One Shot Deal", "track" => 4},
-        {"name" => "Three Way Dance", "track" => 5}]).must_equal Album.new([Song.new("One Shot Deal", 4), Song.new("Three Way Dance", 5)])
+      _(album.extend(representer).from_hash("songs" => [{"name" => "One Shot Deal", "track" => 4},
+        {"name" => "Three Way Dance", "track" => 5}])).must_equal Album.new([Song.new("One Shot Deal", 4), Song.new("Three Way Dance", 5)])
     end
   end
 end
@@ -169,14 +169,14 @@ class HashWithScalarCollectionTest < MiniTest::Spec
 
   describe "#to_hash" do
     it "renders a block style list per default" do
-      album.extend(representer).to_hash.must_equal("songs" => ["Jackhammer", "Terrible Man"])
+      _(album.extend(representer).to_hash).must_equal("songs" => ["Jackhammer", "Terrible Man"])
     end
   end
 
 
   describe "#from_hash" do
     it "parses a block style list" do
-      album.extend(representer).from_hash("songs" => ["Off Key Melody", "Sinking"]).must_equal Album.new(["Off Key Melody", "Sinking"])
+      _(album.extend(representer).from_hash("songs" => ["Off Key Melody", "Sinking"])).must_equal Album.new(["Off Key Melody", "Sinking"])
     end
   end
 end

data/test/heritage_test.rb

@@ -35,15 +35,15 @@ class HeritageTest < Minitest::Spec
   end
 
   it "B must inherit Hello! feature from A" do
-    B.representable_attrs.get(:id)[:extend].(nil).new(nil).hello.must_equal "Hello!"
+    _(B.representable_attrs.get(:id)[:extend].(nil).new(nil).hello).must_equal "Hello!"
   end
 
   it "B must have Ciao from module (feauture) Ciao" do
-    B.representable_attrs.get(:id)[:extend].(nil).new(nil).ciao.must_equal "Ciao!"
+    _(B.representable_attrs.get(:id)[:extend].(nil).new(nil).ciao).must_equal "Ciao!"
   end
 
   it "C must inherit Hello! feature from A" do
-    C.representable_attrs.get(:id)[:extend].(nil).new(nil).hello.must_equal "Hello!"
+    _(C.representable_attrs.get(:id)[:extend].(nil).new(nil).hello).must_equal "Hello!"
   end
 
   module M
@@ -60,6 +60,6 @@ class HeritageTest < Minitest::Spec
   let(:obj_extending_N) { Object.new.extend(N) }
 
   it "obj should inherit from N, and N from M" do
-    obj_extending_N.hello.must_equal "Hello!"
+    _(obj_extending_N.hello).must_equal "Hello!"
   end
 end

data/test/if_test.rb

@@ -44,20 +44,20 @@ class IfTest < MiniTest::Spec
     subject { OpenStruct.new(:signed_contract => false, :label => "Fat") }
 
     it "skips when false" do
-      subject.extend(representer).to_hash.must_equal({})
+      _(subject.extend(representer).to_hash).must_equal({})
     end
 
     it "represents when true" do
       subject.signed_contract= true
-      subject.extend(representer).to_hash.must_equal({"label"=>"Fat"})
+      _(subject.extend(representer).to_hash).must_equal({"label"=>"Fat"})
     end
 
     it "works with decorator" do
       rpr = representer
-      Class.new(Representable::Decorator) do
+      _(Class.new(Representable::Decorator) do
         include Representable::Hash
         include rpr
-      end.new(subject).to_hash.must_equal({})
+      end.new(subject).to_hash).must_equal({})
     end
   end
 
@@ -69,11 +69,11 @@ class IfTest < MiniTest::Spec
     subject { OpenStruct.new(:name => "Outbound").extend(representer) }
 
     it "works without specifying options" do
-      subject.to_hash.must_equal({})
+      _(subject.to_hash).must_equal({})
     end
 
     it "passes user options to block" do
-      subject.to_hash(user_options: { include_name: true }).must_equal({"name" => "Outbound"})
+      _(subject.to_hash(user_options: { include_name: true })).must_equal({"name" => "Outbound"})
     end
   end
 end

data/test/include_exclude_test.rb

@@ -24,15 +24,15 @@ class IncludeExcludeTest < Minitest::Spec
     it "accepts :exclude option" do
       decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, exclude: [:title])
 
-      song.title.must_equal "Listless"
-      song.artist.must_equal Artist.new(nil, 2)
+      _(song.title).must_equal "Listless"
+      _(song.artist).must_equal Artist.new(nil, 2)
     end
 
     it "accepts :include option" do
       decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, include: [:title])
 
-      song.title.must_equal "Don't Smile In Trouble"
-      song.artist.must_equal Artist.new("7yearsbadluck", 1)
+      _(song.title).must_equal "Don't Smile In Trouble"
+      _(song.artist).must_equal Artist.new("7yearsbadluck", 1)
     end
 
     it "accepts nested :exclude/:include option" do
@@ -44,30 +44,30 @@ class IncludeExcludeTest < Minitest::Spec
         }
       )
 
-      song.title.must_equal "Listless"
-      song.artist.must_equal Artist.new("Foo", nil, [Song.new("Listless", nil, nil)])
+      _(song.title).must_equal "Listless"
+      _(song.artist).must_equal Artist.new("Foo", nil, [Song.new("Listless", nil, nil)])
     end
   end
 
   describe "#to_hash" do
     it "accepts :exclude option" do
-      decorator.to_hash(exclude: [:title]).must_equal({"artist"=>{"name"=>"7yearsbadluck", "id"=>1}})
+      _(decorator.to_hash(exclude: [:title])).must_equal({"artist"=>{"name"=>"7yearsbadluck", "id"=>1}})
     end
 
     it "accepts :include option" do
-      decorator.to_hash(include: [:title]).must_equal({"title"=>"Listless"})
+      _(decorator.to_hash(include: [:title])).must_equal({"title"=>"Listless"})
     end
 
     it "accepts nested :exclude/:include option" do
       decorator = representer.new(Song.new("Listless", Artist.new("7yearsbadluck", 1, [Song.new("C.O.A.B.I.E.T.L.")])))
 
-      decorator.to_hash(
+      _(decorator.to_hash(
         exclude: [:title],
         artist: {
           exclude: [:id],
           songs: { include: [:title] }
         }
-      ).must_equal({"artist"=>{"name"=>"7yearsbadluck", "songs"=>[{"title"=>"C.O.A.B.I.E.T.L."}]}})
+      )).must_equal({"artist"=>{"name"=>"7yearsbadluck", "songs"=>[{"title"=>"C.O.A.B.I.E.T.L."}]}})
     end
   end
 
@@ -82,7 +82,7 @@ class IncludeExcludeTest < Minitest::Spec
 
     # FIXME: we should test all representable-options (:include, :exclude, ?)
 
-    Cover.new("Roxanne", Cover.new("Roxanne (Don't Put On The Red Light)")).extend(cover_rpr).
-      to_hash(:include => [:original]).must_equal({"original"=>{"title"=>"Roxanne (Don't Put On The Red Light)"}})
+    _(Cover.new("Roxanne", Cover.new("Roxanne (Don't Put On The Red Light)")).extend(cover_rpr).
+      to_hash(:include => [:original])).must_equal({"original"=>{"title"=>"Roxanne (Don't Put On The Red Light)"}})
   end
 end

data/test/inherit_test.rb

@@ -19,8 +19,8 @@ class InheritTest < MiniTest::Spec
       property :track, :inherit => true, :getter => lambda { |*| "n/a" }
     end
 
-    it { SongRepresenter.prepare(song).to_hash.must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>1}) }
-    it { representer.prepare(song).to_hash.must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>"n/a"}) } # as: inherited.
+    it { _(SongRepresenter.prepare(song).to_hash).must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>1}) }
+    it { _(representer.prepare(song).to_hash).must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>"n/a"}) } # as: inherited.
   end
 
   describe ":inherit with empty inline representer" do
@@ -32,9 +32,9 @@ class InheritTest < MiniTest::Spec
       end
     end
 
-    it { SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { _(SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
     # the block doesn't override the inline representer.
-    it { representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { _(representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
   end
 
   describe ":inherit with overriding inline representer" do
@@ -48,7 +48,7 @@ class InheritTest < MiniTest::Spec
       end
     end
 
-    it { representer.prepare( Song.new(Struct.new(:string, :length).new("Believe It", 10), 1)).to_hash.must_equal({"title"=>{"s"=>"Believe It","length"=>10}, "no"=>1}) }
+    it { _(representer.prepare( Song.new(Struct.new(:string, :length).new("Believe It", 10), 1)).to_hash).must_equal({"title"=>{"s"=>"Believe It","length"=>10}, "no"=>1}) }
   end
 
   describe ":inherit with empty inline and options" do
@@ -60,8 +60,8 @@ class InheritTest < MiniTest::Spec
       end
     end
 
-    it { SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
-    it { representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { _(SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { _(representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
   end
 
   describe ":inherit with inline without block but options" do
@@ -71,8 +71,8 @@ class InheritTest < MiniTest::Spec
       property :name, :inherit => true, :as => :name # FIXME: add :getter or something else dynamic since this is double-wrapped.
     end
 
-    it { SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
-    it { representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { _(SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { _(representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
   end
 
 
@@ -86,12 +86,12 @@ class InheritTest < MiniTest::Spec
     end
 
     it "replaces inherited property" do
-      representer.representable_attrs.size.must_equal 2
+      _(representer.representable_attrs.size).must_equal 2
 
       definition = representer.representable_attrs.get(:track) # TODO: find a better way to assert Definition identity.
       # definition.keys.size.must_equal 2
-      definition[:representable].   must_equal true
-      definition.name.must_equal "track" # was "no".
+      _(definition[:representable]).   must_equal true
+      _(definition.name).must_equal "track" # was "no".
     end
   end
 
@@ -119,12 +119,12 @@ class InheritTest < MiniTest::Spec
       end
     }
 
-    it { representer.new(OpenStruct.new(hit: OpenStruct.new(title: "I WILL BE OVERRIDDEN", :length => "2:59"))).to_hash.must_equal(
+    it { _(representer.new(OpenStruct.new(hit: OpenStruct.new(title: "I WILL BE OVERRIDDEN", :length => "2:59"))).to_hash).must_equal(
       {"hit"=>{"title"=>"Cheap Transistor Radio"}}) }
 
     # inheriting decorator inherits inline representer class (InlineRepresenter#title).
     # inheriting decorator adds :length.
-    it { inheriting.new(OpenStruct.new(:hit => OpenStruct.new(:title => "Hole In Your Soul", :length => "2:59"))).to_hash.must_equal(
+    it { _(inheriting.new(OpenStruct.new(:hit => OpenStruct.new(:title => "Hole In Your Soul", :length => "2:59"))).to_hash).must_equal(
       {"hit"=>{"title"=>"Cheap Transistor Radio", "length"=>"2:59"}}) }
   end
 
@@ -135,7 +135,7 @@ class InheritTest < MiniTest::Spec
       property :name, :inherit => true
     end
 
-    it { representer.prepare(Song.new("The Beginning")).to_hash.must_equal({"name"=>"The Beginning"})}
+    it { _(representer.prepare(Song.new("The Beginning")).to_hash).must_equal({"name"=>"The Beginning"})}
   end
 end
 

data/test/inline_test.rb

@@ -22,7 +22,7 @@ class InlineTest < MiniTest::Spec
       let(:format) { format }
 
       it { render(request).must_equal_document output }
-      it { parse(request, input).song.name.must_equal "You've Taken Everything"}
+      it { _(parse(request, input).song.name).must_equal "You've Taken Everything"}
     end
   end
 
@@ -47,7 +47,7 @@ class InlineTest < MiniTest::Spec
       let(:format) { format } # FIXME: why do we have to define this?
 
       it { render(request).must_equal_document output }
-      it { parse(request, input).songs.first.name.must_equal "You've Taken Everything"}
+      it { _(parse(request, input).songs.first.name).must_equal "You've Taken Everything"}
     end
   end
 
@@ -58,7 +58,7 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it { request.to_hash.must_equal({"song"=>{"name"=>"Alive"}}) }
+    it { _(request.to_hash).must_equal({"song"=>{"name"=>"Alive"}}) }
   end
 
 
@@ -76,7 +76,7 @@ class InlineTest < MiniTest::Spec
       end
 
       it "doesn't change represented object" do
-        request.send("from_#{format}", input).song.must_equal song
+        _(request.send("from_#{format}", input).song).must_equal song
       end
     end
   end
@@ -96,8 +96,8 @@ class InlineTest < MiniTest::Spec
 
       let(:decorator) { representer.prepare(request) }
 
-      it { decorator.to_hash.must_equal({"requester"=>"Josephine", "song"=>{"name"=>"Alive"}}) }
-      it { decorator.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name.must_equal "You've Taken Everything"}
+      it { _(decorator.to_hash).must_equal({"requester"=>"Josephine", "song"=>{"name"=>"Alive"}}) }
+      it { _(decorator.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name).must_equal "You've Taken Everything"}
     end
   end
 
@@ -110,7 +110,7 @@ class InlineTest < MiniTest::Spec
 
     it "uses an inline decorator and doesn't alter represented" do
       representer.prepare(Struct.new(:song).new(song)).to_hash
-      song.wont_be_kind_of Representable
+      _(song).wont_be_kind_of Representable
     end
   end
 
@@ -221,8 +221,8 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it do OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
-      to_hash.
+    it do _(OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
+      to_hash).
       must_equal({"song"=>{"artist"=>"Strung Out", "title"=>"The Fever And The Sound"}})
     end
   end
@@ -246,7 +246,7 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it { Object.new.extend(Mod).to_hash.must_equal("song"=>{"duration"=>"6:53"}) }
+    it { _(Object.new.extend(Mod).to_hash).must_equal("song"=>{"duration"=>"6:53"}) }
   end
 
   # define method inline with Decorator
@@ -267,6 +267,6 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it { dec.new(Object.new).to_hash.must_equal("song"=>{"duration"=>"6:53"}) }
+    it { _(dec.new(Object.new).to_hash).must_equal("song"=>{"duration"=>"6:53"}) }
   end
 end

data/test/instance_test.rb

@@ -22,7 +22,7 @@ class InstanceTest < BaseTest
       end
 
       song = OpenStruct.new.extend(representer).from_hash({"title" => object})
-      song.title.must_equal object
+      _(song.title).must_equal object
     end
   end
 
@@ -36,11 +36,11 @@ class InstanceTest < BaseTest
         :extend => song_representer
     end
 
-    it( "xxx") { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash("song" => {"id" => 1}).song.must_equal Song.new(1, "The Answer Is Still No") }
+    it( "xxx") { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash("song" => {"id" => 1}).song).must_equal Song.new(1, "The Answer Is Still No") }
 
-    it { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash("song" => {"id" => 2}).song.must_equal Song.new(2, "Invincible") }
+    it { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash("song" => {"id" => 2}).song).must_equal Song.new(2, "Invincible") }
   end
 
 
@@ -59,9 +59,9 @@ class InstanceTest < BaseTest
       Song.new(1, "The Answer Is Still No"),
       Song.new(2, "")])
 
-      album.
+      _(album.
         extend(representer).
-        from_hash("songs" => [{"id" => 2},{"id" => 2, "title"=>"The Answer Is Still No"}]).songs.must_equal [
+        from_hash("songs" => [{"id" => 2},{"id" => 2, "title"=>"The Answer Is Still No"}]).songs).must_equal [
           Song.new(2, "Invincible"), Song.new(2, "The Answer Is Still No")]
     }
   end
@@ -71,8 +71,8 @@ class InstanceTest < BaseTest
       property :song, :instance => lambda { |options| Struct.new(:args, :id).new([options[:fragment], options[:user_options]]) }, :extend => song_representer
     end
 
-    it { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash({"song" => {"id" => 1}}, user_options: { volume: 1 }).song.args.must_equal([{"id"=>1}, {:volume=>1}]) }
+    it { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash({"song" => {"id" => 1}}, user_options: { volume: 1 }).song.args).must_equal([{"id"=>1}, {:volume=>1}]) }
   end
 
   # TODO: raise and test instance:{nil}
@@ -117,13 +117,13 @@ class InstanceTest < BaseTest
         extend(representer).
         from_hash("songs" => [{"title" => "The Answer Is Still No"}, {"title" => "Invincible"}])
 
-      album.songs.must_equal [
+      _(album.songs).must_equal [
         Song.new(1, "The Answer Is Still No"),
         Song.new(2, "Invincible")]
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
-      songs[1].object_id.must_equal album.songs[1].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
+      _(songs[1].object_id).must_equal album.songs[1].object_id
     }
   end
 
@@ -146,17 +146,17 @@ class InstanceTest < BaseTest
       Song.new(1, "The Answer Is Still No"),
       Song.new(2, "Invncble")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"id" => 2, "title" => "Invincible"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(1, "The Answer Is Still No"),
           Song.new(2, "Invincible")]
           # TODO: check elements object_id!
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
-      songs[1].object_id.must_equal album.songs[1].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
+      _(songs[1].object_id).must_equal album.songs[1].object_id
     }
   end
 
@@ -178,15 +178,15 @@ class InstanceTest < BaseTest
       album= Struct.new(:songs).new(songs = [
         Song.new(1, "The Answer Is Still No")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"title" => "Invincible"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(1, "The Answer Is Still No"),
           Song.new(2, "Invincible")]
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
     }
   end
 
@@ -212,15 +212,15 @@ class InstanceTest < BaseTest
         Song.new(1, "The Answer Is Still No"),
         Song.new(2, "Invincible")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"replace_id"=>2, "id" => 3, "title" => "Soulmate"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(1, "The Answer Is Still No"),
           Song.new(3, "Soulmate")]
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
     }
   end
 
@@ -235,13 +235,13 @@ class InstanceTest < BaseTest
       album= Struct.new(:songs).new(songs = [
         Song.new(1, "The Answer Is Still No")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"title" => "Invincible"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(nil, "Invincible")]
 
-      songs.object_id.wont_equal album.songs.object_id
+      _(songs.object_id).wont_equal album.songs.object_id
     }
   end
 end