representable 3.2.0 → 3.3.0

data/test/for_collection_test.rb

@@ -1,6 +1,6 @@
-require 'test_helper'
+require "test_helper"
 
-class ForCollectionTest < MiniTest::Spec
+class ForCollectionTest < Minitest::Spec
   module SongRepresenter
     include Representable::JSON
 
@@ -10,28 +10,26 @@ class ForCollectionTest < MiniTest::Spec
   let(:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
   let(:json)  { "[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]" }
 
-
   # Module.for_collection
   # Decorator.for_collection
   for_formats(
-    :hash => [Representable::Hash, out=[{"name" => "Days Go By"}, {"name"=>"Can't Take Them All"}], out],
-    :json => [Representable::JSON, out="[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]", out],
+    :hash => [Representable::Hash, out = [{"name" => "Days Go By"}, {"name"=>"Can't Take Them All"}], out],
+    :json => [Representable::JSON, out = "[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]", out]
     # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
   ) do |format, mod, output, input|
-
     describe "Module::for_collection [#{format}]" do
       let(:format) { format }
 
-      let(:representer) {
+      let(:representer) do
         Module.new do
           include mod
-          property :name#, :as => :title
+          property :name # , :as => :title
 
           collection_representer :class => Song
 
           # self.representation_wrap = :songs if format == :xml
         end
-      }
+      end
 
       it { render(songs.extend(representer.for_collection)).must_equal_document output }
       it { render(representer.for_collection.prepare(songs)).must_equal_document output }
@@ -42,28 +40,27 @@ class ForCollectionTest < MiniTest::Spec
     describe "Module::for_collection without configuration [#{format}]" do
       let(:format) { format }
 
-      let(:representer) {
+      let(:representer) do
         Module.new do
           include mod
           property :name
         end
-      }
+      end
 
       # rendering works out of the box, no config necessary
       it { render(songs.extend(representer.for_collection)).must_equal_document output }
     end
 
-
     describe "Decorator::for_collection [#{format}]" do
       let(:format) { format }
-      let(:representer) {
+      let(:representer) do
         Class.new(Representable::Decorator) do
           include mod
           property :name
 
           collection_representer :class => Song
         end
-      }
+      end
 
       it { render(representer.for_collection.new(songs)).must_equal_document output }
       it { _(parse(representer.for_collection.new([]), input)).must_equal songs }
@@ -71,4 +68,4 @@ class ForCollectionTest < MiniTest::Spec
   end
 
   # with module including module
-end
+end

data/test/generic_test.rb

@@ -1,11 +1,11 @@
-require 'test_helper'
+require "test_helper"
 
-class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
+# TODO: rename/restructure to CollectionTest.
+class GenericTest < Minitest::Spec
   let(:new_album)  { OpenStruct.new.extend(representer) }
   let(:album)      { OpenStruct.new(:songs => ["Fuck Armageddon"]).extend(representer) }
   let(:song) { OpenStruct.new(:title => "Resist Stance") }
-  let(:song_representer) { Module.new do include Representable::Hash; property :title end  }
-
+  let(:song_representer) { Module.new { include Representable::Hash; property :title } }
 
   describe "::collection" do
     representer! do
@@ -23,14 +23,12 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
       _(album.songs).must_equal ["Fuck Armageddon"] # when the collection is not present in the incoming hash, this propery stays untouched.
     end
 
-
     # when collection is nil, it doesn't get rendered:
     for_formats(
       :hash => [Representable::Hash, {}],
-      :xml  => [Representable::XML, "<open_struct></open_struct>"],
-      :yaml => [Representable::YAML, "--- {}\n"], # FIXME: this doesn't look right.
-    ) do |format, mod, output, input|
-
+      :xml  => [Representable::XML, "<album></album>"],
+      :yaml => [Representable::YAML, "--- {}\n"] # FIXME: this doesn't look right.
+    ) do |format, mod, output, _input|
       describe "nil collections" do
         let(:format) { format }
 
@@ -50,10 +48,9 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
     # when collection is set but empty, render the empty collection.
     for_formats(
       :hash => [Representable::Hash, {"songs" => []}],
-      #:xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
-      :yaml => [Representable::YAML, "---\nsongs: []\n"],
-    ) do |format, mod, output, input|
-
+      # :xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
+      :yaml => [Representable::YAML, "---\nsongs: []\n"]
+    ) do |format, mod, output, _input|
       describe "empty collections" do
         let(:format) { format }
 
@@ -70,14 +67,12 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
       end
     end
 
-
     # when collection is [], suppress rendering when render_empty: false.
     for_formats(
       :hash => [Representable::Hash, {}],
-      #:xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
-      :yaml => [Representable::YAML, "--- {}\n"],
-    ) do |format, mod, output, input|
-
+      # :xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
+      :yaml => [Representable::YAML, "--- {}\n"]
+    ) do |format, mod, output, _input|
       describe "render_empty [#{format}]" do
         let(:format) { format }
 
@@ -93,14 +88,12 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
     end
   end
 
-
   # wrap_test
   for_formats(
-    :hash => [Representable::Hash, {}],
+    :hash => [Representable::Hash, {}]
     # :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song>/open_struct>"],
     # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
   ) do |format, mod, input|
-
     describe "parsing [#{format}] with wrap where wrap is missing" do
       representer!(:module => mod) do
         self.representation_wrap = :song
@@ -113,4 +106,4 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
       end
     end
   end
-end
+end

data/test/getter_setter_test.rb

@@ -1,21 +1,26 @@
-require 'test_helper'
+require "test_helper"
 
 class GetterSetterTest < BaseTest
   representer! do
     property :name, # key under :name.
-      :getter => lambda { |user_options:, **| "#{user_options[:welcome]} #{song_name}" },
-      :setter => lambda { |user_options:, input:, **| self.song_name = "#{user_options[:welcome]} #{input}" }
+             :getter => ->(user_options:, **) { "#{user_options[:welcome]} #{song_name}" },
+             :setter => ->(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.instance_eval { def name; fail; end }
     _(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.instance_eval { def name=(*); fail; end; self }
+    _(
+      subject.from_hash(
+        {"name" => "Eyes Without A Face"},
+        user_options: {welcome: "Hello"}
+      ).song_name
+    ).must_equal "Hello Eyes Without A Face"
   end
 end

data/test/hash_bindings_test.rb

@@ -1,6 +1,6 @@
-require 'test_helper'
+require "test_helper"
 
-class HashBindingTest < MiniTest::Spec
+class HashBindingTest < Minitest::Spec
   module SongRepresenter
     include Representable::JSON
     property :name
@@ -11,7 +11,6 @@ class HashBindingTest < MiniTest::Spec
     include SongRepresenter
   end
 
-
   describe "PropertyBinding" do
     describe "#read" do
       before do
@@ -19,7 +18,8 @@ class HashBindingTest < MiniTest::Spec
       end
 
       it "returns fragment if present" do
-        assert_equal "Stick The Flag Up Your Goddamn Ass, You Sonofabitch", @property.read({"song" => "Stick The Flag Up Your Goddamn Ass, You Sonofabitch"}, "song")
+        assert_equal "Stick The Flag Up Your Goddamn Ass, You Sonofabitch",
+                     @property.read({"song" => "Stick The Flag Up Your Goddamn Ass, You Sonofabitch"}, "song")
         assert_equal "", @property.read({"song" => ""}, "song")
         assert_nil @property.read({"song" => nil}, "song")
       end
@@ -28,10 +28,12 @@ class HashBindingTest < MiniTest::Spec
         assert_equal Representable::Binding::FragmentNotFound, @property.read({}, "song")
       end
 
+      it "will not fail if given an empty hash value and will return FRAGMENT_NOT_FOUND" do
+        assert_equal Representable::Binding::FragmentNotFound, @property.read(nil, "song")
+      end
     end
   end
 
-
   describe "CollectionBinding" do
     describe "with plain text items" do
       before do
@@ -50,9 +52,6 @@ class HashBindingTest < MiniTest::Spec
     end
   end
 
-
-
-
   describe "HashBinding" do
     describe "with plain text items" do
       before do
@@ -60,19 +59,30 @@ class HashBindingTest < MiniTest::Spec
       end
 
       it "extracts with #read" do
-        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"} , @property.read({"songs" => {"first" => "The Gargoyle", "second" => "Bronx"}}, "songs"))
+        assert_equal(
+          {"first" => "The Gargoyle", "second" => "Bronx"},
+          @property.read({"songs" => {"first" => "The Gargoyle", "second" => "Bronx"}}, "songs")
+        )
       end
 
       it "inserts with #write" do
         doc = {}
-        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"}, @property.write(doc, {"first" => "The Gargoyle", "second" => "Bronx"}, "songs"))
+        assert_equal(
+          {"first" => "The Gargoyle", "second" => "Bronx"},
+          @property.write(doc, {"first" => "The Gargoyle", "second" => "Bronx"}, "songs")
+        )
         assert_equal({"songs"=>{"first" => "The Gargoyle", "second" => "Bronx"}}, doc)
       end
     end
 
     describe "with objects" do
       before do
-        @property = Representable::Hash::Binding.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter))
+        @property = Representable::Hash::Binding.new(
+          Representable::Definition.new(
+            :songs, :hash => true, :class => Song,
+          :extend => SongRepresenter
+          )
+        )
       end
 
       it "doesn't change the represented hash in #write" do
@@ -82,6 +92,5 @@ class HashBindingTest < MiniTest::Spec
         assert_equal({"first" => song}, hash)
       end
     end
-
   end
 end

data/test/hash_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class HashPublicMethodsTest < Minitest::Spec
   #---
@@ -9,7 +9,7 @@ class HashPublicMethodsTest < Minitest::Spec
     property :name
   end
 
-  let(:data) { {"id"=>1,"name"=>"Rancid"} }
+  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"] }
@@ -22,7 +22,7 @@ class HashPublicMethodsTest < Minitest::Spec
   it { _(BandRepresenter.new(band).render).must_equal data }
 end
 
-class HashWithScalarPropertyTest < MiniTest::Spec
+class HashWithScalarPropertyTest < Minitest::Spec
   Album = Struct.new(:title)
 
   representer! do
@@ -37,7 +37,6 @@ class HashWithScalarPropertyTest < MiniTest::Spec
     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"
@@ -52,8 +51,7 @@ class HashWithScalarPropertyTest < MiniTest::Spec
   end
 end
 
-
-class HashWithTypedPropertyTest < MiniTest::Spec
+class HashWithTypedPropertyTest < Minitest::Spec
   Album = Struct.new(:best_song)
 
   representer! do
@@ -85,7 +83,7 @@ class HashWithTypedPropertyTest < MiniTest::Spec
 
     # nested blank hash creates blank object when not populated.
     it do
-      album = Album.new#(Song.new("Pre-medicated Murder"))
+      album = Album.new # (Song.new("Pre-medicated Murder"))
       album.extend(representer).from_hash("best_song" => {})
       _(album.best_song.name).must_be_nil
     end
@@ -100,7 +98,7 @@ class HashWithTypedPropertyTest < MiniTest::Spec
 end
 
 # TODO: move to AsTest.
-class HashWithTypedPropertyAndAs < MiniTest::Spec
+class HashWithTypedPropertyAndAs < Minitest::Spec
   representer! do
     property :song, :class => Song, :as => :hit do
       property :name
@@ -112,29 +110,27 @@ class HashWithTypedPropertyAndAs < MiniTest::Spec
   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
-  #   #     include Representable::XML
-  #   #     self.representation_wrap = :song
-  #   #     property :name
-  #   #   end
-
-  #   #   let(:hash_album) { Module.new do
-  #   #     include Representable::XML
-  #   #     self.representation_wrap = :album
-  #   #     property :song, :extend => hash_song, :class => Song, :as => :hit
-  #   #   end }
-
-  #   #   let(:album) { OpenStruct.new(:song => Song.new("Liar")).extend(hash_album) }
-
-  #   #   it { album.to_xml.must_equal_xml("<album><hit><name>Liar</name></hit></album>") }
-  #   #   #it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
-  #   # end
-  # end
-
-
-
-class HashWithTypedCollectionTest < MiniTest::Spec
+#   # describe "FIXME COMBINE WITH ABOVE with :extend and :as" do
+#   #   hash_song = Module.new do
+#   #     include Representable::XML
+#   #     self.representation_wrap = :song
+#   #     property :name
+#   #   end
+
+#   #   let(:hash_album) { Module.new do
+#   #     include Representable::XML
+#   #     self.representation_wrap = :album
+#   #     property :song, :extend => hash_song, :class => Song, :as => :hit
+#   #   end }
+
+#   #   let(:album) { OpenStruct.new(:song => Song.new("Liar")).extend(hash_album) }
+
+#   #   it { album.to_xml.must_equal_xml("<album><hit><name>Liar</name></hit></album>") }
+#   #   #it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
+#   # end
+# end
+
+class HashWithTypedCollectionTest < Minitest::Spec
   Album = Struct.new(:songs)
 
   representer! do
@@ -148,35 +144,54 @@ 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
 
-class HashWithScalarCollectionTest < MiniTest::Spec
+class HashWithScalarCollectionTest < Minitest::Spec
   Album = Struct.new(:songs)
   representer! { collection :songs }
 
   let(:album) { Album.new(["Jackhammer", "Terrible Man"]) }
 
-
   describe "#to_hash" do
     it "renders a block style list per default" do
       _(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

@@ -26,7 +26,6 @@ class HeritageTest < Minitest::Spec
     feature Ciao # does NOT extend id, of course.
 
     property :id, inherit: true do
-
     end
   end
 

data/test/if_test.rb

@@ -1,35 +1,38 @@
-require 'test_helper'
+require "test_helper"
 
-class IfTest < MiniTest::Spec
-  let(:band_class) { Class.new do
-    include Representable::Hash
-    attr_accessor :fame
-    self
-  end }
+class IfTest < Minitest::Spec
+  let(:band_class) do
+    Class.new do
+      include Representable::Hash
+      attr_accessor :fame
+
+      self
+    end
+  end
 
   it "respects property when condition true" do
-    band_class.class_eval { property :fame, :if => lambda { |*| true } }
+    band_class.class_eval { property :fame, :if => ->(*) { true } }
     band = band_class.new
     band.from_hash({"fame"=>"oh yes"})
     assert_equal "oh yes", band.fame
   end
 
   it "ignores property when condition false" do
-    band_class.class_eval { property :fame, :if => lambda { |*| false } }
+    band_class.class_eval { property :fame, :if => ->(*) { false } }
     band = band_class.new
     band.from_hash({"fame"=>"oh yes"})
     assert_nil band.fame
   end
 
   it "ignores property when :exclude'ed even when condition is true" do
-    band_class.class_eval { property :fame, :if => lambda { |*| true } }
+    band_class.class_eval { property :fame, :if => ->(*) { true } }
     band = band_class.new
     band.from_hash({"fame"=>"oh yes"}, {:exclude => [:fame]})
     assert_nil band.fame
   end
 
   it "executes block in instance context" do
-    band_class.class_eval { property :fame, :if => lambda { |*| groupies }; attr_accessor :groupies }
+    band_class.class_eval { property :fame, :if => ->(*) { groupies }; attr_accessor :groupies }
     band = band_class.new
     band.groupies = true
     band.from_hash({"fame"=>"oh yes"})
@@ -38,7 +41,7 @@ class IfTest < MiniTest::Spec
 
   describe "executing :if lambda in represented instance context" do
     representer! do
-      property :label, :if => lambda { |*| signed_contract }
+      property :label, :if => ->(*) { signed_contract }
     end
 
     subject { OpenStruct.new(:signed_contract => false, :label => "Fat") }
@@ -48,23 +51,24 @@ class IfTest < MiniTest::Spec
     end
 
     it "represents when true" do
-      subject.signed_contract= true
+      subject.signed_contract = true
       _(subject.extend(representer).to_hash).must_equal({"label"=>"Fat"})
     end
 
     it "works with decorator" do
       rpr = representer
-      _(Class.new(Representable::Decorator) do
-        include Representable::Hash
-        include rpr
-      end.new(subject).to_hash).must_equal({})
+      _(
+        Class.new(Representable::Decorator) {
+          include Representable::Hash
+          include rpr
+        }.new(subject).to_hash
+      ).must_equal({})
     end
   end
 
-
   describe "propagating user options to the block" do
     representer! do
-      property :name, :if => lambda { |opts| opts[:user_options][:include_name] }
+      property :name, :if => ->(opts) { opts[:user_options][:include_name] }
     end
     subject { OpenStruct.new(:name => "Outbound").extend(representer) }
 
@@ -73,7 +77,7 @@ class IfTest < MiniTest::Spec
     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
+end

data/test/include_exclude_test.rb

@@ -17,30 +17,34 @@ class IncludeExcludeTest < Minitest::Spec
     end
   end
 
-  let(:song) { Song.new("Listless", Artist.new("7yearsbadluck", 1  )) }
+  let(:song) { Song.new("Listless", Artist.new("7yearsbadluck", 1)) }
   let(:decorator) { representer.new(song) }
 
   describe "#from_hash" do
     it "accepts :exclude option" do
-      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, exclude: [:title])
+      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)
     end
 
     it "accepts :include option" do
-      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, include: [:title])
+      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)
     end
 
     it "accepts nested :exclude/:include option" do
-      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"name"=>"Foo", "id"=>2, "songs"=>[{"id"=>1, "title"=>"Listless"}]}},
+      decorator.from_hash(
+        {
+          "title"  => "Don't Smile In Trouble",
+          "artist" => {"name" => "Foo", "id" => 2, "songs" => [{"id" => 1, "title" => "Listless"}]}
+        },
         exclude: [:title],
-        artist: {
+        artist:  {
           exclude: [:id],
-          songs: { include: [:title] }
+          songs:   {include: [:title]}
         }
       )
 
@@ -51,7 +55,7 @@ class IncludeExcludeTest < Minitest::Spec
 
   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
@@ -61,13 +65,15 @@ class IncludeExcludeTest < Minitest::Spec
     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(
-        exclude: [:title],
-        artist: {
-          exclude: [:id],
-          songs: { include: [:title] }
-        }
-      )).must_equal({"artist"=>{"name"=>"7yearsbadluck", "songs"=>[{"title"=>"C.O.A.B.I.E.T.L."}]}})
+      _(
+        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."}]}})
     end
   end
 
@@ -82,7 +88,9 @@ 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