representable 1.8.5 → 2.0.0.rc1

data/test/coercion_test.rb

@@ -1,113 +1,52 @@
 require 'test_helper'
 require 'representable/coercion'
-require 'representable/decorator/coercion'
 
 class VirtusCoercionTest < MiniTest::Spec
-  class Song  # note that we have to define accessors for the properties here.
-    attr_accessor :title, :composed_at, :track
-  end
+  representer! do
+    include Representable::Coercion
 
-  let (:date) { DateTime.parse("Fri, 18 Nov 1983 00:00:00 +0000") }
+    property :title # no coercion.
+    property :length, :type => Float
 
-  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.
+    property :band, :class => OpenStruct do
+      property :founded, :type => Integer
     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"
+    collection :songs, :class => OpenStruct do
+      property :ok, :type => Virtus::Attribute::Boolean
     end
-
-     it "coerces when rendering" do
-       song = Song.new.extend(SongRepresenter)
-       song.title       = "Scarified"
-       song.composed_at = "Fri, 18 Nov 1983"
-
-       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
+  let (:album) { OpenStruct.new(:title => "Dire Straits", :length => 41.34,
+    :band  => OpenStruct.new(:founded => "1977"),
+    :songs => [OpenStruct.new(:ok => 1), OpenStruct.new(:ok => 0)]) }
 
-      property :composed_at,  :type => DateTime, :default => "May 12th, 2012"
-      property :track,        :type => Integer
+  it { album.extend(representer).to_hash.must_equal({"title"=>"Dire Straits", "length"=>41.34, "band"=>{"founded"=>1977}, "songs"=>[{"ok"=>true}, {"ok"=>false}]}) }
 
-      attr_accessor :composed_at, :track
-    end
+  it {
+    album = OpenStruct.new
+    album.extend(representer)
+    album.from_hash({"title"=>"Dire Straits", "length"=>"41.34", "band"=>{"founded"=>"1977"}, "songs"=>[{"ok"=>1}, {"ok"=>0}]})
 
-    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
+    # it
+    album.length.must_equal 41.34
+    album.band.founded.must_equal 1977
+    album.songs[0].ok.must_equal true
+  }
 
-    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
+  describe "with user :parse_filter and :render_filter" do
+    representer! do
       include Representable::Coercion
 
-      property :composed_at, :type => DateTime
-      property :title
+      property :length, :type => Float,
+      :parse_filter  => lambda { |fragment, doc, options| "#{fragment}.1" }, # happens BEFORE coercer.
+      :render_filter => lambda { |fragment, doc, options| "#{fragment}.1" }
     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
+    # user's :parse_filter(s) are run before coercion.
+    it { OpenStruct.new.extend(representer).from_hash("length"=>"1").length.must_equal 1.1 }
+    # user's :render_filter(s) are run before coercion.
+    it { OpenStruct.new(:length=>1).extend(representer).to_hash.must_equal({"length" => 1.1}) }
   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
+end

data/test/config/inherit_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+
+# tests defining representers in modules, decorators and classes and the inheritance when combined.
+
+class ConfigInheritTest < MiniTest::Spec
+  def assert_cloned(child, parent, property)
+    child_def  = child.representable_attrs.get(property)
+    parent_def = parent.representable_attrs.get(property)
+
+    child_def.merge!(:alias => property)
+
+    child_def[:alias].wont_equal parent_def[:alias]
+    child_def.object_id.wont_equal parent_def.object_id
+  end
+  # class Object
+
+  # end
+  module GenreModule
+    include Representable
+    property :genre
+  end
+
+
+  # in Decorator ------------------------------------------------
+  class Decorator < Representable::Decorator
+    property :title
+  end
+
+  it { Decorator.representable_attrs[:definitions].keys.must_equal ["title"] }
+
+  # in inheriting Decorator
+
+  class InheritingDecorator < Decorator
+    property :location
+  end
+
+  it { InheritingDecorator.representable_attrs[:definitions].keys.must_equal ["title", "location"] }
+  it { assert_cloned(InheritingDecorator, Decorator, "title") }
+
+  # in inheriting and including Decorator
+
+  class InheritingAndIncludingDecorator < Decorator
+    include GenreModule
+    property :location
+  end
+
+  it { InheritingAndIncludingDecorator.representable_attrs[:definitions].keys.must_equal ["title", "genre", "location"] }
+  it { assert_cloned(InheritingAndIncludingDecorator, GenreModule, :genre) }
+
+
+  # in module ---------------------------------------------------
+  module Module
+    include Representable
+    property :title
+  end
+
+  it { Module.representable_attrs[:definitions].keys.must_equal ["title"] }
+
+
+  # in module including module
+  module SubModule
+    include Representable
+    include Module
+
+    property :location
+  end
+
+  it { SubModule.representable_attrs[:definitions].keys.must_equal ["title", "location"] }
+  it { assert_cloned(SubModule, Module, :title) }
+
+  # including preserves order
+  module IncludingModule
+    include Representable
+    property :genre
+    include Module
+
+    property :location
+  end
+
+  it { IncludingModule.representable_attrs[:definitions].keys.must_equal ["genre", "title", "location"] }
+
+
+  # included in class -------------------------------------------
+  class Class
+    include Representable
+    include IncludingModule
+  end
+
+  it { Class.representable_attrs[:definitions].keys.must_equal ["genre", "title", "location"] }
+  it { assert_cloned(Class, IncludingModule, :title) }
+  it { assert_cloned(Class, IncludingModule, :location) }
+  it { assert_cloned(Class, IncludingModule, :genre) }
+
+  # included in class with order
+  class DefiningClass
+    include Representable
+    property :street_cred
+    include IncludingModule
+  end
+
+  it { DefiningClass.representable_attrs[:definitions].keys.must_equal ["street_cred", "genre", "title", "location"] }
+
+  # in class
+  class RepresenterClass
+    include Representable
+    property :title
+  end
+
+  it { RepresenterClass.representable_attrs[:definitions].keys.must_equal ["title"] }
+
+
+  # in inheriting class
+  class InheritingClass < RepresenterClass
+    include Representable
+    property :location
+  end
+
+  it { InheritingClass.representable_attrs[:definitions].keys.must_equal ["title", "location"] }
+  it { assert_cloned(InheritingClass, RepresenterClass, :title) }
+
+  # in inheriting class and including
+  class InheritingAndIncludingClass < RepresenterClass
+    property :location
+    include GenreModule
+  end
+
+  it { InheritingAndIncludingClass.representable_attrs[:definitions].keys.must_equal ["title", "location", "genre"] }
+end

data/test/config_test.rb

@@ -1,12 +1,9 @@
 require 'test_helper'
 
-# tested feature: ::property
-
 class ConfigTest < MiniTest::Spec
   subject { Representable::Config.new }
   PunkRock = Class.new
-
-  let (:definition) { Representable::Definition.new(:title) }
+  Definition = Representable::Definition
 
   describe "wrapping" do
     it "returns false per default" do
@@ -24,35 +21,54 @@ class ConfigTest < MiniTest::Spec
     end
   end
 
-  describe "#cloned" do
-    it "clones all definitions" do
-      subject << obj = definition
-
-      subject.cloned.map(&:name).must_equal ["title"]
-      subject.cloned.first.object_id.wont_equal obj.object_id
+  # describe "#[]" do
+  #   before { subject.add(:title, {:me => true}) }
+
+  #   it { subject[:unknown].must_equal     nil }
+  #   it { subject.get(:title)[:me].must_equal  true }
+  #   it { subject["title"][:me].must_equal true }
+  # end
+
+  # []=
+  # []=(... inherit: true)
+  # forwarded to Config#definitions
+  # that goes to ConfigDefinitionsTest
+  describe "#add" do
+    before { subject.add(:title, {:me => true}) }
+
+    # must be kind of Definition
+    it { subject.size.must_equal 1 }
+    it { subject.get(:title).name.must_equal "title" }
+    it { subject.get(:title)[:me].must_equal true }
+
+    # this is actually tested in context in inherit_test.
+    it "overrides former definition" do
+      subject.add(:title, {:peer => Module})
+      subject.get(:title)[:me].must_equal nil
+      subject.get(:title)[:peer].must_equal Module
     end
-  end
 
-  describe "#<<" do
-    it "returns Definition" do
-      (subject << definition).must_equal definition
-    end
+    describe "inherit: true" do
+      before {
+        subject.add(:title, {:me => true})
+        subject.add(:title, {:peer => Module, :inherit => true})
+      }
 
-    it "overwrites old property" do
-      subject << definition
-      subject << overrider = Representable::Definition.new(:title)
-
-      subject.size.must_equal 1
-      subject.first.must_equal overrider
+      it { subject.get(:title)[:me].must_equal true }
+      it { subject.get(:title)[:peer].must_equal Module }
     end
   end
 
-  describe "#[]" do
-    before { subject << definition }
 
-    it { subject[:unknown].must_equal nil }
-    it { subject[:title].must_equal definition }
-    it { subject["title"].must_equal definition }
+  describe "#each" do
+    before { subject.add(:title, {:me => true}) }
+
+    it "what" do
+      definitions = []
+      subject.each { |dfn| definitions << dfn }
+      definitions.size.must_equal 1
+      definitions[0][:me].must_equal true
+    end
   end
 
   describe "#options" do
@@ -63,60 +79,78 @@ class ConfigTest < MiniTest::Spec
     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
+
+  describe "#add" do
+    subject { Representable::Config.new.add(:title, {:me => true}) }
+
+    it { subject.must_be_kind_of Representable::Definition }
+    it { subject[:me].must_equal true }
+  end
+
+  describe "#get" do
+    subject       { Representable::Config.new }
+
+    it do
+      title  = subject.add(:title, {})
+      length = subject.add(:length, {})
+
+      subject.get(:title).must_equal title
+      subject.get(:length).must_equal length
+    end
+  end
+
+
+  describe "xxx- #inherit!" do
+    let (:title)  { Definition.new(:title) }
+    let (:length) { Definition.new(:length) }
+    let (:stars)  { Definition.new(:stars) }
+
+    it do
+      parent = Representable::Config.new
+      parent.add(:title, {:alias => "Callname"})
+      parent[:features][Object] = true
+      # DISCUSS: build Inheritable::Hash automatically in options? is there a gem for that?
+      parent.options[:additional_features] = Representable::Inheritable::Hash[Object => true]
+
+      subject.inherit!(parent)
+
+      # add to inherited config:
+      subject.add(:stars, {})
+      subject[:features][Module] = true
+      subject.options[:additional_features][Module] = true
+
+      subject[:features].must_equal({Object => true, Module => true})
+
+      parent.options[:additional_features].must_equal({Object => true})
+      subject.options[:additional_features].must_equal({Object => true, Module => true})
+
+      # test Definition interface:
+
+      # definitions.size.must_equal([subject.get(:title), subject.get(:stars)])
+      subject.get(:title).object_id.wont_equal parent.get(:title).object_id
+      # subject.get(:stars).object_id.must_equal stars.object_id
+    end
+
+    # Config with Inheritable::Array
+    it "xx" do
+      parent = Representable::Config.new
+      parent.options[:links] = Representable::Inheritable::Array.new
+      parent.options[:links] << "//1"
+
+      subject.options[:links] = Representable::Inheritable::Array.new
+      subject.options[:links] << "//2"
+
+      subject.inherit!(parent)
+      subject.options[:links].must_equal ["//2", "//1"]
+    end
+  end
+
+  describe "#features" do
+    it do
+      subject[:features][Object] = true
+      subject[:features][Module] = true
+
+      subject.features.must_equal [Object, Module]
     end
   end
 end