representable 2.0.4 → 2.1.0

data/test/lonely_test.rb

@@ -28,7 +28,7 @@ class LonelyRepresenterTest < MiniTest::Spec
         assert_json json, songs.extend(representer).to_json
       end
 
-      it "renders array with decorator" do
+      it "renders array with decorator xxx" do
         assert_json json, decorator.new(songs).to_json
       end
 

data/test/realistic_benchmark.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+require 'benchmark'
+
+SONG_PROPERTIES = 50.times.collect do |i|
+  "property_#{i}"
+end
+
+
+module SongRepresenter
+  include Representable::JSON
+
+  SONG_PROPERTIES.each { |p| property p }
+end
+
+class SongDecorator < Representable::Decorator
+  include Representable::JSON
+
+  SONG_PROPERTIES.each { |p| property p }
+end
+
+module AlbumRepresenter
+  include Representable::JSON
+
+  # collection :songs, extend: SongRepresenter
+  collection :songs, extend: SongDecorator
+end
+
+def random_song
+  attrs = Hash[SONG_PROPERTIES.collect { |n| [n,n] }]
+  OpenStruct.new(attrs)
+end
+
+times = []
+
+3.times.each do
+  album = OpenStruct.new(songs: 50.times.collect { random_song })
+
+  times << Benchmark.measure do
+    puts "================ next!"
+    album.extend(AlbumRepresenter).to_json
+  end
+end
+
+puts times.join("")
+
+# 100 songs, 100 attrs
+#  0.050000   0.000000   0.050000 (  0.093157)
+
+## 100 songs, 1000 attrs
+#  0.470000   0.010000   0.480000 (  0.483708)
+
+
+### without binding cache:
+  # 2.790000   0.030000   2.820000 (  2.820190)
+
+
+
+### with extend: on Song, with binding cache>
+  # 2.490000   0.030000   2.520000 (  2.517433) 2.4-3.0
+  ### without skip?
+  # 2.030000   0.020000   2.050000 (  2.050796) 2.1-2.3
+
+    ### without :writer
+    # 2.270000   0.010000   2.280000 (  2.284530 1.9-2.2
+      ### without :render_filter
+      #   2.020000   0.000000   2.020000 (  2.030234) 1.5-2.0
+        ###without default_for and skipable?
+        #   1.730000   0.010000   1.740000 (  1.735597 1.4-1.7
+          ### without :serialize
+          #   1.780000   0.010000   1.790000 (  1.786791) 1.4-1.7
+          ### using decorator
+          # 1.400000   0.030000   1.430000 (  1.434206) 1.4-1.6
+            ### with prepare AFTER  representable?
+            # 1.330000   0.010000   1.340000 (  1.335900) 1.1-1.3
+
+
+# representable 2.0
+# 3.000000   0.020000   3.020000 (  3.013031) 2.7-3.0
+
+# no method missing
+# 2.280000   0.030000   2.310000 (  2.313522) 2.2-2.5
+# no def_delegator in Definition
+# 2.130000   0.010000   2.140000 (  2.136115) 1.7-2.1

data/test/skip_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class SkipTest < MiniTest::Spec
+  representer! do
+    property :title
+    property :band,
+      skip_parse: lambda { |fragment, opts| opts[:skip?] and fragment["name"].nil? }, class: OpenStruct do
+        property :name
+    end
+
+    collection :airplays,
+      skip_parse: lambda { |fragment, opts| puts fragment.inspect; opts[:skip?] and fragment["station"].nil? }, class: OpenStruct do
+        property :station
+    end
+  end
+
+  let (:song) { OpenStruct.new.extend(representer) }
+
+  # do parse.
+  it { song.from_hash({"band" => {"name" => "Mute 98"}}, skip?: true).band.name.must_equal "Mute 98" }
+  it { song.from_hash({"airplays" => [{"station" => "JJJ"}]}, skip?: true).airplays[0].station.must_equal "JJJ" }
+
+  # skip parsing.
+  it { song.from_hash({"band" => {}}, skip?: true).band.must_equal nil }
+  # skip_parse is _per item_.
+  let (:airplay) { OpenStruct.new(station: "JJJ") }
+  it { song.from_hash({"airplays" => [{"station" => "JJJ"}, {}]}, skip?: true).airplays.must_equal [airplay] }
+end

data/test/xml_bindings_test.rb

@@ -23,120 +23,13 @@ class XMLBindingTest < MiniTest::Spec
     @song = SongWithRepresenter.new("Thinning the Herd")
   end
 
-  describe "PropertyBinding" do
-    describe "with plain text" do
-      before do
-        @property = Representable::XML::PropertyBinding.new(Representable::Definition.new(:song), nil, nil, {:doc => @doc})
-      end
-
-      it "extracts with #read" do
-        assert_equal "Thinning the Herd", @property.read(Nokogiri::XML("<song>Thinning the Herd</song>"))
-      end
-
-      it "inserts with #write" do
-        @property.write(@doc, "Thinning the Herd")
-        assert_xml_equal "<song>Thinning the Herd</song>", @doc.to_s
-      end
-    end
-
-    describe "with an object" do
-      before do
-        @property = Representable::XML::PropertyBinding.new(Representable::Definition.new(:song, :class => SongWithRepresenter), nil, nil, {:doc => @doc})
-      end
-
-      it "extracts with #read" do
-        assert_equal @song, @property.read(Nokogiri::XML("<song><name>Thinning the Herd</name></song>"))
-      end
-
-      it "inserts with #write" do
-        @property.write(@doc, @song)
-        assert_xml_equal("<song><name>Thinning the Herd</name></song>", @doc.to_s)
-      end
-    end
-
-    describe "with an object and :extend" do
-      before do
-        @property = Representable::XML::PropertyBinding.new(Representable::Definition.new(:song, :class => Song, :extend => SongRepresenter), nil, nil, {:doc => @doc})
-      end
-
-      it "extracts with #read" do
-        assert_equal @song, @property.read(Nokogiri::XML("<song><name>Thinning the Herd</name></song>"))
-      end
-
-      it "inserts with #write" do
-        @property.write(@doc, @song)
-        assert_xml_equal("<song><name>Thinning the Herd</name></song>", @doc.to_s)
-      end
-    end
-  end
-
-
-  describe "CollectionBinding" do
-    describe "with plain text items" do
-      before do
-        @property = Representable::XML::CollectionBinding.new(Representable::Definition.new(:song, :collection => true), Struct.new(:song).new, nil)
-      end
 
-      it "extracts with #read" do
-        assert_equal ["The Gargoyle", "Bronx"], @property.read(Nokogiri::XML("<doc><song>The Gargoyle</song><song>Bronx</song></doc>").root)
-      end
-
-      it "inserts with #write" do
-        parent = Nokogiri::XML::Node.new("parent", @doc)
-        @property.write(parent, ["The Gargoyle", "Bronx"])
-        assert_xml_equal("<songs><song>The Gargoyle</song><song>Bronx</song></songs>", parent.to_s)
-      end
-    end
-
-    describe "with objects" do
-      before do
-        @property = Representable::XML::PropertyBinding.new(Representable::Definition.new(:song, :collection => true, :class => SongWithRepresenter), nil, nil, {:doc => @doc})
-      end
-
-      it "extracts with #read" do
-        assert_equal @song, @property.read(Nokogiri::XML("<song><name>Thinning the Herd</name></song>"))
-      end
-
-      it "inserts with #write" do
-        @property.write(@doc, @song)
-        assert_xml_equal("<song><name>Thinning the Herd</name></song>", @doc.to_s)
-        assert_kind_of Nokogiri::XML::Node, @doc.children.first
-        assert_equal "song", @doc.children.first.name
-        assert_equal "name", @doc.children.first.children.first.name
-      end
-    end
-  end
-
-
-  describe "HashBinding" do
-    describe "with plain text items" do
-      before do
-        @property = Representable::XML::HashBinding.new(Representable::Definition.new(:songs, :hash => true), nil, nil)
-      end
-
-      it "extracts with #read" do
-        assert_equal({"first" => "The Gargoyle", "second" => "Bronx"} , @property.read(Nokogiri::XML("<songs><first>The Gargoyle</first><second>Bronx</second></songs>")))
-      end
-
-      it "inserts with #write" do
-        parent = Nokogiri::XML::Node.new("parent", @doc)
-        @property.write(parent, {"first" => "The Gargoyle", "second" => "Bronx"})
-        assert_xml_equal("<songs><first>The Gargoyle</first><second>Bronx</second></songs>", parent.to_s)
-      end
-    end
-
-    describe "with objects" do
-      before do
-        @property = Representable::XML::HashBinding.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter), nil)
-      end
-    end
-  end
 
 
   describe "AttributeBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::XML::AttributeBinding.new(Representable::Definition.new(:name, :attribute => true), nil, nil)
+        @property = Representable::XML::Binding::Attribute.new(Representable::Definition.new(:name, :attribute => true), nil, nil)
       end
 
       it "extracts with #read" do
@@ -153,7 +46,7 @@ class XMLBindingTest < MiniTest::Spec
 
   describe "ContentBinding" do
     before do
-      @property = Representable::XML::ContentBinding.new(Representable::Definition.new(:name, :content => true), nil, nil)
+      @property = Representable::XML::Binding::Content.new(Representable::Definition.new(:name, :content => true), nil, nil)
     end
 
     it "extracts with #read" do

data/test/xml_test.rb

@@ -104,20 +104,20 @@ class XmlTest < MiniTest::Spec
 
     describe "XML::Binding#build_for" do
       it "returns AttributeBinding" do
-        assert_kind_of XML::AttributeBinding, XML::PropertyBinding.build_for(Def.new(:band, :as => "band", :attribute => true), nil, nil)
+        assert_kind_of XML::Binding::Attribute, XML::Binding.build_for(Def.new(:band, :as => "band", :attribute => true), nil, nil)
       end
 
-      it "returns PropertyBinding" do
-        assert_kind_of XML::PropertyBinding, XML::PropertyBinding.build_for(Def.new(:band, :class => Hash), nil, nil)
-        assert_kind_of XML::PropertyBinding, XML::PropertyBinding.build_for(Def.new(:band, :as => :content), nil, nil)
+      it "returns Binding" do
+        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :class => Hash), nil, nil)
+        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :as => :content), nil, nil)
       end
 
       it "returns CollectionBinding" do
-        assert_kind_of XML::CollectionBinding, XML::PropertyBinding.build_for(Def.new(:band, :collection => :true), nil, nil)
+        assert_kind_of XML::Binding::Collection, XML::Binding.build_for(Def.new(:band, :collection => :true), nil, nil)
       end
 
       it "returns HashBinding" do
-        assert_kind_of XML::HashBinding, XML::PropertyBinding.build_for(Def.new(:band, :hash => :true), nil, nil)
+        assert_kind_of XML::Binding::Hash, XML::Binding.build_for(Def.new(:band, :hash => :true), nil, nil)
       end
     end
 
@@ -206,7 +206,7 @@ end
 
 
 class CDataBand
-  class CData < Representable::XML::PropertyBinding
+  class CData < Representable::XML::Binding
     def serialize_node(parent, value)
       parent << Nokogiri::XML::CDATA.new(parent, represented.name)
     end
@@ -320,14 +320,14 @@ class CollectionTest < MiniTest::Spec
 
 
   describe ":as" do
-    let(:xml) {
+    let(:xml_doc) {
       Module.new do
         include Representable::XML
         collection :songs, :as => :song
       end }
 
     it "collects untyped items" do
-      album = Album.new.extend(xml).from_xml(%{
+      album = Album.new.extend(xml_doc).from_xml(%{
         <album>
           <song>Two Kevins</song>
           <song>Wright and Rong</song>
@@ -340,8 +340,8 @@ class CollectionTest < MiniTest::Spec
 
 
   describe ":wrap" do
-    let (:album) { Album.new.extend(xml) }
-    let (:xml) {
+    let (:album) { Album.new.extend(xml_doc) }
+    let (:xml_doc) {
       Module.new do
         include Representable::XML
         collection :songs, :as => :song, :wrap => :songs
@@ -397,22 +397,22 @@ class CollectionTest < MiniTest::Spec
         end
 
         let (:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
-        let (:xml)   { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
+        let (:xml_doc)   { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
 
         it "renders array" do
-          songs.extend(representer).to_xml.must_equal_xml xml
+          songs.extend(representer).to_xml.must_equal_xml xml_doc
         end
 
         it "renders array with decorator" do
-          decorator.new(songs).to_xml.must_equal_xml xml
+          decorator.new(songs).to_xml.must_equal_xml xml_doc
         end
 
         it "parses array" do
-          [].extend(representer).from_xml(xml).must_equal songs
+          [].extend(representer).from_xml(xml_doc).must_equal songs
         end
 
         it "parses array with decorator" do
-          decorator.new([]).from_xml(xml).must_equal songs
+          decorator.new([]).from_xml(xml_doc).must_equal songs
         end
       end
     end
@@ -423,11 +423,11 @@ class CollectionTest < MiniTest::Spec
       end
 
       let (:songs) { {"one" => "Graveyards", "two" => "Can't Take Them All"} }
-      let (:xml)   { "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
+      let (:xml_doc)   { "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
 
       describe "#to_xml" do
         it "renders hash" do
-          songs.extend(representer).to_xml.must_equal_xml xml
+          songs.extend(representer).to_xml.must_equal_xml xml_doc
         end
 
         it "respects :exclude" do
@@ -439,27 +439,65 @@ class CollectionTest < MiniTest::Spec
         end
 
         it "renders hash with decorator" do
-          decorator.new(songs).to_xml.must_equal_xml xml
+          decorator.new(songs).to_xml.must_equal_xml xml_doc
         end
       end
 
       describe "#from_json" do
         it "returns hash" do
-          {}.extend(representer).from_xml(xml).must_equal songs
+          {}.extend(representer).from_xml(xml_doc).must_equal songs
         end
 
         it "respects :exclude" do
-          assert_equal({"two" => "Can't Take Them All"}, {}.extend(representer).from_xml(xml, :exclude => [:one]))
+          assert_equal({"two" => "Can't Take Them All"}, {}.extend(representer).from_xml(xml_doc, :exclude => [:one]))
         end
 
         it "respects :include" do
-          assert_equal({"one" => "Graveyards"}, {}.extend(representer).from_xml(xml, :include => [:one]))
+          assert_equal({"one" => "Graveyards"}, {}.extend(representer).from_xml(xml_doc, :include => [:one]))
         end
 
         it "parses hash with decorator" do
-          decorator.new({}).from_xml(xml).must_equal songs
+          decorator.new({}).from_xml(xml_doc).must_equal songs
         end
       end
     end
   end
 end
+
+class XmlHashTest < MiniTest::Spec
+  # scalar, no object
+  describe "plain text" do
+    representer!(module: Representable::XML) do
+      hash :songs
+    end
+
+    let (:doc) { "<open_struct><first>The Gargoyle</first><second>Bronx</second></open_struct>" }
+
+    # to_xml
+    it { OpenStruct.new(songs: {"first" => "The Gargoyle", "second" => "Bronx"}).extend(representer).to_xml.must_equal_xml(doc) }
+    # FIXME: this NEVER worked!
+    # it { OpenStruct.new.extend(representer).from_xml(doc).songs.must_equal({"first" => "The Gargoyle", "second" => "Bronx"}) }
+  end
+
+  describe "with objects" do
+    representer!(module: Representable::XML) do
+      hash :songs, class: OpenStruct do
+        property :title
+      end
+    end
+
+    let (:doc) { "<open_struct>
+  <open_struct>
+    <title>The Gargoyle</title>
+  </open_struct>
+  <open_struct>
+    <title>Bronx</title>
+  </open_struct>
+</open_struct>" }
+
+    # to_xml
+    it { OpenStruct.new(songs: {"first" => OpenStruct.new(title: "The Gargoyle"), "second" => OpenStruct.new(title: "Bronx")}).extend(representer).to_xml.must_equal_xml(doc) }
+    # FIXME: this NEVER worked!
+    # it { OpenStruct.new.extend(representer).from_xml(doc).songs.must_equal({"first" => "The Gargoyle", "second" => "Bronx"}) }
+  end
+end

data/test/yaml_test.rb

@@ -124,18 +124,15 @@ songs: [Off Key Melody, Sinking]").must_equal Album.new(["Off Key Melody", "Sink
 
 
     describe "with :class and :extend" do
-      yaml_song = yaml_representer do
-        property :name
-        property :track
-      end
       let (:yaml_album) { Module.new do
         include Representable::YAML
-        collection :songs, :extend => yaml_song, :class => Song
+        collection :songs, :class => Song do
+          property :name
+          property :track
+        end
       end }
 
-      let (:album) { Album.new.tap do |album|
-        album.songs = [Song.new("Liar", 1), Song.new("What I Know", 2)]
-      end }
+      let (:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
 
 
       describe "#to_yaml" do