representable 1.5.3 → 1.6.0

data/test/coercion_test.rb

@@ -3,82 +3,111 @@ require 'representable/coercion'
 require 'representable/decorator/coercion'
 
 class VirtusCoercionTest < MiniTest::Spec
-  class Song  # note that we don't define accessors for the properties here.
-    attr_accessor :title
+  class Song  # note that we have to define accessors for the properties here.
+    attr_accessor :title, :composed_at, :track
   end
 
-  describe "Coercion with Virtus" do
-    describe "on object level" do
-      module SongRepresenter
-        include Representable::JSON
-        include Representable::Coercion
-        property :composed_at,  :type => DateTime
-        property :track,        :type => Integer
-        property :title # no coercion.
-      end
-
-      it "coerces properties in #from_json" do
-        song = Song.new.extend(SongRepresenter).from_json('{"composed_at":"November 18th, 1983","track":"18","title":"Scarified"}')
-        assert_kind_of DateTime, song.composed_at
-        assert_equal DateTime.parse("Fri, 18 Nov 1983 00:00:00 +0000"), song.composed_at
-        assert_equal 18, song.track
-        song.title.must_equal "Scarified"
-      end
-
-      # it "coerces when rendering" do
-      #   song = Song.new
-      #   song.title = "Scarified"
-      #   song.to_json.must_equal ''
-      # end
+  let (:date) { DateTime.parse("Fri, 18 Nov 1983 00:00:00 +0000") }
+
+  describe "on object level" do
+    module SongRepresenter
+      include Representable::JSON
+      include Representable::Coercion
+      property :composed_at,  :type => DateTime
+      property :track,        :type => Integer
+      property :title # no coercion.
+    end
+
+    it "coerces properties in #from_json" do
+      song = Song.new.extend(SongRepresenter).from_json('{"composed_at":"November 18th, 1983","track":"18","title":"Scarified"}')
+      song.composed_at.must_equal date
+      song.track.must_equal 18
+      song.title.must_equal "Scarified"
     end
 
+     it "coerces when rendering" do
+       song = Song.new.extend(SongRepresenter)
+       song.title       = "Scarified"
+       song.composed_at = "Fri, 18 Nov 1983"
 
-    describe "on class level" do
-      class ImmigrantSong
-        include Representable::JSON
-        include Representable::Coercion
+       song.to_hash.must_equal({"title" => "Scarified", "composed_at" => date})
+     end
+  end
+
+  describe "on class level" do
+    class ImmigrantSong
+      include Representable::JSON
+      include Representable::Coercion
 
-        property :composed_at,  :type => DateTime, :default => "May 12th, 2012"
-        property :track,        :type => Integer
-      end
+      property :composed_at,  :type => DateTime, :default => "May 12th, 2012"
+      property :track,        :type => Integer
 
-      it "coerces into the provided type" do
-        song = ImmigrantSong.new.from_json("{\"composed_at\":\"November 18th, 1983\",\"track\":\"18\"}")
-        assert_equal DateTime.parse("Fri, 18 Nov 1983 00:00:00 +0000"), song.composed_at
-        assert_equal 18, song.track
-      end
+      attr_accessor :composed_at, :track
+    end
 
-      it "respects the :default options" do
-        song = ImmigrantSong.new.from_json("{}")
-        assert_kind_of DateTime, song.composed_at
-        assert_equal DateTime.parse("Mon, 12 May 2012 00:00:00 +0000"), song.composed_at
-      end
+    it "coerces into the provided type" do
+      song = ImmigrantSong.new.from_json("{\"composed_at\":\"November 18th, 1983\",\"track\":\"18\"}")
+      song.composed_at.must_equal date
+      song.track.must_equal 18
     end
 
-    describe "on decorator" do
-      class SongRepresentation < Representable::Decorator
-        include Representable::JSON
-        include Representable::Decorator::Coercion
-
-        property :composed_at, :type => DateTime
-        property :title
-      end
-
-      it "coerces when parsing" do
-        song = SongRepresentation.new(OpenStruct.new).from_json("{\"composed_at\":\"November 18th, 1983\", \"title\": \"Scarified\"}")
-        song.must_be_kind_of OpenStruct
-        song.composed_at.must_equal DateTime.parse("Fri, 18 Nov 1983")
-        song.title.must_equal "Scarified"
-      end
-
-      it "coerces when rendering" do
-        SongRepresentation.new(
-          OpenStruct.new(
-            :composed_at  => "November 18th, 1983",
-            :title        => "Scarified"
-          )
-        ).to_hash.must_equal({"composed_at"=>DateTime.parse("Fri, 18 Nov 1983"), "title"=>"Scarified"})
-      end
+    it "respects the :default options" do
+      song = ImmigrantSong.new.from_json("{}")
+      song.composed_at.must_equal DateTime.parse("Mon, 12 May 2012 00:00:00 +0000")
     end
   end
+
+  describe "on decorator" do
+    class SongRepresentation < Representable::Decorator
+      include Representable::JSON
+      include Representable::Coercion
+
+      property :composed_at, :type => DateTime
+      property :title
+    end
+
+    it "coerces when parsing" do
+      song = SongRepresentation.new(OpenStruct.new).from_json("{\"composed_at\":\"November 18th, 1983\", \"title\": \"Scarified\"}")
+      song.must_be_kind_of OpenStruct
+      song.composed_at.must_equal date
+      song.title.must_equal "Scarified"
+    end
+
+    it "coerses with inherited decorator" do
+      song = Class.new(SongRepresentation).new(OpenStruct.new).from_json("{\"composed_at\":\"November 18th, 1983\", \"title\": \"Scarified\"}")
+      song.composed_at.must_equal date
+    end
+
+    it "coerces when rendering" do
+      SongRepresentation.new(
+        OpenStruct.new(
+          :composed_at  => "November 18th, 1983",
+          :title        => "Scarified"
+        )
+      ).to_hash.must_equal({"composed_at"=>date, "title"=>"Scarified"})
+    end
+  end
+
+  # DISCUSS: do we actually wanna have accessors in a decorator/module? i guess the better idea is to let coercion happen through from_/to_,
+  # only, to make it as simple as possible.
+  # describe "without serialization/deserialization" do
+  #   let (:coercer_class) do
+  #     class SongCoercer < Representable::Decorator
+  #       include Representable::Decorator::Coercion
+
+  #       property :composed_at, :type => DateTime
+  #       property :title
+
+  #       self
+  #     end
+  #   end
+
+  #   it "coerces when setting" do
+  #     coercer = coercer_class.new(song = OpenStruct.new)
+  #     coercer.composed_at = "November 18th, 1983"
+  #     #coercer.title       = "Scarified"
+
+  #     song.composed_at.must_equal date
+  #   end
+  # end
 end

data/test/decorator_test.rb

@@ -17,6 +17,16 @@ class DecoratorTest < MiniTest::Spec
   let (:album) { Album.new([song]) }
   let (:decorator) { AlbumRepresentation.new(album) }
 
+  describe "inheritance" do
+    let (:inherited_decorator) do
+      Class.new(AlbumRepresentation) do
+        property :best_song
+      end.new(Album.new([song], "Stand Up"))
+    end
+
+    it { inherited_decorator.to_hash.must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}], "best_song"=>"Stand Up"}) }
+  end
+
   it "renders" do
     decorator.to_hash.must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}]})
     album.wont_respond_to :to_hash

data/test/inheritance_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class InheritanceTest < MiniTest::Spec
+  let (:decorator) do
+    Class.new(Representable::Decorator) do
+      property :title
+    end
+  end
+
+  # Decorator.new.representable_attrs != Decorator.representable_attrs
+  it "doesn't clone for instantiated decorator" do
+    instance = decorator.new(Object.new)
+    instance.send(:representable_attrs).first.options[:instance] = true
+
+    # we didn't clone and thereby change the original config:
+    instance.send(:representable_attrs).to_s.must_equal decorator.representable_attrs.to_s
+  end
+
+  # TODO:  ? (performance?)
+  #  more tests on cloning
+end

data/test/json_test.rb

@@ -144,13 +144,13 @@ module JsonTest
         end
       end
 
-      describe "#representable_bindings_for" do
-        it "returns bindings for each property" do
-          bins = @band.send(:representable_bindings_for, Representable::JSON::PropertyBinding, {})
-          assert_equal 2, bins.size
-          assert_equal "name", bins.first.name
-        end
-      end
+      # describe "#representable_bindings_for" do
+      #   it "returns bindings for each property" do
+      #     bins = @band.send(:representable_bindings_for, Representable::JSON::PropertyBinding, {})
+      #     assert_equal 2, bins.size
+      #     assert_equal "name", bins.first.name
+      #   end
+      # end
     end
 
 

data/test/representable_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class RepresentableTest < MiniTest::Spec
   class Band
-    include Representable
+    include Representable::Hash
     property :name
     attr_accessor :name
   end
@@ -92,7 +92,6 @@ class RepresentableTest < MiniTest::Spec
 
         assert parent.representable_attrs.first != child.representable_attrs.first, "definitions shouldn't be identical"
       end
-
     end
   end
 
@@ -172,6 +171,12 @@ class RepresentableTest < MiniTest::Spec
         assert_equal "friends", band.representable_attrs.last.from
       end
     end
+
+    representer! {}
+
+    it "returns the Definition instance" do
+      representer.property(:name).must_be_kind_of Representable::Definition
+    end
   end
 
   describe "#collection" do
@@ -242,36 +247,36 @@ class RepresentableTest < MiniTest::Spec
     end
 
     it "copies values from document to object" do
-      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {}, Representable::Hash::PropertyBinding)
+      @band.from_hash({"name"=>"No One's Choice", "groupies"=>2})
       assert_equal "No One's Choice", @band.name
       assert_equal 2, @band.groupies
     end
 
     it "accepts :exclude option" do
-      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:exclude => [:groupies]}, Representable::Hash::PropertyBinding)
+      @band.from_hash({"name"=>"No One's Choice", "groupies"=>2}, {:exclude => [:groupies]})
       assert_equal "No One's Choice", @band.name
       assert_equal nil, @band.groupies
     end
 
     it "accepts :include option" do
-      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:include => [:groupies]}, Representable::Hash::PropertyBinding)
+      @band.from_hash({"name"=>"No One's Choice", "groupies"=>2}, :include => [:groupies])
       assert_equal 2, @band.groupies
       assert_equal nil, @band.name
     end
 
     it "ignores non-writeable properties" do
       @band = Class.new(Band) { property :name; collection :founders, :writeable => false; attr_accessor :founders }.new
-      @band.update_properties_from({"name" => "Iron Maiden", "groupies" => 2, "founders" => [{ "name" => "Steve Harris" }] }, {}, Representable::Hash::PropertyBinding)
+      @band.from_hash("name" => "Iron Maiden", "groupies" => 2, "founders" => ["Steve Harris"])
       assert_equal "Iron Maiden", @band.name
       assert_equal nil, @band.founders
     end
 
     it "always returns the represented" do
-      assert_equal @band, @band.update_properties_from({"name"=>"Nofx"}, {}, Representable::Hash::PropertyBinding)
+      assert_equal @band, @band.from_hash({"name"=>"Nofx"})
     end
 
     it "includes false attributes" do
-      @band.update_properties_from({"groupies"=>false}, {}, Representable::Hash::PropertyBinding)
+      @band.from_hash({"groupies"=>false})
       assert_equal false, @band.groupies
     end
 
@@ -279,14 +284,15 @@ class RepresentableTest < MiniTest::Spec
       @band.instance_eval do
         def name=(*); raise "I should never be called!"; end
       end
-      @band.update_properties_from({}, {}, Representable::Hash::PropertyBinding)
+      @band.from_hash({})
     end
 
+    # FIXME: do we need this test with XML _and_ JSON?
     it "ignores (no-default) properties not present in the incoming document" do
-      { Representable::JSON => [{}, Representable::Hash::PropertyBinding],
-        Representable::XML  => [xml(%{<band/>}), Representable::XML::PropertyBinding]
+      { Representable::Hash => [:from_hash, {}],
+        Representable::XML  => [:from_xml,  xml(%{<band/>}).to_s]
       }.each do |format, config|
-        nested_repr = Module.new do # this module is never applied.
+        nested_repr = Module.new do # this module is never applied. # FIXME: can we make that a simpler test?
           include format
           property :created_at
         end
@@ -297,7 +303,7 @@ class RepresentableTest < MiniTest::Spec
         end
 
         @band = Band.new.extend(repr)
-        @band.update_properties_from(config.first, {}, config.last)
+        @band.send(config.first, config.last)
         assert_equal nil, @band.name, "Failed in #{format}"
       end
     end
@@ -348,16 +354,16 @@ class RepresentableTest < MiniTest::Spec
     end
 
     it "compiles document from properties in object" do
-      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding))
+      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.to_hash)
     end
 
     it "accepts :exclude option" do
-      hash = @band.send(:create_representation_with, {}, {:exclude => [:groupies]}, Representable::Hash::PropertyBinding)
+      hash = @band.to_hash({:exclude => [:groupies]})
       assert_equal({"name"=>"No One's Choice"}, hash)
     end
 
     it "accepts :include option" do
-      hash = @band.send(:create_representation_with, {}, {:include => [:groupies]}, Representable::Hash::PropertyBinding)
+      hash = @band.to_hash({:include => [:groupies]})
       assert_equal({"groupies"=>2}, hash)
     end
 
@@ -366,18 +372,18 @@ class RepresentableTest < MiniTest::Spec
       @band.name = "Iron Maiden"
       @band.founder_ids = [1,2,3]
 
-      hash = @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding)
+      hash = @band.to_hash
       assert_equal({"name" => "Iron Maiden"}, hash)
     end
 
     it "does not write nil attributes" do
       @band.groupies = nil
-      assert_equal({"name"=>"No One's Choice"}, @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding))
+      assert_equal({"name"=>"No One's Choice"}, @band.to_hash)
     end
 
     it "writes false attributes" do
       @band.groupies = false
-      assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding))
+      assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.to_hash)
     end
 
     describe "when :render_nil is true" do
@@ -390,7 +396,7 @@ class RepresentableTest < MiniTest::Spec
 
         @band.extend(mod) # FIXME: use clean object.
         @band.groupies = nil
-        hash = @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding)
+        hash = @band.to_hash
         assert_equal({"name"=>"No One's Choice", "groupies" => nil}, hash)
       end
 
@@ -403,7 +409,7 @@ class RepresentableTest < MiniTest::Spec
 
         @band.extend(mod) # FIXME: use clean object.
         @band.groupies = nil
-        hash = @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding)
+        hash = @band.to_hash
         assert_equal({"name"=>"No One's Choice", "groupies" => nil}, hash)
       end
     end
@@ -422,6 +428,63 @@ class RepresentableTest < MiniTest::Spec
     end
   end
 
+  describe "inline representers" do
+    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"}}],
+      :json => [Representable::JSON, "{\"song\":{\"name\":\"Alive\"}}", "{\"song\":{\"name\":\"You've Taken Everything\"}}"],
+      :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"],
+    }.each do |format, cfg|
+      mod, output, input = cfg
+
+      describe "[#{format}] with :class" do
+        representer!(mod) do
+          property :song, :class => Song do
+            property :name
+          end
+        end
+
+        it { request.send("to_#{format}").must_equal output }
+        it { request.send("from_#{format}", input).song.name.must_equal "You've Taken Everything"}
+      end
+    end
+
+    describe "without :class" do
+      representer! do
+        property :song do
+          property :name
+        end
+      end
+
+      it { request.to_hash.must_equal({"song"=>{"name"=>"Alive"}}) }
+    end
+
+    describe "decorator" do
+      let (:representer) do
+        Class.new(Representable::Decorator) do
+          include Representable::Hash
+
+          property :song, :class => Song do
+            property :name
+          end
+
+          self
+        end
+      end
+
+      it { request.to_hash.must_equal({"song"=>{"name"=>"Alive"}}) }
+      it { request.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name.must_equal "You've Taken Everything"}
+
+      it "uses an inline decorator" do
+        request.to_hash
+        song.wont_be_kind_of Representable
+      end
+    end
+  end
+
   describe ":if" do
     before do
       @pop = Class.new(PopBand) { attr_accessor :fame }
@@ -430,21 +493,21 @@ class RepresentableTest < MiniTest::Spec
     it "respects property when condition true" do
       @pop.class_eval { property :fame, :if => lambda { true } }
       band = @pop.new
-      band.update_properties_from({"fame"=>"oh yes"}, {}, Representable::Hash::PropertyBinding)
+      band.from_hash({"fame"=>"oh yes"})
       assert_equal "oh yes", band.fame
     end
 
     it "ignores property when condition false" do
       @pop.class_eval { property :fame, :if => lambda { false } }
       band = @pop.new
-      band.update_properties_from({"fame"=>"oh yes"}, {}, Representable::Hash::PropertyBinding)
+      band.from_hash({"fame"=>"oh yes"})
       assert_equal nil, band.fame
     end
 
     it "ignores property when :exclude'ed even when condition is true" do
       @pop.class_eval { property :fame, :if => lambda { true } }
       band = @pop.new
-      band.update_properties_from({"fame"=>"oh yes"}, {:exclude => [:fame]}, Representable::Hash::PropertyBinding)
+      band.from_hash({"fame"=>"oh yes"}, {:exclude => [:fame]})
       assert_equal nil, band.fame
     end
 
@@ -452,7 +515,7 @@ class RepresentableTest < MiniTest::Spec
       @pop.class_eval { property :fame, :if => lambda { groupies } }
       band = @pop.new
       band.groupies = true
-      band.update_properties_from({"fame"=>"oh yes"}, {}, Representable::Hash::PropertyBinding)
+      band.from_hash({"fame"=>"oh yes"})
       assert_equal "oh yes", band.fame
     end
 
@@ -793,11 +856,68 @@ class RepresentableTest < MiniTest::Spec
       end
     end
 
-    describe "clone" do
+    describe "#clone" do
       it "clones all definitions" do
         subject << Object.new
         assert subject.first != subject.clone.first
       end
     end
+
+    describe "Config inheritance" do
+      # TODO: this section will soon be moved to uber.
+      describe "inheritance when including" do
+        # TODO: test all the below issues AND if cloning works.
+        module TestMethods
+          def representer_for(modules=[Representable], &block)
+            Module.new do
+              extend TestMethods
+              include *modules
+              module_exec(&block)
+            end
+          end
+        end
+        include TestMethods
+
+        it "inherits to uninitialized child" do
+          representer_for do # child
+            include(representer_for do # parent
+              representable_attrs.inheritable_array(:links) << "bar"
+            end)
+          end.representable_attrs.inheritable_array(:links).must_equal(["bar"])
+        end
+
+        it "works with uninitialized parent" do
+          representer_for do # child
+            representable_attrs.inheritable_array(:links) << "bar"
+
+            include(representer_for do # parent
+            end)
+          end.representable_attrs.inheritable_array(:links).must_equal(["bar"])
+        end
+
+        it "inherits when both are initialized" do
+          representer_for do # child
+            representable_attrs.inheritable_array(:links) << "bar"
+
+            include(representer_for do # parent
+              representable_attrs.inheritable_array(:links) << "stadium"
+            end)
+          end.representable_attrs.inheritable_array(:links).must_equal(["bar", "stadium"])
+        end
+
+        it "clones parent inheritables" do # FIXME: actually we don't clone here!
+          representer_for do # child
+            representable_attrs.inheritable_array(:links) << "bar"
+
+            include(parent = representer_for do # parent
+              representable_attrs.inheritable_array(:links) << "stadium"
+            end)
+
+            parent.representable_attrs.inheritable_array(:links) << "park"  # modify parent array.
+
+          end.representable_attrs.inheritable_array(:links).must_equal(["bar", "stadium"])
+        end
+      end
+    end
   end
 end