representable 2.4.0.rc3 → 2.4.0.rc4

data/test/lonely_test.rb

@@ -112,7 +112,7 @@ class LonelyRepresenterTest < MiniTest::Spec
     end
 
 
-    it { [1,2].extend(representer).to_hash(one: One, two: Two).must_equal(["One: 1", "Two: 2"]) }
+    it { [1,2].extend(representer).to_hash(user_options: {one: One, two: Two}).must_equal(["One: 1", "Two: 2"]) }
   end
 
 
@@ -158,7 +158,7 @@ class LonelyRepresenterTest < MiniTest::Spec
           assert_equal({"two" => Song.new("Can't Take Them All")}, {}.extend(representer).from_json(json, :exclude => [:one]))
         end
 
-        it "xxxrespects :include" do
+        it "respects :include" do
           assert_equal({"one" => Song.new("Days Go By")}, {}.extend(representer).from_json(json, :include => [:one]))
         end
       end
@@ -221,3 +221,19 @@ class LonelyRepresenterTest < MiniTest::Spec
     end
   end
 end
+
+
+# describe "Hash::Collection with :include" do
+class CollectionWithIncludeTest < MiniTest::Spec
+  Song = Struct.new(:id, :title)
+
+  representer!(decorator: true, module: Representable::Hash::Collection) do
+    items do
+      property :id
+      property :title
+    end
+  end
+
+  it { representer.new([Song.new(1, "ACAB")]).to_hash.must_equal([{"id"=>1, "title"=>"ACAB"}]) }
+  it { representer.new([Song.new(1, "ACAB")]).to_hash(include: [:title]).must_equal([{"title"=>"ACAB"}]) }
+end

data/test/object_test.rb

@@ -8,10 +8,10 @@ class ObjectTest < MiniTest::Spec
   representer!(module: Representable::Object) do
     property :title
 
-    property :album, instance: lambda { |fragment, *| fragment.name.upcase!; fragment } do
+    property :album, instance: lambda { |options| options[:fragment].name.upcase!; options[:fragment] } do
       property :name
 
-      collection :songs, instance: lambda { |fragment, *| fragment.title.upcase!; fragment } do
+      collection :songs, instance: lambda { |options| options[:fragment].title.upcase!; options[:fragment] } do
         property :title
       end
     end
@@ -42,10 +42,10 @@ class ObjectTest < MiniTest::Spec
     representer!(module: Representable::Object) do
       property :title
 
-      property :album, render_filter: lambda { |object, *| object.name = "Live"; object } do
+      property :album, render_filter: lambda { |input, options|input.name = "Live";input } do
         property :name
 
-        collection :songs, render_filter: lambda { |object, *| object[0].title = 1; object } do
+        collection :songs, render_filter: lambda { |input, options|input[0].title = 1;input } do
           property :title
         end
       end

data/test/parse_pipeline_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+class ParsePipelineTest < MiniTest::Spec
+  Album  = Struct.new(:id, :artist, :songs)
+  Artist = Struct.new(:email)
+  Song   = Struct.new(:title)
+
+  describe "transforming nil to [] when parsing" do
+    representer!(decorator: true) do
+      collection :songs,
+          parse_pipeline: ->(*) {
+            Representable::Pipeline.insert(
+              parse_functions,                                # original function list from Binding#parse_functions.
+              ->(input, options) { input.nil? ? [] : input }, # your new function (can be any callable object)..
+              replace: Representable::OverwriteOnNil          # ..that replaces the original function.
+            )
+          },
+          class: Song do
+        property :title
+      end
+    end
+
+    it do
+      representer.new(album = Album.new).from_hash("songs"=>nil)
+      album.songs.must_equal []
+    end
+
+    it do
+      representer.new(album = Album.new).from_hash("songs"=>[{"title" => "Business Conduct"}])
+      album.songs.must_equal [Song.new("Business Conduct")]
+    end
+  end
+
+
+  # tests [Collect[Instance, Prepare, Deserialize], Setter]
+  class Representer < Representable::Decorator
+    include Representable::Hash
+
+    # property :artist, populator: Uber::Options::Value.new(ArtistPopulator.new), pass_options:true do
+    #   property :email
+    # end
+    # DISCUSS: rename to populator_pipeline ?
+    collection :songs, parse_pipeline: ->(*) { [Collect[Instance, Prepare, Deserialize], Setter] }, instance: :instance!, exec_context: :decorator, pass_options: true do
+      property :title
+    end
+
+    def instance!(*options)
+      puts "@@@@@ #{options.inspect}"
+      Song.new
+    end
+
+    def songs=(array)
+      represented.songs=array
+    end
+  end
+
+  it do
+    skip "TODO: implement :parse_pipeline and :render_pipeline, and before/after/replace semantics"
+    album = Album.new
+    Representer.new(album).from_hash({"artist"=>{"email"=>"yo"}, "songs"=>[{"title"=>"Affliction"}, {"title"=>"Dream Beater"}]})
+    album.songs.must_equal([Song.new("Affliction"), Song.new("Dream Beater")])
+    puts album.inspect
+  end
+end

data/test/parse_strategy_test.rb

@@ -208,7 +208,7 @@ class ParseStrategyFindOrInstantiateTest < BaseTest
   describe "property with dynamic :class" do
     representer!(:inject => :song_representer) do
       property :song, :parse_strategy => :find_or_instantiate, :extend => song_representer,
-        :class => lambda { |fragment, *args| fragment["class"] }
+        :class => lambda { |options| options[:fragment]["class"] }
     end
 
     let (:album) { Struct.new(:song).new.extend(representer) }
@@ -241,7 +241,7 @@ class ParseStrategyLambdaTest < MiniTest::Spec
   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".
+        :instance      => lambda { |options| options[:fragment].to_s },  # this will still call song.title= "8675309".
         :representable => false # don't call object.from_hash
     end
 
@@ -252,7 +252,7 @@ class ParseStrategyLambdaTest < MiniTest::Spec
 
   describe "collection" do
     representer!(:inject => :song_representer) do
-      collection :songs, :parse_strategy => lambda { |fragment, i, options|
+      collection :songs, :parse_strategy => lambda { |options|
         songs << song = Song.new
         song
       }, :extend => song_representer

data/test/pipeline_test.rb

@@ -119,12 +119,11 @@ class PipelineTest < MiniTest::Spec
       R::GetValue,
       R::StopOnSkipable,
       R::StopOnNil,
-      R::SkipRender,
       R::Decorate,
       R::Serialize,
       R::AssignName,
       R::WriteFragment
-    ].extend(P::Debug).(nil, {represented: song_model, binding: artist, doc: doc, user_options: {}}).must_equal({"name" => "Diesel Boy"})
+    ].extend(P::Debug).(nil, {represented: song_model, binding: artist, doc: doc, options: {}}).must_equal({"name" => "Diesel Boy"})
 
     doc.must_equal({"artist"=>{"name"=>"Diesel Boy"}})
   end
@@ -135,13 +134,12 @@ class PipelineTest < MiniTest::Spec
       R::ReadFragment,
       R::StopOnNotFound,
       R::OverwriteOnNil,
-      # R::SkipParse,
       R::AssignFragment,
-      R::CreateObject,
+      R::CreateObject::Class,
       R::Decorate,
       R::Deserialize,
       R::SetValue,
-    ].extend(P::Debug).(doc={"artist"=>{"name"=>"Doobie Brothers"}}, {represented: song_model, binding: artist, doc: doc, user_options: {}}).must_equal model=Artist.new("Doobie Brothers")
+    ].extend(P::Debug).(doc={"artist"=>{"name"=>"Doobie Brothers"}}, {represented: song_model, binding: artist, doc: doc, options: {}}).must_equal model=Artist.new("Doobie Brothers")
     song_model.artist.must_equal model
   end
 
@@ -149,7 +147,7 @@ class PipelineTest < MiniTest::Spec
   ######### collection :ratings
 
   let (:ratings) {
-    dfn = R::Definition.new(:ratings, collection: true)
+    dfn = R::Definition.new(:ratings, collection: true, skip_render: ->(*) { false })
 
     R::Hash::Binding::Collection.new(dfn)
   }
@@ -163,7 +161,7 @@ class PipelineTest < MiniTest::Spec
       ],
       R::AssignName,
       R::WriteFragment
-    ].extend(P::Debug).(nil, {represented: Album.new([1,2,3]), binding: ratings, doc: doc}).must_equal([1,2,3])
+    ].extend(P::Debug).(nil, {represented: Album.new([1,2,3]), binding: ratings, doc: doc, options: {}}).must_equal([1,2,3])
 
     doc.must_equal({"ratings"=>[1,2,3]})
   end
@@ -180,13 +178,12 @@ class PipelineTest < MiniTest::Spec
       R::GetValue,
       R::StopOnSkipable,
       R::Collect[
-        R::SkipRender,
         R::Decorate,
         R::Serialize,
       ],
       R::AssignName,
       R::WriteFragment
-    ].extend(P::Debug).(nil, {represented: Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]), binding: artists, doc: doc, user_options: {}}).must_equal([{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}])
+    ].extend(P::Debug).(nil, {represented: Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]), binding: artists, doc: doc, options: {}}).must_equal([{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}])
 
     doc.must_equal({"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]})
   end
@@ -203,13 +200,12 @@ let (:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van H
       # R::SkipParse,
       R::Collect[
         R::AssignFragment,
-        R::SkipRender,
-        R::CreateObject,
+        R::CreateObject::Class,
         R::Decorate,
         R::Deserialize,
       ],
       R::SetValue,
-    ].extend(P::Debug).(doc, {represented: album_model, binding: artists, doc: doc, user_options: {}}).must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
+    ].extend(P::Debug).(doc, {represented: album_model, binding: artists, doc: doc, options: {}}).must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
 
     album_model.artists.must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
   end

data/test/prepare_test.rb

@@ -18,10 +18,9 @@ class PrepareTest < BaseTest
   describe "#to_hash" do # TODO: introduce :representable option?
     representer! do
       property :song,
-        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
+        :prepare       => lambda { |options| options[:binding][:arbitrary].new(options[:input]) },
         :arbitrary     => PreparerClass,
         :extend => true,
-        :pass_options  => true,
         :representable => false # don't call #to_hash.
     end
 
@@ -47,7 +46,7 @@ class PrepareTest < BaseTest
   describe "#from_hash" do
     representer! do
       property :song,
-        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
+        :prepare       => lambda { |options| options[:binding][:arbitrary].new(options[:input]) },
         :arbitrary     => PreparerClass,
         #:extend => true, # TODO: typed: true would be better.
         :instance => String.new, # pass_fragment

data/test/reader_writer_test.rb

@@ -3,14 +3,14 @@ require 'test_helper'
 class ReaderWriterTest < BaseTest
   representer! do
     property :name,
-      :writer => lambda { |doc, args| doc["title"] = "#{args[:nr]}) #{name}" },
-      :reader => lambda { |doc, args| self.name = doc["title"].split(") ").last }
+      :writer => lambda { |options| options[:doc]["title"] = "#{options[:user_options][:nr]}) #{options[:input]}" },
+      :reader => lambda { |options| self.name = options[:doc]["title"].split(") ").last }
   end
 
   subject { OpenStruct.new(:name => "Disorder And Disarray").extend(representer) }
 
   it "uses :writer when rendering" do
-    subject.to_hash(:nr => 14).must_equal({"title" => "14) Disorder And Disarray"})
+    subject.to_hash(user_options: {nr: 14}).must_equal({"title" => "14) Disorder And Disarray"})
   end
 
   it "uses :reader when parsing" do

data/test/representable_test.rb

@@ -222,19 +222,6 @@ 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
-      assert_equal nil, @band.groupies
-    end
-
-    it "accepts :include option" do
-      @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.from_hash("name" => "Iron Maiden", "groupies" => 2, "founders" => ["Steve Harris"])
@@ -292,23 +279,23 @@ class RepresentableTest < MiniTest::Spec
 
           property :length, class: OpenStruct do
             def to_hash(options)
-              {seconds: options[:nr]}
+              {seconds: options[:user_options][:nr]}
             end
 
             def from_hash(hash, options)
               super.tap do
-                self.seconds = options[:nr]
+                self.seconds = options[:user_options][:nr]
               end
             end
           end
 
           def to_hash(options)
-            super.merge({"nr" => options[:nr]})
+            super.merge({"nr" => options[:user_options][:nr]})
           end
 
           def from_hash(data, options)
             super.tap do
-              self.nr = options[:nr]
+              self.nr = options[:user_options][:nr]
             end
           end
         end
@@ -316,11 +303,11 @@ class RepresentableTest < MiniTest::Spec
 
       it "#to_hash propagates to nested objects" do
         OpenStruct.new(track: OpenStruct.new(nr: 1, length: OpenStruct.new(seconds: nil))).extend(representer).extend(Representable::Debug).
-          to_hash(nr: 9).must_equal({"track"=>{"nr"=>9, "length"=>{seconds: 9}}})
+          to_hash(user_options: {nr: 9}).must_equal({"track"=>{"nr"=>9, "length"=>{seconds: 9}}})
       end
 
       it "#from_hash propagates to nested objects" do
-        song = OpenStruct.new.extend(representer).from_hash({"track"=>{"nr" => "replace me", "length"=>{"seconds"=>"replacing"}}}, :nr => 9)
+        song = OpenStruct.new.extend(representer).from_hash({"track"=>{"nr" => "replace me", "length"=>{"seconds"=>"replacing"}}}, user_options: {nr: 9})
         song.track.nr.must_equal 9
         song.track.length.seconds.must_equal 9
       end
@@ -338,16 +325,6 @@ class RepresentableTest < MiniTest::Spec
       assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.to_hash)
     end
 
-    it "accepts :exclude option" do
-      hash = @band.to_hash({:exclude => [:groupies]})
-      assert_equal({"name"=>"No One's Choice"}, hash)
-    end
-
-    it "accepts :include option" do
-      hash = @band.to_hash({:include => [:groupies]})
-      assert_equal({"groupies"=>2}, hash)
-    end
-
     it "ignores non-readable properties" do
       @band = Class.new(Band) { property :name; collection :founder_ids, :readable => false; attr_accessor :founder_ids }.new
       @band.name = "Iron Maiden"
@@ -366,19 +343,6 @@ class RepresentableTest < MiniTest::Spec
       @band.groupies = false
       assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.to_hash)
     end
-
-    it "does not propagate private options to nested objects" do
-      cover_rpr = Module.new do
-        include Representable::Hash
-        property :title
-        property :original, :extend => self
-      end
-
-      # FIXME: we should test all representable-options (:include, :exclude, ?)
-
-      Class.new(OpenStruct).new(:title => "Roxanne", :original => Class.new(OpenStruct).new(:title => "Roxanne (Don't Put On The Red Light)")).extend(cover_rpr).
-        to_hash(:include => [:original]).must_equal({"original"=>{"title"=>"Roxanne (Don't Put On The Red Light)"}})
-    end
   end
 
 
@@ -427,7 +391,7 @@ class RepresentableTest < MiniTest::Spec
 
     describe "property with :extend" do
       representer! do
-        property :name, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
+        property :name, :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
       end
 
       it "uses lambda when rendering" do
@@ -442,8 +406,8 @@ class RepresentableTest < MiniTest::Spec
 
       describe "with :class lambda" do
         representer! do
-          property :name, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
-                          :class  => lambda { |fragment, *| fragment == "Still Failing?" ? String : UpcaseString }
+          property :name, :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
+                          :class  => lambda { |options| options[:fragment] == "Still Failing?" ? String : UpcaseString }
         end
 
         it "creates instance from :class lambda when parsing" do
@@ -461,7 +425,7 @@ class RepresentableTest < MiniTest::Spec
 
     describe "collection with :extend" do
       representer! do
-        collection :songs, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
+        collection :songs, :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
       end
 
       it "uses lambda for each item when rendering" do
@@ -475,8 +439,8 @@ class RepresentableTest < MiniTest::Spec
 
       describe "with :class lambda" do
         representer! do
-          collection :songs,  :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
-                              :class  => lambda { |fragment, *| fragment == "Still Failing?" ? String : UpcaseString }
+          collection :songs,  :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
+                              :class  => lambda { |options| options[:input] == "Still Failing?" ? String : UpcaseString }
         end
 
         it "creates instance from :class lambda for each item when parsing" do

data/test/serialize_deserialize_test.rb

@@ -6,28 +6,28 @@ class SerializeDeserializeTest < BaseTest
   describe "deserialize" do
     representer! do
       property :song,
-        :instance => lambda { |fragment, *| fragment.to_s.upcase },
-        :prepare  => lambda { |fragment, *| fragment },
-        :deserialize => lambda { |object, fragment, args|
-          "#{object} #{fragment} #{args.inspect}"
+        :instance => lambda { |options| options[:input].to_s.upcase },
+        :prepare  => lambda { |options| options[:input] },
+        :deserialize => lambda { |options|
+          "#{options[:input]} #{options[:fragment]} #{options[:user_options].inspect}"
         }
     end
 
-    it { subject.from_hash({"song" => Object}, {:volume => 9}).song.must_equal "OBJECT Object {:volume=>9}" }
+    it { subject.from_hash({"song" => Object}, user_options: {volume: 9}).song.must_equal "OBJECT Object {:volume=>9}" }
   end
 
   describe "serialize" do
     representer! do
       property :song,
         :representable => true,
-        :prepare  => lambda { |fragment, *| fragment },
-        :serialize => lambda { |object, args|
-          "#{object} #{args.inspect}"
+        :prepare  => lambda { |options| options[:fragment] },
+        :serialize => lambda { |options|
+          "#{options[:input]} #{options[:user_options].inspect}"
         }
     end
 
     before { subject.song = "Arrested In Shanghai" }
 
-    it { subject.to_hash({:volume => 9}).must_equal({"song"=>"Arrested In Shanghai {:volume=>9}"}) }
+    it { subject.to_hash(user_options: {volume: 9}).must_equal({"song"=>"Arrested In Shanghai {:volume=>9}"}) }
   end
 end