representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/is_representable_test.rb

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

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

data/test-with-deprecations/lonely_test.rb

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