representable 2.4.1 → 3.0.0

data/test-with-deprecations/lonely_test.rb

@@ -1,239 +0,0 @@
-require 'test_helper'
-
-require 'representable/json/hash'
-
-class LonelyRepresenterTest < MiniTest::Spec
-
-  # test ::items without arguments, render-only.
-  for_formats(
-    :hash => [Representable::Hash::Collection, [{"name"=>"Resist Stance"}, {"name"=>"Suffer"}]],
-    :json => [Representable::JSON::Collection, "[{\"name\":\"Resist Stance\"},{\"name\":\"Suffer\"}]"],
-    :xml  => [Representable::XML::Collection, "<array><song><name>Resist Stance</name></song><song><name>Suffer</name></song></array>"],
-  ) do |format, mod, output, input|
-
-    describe "[#{format}] lonely collection, render-only" do # TODO: introduce :representable option?
-      let (:format) { format }
-
-      representer!(module: mod) do
-        items do
-          property :name
-        end
-      end
-
-      let (:album) { [Song.new("Resist Stance"), Song.new("Suffer")].extend(representer) }
-
-      it "calls #to_hash on song instances, nothing else" do
-        render(album).must_equal_document(output)
-      end
-    end
-  end
-
-
-
-  module SongRepresenter
-    include Representable::JSON
-
-    property :name
-  end
-
-  let (:decorator) { rpr = representer; Class.new(Representable::Decorator) { include Representable::Hash; include rpr } }
-
-  describe "JSON::Collection" do
-    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\"}]" }
-
-    describe "with contained objects" do
-      let (:representer) {
-        Module.new do
-          include Representable::JSON::Collection
-          items :class => Song, :extend => SongRepresenter
-        end
-      }
-
-
-      it "renders array" do
-        assert_json json, songs.extend(representer).to_json
-      end
-
-      it "renders array with decorator" do
-        assert_json json, decorator.new(songs).to_json
-      end
-
-      it "parses array" do
-        [].extend(representer).from_json(json).must_equal songs
-      end
-
-      it "parses array with decorator" do
-        decorator.new([]).from_json(json).must_equal songs
-      end
-    end
-
-    describe "with inline representer" do
-      representer!(:module => Representable::JSON::Collection) do
-        items :class => Song do
-          property :name
-        end
-      end
-
-      it { songs.extend(representer).to_json.must_equal json }
-      it { [].extend(representer).from_json(json).must_equal songs }
-    end
-
-    describe "with contained text" do
-      let (:representer) {
-        Module.new do
-          include Representable::JSON::Collection
-        end
-      }
-      let (:songs) { ["Days Go By", "Can't Take Them All"] }
-      let (:json)  { "[\"Days Go By\",\"Can't Take Them All\"]" }
-
-      it "renders contained items #to_json" do
-        assert_json json, songs.extend(representer).to_json
-      end
-
-      it "returns objects array from #from_json" do
-        [].extend(representer).from_json(json).must_equal songs
-      end
-    end
-  end
-
-  describe "Hash::Collection with dynamic options" do
-    class One < Representable::Decorator
-      def to_hash(*); "One: #{represented}"; end
-    end
-
-    class Two < Representable::Decorator
-      def to_hash(*); "Two: #{represented}"; end
-    end
-
-    representer!(module: Representable::Hash::Collection) do
-      items extend: ->(options) { options[:input] == 1 ? options[:user_options][:one] : options[:user_options][:two] }
-    end
-
-
-    it { [1,2].extend(representer).to_hash(one: One, two: Two).must_equal(["One: 1", "Two: 2"]) }
-  end
-
-
-  describe "JSON::Hash" do  # TODO: move to HashTest.
-    describe "with contained objects" do
-      let (:representer) {
-        Module.new do
-          include Representable::JSON::Hash
-          values :class => Song, :extend => SongRepresenter
-        end
-      }
-      let (:json)  { "{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}" }
-      let (:songs) { {"one" => Song.new("Days Go By"), "two" => Song.new("Can't Take Them All")} }
-
-      describe "#to_json" do
-        it "renders hash" do
-          songs.extend(representer).to_json.must_equal json
-        end
-
-        it "renders hash with decorator" do
-          decorator.new(songs).to_json.must_equal json
-        end
-
-        it "respects :exclude" do
-          assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:exclude => [:one])
-        end
-
-        it "respects :include" do
-          assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:include => [:two])
-        end
-      end
-
-      describe "#from_json" do
-        it "returns objects array" do
-          {}.extend(representer).from_json(json).must_equal songs
-        end
-
-        it "parses hash with decorator" do
-          decorator.new({}).from_json(json).must_equal songs
-        end
-
-        it "respects :exclude" do
-          assert_equal({"two" => Song.new("Can't Take Them All")}, {}.extend(representer).from_json(json, :exclude => [:one]))
-        end
-
-        it "respects :include" do
-          assert_equal({"one" => Song.new("Days Go By")}, {}.extend(representer).from_json(json, :include => [:one]))
-        end
-      end
-
-
-      describe "with inline representer" do
-        representer!(:module => Representable::JSON::Hash) do
-          values :class => Song do
-            property :name
-          end
-        end
-
-        it { songs.extend(representer).to_json.must_equal json }
-        it { {}.extend(representer).from_json(json).must_equal songs }
-      end
-    end
-
-
-    describe "with scalar" do
-      let (:representer) {
-        Module.new do
-          include Representable::JSON::Hash
-        end
-      }
-      let (:json)  { %{{"one":1,"two":2}} }
-      let (:data) { {one: 2, two: 3} }
-
-      describe "#to_json" do
-        it { data.extend(representer).to_json.must_equal %{{"one":2,"two":3}} }
-
-        # it "respects :exclude" do
-        #   assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:exclude => [:one])
-        # end
-
-        # it "respects :include" do
-        #   assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:include => [:two])
-        # end
-      end
-
-      describe "#from_json" do # FIXME: what's the point of this?
-        it { data.extend(representer).from_hash(data).must_equal data }
-      end
-    end
-
-
-    describe "with contained text" do
-      before do
-        @songs_representer = Module.new do
-          include Representable::JSON::Collection
-        end
-      end
-
-      it "renders contained items #to_json" do
-        assert_json "[\"Days Go By\",\"Can't Take Them All\"]", ["Days Go By", "Can't Take Them All"].extend(@songs_representer).to_json
-      end
-
-      it "returns objects array from #from_json" do
-        assert_equal ["Days Go By", "Can't Take Them All"], [].extend(@songs_representer).from_json("[\"Days Go By\",\"Can't Take Them All\"]")
-      end
-    end
-  end
-end
-
-
-# describe "Hash::Collection with :include" do
-class CollectionWithIncludeTest < MiniTest::Spec
-  Song = Struct.new(:id, :title)
-
-  representer!(decorator: true, module: Representable::Hash::Collection) do
-    items do
-      property :id
-      property :title
-    end
-  end
-
-  it { representer.new([Song.new(1, "ACAB")]).to_hash.must_equal([{"id"=>1, "title"=>"ACAB"}]) }
-  it { representer.new([Song.new(1, "ACAB")]).to_hash(include: [:title]).must_equal([{"title"=>"ACAB"}]) }
-end

data/test-with-deprecations/mongoid_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-require 'mongoid'
-require 'mongoid/document'
-
-class MongoidTest < MiniTest::Spec
-  describe "Mongoid compatibility" do
-    it "allows #to_json" do
-      class Profile
-        include Mongoid::Document
-        field :name
-      end
-      
-      class Dude
-        include Mongoid::Document
-        embeds_one :profile, :class_name => "MongoidTest::Profile"
-      end
-      
-      module ProfileRepresenter
-       include Representable::JSON
-
-       property :name
-      end
-
-      dude = Dude.new
-      dude.profile = Profile.new
-      dude.profile.name = "Kofi"
-      
-      assert_equal "{\"name\":\"Kofi\"}", dude.profile.extend(ProfileRepresenter).to_json
-    end      
-  end
-end

data/test-with-deprecations/nested_test.rb

@@ -1,115 +0,0 @@
-require 'test_helper'
-
-class NestedTest < MiniTest::Spec
-	Album = Struct.new(:label, :owner, :amount)
-
-	for_formats(
-    :hash => [Representable::Hash, {"label" => {"label"=>"Epitaph", "owner"=>"Brett Gurewitz", "releases"=>{"amount"=>19}}}],
-    # :xml  => [Representable::XML, "<open_struct></open_struct>"],
-    :yaml => [Representable::YAML, "---\nlabel:\n  label: Epitaph\n  owner: Brett Gurewitz\n  releases:\n    amount: 19\n"]
-  ) do |format, mod, output, input|
-
-    [false, true].each do |is_decorator|
-      describe "::nested with (inline representer|decorator): #{is_decorator}" do
-        let (:format) { format }
-
-        representer!(:module => mod, :decorator => is_decorator) do
-          nested :label do
-            property :label
-            property :owner
-
-            # self.representation_wrap = nil if format == :xml
-            nested :releases do
-              property :amount
-            end
-          end
-
-          # self.representation_wrap = :album if format == :xml
-        end
-
-        let (:album) { Album.new("Epitaph", "Brett Gurewitz", 19) }
-        let (:decorator) { representer.prepare(album) }
-
-        it "renders nested Album-properties in separate section" do
-          render(decorator).must_equal_document output
-
-          # do not use extend on the nested object. # FIXME: make this a proper test with two describes instead of this pseudo-meta stuff.
-          if is_decorator==true
-            album.wont_be_kind_of(Representable::Hash)
-          end
-        end
-
-        it "parses nested properties to Album instance" do
-          album = parse(representer.prepare(Album.new), output)
-          album.label.must_equal "Epitaph"
-          album.owner.must_equal "Brett Gurewitz"
-        end
-      end
-    end
-
-
-    describe "Decorator ::nested with extend:" do
-      let (:format) { format }
-
-      representer!(:name => :label_rpr) do
-      	include mod
-      	property :label
-        property :owner
-
-        nested :releases do # DISCUSS: do we need to test this?
-          property :amount
-        end
-      end
-
-      representer!(:module => mod, :decorator => true, :inject => :label_rpr) do
-        nested :label, :extend => label_rpr
-
-        self.representation_wrap = :album if format == :xml
-      end
-
-      let (:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
-
-      # TODO: shared example with above.
-      it "renders nested Album-properties in separate section" do
-        render(album).must_equal_document output
-      end
-
-      it "parses nested properties to Album instance" do
-      	album = parse(representer.prepare(Album.new), output)
-      	album.label.must_equal "Epitaph"
-      	album.owner.must_equal "Brett Gurewitz"
-        album.amount.must_equal 19
-      end
-    end
-  end
-
-
-  describe "::nested without block but with inherit:" do
-
-    representer!(:name => :parent) do
-      include Representable::Hash
-
-      nested :label do
-        property :owner
-      end
-    end
-
-    representer!(:module => Representable::Hash, :inject => :parent) do
-      include parent
-      nested :label, :inherit => true, :as => "Label"
-    end
-
-    let (:album) { representer.prepare(Album.new("Epitaph", "Brett Gurewitz", 19)) }
-
-    it "renders nested Album-properties in separate section" do
-      representer.prepare(album).to_hash.must_equal({"Label"=>{"owner"=>"Brett Gurewitz"}})
-    end
-
-    # it "parses nested properties to Album instance" do
-    #   album = parse(representer.prepare(Album.new), output)
-    #   album.label.must_equal "Epitaph"
-    #   album.owner.must_equal "Brett Gurewitz"
-    #   album.amount.must_equal 19
-    # end
-  end
-end

data/test-with-deprecations/object_test.rb

@@ -1,60 +0,0 @@
-require "test_helper"
-require "representable/object"
-
-class ObjectTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album)
-  Album = Struct.new(:name, :songs)
-
-  representer!(module: Representable::Object) do
-    property :title
-
-    property :album, instance: lambda { |fragment, *| fragment.name.upcase!; fragment } do
-      property :name
-
-      collection :songs, instance: lambda { |fragment, *| fragment.title.upcase!; fragment } do
-        property :title
-      end
-    end
-    # TODO: collection
-  end
-
-  let (:source) { Song.new("The King Is Dead", Album.new("Ruiner", [Song.new("In Vino Veritas II")])) }
-  let (:target) { Song.new }
-
-  it do
-    representer.prepare(target).from_object(source)
-
-    target.title.must_equal "The King Is Dead"
-    target.album.name.must_equal "RUINER"
-    target.album.songs[0].title.must_equal "IN VINO VERITAS II"
-  end
-
-  # ignore nested object when nil
-  it do
-    representer.prepare(Song.new("The King Is Dead")).from_object(Song.new)
-
-    target.title.must_equal nil # scalar property gets overridden when nil.
-    target.album.must_equal nil # nested property stays nil.
-  end
-
-  # to_object
-  describe "#to_object" do
-    representer!(module: Representable::Object) do
-      property :title
-
-      property :album, render_filter: lambda { |object, *| object.name = "Live"; object } do
-        property :name
-
-        collection :songs, render_filter: lambda { |object, *| object[0].title = 1; object } do
-          property :title
-        end
-      end
-    end
-
-    it do
-      representer.prepare(source).to_object
-      source.album.name.must_equal "Live"
-      source.album.songs[0].title.must_equal 1
-    end
-  end
-end

data/test-with-deprecations/parse_pipeline_test.rb

@@ -1,64 +0,0 @@
-require "test_helper"
-
-class ParsePipelineTest < MiniTest::Spec
-  Album  = Struct.new(:id, :artist, :songs)
-  Artist = Struct.new(:email)
-  Song   = Struct.new(:title)
-
-  describe "transforming nil to [] when parsing" do
-    representer!(decorator: true) do
-      collection :songs,
-          parse_pipeline: ->(*) {
-            Representable::Pipeline.insert(
-              parse_functions,                                # original function list from Binding#parse_functions.
-              ->(input, options) { input.nil? ? [] : input }, # your new function (can be any callable object)..
-              replace: Representable::OverwriteOnNil          # ..that replaces the original function.
-            )
-          },
-          class: Song do
-        property :title
-      end
-    end
-
-    it do
-      representer.new(album = Album.new).from_hash("songs"=>nil)
-      album.songs.must_equal []
-    end
-
-    it do
-      representer.new(album = Album.new).from_hash("songs"=>[{"title" => "Business Conduct"}])
-      album.songs.must_equal [Song.new("Business Conduct")]
-    end
-  end
-
-
-  # tests [Collect[Instance, Prepare, Deserialize], Setter]
-  class Representer < Representable::Decorator
-    include Representable::Hash
-
-    # property :artist, populator: Uber::Options::Value.new(ArtistPopulator.new), pass_options:true do
-    #   property :email
-    # end
-    # DISCUSS: rename to populator_pipeline ?
-    collection :songs, parse_pipeline: ->(*) { [Collect[Instance, Prepare, Deserialize], Setter] }, instance: :instance!, exec_context: :decorator, pass_options: true do
-      property :title
-    end
-
-    def instance!(*options)
-      puts "@@@@@ #{options.inspect}"
-      Song.new
-    end
-
-    def songs=(array)
-      represented.songs=array
-    end
-  end
-
-  it do
-    skip "TODO: implement :parse_pipeline and :render_pipeline, and before/after/replace semantics"
-    album = Album.new
-    Representer.new(album).from_hash({"artist"=>{"email"=>"yo"}, "songs"=>[{"title"=>"Affliction"}, {"title"=>"Dream Beater"}]})
-    album.songs.must_equal([Song.new("Affliction"), Song.new("Dream Beater")])
-    puts album.inspect
-  end
-end