representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/mongoid_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+require 'mongoid'
+require 'mongoid/document'
+
+class MongoidTest < MiniTest::Spec
+  describe "Mongoid compatibility" do
+    it "allows #to_json" do
+      class Profile
+        include Mongoid::Document
+        field :name
+      end
+      
+      class Dude
+        include Mongoid::Document
+        embeds_one :profile, :class_name => "MongoidTest::Profile"
+      end
+      
+      module ProfileRepresenter
+       include Representable::JSON
+
+       property :name
+      end
+
+      dude = Dude.new
+      dude.profile = Profile.new
+      dude.profile.name = "Kofi"
+      
+      assert_equal "{\"name\":\"Kofi\"}", dude.profile.extend(ProfileRepresenter).to_json
+    end      
+  end
+end

data/test-with-deprecations/nested_test.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+class NestedTest < MiniTest::Spec
+	Album = Struct.new(:label, :owner, :amount)
+
+	for_formats(
+    :hash => [Representable::Hash, {"label" => {"label"=>"Epitaph", "owner"=>"Brett Gurewitz", "releases"=>{"amount"=>19}}}],
+    # :xml  => [Representable::XML, "<open_struct></open_struct>"],
+    :yaml => [Representable::YAML, "---\nlabel:\n  label: Epitaph\n  owner: Brett Gurewitz\n  releases:\n    amount: 19\n"]
+  ) do |format, mod, output, input|
+
+    [false, true].each do |is_decorator|
+      describe "::nested with (inline representer|decorator): #{is_decorator}" do
+        let (:format) { format }
+
+        representer!(:module => mod, :decorator => is_decorator) do
+          nested :label do
+            property :label
+            property :owner
+
+            # self.representation_wrap = nil if format == :xml
+            nested :releases do
+              property :amount
+            end
+          end
+
+          # self.representation_wrap = :album if format == :xml
+        end
+
+        let (:album) { Album.new("Epitaph", "Brett Gurewitz", 19) }
+        let (:decorator) { representer.prepare(album) }
+
+        it "renders nested Album-properties in separate section" do
+          render(decorator).must_equal_document output
+
+          # do not use extend on the nested object. # FIXME: make this a proper test with two describes instead of this pseudo-meta stuff.
+          if is_decorator==true
+            album.wont_be_kind_of(Representable::Hash)
+          end
+        end
+
+        it "parses nested properties to Album instance" do
+          album = parse(representer.prepare(Album.new), output)
+          album.label.must_equal "Epitaph"
+          album.owner.must_equal "Brett Gurewitz"
+        end
+      end
+    end
+
+
+    describe "Decorator ::nested with extend:" do
+      let (:format) { format }
+
+      representer!(:name => :label_rpr) do
+      	include mod
+      	property :label
+        property :owner
+
+        nested :releases do # DISCUSS: do we need to test this?
+          property :amount
+        end
+      end
+
+      representer!(:module => mod, :decorator => true, :inject => :label_rpr) do
+        nested :label, :extend => label_rpr
+
+        self.representation_wrap = :album if format == :xml
+      end
+
+      let (:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
+
+      # TODO: shared example with above.
+      it "renders nested Album-properties in separate section" do
+        render(album).must_equal_document output
+      end
+
+      it "parses nested properties to Album instance" do
+      	album = parse(representer.prepare(Album.new), output)
+      	album.label.must_equal "Epitaph"
+      	album.owner.must_equal "Brett Gurewitz"
+        album.amount.must_equal 19
+      end
+    end
+  end
+
+
+  describe "::nested without block but with inherit:" do
+
+    representer!(:name => :parent) do
+      include Representable::Hash
+
+      nested :label do
+        property :owner
+      end
+    end
+
+    representer!(:module => Representable::Hash, :inject => :parent) do
+      include parent
+      nested :label, :inherit => true, :as => "Label"
+    end
+
+    let (:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
+
+    it "renders nested Album-properties in separate section" do
+      representer.prepare(album).to_hash.must_equal({"Label"=>{"owner"=>"Brett Gurewitz"}})
+    end
+
+    # it "parses nested properties to Album instance" do
+    #   album = parse(representer.prepare(Album.new), output)
+    #   album.label.must_equal "Epitaph"
+    #   album.owner.must_equal "Brett Gurewitz"
+    #   album.amount.must_equal 19
+    # end
+  end
+end

data/test-with-deprecations/object_test.rb

@@ -0,0 +1,60 @@
+require "test_helper"
+require "representable/object"
+
+class ObjectTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album)
+  Album = Struct.new(:name, :songs)
+
+  representer!(module: Representable::Object) do
+    property :title
+
+    property :album, instance: lambda { |fragment, *| fragment.name.upcase!; fragment } do
+      property :name
+
+      collection :songs, instance: lambda { |fragment, *| fragment.title.upcase!; fragment } do
+        property :title
+      end
+    end
+    # TODO: collection
+  end
+
+  let (:source) { Song.new("The King Is Dead", Album.new("Ruiner", [Song.new("In Vino Veritas II")])) }
+  let (:target) { Song.new }
+
+  it do
+    representer.prepare(target).from_object(source)
+
+    target.title.must_equal "The King Is Dead"
+    target.album.name.must_equal "RUINER"
+    target.album.songs[0].title.must_equal "IN VINO VERITAS II"
+  end
+
+  # ignore nested object when nil
+  it do
+    representer.prepare(Song.new("The King Is Dead")).from_object(Song.new)
+
+    target.title.must_equal nil # scalar property gets overridden when nil.
+    target.album.must_equal nil # nested property stays nil.
+  end
+
+  # to_object
+  describe "#to_object" do
+    representer!(module: Representable::Object) do
+      property :title
+
+      property :album, render_filter: lambda { |object, *| object.name = "Live"; object } do
+        property :name
+
+        collection :songs, render_filter: lambda { |object, *| object[0].title = 1; object } do
+          property :title
+        end
+      end
+    end
+
+    it do
+      representer.prepare(source).to_object
+      source.album.name.must_equal "Live"
+      source.album.songs[0].title.must_equal 1
+    end
+  end
+end

data/{test/---deserialize-pipeline_test.rb → test-with-deprecations/parse_pipeline_test.rb}

@@ -1,10 +1,37 @@
 require "test_helper"
 
-class DeserializePipelineTest < MiniTest::Spec
-  Album  = Struct.new(:artist, :songs)
+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

data/test-with-deprecations/parse_strategy_test.rb

@@ -0,0 +1,279 @@
+require 'test_helper'
+
+# parse_strategy: :sync
+# parse_strategy: :replace
+# parse_strategy: :find_or_instantiate ("expand" since we don't delete existing unmatched in target)
+
+
+class ParseStrategySyncTest < BaseTest
+  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
+
+
+  # Sync errors, when model and incoming are not in sync.
+  describe ":sync with error" do
+    representer! do
+      property :song, :parse_strategy => :sync do
+        property :title
+      end
+    end
+
+    # object.song is nil whereas the document contains one.
+    it do
+      assert_raises Representable::DeserializeError do
+        OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Perpetual"}})
+      end
+    end
+  end
+
+
+
+  # Lonely 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
+end
+
+
+class ParseStrategyFindOrInstantiateTest < BaseTest
+  # parse_strategy: :find_or_instantiate
+
+  Song = Struct.new(:id, :title)
+  Song.class_eval do
+    def self.find_by(attributes={})
+      return new(1, "Resist Stan") if attributes[:id]==1# we should return the same object here
+      new
+    end
+  end
+
+  representer!(:name => :song_representer) do
+    property :title
+  end
+
+
+  describe "collection" do
+    representer!(:inject => :song_representer) do
+      collection :songs, :parse_strategy => :find_or_instantiate, :extend => song_representer, :class => Song
+    end
+
+    let (:album) { Struct.new(:songs).new([]).extend(representer) }
+
+
+    it "replaces the existing collection with a new consisting of existing items or new items" do
+      songs_id = album.songs.object_id
+
+      album.from_hash({"songs"=>[{"id" => 1, "title"=>"Resist Stance"}, {"title"=>"Suffer"}]})
+
+      album.songs[0].title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      album.songs[0].id.must_equal 1
+      album.songs[1].title.must_equal "Suffer"
+      album.songs[1].id.must_equal nil
+
+      album.songs.object_id.wont_equal songs_id
+    end
+
+    # TODO: test with existing collection
+  end
+
+
+  describe "property" do
+    representer!(:inject => :song_representer) do
+      property :song, :parse_strategy => :find_or_instantiate, :extend => song_representer, :class => Song
+    end
+
+    let (:album) { Struct.new(:song).new.extend(representer) }
+
+
+    it "finds song by id" do
+      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance"}})
+
+      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      album.song.id.must_equal 1
+    end
+
+    it "creates song" do
+      album.from_hash({"song"=>{"title"=>"Off The Track"}})
+
+      album.song.title.must_equal "Off The Track"
+      album.song.id.must_equal nil
+    end
+  end
+
+
+  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"] }
+    end
+
+    let (:album) { Struct.new(:song).new.extend(representer) }
+
+
+    it "finds song by id" do
+      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance", "class"=>Song}})
+
+      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      album.song.id.must_equal 1
+    end
+  end
+end
+
+
+class ParseStrategyLambdaTest < MiniTest::Spec
+  Song = Struct.new(:id, :title)
+  Song.class_eval do
+    def self.find_by(attributes={})
+      return new(1, "Resist Stan") if attributes[:id]==1# we should return the same object here
+      new
+    end
+  end
+
+  representer!(:name => :song_representer) do
+    property :title
+  end
+
+  # property with instance: lambda, using representable's setter. # TODO: that should be handled better via my api.
+  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".
+        :representable => false # don't call object.from_hash
+    end
+
+    let (:song) { Song.new(nil, nil) }
+    it { song.extend(representer).from_hash("title" => 8675309).title.must_equal "8675309" }
+  end
+
+
+  describe "collection" do
+    representer!(:inject => :song_representer) do
+      collection :songs, :parse_strategy => lambda { |fragment, i, options|
+        songs << song = Song.new
+        song
+      }, :extend => song_representer
+    end
+
+    let (:album) { Struct.new(:songs).new([Song.new(1, "A Walk")]).extend(representer) }
+
+
+    it "adds to existing collection" do
+      songs_id = album.songs.object_id
+
+      album.from_hash({"songs"=>[{"title"=>"Resist Stance"}]})
+
+      album.songs[0].title.must_equal "A Walk" # note how title is updated from "Resist Stan"
+      album.songs[0].id.must_equal 1
+      album.songs[1].title.must_equal "Resist Stance"
+      album.songs[1].id.must_equal nil
+
+      album.songs.object_id.must_equal songs_id
+    end
+
+    # TODO: test with existing collection
+  end
+end