representable 3.0.0 → 3.1.0

data/test/heritage_test.rb

@@ -3,16 +3,16 @@ require "test_helper"
 class HeritageTest < Minitest::Spec
   module Hello
     def hello
-      puts "Hello!"
+      "Hello!"
     end
   end
-    module Ciao
+
+  module Ciao
     def ciao
-      puts "Ciao!"
+      "Ciao!"
     end
   end
 
-
   class A < Representable::Decorator
     include Representable::Hash
 
@@ -34,15 +34,16 @@ class HeritageTest < Minitest::Spec
     property :id do end # overwrite old :id.
   end
 
-  it do
-    # puts A.heritage.inspect
-    # puts B.heritage.inspect
+  it "B must inherit Hello! feature from A" do
+    _(B.representable_attrs.get(:id)[:extend].(nil).new(nil).hello).must_equal "Hello!"
+  end
 
-    puts B.representable_attrs.get(:id)[:extend].(nil).new(nil).hello
-    puts B.representable_attrs.get(:id)[:extend].(nil).new(nil).ciao
+  it "B must have Ciao from module (feauture) Ciao" do
+    _(B.representable_attrs.get(:id)[:extend].(nil).new(nil).ciao).must_equal "Ciao!"
+  end
 
-    # feature Hello must be "inherited" from A and included in new C properties, too.
-    puts C.representable_attrs.get(:id)[:extend].(nil).new(nil).hello
+  it "C must inherit Hello! feature from A" do
+    _(C.representable_attrs.get(:id)[:extend].(nil).new(nil).hello).must_equal "Hello!"
   end
 
   module M
@@ -56,7 +57,9 @@ class HeritageTest < Minitest::Spec
     feature Ciao
   end
 
-  it do
-    Object.new.extend(N).hello
+  let(:obj_extending_N) { Object.new.extend(N) }
+
+  it "obj should inherit from N, and N from M" do
+    _(obj_extending_N.hello).must_equal "Hello!"
   end
 end

data/test/if_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class IfTest < MiniTest::Spec
-  let (:band_class) { Class.new do
+  let(:band_class) { Class.new do
     include Representable::Hash
     attr_accessor :fame
     self
@@ -18,14 +18,14 @@ class IfTest < MiniTest::Spec
     band_class.class_eval { property :fame, :if => lambda { |*| false } }
     band = band_class.new
     band.from_hash({"fame"=>"oh yes"})
-    assert_equal nil, band.fame
+    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 = band_class.new
     band.from_hash({"fame"=>"oh yes"}, {:exclude => [:fame]})
-    assert_equal nil, band.fame
+    assert_nil band.fame
   end
 
   it "executes block in instance context" do
@@ -44,20 +44,20 @@ class IfTest < MiniTest::Spec
     subject { OpenStruct.new(:signed_contract => false, :label => "Fat") }
 
     it "skips when false" do
-      subject.extend(representer).to_hash.must_equal({})
+      _(subject.extend(representer).to_hash).must_equal({})
     end
 
     it "represents when true" do
       subject.signed_contract= true
-      subject.extend(representer).to_hash.must_equal({"label"=>"Fat"})
+      _(subject.extend(representer).to_hash).must_equal({"label"=>"Fat"})
     end
 
     it "works with decorator" do
       rpr = representer
-      Class.new(Representable::Decorator) do
+      _(Class.new(Representable::Decorator) do
         include Representable::Hash
         include rpr
-      end.new(subject).to_hash.must_equal({})
+      end.new(subject).to_hash).must_equal({})
     end
   end
 
@@ -69,11 +69,11 @@ class IfTest < MiniTest::Spec
     subject { OpenStruct.new(:name => "Outbound").extend(representer) }
 
     it "works without specifying options" do
-      subject.to_hash.must_equal({})
+      _(subject.to_hash).must_equal({})
     end
 
     it "passes user options to block" do
-      subject.to_hash(user_options: { include_name: true }).must_equal({"name" => "Outbound"})
+      _(subject.to_hash(user_options: { include_name: true })).must_equal({"name" => "Outbound"})
     end
   end
 end

data/test/include_exclude_test.rb

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

data/test/inherit_test.rb

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

data/test/inline_test.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
 
 class InlineTest < MiniTest::Spec
-  let (:song)    { Song.new("Alive") }
-  let (:request) { representer.prepare(OpenStruct.new(:song => song)) }
+  let(:song)    { Song.new("Alive") }
+  let(:request) { representer.prepare(OpenStruct.new(:song => song)) }
 
   {
     :hash => [Representable::Hash, {"song"=>{"name"=>"Alive"}}, {"song"=>{"name"=>"You've Taken Everything"}}],
@@ -19,10 +19,10 @@ class InlineTest < MiniTest::Spec
         end
       end
 
-      let (:format) { format }
+      let(:format) { format }
 
       it { render(request).must_equal_document output }
-      it { parse(request, input).song.name.must_equal "You've Taken Everything"}
+      it { _(parse(request, input).song.name).must_equal "You've Taken Everything"}
     end
   end
 
@@ -36,7 +36,7 @@ class InlineTest < MiniTest::Spec
     collection_options ||= {}
 
     describe "[#{format}] collection with :class" do
-      let (:request) { representer.prepare(OpenStruct.new(:songs => [song])) }
+      let(:request) { representer.prepare(OpenStruct.new(:songs => [song])) }
 
       representer!(:module => mod) do
         collection :songs, collection_options.merge(:class => Song) do
@@ -44,10 +44,10 @@ class InlineTest < MiniTest::Spec
         end
       end
 
-      let (:format) { format } # FIXME: why do we have to define this?
+      let(:format) { format } # FIXME: why do we have to define this?
 
       it { render(request).must_equal_document output }
-      it { parse(request, input).songs.first.name.must_equal "You've Taken Everything"}
+      it { _(parse(request, input).songs.first.name).must_equal "You've Taken Everything"}
     end
   end
 
@@ -58,7 +58,7 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it { request.to_hash.must_equal({"song"=>{"name"=>"Alive"}}) }
+    it { _(request.to_hash).must_equal({"song"=>{"name"=>"Alive"}}) }
   end
 
 
@@ -76,14 +76,14 @@ class InlineTest < MiniTest::Spec
       end
 
       it "doesn't change represented object" do
-        request.send("from_#{format}", input).song.must_equal song
+        _(request.send("from_#{format}", input).song).must_equal song
       end
     end
   end
 
 
   describe "inheriting from outer representer" do
-    let (:request) { Struct.new(:song, :requester).new(song, "Josephine") }
+    let(:request) { Struct.new(:song, :requester).new(song, "Josephine") }
 
     [false, true].each do |is_decorator| # test for module and decorator.
       representer!(:decorator => is_decorator) do
@@ -94,10 +94,10 @@ class InlineTest < MiniTest::Spec
         end
       end
 
-      let (:decorator) { representer.prepare(request) }
+      let(:decorator) { representer.prepare(request) }
 
-      it { decorator.to_hash.must_equal({"requester"=>"Josephine", "song"=>{"name"=>"Alive"}}) }
-      it { decorator.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name.must_equal "You've Taken Everything"}
+      it { _(decorator.to_hash).must_equal({"requester"=>"Josephine", "song"=>{"name"=>"Alive"}}) }
+      it { _(decorator.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name).must_equal "You've Taken Everything"}
     end
   end
 
@@ -110,7 +110,7 @@ class InlineTest < MiniTest::Spec
 
     it "uses an inline decorator and doesn't alter represented" do
       representer.prepare(Struct.new(:song).new(song)).to_hash
-      song.wont_be_kind_of Representable
+      _(song).wont_be_kind_of Representable
     end
   end
 
@@ -128,7 +128,7 @@ class InlineTest < MiniTest::Spec
   #   end
 
   #   describe ":getter with inline representer" do
-  #     let (:format) { format }
+  #     let(:format) { format }
 
   #     representer!(:module => mod) do
   #       self.representation_wrap = :album
@@ -136,7 +136,7 @@ class InlineTest < MiniTest::Spec
   #       property :artist, :getter => lambda { |args| represented }, :extend => ArtistRepresenter
   #     end
 
-  #     let (:album) { OpenStruct.new(:label => "Epitaph").extend(representer) }
+  #     let(:album) { OpenStruct.new(:label => "Epitaph").extend(representer) }
 
   #     it "renders nested Album-properties in separate section" do
   #       render(album).must_equal_document output
@@ -157,7 +157,7 @@ class InlineTest < MiniTest::Spec
     end
 
     describe ":getter with :decorator" do
-      let (:format) { format }
+      let(:format) { format }
 
       representer!(:module => mod) do
         self.representation_wrap = "album"
@@ -165,7 +165,7 @@ class InlineTest < MiniTest::Spec
         property :artist, :getter => lambda { |args| represented }, :decorator => ArtistDecorator
       end
 
-      let (:album) { OpenStruct.new(:label => "Epitaph").extend(representer) }
+      let(:album) { OpenStruct.new(:label => "Epitaph").extend(representer) }
 
       it "renders nested Album-properties in separate section" do
         render(album).must_equal_document output
@@ -182,7 +182,7 @@ class InlineTest < MiniTest::Spec
   }) do |format, mod, output|
 
     describe "helper method within inline representer [#{format}]" do
-      let (:format) { format }
+      let(:format) { format }
 
       representer!(:module => mod, :decorator => true) do
         self.representation_wrap = :request if format == :xml
@@ -199,7 +199,7 @@ class InlineTest < MiniTest::Spec
         end
       end
 
-      let (:request) { representer.prepare(OpenStruct.new(:song => Song.new("Alive"))) }
+      let(:request) { representer.prepare(OpenStruct.new(:song => Song.new("Alive"))) }
 
       it do
         render(request).must_equal_document output
@@ -221,8 +221,8 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it do OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
-      to_hash.
+    it do _(OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
+      to_hash).
       must_equal({"song"=>{"artist"=>"Strung Out", "title"=>"The Fever And The Sound"}})
     end
   end
@@ -246,7 +246,7 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it { Object.new.extend(Mod).to_hash.must_equal("song"=>{"duration"=>"6:53"}) }
+    it { _(Object.new.extend(Mod).to_hash).must_equal("song"=>{"duration"=>"6:53"}) }
   end
 
   # define method inline with Decorator
@@ -267,6 +267,6 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it { dec.new(Object.new).to_hash.must_equal("song"=>{"duration"=>"6:53"}) }
+    it { _(dec.new(Object.new).to_hash).must_equal("song"=>{"duration"=>"6:53"}) }
   end
 end