representable 2.4.1 → 3.0.0

data/test-with-deprecations/heritage_test.rb

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

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

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

data/test-with-deprecations/inherit_test.rb

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

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