representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/inherit_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+class InheritTest < MiniTest::Spec
+  module SongRepresenter # it's important to have a global module so we can test if stuff gets overridden in the original module.
+    include Representable::Hash
+    property :name, :as => :title do
+      property :string, :as => :str
+    end
+
+    property :track, :as => :no
+  end
+
+  let (:song) { Song.new(Struct.new(:string).new("Roxanne"), 1) }
+
+  describe ":inherit plain property" do
+    representer! do
+      include SongRepresenter
+
+      property :track, :inherit => true, :getter => lambda { |*| "n/a" }
+    end
+
+    it { SongRepresenter.prepare(song).to_hash.must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>1}) }
+    it { representer.prepare(song).to_hash.must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>"n/a"}) } # as: inherited.
+  end
+
+  describe ":inherit with empty inline representer" do
+    representer! do
+      include SongRepresenter
+
+      property :name, :inherit => true do # inherit as: title
+        # that doesn't make sense.
+      end
+    end
+
+    it { SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    # the block doesn't override the inline representer.
+    it { representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+  end
+
+  describe ":inherit with overriding inline representer" do
+    representer! do
+      include SongRepresenter
+
+      puts "passing block"
+      property :name, :inherit => true do # inherit as: title
+        property :string, :as => :s
+        property :length
+      end
+    end
+
+    it { representer.prepare( Song.new(Struct.new(:string, :length).new("Believe It", 10), 1)).to_hash.must_equal({"title"=>{"s"=>"Believe It","length"=>10}, "no"=>1}) }
+  end
+
+  describe ":inherit with empty inline and options" do
+    representer! do
+      include SongRepresenter
+
+      property :name, inherit: true, as: :name do # inherit module, only.
+        # that doesn't make sense. but it should simply inherit the old nested properties.
+      end
+    end
+
+    it { SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
+  end
+
+  describe ":inherit with inline without block but options" do
+    representer! do
+      include SongRepresenter
+
+      property :name, :inherit => true, :as => :name # FIXME: add :getter or something else dynamic since this is double-wrapped.
+    end
+
+    it { SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it { representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
+  end
+
+
+
+  # no :inherit
+  describe "overwriting without :inherit" do
+    representer! do
+      include SongRepresenter
+
+      property :track, :representable => true
+    end
+
+    it "replaces inherited property" do
+      representer.representable_attrs.size.must_equal 2
+
+      definition = representer.representable_attrs.get(:track) # TODO: find a better way to assert Definition identity.
+      # definition.keys.size.must_equal 2
+      definition[:representable].   must_equal true
+      definition.name.must_equal "track" # was "no".
+    end
+  end
+
+
+  # decorator
+  describe ":inherit with decorator" do
+    representer!(:decorator => true) do
+      property :hit do
+        property :title, exec_context: :decorator
+
+        def title
+          "Cheap Transistor Radio"
+        end
+      end
+    end
+
+    let (:inheriting) {
+      class InheritingDecorator < representer
+        include Representable::Debug
+        property :hit, :inherit => true do
+          include Representable::Debug
+          property :length
+        end
+        self
+      end
+    }
+
+    it { representer.new(OpenStruct.new(hit: OpenStruct.new(title: "I WILL BE OVERRIDDEN", :length => "2:59"))).to_hash.must_equal(
+      {"hit"=>{"title"=>"Cheap Transistor Radio"}}) }
+
+    # inheriting decorator inherits inline representer class (InlineRepresenter#title).
+    # inheriting decorator adds :length.
+    it { inheriting.new(OpenStruct.new(:hit => OpenStruct.new(:title => "Hole In Your Soul", :length => "2:59"))).to_hash.must_equal(
+      {"hit"=>{"title"=>"Cheap Transistor Radio", "length"=>"2:59"}}) }
+  end
+
+
+  # :inherit when property doesn't exist, yet.
+  describe ":inherit without inheritable property" do
+    representer! do
+      property :name, :inherit => true
+    end
+
+    it { representer.prepare(Song.new("The Beginning")).to_hash.must_equal({"name"=>"The Beginning"})}
+  end
+end
+
+
+# class InheritancingTest < MiniTest::Spec
+#   class SongDecorator < Representable::Decorator
+#     include Representable::Hash
+#     property :album do
+#       # does have Hash.
+#       property :title
+#     end
+#   end
+
+#   class JsonSongDecorator < SongDecorator
+#     include Representable::XML
+#   end
+
+#   it do
+#     puts JsonSongDecorator.new(OpenStruct.new(:album => OpenStruct.new(:title => "Erotic Cakes", :tracks => nil))).to_xml
+#   end
+# end

data/test-with-deprecations/inline_test.rb

@@ -0,0 +1,272 @@
+require 'test_helper'
+
+class InlineTest < MiniTest::Spec
+  let (:song)    { Song.new("Alive") }
+  let (:request) { representer.prepare(OpenStruct.new(:song => song)) }
+
+  {
+    :hash => [Representable::Hash, {"song"=>{"name"=>"Alive"}}, {"song"=>{"name"=>"You've Taken Everything"}}],
+    :json => [Representable::JSON, "{\"song\":{\"name\":\"Alive\"}}", "{\"song\":{\"name\":\"You've Taken Everything\"}}"],
+    :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song>/open_struct>"],
+    :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
+  }.each do |format, cfg|
+    mod, output, input = cfg
+
+    describe "[#{format}] with :class" do
+      representer!(:module => mod) do
+        property :song, :class => Song do
+          property :name
+        end
+      end
+
+      let (:format) { format }
+
+      it { render(request).must_equal_document output }
+      it { parse(request, input).song.name.must_equal "You've Taken Everything"}
+    end
+  end
+
+  {
+    :hash => [Representable::Hash, {"songs"=>[{"name"=>"Alive"}]}, {"songs"=>[{"name"=>"You've Taken Everything"}]}],
+    :json => [Representable::JSON, "{\"songs\":[{\"name\":\"Alive\"}]}", "{\"songs\":[{\"name\":\"You've Taken Everything\"}]}"],
+    :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song></open_struct>", { :as => :song }],
+    :yaml => [Representable::YAML, "---\nsongs:\n- name: Alive\n", "---\nsongs:\n- name: You've Taken Everything\n"],
+  }.each do |format, cfg|
+    mod, output, input, collection_options = cfg
+    collection_options ||= {}
+
+    describe "[#{format}] collection with :class" do
+      let (:request) { representer.prepare(OpenStruct.new(:songs => [song])) }
+
+      representer!(:module => mod) do
+        collection :songs, collection_options.merge(:class => Song) do
+          property :name
+        end
+      end
+
+      let (:format) { format } # FIXME: why do we have to define this?
+
+      it { render(request).must_equal_document output }
+      it { parse(request, input).songs.first.name.must_equal "You've Taken Everything"}
+    end
+  end
+
+  describe "without :class" do
+    representer! do
+      property :song do
+        property :name
+      end
+    end
+
+    it { request.to_hash.must_equal({"song"=>{"name"=>"Alive"}}) }
+  end
+
+
+  for_formats(
+    :hash => [Representable::Hash, {}],
+    # :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song>/open_struct>"],
+    # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
+  ) do |format, mod, input|
+
+    describe "parsing [#{format}] where nested property missing" do
+      representer!(:module => mod) do
+        property :song do
+          property :name
+        end
+      end
+
+      it "doesn't change represented object" do
+        request.send("from_#{format}", input).song.must_equal song
+      end
+    end
+  end
+
+
+  describe "inheriting from outer representer" do
+    let (:request) { Struct.new(:song, :requester).new(song, "Josephine") }
+
+    [false, true].each do |is_decorator| # test for module and decorator.
+      representer!(:decorator => is_decorator) do
+        property :requester
+
+        property :song, :class => Song do
+          property :name
+        end
+      end
+
+      let (:decorator) { representer.prepare(request) }
+
+      it { decorator.to_hash.must_equal({"requester"=>"Josephine", "song"=>{"name"=>"Alive"}}) }
+      it { decorator.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name.must_equal "You've Taken Everything"}
+    end
+  end
+
+  describe "object pollution" do
+    representer!(:decorator => true) do
+      property :song do
+        property :name
+      end
+    end
+
+    it "uses an inline decorator and doesn't alter represented" do
+      representer.prepare(Struct.new(:song).new(song)).to_hash
+      song.wont_be_kind_of Representable
+    end
+  end
+
+  # TODO: should be in extend:/decorator: test.
+  # FIXME: this tests :getter{represented}+:extend - represented gets extended twice and the inline decorator overrides original config.
+  # for_formats(
+  #   :hash => [Representable::Hash, {"album" => {"artist" => {"label"=>"Epitaph"}}}],
+  #   # :xml  => [Representable::XML, "<open_struct></open_struct>"],
+  #   #:yaml => [Representable::YAML, "---\nlabel:\n  label: Epitaph\n  owner: Brett Gurewitz\n"]
+  # ) do |format, mod, output, input|
+
+  #   module ArtistRepresenter
+  #     include Representable::JSON
+  #     property :label
+  #   end
+
+  #   describe ":getter with inline representer" do
+  #     let (:format) { format }
+
+  #     representer!(:module => mod) do
+  #       self.representation_wrap = :album
+
+  #       property :artist, :getter => lambda { |args| represented }, :extend => ArtistRepresenter
+  #     end
+
+  #     let (:album) { OpenStruct.new(:label => "Epitaph").extend(representer) }
+
+  #     it "renders nested Album-properties in separate section" do
+  #       render(album).must_equal_document output
+  #     end
+  #   end
+  # end
+
+
+  for_formats({
+      :hash => [Representable::Hash, {"album" => {"artist" => {"label"=>"Epitaph"}}}],
+      # :xml  => [Representable::XML, "<open_struct></open_struct>"],
+      #:yaml => [Representable::YAML, "---\nlabel:\n  label: Epitaph\n  owner: Brett Gurewitz\n"]
+    }) do |format, mod, output, input|
+
+    class ArtistDecorator < Representable::Decorator
+      include Representable::JSON
+      property :label
+    end
+
+    describe ":getter with :decorator" do
+      let (:format) { format }
+
+      representer!(:module => mod) do
+        self.representation_wrap = "album"
+
+        property :artist, :getter => lambda { |args| represented }, :decorator => ArtistDecorator
+      end
+
+      let (:album) { OpenStruct.new(:label => "Epitaph").extend(representer) }
+
+      it "renders nested Album-properties in separate section" do
+        render(album).must_equal_document output
+      end
+    end
+  end
+
+
+  # test helper methods within inline representer
+  for_formats({
+    :hash => [Representable::Hash, {"song"=>{"name"=>"ALIVE"}}],
+    :xml  => [Representable::XML, "<request>\n  <song>\n    <name>ALIVE</name>\n  </song>\n</request>"],
+    :yaml => [Representable::YAML, "---\nsong:\n  name: ALIVE\n"],
+  }) do |format, mod, output|
+
+    describe "helper method within inline representer [#{format}]" do
+      let (:format) { format }
+
+      representer!(:module => mod, :decorator => true) do
+        self.representation_wrap = :request if format == :xml
+
+        property :requester
+        property :song do
+          property :name, :exec_context => :decorator
+
+          define_method :name do
+            represented.name.upcase
+          end
+
+          self.representation_wrap = :song if format == :xml
+        end
+      end
+
+      let (:request) { representer.prepare(OpenStruct.new(:song => Song.new("Alive"))) }
+
+      it do
+        render(request).must_equal_document output
+      end
+    end
+  end
+
+
+  describe "include module in inline representers" do
+    representer! do
+      extension = Module.new do
+        include Representable::Hash
+        property :title
+      end
+
+      property :song do
+        include extension
+        property :artist
+      end
+    end
+
+    it do OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
+      to_hash.
+      must_equal({"song"=>{"artist"=>"Strung Out", "title"=>"The Fever And The Sound"}})
+    end
+  end
+
+
+  # define method in inline representer
+  describe "define method in inline representer" do
+    Mod = Module.new do
+      include Representable::Hash
+
+      def song
+        "Object.new"
+      end
+
+      property :song do
+        property :duration
+
+        def duration
+          "6:53"
+        end
+      end
+    end
+
+    it { Object.new.extend(Mod).to_hash.must_equal("song"=>{"duration"=>"6:53"}) }
+  end
+
+  # define method inline with Decorator
+  describe "define method inline with Decorator" do
+    dec = Class.new(Representable::Decorator) do
+      include Representable::Hash
+
+      def song
+        "Object.new"
+      end
+
+      property :song, :exec_context => :decorator do
+        property :duration, :exec_context => :decorator
+
+        def duration
+          "6:53"
+        end
+      end
+    end
+
+    it { dec.new(Object.new).to_hash.must_equal("song"=>{"duration"=>"6:53"}) }
+  end
+end

data/test-with-deprecations/instance_test.rb

@@ -0,0 +1,266 @@
+require 'test_helper'
+
+class InstanceTest < BaseTest
+  Song = Struct.new(:id, :title)
+  Song.class_eval do
+    def self.find(id)
+      new(id, "Invincible")
+    end
+  end
+
+  describe "lambda { fragment } (new way of class: lambda { nil })" do
+    representer! do
+      property :title, :instance  => lambda { |fragment, args| fragment }
+    end
+
+    it "skips creating new instance" do
+      object = Object.new
+      object.instance_eval do
+        def from_hash(hash, *args)
+          hash
+        end
+      end
+
+      song = OpenStruct.new.extend(representer).from_hash(hash = {"title" => object})
+      song.title.must_equal object
+    end
+  end
+
+
+# TODO: use *args in from_hash.
+# DISCUSS: do we need parse_strategy?
+  describe "property with :instance" do
+    representer!(:inject => :song_representer) do
+      property :song,
+        :instance => lambda { |fragment, *args| fragment["id"] == song.id ? song : Song.find(fragment["id"]) },
+        :extend => song_representer
+    end
+
+    it( "xxx") { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash("song" => {"id" => 1}).song.must_equal Song.new(1, "The Answer Is Still No") }
+
+    it { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash("song" => {"id" => 2}).song.must_equal Song.new(2, "Invincible") }
+  end
+
+
+  describe "collection with :instance" do
+    representer!(:inject => :song_representer) do
+      collection :songs,
+        :instance => lambda { |fragment, i, *args|
+          fragment["id"] == songs[i].id ? songs[i] : Song.find(fragment["id"])
+        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+
+        :extend => song_representer
+    end
+
+    it {
+      album= Struct.new(:songs).new(songs = [
+      Song.new(1, "The Answer Is Still No"),
+      Song.new(2, "")])
+
+      album.
+        extend(representer).
+        from_hash("songs" => [{"id" => 2},{"id" => 2, "title"=>"The Answer Is Still No"}]).songs.must_equal [
+          Song.new(2, "Invincible"), Song.new(2, "The Answer Is Still No")]
+    }
+  end
+
+  describe "property with lambda receiving fragment and args" do
+    representer!(:inject => :song_representer) do
+      property :song, :instance => lambda { |fragment, args| Struct.new(:args, :id).new([fragment, args]) }, :extend => song_representer
+    end
+
+    it { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+      from_hash({"song" => {"id" => 1}}, {:volume => 1}).song.args.must_equal([{"id"=>1}, {:volume=>1}]) }
+  end
+
+  # TODO: raise and test instance:{nil}
+  # describe "property with instance: { nil }" do # TODO: introduce :representable option?
+  #   representer!(:inject => :song_representer) do
+  #     property :song, :instance => lambda { |*| nil }, :extend => song_representer
+  #   end
+
+  #   let (:hit) { hit = OpenStruct.new(:song => song).extend(representer) }
+
+  #   it "calls #to_hash on song instance, nothing else" do
+  #     hit.to_hash.must_equal("song"=>{"title"=>"Resist Stance"})
+  #   end
+
+  #   it "calls #from_hash on the existing song instance, nothing else" do
+  #     song_id = hit.song.object_id
+  #     hit.from_hash("song"=>{"title"=>"Suffer"})
+  #     hit.song.title.must_equal "Suffer"
+  #     hit.song.object_id.must_equal song_id
+  #   end
+  # end
+
+  # lambda { |fragment, i, Context(binding: <..>, args: [..])| }
+
+  describe "sync" do
+    representer!(:inject => :song_representer) do
+      collection :songs,
+        :instance => lambda { |fragment, i, *args|
+          songs[i]
+        },
+        :extend => song_representer,
+        # :parse_strategy => :sync
+        :setter => lambda { |*|  }
+    end
+
+    it {
+      album= Struct.new(:songs).new(songs = [
+      Song.new(1, "The Answer Is Still No"),
+      Song.new(2, "Invncble")])
+
+      album.
+        extend(representer).
+        from_hash("songs" => [{"title" => "The Answer Is Still No"}, {"title" => "Invincible"}])
+
+      album.songs.must_equal [
+        Song.new(1, "The Answer Is Still No"),
+        Song.new(2, "Invincible")]
+
+      songs.object_id.must_equal album.songs.object_id
+      songs[0].object_id.must_equal album.songs[0].object_id
+      songs[1].object_id.must_equal album.songs[1].object_id
+    }
+  end
+
+  describe "update existing elements, only" do
+    representer!(:inject => :song_representer) do
+      collection :songs,
+        :instance => lambda { |fragment, i, *args|
+
+          #fragment["id"] == songs[i].id ? songs[i] : Song.find(fragment["id"])
+          songs.find { |s| s.id == fragment["id"] }
+        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+
+        :extend => song_representer,
+        # :parse_strategy => :sync
+        :setter => lambda { |*|  }
+    end
+
+    it("hooray") {
+      album= Struct.new(:songs).new(songs = [
+      Song.new(1, "The Answer Is Still No"),
+      Song.new(2, "Invncble")])
+
+      album.
+        extend(representer).
+        from_hash("songs" => [{"id" => 2, "title" => "Invincible"}]).
+        songs.must_equal [
+          Song.new(1, "The Answer Is Still No"),
+          Song.new(2, "Invincible")]
+          # TODO: check elements object_id!
+
+      songs.object_id.must_equal album.songs.object_id
+      songs[0].object_id.must_equal album.songs[0].object_id
+      songs[1].object_id.must_equal album.songs[1].object_id
+    }
+  end
+
+
+  describe "add incoming elements, only" do
+    representer!(:inject => :song_representer) do
+      collection :songs,
+        :instance => lambda { |fragment, i, *args|
+          songs << song=Song.new(2)
+          song
+        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+
+        :extend => song_representer,
+        # :parse_strategy => :sync
+        :setter => lambda { |*|  }
+    end
+
+    it {
+      album= Struct.new(:songs).new(songs = [
+        Song.new(1, "The Answer Is Still No")])
+
+      album.
+        extend(representer).
+        from_hash("songs" => [{"title" => "Invincible"}]).
+        songs.must_equal [
+          Song.new(1, "The Answer Is Still No"),
+          Song.new(2, "Invincible")]
+
+      songs.object_id.must_equal album.songs.object_id
+      songs[0].object_id.must_equal album.songs[0].object_id
+    }
+  end
+
+
+  # not sure if this must be a library strategy
+  describe "replace existing element" do
+    representer!(:inject => :song_representer) do
+      collection :songs,
+        :instance => lambda { |fragment, i, *args|
+          id = fragment.delete("replace_id")
+          replaced = songs.find { |s| s.id == id }
+          songs[songs.index(replaced)] = song=Song.new(3)
+          song
+        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+
+        :extend => song_representer,
+        # :parse_strategy => :sync
+        :setter => lambda { |*|  }
+    end
+
+    it {
+      album= Struct.new(:songs).new(songs = [
+        Song.new(1, "The Answer Is Still No"),
+        Song.new(2, "Invincible")])
+
+      album.
+        extend(representer).
+        from_hash("songs" => [{"replace_id"=>2, "id" => 3, "title" => "Soulmate"}]).
+        songs.must_equal [
+          Song.new(1, "The Answer Is Still No"),
+          Song.new(3, "Soulmate")]
+
+      songs.object_id.must_equal album.songs.object_id
+      songs[0].object_id.must_equal album.songs[0].object_id
+    }
+  end
+
+
+  describe "replace collection" do
+    representer!(:inject => :song_representer) do
+      collection :songs,
+        :extend => song_representer, :class => Song
+    end
+
+    it {
+      album= Struct.new(:songs).new(songs = [
+        Song.new(1, "The Answer Is Still No")])
+
+      album.
+        extend(representer).
+        from_hash("songs" => [{"title" => "Invincible"}]).
+        songs.must_equal [
+          Song.new(nil, "Invincible")]
+
+      songs.object_id.wont_equal album.songs.object_id
+    }
+  end
+
+
+  describe "new syntax for instance: true" do
+    representer!(:inject => :song_representer) do
+      property :song, :pass_options => true,
+        :extend => song_representer, :instance => lambda { |fragment, args| args.binding.get(represented: args.represented) }
+    end
+
+    it "uses Binding#get instead of creating an instance, but deprecates" do
+      album= Struct.new(:song).new(song = Song.new(1, "The Answer Is Still No"))
+
+      album.
+        extend(representer).
+        from_hash("song" => {"title" => "Invincible"}).
+        song.must_equal Song.new(1, "Invincible")
+
+      album.song.object_id.must_equal song.object_id
+    end
+  end
+end