representable 2.4.1 → 3.0.0

data/test-with-deprecations/filter_test.rb

@@ -1,57 +0,0 @@
-require 'test_helper'
-
-class FilterPipelineTest < MiniTest::Spec
-  let (:block1) { lambda { |input, options| "1: #{input}" } }
-  let (:block2) { lambda { |input, options| "2: #{input}" } }
-
-  subject { Representable::Pipeline[block1, block2] }
-
-  it { subject.call("Horowitz", {}).must_equal "2: 1: Horowitz" }
-end
-
-
-class FilterTest < MiniTest::Spec
-  representer! do
-    property :title
-
-    property :track,
-      :parse_filter  => lambda { |input, options| "#{input.downcase},#{options[:doc]}" },
-      :render_filter => lambda { |val, options| "#{val.upcase},#{options[:doc]},#{options[:options][:user_options]}" }
-  end
-
-  # gets doc and options.
-  it {
-    song = OpenStruct.new.extend(representer).from_hash("title" => "VULCAN EARS", "track" => "Nine")
-    song.title.must_equal "VULCAN EARS"
-    song.track.must_equal "nine,{\"title\"=>\"VULCAN EARS\", \"track\"=>\"Nine\"}"
-  }
-
-  it { OpenStruct.new("title" => "vulcan ears", "track" => "Nine").extend(representer).to_hash.must_equal( {"title"=>"vulcan ears", "track"=>"NINE,{\"title\"=>\"vulcan ears\"},{}"}) }
-
-
-  describe "#parse_filter" do
-    representer! do
-      property :track,
-        :parse_filter => [
-          lambda { |input, options| "#{input}-1" },
-          lambda { |input, options| "#{input}-2" }],
-        :render_filter => [
-          lambda { |val, options| "#{val}-1" },
-          lambda { |val, options| "#{val}-2" }]
-    end
-
-    # order matters.
-    it { OpenStruct.new.extend(representer).from_hash("track" => "Nine").track.must_equal "Nine-1-2" }
-    it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
-  end
-end
-
-
-# class RenderFilterTest < MiniTest::Spec
-#   representer! do
-#     property :track, :render_filter => [lambda { |val, options| "#{val}-1" } ]
-#     property :track, :render_filter => [lambda { |val, options| "#{val}-2" } ], :inherit => true
-#   end
-
-#   it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
-# end

data/test-with-deprecations/for_collection_test.rb

@@ -1,74 +0,0 @@
-require 'test_helper'
-
-class ForCollectionTest < MiniTest::Spec
-  module SongRepresenter
-    include Representable::JSON
-
-    property :name
-  end
-
-  let (:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
-  let (:json)  { "[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]" }
-
-
-  # Module.for_collection
-  # Decorator.for_collection
-  for_formats(
-    :hash => [Representable::Hash, out=[{"name" => "Days Go By"}, {"name"=>"Can't Take Them All"}], out],
-    :json => [Representable::JSON, out="[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]", out],
-    # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
-  ) do |format, mod, output, input|
-
-    describe "Module::for_collection [#{format}]" do
-      let (:format) { format }
-
-      let (:representer) {
-        Module.new do
-          include mod
-          property :name#, :as => :title
-
-          collection_representer :class => Song
-
-          # self.representation_wrap = :songs if format == :xml
-        end
-      }
-
-      it { render(songs.extend(representer.for_collection)).must_equal_document output }
-      it { render(representer.for_collection.prepare(songs)).must_equal_document output }
-      # parsing needs the class set, at least
-      it { parse([].extend(representer.for_collection), input).must_equal songs }
-    end
-
-    describe "Module::for_collection without configuration [#{format}]" do
-      let (:format) { format }
-
-      let (:representer) {
-        Module.new do
-          include mod
-          property :name
-        end
-      }
-
-      # rendering works out of the box, no config necessary
-      it { render(songs.extend(representer.for_collection)).must_equal_document output }
-    end
-
-
-    describe "Decorator::for_collection [#{format}]" do
-      let (:format) { format }
-      let (:representer) {
-        Class.new(Representable::Decorator) do
-          include mod
-          property :name
-
-          collection_representer :class => Song
-        end
-      }
-
-      it { render(representer.for_collection.new(songs)).must_equal_document output }
-      it { parse(representer.for_collection.new([]), input).must_equal songs }
-    end
-  end
-
-  # with module including module
-end

data/test-with-deprecations/generic_test.rb

@@ -1,116 +0,0 @@
-require 'test_helper'
-
-class GenericTest < MiniTest::Spec # TODO: rename/restructure to CollectionTest.
-  let (:new_album)  { OpenStruct.new.extend(representer) }
-  let (:album)      { OpenStruct.new(:songs => ["Fuck Armageddon"]).extend(representer) }
-  let (:song) { OpenStruct.new(:title => "Resist Stance") }
-  let (:song_representer) { Module.new do include Representable::Hash; property :title end  }
-
-
-  describe "::collection" do
-    representer! do
-      collection :songs
-    end
-
-    it "doesn't initialize property" do
-      new_album.from_hash({})
-      new_album.songs.must_equal nil
-    end
-
-    it "leaves properties untouched" do
-      album.from_hash({})
-      # TODO: test property.
-      album.songs.must_equal ["Fuck Armageddon"] # when the collection is not present in the incoming hash, this propery stays untouched.
-    end
-
-
-    # when collection is nil, it doesn't get rendered:
-    for_formats(
-      :hash => [Representable::Hash, {}],
-      :xml  => [Representable::XML, "<open_struct></open_struct>"],
-      :yaml => [Representable::YAML, "--- {}\n"], # FIXME: this doesn't look right.
-    ) do |format, mod, output, input|
-
-      describe "nil collections" do
-        let (:format) { format }
-
-        representer!(:module => mod) do
-          collection :songs
-          self.representation_wrap = :album if format == :xml
-        end
-
-        let (:album) { Album.new.extend(representer) }
-
-        it "doesn't render collection in #{format}" do
-          render(album).must_equal_document output
-        end
-      end
-    end
-
-    # when collection is set but empty, render the empty collection.
-    for_formats(
-      :hash => [Representable::Hash, {"songs" => []}],
-      #:xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
-      :yaml => [Representable::YAML, "---\nsongs: []\n"],
-    ) do |format, mod, output, input|
-
-      describe "empty collections" do
-        let (:format) { format }
-
-        representer!(:module => mod) do
-          collection :songs
-          self.representation_wrap = :album if format == :xml
-        end
-
-        let (:album) { OpenStruct.new(:songs => []).extend(representer) }
-
-        it "renders empty collection in #{format}" do
-          render(album).must_equal_document output
-        end
-      end
-    end
-
-
-    # when collection is [], suppress rendering when render_empty: false.
-    for_formats(
-      :hash => [Representable::Hash, {}],
-      #:xml  => [Representable::XML, "<open_struct><songs/></open_struct>"],
-      :yaml => [Representable::YAML, "--- {}\n"],
-    ) do |format, mod, output, input|
-
-      describe "render_empty [#{format}]" do
-        let (:format) { format }
-
-        representer!(:module => mod) do
-          collection :songs, :render_empty => false
-          self.representation_wrap = :album if format == :xml
-        end
-
-        let (:album) { OpenStruct.new(:songs => []).extend(representer) }
-
-        it { render(album).must_equal_document output }
-      end
-    end
-  end
-
-
-  # wrap_test
-  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}] with wrap where wrap is missing" do
-      representer!(:module => mod) do
-        self.representation_wrap = :song
-
-        property :title
-      end
-
-      it "doesn't change represented object" do
-        song.extend(representer).send("from_#{format}", input).title.must_equal "Resist Stance"
-      end
-    end
-  end
-end

data/test-with-deprecations/getter_setter_test.rb

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

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

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