representable 3.0.4 → 3.2.0

data/test/is_representable_test.rb

@@ -9,9 +9,9 @@ class IsRepresentableTest < BaseTest
     end
 
     it "does extend but doesn't call #to_hash" do
-      Struct.new(:song).new(song = Object.new).extend(representer).
-        to_hash.must_equal("song" => song)
-      song.must_be_kind_of Representable::Hash
+      _(Struct.new(:song).new(song = Object.new).extend(representer).
+        to_hash).must_equal("song" => song)
+      _(song).must_be_kind_of Representable::Hash
     end
   end
 
@@ -30,9 +30,9 @@ class IsRepresentableTest < BaseTest
         end
       end
 
-      Struct.new(:song).new(song).extend(representer).
-        to_hash.must_equal("song" => 1)
-      song.wont_be_kind_of Representable::Hash
+      _(Struct.new(:song).new(song).extend(representer).
+        to_hash).must_equal("song" => 1)
+      _(song).wont_be_kind_of Representable::Hash
     end
   end
 
@@ -48,8 +48,8 @@ class IsRepresentableTest < BaseTest
       hit = Struct.new(:song).new.extend(representer).
         from_hash("song" => 1)
 
-      hit.song.must_equal OpenStruct.new
-      hit.song.must_be_kind_of Representable::Hash
+      _(hit.song).must_equal OpenStruct.new
+      _(hit.song).must_be_kind_of Representable::Hash
     end
   end
 
@@ -70,8 +70,8 @@ class IsRepresentableTest < BaseTest
       hit = Struct.new(:song).new.extend(representer).
         from_hash("song" => "Sonata No.2")
 
-      hit.song.must_equal "Piano?"
-      hit.song.wont_be_kind_of Representable::Hash
+      _(hit.song).must_equal "Piano?"
+      _(hit.song).wont_be_kind_of Representable::Hash
     end
   end
 end

data/test/json_test.rb

@@ -13,15 +13,15 @@ class JSONPublicMethodsTest < Minitest::Spec
 
   let(:json) { '{"id":1,"name":"Rancid"}' }
 
-  it { BandRepresenter.new(Band.new).from_json(json)[:id, :name].must_equal [1, "Rancid"] }
-  it { BandRepresenter.new(Band.new).parse(json)[:id, :name].must_equal [1, "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).from_json(json)[:id, :name]).must_equal [1, "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).parse(json)[:id, :name]).must_equal [1, "Rancid"] }
 
   #---
   # to_json
   let(:band) { Band.new(1, "Rancid") }
 
-  it { BandRepresenter.new(band).to_json.must_equal json }
-  it { BandRepresenter.new(band).render.must_equal json }
+  it { _(BandRepresenter.new(band).to_json).must_equal json }
+  it { _(BandRepresenter.new(band).render).must_equal json }
 end
 
   class APITest < MiniTest::Spec
@@ -356,7 +356,7 @@ end
       end
 
       it "renders" do
-        OpenStruct.new(:songs => {"7" => Song.new("Contemplation")}).extend(representer).to_hash.must_equal("songs"=>{"7"=>{"name"=>"Contemplation"}})
+        _(OpenStruct.new(:songs => {"7" => Song.new("Contemplation")}).extend(representer).to_hash).must_equal("songs"=>{"7"=>{"name"=>"Contemplation"}})
       end
 
       describe "parsing" do
@@ -364,12 +364,12 @@ end
         let(:hsh) { {"7"=>{"name"=>"Contemplation"}} }
 
         it "parses incoming hash" do
-          subject.from_hash("songs"=>hsh).songs.must_equal({"7"=>Song.new("Contemplation")})
+          _(subject.from_hash("songs"=>hsh).songs).must_equal({"7"=>Song.new("Contemplation")})
         end
 
         it "doesn't modify the incoming hash" do
           subject.from_hash("songs"=> incoming_hash = hsh.dup)
-          hsh.must_equal incoming_hash
+          _(hsh).must_equal incoming_hash
         end
       end
     end

data/test/lonely_test.rb

@@ -60,11 +60,11 @@ class LonelyRepresenterTest < MiniTest::Spec
       end
 
       it "parses array" do
-        [].extend(representer).from_json(json).must_equal songs
+        _([].extend(representer).from_json(json)).must_equal songs
       end
 
       it "parses array with decorator" do
-        decorator.new([]).from_json(json).must_equal songs
+        _(decorator.new([]).from_json(json)).must_equal songs
       end
     end
 
@@ -75,8 +75,8 @@ class LonelyRepresenterTest < MiniTest::Spec
         end
       end
 
-      it { songs.extend(representer).to_json.must_equal json }
-      it { [].extend(representer).from_json(json).must_equal songs }
+      it { _(songs.extend(representer).to_json).must_equal json }
+      it { _([].extend(representer).from_json(json)).must_equal songs }
     end
 
     describe "with contained text" do
@@ -93,7 +93,7 @@ class LonelyRepresenterTest < MiniTest::Spec
       end
 
       it "returns objects array from #from_json" do
-        [].extend(representer).from_json(json).must_equal songs
+        _([].extend(representer).from_json(json)).must_equal songs
       end
     end
   end
@@ -112,7 +112,7 @@ class LonelyRepresenterTest < MiniTest::Spec
     end
 
 
-    it { [1,2].extend(representer).to_hash(user_options: {one: One, two: Two}).must_equal(["One: 1", "Two: 2"]) }
+    it { _([1,2].extend(representer).to_hash(user_options: {one: One, two: Two})).must_equal(["One: 1", "Two: 2"]) }
   end
 
 
@@ -129,11 +129,11 @@ class LonelyRepresenterTest < MiniTest::Spec
 
       describe "#to_json" do
         it "renders hash" do
-          songs.extend(representer).to_json.must_equal json
+          _(songs.extend(representer).to_json).must_equal json
         end
 
         it "renders hash with decorator" do
-          decorator.new(songs).to_json.must_equal json
+          _(decorator.new(songs).to_json).must_equal json
         end
 
         it "respects :exclude" do
@@ -147,11 +147,11 @@ class LonelyRepresenterTest < MiniTest::Spec
 
       describe "#from_json" do
         it "returns objects array" do
-          {}.extend(representer).from_json(json).must_equal songs
+          _({}.extend(representer).from_json(json)).must_equal songs
         end
 
         it "parses hash with decorator" do
-          decorator.new({}).from_json(json).must_equal songs
+          _(decorator.new({}).from_json(json)).must_equal songs
         end
 
         it "respects :exclude" do
@@ -171,8 +171,8 @@ class LonelyRepresenterTest < MiniTest::Spec
           end
         end
 
-        it { songs.extend(representer).to_json.must_equal json }
-        it { {}.extend(representer).from_json(json).must_equal songs }
+        it { _(songs.extend(representer).to_json).must_equal json }
+        it { _({}.extend(representer).from_json(json)).must_equal songs }
       end
     end
 
@@ -187,7 +187,7 @@ class LonelyRepresenterTest < MiniTest::Spec
       let(:data) { {one: 2, two: 3} }
 
       describe "#to_json" do
-        it { data.extend(representer).to_json.must_equal %{{"one":2,"two":3}} }
+        it { _(data.extend(representer).to_json).must_equal %{{"one":2,"two":3}} }
 
         # it "respects :exclude" do
         #   assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:exclude => [:one])
@@ -199,7 +199,7 @@ class LonelyRepresenterTest < MiniTest::Spec
       end
 
       describe "#from_json" do # FIXME: what's the point of this?
-        it { data.extend(representer).from_hash(data).must_equal data }
+        it { _(data.extend(representer).from_hash(data)).must_equal data }
       end
     end
 
@@ -234,6 +234,6 @@ class CollectionWithIncludeTest < MiniTest::Spec
     end
   end
 
-  it { representer.new([Song.new(1, "ACAB")]).to_hash.must_equal([{"id"=>1, "title"=>"ACAB"}]) }
-  it { representer.new([Song.new(1, "ACAB")]).to_hash(include: [:title]).must_equal([{"title"=>"ACAB"}]) }
+  it { _(representer.new([Song.new(1, "ACAB")]).to_hash).must_equal([{"id"=>1, "title"=>"ACAB"}]) }
+  it { _(representer.new([Song.new(1, "ACAB")]).to_hash(include: [:title])).must_equal([{"title"=>"ACAB"}]) }
 end

data/test/nested_test.rb

@@ -35,14 +35,14 @@ class NestedTest < MiniTest::Spec
 
           # do not use extend on the nested object. # FIXME: make this a proper test with two describes instead of this pseudo-meta stuff.
           if is_decorator==true
-            album.wont_be_kind_of(Representable::Hash)
+            _(album).wont_be_kind_of(Representable::Hash)
           end
         end
 
         it "parses nested properties to Album instance" do
           album = parse(representer.prepare(Album.new), output)
-          album.label.must_equal "Epitaph"
-          album.owner.must_equal "Brett Gurewitz"
+          _(album.label).must_equal "Epitaph"
+          _(album.owner).must_equal "Brett Gurewitz"
         end
       end
     end
@@ -76,9 +76,9 @@ class NestedTest < MiniTest::Spec
 
       it "parses nested properties to Album instance" do
       	album = parse(representer.prepare(Album.new), output)
-      	album.label.must_equal "Epitaph"
-      	album.owner.must_equal "Brett Gurewitz"
-        album.amount.must_equal 19
+      	_(album.label).must_equal "Epitaph"
+      	_(album.owner).must_equal "Brett Gurewitz"
+        _(album.amount).must_equal 19
       end
     end
   end
@@ -102,7 +102,7 @@ class NestedTest < MiniTest::Spec
     let(:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
 
     it "renders nested Album-properties in separate section" do
-      representer.prepare(album).to_hash.must_equal({"Label"=>{"owner"=>"Brett Gurewitz"}})
+      _(representer.prepare(album).to_hash).must_equal({"Label"=>{"owner"=>"Brett Gurewitz"}})
     end
 
     # it "parses nested properties to Album instance" do

data/test/object_test.rb

@@ -24,17 +24,17 @@ class ObjectTest < MiniTest::Spec
   it do
     representer.prepare(target).from_object(source)
 
-    target.title.must_equal "The King Is Dead"
-    target.album.name.must_equal "RUINER"
-    target.album.songs[0].title.must_equal "IN VINO VERITAS II"
+    _(target.title).must_equal "The King Is Dead"
+    _(target.album.name).must_equal "RUINER"
+    _(target.album.songs[0].title).must_equal "IN VINO VERITAS II"
   end
 
   # ignore nested object when nil
   it do
     representer.prepare(Song.new("The King Is Dead")).from_object(Song.new)
 
-    target.title.must_be_nil # scalar property gets overridden when nil.
-    target.album.must_be_nil # nested property stays nil.
+    _(target.title).must_be_nil # scalar property gets overridden when nil.
+    _(target.album).must_be_nil # nested property stays nil.
   end
 
   # to_object
@@ -53,8 +53,8 @@ class ObjectTest < MiniTest::Spec
 
     it do
       representer.prepare(source).to_object
-      source.album.name.must_equal "Live"
-      source.album.songs[0].title.must_equal 1
+      _(source.album.name).must_equal "Live"
+      _(source.album.songs[0].title).must_equal 1
     end
   end
 end

data/test/option_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class OptionTest < MiniTest::Spec
+  class Callable
+    include Uber::Callable
+    def call(*); "callable" end
+  end
+
+  class MyRepresenter < Representable::Decorator
+    include Representable::JSON
+
+    property :static,   getter: "static"
+    property :symbol,   getter: :symbol
+    property :proc,     getter: ->(*) { "proc" }
+    property :callable, getter: Callable.new
+  end
+
+  Album = Struct.new(:static) do
+    def symbol(*); "symbol" end
+  end
+
+  let(:album_representer) { MyRepresenter.new(Album.new) }
+
+  describe ::Representable::Option do
+    it "supports all types of callables (method, proc, static etc)" do
+      _(album_representer.to_hash).must_equal({
+        "static"    => "static",
+        "symbol"    => "symbol",
+        "proc"      => "proc",
+        "callable"  => "callable",
+      })
+    end
+  end
+end

data/test/parse_pipeline_test.rb

@@ -22,12 +22,12 @@ class ParsePipelineTest < MiniTest::Spec
 
     it do
       representer.new(album = Album.new).from_hash("songs"=>nil)
-      album.songs.must_equal []
+      _(album.songs).must_equal []
     end
 
     it do
       representer.new(album = Album.new).from_hash("songs"=>[{"title" => "Business Conduct"}])
-      album.songs.must_equal [Song.new("Business Conduct")]
+      _(album.songs).must_equal [Song.new("Business Conduct")]
     end
   end
 
@@ -57,6 +57,6 @@ class ParsePipelineTest < MiniTest::Spec
     skip "TODO: implement :parse_pipeline and :render_pipeline, and before/after/replace semantics"
     album = Album.new
     Representer.new(album).from_hash({"artist"=>{"email"=>"yo"}, "songs"=>[{"title"=>"Affliction"}, {"title"=>"Dream Beater"}]})
-    album.songs.must_equal([Song.new("Affliction"), Song.new("Dream Beater")])
+    _(album.songs).must_equal([Song.new("Affliction"), Song.new("Dream Beater")])
   end
 end

data/test/pipeline_test.rb

@@ -24,15 +24,15 @@ class PipelineTest < MiniTest::Spec
   AssignFragment = ->(input, options) { options[:fragment] = input }
 
   it "linear" do
-    P[SkipParse, Setter].("doc", {fragment: 1}).must_equal "Setter(doc)"
+    _(P[SkipParse, Setter].("doc", {fragment: 1})).must_equal "Setter(doc)"
 
 
     # parse style.
-    P[AssignFragment, SkipParse, CreateObject, Prepare].("Bla", {}).must_equal "Prepare(#<OpenStruct>)"
+    _(P[AssignFragment, SkipParse, CreateObject, Prepare].("Bla", {})).must_equal "Prepare(#<OpenStruct>)"
 
 
     # render style.
-    P[Getter, StopOnNil, SkipRender, Prepare, Setter].(nil, {}).
+    _(P[Getter, StopOnNil, SkipRender, Prepare, Setter].(nil, {})).
       must_equal "Setter(Prepare(Yo))"
 
     # pipeline = Representable::Pipeline[SkipParse  , SetResult, ModifyResult]
@@ -46,8 +46,8 @@ class PipelineTest < MiniTest::Spec
 
 
     pipeline = Representable::Pipeline[SkipParse, Stopping, Prepare]
-    pipeline.(nil, fragment: "oy!").must_equal "Prepare()"
-    pipeline.(nil, fragment: "stop!").must_equal Representable::Pipeline::Stop
+    _(pipeline.(nil, fragment: "oy!")).must_equal "Prepare()"
+    _(pipeline.(nil, fragment: "stop!")).must_equal Representable::Pipeline::Stop
   end
 
   describe "Collect" do
@@ -55,11 +55,11 @@ class PipelineTest < MiniTest::Spec
     Add = ->(input, options) { "#{input}+" }
     let(:pipeline) { R::Collect[Reverse, Add] }
 
-    it { pipeline.(["yo!", "oy!"], {}).must_equal ["!oy+", "!yo+"] }
+    it { _(pipeline.(["yo!", "oy!"], {})).must_equal ["!oy+", "!yo+"] }
 
     describe "Pipeline with Collect" do
       let(:pipeline) { P[Reverse, R::Collect[Reverse, Add]] }
-      it { pipeline.(["yo!", "oy!"], {}).must_equal ["!yo+", "!oy+"] }
+      it { _(pipeline.(["yo!", "oy!"], {})).must_equal ["!yo+", "!oy+"] }
     end
   end
 
@@ -76,26 +76,26 @@ class PipelineTest < MiniTest::Spec
 
   it "rendering scalar property" do
     doc = {}
-    P[
+    _(P[
       R::GetValue,
       R::StopOnSkipable,
       R::AssignName,
       R::WriteFragment
-    ].(nil, {represented: Song.new("Lime Green"), binding: title, doc: doc}).must_equal "Lime Green"
+    ].(nil, {represented: Song.new("Lime Green"), binding: title, doc: doc})).must_equal "Lime Green"
 
-    doc.must_equal({"title"=>"Lime Green"})
+    _(doc).must_equal({"title"=>"Lime Green"})
   end
 
   it "parsing scalar property" do
-    P[
+    _(P[
       R::AssignName,
       R::ReadFragment,
       R::StopOnNotFound,
       R::OverwriteOnNil,
       # R::SkipParse,
       R::SetValue,
-    ].extend(P::Debug).(doc={"title"=>"Eruption"}, {represented: song=Song.new("Lime Green"), binding: title, doc: doc}).must_equal "Eruption"
-    song.title.must_equal "Eruption"
+    ].extend(P::Debug).(doc={"title"=>"Eruption"}, {represented: song=Song.new("Lime Green"), binding: title, doc: doc})).must_equal "Eruption"
+    _(song.title).must_equal "Eruption"
   end
 
 
@@ -115,7 +115,7 @@ class PipelineTest < MiniTest::Spec
 
   it "rendering typed property" do
     doc = {}
-    P[
+    _(P[
       R::GetValue,
       R::StopOnSkipable,
       R::StopOnNil,
@@ -123,13 +123,13 @@ class PipelineTest < MiniTest::Spec
       R::Serialize,
       R::AssignName,
       R::WriteFragment
-    ].extend(P::Debug).(nil, {represented: song_model, binding: artist, doc: doc, options: {}}).must_equal({"name" => "Diesel Boy"})
+    ].extend(P::Debug).(nil, {represented: song_model, binding: artist, doc: doc, options: {}})).must_equal({"name" => "Diesel Boy"})
 
-    doc.must_equal({"artist"=>{"name"=>"Diesel Boy"}})
+    _(doc).must_equal({"artist"=>{"name"=>"Diesel Boy"}})
   end
 
   it "parsing typed property" do
-    P[
+    _(P[
       R::AssignName,
       R::ReadFragment,
       R::StopOnNotFound,
@@ -139,8 +139,8 @@ class PipelineTest < MiniTest::Spec
       R::Decorate,
       R::Deserialize,
       R::SetValue,
-    ].extend(P::Debug).(doc={"artist"=>{"name"=>"Doobie Brothers"}}, {represented: song_model, binding: artist, doc: doc, options: {}}).must_equal model=Artist.new("Doobie Brothers")
-    song_model.artist.must_equal model
+    ].extend(P::Debug).(doc={"artist"=>{"name"=>"Doobie Brothers"}}, {represented: song_model, binding: artist, doc: doc, options: {}})).must_equal model=Artist.new("Doobie Brothers")
+    _(song_model.artist).must_equal model
   end
 
 
@@ -153,7 +153,7 @@ class PipelineTest < MiniTest::Spec
   }
   it "render scalar collection" do
     doc = {}
-    P[
+    _(P[
       R::GetValue,
       R::StopOnSkipable,
       R::Collect[
@@ -161,9 +161,9 @@ class PipelineTest < MiniTest::Spec
       ],
       R::AssignName,
       R::WriteFragment
-    ].extend(P::Debug).(nil, {represented: Album.new([1,2,3]), binding: ratings, doc: doc, options: {}}).must_equal([1,2,3])
+    ].extend(P::Debug).(nil, {represented: Album.new([1,2,3]), binding: ratings, doc: doc, options: {}})).must_equal([1,2,3])
 
-    doc.must_equal({"ratings"=>[1,2,3]})
+    _(doc).must_equal({"ratings"=>[1,2,3]})
   end
 
 ######### collection :songs, extend: SongRepresenter
@@ -174,7 +174,7 @@ class PipelineTest < MiniTest::Spec
   }
   it "render typed collection" do
     doc = {}
-    P[
+    _(P[
       R::GetValue,
       R::StopOnSkipable,
       R::Collect[
@@ -183,16 +183,16 @@ class PipelineTest < MiniTest::Spec
       ],
       R::AssignName,
       R::WriteFragment
-    ].extend(P::Debug).(nil, {represented: Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]), binding: artists, doc: doc, options: {}}).must_equal([{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}])
+    ].extend(P::Debug).(nil, {represented: Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]), binding: artists, doc: doc, options: {}})).must_equal([{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}])
 
-    doc.must_equal({"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]})
+    _(doc).must_equal({"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]})
   end
 
 let(:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]) }
 
   it "parse typed collection" do
     doc = {"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]}
-    P[
+    _(P[
       R::AssignName,
       R::ReadFragment,
       R::StopOnNotFound,
@@ -205,9 +205,9 @@ let(:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Ha
         R::Deserialize,
       ],
       R::SetValue,
-    ].extend(P::Debug).(doc, {represented: album_model, binding: artists, doc: doc, options: {}}).must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
+    ].extend(P::Debug).(doc, {represented: album_model, binding: artists, doc: doc, options: {}})).must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
 
-    album_model.artists.must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
+    _(album_model.artists).must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
   end
 
   # TODO: test with arrays, too, not "only" Pipeline instances.
@@ -215,41 +215,41 @@ let(:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Ha
     let(:pipeline) { P[R::GetValue, R::StopOnSkipable, R::StopOnNil] }
 
     it "returns Pipeline instance when passing in Pipeline instance" do
-      P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).must_be_instance_of(R::Pipeline)
+      _(P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable)).must_be_instance_of(R::Pipeline)
     end
 
     it "replaces if exists" do
       # pipeline.insert!(R::Default, replace: R::StopOnSkipable)
-      P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).must_equal P[R::GetValue, R::Default, R::StopOnNil]
-      pipeline.must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
+      _(P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable)).must_equal P[R::GetValue, R::Default, R::StopOnNil]
+      _(pipeline).must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
     end
 
     it "replaces Function instance" do
       pipeline = P[R::Prepare, R::StopOnSkipable, R::StopOnNil]
-      P::Insert.(pipeline, R::Default, replace: R::Prepare).must_equal P[R::Default, R::StopOnSkipable, R::StopOnNil]
-      pipeline.must_equal P[R::Prepare, R::StopOnSkipable, R::StopOnNil]
+      _(P::Insert.(pipeline, R::Default, replace: R::Prepare)).must_equal P[R::Default, R::StopOnSkipable, R::StopOnNil]
+      _(pipeline).must_equal P[R::Prepare, R::StopOnSkipable, R::StopOnNil]
     end
 
     it "does not replace when not existing" do
       P::Insert.(pipeline, R::Default, replace: R::Prepare)
-      pipeline.must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
+      _(pipeline).must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
     end
 
     it "applies on nested Collect" do
       pipeline = P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil]
 
-      P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
-      pipeline.must_equal P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil]
+      _(P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).extend(P::Debug).inspect).must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
+      _(pipeline).must_equal P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil]
 
 
-      P::Insert.(pipeline, R::Default, replace: R::StopOnNil).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], Default]"
+      _(P::Insert.(pipeline, R::Default, replace: R::StopOnNil).extend(P::Debug).inspect).must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], Default]"
     end
 
     it "applies on nested Collect with Function::CreateObject" do
       pipeline = P[R::GetValue, R::Collect[R::GetValue, R::CreateObject], R::StopOnNil]
 
-      P::Insert.(pipeline, R::Default, replace: R::CreateObject).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
-      pipeline.must_equal P[R::GetValue, R::Collect[R::GetValue, R::CreateObject], R::StopOnNil]
+      _(P::Insert.(pipeline, R::Default, replace: R::CreateObject).extend(P::Debug).inspect).must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
+      _(pipeline).must_equal P[R::GetValue, R::Collect[R::GetValue, R::CreateObject], R::StopOnNil]
     end
   end
 
@@ -257,8 +257,8 @@ let(:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Ha
     let(:pipeline) { P[R::GetValue, R::StopOnNil] }
 
     it do
-      P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect.must_equal "Pipeline[StopOnNil]"
-      pipeline.extend(P::Debug).inspect.must_equal "Pipeline[GetValue, StopOnNil]"
+      _(P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect).must_equal "Pipeline[StopOnNil]"
+      _(pipeline.extend(P::Debug).inspect).must_equal "Pipeline[GetValue, StopOnNil]"
     end
   end
 
@@ -266,8 +266,8 @@ let(:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Ha
     let(:pipeline) { P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil] }
 
     it do
-      P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect.must_equal "Pipeline[Collect[StopOnSkipable], StopOnNil]"
-      pipeline.extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], StopOnNil]"
+      _(P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect).must_equal "Pipeline[Collect[StopOnSkipable], StopOnNil]"
+      _(pipeline.extend(P::Debug).inspect).must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], StopOnNil]"
     end
   end
 end

data/test/populator_test.rb

@@ -20,7 +20,7 @@ class PopulatorTest < Minitest::Spec
 
     it do
       album.extend(representer).from_hash("songs"=>[{"id"=>1}, {"id"=>2}], "artist"=>{"name"=>"Waste"})
-      album.inspect.must_equal "#<struct PopulatorTest::Album songs=[#<struct PopulatorTest::Song id=1>, #<struct PopulatorTest::Song id=2>], artist=#<struct PopulatorTest::Artist name=\"Waste\">>"
+      _(album.inspect).must_equal "#<struct PopulatorTest::Album songs=[#<struct PopulatorTest::Song id=1>, #<struct PopulatorTest::Song id=2>], artist=#<struct PopulatorTest::Artist name=\"Waste\">>"
     end
   end
 
@@ -37,7 +37,7 @@ class PopulatorFindOrInstantiateTest < Minitest::Spec
     end
   end
 
-  Composer = Struct.new(:song)
+  Composer = Class.new
   Composer.class_eval do
     def song=(v)
       @song = v
@@ -60,17 +60,17 @@ class PopulatorFindOrInstantiateTest < Minitest::Spec
     it "finds by :id and creates new without :id" do
       album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance"}})
 
-      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
-      album.song.id.must_equal 1
-      album.song.uid.must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
+      _(album.song.title).must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      _(album.song.id).must_equal 1
+      _(album.song.uid).must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
     end
 
     it "creates new without :id" do
       album.from_hash({"song"=>{"title"=>"Lower"}})
 
-      album.song.title.must_equal "Lower"
-      album.song.id.must_be_nil
-      album.song.uid.must_be_nil
+      _(album.song.title).must_equal "Lower"
+      _(album.song.id).must_be_nil
+      _(album.song.uid).must_be_nil
     end
   end
 
@@ -90,16 +90,16 @@ class PopulatorFindOrInstantiateTest < Minitest::Spec
         {"title"=>"Suffer"}
       ]})
 
-      album.songs[0].title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
-      album.songs[0].id.must_equal 1
-      album.songs[0].uid.must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
+      _(album.songs[0].title).must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      _(album.songs[0].id).must_equal 1
+      _(album.songs[0].uid).must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
 
-      album.songs[1].title.must_equal "Suffer"
-      album.songs[1].id.must_be_nil
-      album.songs[1].uid.must_be_nil
+      _(album.songs[1].title).must_equal "Suffer"
+      _(album.songs[1].id).must_be_nil
+      _(album.songs[1].uid).must_be_nil
     end
 
     # TODO: test with existing collection
   end
 
-end
+end

data/test/prepare_test.rb

@@ -28,7 +28,7 @@ class PrepareTest < BaseTest
 
     it "calls prepare:, nothing else" do
       # render(hit).must_equal_document(output)
-      hit.to_hash.must_equal({"song" => PreparerClass.new(song)})
+      _(hit.to_hash).must_equal({"song" => PreparerClass.new(song)})
     end
 
 
@@ -60,7 +60,7 @@ class PrepareTest < BaseTest
       # render(hit).must_equal_document(output)
       hit.from_hash("song" => {})
 
-      hit.song.must_equal(PreparerClass.new(String.new))
+      _(hit.song).must_equal(PreparerClass.new(String.new))
     end
   end
 end