representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/pipeline_test.rb

@@ -0,0 +1,277 @@
+require "test_helper"
+
+class PipelineTest < MiniTest::Spec
+  Song   = Struct.new(:title, :artist)
+  Artist = Struct.new(:name)
+  Album  = Struct.new(:ratings, :artists)
+
+  R = Representable
+  P = R::Pipeline
+
+  Getter        = ->(input, options) { "Yo" }
+  StopOnNil     = ->(input, options) { input }
+  SkipRender    = ->(input, *) { input == "Yo" ? input : P::Stop }
+
+  Prepare       = ->(input, options) { "Prepare(#{input})" }
+  Deserialize   = ->(input, options) { "Deserialize(#{input}, #{options[:fragment]})" }
+
+  SkipParse     = ->(input, options) { input }
+  CreateObject  = ->(input, options) { OpenStruct.new }
+
+
+  Setter        = ->(input, options) { "Setter(#{input})" }
+
+  AssignFragment = ->(input, options) { options[:fragment] = input }
+
+  it "linear" do
+    P[SkipParse, Setter].("doc", {fragment: 1}).must_equal "Setter(doc)"
+
+
+    # parse style.
+    P[AssignFragment, SkipParse, CreateObject, Prepare].("Bla", {}).must_equal "Prepare(#<OpenStruct>)"
+
+
+    # render style.
+    P[Getter, StopOnNil, SkipRender, Prepare, Setter].(nil, {}).
+      must_equal "Setter(Prepare(Yo))"
+
+    # pipeline = Representable::Pipeline[SkipParse  , SetResult, ModifyResult]
+    # pipeline.(fragment: "yo!").must_equal "modified object from yo!"
+  end
+
+  Stopping      = ->(input, options) { return P::Stop if options[:fragment] == "stop!"; input }
+
+
+  it "stopping" do
+
+
+    pipeline = Representable::Pipeline[SkipParse, Stopping, Prepare]
+    pipeline.(nil, fragment: "oy!").must_equal "Prepare()"
+    pipeline.(nil, fragment: "stop!").must_equal Representable::Pipeline::Stop
+  end
+
+  describe "Collect" do
+    Reverse = ->(input, options) { input.reverse }
+    Add = ->(input, options) { "#{input}+" }
+    let(:pipeline) { R::Collect[Reverse, Add] }
+
+    it { pipeline.(["yo!", "oy!"], {}).must_equal ["!oy+", "!yo+"] }
+
+    describe "Pipeline with Collect" do
+      let(:pipeline) { P[Reverse, R::Collect[Reverse, Add]] }
+      it { pipeline.(["yo!", "oy!"], {}).must_equal ["!yo+", "!oy+"] }
+    end
+  end
+
+
+
+
+  ######### scalar property
+
+  let (:title) {
+    dfn = R::Definition.new(:title)
+
+    R::Hash::Binding.new(dfn)
+  }
+
+  it "rendering scalar property" do
+    doc = {}
+    P[
+      R::GetValue,
+      R::StopOnSkipable,
+      R::AssignName,
+      R::WriteFragment
+    ].(nil, {represented: Song.new("Lime Green"), binding: title, doc: doc}).must_equal "Lime Green"
+
+    doc.must_equal({"title"=>"Lime Green"})
+  end
+
+  it "parsing scalar property" do
+    P[
+      R::AssignName,
+      R::ReadFragment,
+      R::StopOnNotFound,
+      R::OverwriteOnNil,
+      # R::SkipParse,
+      R::SetValue,
+    ].extend(P::Debug).(doc={"title"=>"Eruption"}, {represented: song=Song.new("Lime Green"), binding: title, doc: doc}).must_equal "Eruption"
+    song.title.must_equal "Eruption"
+  end
+
+
+
+  module ArtistRepresenter
+    include Representable::Hash
+    property :name
+  end
+
+  let (:artist) {
+    dfn = R::Definition.new(:artist, extend: ArtistRepresenter, class: Artist)
+
+    R::Hash::Binding.new(dfn)
+  }
+
+  let (:song_model) { Song.new("Lime Green", Artist.new("Diesel Boy")) }
+
+  it "rendering typed property" do
+    doc = {}
+    P[
+      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, options: {}}).must_equal({"name" => "Diesel Boy"})
+
+    doc.must_equal({"artist"=>{"name"=>"Diesel Boy"}})
+  end
+
+  it "parsing typed property" do
+    P[
+      R::AssignName,
+      R::ReadFragment,
+      R::StopOnNotFound,
+      R::OverwriteOnNil,
+      # R::SkipParse,
+      R::AssignFragment,
+      R::CreateObject::Class,
+      R::Decorate,
+      R::Deserialize,
+      R::SetValue,
+    ].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
+
+
+  ######### collection :ratings
+
+  let (:ratings) {
+    dfn = R::Definition.new(:ratings, collection: true)
+
+    R::Hash::Binding::Collection.new(dfn)
+  }
+  it "render scalar collection" do
+    doc = {}
+    P[
+      R::GetValue,
+      R::StopOnSkipable,
+      R::Collect[
+        R::SkipRender,
+      ],
+      R::AssignName,
+      R::WriteFragment
+    ].extend(P::Debug).(nil, {represented: Album.new([1,2,3]), binding: ratings, doc: doc}).must_equal([1,2,3])
+
+    doc.must_equal({"ratings"=>[1,2,3]})
+  end
+
+######### collection :songs, extend: SongRepresenter
+  let (:artists) {
+    dfn = R::Definition.new(:artists, collection: true, extend: ArtistRepresenter, class: Artist)
+
+    R::Hash::Binding::Collection.new(dfn)
+  }
+  it "render typed collection" do
+    doc = {}
+    P[
+      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, options: {}}).must_equal([{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}])
+
+    doc.must_equal({"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]})
+  end
+
+let (:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]) }
+
+  it "parse typed collection" do
+    doc = {"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]}
+    P[
+      R::AssignName,
+      R::ReadFragment,
+      R::StopOnNotFound,
+      R::OverwriteOnNil,
+      # R::SkipParse,
+      R::Collect[
+        R::AssignFragment,
+        R::SkipRender,
+        R::CreateObject::Class,
+        R::Decorate,
+        R::Deserialize,
+      ],
+      R::SetValue,
+    ].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
+
+  # TODO: test with arrays, too, not "only" Pipeline instances.
+  describe "#Insert Pipeline[], Function, replace: OldFunction" do
+    let (:pipeline) { P[R::GetValue, R::StopOnSkipable, R::StopOnNil] }
+
+    it "returns Pipeline instance when passing in Pipeline instance" do
+      P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).must_be_instance_of(R::Pipeline)
+    end
+
+    it "replaces if exists" do
+      # pipeline.insert!(R::Default, replace: R::StopOnSkipable)
+      P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).must_equal P[R::GetValue, R::Default, R::StopOnNil]
+      pipeline.must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
+    end
+
+    it "replaces Function instance" do
+      pipeline = P[R::Prepare, R::StopOnSkipable, R::StopOnNil]
+      P::Insert.(pipeline, R::Default, replace: R::Prepare).must_equal P[R::Default, R::StopOnSkipable, R::StopOnNil]
+      pipeline.must_equal P[R::Prepare, R::StopOnSkipable, R::StopOnNil]
+    end
+
+    it "does not replace when not existing" do
+      P::Insert.(pipeline, R::Default, replace: R::Prepare)
+      pipeline.must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
+    end
+
+    it "applies on nested Collect" do
+      pipeline = P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil]
+
+      P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
+      pipeline.must_equal P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil]
+
+
+      P::Insert.(pipeline, R::Default, replace: R::StopOnNil).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], Default]"
+    end
+
+    it "applies on nested Collect with Function::CreateObject" do
+      pipeline = P[R::GetValue, R::Collect[R::GetValue, R::CreateObject], R::StopOnNil]
+
+      P::Insert.(pipeline, R::Default, replace: R::CreateObject).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
+      pipeline.must_equal P[R::GetValue, R::Collect[R::GetValue, R::CreateObject], R::StopOnNil]
+    end
+  end
+
+  describe "Insert.(delete: true)" do
+    let(:pipeline) { P[R::GetValue, R::StopOnNil] }
+
+    it do
+      P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect.must_equal "Pipeline[StopOnNil]"
+      pipeline.extend(P::Debug).inspect.must_equal "Pipeline[GetValue, StopOnNil]"
+    end
+  end
+
+  describe "Insert.(delete: true) with Collect" do
+    let(:pipeline) { P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil] }
+
+    it do
+      P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect.must_equal "Pipeline[Collect[StopOnSkipable], StopOnNil]"
+      pipeline.extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], StopOnNil]"
+    end
+  end
+end

data/test-with-deprecations/populator_test.rb

@@ -0,0 +1,105 @@
+require "test_helper"
+
+class PopulatorTest < Minitest::Spec
+  Song   = Struct.new(:id)
+  Artist = Struct.new(:name)
+  Album  = Struct.new(:songs, :artist)
+
+  describe "populator: ->{}" do
+    representer! do
+      collection :songs, populator: ->(input, options) { options[:represented].songs << song = Song.new; song } do
+        property :id
+      end
+
+      property :artist, populator: ->(input, options) { options[:represented].artist = Artist.new } do
+        property :name
+      end
+    end
+
+    let (:album) { Album.new([]) }
+
+    it do
+      album.extend(representer).from_hash("songs"=>[{"id"=>1}, {"id"=>2}], "artist"=>{"name"=>"Waste"})
+      album.inspect.must_equal "#<struct PopulatorTest::Album songs=[#<struct PopulatorTest::Song id=1>, #<struct PopulatorTest::Song id=2>], artist=#<struct PopulatorTest::Artist name=\"Waste\">>"
+    end
+  end
+
+  describe "populator: ->{}, " do
+
+  end
+end
+
+class PopulatorFindOrInstantiateTest < Minitest::Spec
+  Song = Struct.new(:id, :title, :uid) do
+    def self.find_by(attributes={})
+      return new(1, "Resist Stan", "abcd") if attributes[:id]==1# we should return the same object here
+      new
+    end
+  end
+
+  Composer = Struct.new(:song)
+  Composer.class_eval do
+    def song=(v)
+      @song = v
+      "Absolute nonsense" # this tests that the populator always returns the correct object.
+    end
+
+    attr_reader :song
+  end
+
+  describe "FindOrInstantiate with property" do
+    representer! do
+      property :song, populator: Representable::FindOrInstantiate, class: Song do
+        property :id
+        property :title
+      end
+    end
+
+    let (:album) { Composer.new.extend(representer).extend(Representable::Debug) }
+
+    it "finds by :id and creates new without :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
+      album.song.uid.must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
+    end
+
+    it "creates new without :id" do
+      album.from_hash({"song"=>{"title"=>"Lower"}})
+
+      album.song.title.must_equal "Lower"
+      album.song.id.must_equal nil
+      album.song.uid.must_equal nil
+    end
+  end
+
+  describe "FindOrInstantiate with collection" do
+    representer! do
+      collection :songs, populator: Representable::FindOrInstantiate, class: Song do
+        property :id
+        property :title
+      end
+    end
+
+    let (:album) { Struct.new(:songs).new([]).extend(representer) }
+
+    it "finds by :id and creates new without :id" do
+      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[0].uid.must_equal "abcd" # not changed via populator, indicating this is a formerly "persisted" object.
+
+      album.songs[1].title.must_equal "Suffer"
+      album.songs[1].id.must_equal nil
+      album.songs[1].uid.must_equal nil
+    end
+
+    # TODO: test with existing collection
+  end
+
+end

data/test-with-deprecations/prepare_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class PrepareTest < BaseTest
+  class PreparerClass
+    def initialize(object)
+      @object = object
+    end
+
+    def ==(b)
+      return unless b.instance_of?(PreparerClass)
+
+      object == b.object
+    end
+
+    attr_reader :object
+  end
+
+  describe "#to_hash" do # TODO: introduce :representable option?
+    representer! do
+      property :song,
+        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
+        :arbitrary     => PreparerClass,
+        :extend => true,
+        :pass_options  => true,
+        :representable => false # don't call #to_hash.
+    end
+
+    let (:hit) { Struct.new(:song).new(song).extend(representer) }
+
+    it "calls prepare:, nothing else" do
+      # render(hit).must_equal_document(output)
+      hit.to_hash.must_equal({"song" => PreparerClass.new(song)})
+    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
+
+
+  describe "#from_hash" do
+    representer! do
+      property :song,
+        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
+        :arbitrary     => PreparerClass,
+        #:extend => true, # TODO: typed: true would be better.
+        :instance => String.new, # pass_fragment
+        :pass_options  => true,
+        :representable => false # don't call #to_hash.
+    end
+
+    let (:hit) { Struct.new(:song).new.extend(representer) }
+
+    it "calls prepare:, nothing else" do
+      # render(hit).must_equal_document(output)
+      hit.from_hash("song" => {})
+
+      hit.song.must_equal(PreparerClass.new(String.new))
+    end
+  end
+end