representable 3.0.0 → 3.1.0

data/test/{example.rb → examples/example.rb}

@@ -17,7 +17,6 @@ end
 
 song = Song.new(:title => "Fallout", :track => 1)
 
-require 'representable/json'
 module SongRepresenter
   include Representable::JSON
 

data/test/examples/object.rb

@@ -7,8 +7,6 @@ require "pp"
 source = OpenStruct.new(name: "30 Years Live", songs: [
   OpenStruct.new(id: 1, title: "Dear Beloved"), OpenStruct.new(id: 2, title: "Fuck Armageddon")])
 
-pp source
-
 require "representable/object"
 
 class AlbumRepresenter < Representable::Decorator
@@ -26,6 +24,4 @@ Song = Struct.new(:title)
 
 target = Album.new
 
-AlbumRepresenter.new(target).from_object(source)
-
-pp target
+AlbumRepresenter.new(target).from_object(source)

data/test/exec_context_test.rb

@@ -7,8 +7,8 @@ class ExecContextTest < MiniTest::Spec
     # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
   ) do |format, mod, input, output|
 
-    let (:song) { representer.prepare(Song.new("Timing")) }
-    let (:format) { format }
+    let(:song) { representer.prepare(Song.new("Timing")) }
+    let(:format) { format }
 
 
     describe "exec_context: nil" do
@@ -17,7 +17,7 @@ class ExecContextTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document output }
-      it { parse(song, input).name.must_equal "Rebel Fate" }
+      it { _(parse(song, input).name).must_equal "Rebel Fate" }
     end
 
 
@@ -27,7 +27,7 @@ class ExecContextTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document output }
-      it { parse(song, input).name.must_equal "Rebel Fate" }
+      it { _(parse(song, input).name).must_equal "Rebel Fate" }
     end
 
 
@@ -41,7 +41,7 @@ class ExecContextTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
-      it { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+      it { _(parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name).must_equal "Rebel Fate" }
     end
 
 
@@ -53,7 +53,7 @@ class ExecContextTest < MiniTest::Spec
         end
 
         it { render(song).must_equal_document output }
-        it { parse(song, input).name.must_equal "Rebel Fate" }
+        it { _(parse(song, input).name).must_equal "Rebel Fate" }
       end
 
 
@@ -71,7 +71,7 @@ class ExecContextTest < MiniTest::Spec
         end
 
         it { render(song).must_equal_document({Representable::Decorator=>"Timebomb"}) }
-        it { parse(song, {Representable::Decorator=>"Listless"}).name.must_equal "Listless" }
+        it { _(parse(song, {Representable::Decorator=>"Listless"}).name).must_equal "Listless" }
       end
 
 
@@ -86,7 +86,7 @@ class ExecContextTest < MiniTest::Spec
         end
 
         it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
-        it("xxx") { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+        it("xxx") { _(parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name).must_equal "Rebel Fate" }
       end
     end
   end

data/test/features_test.rb

@@ -20,23 +20,23 @@ class FeaturesTest < MiniTest::Spec
     end
   }
 
-  let (:song) { OpenStruct.new(:details => Object.new) }
+  let(:song) { OpenStruct.new(:details => Object.new) }
 
   describe "Module" do
     representer! do
-      instance_exec &definition
+      instance_exec(&definition)
     end
 
-    it { song.extend(representer).to_hash.must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
+    it { _(song.extend(representer).to_hash).must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
   end
 
 
   describe "Decorator" do
     representer!(:decorator => true) do
-      instance_exec &definition
+      instance_exec(&definition)
     end
 
-    it { representer.new(song).to_hash.must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
+    it { _(representer.new(song).to_hash).must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
   end
 end
 
@@ -65,6 +65,6 @@ class FeatureInclusionOrderTest < MiniTest::Spec
   end
 
   it do
-    representer.new(OpenStruct.new(song: Object)).to_hash.must_equal({"title"=>"I am number two, I was first!", "song"=>{"title"=>"I am number two, I was first!"}})
+    _(representer.new(OpenStruct.new(song: Object)).to_hash).must_equal({"title"=>"I am number two, I was first!", "song"=>{"title"=>"I am number two, I was first!"}})
   end
 end

data/test/filter_test.rb

@@ -1,12 +1,12 @@
 require 'test_helper'
 
 class FilterPipelineTest < MiniTest::Spec
-  let (:block1) { lambda { |input, options| "1: #{input}" } }
-  let (:block2) { lambda { |input, options| "2: #{input}" } }
+  let(:block1) { lambda { |input, options| "1: #{input}" } }
+  let(:block2) { lambda { |input, options| "2: #{input}" } }
 
   subject { Representable::Pipeline[block1, block2] }
 
-  it { subject.call("Horowitz", {}).must_equal "2: 1: Horowitz" }
+  it { _(subject.call("Horowitz", {})).must_equal "2: 1: Horowitz" }
 end
 
 
@@ -22,11 +22,11 @@ class FilterTest < MiniTest::Spec
   # gets doc and options.
   it {
     song = OpenStruct.new.extend(representer).from_hash("title" => "VULCAN EARS", "track" => "Nine")
-    song.title.must_equal "VULCAN EARS"
-    song.track.must_equal "nine,{\"title\"=>\"VULCAN EARS\", \"track\"=>\"Nine\"}"
+    _(song.title).must_equal "VULCAN EARS"
+    _(song.track).must_equal "nine,{\"title\"=>\"VULCAN EARS\", \"track\"=>\"Nine\"}"
   }
 
-  it { OpenStruct.new("title" => "vulcan ears", "track" => "Nine").extend(representer).to_hash.must_equal( {"title"=>"vulcan ears", "track"=>"NINE,{\"title\"=>\"vulcan ears\"},{}"}) }
+  it { _(OpenStruct.new("title" => "vulcan ears", "track" => "Nine").extend(representer).to_hash).must_equal( {"title"=>"vulcan ears", "track"=>"NINE,{\"title\"=>\"vulcan ears\"},{}"}) }
 
 
   describe "#parse_filter" do
@@ -41,8 +41,8 @@ class FilterTest < MiniTest::Spec
     end
 
     # order matters.
-    it { OpenStruct.new.extend(representer).from_hash("track" => "Nine").track.must_equal "Nine-1-2" }
-    it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
+    it { _(OpenStruct.new.extend(representer).from_hash("track" => "Nine").track).must_equal "Nine-1-2" }
+    it { _(OpenStruct.new("track" => "Nine").extend(representer).to_hash).must_equal({"track"=>"Nine-1-2"}) }
   end
 end
 

data/test/for_collection_test.rb

@@ -7,8 +7,8 @@ class ForCollectionTest < MiniTest::Spec
     property :name
   end
 
-  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\"}]" }
+  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
@@ -20,9 +20,9 @@ class ForCollectionTest < MiniTest::Spec
   ) do |format, mod, output, input|
 
     describe "Module::for_collection [#{format}]" do
-      let (:format) { format }
+      let(:format) { format }
 
-      let (:representer) {
+      let(:representer) {
         Module.new do
           include mod
           property :name#, :as => :title
@@ -36,13 +36,13 @@ class ForCollectionTest < MiniTest::Spec
       it { render(songs.extend(representer.for_collection)).must_equal_document output }
       it { render(representer.for_collection.prepare(songs)).must_equal_document output }
       # parsing needs the class set, at least
-      it { parse([].extend(representer.for_collection), input).must_equal songs }
+      it { _(parse([].extend(representer.for_collection), input)).must_equal songs }
     end
 
     describe "Module::for_collection without configuration [#{format}]" do
-      let (:format) { format }
+      let(:format) { format }
 
-      let (:representer) {
+      let(:representer) {
         Module.new do
           include mod
           property :name
@@ -55,8 +55,8 @@ class ForCollectionTest < MiniTest::Spec
 
 
     describe "Decorator::for_collection [#{format}]" do
-      let (:format) { format }
-      let (:representer) {
+      let(:format) { format }
+      let(:representer) {
         Class.new(Representable::Decorator) do
           include mod
           property :name
@@ -66,7 +66,7 @@ class ForCollectionTest < MiniTest::Spec
       }
 
       it { render(representer.for_collection.new(songs)).must_equal_document output }
-      it { parse(representer.for_collection.new([]), input).must_equal songs }
+      it { _(parse(representer.for_collection.new([]), input)).must_equal songs }
     end
   end
 

data/test/generic_test.rb

@@ -1,10 +1,10 @@
 require 'test_helper'
 
 class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
-  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(: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  }
 
 
   describe "::collection" do
@@ -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_equal 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
 
 
@@ -32,14 +32,14 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
     ) do |format, mod, output, input|
 
       describe "nil collections" do
-        let (:format) { format }
+        let(:format) { format }
 
         representer!(:module => mod) do
           collection :songs
           self.representation_wrap = :album if format == :xml
         end
 
-        let (:album) { Album.new.extend(representer) }
+        let(:album) { Album.new.extend(representer) }
 
         it "doesn't render collection in #{format}" do
           render(album).must_equal_document output
@@ -55,14 +55,14 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
     ) do |format, mod, output, input|
 
       describe "empty collections" do
-        let (:format) { format }
+        let(:format) { format }
 
         representer!(:module => mod) do
           collection :songs
           self.representation_wrap = :album if format == :xml
         end
 
-        let (:album) { OpenStruct.new(:songs => []).extend(representer) }
+        let(:album) { OpenStruct.new(:songs => []).extend(representer) }
 
         it "renders empty collection in #{format}" do
           render(album).must_equal_document output
@@ -79,14 +79,14 @@ class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
     ) do |format, mod, output, input|
 
       describe "render_empty [#{format}]" do
-        let (:format) { format }
+        let(:format) { format }
 
         representer!(:module => mod) do
           collection :songs, :render_empty => false
           self.representation_wrap = :album if format == :xml
         end
 
-        let (:album) { OpenStruct.new(:songs => []).extend(representer) }
+        let(:album) { OpenStruct.new(:songs => []).extend(representer) }
 
         it { render(album).must_equal_document output }
       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_bindings_test.rb

@@ -21,7 +21,7 @@ class HashBindingTest < MiniTest::Spec
       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 "", @property.read({"song" => ""}, "song")
-        assert_equal nil, @property.read({"song" => nil}, "song")
+        assert_nil @property.read({"song" => nil}, "song")
       end
 
       it "returns FRAGMENT_NOT_FOUND if not in document" do

data/test/hash_test.rb

@@ -1,5 +1,27 @@
 require 'test_helper'
 
+class HashPublicMethodsTest < Minitest::Spec
+  #---
+  # from_hash
+  class BandRepresenter < Representable::Decorator
+    include Representable::Hash
+    property :id
+    property :name
+  end
+
+  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"] }
+
+  #---
+  # 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 }
+end
+
 class HashWithScalarPropertyTest < MiniTest::Spec
   Album = Struct.new(:title)
 
@@ -7,24 +29,24 @@ class HashWithScalarPropertyTest < MiniTest::Spec
     property :title
   end
 
-  let (:album) { Album.new("Liar") }
+  let(:album) { Album.new("Liar") }
 
   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_equal nil
+      _(album.title).must_be_nil
       album.extend(representer).from_hash("title" => nil)
     end
   end
@@ -40,39 +62,39 @@ class HashWithTypedPropertyTest < MiniTest::Spec
     end
   end
 
-  let (:album) { Album.new(Song.new("Liar")) }
+  let(:album) { Album.new(Song.new("Liar")) }
 
   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_equal 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_equal 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_equal nil
+      _(album.best_song).must_be_nil
     end
   end
 end
@@ -85,10 +107,10 @@ class HashWithTypedPropertyAndAs < MiniTest::Spec
     end
   end
 
-  let (:album) { OpenStruct.new(:song => Song.new("Liar")).extend(representer) }
+  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
@@ -97,13 +119,13 @@ end
   #   #     property :name
   #   #   end
 
-  #   #   let (:hash_album) { Module.new do
+  #   #   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) }
+  #   #   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")) }
@@ -122,18 +144,18 @@ class HashWithTypedCollectionTest < MiniTest::Spec
     end
   end
 
-  let (:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
+  let(:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
 
   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
@@ -142,19 +164,19 @@ class HashWithScalarCollectionTest < MiniTest::Spec
   Album = Struct.new(:songs)
   representer! { collection :songs }
 
-  let (:album) { Album.new(["Jackhammer", "Terrible Man"]) }
+  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"])
+      _(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
+end