representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/getter_setter_test.rb

@@ -0,0 +1,21 @@
+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 "uses :setter when parsing" do
+    subject.instance_eval { def name=(*); raise; end; self }
+    subject.from_hash({"name" => "Eyes Without A Face"}, :welcome => "Hello").song_name.must_equal "Hello Eyes Without A Face"
+  end
+end

data/test-with-deprecations/hash_bindings_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class HashBindingTest < MiniTest::Spec
+  module SongRepresenter
+    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::Binding.new(Representable::Definition.new(:song))
+      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"}, "song")
+        assert_equal "", @property.read({"song" => ""}, "song")
+        assert_equal nil, @property.read({"song" => nil}, "song")
+      end
+
+      it "returns FRAGMENT_NOT_FOUND if not in document" do
+        assert_equal Representable::Binding::FragmentNotFound, @property.read({}, "song")
+      end
+
+    end
+  end
+
+
+  describe "CollectionBinding" do
+    describe "with plain text items" do
+      before do
+        @property = Representable::Hash::Binding::Collection.new(Representable::Definition.new(:songs, :collection => true))
+      end
+
+      it "extracts with #read" do
+        assert_equal ["The Gargoyle", "Bronx"], @property.read({"songs" => ["The Gargoyle", "Bronx"]}, "songs")
+      end
+
+      it "inserts with #write" do
+        doc = {}
+        assert_equal(["The Gargoyle", "Bronx"], @property.write(doc, ["The Gargoyle", "Bronx"], "songs"))
+        assert_equal({"songs"=>["The Gargoyle", "Bronx"]}, doc)
+      end
+    end
+  end
+
+
+
+
+  describe "HashBinding" do
+    describe "with plain text items" do
+      before do
+        @property = Representable::Hash::Binding.new(Representable::Definition.new(:songs, :hash => true))
+      end
+
+      it "extracts with #read" do
+        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"} , @property.read({"songs" => {"first" => "The Gargoyle", "second" => "Bronx"}}, "songs"))
+      end
+
+      it "inserts with #write" do
+        doc = {}
+        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"}, @property.write(doc, {"first" => "The Gargoyle", "second" => "Bronx"}, "songs"))
+        assert_equal({"songs"=>{"first" => "The Gargoyle", "second" => "Bronx"}}, doc)
+      end
+    end
+
+    describe "with objects" do
+      before do
+        @property = Representable::Hash::Binding.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter))
+      end
+
+      it "doesn't change the represented hash in #write" do
+        song = Song.new("Better Than That")
+        hash = {"first" => song}
+        @property.write({}, hash, "song")
+        assert_equal({"first" => song}, hash)
+      end
+    end
+
+  end
+end

data/test-with-deprecations/hash_test.rb

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+class HashWithScalarPropertyTest < MiniTest::Spec
+  Album = Struct.new(:title)
+
+  representer! do
+    property :title
+  end
+
+  let (:album) { Album.new("Liar") }
+
+  describe "#to_hash" do
+    it "renders plain property" do
+      album.extend(representer).to_hash.must_equal("title" => "Liar")
+    end
+  end
+
+
+  describe "#from_hash" do
+    it "parses plain property" do
+      album.extend(representer).from_hash("title" => "This Song Is Recycled").title.must_equal "This Song Is Recycled"
+    end
+
+    # Fixes issue #115
+    it "allows nil value in the incoming document and corresponding nil value for the represented" do
+      album = Album.new
+      album.title.must_equal nil
+      album.extend(representer).from_hash("title" => nil)
+    end
+  end
+end
+
+
+class HashWithTypedPropertyTest < MiniTest::Spec
+  Album = Struct.new(:best_song)
+
+  representer! do
+    property :best_song, :class => Song do
+      property :name
+    end
+  end
+
+  let (:album) { Album.new(Song.new("Liar")) }
+
+  describe "#to_hash" do
+    it "renders embedded typed property" do
+      album.extend(representer).to_hash.must_equal("best_song" => {"name" => "Liar"})
+    end
+  end
+
+  describe "#from_hash" do
+    it "parses embedded typed property" do
+      album.extend(representer).from_hash("best_song" => {"name" => "Go With Me"})
+      album.best_song.name.must_equal "Go With Me"
+    end
+
+    # nested nil removes nested object.
+    it do
+      album = Album.new(Song.new("Pre-medicated Murder"))
+      album.extend(representer).from_hash("best_song" => nil)
+      album.best_song.must_equal nil
+    end
+
+    # nested blank hash creates blank object when not populated.
+    it do
+      album = Album.new#(Song.new("Pre-medicated Murder"))
+      album.extend(representer).from_hash("best_song" => {})
+      album.best_song.name.must_equal nil
+    end
+
+    # Fixes issue #115
+    it "allows nil value in the incoming document and corresponding nil value for the represented" do
+      album = Album.new
+      album.extend(representer).from_hash("best_song" => nil)
+      album.best_song.must_equal nil
+    end
+  end
+end
+
+# TODO: move to AsTest.
+class HashWithTypedPropertyAndAs < MiniTest::Spec
+  representer! do
+    property :song, :class => Song, :as => :hit do
+      property :name
+    end
+  end
+
+  let (:album) { OpenStruct.new(:song => Song.new("Liar")).extend(representer) }
+
+  it { album.to_hash.must_equal("hit" => {"name" => "Liar"}) }
+  it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
+end
+  #   # describe "FIXME COMBINE WITH ABOVE with :extend and :as" do
+  #   #   hash_song = Module.new do
+  #   #     include Representable::XML
+  #   #     self.representation_wrap = :song
+  #   #     property :name
+  #   #   end
+
+  #   #   let (:hash_album) { Module.new do
+  #   #     include Representable::XML
+  #   #     self.representation_wrap = :album
+  #   #     property :song, :extend => hash_song, :class => Song, :as => :hit
+  #   #   end }
+
+  #   #   let (:album) { OpenStruct.new(:song => Song.new("Liar")).extend(hash_album) }
+
+  #   #   it { album.to_xml.must_equal_xml("<album><hit><name>Liar</name></hit></album>") }
+  #   #   #it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
+  #   # end
+  # end
+
+
+
+class HashWithTypedCollectionTest < MiniTest::Spec
+  Album = Struct.new(:songs)
+
+  representer! do
+    collection :songs, class: Song do
+      property :name
+      property :track
+    end
+  end
+
+  let (:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
+
+  describe "#to_hash" do
+    it "renders collection of typed property" do
+      album.extend(representer).to_hash.must_equal("songs" => [{"name" => "Liar", "track" => 1}, {"name" => "What I Know", "track" => 2}])
+    end
+  end
+
+  describe "#from_hash" do
+    it "parses collection of typed property" do
+      album.extend(representer).from_hash("songs" => [{"name" => "One Shot Deal", "track" => 4},
+        {"name" => "Three Way Dance", "track" => 5}]).must_equal Album.new([Song.new("One Shot Deal", 4), Song.new("Three Way Dance", 5)])
+    end
+  end
+end
+
+class HashWithScalarCollectionTest < MiniTest::Spec
+  Album = Struct.new(:songs)
+  representer! { collection :songs }
+
+  let (:album) { Album.new(["Jackhammer", "Terrible Man"]) }
+
+
+  describe "#to_hash" do
+    it "renders a block style list per default" do
+      album.extend(representer).to_hash.must_equal("songs" => ["Jackhammer", "Terrible Man"])
+    end
+  end
+
+
+  describe "#from_hash" do
+    it "parses a block style list" do
+      album.extend(representer).from_hash("songs" => ["Off Key Melody", "Sinking"]).must_equal Album.new(["Off Key Melody", "Sinking"])
+    end
+  end
+end

data/test-with-deprecations/heritage_test.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+class HeritageTest < Minitest::Spec
+  module Hello
+    def hello
+      puts "Hello!"
+    end
+  end
+    module Ciao
+    def ciao
+      puts "Ciao!"
+    end
+  end
+
+
+  class A < Representable::Decorator
+    include Representable::Hash
+
+    feature Hello
+
+    property :id do
+    end
+  end
+
+  class B < A
+    feature Ciao # does NOT extend id, of course.
+
+    property :id, inherit: true do
+
+    end
+  end
+
+  class C < A
+    property :id do end # overwrite old :id.
+  end
+
+  it do
+    # puts A.heritage.inspect
+    # puts B.heritage.inspect
+
+    puts B.representable_attrs.get(:id)[:extend].(nil).new(nil).hello
+    puts B.representable_attrs.get(:id)[:extend].(nil).new(nil).ciao
+
+    # feature Hello must be "inherited" from A and included in new C properties, too.
+    puts C.representable_attrs.get(:id)[:extend].(nil).new(nil).hello
+  end
+
+  module M
+    include Representable
+    feature Hello
+  end
+
+  module N
+    include Representable
+    include M
+    feature Ciao
+  end
+
+  it do
+    Object.new.extend(N).hello
+  end
+end

data/test-with-deprecations/if_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class IfTest < MiniTest::Spec
+  let (:band_class) { Class.new do
+    include Representable::Hash
+    attr_accessor :fame
+    self
+  end }
+
+  it "respects property when condition true" do
+    band_class.class_eval { property :fame, :if => lambda { |*| true } }
+    band = band_class.new
+    band.from_hash({"fame"=>"oh yes"})
+    assert_equal "oh yes", band.fame
+  end
+
+  it "ignores property when condition false" do
+    band_class.class_eval { property :fame, :if => lambda { |*| false } }
+    band = band_class.new
+    band.from_hash({"fame"=>"oh yes"})
+    assert_equal nil, band.fame
+  end
+
+  it "ignores property when :exclude'ed even when condition is true" do
+    band_class.class_eval { property :fame, :if => lambda { |*| true } }
+    band = band_class.new
+    band.from_hash({"fame"=>"oh yes"}, {:exclude => [:fame]})
+    assert_equal nil, band.fame
+  end
+
+  it "executes block in instance context" do
+    band_class.class_eval { property :fame, :if => lambda { |*| groupies }; attr_accessor :groupies }
+    band = band_class.new
+    band.groupies = true
+    band.from_hash({"fame"=>"oh yes"})
+    assert_equal "oh yes", band.fame
+  end
+
+  describe "executing :if lambda in represented instance context" do
+    representer! do
+      property :label, :if => lambda { |*| signed_contract }
+    end
+
+    subject { OpenStruct.new(:signed_contract => false, :label => "Fat") }
+
+    it "skips when false" do
+      subject.extend(representer).to_hash.must_equal({})
+    end
+
+    it "represents when true" do
+      subject.signed_contract= true
+      subject.extend(representer).to_hash.must_equal({"label"=>"Fat"})
+    end
+
+    it "works with decorator" do
+      rpr = representer
+      Class.new(Representable::Decorator) do
+        include Representable::Hash
+        include rpr
+      end.new(subject).to_hash.must_equal({})
+    end
+  end
+
+
+  describe "propagating user options to the block" do
+    representer! do
+      property :name, :if => lambda { |opts| opts[:include_name] }
+    end
+    subject { OpenStruct.new(:name => "Outbound").extend(representer) }
+
+    it "works without specifying options" do
+      subject.to_hash.must_equal({})
+    end
+
+    it "passes user options to block" do
+      subject.to_hash(:include_name => true).must_equal({"name" => "Outbound"})
+    end
+  end
+end

data/test-with-deprecations/include_exclude_test.rb

@@ -0,0 +1,88 @@
+require "test_helper"
+
+class IncludeExcludeTest < Minitest::Spec
+  Song   = Struct.new(:title, :artist, :id)
+  Artist = Struct.new(:name, :id, :songs)
+
+  representer!(decorator: true) do
+    property :title
+    property :artist, class: Artist do
+      property :name
+      property :id
+
+      collection :songs, class: Song do
+        property :title
+        property :id
+      end
+    end
+  end
+
+  let (:song) { Song.new("Listless", Artist.new("7yearsbadluck", 1  )) }
+  let (:decorator) { representer.new(song) }
+
+  describe "#from_hash" do
+    it "accepts :exclude option" do
+      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, exclude: [:title])
+
+      song.title.must_equal "Listless"
+      song.artist.must_equal Artist.new(nil, 2)
+    end
+
+    it "accepts :include option" do
+      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, include: [:title])
+
+      song.title.must_equal "Don't Smile In Trouble"
+      song.artist.must_equal Artist.new("7yearsbadluck", 1)
+    end
+
+    it "accepts nested :exclude/:include option" do
+      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"name"=>"Foo", "id"=>2, "songs"=>[{"id"=>1, "title"=>"Listless"}]}},
+        exclude: [:title],
+        artist: {
+          exclude: [:id],
+          songs: { include: [:title] }
+        }
+      )
+
+      song.title.must_equal "Listless"
+      song.artist.must_equal Artist.new("Foo", nil, [Song.new("Listless", nil, nil)])
+    end
+  end
+
+  describe "#to_hash" do
+    it "accepts :exclude option" do
+      decorator.to_hash(exclude: [:title]).must_equal({"artist"=>{"name"=>"7yearsbadluck", "id"=>1}})
+    end
+
+    it "accepts :include option" do
+      decorator.to_hash(include: [:title]).must_equal({"title"=>"Listless"})
+    end
+
+    it "accepts nested :exclude/:include option" do
+      decorator = representer.new(Song.new("Listless", Artist.new("7yearsbadluck", 1, [Song.new("C.O.A.B.I.E.T.L.")])))
+
+      decorator.to_hash(
+        exclude: [:title],
+        artist: {
+          exclude: [:id],
+          songs: { include: [:title] }
+        }
+      ).must_equal({"artist"=>{"name"=>"7yearsbadluck", "songs"=>[{"title"=>"C.O.A.B.I.E.T.L."}]}})
+    end
+  end
+
+  it "xdoes not propagate private options to nested objects" do
+    Cover = Struct.new(:title, :original)
+
+    cover_rpr = Module.new do
+      include Representable::Hash
+      property :title
+      property :original, extend: self
+    end
+
+    # FIXME: we should test all representable-options (:include, :exclude, ?)
+
+    Cover.new("Roxanne", Cover.new("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