representable 2.3.0 → 2.4.0.rc1

data/test/exec_context_test.rb

@@ -86,7 +86,7 @@ class ExecContextTest < MiniTest::Spec
         end
 
         it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
-        it { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+        it("xxx") { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
       end
     end
   end

data/test/filter_test.rb

@@ -1,28 +1,29 @@
 require 'test_helper'
 
 class FilterPipelineTest < MiniTest::Spec
-  let (:block1) { lambda { |value, *| "1: #{value}" } }
-  let (:block2) { lambda { |value, *| "2: #{value}" } }
+  let (:block1) { lambda { |input, options| "1: #{input}" } }
+  let (:block2) { lambda { |input, options| "2: #{input}" } }
 
   subject { Representable::Pipeline[block1, block2] }
 
-  it { subject.call(Object, "Horowitz").must_equal "2: 1: Horowitz" }
+  it { subject.call("Horowitz", {}).must_equal "2: 1: Horowitz" }
 end
 
 
 class FilterTest < MiniTest::Spec
   representer! do
     property :title
+
     property :track,
-      :parse_filter  => lambda { |val, doc, options| "#{val.downcase},#{doc},#{options}" },
-      :render_filter => lambda { |val, doc, options| "#{val.upcase},#{doc},#{options}" }
+      :parse_filter  => lambda { |input, options| "#{input.downcase},#{options[:doc]}" },
+      :render_filter => lambda { |val, options| "#{val.upcase},#{options[:doc]},#{options[:user_options]}" }
   end
 
   # gets doc and options.
   it {
     song = OpenStruct.new.extend(representer).from_hash("title" => "VULCAN EARS", "track" => "Nine")
     song.title.must_equal "VULCAN EARS"
-    song.track.must_equal "nine,{\"title\"=>\"VULCAN EARS\", \"track\"=>\"Nine\"},{}"
+    song.track.must_equal "nine,{\"title\"=>\"VULCAN EARS\", \"track\"=>\"Nine\"}"
   }
 
   it { OpenStruct.new("title" => "vulcan ears", "track" => "Nine").extend(representer).to_hash.must_equal( {"title"=>"vulcan ears", "track"=>"NINE,{\"title\"=>\"vulcan ears\"},{}"}) }
@@ -32,14 +33,11 @@ class FilterTest < MiniTest::Spec
     representer! do
       property :track,
         :parse_filter => [
-          lambda { |val, doc, options| "#{val}-1" },
-          lambda { |val, doc, options| "#{val}-2" }],
+          lambda { |input, options| "#{input}-1" },
+          lambda { |input, options| "#{input}-2" }],
         :render_filter => [
-          lambda { |val, doc, options| "#{val}-1" },
-          lambda { |val, doc, options| "#{val}-2" }]
-
-      # definition[:parse_filter].instance_variable_get(:@value) << lambda { |val, doc, options| "#{val}-1" }
-      # property :track, :parse_filter => lambda { |val, doc, options| "#{val}-2" }, :inherit => true
+          lambda { |val, options| "#{val}-1" },
+          lambda { |val, options| "#{val}-2" }]
     end
 
     # order matters.
@@ -49,11 +47,11 @@ class FilterTest < MiniTest::Spec
 end
 
 
-class RenderFilterTest < MiniTest::Spec
-  representer! do
-    property :track, :render_filter => [lambda { |val, doc, options| "#{val}-1" } ]
-    property :track, :render_filter => [lambda { |val, doc, options| "#{val}-2" } ], :inherit => true
-  end
+# class RenderFilterTest < MiniTest::Spec
+#   representer! do
+#     property :track, :render_filter => [lambda { |val, options| "#{val}-1" } ]
+#     property :track, :render_filter => [lambda { |val, options| "#{val}-2" } ], :inherit => true
+#   end
 
-  it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
-end
+#   it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
+# end

data/test/getter_setter_test.rb

@@ -14,15 +14,8 @@ class GetterSetterTest < BaseTest
     subject.to_hash(:welcome => "Hi").must_equal({"name" => "Hi Mony Mony"})
   end
 
-  it "does not call original reader when rendering" do
-    subject.instance_eval { def name; raise; end; self }.to_hash({})
-  end
-
   it "uses :setter when parsing" do
+    subject.instance_eval { def name=(*); raise; end; self }
     subject.from_hash({"name" => "Eyes Without A Face"}, :welcome => "Hello").song_name.must_equal "Hello Eyes Without A Face"
   end
-
-  it "does not call original writer when parsing" do
-    subject.instance_eval { def name=(*); raise; end; self }.from_hash({"name"=>"Dana D And Talle T"}, {})
-  end
 end

data/test/hash_bindings_test.rb

@@ -15,17 +15,17 @@ class HashBindingTest < MiniTest::Spec
   describe "PropertyBinding" do
     describe "#read" do
       before do
-        @property = Representable::Hash::Binding.new(Representable::Definition.new(:song), nil)
+        @property = Representable::Hash::Binding.new(Representable::Definition.new(:song))
       end
 
       it "returns fragment if present" do
-        assert_equal "Stick The Flag Up Your Goddamn Ass, You Sonofabitch", @property.read({"song" => "Stick The Flag Up Your Goddamn Ass, You Sonofabitch"})
-        assert_equal "", @property.read({"song" => ""})
-        assert_equal nil, @property.read({"song" => nil})
+        assert_equal "Stick The Flag Up Your Goddamn Ass, You Sonofabitch", @property.read({"song" => "Stick The Flag Up Your Goddamn Ass, You Sonofabitch"}, "song")
+        assert_equal "", @property.read({"song" => ""}, "song")
+        assert_equal nil, @property.read({"song" => nil}, "song")
       end
 
       it "returns FRAGMENT_NOT_FOUND if not in document" do
-        assert_equal Representable::Binding::FragmentNotFound, @property.read({})
+        assert_equal Representable::Binding::FragmentNotFound, @property.read({}, "song")
       end
 
     end
@@ -35,16 +35,16 @@ class HashBindingTest < MiniTest::Spec
   describe "CollectionBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::Hash::Binding::Collection.new(Representable::Definition.new(:songs, :collection => true), Album.new)
+        @property = Representable::Hash::Binding::Collection.new(Representable::Definition.new(:songs, :collection => true))
       end
 
       it "extracts with #read" do
-        assert_equal ["The Gargoyle", "Bronx"], @property.read("songs" => ["The Gargoyle", "Bronx"])
+        assert_equal ["The Gargoyle", "Bronx"], @property.read({"songs" => ["The Gargoyle", "Bronx"]}, "songs")
       end
 
       it "inserts with #write" do
         doc = {}
-        assert_equal(["The Gargoyle", "Bronx"], @property.write(doc, ["The Gargoyle", "Bronx"]))
+        assert_equal(["The Gargoyle", "Bronx"], @property.write(doc, ["The Gargoyle", "Bronx"], "songs"))
         assert_equal({"songs"=>["The Gargoyle", "Bronx"]}, doc)
       end
     end
@@ -56,29 +56,29 @@ class HashBindingTest < MiniTest::Spec
   describe "HashBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::Hash::Binding::Hash.new(Representable::Definition.new(:songs, :hash => true), nil)
+        @property = Representable::Hash::Binding.new(Representable::Definition.new(:songs, :hash => true))
       end
 
       it "extracts with #read" do
-        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"} , @property.read("songs" => {"first" => "The Gargoyle", "second" => "Bronx"}))
+        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"} , @property.read({"songs" => {"first" => "The Gargoyle", "second" => "Bronx"}}, "songs"))
       end
 
       it "inserts with #write" do
         doc = {}
-        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"}, @property.write(doc, {"first" => "The Gargoyle", "second" => "Bronx"}))
+        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"}, @property.write(doc, {"first" => "The Gargoyle", "second" => "Bronx"}, "songs"))
         assert_equal({"songs"=>{"first" => "The Gargoyle", "second" => "Bronx"}}, doc)
       end
     end
 
     describe "with objects" do
       before do
-        @property = Representable::Hash::Binding::Hash.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter), nil)
+        @property = Representable::Hash::Binding.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter))
       end
 
       it "doesn't change the represented hash in #write" do
         song = Song.new("Better Than That")
         hash = {"first" => song}
-        @property.write({}, hash)
+        @property.write({}, hash, "song")
         assert_equal({"first" => song}, hash)
       end
     end

data/test/heritage_test.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+class HeritageTest < Minitest::Spec
+  module Hello
+    def hello
+      puts "Hello!"
+    end
+  end
+    module Ciao
+    def ciao
+      puts "Ciao!"
+    end
+  end
+
+
+  class A < Representable::Decorator
+    include Representable::Hash
+
+    feature Hello
+
+    property :id do
+    end
+  end
+
+  class B < A
+    feature Ciao # does NOT extend id, of course.
+
+    property :id, inherit: true do
+
+    end
+  end
+
+  class C < A
+    property :id do end # overwrite old :id.
+  end
+
+  it do
+    # puts A.heritage.inspect
+    # puts B.heritage.inspect
+
+    puts B.representable_attrs.get(:id)[:extend].(nil).new(nil).hello
+    puts B.representable_attrs.get(:id)[:extend].(nil).new(nil).ciao
+
+    # feature Hello must be "inherited" from A and included in new C properties, too.
+    puts C.representable_attrs.get(:id)[:extend].(nil).new(nil).hello
+  end
+
+  module M
+    include Representable
+    feature Hello
+  end
+
+  module N
+    include Representable
+    include M
+    feature Ciao
+  end
+
+  it do
+    Object.new.extend(N).hello
+  end
+end

data/test/if_test.rb

@@ -55,6 +55,7 @@ class IfTest < MiniTest::Spec
     it "works with decorator" do
       rpr = representer
       Class.new(Representable::Decorator) do
+        include Representable::Hash
         include rpr
       end.new(subject).to_hash.must_equal({})
     end

data/test/inherit_test.rb

@@ -55,8 +55,8 @@ class InheritTest < MiniTest::Spec
     representer! do
       include SongRepresenter
 
-      property :name, :inherit => true, :as => :name do # inherit module, only.
-        # that doesn't make sense.
+      property :name, inherit: true, as: :name do # inherit module, only.
+        # that doesn't make sense. but it should simply inherit the old nested properties.
       end
     end
 
@@ -91,7 +91,7 @@ class InheritTest < MiniTest::Spec
       definition = representer.representable_attrs.get(: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".
+      definition.name.must_equal "track" # was "no".
     end
   end
 
@@ -110,7 +110,9 @@ class InheritTest < MiniTest::Spec
 
     let (:inheriting) {
       class InheritingDecorator < representer
+        include Representable::Debug
         property :hit, :inherit => true do
+          include Representable::Debug
           property :length
         end
         self

data/test/instance_test.rb

@@ -36,7 +36,7 @@ class InstanceTest < BaseTest
         :extend => song_representer
     end
 
-    it { OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
+    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).
@@ -48,7 +48,6 @@ class InstanceTest < BaseTest
     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.
 
@@ -142,7 +141,7 @@ class InstanceTest < BaseTest
         :setter => lambda { |*|  }
     end
 
-    it {
+    it("hooray") {
       album= Struct.new(:songs).new(songs = [
       Song.new(1, "The Answer Is Still No"),
       Song.new(2, "Invncble")])
@@ -250,7 +249,7 @@ class InstanceTest < BaseTest
   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 }
+        :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

data/test/json_test.rb

@@ -88,25 +88,13 @@ module JsonTest
 
       describe "#build_for" do
         it "returns TextBinding" do
-          assert_kind_of Representable::Hash::Binding, Representable::Hash::Binding.build_for(Def.new(:band), nil)
-        end
-
-        it "returns HashBinding" do
-          assert_kind_of Representable::Hash::Binding::Hash, Representable::Hash::Binding.build_for(Def.new(:band, :hash => true), nil)
+          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), nil)
+          assert_kind_of Representable::Hash::Binding::Collection, Representable::Hash::Binding.build_for(Def.new(:band, :collection => true))
         end
       end
-
-      # describe "#representable_bindings_for" do
-      #   it "returns bindings for each property" do
-      #     bins = @band.send(:representable_bindings_for, Representable::JSON::Binding, {})
-      #     assert_equal 2, bins.size
-      #     assert_equal "name", bins.first.name
-      #   end
-      # end
     end
 
 
@@ -242,50 +230,6 @@ module JsonTest
       end
     end
 
-    describe ":default => :value" do
-      before do
-        @Album = Class.new do
-        include Representable::JSON
-        property :name, :default => "30 Years Live"
-        attr_accessor :name
-      end
-    end
-
-    describe "#from_json" do
-      it "uses default when property nil in doc" do
-        album = @Album.new.from_json({}.to_json)
-        assert_equal "30 Years Live", album.name
-      end
-
-      it "uses value from doc when present" do
-        album = @Album.new.from_json({:name => "Live At The Wireless"}.to_json)
-        assert_equal "Live At The Wireless", album.name
-      end
-
-      it "uses value from doc when empty string" do
-        album = @Album.new.from_json({:name => ""}.to_json)
-        assert_equal "", album.name
-      end
-    end
-
-    describe "#to_json" do
-      it "uses default when not available in object" do
-        assert_json "{\"name\":\"30 Years Live\"}", @Album.new.to_json
-      end
-
-      it "uses value from represented object when present" do
-        album = @Album.new
-        album.name = "Live At The Wireless"
-        assert_json "{\"name\":\"Live At The Wireless\"}", album.to_json
-      end
-
-      it "uses value from represented object when emtpy string" do
-        album = @Album.new
-        album.name = ""
-        assert_json "{\"name\":\"\"}", album.to_json
-      end
-    end
-  end
 end
 
 
@@ -302,7 +246,7 @@ end
         assert_equal ["Out in the cold", "Microphone"], cd.songs
       end
 
-      it "#to_json serializes correctly" do
+      it "zzz#to_json serializes correctly" do
         cd = CD.new
         cd.songs = ["Out in the cold", "Microphone"]
 

data/test/lonely_test.rb

@@ -36,7 +36,7 @@ class LonelyRepresenterTest < MiniTest::Spec
     property :name
   end
 
-  let (:decorator) { rpr = representer; Class.new(Representable::Decorator) { include rpr } }
+  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")] }
@@ -55,7 +55,7 @@ class LonelyRepresenterTest < MiniTest::Spec
         assert_json json, songs.extend(representer).to_json
       end
 
-      it "renders array with decorator xxx" do
+      it "renders array with decorator" do
         assert_json json, decorator.new(songs).to_json
       end
 
@@ -98,6 +98,23 @@ class LonelyRepresenterTest < MiniTest::Spec
     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
@@ -141,7 +158,7 @@ class LonelyRepresenterTest < MiniTest::Spec
           assert_equal({"two" => Song.new("Can't Take Them All")}, {}.extend(representer).from_json(json, :exclude => [:one]))
         end
 
-        it "respects :include" do
+        it "xxxrespects :include" do
           assert_equal({"one" => Song.new("Days Go By")}, {}.extend(representer).from_json(json, :include => [:one]))
         end
       end
@@ -160,6 +177,33 @@ class LonelyRepresenterTest < MiniTest::Spec
     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