representable 2.4.1 → 3.0.0

data/test-with-deprecations/instance_test.rb

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

data/test-with-deprecations/is_representable_test.rb

@@ -1,77 +0,0 @@
-require 'test_helper'
-
-class IsRepresentableTest < BaseTest
-  describe "representable: false, extend:" do
-    representer!(:inject => :song_representer) do
-      property :song,
-        :representable => false,
-        :extend        => song_representer
-    end
-
-    it "does extend but doesn't call #to_hash" do
-      Struct.new(:song).new(song = Object.new).extend(representer).
-        to_hash.must_equal("song" => song)
-      song.must_be_kind_of Representable::Hash
-    end
-  end
-
-
-  describe "representable: true, no extend:" do
-    representer!(:inject => :song_representer) do
-      property :song,
-        :representable => true
-    end
-
-    it "doesn't extend but calls #to_hash" do
-      song = Object.new
-      song.instance_eval do
-        def to_hash(*)
-          1
-        end
-      end
-
-      Struct.new(:song).new(song).extend(representer).
-        to_hash.must_equal("song" => 1)
-      song.wont_be_kind_of Representable::Hash
-    end
-  end
-
-  # TODO: TEST implement for from_hash.
-
-  describe "representable: false, with class:" do
-    representer!(:inject => :song_representer) do
-      property :song,
-        :representable => false, :class => OpenStruct, :extend => song_representer
-    end
-
-    it "does extend but doesn't call #from_hash" do
-      hit = Struct.new(:song).new.extend(representer).
-        from_hash("song" => 1)
-
-      hit.song.must_equal OpenStruct.new
-      hit.song.must_be_kind_of Representable::Hash
-    end
-  end
-
-
-  describe "representable: true, without extend: but class:" do
-    SongReader = Class.new do
-      def from_hash(*)
-        "Piano?"
-      end
-    end
-
-    representer!(:inject => :song_representer) do
-      property :song,
-        :representable => true, :class => SongReader
-    end
-
-    it "doesn't extend but calls #from_hash" do
-      hit = Struct.new(:song).new.extend(representer).
-        from_hash("song" => "Sonata No.2")
-
-      hit.song.must_equal "Piano?"
-      hit.song.wont_be_kind_of Representable::Hash
-    end
-  end
-end

data/test-with-deprecations/json_test.rb

@@ -1,355 +0,0 @@
-require 'test_helper'
-
-module JsonTest
-  class APITest < MiniTest::Spec
-    Json = Representable::JSON
-    Def = Representable::Definition
-
-    describe "JSON module" do
-      before do
-        @Band = Class.new do
-          include Representable::JSON
-          property :name
-          property :label
-          attr_accessor :name, :label
-
-          def initialize(name=nil)
-            self.name = name if name
-          end
-        end
-
-        @band = @Band.new
-      end
-
-
-      describe "#from_json" do
-        before do
-          @band = @Band.new
-          @json  = {:name => "Nofx", :label => "NOFX"}.to_json
-        end
-
-        it "parses JSON and assigns properties" do
-          @band.from_json(@json)
-          assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
-        end
-      end
-
-
-      describe "#from_hash" do
-        before do
-          @band = @Band.new
-          @hash  = {"name" => "Nofx", "label" => "NOFX"}
-        end
-
-        it "receives hash and assigns properties" do
-          @band.from_hash(@hash)
-          assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
-        end
-
-        it "respects :wrap option" do
-          @band.from_hash({"band" => {"name" => "This Is A Standoff"}}, :wrap => :band)
-          assert_equal "This Is A Standoff", @band.name
-        end
-
-        it "respects :wrap option over representation_wrap" do
-          @Band.class_eval do
-            self.representation_wrap = :group
-          end
-          @band.from_hash({"band" => {"name" => "This Is A Standoff"}}, :wrap => :band)
-          assert_equal "This Is A Standoff", @band.name
-        end
-      end
-
-
-      describe "#to_json" do
-        it "delegates to #to_hash and returns string" do
-          assert_json "{\"name\":\"Rise Against\"}", @Band.new("Rise Against").to_json
-        end
-      end
-
-
-      describe "#to_hash" do
-        it "returns unwrapped hash" do
-          hash = @Band.new("Rise Against").to_hash
-          assert_equal({"name"=>"Rise Against"}, hash)
-        end
-
-        it "respects :wrap option" do
-          assert_equal({:band=>{"name"=>"NOFX"}}, @Band.new("NOFX").to_hash(:wrap => :band))
-        end
-
-        it "respects :wrap option over representation_wrap" do
-          @Band.class_eval do
-            self.representation_wrap = :group
-          end
-          assert_equal({:band=>{"name"=>"Rise Against"}}, @Band.new("Rise Against").to_hash(:wrap => :band))
-        end
-      end
-
-      describe "#build_for" do
-        it "returns TextBinding" do
-          assert_kind_of Representable::Hash::Binding, Representable::Hash::Binding.build_for(Def.new(:band))
-        end
-
-        it "returns CollectionBinding" do
-          assert_kind_of Representable::Hash::Binding::Collection, Representable::Hash::Binding.build_for(Def.new(:band, :collection => true))
-        end
-      end
-    end
-
-
-    describe "DCI" do
-      module SongRepresenter
-        include Representable::JSON
-        property :name
-      end
-
-      module AlbumRepresenter
-        include Representable::JSON
-        property :best_song, :class => Song, :extend => SongRepresenter
-        collection :songs, :class => Song, :extend => SongRepresenter
-      end
-
-
-      it "allows adding the representer by using #extend" do
-        module BandRepresenter
-          include Representable::JSON
-          property :name
-        end
-
-        civ = Object.new
-        civ.instance_eval do
-          def name; "CIV"; end
-          def name=(v)
-            @name = v
-          end
-        end
-
-        civ.extend(BandRepresenter)
-        assert_json "{\"name\":\"CIV\"}", civ.to_json
-      end
-
-      it "extends contained models when serializing" do
-        @album = Album.new([Song.new("I Hate My Brain"), mr=Song.new("Mr. Charisma")], mr)
-        @album.extend(AlbumRepresenter)
-
-        assert_json "{\"best_song\":{\"name\":\"Mr. Charisma\"},\"songs\":[{\"name\":\"I Hate My Brain\"},{\"name\":\"Mr. Charisma\"}]}", @album.to_json
-      end
-
-      it "extends contained models when deserializing" do
-        #@album = Album.new(Song.new("I Hate My Brain"), Song.new("Mr. Charisma"))
-        @album = Album.new
-        @album.extend(AlbumRepresenter)
-
-        @album.from_json("{\"best_song\":{\"name\":\"Mr. Charisma\"},\"songs\":[{\"name\":\"I Hate My Brain\"},{\"name\":\"Mr. Charisma\"}]}")
-        assert_equal "Mr. Charisma", @album.best_song.name
-      end
-    end
-  end
-
-
-  class PropertyTest < MiniTest::Spec
-    describe "property :name" do
-      class Band
-        include Representable::JSON
-        property :name
-        attr_accessor :name
-      end
-
-      it "#from_json creates correct accessors" do
-        band = Band.new.from_json({:name => "Bombshell Rocks"}.to_json)
-        assert_equal "Bombshell Rocks", band.name
-      end
-
-      it "#to_json serializes correctly" do
-        band = Band.new
-        band.name = "Cigar"
-
-        assert_json '{"name":"Cigar"}', band.to_json
-      end
-    end
-
-    describe ":class => Item" do
-      class Label
-        include Representable::JSON
-        property :name
-        attr_accessor :name
-      end
-
-      class Album
-        include Representable::JSON
-        property :label, :class => Label
-        attr_accessor :label
-      end
-
-      it "#from_json creates one Item instance" do
-        album = Album.new.from_json('{"label":{"name":"Fat Wreck"}}')
-        assert_equal "Fat Wreck", album.label.name
-      end
-
-      it "#to_json serializes" do
-        label = Label.new; label.name = "Fat Wreck"
-        album = Album.new; album.label = label
-
-        assert_json '{"label":{"name":"Fat Wreck"}}', album.to_json
-      end
-
-      describe ":different_name, :class => Label" do
-        before do
-          @Album = Class.new do
-            include Representable::JSON
-            property :seller, :class => Label
-            attr_accessor :seller
-          end
-        end
-
-        it "#to_xml respects the different name" do
-          label = Label.new; label.name = "Fat Wreck"
-          album = @Album.new; album.seller = label
-
-          assert_json "{\"seller\":{\"name\":\"Fat Wreck\"}}", album.to_json(:wrap => false)
-        end
-      end
-    end
-
-    describe ":as => :songName" do
-      class Song
-        include Representable::JSON
-        property :name, :as => :songName
-        attr_accessor :name
-      end
-
-      it "respects :as in #from_json" do
-        song = Song.new.from_json({:songName => "Run To The Hills"}.to_json)
-        assert_equal "Run To The Hills", song.name
-      end
-
-      it "respects :as in #to_json" do
-        song = Song.new; song.name = "22 Acacia Avenue"
-        assert_json '{"songName":"22 Acacia Avenue"}', song.to_json
-      end
-    end
-
-end
-
-
-  class CollectionTest < MiniTest::Spec
-    describe "collection :name" do
-      class CD
-        include Representable::JSON
-        collection :songs
-        attr_accessor :songs
-      end
-
-      it "#from_json creates correct accessors" do
-        cd = CD.new.from_json({:songs => ["Out in the cold", "Microphone"]}.to_json)
-        assert_equal ["Out in the cold", "Microphone"], cd.songs
-      end
-
-      it "zzz#to_json serializes correctly" do
-        cd = CD.new
-        cd.songs = ["Out in the cold", "Microphone"]
-
-        assert_json '{"songs":["Out in the cold","Microphone"]}', cd.to_json
-      end
-    end
-
-    describe "collection :name, :class => Band" do
-      class Band
-        include Representable::JSON
-        property :name
-        attr_accessor :name
-
-        def initialize(name="")
-          self.name = name
-        end
-      end
-
-      class Compilation
-        include Representable::JSON
-        collection :bands, :class => Band
-        attr_accessor :bands
-      end
-
-      describe "#from_json" do
-        it "pushes collection items to array" do
-          cd = Compilation.new.from_json({:bands => [
-            {:name => "Cobra Skulls"},
-            {:name => "Diesel Boy"}]}.to_json)
-          assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
-        end
-      end
-
-      it "responds to #to_json" do
-        cd = Compilation.new
-        cd.bands = [Band.new("Diesel Boy"), Band.new("Bad Religion")]
-
-        assert_json '{"bands":[{"name":"Diesel Boy"},{"name":"Bad Religion"}]}', cd.to_json
-      end
-    end
-
-
-    describe ":as => :songList" do
-      class Songs
-        include Representable::JSON
-        collection :tracks, :as => :songList
-        attr_accessor :tracks
-      end
-
-      it "respects :as in #from_json" do
-        songs = Songs.new.from_json({:songList => ["Out in the cold", "Microphone"]}.to_json)
-        assert_equal ["Out in the cold", "Microphone"], songs.tracks
-      end
-
-      it "respects option in #to_json" do
-        songs = Songs.new
-        songs.tracks = ["Out in the cold", "Microphone"]
-
-        assert_json '{"songList":["Out in the cold","Microphone"]}', songs.to_json
-      end
-    end
-  end
-
-  class HashTest < MiniTest::Spec
-    describe "hash :songs" do
-      representer!(:module => Representable::JSON) do
-        hash :songs
-      end
-
-      subject { OpenStruct.new.extend(representer) }
-
-      it "renders with #to_json" do
-        subject.songs = {:one => "65", :two => "Emo Boy"}
-        assert_json "{\"songs\":{\"one\":\"65\",\"two\":\"Emo Boy\"}}", subject.to_json
-      end
-
-      it "parses with #from_json" do
-        assert_equal({"one" => "65", "two" => ["Emo Boy"]}, subject.from_json("{\"songs\":{\"one\":\"65\",\"two\":[\"Emo Boy\"]}}").songs)
-      end
-    end
-
-    describe "hash :songs, :class => Song" do
-      representer!(:module => Representable::JSON) do
-        hash :songs, :extend => Module.new { include Representable::JSON; property :name }, :class => Song
-      end
-
-      it "renders" do
-        OpenStruct.new(:songs => {"7" => Song.new("Contemplation")}).extend(representer).to_hash.must_equal("songs"=>{"7"=>{"name"=>"Contemplation"}})
-      end
-
-      describe "parsing" do
-        subject { OpenStruct.new.extend(representer) }
-        let (:hsh) { {"7"=>{"name"=>"Contemplation"}} }
-
-        it "parses incoming hash" do
-          subject.from_hash("songs"=>hsh).songs.must_equal({"7"=>Song.new("Contemplation")})
-        end
-
-        it "doesn't modify the incoming hash" do
-          subject.from_hash("songs"=> incoming_hash = hsh.dup)
-          hsh.must_equal incoming_hash
-        end
-      end
-    end
-  end
-end