representable 1.7.7 → 1.8.0

data/test/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/json_test.rb

@@ -109,11 +109,6 @@ module JsonTest
           assert_equal({"name"=>"Rise Against"}, hash)
         end
 
-        it "respects #representation_wrap=" do
-          @Band.representation_wrap = :group
-          assert_equal({:group=>{"name"=>"Rise Against"}}, @Band.new("Rise Against").to_hash)
-        end
-
         it "respects :wrap option" do
           assert_equal({:band=>{"name"=>"NOFX"}}, @Band.new("NOFX").to_hash(:wrap => :band))
         end
@@ -128,15 +123,15 @@ module JsonTest
 
       describe "#build_for" do
         it "returns TextBinding" do
-          assert_kind_of Representable::Hash::PropertyBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band), nil)
+          assert_kind_of Representable::Hash::PropertyBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band), nil, nil)
         end
 
         it "returns HashBinding" do
-          assert_kind_of Representable::Hash::HashBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band, :hash => true), nil)
+          assert_kind_of Representable::Hash::HashBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band, :hash => true), nil, nil)
         end
 
         it "returns CollectionBinding" do
-          assert_kind_of Representable::Hash::CollectionBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band, :collection => true), nil)
+          assert_kind_of Representable::Hash::CollectionBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band, :collection => true), nil, nil)
         end
       end
 
@@ -264,24 +259,6 @@ module JsonTest
       end
     end
 
-    describe ":from => :songName" do
-      class Song
-        include Representable::JSON
-        property :name, :from => :songName
-        attr_accessor :name
-      end
-
-      it "respects :from in #from_json" do
-        song = Song.from_json({:songName => "Run To The Hills"}.to_json)
-        assert_equal "Run To The Hills", song.name
-      end
-
-      it "respects :from in #to_json" do
-        song = Song.new; song.name = "Run To The Hills"
-        assert_json '{"songName":"Run To The Hills"}', song.to_json
-      end
-    end
-
     describe ":as => :songName" do
       class Song
         include Representable::JSON
@@ -403,14 +380,14 @@ end
     end
 
 
-    describe ":from => :songList" do
+    describe ":as => :songList" do
       class Songs
         include Representable::JSON
-        collection :tracks, :from => :songList
+        collection :tracks, :as => :songList
         attr_accessor :tracks
       end
 
-      it "respects :from in #from_json" do
+      it "respects :as in #from_json" do
         songs = Songs.from_json({:songList => ["Out in the cold", "Microphone"]}.to_json)
         assert_equal ["Out in the cold", "Microphone"], songs.tracks
       end

data/test/nested_test.rb

@@ -76,4 +76,34 @@ class NestedTest < MiniTest::Spec
       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/parse_strategy_test.rb

@@ -0,0 +1,249 @@
+require 'test_helper'
+
+# parse_strategy: :sync
+# parse_strategy: :replace
+# parse_strategy: :find_or_instantiate ("expand" since we don't delete existing unmatched in target)
+
+
+class ParseStrategySyncTest < BaseTest
+  for_formats(
+    :hash => [Representable::Hash, {"song"=>{"title"=>"Resist Stance"}}, {"song"=>{"title"=>"Suffer"}}],
+    :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><song><title>Suffer</title></song></open_struct>",],
+    :yaml => [Representable::YAML, "---\nsong:\n  title: Resist Stance\n", "---\nsong:\n  title: Suffer\n"],
+  ) do |format, mod, output, input|
+
+    describe "[#{format}] property with parse_strategy: :sync" do # TODO: introduce :representable option?
+      let (:format) { format }
+
+      representer!(:module => mod, :name => :song_representer) do
+        property :title
+        self.representation_wrap = :song if format == :xml
+      end
+
+      representer!(:inject => :song_representer, :module => mod) do
+        property :song, :parse_strategy => :sync, :extend => song_representer
+      end
+
+      let (:hit) { hit = OpenStruct.new(:song => song).extend(representer) }
+
+      it "calls #to_hash on song instance, nothing else" do
+        render(hit).must_equal_document(output)
+      end
+
+
+      it "calls #from_hash on the existing song instance, nothing else" do
+        song_id = hit.song.object_id
+
+        parse(hit, input)
+
+        hit.song.title.must_equal "Suffer"
+        hit.song.object_id.must_equal song_id
+      end
+    end
+  end
+
+  # FIXME: there's a bug with XML and the collection name!
+  for_formats(
+    :hash => [Representable::Hash, {"songs"=>[{"title"=>"Resist Stance"}]}, {"songs"=>[{"title"=>"Suffer"}]}],
+    #:json => [Representable::JSON, "{\"song\":{\"name\":\"Alive\"}}", "{\"song\":{\"name\":\"You've Taken Everything\"}}"],
+    :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><songs><title>Suffer</title></songs></open_struct>"],
+    :yaml => [Representable::YAML, "---\nsongs:\n- title: Resist Stance\n", "---\nsongs:\n- title: Suffer\n"],
+  ) do |format, mod, output, input|
+
+    describe "[#{format}] collection with :parse_strategy: :sync" do # TODO: introduce :representable option?
+      let (:format) { format }
+      representer!(:module => mod, :name => :song_representer) do
+        property :title
+        self.representation_wrap = :song if format == :xml
+      end
+
+      representer!(:inject => :song_representer, :module => mod) do
+        collection :songs, :parse_strategy => :sync, :extend => song_representer
+      end
+
+      let (:album) { OpenStruct.new(:songs => [song]).extend(representer) }
+
+      it "calls #to_hash on song instances, nothing else" do
+        render(album).must_equal_document(output)
+      end
+
+      it "calls #from_hash on the existing song instance, nothing else" do
+        collection_id = album.songs.object_id
+        song          = album.songs.first
+        song_id       = song.object_id
+
+        parse(album, input)
+
+        album.songs.first.title.must_equal "Suffer"
+        song.title.must_equal "Suffer"
+        #album.songs.object_id.must_equal collection_id # TODO: don't replace!
+        song.object_id.must_equal song_id
+      end
+    end
+  end
+
+
+  # Lonely Collection
+  for_formats(
+    :hash => [Representable::Hash::Collection, [{"title"=>"Resist Stance"}], [{"title"=>"Suffer"}]],
+    # :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><songs><title>Suffer</title></songs></open_struct>"],
+  ) do |format, mod, output, input|
+
+    describe "[#{format}] lonely collection with :parse_strategy: :sync" do # TODO: introduce :representable option?
+      let (:format) { format }
+      representer!(:module => Representable::Hash, :name => :song_representer) do
+        property :title
+        self.representation_wrap = :song if format == :xml
+      end
+
+      representer!(:inject => :song_representer, :module => mod) do
+        items :parse_strategy => :sync, :extend => song_representer
+      end
+
+      let (:album) { [song].extend(representer) }
+
+      it "calls #to_hash on song instances, nothing else" do
+        render(album).must_equal_document(output)
+      end
+
+      it "calls #from_hash on the existing song instance, nothing else" do
+        #collection_id = album.object_id
+        song          = album.first
+        song_id       = song.object_id
+
+        parse(album, input)
+
+        album.first.title.must_equal "Suffer"
+        song.title.must_equal "Suffer"
+        song.object_id.must_equal song_id
+      end
+    end
+  end
+end
+
+
+class ParseStrategyFindOrInstantiateTest < BaseTest
+  # parse_strategy: :find_or_instantiate
+
+  Song = Struct.new(:id, :title)
+  Song.class_eval do
+    def self.find(id)
+      return new(1, "Resist Stan") if id==1# we should return the same object here
+      new
+    end
+  end
+
+  representer!(:name => :song_representer) do
+    property :title
+  end
+
+
+  describe "collection" do
+    representer!(:inject => :song_representer) do
+      collection :songs, :parse_strategy => :find_or_instantiate, :extend => song_representer, :class => Song
+    end
+
+    let (:album) { Struct.new(:songs).new([]).extend(representer) }
+
+
+    it "replaces the existing collection with a new consisting of existing items or new items" do
+      songs_id = album.songs.object_id
+
+      album.from_hash({"songs"=>[{"id" => 1, "title"=>"Resist Stance"}, {"title"=>"Suffer"}]})
+
+      album.songs[0].title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      album.songs[0].id.must_equal 1
+      album.songs[1].title.must_equal "Suffer"
+      album.songs[1].id.must_equal nil
+
+      album.songs.object_id.wont_equal songs_id
+    end
+
+    # TODO: test with existing collection
+  end
+
+
+  describe "property" do
+    representer!(:inject => :song_representer) do
+      property :song, :parse_strategy => :find_or_instantiate, :extend => song_representer, :class => Song
+    end
+
+    let (:album) { Struct.new(:song).new.extend(representer) }
+
+
+    it "finds song by id" do
+      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance"}})
+
+      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      album.song.id.must_equal 1
+    end
+
+    it "creates song" do
+      album.from_hash({"song"=>{"title"=>"Off The Track"}})
+
+      album.song.title.must_equal "Off The Track"
+      album.song.id.must_equal nil
+    end
+  end
+
+
+  describe "property with dynamic :class" do
+    representer!(:inject => :song_representer) do
+      property :song, :parse_strategy => :find_or_instantiate, :extend => song_representer,
+        :class => lambda { |fragment, *args| fragment["class"] }
+    end
+
+    let (:album) { Struct.new(:song).new.extend(representer) }
+
+
+    it "finds song by id" do
+      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance", "class"=>Song}})
+
+      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
+      album.song.id.must_equal 1
+    end
+  end
+end
+
+
+class ParseStrategyLambdaTest < MiniTest::Spec
+  Song = Struct.new(:id, :title)
+  Song.class_eval do
+    def self.find(id)
+      return new(1, "Resist Stan") if id==1# we should return the same object here
+      new
+    end
+  end
+
+  representer!(:name => :song_representer) do
+    property :title
+  end
+
+
+  describe "collection" do
+    representer!(:inject => :song_representer) do
+      collection :songs, :parse_strategy => lambda { |fragment, i, options|
+        songs << song = Song.new
+        song
+      }, :extend => song_representer
+    end
+
+    let (:album) { Struct.new(:songs).new([Song.new(1, "A Walk")]).extend(representer) }
+
+
+    it "adds to existing collection" do
+      songs_id = album.songs.object_id
+
+      album.from_hash({"songs"=>[{"title"=>"Resist Stance"}]})
+
+      album.songs[0].title.must_equal "A Walk" # note how title is updated from "Resist Stan"
+      album.songs[0].id.must_equal 1
+      album.songs[1].title.must_equal "Resist Stance"
+      album.songs[1].id.must_equal nil
+
+      album.songs.object_id.must_equal songs_id
+    end
+
+    # TODO: test with existing collection
+  end
+end

data/test/pass_options_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class PassOptionsTest < BaseTest
+  let (:format) { :hash }
+  let (:song) { Struct.new(:title).new("Revolution") }
+  let (:prepared) { representer.prepare song }
+
+  describe "module" do
+    representer! do
+      property :title, :pass_options => true,
+        :as => lambda { |args| [args.binding.name, args.user_options, args.represented, args.decorator]  }
+    end
+
+    it { render(prepared, :volume => 1).must_equal_document({["title", {:volume=>1}, prepared, prepared] => "Revolution"}) }
+    # it { parse(prepared, {"args" => "Wie Es Geht"}).name.must_equal "Wie Es Geht" }
+  end
+
+  describe "decorator" do
+    representer!(:decorator => true) do
+      property :title, :pass_options => true,
+        :as => lambda { |args| [args.binding.name, args.user_options, args.represented, args.decorator]  }
+    end
+
+    it { render(prepared, :volume => 1).must_equal_document({["title", {:volume=>1}, song, prepared] => "Revolution"}) }
+    # it { parse(prepared, {"args" => "Wie Es Geht"}).name.must_equal "Wie Es Geht" }
+  end
+end