representable 2.4.1 → 3.0.0

data/test-with-deprecations/parse_strategy_test.rb

@@ -1,279 +0,0 @@
-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

data/test-with-deprecations/pass_options_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-class PassOptionsTest < BaseTest
-  let (:format) { :hash }
-  let (:song) { Struct.new(:title).new("Revolution") }
-  let (:prepared) { representer.prepare song }
-
-  describe "module" do
-    representer! do
-      property :title, :pass_options => true,
-        :as => lambda { |args| [args.binding.name, args.user_options, args.represented, args.decorator]  }
-    end
-
-    it { render(prepared, :volume => 1).must_equal_document({["title", {:volume=>1}, prepared, prepared] => "Revolution"}) }
-    # it { parse(prepared, {"args" => "Wie Es Geht"}).name.must_equal "Wie Es Geht" }
-  end
-
-  describe "decorator" do
-    representer!(:decorator => true) do
-      property :title, :pass_options => true,
-        :as => lambda { |args| [args.binding.name, args.user_options, args.represented, args.decorator]  }
-    end
-
-    it { render(prepared, :volume => 1).must_equal_document({["title", {:volume=>1}, song, prepared] => "Revolution"}) }
-    # it { parse(prepared, {"args" => "Wie Es Geht"}).name.must_equal "Wie Es Geht" }
-  end
-end

data/test-with-deprecations/pipeline_test.rb

@@ -1,277 +0,0 @@
-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