representable 1.7.7 → 1.8.0

data/test/exec_context_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+class ExecContextTest < MiniTest::Spec
+  for_formats(
+    :hash => [Representable::Hash, {Song => "Rebel Fate"}, {Song=>"Timing"}],
+    # :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"],
+  ) do |format, mod, input, output|
+
+    let (:song) { representer.prepare(Song.new("Timing")) }
+    let (:format) { format }
+
+
+    describe "exec_context: nil" do
+      representer!(:module => mod) do
+        property :name, :as => lambda { |*| self.class }
+      end
+
+      it { render(song).must_equal_document output }
+      it { parse(song, input).name.must_equal "Rebel Fate" }
+    end
+
+
+    describe "exec_context: :decorator" do
+      representer!(:module => mod) do
+        property :name, :as => lambda { |*| self.class }, :exec_context => :decorator
+      end
+
+      it { render(song).must_equal_document output }
+      it { parse(song, input).name.must_equal "Rebel Fate" }
+    end
+
+
+    describe "exec_context: :binding" do
+      representer!(:module => mod) do
+        property :name,
+          :as           => lambda { |*| self.class }, # to actually test
+          :exec_context => :binding,
+          :setter        => lambda { |v, *args| represented.name = v # to make parsing work.
+        }
+      end
+
+      it { render(song).must_equal_document({Representable::Hash::PropertyBinding => "name"}) }
+      it { parse(song, {Representable::Hash::PropertyBinding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+    end
+
+
+    describe "Decorator" do
+      # DISCUSS: do we need this test?
+      describe "exec_context: nil" do
+        representer!(:module => mod, :decorator => true) do
+          property :name, :as => lambda { |*| self.class }
+        end
+
+        it { render(song).must_equal_document output }
+        it { parse(song, input).name.must_equal "Rebel Fate" }
+      end
+
+
+      describe "exec_context: :decorator" do # this tests if lambdas are run in the right context, if methods are called in the right context and if we can access the represented object.
+        representer!(:module => mod, :decorator => true) do
+          property :name, :as => lambda { |*| self.class.superclass }, :exec_context => :decorator
+
+          define_method :name do # def in Decorator class.
+            "Timebomb"
+          end
+
+          define_method :"name=" do |v| # def in Decorator class.
+            represented.name = v
+          end
+        end
+
+        it { render(song).must_equal_document({Representable::Decorator=>"Timebomb"}) }
+        it { parse(song, {Representable::Decorator=>"Listless"}).name.must_equal "Listless" }
+      end
+
+
+      # DISCUSS: do we need this test?
+      describe "exec_context: :binding" do
+        representer!(:module => mod, :decorator => true) do
+          property :name,
+            :as           => lambda { |*| self.class }, # to actually test
+            :exec_context => :binding,
+            :setter        => lambda { |v, *args| represented.name = v # to make parsing work.
+          }
+        end
+
+        it { render(song).must_equal_document({Representable::Hash::PropertyBinding => "name"}) }
+        it { parse(song, {Representable::Hash::PropertyBinding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+      end
+    end
+  end
+end

data/test/generic_test.rb

@@ -73,160 +73,6 @@ class GenericTest < MiniTest::Spec
   end
 
 
-  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) }
-
-    it "calls #to_hash on song instance, nothing else" do
-      hit.to_hash.must_equal("song"=>{"title"=>"Resist Stance"})
-    end
-
-    it "calls #from_hash on the existing song instance, nothing else" do
-      song_id = hit.song.object_id
-      hit.from_hash("song"=>{"title"=>"Suffer"})
-      hit.song.title.must_equal "Suffer"
-      hit.song.object_id.must_equal song_id
-    end
-  end
-
-
-  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
-  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
-
-      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
-
-
-  # 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
-
-      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
-
-  describe "mix :extend and inline representers" do
-    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
-
-
   # wrap_test
   for_formats(
     :hash => [Representable::Hash, {}],

data/test/getter_setter_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class GetterSetterTest < BaseTest
+  representer! do
+    property :name, # key under :name.
+      :getter => lambda { |args| "#{args[:welcome]} #{song_name}" },
+      :setter => lambda { |val, args| self.song_name = "#{args[:welcome]} #{val}" }
+  end
+
+  subject { Struct.new(:song_name).new("Mony Mony").extend(representer) }
+
+  it "uses :getter when rendering" do
+    subject.instance_eval { def name; raise; end }
+    subject.to_hash(:welcome => "Hi").must_equal({"name" => "Hi Mony Mony"})
+  end
+
+  it "does not call original reader when rendering" do
+    subject.instance_eval { def name; raise; end; self }.to_hash({})
+  end
+
+  it "uses :setter when parsing" do
+    subject.from_hash({"name" => "Eyes Without A Face"}, :welcome => "Hello").song_name.must_equal "Hello Eyes Without A Face"
+  end
+
+  it "does not call original writer when parsing" do
+    subject.instance_eval { def name=(*); raise; end; self }.from_hash({"name"=>"Dana D And Talle T"}, {})
+  end
+end

data/test/hash_bindings_test.rb

@@ -5,91 +5,91 @@ class HashBindingTest < MiniTest::Spec
     include Representable::JSON
     property :name
   end
-  
+
   class SongWithRepresenter < ::Song
     include Representable
     include SongRepresenter
   end
-  
-  
+
+
   describe "PropertyBinding" do
     describe "#read" do
       before do
-        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song), nil)
+        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song), nil, nil)
       end
-      
+
       it "returns fragment if present" do
         assert_equal "Stick The Flag Up Your Goddamn Ass, You Sonofabitch", @property.read({"song" => "Stick The Flag Up Your Goddamn Ass, You Sonofabitch"})
         assert_equal "", @property.read({"song" => ""})
         assert_equal nil, @property.read({"song" => nil})
       end
-      
+
       it "returns FRAGMENT_NOT_FOUND if not in document" do
         assert_equal Representable::Binding::FragmentNotFound, @property.read({})
       end
-      
+
     end
-    
+
     describe "with plain text" do
       before do
-        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song), nil)
+        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song), nil, nil)
       end
-      
+
       it "extracts with #read" do
         assert_equal "Thinning the Herd", @property.read("song" => "Thinning the Herd")
       end
-      
+
       it "inserts with #write" do
         doc = {}
         assert_equal("Thinning the Herd", @property.write(doc,"Thinning the Herd"))
         assert_equal({"song"=>"Thinning the Herd"}, doc)
       end
     end
-    
+
     describe "with an object" do
       before do
-        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song, :class => SongWithRepresenter), nil)
+        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song, :class => SongWithRepresenter), nil, nil)
         @doc      = {}
       end
-      
+
       it "extracts with #read" do
         assert_equal SongWithRepresenter.new("Thinning the Herd"), @property.read("song" => {"name" => "Thinning the Herd"})
       end
-      
+
       it "inserts with #write" do
         assert_equal({"name"=>"Thinning the Herd"}, @property.write(@doc, SongWithRepresenter.new("Thinning the Herd")))
         assert_equal({"song" => {"name"=>"Thinning the Herd"}}, @doc)
       end
     end
-    
+
     describe "with an object and :extend" do
       before do
-        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song, :class => Song, :extend => SongRepresenter), nil)
+        @property = Representable::Hash::PropertyBinding.new(Representable::Definition.new(:song, :class => Song, :extend => SongRepresenter), nil, nil)
         @doc      = {}
       end
-      
+
       it "extracts with #read" do
         assert_equal Song.new("Thinning the Herd"), @property.read("song" => {"name" => "Thinning the Herd"})
       end
-      
+
       it "inserts with #write" do
         assert_equal({"name"=>"Thinning the Herd"}, @property.write(@doc, Song.new("Thinning the Herd")))
         assert_equal({"song" => {"name"=>"Thinning the Herd"}}, @doc)
       end
     end
   end
-  
-    
+
+
   describe "CollectionBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::Hash::CollectionBinding.new(Representable::Definition.new(:songs, :collection => true), nil)
+        @property = Representable::Hash::CollectionBinding.new(Representable::Definition.new(:songs, :collection => true), Album.new, nil)
       end
-      
+
       it "extracts with #read" do
         assert_equal ["The Gargoyle", "Bronx"], @property.read("songs" => ["The Gargoyle", "Bronx"])
       end
-      
+
       it "inserts with #write" do
         doc = {}
         assert_equal(["The Gargoyle", "Bronx"], @property.write(doc, ["The Gargoyle", "Bronx"]))
@@ -97,32 +97,32 @@ class HashBindingTest < MiniTest::Spec
       end
     end
   end
-  
-  
-  
-    
+
+
+
+
   describe "HashBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::Hash::HashBinding.new(Representable::Definition.new(:songs, :hash => true), nil)
+        @property = Representable::Hash::HashBinding.new(Representable::Definition.new(:songs, :hash => true), nil, nil)
       end
-      
+
       it "extracts with #read" do
         assert_equal({"first" => "The Gargoyle", "second" => "Bronx"} , @property.read("songs" => {"first" => "The Gargoyle", "second" => "Bronx"}))
       end
-      
+
       it "inserts with #write" do
         doc = {}
         assert_equal({"first" => "The Gargoyle", "second" => "Bronx"}, @property.write(doc, {"first" => "The Gargoyle", "second" => "Bronx"}))
         assert_equal({"songs"=>{"first" => "The Gargoyle", "second" => "Bronx"}}, doc)
       end
     end
-    
+
     describe "with objects" do
       before do
-        @property = Representable::Hash::HashBinding.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter), nil)
+        @property = Representable::Hash::HashBinding.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter), nil, nil)
       end
-      
+
       it "doesn't change the represented hash in #write" do
         song = Song.new("Better Than That")
         hash = {"first" => song}
@@ -130,6 +130,6 @@ class HashBindingTest < MiniTest::Spec
         assert_equal({"first" => song}, hash)
       end
     end
-    
+
   end
 end

data/test/hash_test.rb

@@ -1,5 +1,4 @@
 require 'test_helper'
-require 'representable/hash'
 
 class HashTest < MiniTest::Spec
   def self.hash_representer(&block)
@@ -147,23 +146,4 @@ class HashTest < MiniTest::Spec
       end
     end
   end
-
-
-  class DefinitionTest < MiniTest::Spec
-    it "what" do
-      class Representable::Hash::Binding < SimpleDelegator
-
-      end
-
-      definition  = Representable::Definition.new(:name)
-      wrapped     = Representable::Hash::Binding.new(definition)
-
-      wrapped.name.must_equal "name"
-      wrapped.hash?.must_equal nil
-      wrapped.array?.must_equal nil
-      wrapped.options.must_equal({})
-
-      #wrapped.
-    end
-  end
 end