representable 1.6.1 → 1.7.0

data/lib/representable/hash/collection.rb

@@ -12,7 +12,7 @@ module Representable::Hash
 
     module ClassMethods
       def items(options)
-        collection :_self, options
+        collection :_self, options.merge(:getter => lambda { |*| self })
       end
     end
 

data/lib/representable/serializer.rb

@@ -0,0 +1,18 @@
+require "representable/deserializer"
+
+module Representable
+  class ObjectSerializer < ObjectDeserializer
+    def call
+      return @object if @object.nil?
+
+      representable = prepare(@object)
+
+      serialize(representable, @binding.user_options)
+    end
+
+  private
+    def serialize(object, user_options)
+      object.send(@binding.serialize_method, user_options.merge!({:wrap => false}))
+    end
+  end
+end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "1.6.1"
+  VERSION = "1.7.0"
 end

data/test/config_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+class ConfigTest < MiniTest::Spec
+  subject { Representable::Config.new }
+  PunkRock = Class.new
+
+  let (:definition) { Representable::Definition.new(:title) }
+
+  describe "wrapping" do
+    it "returns false per default" do
+      assert_equal nil, subject.wrap_for("Punk")
+    end
+
+    it "infers a printable class name if set to true" do
+      subject.wrap = true
+      assert_equal "punk_rock", subject.wrap_for(PunkRock)
+    end
+
+    it "can be set explicitely" do
+      subject.wrap = "Descendents"
+      assert_equal "Descendents", subject.wrap_for(PunkRock)
+    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
+    end
+  end
+
+  describe "#<<" do
+    it "returns Definition" do
+      (subject << definition).must_equal definition
+    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 }
+  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

data/test/definition_test.rb

@@ -5,23 +5,23 @@ class DefinitionTest < MiniTest::Spec
     before do
       @def = Representable::Definition.new(:songs)
     end
-    
+
     describe "DCI" do
       it "responds to #representer_module" do
         assert_equal nil, Representable::Definition.new(:song).representer_module
         assert_equal Hash, Representable::Definition.new(:song, :extend => Hash).representer_module
       end
     end
-    
+
     describe "#typed?" do
       it "is false per default" do
         assert ! @def.typed?
       end
-      
+
       it "is true when :class is present" do
         assert Representable::Definition.new(:songs, :class => Hash).typed?
       end
-      
+
       it "is true when :extend is present, only" do
         assert Representable::Definition.new(:songs, :extend => Hash).typed?
       end
@@ -30,109 +30,109 @@ class DefinitionTest < MiniTest::Spec
         assert Representable::Definition.new(:songs, :instance => Object.new).typed?
       end
     end
-    
+
     it "responds to #getter and returns string" do
       assert_equal "songs", @def.getter
     end
-    
+
     it "responds to #name" do
-      assert_equal "songs", @def.name 
+      assert_equal "songs", @def.name
     end
-    
+
     it "responds to #setter" do
       assert_equal :"songs=", @def.setter
     end
-    
+
     it "responds to #sought_type" do
       assert_equal nil, @def.sought_type
     end
-    
+
     describe "#clone" do
       it "clones @options" do
         @def.options[:volume] = 9
         cloned = @def.clone
         cloned.options[:volume] = 8
-        
+
         assert_equal @def.options[:volume], 9
         assert_equal cloned.options[:volume], 8
       end
     end
   end
-  
+
   describe "#has_default?" do
     it "returns false if no :default set" do
       assert_equal false, Representable::Definition.new(:song).has_default?
     end
-    
+
     it "returns true if :default set" do
       assert_equal true, Representable::Definition.new(:song, :default => nil).has_default?
     end
-    
+
     it "returns true if :collection" do
       assert_equal true, Representable::Definition.new(:songs, :collection => true).has_default?
     end
-    
+
   end
-  
-  
+
+
   describe "#skipable_nil_value?" do
     # default if skipable_nil_value?
     before do
       @def = Representable::Definition.new(:song, :render_nil => true)
     end
-    
+
     it "returns false when not nil" do
       assert_equal false, @def.skipable_nil_value?("Disconnect, Disconnect")
     end
-    
+
     it "returns false when nil and :render_nil => true" do
       assert_equal false, @def.skipable_nil_value?(nil)
     end
-    
+
     it "returns true when nil and :render_nil => false" do
       assert_equal true, Representable::Definition.new(:song).skipable_nil_value?(nil)
     end
-    
+
     it "returns false when not nil and :render_nil => false" do
       assert_equal false, Representable::Definition.new(:song).skipable_nil_value?("Fatal Flu")
     end
   end
-  
-  
+
+
   describe "#default_for" do
     before do
       @def = Representable::Definition.new(:song, :default => "Insider")
     end
-    
+
     it "always returns value when value not nil" do
       assert_equal "Black And Blue", @def.default_for("Black And Blue")
     end
-    
+
     it "returns false when value false" do
       assert_equal false, @def.default_for(false)
     end
-    
+
     it "returns default when value nil" do
       assert_equal "Insider", @def.default_for(nil)
     end
-    
+
     it "returns nil when value nil and :render_nil true" do
       @def = Representable::Definition.new(:song, :render_nil => true)
       assert_equal nil, @def.default_for(nil)
     end
-    
+
     it "returns nil when value nil and :render_nil true even when :default is set" do
       @def = Representable::Definition.new(:song, :render_nil => true, :default => "The Quest")
       assert_equal nil, @def.default_for(nil)
     end
-    
+
     it "returns nil if no :default" do
       @def = Representable::Definition.new(:song)
       assert_equal nil, @def.default_for(nil)
     end
   end
-    
-  
+
+
   describe "#writeable?" do
 
     it "returns true when :writeable is not given" do
@@ -154,7 +154,7 @@ class DefinitionTest < MiniTest::Spec
       @def = Representable::Definition.new(:song, :writeable => nil)
       assert_equal nil, @def.writeable?
     end
-    
+
   end
 
   describe "#readable?" do
@@ -203,47 +203,47 @@ class DefinitionTest < MiniTest::Spec
     before do
       @def = Representable::Definition.new(:songs, :collection => true, :tag => :song)
     end
-    
+
     it "responds to #array?" do
       assert @def.array?
     end
-    
+
     it "responds to #sought_type" do
       assert_equal nil, @def.sought_type
     end
-    
+
     it "responds to #default" do
       assert_equal [], @def.send(:default)
     end
   end
-  
+
   describe ":class => Item" do
     before do
       @def = Representable::Definition.new(:songs, :class => Hash)
     end
-    
+
     it "responds to #sought_type" do
       assert_equal Hash, @def.sought_type
     end
   end
-  
+
   describe ":default => value" do
     it "responds to #default" do
       @def = Representable::Definition.new(:song)
       assert_equal nil, @def.send(:default)
     end
-    
+
     it "accepts a default value" do
       @def = Representable::Definition.new(:song, :default => "Atheist Peace")
       assert_equal "Atheist Peace", @def.send(:default)
     end
   end
-  
+
   describe ":hash => true" do
     before do
       @def = Representable::Definition.new(:songs, :hash => true)
     end
-    
+
     it "responds to #hash?" do
       assert @def.hash?
       assert ! Representable::Definition.new(:songs).hash?
@@ -259,4 +259,9 @@ class DefinitionTest < MiniTest::Spec
       assert_equal subject.binding, Object
     end
   end
+
+  describe "#sync?" do
+    it { Representable::Definition.new(:song).sync?.must_equal false }
+    it { Representable::Definition.new(:song, :parse_strategy => :sync).sync?.must_equal true }
+  end
 end

data/test/generic_test.rb

@@ -4,7 +4,7 @@ class GenericTest < MiniTest::Spec
 # one day, this file will contain all engine-independent test cases. one day...
   let (:new_album)  { OpenStruct.new.extend(representer) }
   let (:album)      { OpenStruct.new(:songs => ["Fuck Armageddon"]).extend(representer) }
-  let (:song) { OpenStruct.new(:title => "Resist Stance").extend(song_representer) }
+  let (:song) { OpenStruct.new(:title => "Resist Stance") }
   let (:song_representer) { Module.new do include Representable::Hash; property :title end  }
 
 
@@ -25,12 +25,12 @@ class GenericTest < MiniTest::Spec
   end
 
 
-  describe ":representable with property" do # TODO: introduce :representable option?
-    representer! do
-      property :song, :instance => lambda { |*| nil }
+  describe "property with instance: { nil }" do # TODO: introduce :representable option?
+    representer!(:inject => :song_representer) do
+      property :song, :instance => lambda { |*| nil }, :extend => song_representer
     end
 
-    let (:hit) { hit = OpenStruct.new(:song => song).extend(representer) } # note that song is already representable.
+    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"})
@@ -44,30 +44,169 @@ class GenericTest < MiniTest::Spec
     end
   end
 
+  def self.for_formats(formats)
+    formats.each do |format, cfg|
+      mod, output, input = cfg
+      yield format, mod, output, input
+    end
+  end
 
-  describe ":representable with collection" do # TODO: introduce :representable option?
-    representer! do
-      collection :songs, :instance => lambda { |*| nil }
+
+  for_formats(
+    :hash => [Representable::Hash, {"song"=>{"title"=>"Resist Stance"}}, {"song"=>{"title"=>"Suffer"}}],
+    :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><song><title>Suffer</title></song></open_struct>",],
+    :yaml => [Representable::YAML, "---\nsong:\n  title: Resist Stance\n", "---\nsong:\n  title: Suffer\n"],
+  ) do |format, mod, output, input|
+
+    describe "[#{format}] property with parse_strategy: :sync" do # TODO: introduce :representable option?
+      let (:format) { format }
+
+      representer!(:module => mod, :name => :song_representer) do
+        property :title
+        self.representation_wrap = :song if format == :xml
+      end
+
+      representer!(:inject => :song_representer, :module => mod) do
+        property :song, :parse_strategy => :sync, :extend => song_representer
+      end
+
+      let (:hit) { hit = OpenStruct.new(:song => song).extend(representer) }
+
+      it "calls #to_hash on song instance, nothing else" do
+        render(hit).must_equal_document(output)
+      end
+
+
+      it "calls #from_hash on the existing song instance, nothing else" do
+        song_id = hit.song.object_id
+
+        parse(hit, input)
+
+        hit.song.title.must_equal "Suffer"
+        hit.song.object_id.must_equal song_id
+      end
     end
-    let (:album) { OpenStruct.new(:songs => [song]).extend(representer) }
+  end
+
+  # FIXME: there's a bug with XML and the collection name!
+  for_formats(
+    :hash => [Representable::Hash, {"songs"=>[{"title"=>"Resist Stance"}]}, {"songs"=>[{"title"=>"Suffer"}]}],
+    #:json => [Representable::JSON, "{\"song\":{\"name\":\"Alive\"}}", "{\"song\":{\"name\":\"You've Taken Everything\"}}"],
+    :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><songs><title>Suffer</title></songs></open_struct>"],
+    :yaml => [Representable::YAML, "---\nsongs:\n- title: Resist Stance\n", "---\nsongs:\n- title: Suffer\n"],
+  ) do |format, mod, output, input|
+
+    describe "[#{format}] collection with :parse_strategy: :sync" do # TODO: introduce :representable option?
+      let (:format) { format }
+      representer!(:module => mod, :name => :song_representer) do
+        property :title
+        self.representation_wrap = :song if format == :xml
+      end
+
+      representer!(:inject => :song_representer, :module => mod) do
+        collection :songs, :parse_strategy => :sync, :extend => song_representer
+      end
 
-    it "calls #to_hash on song instances, nothing else" do
-      album.to_hash.must_equal("songs"=>[{"title"=>"Resist Stance"}])
+      let (:album) { OpenStruct.new(:songs => [song]).extend(representer) }
+
+      it "calls #to_hash on song instances, nothing else" do
+        render(album).must_equal_document(output)
+      end
+
+      it "calls #from_hash on the existing song instance, nothing else" do
+        collection_id = album.songs.object_id
+        song          = album.songs.first
+        song_id       = song.object_id
+
+        parse(album, input)
+
+        album.songs.first.title.must_equal "Suffer"
+        song.title.must_equal "Suffer"
+        #album.songs.object_id.must_equal collection_id # TODO: don't replace!
+        song.object_id.must_equal song_id
+      end
     end
+  end
 
-    it "calls #from_hash on the existing song instance, nothing else" do
-      album.songs.instance_eval do
-        def from_hash(items, *args)
-          #puts items #=> {"title"=>"Suffer"}
-          first.from_hash(items)  # example how you can use this.
-        end
+  def render(object)
+    AssertableDocument.new(object.send("to_#{format}"), format)
+  end
+
+  def parse(object, input)
+    object.send("from_#{format}", input)
+  end
+
+  class AssertableDocument
+    attr_reader :document
+
+    def initialize(document, format)
+      @document, @format = document, format
+    end
+
+    def must_equal_document(*args)
+      return document.must_equal_xml(*args) if @format == :xml
+      document.must_equal(*args)
+    end
+  end
+
+
+  # Lonely Collection
+  require "representable/hash/collection"
+
+  for_formats(
+    :hash => [Representable::Hash::Collection, [{"title"=>"Resist Stance"}], [{"title"=>"Suffer"}]],
+    # :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><songs><title>Suffer</title></songs></open_struct>"],
+  ) do |format, mod, output, input|
+
+    describe "[#{format}] lonely collection with :parse_strategy: :sync" do # TODO: introduce :representable option?
+      let (:format) { format }
+      representer!(:module => Representable::Hash, :name => :song_representer) do
+        property :title
+        self.representation_wrap = :song if format == :xml
+      end
+
+      representer!(:inject => :song_representer, :module => mod) do
+        items :parse_strategy => :sync, :extend => song_representer
       end
 
-      song = album.songs.first
-      song_id = song.object_id
-      album.from_hash("songs"=>[{"title"=>"Suffer"}])
-      song.title.must_equal "Suffer"
-      song.object_id.must_equal song_id
+      let (:album) { [song].extend(representer) }
+
+      it "calls #to_hash on song instances, nothing else" do
+        render(album).must_equal_document(output)
+      end
+
+      it "calls #from_hash on the existing song instance, nothing else" do
+        #collection_id = album.object_id
+        song          = album.first
+        song_id       = song.object_id
+
+        parse(album, input)
+
+        album.first.title.must_equal "Suffer"
+        song.title.must_equal "Suffer"
+        song.object_id.must_equal song_id
+      end
+    end
+  end
+
+  def render(object)
+    AssertableDocument.new(object.send("to_#{format}"), format)
+  end
+
+  def parse(object, input)
+    object.send("from_#{format}", input)
+  end
+
+  class AssertableDocument
+    attr_reader :document
+
+    def initialize(document, format)
+      @document, @format = document, format
+    end
+
+    def must_equal_document(*args)
+      return document.must_equal_xml(*args) if @format == :xml
+      document.must_equal(*args)
     end
   end