representable 1.7.7 → 1.8.0

data/test/if_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class IfTest < MiniTest::Spec
+  let (:band_class) { Class.new do
+    include Representable::Hash
+    attr_accessor :fame
+    self
+  end }
+
+  it "respects property when condition true" do
+    band_class.class_eval { property :fame, :if => lambda { |*| true } }
+    band = band_class.new
+    band.from_hash({"fame"=>"oh yes"})
+    assert_equal "oh yes", band.fame
+  end
+
+  it "ignores property when condition false" do
+    band_class.class_eval { property :fame, :if => lambda { |*| false } }
+    band = band_class.new
+    band.from_hash({"fame"=>"oh yes"})
+    assert_equal nil, band.fame
+  end
+
+  it "ignores property when :exclude'ed even when condition is true" do
+    band_class.class_eval { property :fame, :if => lambda { |*| true } }
+    band = band_class.new
+    band.from_hash({"fame"=>"oh yes"}, {:exclude => [:fame]})
+    assert_equal nil, band.fame
+  end
+
+  it "executes block in instance context" do
+    band_class.class_eval { property :fame, :if => lambda { |*| groupies }; attr_accessor :groupies }
+    band = band_class.new
+    band.groupies = true
+    band.from_hash({"fame"=>"oh yes"})
+    assert_equal "oh yes", band.fame
+  end
+
+  describe "executing :if lambda in represented instance context" do
+    representer! do
+      property :label, :if => lambda { |*| signed_contract }
+    end
+
+    subject { OpenStruct.new(:signed_contract => false, :label => "Fat") }
+
+    it "skips when false" do
+      subject.extend(representer).to_hash.must_equal({})
+    end
+
+    it "represents when true" do
+      subject.signed_contract= true
+      subject.extend(representer).to_hash.must_equal({"label"=>"Fat"})
+    end
+
+    it "works with decorator" do
+      rpr = representer
+      Class.new(Representable::Decorator) do
+        include rpr
+      end.new(subject).to_hash.must_equal({})
+    end
+  end
+
+
+  describe "propagating user options to the block" do
+    representer! do
+      property :name, :if => lambda { |opts| opts[:include_name] }
+    end
+    subject { OpenStruct.new(:name => "Outbound").extend(representer) }
+
+    it "works without specifying options" do
+      subject.to_hash.must_equal({})
+    end
+
+    it "passes user options to block" do
+      subject.to_hash(:include_name => true).must_equal({"name" => "Outbound"})
+    end
+  end
+end

data/test/inherit_test.rb

@@ -66,11 +66,31 @@ class InheritTest < MiniTest::Spec
     representer! do
       include SongRepresenter
 
-      property :name, :inherit => true, :as => :name
+      property :name, :inherit => true, :as => :name # FIXME: add :getter or something else dynamic since this is double-wrapped.
     end
 
     it { SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
     it { representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash.must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
   end
 
+
+
+  # no :inherit
+  describe "overwriting without :inherit" do
+    representer! do
+      include SongRepresenter
+
+      property :track, :representable => true
+    end
+
+    it "replaces inherited property" do
+      representer.representable_attrs.size.must_equal 2
+
+      definition = representer.representable_attrs[:track] # TODO: find a better way to assert Definition identity.
+      definition.keys.size.must_equal 2
+      definition[:representable].   must_equal true
+      definition[:as].evaluate(nil).must_equal "track" # was "no".
+    end
+  end
+
 end

data/test/inheritance_test.rb

@@ -10,7 +10,7 @@ class InheritanceTest < MiniTest::Spec
   # Decorator.new.representable_attrs != Decorator.representable_attrs
   it "doesn't clone for instantiated decorator" do
     instance = decorator.new(Object.new)
-    instance.send(:representable_attrs).first.options[:instance] = true
+    instance.send(:representable_attrs).first.merge!(:instance => true)
 
     # we didn't clone and thereby change the original config:
     instance.send(:representable_attrs).to_s.must_equal decorator.representable_attrs.to_s

data/test/inline_test.rb

@@ -27,7 +27,7 @@ class InlineTest < MiniTest::Spec
   {
     :hash => [Representable::Hash, {"songs"=>[{"name"=>"Alive"}]}, {"songs"=>[{"name"=>"You've Taken Everything"}]}],
     :json => [Representable::JSON, "{\"songs\":[{\"name\":\"Alive\"}]}", "{\"songs\":[{\"name\":\"You've Taken Everything\"}]}"],
-    :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>", { :from => :song }],
+    :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>", { :as => :song }],
     :yaml => [Representable::YAML, "---\nsongs:\n- name: Alive\n", "---\nsongs:\n- name: You've Taken Everything\n"],
   }.each do |format, cfg|
     mod, output, input, collection_options = cfg
@@ -185,7 +185,7 @@ class InlineTest < MiniTest::Spec
 
         property :requester
         property :song do
-          property :name, :decorator_scope => true
+          property :name, :exec_context => :decorator
 
           define_method :name do
             represented.name.upcase
@@ -202,4 +202,42 @@ class InlineTest < MiniTest::Spec
       end
     end
   end
+
+
+  describe "deprecate mixing :extend and inline representers" do # TODO: remove in 2.0.
+    representer! do
+      rpr_module = Module.new do
+        include Representable::Hash
+        property :title
+      end
+      property :song, :extend => rpr_module do
+        property :artist
+      end
+    end
+
+    it do OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
+      to_hash.
+      must_equal({"song"=>{"artist"=>"Strung Out", "title"=>"The Fever And The Sound"}})
+    end
+  end
+
+
+  describe "include module in inline representers" do
+    representer! do
+      extension = Module.new do
+        include Representable::Hash
+        property :title
+      end
+
+      property :song do
+        include extension
+        property :artist
+      end
+    end
+
+    it do OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
+      to_hash.
+      must_equal({"song"=>{"artist"=>"Strung Out", "title"=>"The Fever And The Sound"}})
+    end
+  end
 end

data/test/instance_test.rb

@@ -0,0 +1,286 @@
+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 { 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 {
+      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 "instance: true" do
+    representer!(:inject => :song_representer) do
+      property :song,
+        :extend => song_representer, :instance => true
+    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
+
+
+  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 }
+    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