representable 3.2.0 → 3.3.0

data/test/pipeline_test.rb

@@ -1,6 +1,6 @@
 require "test_helper"
 
-class PipelineTest < MiniTest::Spec
+class PipelineTest < Minitest::Spec
   Song   = Struct.new(:title, :artist)
   Artist = Struct.new(:name)
   Album  = Struct.new(:ratings, :artists)
@@ -8,32 +8,29 @@ class PipelineTest < MiniTest::Spec
   R = Representable
   P = R::Pipeline
 
-  Getter        = ->(input, options) { "Yo" }
-  StopOnNil     = ->(input, options) { input }
+  Getter        = ->(_input, _options) { "Yo" }
+  StopOnNil     = ->(input, _options) { input }
   SkipRender    = ->(input, *) { input == "Yo" ? input : P::Stop }
 
-  Prepare       = ->(input, options) { "Prepare(#{input})" }
+  Prepare       = ->(input, _options) { "Prepare(#{input})" }
   Deserialize   = ->(input, options) { "Deserialize(#{input}, #{options[:fragment]})" }
 
-  SkipParse     = ->(input, options) { input }
-  CreateObject  = ->(input, options) { OpenStruct.new }
+  SkipParse     = ->(input, _options) { input }
+  CreateObject  = ->(_input, _options) { OpenStruct.new }
 
-
-  Setter        = ->(input, options) { "Setter(#{input})" }
+  Setter        = ->(input, _options) { "Setter(#{input})" }
 
   AssignFragment = ->(input, options) { options[:fragment] = input }
 
   it "linear" do
     _(P[SkipParse, Setter].("doc", {fragment: 1})).must_equal "Setter(doc)"
 
-
     # parse style.
     _(P[AssignFragment, SkipParse, CreateObject, Prepare].("Bla", {})).must_equal "Prepare(#<OpenStruct>)"
 
-
     # render style.
-    _(P[Getter, StopOnNil, SkipRender, Prepare, Setter].(nil, {})).
-      must_equal "Setter(Prepare(Yo))"
+    _(P[Getter, StopOnNil, SkipRender, Prepare, Setter].(nil, {}))
+      .must_equal "Setter(Prepare(Yo))"
 
     # pipeline = Representable::Pipeline[SkipParse  , SetResult, ModifyResult]
     # pipeline.(fragment: "yo!").must_equal "modified object from yo!"
@@ -41,18 +38,15 @@ class PipelineTest < MiniTest::Spec
 
   Stopping      = ->(input, options) { return P::Stop if options[:fragment] == "stop!"; input }
 
-
   it "stopping" do
-
-
     pipeline = Representable::Pipeline[SkipParse, Stopping, Prepare]
     _(pipeline.(nil, fragment: "oy!")).must_equal "Prepare()"
     _(pipeline.(nil, fragment: "stop!")).must_equal Representable::Pipeline::Stop
   end
 
   describe "Collect" do
-    Reverse = ->(input, options) { input.reverse }
-    Add = ->(input, options) { "#{input}+" }
+    Reverse = ->(input, _options) { input.reverse }
+    Add = ->(input, _options) { "#{input}+" }
     let(:pipeline) { R::Collect[Reverse, Add] }
 
     it { _(pipeline.(["yo!", "oy!"], {})).must_equal ["!oy+", "!yo+"] }
@@ -63,149 +57,172 @@ class PipelineTest < MiniTest::Spec
     end
   end
 
-
-
-
   ######### scalar property
 
-  let(:title) {
+  let(:title) do
     dfn = R::Definition.new(:title)
 
     R::Hash::Binding.new(dfn)
-  }
+  end
 
   it "rendering scalar property" do
     doc = {}
-    _(P[
-      R::GetValue,
-      R::StopOnSkipable,
-      R::AssignName,
-      R::WriteFragment
-    ].(nil, {represented: Song.new("Lime Green"), binding: title, doc: doc})).must_equal "Lime Green"
+    _(
+      P[
+            R::GetValue,
+            R::StopOnSkipable,
+            R::AssignName,
+            R::WriteFragment
+          ].(nil, {represented: Song.new("Lime Green"), binding: title, doc: doc})
+    ).must_equal "Lime Green"
 
     _(doc).must_equal({"title"=>"Lime Green"})
   end
 
   it "parsing scalar property" do
-    _(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"
+    _(
+      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"
   end
 
-
-
   module ArtistRepresenter
     include Representable::Hash
     property :name
   end
 
-  let(:artist) {
+  let(:artist) do
     dfn = R::Definition.new(:artist, extend: ArtistRepresenter, class: Artist)
 
     R::Hash::Binding.new(dfn)
-  }
+  end
 
   let(:song_model) { Song.new("Lime Green", Artist.new("Diesel Boy")) }
 
   it "rendering typed property" do
     doc = {}
-    _(P[
-      R::GetValue,
-      R::StopOnSkipable,
-      R::StopOnNil,
-      R::Decorate,
-      R::Serialize,
-      R::AssignName,
-      R::WriteFragment
-    ].extend(P::Debug).(nil, {represented: song_model, binding: artist, doc: doc, options: {}})).must_equal({"name" => "Diesel Boy"})
+    _(
+      P[
+            R::GetValue,
+            R::StopOnSkipable,
+            R::StopOnNil,
+            R::Decorate,
+            R::Serialize,
+            R::AssignName,
+            R::WriteFragment
+          ].extend(P::Debug).(nil, {
+                                represented: song_model, binding: artist, doc: doc,
+      options: {}
+                              })
+    ).must_equal({"name" => "Diesel Boy"})
 
     _(doc).must_equal({"artist"=>{"name"=>"Diesel Boy"}})
   end
 
   it "parsing typed property" do
-    _(P[
-      R::AssignName,
-      R::ReadFragment,
-      R::StopOnNotFound,
-      R::OverwriteOnNil,
-      R::AssignFragment,
-      R::CreateObject::Class,
-      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")
+    _(
+      P[
+            R::AssignName,
+            R::ReadFragment,
+            R::StopOnNotFound,
+            R::OverwriteOnNil,
+            R::AssignFragment,
+            R::CreateObject::Class,
+            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
   end
 
-
   ######### collection :ratings
 
-  let(:ratings) {
+  let(:ratings) do
     dfn = R::Definition.new(:ratings, collection: true, skip_render: ->(*) { false })
 
     R::Hash::Binding::Collection.new(dfn)
-  }
+  end
   it "render scalar collection" do
     doc = {}
-    _(P[
-      R::GetValue,
-      R::StopOnSkipable,
-      R::Collect[
-        R::SkipRender,
-      ],
-      R::AssignName,
-      R::WriteFragment
-    ].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]})
+    _(
+      P[
+            R::GetValue,
+            R::StopOnSkipable,
+            R::Collect[
+              R::SkipRender,
+            ],
+            R::AssignName,
+            R::WriteFragment
+          ].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]})
   end
 
-######### collection :songs, extend: SongRepresenter
-  let(:artists) {
+  ######### collection :songs, extend: SongRepresenter
+  let(:artists) do
     dfn = R::Definition.new(:artists, collection: true, extend: ArtistRepresenter, class: Artist)
 
     R::Hash::Binding::Collection.new(dfn)
-  }
+  end
   it "render typed collection" do
     doc = {}
-    _(P[
-      R::GetValue,
-      R::StopOnSkipable,
-      R::Collect[
-        R::Decorate,
-        R::Serialize,
-      ],
-      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"}])
+    _(
+      P[
+            R::GetValue,
+            R::StopOnSkipable,
+            R::Collect[
+              R::Decorate,
+              R::Serialize,
+            ],
+            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"}])
 
     _(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")]) }
+  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[
-      R::AssignName,
-      R::ReadFragment,
-      R::StopOnNotFound,
-      R::OverwriteOnNil,
-      # R::SkipParse,
-      R::Collect[
-        R::AssignFragment,
-        R::CreateObject::Class,
-        R::Decorate,
-        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")])
+    _(
+      P[
+            R::AssignName,
+            R::ReadFragment,
+            R::StopOnNotFound,
+            R::OverwriteOnNil,
+            # R::SkipParse,
+            R::Collect[
+              R::AssignFragment,
+              R::CreateObject::Class,
+              R::Decorate,
+              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")])
 
     _(album_model.artists).must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
   end
@@ -238,17 +255,31 @@ let(:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Ha
     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]"
+      _(
+        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]"
+      _(
+        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
@@ -266,8 +297,13 @@ 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]"
+      _(
+        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
+end

data/test/populator_test.rb

@@ -7,11 +7,11 @@ class PopulatorTest < Minitest::Spec
 
   describe "populator: ->{}" do
     representer! do
-      collection :songs, populator: ->(input, options) { options[:represented].songs << song = Song.new; song } do
+      collection :songs, populator: ->(_input, options) { options[:represented].songs << song = Song.new; song } do
         property :id
       end
 
-      property :artist, populator: ->(input, options) { options[:represented].artist = Artist.new } do
+      property :artist, populator: ->(_input, options) { options[:represented].artist = Artist.new } do
         property :name
       end
     end
@@ -19,20 +19,20 @@ class PopulatorTest < Minitest::Spec
     let(:album) { Album.new([]) }
 
     it do
-      album.extend(representer).from_hash("songs"=>[{"id"=>1}, {"id"=>2}], "artist"=>{"name"=>"Waste"})
+      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\">>"
     end
   end
 
   describe "populator: ->{}, " do
-
   end
 end
 
 class PopulatorFindOrInstantiateTest < Minitest::Spec
   Song = Struct.new(:id, :title, :uid) do
-    def self.find_by(attributes={})
-      return new(1, "Resist Stan", "abcd") if attributes[:id]==1# we should return the same object here
+    def self.find_by(attributes = {})
+      return new(1, "Resist Stan", "abcd") if attributes[:id] == 1 # we should return the same object here
+
       new
     end
   end
@@ -58,9 +58,9 @@ class PopulatorFindOrInstantiateTest < Minitest::Spec
     let(:album) { Composer.new.extend(representer).extend(Representable::Debug) }
 
     it "finds by :id and creates new without :id" do
-      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance"}})
+      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.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
@@ -85,12 +85,16 @@ class PopulatorFindOrInstantiateTest < Minitest::Spec
     let(:album) { Struct.new(:songs).new([]).extend(representer) }
 
     it "finds by :id and creates new without :id" do
-      album.from_hash({"songs"=>[
-        {"id" => 1, "title"=>"Resist Stance"},
-        {"title"=>"Suffer"}
-      ]})
-
-      _(album.songs[0].title).must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      album.from_hash(
+        {
+          "songs" => [
+            {"id" => 1, "title" => "Resist Stance"},
+            {"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.
 
@@ -101,5 +105,4 @@ class PopulatorFindOrInstantiateTest < Minitest::Spec
 
     # TODO: test with existing collection
   end
-
 end

data/test/prepare_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class PrepareTest < BaseTest
   class PreparerClass
@@ -6,10 +6,10 @@ class PrepareTest < BaseTest
       @object = object
     end
 
-    def ==(b)
-      return unless b.instance_of?(PreparerClass)
+    def ==(other)
+      return unless other.instance_of?(PreparerClass)
 
-      object == b.object
+      object == other.object
     end
 
     attr_reader :object
@@ -18,10 +18,10 @@ class PrepareTest < BaseTest
   describe "#to_hash" do # TODO: introduce :representable option?
     representer! do
       property :song,
-        :prepare       => lambda { |options| options[:binding][:arbitrary].new(options[:input]) },
-        :arbitrary     => PreparerClass,
-        :extend => true,
-        :representable => false # don't call #to_hash.
+               :prepare       => ->(options) { options[:binding][:arbitrary].new(options[:input]) },
+               :arbitrary     => PreparerClass,
+               :extend        => true,
+               :representable => false # don't call #to_hash.
     end
 
     let(:hit) { Struct.new(:song).new(song).extend(representer) }
@@ -31,7 +31,6 @@ class PrepareTest < BaseTest
       _(hit.to_hash).must_equal({"song" => PreparerClass.new(song)})
     end
 
-
     # it "calls #from_hash on the existing song instance, nothing else" do
     #   song_id = hit.song.object_id
 
@@ -42,16 +41,15 @@ class PrepareTest < BaseTest
     # end
   end
 
-
   describe "#from_hash" do
     representer! do
       property :song,
-        :prepare       => lambda { |options| options[:binding][:arbitrary].new(options[:input]) },
-        :arbitrary     => PreparerClass,
-        #:extend => true, # TODO: typed: true would be better.
-        :instance => String.new, # pass_fragment
-        :pass_options  => true,
-        :representable => false # don't call #to_hash.
+               :prepare       => ->(options) { options[:binding][:arbitrary].new(options[:input]) },
+               :arbitrary     => PreparerClass,
+               # :extend => true, # TODO: typed: true would be better.
+               :instance      => String.new, # pass_fragment
+               :pass_options  => true,
+               :representable => false # don't call #to_hash.
     end
 
     let(:hit) { Struct.new(:song).new.extend(representer) }
@@ -63,4 +61,4 @@ class PrepareTest < BaseTest
       _(hit.song).must_equal(PreparerClass.new(String.new))
     end
   end
-end
+end

data/test/private_options_test.rb

@@ -1,6 +1,7 @@
 require "test_helper"
 
-class PrivateOptionsTest < MiniTest::Spec # TODO: move me to separate file.
+# TODO: move me to separate file.
+class PrivateOptionsTest < Minitest::Spec
   representer!(decorator: true) do
   end
 
@@ -15,4 +16,4 @@ class PrivateOptionsTest < MiniTest::Spec # TODO: move me to separate file.
     representer.new(nil).from_hash(options)
     _(options).must_equal({exclude: "name"})
   end
-end
+end

data/test/reader_writer_test.rb

@@ -1,10 +1,10 @@
-require 'test_helper'
+require "test_helper"
 
 class ReaderWriterTest < BaseTest
   representer! do
     property :name,
-      :writer => lambda { |options| options[:doc]["title"] = "#{options[:user_options][:nr]}) #{options[:input]}" },
-      :reader => lambda { |options| self.name = options[:doc]["title"].split(") ").last }
+             :writer => ->(options) { options[:doc]["title"] = "#{options[:user_options][:nr]}) #{options[:input]}" },
+             :reader => ->(options) { self.name = options[:doc]["title"].split(") ").last }
   end
 
   subject { OpenStruct.new(:name => "Disorder And Disarray").extend(representer) }
@@ -16,4 +16,4 @@ class ReaderWriterTest < BaseTest
   it "uses :reader when parsing" do
     _(subject.from_hash({"title" => "15) The Wars End"}).name).must_equal "The Wars End"
   end
-end
+end

data/test/realistic_benchmark.rb

@@ -1,11 +1,10 @@
-require 'test_helper'
-require 'benchmark'
+require "test_helper"
+require "benchmark"
 
 SONG_PROPERTIES = 50.times.collect do |i|
   "song_property_#{i}"
 end
 
-
 module SongRepresenter
   include Representable::JSON
 
@@ -18,7 +17,6 @@ class NestedProperty < Representable::Decorator
   SONG_PROPERTIES.each { |p| property p }
 end
 
-
 class SongDecorator < Representable::Decorator
   include Representable::JSON
 
@@ -36,7 +34,7 @@ Song  = Struct.new(*SONG_PROPERTIES.map(&:to_sym))
 Album = Struct.new(:songs)
 
 def random_song
-  Song.new(*SONG_PROPERTIES.collect { |p| Song.new(*SONG_PROPERTIES) })
+  Song.new(*SONG_PROPERTIES.collect { |_p| Song.new(*SONG_PROPERTIES) })
 end
 
 times = []
@@ -53,7 +51,7 @@ end
 puts times.join("")
 
 album = Album.new(100.times.collect { random_song })
-require 'ruby-prof'
+require "ruby-prof"
 RubyProf.start
 AlbumRepresenter.new(album).to_hash
 res = RubyProf.stop
@@ -68,30 +66,26 @@ array[0..60].each { |a| puts a }
 ## 100 songs, 1000 attrs
 #  0.470000   0.010000   0.480000 (  0.483708)
 
-
 ### without binding cache:
-  # 2.790000   0.030000   2.820000 (  2.820190)
-
-
+# 2.790000   0.030000   2.820000 (  2.820190)
 
 ### with extend: on Song, with binding cache>
-  # 2.490000   0.030000   2.520000 (  2.517433) 2.4-3.0
-  ### without skip?
-  # 2.030000   0.020000   2.050000 (  2.050796) 2.1-2.3
-
-    ### without :writer
-    # 2.270000   0.010000   2.280000 (  2.284530 1.9-2.2
-      ### without :render_filter
-      #   2.020000   0.000000   2.020000 (  2.030234) 1.5-2.0
-        ###without default_for and skipable?
-        #   1.730000   0.010000   1.740000 (  1.735597 1.4-1.7
-          ### without :serialize
-          #   1.780000   0.010000   1.790000 (  1.786791) 1.4-1.7
-          ### using decorator
-          # 1.400000   0.030000   1.430000 (  1.434206) 1.4-1.6
-            ### with prepare AFTER  representable?
-            # 1.330000   0.010000   1.340000 (  1.335900) 1.1-1.3
-
+# 2.490000   0.030000   2.520000 (  2.517433) 2.4-3.0
+### without skip?
+# 2.030000   0.020000   2.050000 (  2.050796) 2.1-2.3
+
+### without :writer
+# 2.270000   0.010000   2.280000 (  2.284530 1.9-2.2
+### without :render_filter
+#   2.020000   0.000000   2.020000 (  2.030234) 1.5-2.0
+# ##without default_for and skipable?
+#   1.730000   0.010000   1.740000 (  1.735597 1.4-1.7
+### without :serialize
+#   1.780000   0.010000   1.790000 (  1.786791) 1.4-1.7
+### using decorator
+# 1.400000   0.030000   1.430000 (  1.434206) 1.4-1.6
+### with prepare AFTER  representable?
+# 1.330000   0.010000   1.340000 (  1.335900) 1.1-1.3
 
 # representable 2.0
 # 3.000000   0.020000   3.020000 (  3.013031) 2.7-3.0

data/test/render_nil_test.rb

@@ -1,6 +1,6 @@
 require "test_helper"
 
-class RenderNilTest < MiniTest::Spec
+class RenderNilTest < Minitest::Spec
   Song = Struct.new(:title)
 
   describe "render_nil: true" do