representable 3.0.0 → 3.1.0

data/test/instance_test.rb

@@ -22,7 +22,7 @@ class InstanceTest < BaseTest
       end
 
       song = OpenStruct.new.extend(representer).from_hash({"title" => object})
-      song.title.must_equal object
+      _(song.title).must_equal object
     end
   end
 
@@ -36,11 +36,11 @@ class InstanceTest < BaseTest
         :extend => song_representer
     end
 
-    it( "xxx") { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash("song" => {"id" => 1}).song.must_equal Song.new(1, "The Answer Is Still No") }
+    it( "xxx") { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash("song" => {"id" => 1}).song).must_equal Song.new(1, "The Answer Is Still No") }
 
-    it { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash("song" => {"id" => 2}).song.must_equal Song.new(2, "Invincible") }
+    it { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash("song" => {"id" => 2}).song).must_equal Song.new(2, "Invincible") }
   end
 
 
@@ -55,13 +55,13 @@ class InstanceTest < BaseTest
     end
 
     it {
-      album= Struct.new(:songs).new(songs = [
+      album= Struct.new(:songs).new([
       Song.new(1, "The Answer Is Still No"),
       Song.new(2, "")])
 
-      album.
+      _(album.
         extend(representer).
-        from_hash("songs" => [{"id" => 2},{"id" => 2, "title"=>"The Answer Is Still No"}]).songs.must_equal [
+        from_hash("songs" => [{"id" => 2},{"id" => 2, "title"=>"The Answer Is Still No"}]).songs).must_equal [
           Song.new(2, "Invincible"), Song.new(2, "The Answer Is Still No")]
     }
   end
@@ -71,8 +71,8 @@ class InstanceTest < BaseTest
       property :song, :instance => lambda { |options| Struct.new(:args, :id).new([options[:fragment], options[:user_options]]) }, :extend => song_representer
     end
 
-    it { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash({"song" => {"id" => 1}}, user_options: { volume: 1 }).song.args.must_equal([{"id"=>1}, {:volume=>1}]) }
+    it { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash({"song" => {"id" => 1}}, user_options: { volume: 1 }).song.args).must_equal([{"id"=>1}, {:volume=>1}]) }
   end
 
   # TODO: raise and test instance:{nil}
@@ -81,7 +81,7 @@ class InstanceTest < BaseTest
   #     property :song, :instance => lambda { |*| nil }, :extend => song_representer
   #   end
 
-  #   let (:hit) { hit = OpenStruct.new(:song => song).extend(representer) }
+  #   let(:hit) { hit = OpenStruct.new(:song => song).extend(representer) }
 
   #   it "calls #to_hash on song instance, nothing else" do
   #     hit.to_hash.must_equal("song"=>{"title"=>"Resist Stance"})
@@ -117,13 +117,13 @@ class InstanceTest < BaseTest
         extend(representer).
         from_hash("songs" => [{"title" => "The Answer Is Still No"}, {"title" => "Invincible"}])
 
-      album.songs.must_equal [
+      _(album.songs).must_equal [
         Song.new(1, "The Answer Is Still No"),
         Song.new(2, "Invincible")]
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
-      songs[1].object_id.must_equal album.songs[1].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
+      _(songs[1].object_id).must_equal album.songs[1].object_id
     }
   end
 
@@ -146,17 +146,17 @@ class InstanceTest < BaseTest
       Song.new(1, "The Answer Is Still No"),
       Song.new(2, "Invncble")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"id" => 2, "title" => "Invincible"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(1, "The Answer Is Still No"),
           Song.new(2, "Invincible")]
           # TODO: check elements object_id!
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
-      songs[1].object_id.must_equal album.songs[1].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
+      _(songs[1].object_id).must_equal album.songs[1].object_id
     }
   end
 
@@ -178,15 +178,15 @@ class InstanceTest < BaseTest
       album= Struct.new(:songs).new(songs = [
         Song.new(1, "The Answer Is Still No")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"title" => "Invincible"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(1, "The Answer Is Still No"),
           Song.new(2, "Invincible")]
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
     }
   end
 
@@ -212,15 +212,15 @@ class InstanceTest < BaseTest
         Song.new(1, "The Answer Is Still No"),
         Song.new(2, "Invincible")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"replace_id"=>2, "id" => 3, "title" => "Soulmate"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(1, "The Answer Is Still No"),
           Song.new(3, "Soulmate")]
 
-      songs.object_id.must_equal album.songs.object_id
-      songs[0].object_id.must_equal album.songs[0].object_id
+      _(songs.object_id).must_equal album.songs.object_id
+      _(songs[0].object_id).must_equal album.songs[0].object_id
     }
   end
 
@@ -235,13 +235,13 @@ class InstanceTest < BaseTest
       album= Struct.new(:songs).new(songs = [
         Song.new(1, "The Answer Is Still No")])
 
-      album.
+      _(album.
         extend(representer).
         from_hash("songs" => [{"title" => "Invincible"}]).
-        songs.must_equal [
+        songs).must_equal [
           Song.new(nil, "Invincible")]
 
-      songs.object_id.wont_equal album.songs.object_id
+      _(songs.object_id).wont_equal album.songs.object_id
     }
   end
 end

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

@@ -1,10 +1,34 @@
 require 'test_helper'
+require 'json'
 
 module JsonTest
+class JSONPublicMethodsTest < Minitest::Spec
+  #---
+  # from_json
+  class BandRepresenter < Representable::Decorator
+    include Representable::JSON
+    property :id
+    property :name
+  end
+
+  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"] }
+
+  #---
+  # 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 }
+end
+
   class APITest < MiniTest::Spec
     Json = Representable::JSON
     Def = Representable::Definition
 
+
     describe "JSON module" do
       before do
         @Band = Class.new do
@@ -229,9 +253,7 @@ module JsonTest
         assert_json '{"songName":"22 Acacia Avenue"}', song.to_json
       end
     end
-
-end
-
+  end
 
   class CollectionTest < MiniTest::Spec
     describe "collection :name" do
@@ -334,20 +356,20 @@ 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
         subject { OpenStruct.new.extend(representer) }
-        let (:hsh) { {"7"=>{"name"=>"Contemplation"}} }
+        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

@@ -12,7 +12,7 @@ class LonelyRepresenterTest < MiniTest::Spec
   ) do |format, mod, output, input|
 
     describe "[#{format}] lonely collection, render-only" do # TODO: introduce :representable option?
-      let (:format) { format }
+      let(:format) { format }
 
       representer!(module: mod) do
         items do
@@ -20,7 +20,7 @@ class LonelyRepresenterTest < MiniTest::Spec
         end
       end
 
-      let (:album) { [Song.new("Resist Stance"), Song.new("Suffer")].extend(representer) }
+      let(:album) { [Song.new("Resist Stance"), Song.new("Suffer")].extend(representer) }
 
       it "calls #to_hash on song instances, nothing else" do
         render(album).must_equal_document(output)
@@ -36,14 +36,14 @@ class LonelyRepresenterTest < MiniTest::Spec
     property :name
   end
 
-  let (:decorator) { rpr = representer; Class.new(Representable::Decorator) { include Representable::Hash; include rpr } }
+  let(:decorator) { rpr = representer; Class.new(Representable::Decorator) { include Representable::Hash; include rpr } }
 
   describe "JSON::Collection" do
-    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\"}]" }
 
     describe "with contained objects" do
-      let (:representer) {
+      let(:representer) {
         Module.new do
           include Representable::JSON::Collection
           items :class => Song, :extend => SongRepresenter
@@ -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,25 +75,25 @@ 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
-      let (:representer) {
+      let(:representer) {
         Module.new do
           include Representable::JSON::Collection
         end
       }
-      let (:songs) { ["Days Go By", "Can't Take Them All"] }
-      let (:json)  { "[\"Days Go By\",\"Can't Take Them All\"]" }
+      let(:songs) { ["Days Go By", "Can't Take Them All"] }
+      let(:json)  { "[\"Days Go By\",\"Can't Take Them All\"]" }
 
       it "renders contained items #to_json" do
         assert_json json, songs.extend(representer).to_json
       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,28 +112,28 @@ 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
 
 
   describe "JSON::Hash" do  # TODO: move to HashTest.
     describe "with contained objects" do
-      let (:representer) {
+      let(:representer) {
         Module.new do
           include Representable::JSON::Hash
           values :class => Song, :extend => SongRepresenter
         end
       }
-      let (:json)  { "{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}" }
-      let (:songs) { {"one" => Song.new("Days Go By"), "two" => Song.new("Can't Take Them All")} }
+      let(:json)  { "{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}" }
+      let(:songs) { {"one" => Song.new("Days Go By"), "two" => Song.new("Can't Take Them All")} }
 
       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,23 +171,23 @@ 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
 
 
     describe "with scalar" do
-      let (:representer) {
+      let(:representer) {
         Module.new do
           include Representable::JSON::Hash
         end
       }
-      let (:json)  { %{{"one":1,"two":2}} }
-      let (:data) { {one: 2, two: 3} }
+      let(:json)  { %{{"one":1,"two":2}} }
+      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

@@ -11,7 +11,7 @@ class NestedTest < MiniTest::Spec
 
     [false, true].each do |is_decorator|
       describe "::nested with (inline representer|decorator): #{is_decorator}" do
-        let (:format) { format }
+        let(:format) { format }
 
         representer!(:module => mod, :decorator => is_decorator) do
           nested :label do
@@ -27,29 +27,29 @@ class NestedTest < MiniTest::Spec
           # self.representation_wrap = :album if format == :xml
         end
 
-        let (:album) { Album.new("Epitaph", "Brett Gurewitz", 19) }
-        let (:decorator) { representer.prepare(album) }
+        let(:album) { Album.new("Epitaph", "Brett Gurewitz", 19) }
+        let(:decorator) { representer.prepare(album) }
 
         it "renders nested Album-properties in separate section" do
           render(decorator).must_equal_document output
 
           # 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
 
 
     describe "Decorator ::nested with extend:" do
-      let (:format) { format }
+      let(:format) { format }
 
       representer!(:name => :label_rpr) do
       	include mod
@@ -67,7 +67,7 @@ class NestedTest < MiniTest::Spec
         self.representation_wrap = :album if format == :xml
       end
 
-      let (:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
+      let(:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
 
       # TODO: shared example with above.
       it "renders nested Album-properties in separate section" do
@@ -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
@@ -99,10 +99,10 @@ class NestedTest < MiniTest::Spec
       nested :label, :inherit => true, :as => "Label"
     end
 
-    let (:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
+    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