representable 1.8.5 → 2.0.0.rc1

data/test/inheritable_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+# tests Inheritable:: classes (the #inherit! method). This can be moved to uber if necessary.
+
+class ConfigInheritableTest < MiniTest::Spec
+  class CloneableObject
+    include Representable::Cloneable
+
+    # same instance returns same clone.
+    def clone
+      @clone ||= super
+    end
+  end
+
+
+  # Inheritable::Array
+  it do
+    parent = Representable::Inheritable::Array.new([1,2,3])
+    child  = Representable::Inheritable::Array.new([4])
+
+    child.inherit!(parent).must_equal([4,1,2,3])
+  end
+
+  # Inheritable::Hash
+  Inheritable = Representable::Inheritable
+  describe "Inheritable::Hash" do
+    it do
+      parent = Inheritable::Hash[
+        :volume => volume = Uber::Options::Value.new(9),
+        :genre  => "Powermetal",
+        :only_parent => only_parent = Representable::Inheritable::Array["Pumpkin Box"],
+        :in_both     => in_both     = Representable::Inheritable::Array["Roxanne"],
+        :hash => {:type => :parent},
+        :clone => parent_clone = CloneableObject.new # cloneable is in both hashes.
+      ]
+      child  = Inheritable::Hash[
+        :genre => "Metal",
+        :pitch => 99,
+        :in_both => Representable::Inheritable::Array["Generator"],
+        :hash => {:type => :child},
+        :clone => child_clone = CloneableObject.new
+      ]
+
+      child.inherit!(parent)
+
+      # order:
+      child.to_a.must_equal [
+        [:genre, "Powermetal"], # parent overrides child
+        [:pitch, 99],           # parent doesn't define pitch
+        [:in_both, ["Generator", "Roxanne"]], # Inheritable array gets "merged".
+        [:hash, {:type => :parent}], # normal hash merge: parent overwrites child value.
+        [:clone, parent_clone.clone],
+        [:volume, volume],
+        [:only_parent, ["Pumpkin Box"]],
+      ]
+
+      # clone
+      child[:only_parent].object_id.wont_equal parent[:only_parent].object_id
+      child[:clone].object_id.wont_equal parent[:clone].object_id
+
+      # still a hash:
+      child.must_equal(
+        :genre => "Powermetal",
+        :pitch => 99,
+        :in_both => ["Generator", "Roxanne"],
+        :hash => {:type => :parent},
+        :clone => parent_clone.clone,
+        :volume => volume,
+        :only_parent => ["Pumpkin Box"]
+      )
+    end
+
+    # nested:
+    it do
+      parent = Inheritable::Hash[
+        :details => Inheritable::Hash[
+          :title  => title  = "Man Of Steel",
+          :length => length = Representable::Definition.new(:length) # Cloneable.
+      ]]
+
+      child  = Inheritable::Hash[].inherit!(parent)
+      child[:details][:track] = 1
+
+      parent.must_equal({:details => {:title => "Man Of Steel", :length => length}})
+
+      child.keys.must_equal [:details]
+      child[:details].keys.must_equal [:title, :length, :track]
+      child[:details][:title].must_equal "Man Of Steel"
+      child[:details][:track].must_equal 1
+      child[:details][:length].name.must_equal "length"
+
+      # clone
+      child[:details][:title].object_id.must_equal  title.object_id
+      child[:details][:length].object_id.wont_equal length.object_id
+    end
+  end
+end

data/test/inline_test.rb

@@ -208,24 +208,6 @@ class InlineTest < MiniTest::Spec
   end
 
 
-  describe "deprecate mixing :extend and inline representers" do # TODO: remove in 2.0.
-    representer! do
-      rpr_module = Module.new do
-        include Representable::Hash
-        property :title
-      end
-      property :song, :extend => rpr_module do
-        property :artist
-      end
-    end
-
-    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
-
-
   describe "include module in inline representers" do
     representer! do
       extension = Module.new do

data/test/instance_test.rb

@@ -247,25 +247,6 @@ class InstanceTest < BaseTest
   end
 
 
-  describe "instance: true" do
-    representer!(:inject => :song_representer) do
-      property :song,
-        :extend => song_representer, :instance => true
-    end
-
-    it "uses Binding#get instead of creating an instance, but deprecates" do
-      album= Struct.new(:song).new(song = Song.new(1, "The Answer Is Still No"))
-
-      album.
-        extend(representer).
-        from_hash("song" => {"title" => "Invincible"}).
-        song.must_equal Song.new(1, "Invincible")
-
-      album.song.object_id.must_equal song.object_id
-    end
-  end
-
-
   describe "new syntax for instance: true" do
     representer!(:inject => :song_representer) do
       property :song, :pass_options => true,

data/test/json_test.rb

@@ -22,41 +22,6 @@ module JsonTest
       end
 
 
-      describe ".from_json" do
-        it "is delegated to #from_json" do
-          block = lambda {|*args|}
-          @Band.any_instance.expects(:from_json).with("{document}", "options") # FIXME: how to NOT expect block?
-          @Band.from_json("{document}", "options", &block)
-        end
-
-        it "yields new object and options to block" do
-          @Band.class_eval { attr_accessor :new_name }
-          @band = @Band.from_json("{}", :new_name => "Diesel Boy") do |band, options|
-            band.new_name= options[:new_name]
-          end
-          assert_equal "Diesel Boy", @band.new_name
-        end
-      end
-
-
-      describe ".from_hash" do
-        it "is delegated to #from_hash not passing the block" do
-          block = lambda {|*args|}
-          @Band.any_instance.expects(:from_hash).with("{document}", "options") # FIXME: how to NOT expect block?
-          @Band.from_hash("{document}", "options", &block)
-        end
-
-        it "yields new object and options to block" do
-          @Band.class_eval { attr_accessor :new_name }
-          @band = @Band.from_hash({}, :new_name => "Diesel Boy") do |band, options|
-            band.new_name= options[:new_name]
-          end
-
-          assert_equal "Diesel Boy", @band.new_name
-        end
-      end
-
-
       describe "#from_json" do
         before do
           @band = @Band.new
@@ -204,7 +169,7 @@ module JsonTest
       end
 
       it "#from_json creates correct accessors" do
-        band = Band.from_json({:name => "Bombshell Rocks"}.to_json)
+        band = Band.new.from_json({:name => "Bombshell Rocks"}.to_json)
         assert_equal "Bombshell Rocks", band.name
       end
 
@@ -230,7 +195,7 @@ module JsonTest
       end
 
       it "#from_json creates one Item instance" do
-        album = Album.from_json('{"label":{"name":"Fat Wreck"}}')
+        album = Album.new.from_json('{"label":{"name":"Fat Wreck"}}')
         assert_equal "Fat Wreck", album.label.name
       end
 
@@ -267,7 +232,7 @@ module JsonTest
       end
 
       it "respects :as in #from_json" do
-        song = Song.from_json({:songName => "Run To The Hills"}.to_json)
+        song = Song.new.from_json({:songName => "Run To The Hills"}.to_json)
         assert_equal "Run To The Hills", song.name
       end
 
@@ -288,17 +253,17 @@ module JsonTest
 
     describe "#from_json" do
       it "uses default when property nil in doc" do
-        album = @Album.from_json({}.to_json)
+        album = @Album.new.from_json({}.to_json)
         assert_equal "30 Years Live", album.name
       end
 
       it "uses value from doc when present" do
-        album = @Album.from_json({:name => "Live At The Wireless"}.to_json)
+        album = @Album.new.from_json({:name => "Live At The Wireless"}.to_json)
         assert_equal "Live At The Wireless", album.name
       end
 
       it "uses value from doc when empty string" do
-        album = @Album.from_json({:name => ""}.to_json)
+        album = @Album.new.from_json({:name => ""}.to_json)
         assert_equal "", album.name
       end
     end
@@ -333,7 +298,7 @@ end
       end
 
       it "#from_json creates correct accessors" do
-        cd = CD.from_json({:songs => ["Out in the cold", "Microphone"]}.to_json)
+        cd = CD.new.from_json({:songs => ["Out in the cold", "Microphone"]}.to_json)
         assert_equal ["Out in the cold", "Microphone"], cd.songs
       end
 
@@ -364,7 +329,7 @@ end
 
       describe "#from_json" do
         it "pushes collection items to array" do
-          cd = Compilation.from_json({:bands => [
+          cd = Compilation.new.from_json({:bands => [
             {:name => "Cobra Skulls"},
             {:name => "Diesel Boy"}]}.to_json)
           assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
@@ -388,7 +353,7 @@ end
       end
 
       it "respects :as in #from_json" do
-        songs = Songs.from_json({:songList => ["Out in the cold", "Microphone"]}.to_json)
+        songs = Songs.new.from_json({:songList => ["Out in the cold", "Microphone"]}.to_json)
         assert_equal ["Out in the cold", "Microphone"], songs.tracks
       end
 

data/test/lonely_test.rb

@@ -6,6 +6,7 @@ require 'representable/json/hash'
 class LonelyRepresenterTest < MiniTest::Spec
   module SongRepresenter
     include Representable::JSON
+
     property :name
   end
 

data/test/parse_strategy_test.rb

@@ -83,6 +83,24 @@ class ParseStrategySyncTest < BaseTest
   end
 
 
+  # Sync errors, when model and incoming are not in sync.
+  describe ":sync with error" do
+    representer! do
+      property :song, :parse_strategy => :sync do
+        property :title
+      end
+    end
+
+    # object.song is nil whereas the document contains one.
+    it do
+      assert_raises Representable::DeserializeError do
+        OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Perpetual"}})
+      end
+    end
+  end
+
+
+
   # Lonely Collection
   for_formats(
     :hash => [Representable::Hash::Collection, [{"title"=>"Resist Stance"}], [{"title"=>"Suffer"}]],
@@ -219,6 +237,18 @@ class ParseStrategyLambdaTest < MiniTest::Spec
     property :title
   end
 
+  # property with instance: lambda, using representable's setter. # TODO: that should be handled better via my api.
+  describe "property parse_strategy: lambda, representable: false" do
+    representer! do
+      property :title,
+        :instance      => lambda { |fragment, options| fragment.to_s },  # this will still call song.title= "8675309".
+        :representable => false # don't call object.from_hash
+    end
+
+    let (:song) { Song.new(nil, nil) }
+    it { song.extend(representer).from_hash("title" => 8675309).title.must_equal "8675309" }
+  end
+
 
   describe "collection" do
     representer!(:inject => :song_representer) do

data/test/represent_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+class RepresentTest < MiniTest::Spec
+  let (:songs) { [song, Song.new("Can't Take Them All")] }
+  let (:song) { Song.new("Days Go By") }
+
+  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],
+    # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
+  ) do |format, mod, output, input|
+
+    # Representer.represents detects collection.
+    describe "Module#to_/from_#{format}" do
+      let (:format) { format }
+
+      let (:representer) {
+        Module.new do
+          include mod
+          property :name
+
+          collection_representer :class => Song # TODOOOOOOOOOOOO: test without Song and fix THIS FUCKINGNoMethodError: undefined method `name=' for {"name"=>"Days Go By"}:Hash ERROR!!!!!!!!!!!!!!!
+        end
+      }
+
+      it { render(representer.represent(songs)).must_equal_document output }
+      it { parse(representer.represent([]), input).must_equal songs }
+    end
+
+    # Decorator.represents detects collection.
+    describe "Decorator#to_/from_#{format}" do
+      let (:format) { format }
+      let (:representer) {
+        Class.new(Representable::Decorator) do
+          include mod
+          property :name
+
+          collection_representer :class => Song
+        end
+      }
+
+      it { render(representer.represent(songs)).must_equal_document output }
+      it { parse(representer.represent([]), input).must_equal songs }
+    end
+  end
+
+
+  for_formats(
+    :hash => [Representable::Hash, out={"name" => "Days Go By"}, out],
+    :json => [Representable::JSON, out="{\"name\":\"Days Go By\"}", out],
+    # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
+  ) do |format, mod, output, input|
+
+    # Representer.represents detects singular.
+    describe "Module#to_/from_#{format}" do
+      let (:format) { format }
+
+      let (:representer) {
+        Module.new do
+          include mod
+          property :name
+
+          collection_representer :class => Song
+        end
+      }
+
+      it { render(representer.represent(song)).must_equal_document output }
+      it { parse(representer.represent(Song.new), input).must_equal song }
+    end
+
+
+    # Decorator.represents detects singular.
+    describe "Decorator#to_/from_#{format}" do
+      let (:format) { format }
+      let (:representer) {
+        Class.new(Representable::Decorator) do
+          include mod
+          property :name
+
+          collection_representer :class => Song
+        end
+      }
+
+      it { render(representer.represent(song)).must_equal_document output }
+      it { parse(representer.represent(Song.new), input).must_equal song }
+    end
+  end
+end

data/test/representable_test.rb

@@ -27,34 +27,7 @@ class RepresentableTest < MiniTest::Spec
 
 
   describe "#representable_attrs" do
-    it "responds to #representable_attrs" do
-      assert_equal 1, Band.representable_attrs.size
-      assert_equal "name", Band.representable_attrs.first.name
-    end
-
     describe "in module" do
-      it "returns definitions" do
-        assert_equal 1, BandRepresentation.representable_attrs.size
-        assert_equal "name", BandRepresentation.representable_attrs.first.name
-      end
-
-      it "inherits to including modules xxx " do
-        assert_equal 2,  PunkBandRepresentation.representable_attrs.size
-        assert_equal "name", PunkBandRepresentation.representable_attrs[:name].name
-        assert_equal "street_cred", PunkBandRepresentation.representable_attrs[:street_cred].name
-      end
-
-      it "inherits to including class" do
-        band = Class.new do
-          include Representable
-          include PunkBandRepresentation
-        end
-
-        assert_equal 2,  band.representable_attrs.size
-        assert_equal "name", band.representable_attrs[:name].name
-        assert_equal "street_cred", band.representable_attrs[:street_cred].name
-      end
-
       it "allows including the concrete representer module later" do
         vd = class VD
           attr_accessor :name, :street_cred
@@ -78,20 +51,6 @@ class RepresentableTest < MiniTest::Spec
       #  vd.name        = "Van Halen"
       #  assert_equal "{\"name\":\"Van Halen\"}", vd.to_json
       #end
-
-      it "doesn't share inherited properties between family members" do
-        parent = Module.new do
-          include Representable
-          property :id
-        end
-
-        child = Module.new do
-          include Representable
-          include parent
-        end
-
-        assert parent.representable_attrs.first.object_id != child.representable_attrs.first.object_id, "definitions shouldn't be identical"
-      end
     end
   end
 
@@ -173,8 +132,8 @@ class RepresentableTest < MiniTest::Spec
     end
 
     it "creates correct Definition" do
-      assert_equal "albums", RockBand.representable_attrs[:albums].name
-      assert RockBand.representable_attrs[:albums].array?
+      assert_equal "albums", RockBand.representable_attrs.get(:albums).name
+      assert RockBand.representable_attrs.get(:albums).array?
     end
   end
 
@@ -185,13 +144,6 @@ class RepresentableTest < MiniTest::Spec
   end
 
 
-  describe "#definition_class" do
-    it "returns Definition class" do
-      assert_equal Representable::Definition, Band.send(:definition_class)
-    end
-  end
-
-
   # DISCUSS: i don't like the JSON requirement here, what about some generic test module?
   class PopBand
     include Representable::JSON
@@ -211,6 +163,7 @@ class RepresentableTest < MiniTest::Spec
       assert_equal 2, @band.groupies
     end
 
+
     it "accepts :exclude option" do
       @band.from_hash({"name"=>"No One's Choice", "groupies"=>2}, {:exclude => [:groupies]})
       assert_equal "No One's Choice", @band.name