representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/private_options_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+class PrivateOptionsTest < MiniTest::Spec # TODO: move me to separate file.
+  representer!(decorator: true) do
+  end
+
+  options = {exclude: "name"}
+
+  it "render: doesn't modify options" do
+    representer.new(nil).to_hash(options)
+    options.must_equal({exclude: "name"})
+  end
+
+  it "parse: doesn't modify options" do
+    representer.new(nil).from_hash(options)
+    options.must_equal({exclude: "name"})
+  end
+end

data/test-with-deprecations/reader_writer_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class ReaderWriterTest < BaseTest
+  representer! do
+    property :name,
+      :writer => lambda { |doc, args| doc["title"] = "#{args[:nr]}) #{name}" },
+      :reader => lambda { |doc, args| self.name = doc["title"].split(") ").last }
+  end
+
+  subject { OpenStruct.new(:name => "Disorder And Disarray").extend(representer) }
+
+  it "uses :writer when rendering" do
+    subject.to_hash(:nr => 14).must_equal({"title" => "14) Disorder And Disarray"})
+  end
+
+  it "uses :reader when parsing" do
+    subject.from_hash({"title" => "15) The Wars End"}).name.must_equal "The Wars End"
+  end
+end

data/test-with-deprecations/realistic_benchmark.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+require 'benchmark'
+
+Kernel.class_eval do
+  # def respond_to_missing?
+  #   raise
+  # end
+#   alias_method :orig_hash, :hash
+#   def hash
+#     puts "hash in #{self.class}"
+#     raise self.inspect if self.class == Symbol
+#     orig_hash
+#   end
+end
+Representable.deprecations = false
+
+SONG_PROPERTIES = 50.times.collect do |i|
+  "song_property_#{i}"
+end
+
+
+module SongRepresenter
+  include Representable::JSON
+
+  SONG_PROPERTIES.each { |p| property p }
+end
+
+class NestedProperty < Representable::Decorator
+  include Representable::JSON
+
+  SONG_PROPERTIES.each { |p| property p }
+end
+
+
+class SongDecorator < Representable::Decorator
+  include Representable::JSON
+
+  SONG_PROPERTIES.each { |p| property p, extend: NestedProperty }
+end
+
+class AlbumRepresenter < Representable::Decorator
+  include Representable::JSON
+
+  # collection :songs, extend: SongRepresenter
+  collection :songs, extend: SongDecorator
+end
+
+Song  = Struct.new(*SONG_PROPERTIES.map(&:to_sym))
+Album = Struct.new(:songs)
+
+def random_song
+  Song.new(*SONG_PROPERTIES.collect { |p| Song.new(*SONG_PROPERTIES) })
+end
+
+times = []
+
+3.times.each do
+  album = Album.new(100.times.collect { random_song })
+
+  times << Benchmark.measure do
+    puts "================ next!"
+    AlbumRepresenter.new(album).to_json
+  end
+end
+
+puts times.join("")
+
+album = Album.new(100.times.collect { random_song })
+require 'ruby-prof'
+RubyProf.start
+AlbumRepresenter.new(album).to_hash
+res = RubyProf.stop
+printer = RubyProf::FlatPrinter.new(res)
+printer.print(array = [])
+
+array[0..60].each { |a| puts a }
+
+# 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-with-deprecations/render_nil_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+class RenderNilTest < MiniTest::Spec
+  Song = Struct.new(:title)
+
+  describe "render_nil: true" do
+    representer! do
+      property :title, render_nil: true
+    end
+
+    it { Song.new.extend(representer).to_hash.must_equal({"title"=>nil}) }
+  end
+
+  describe "with :extend it shouldn't extend nil" do
+    representer! do
+      property :title, render_nil: true, extend: Class
+    end
+
+    it { Song.new.extend(representer).to_hash.must_equal({"title"=>nil}) }
+  end
+end

data/test-with-deprecations/represent_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+class RepresentTest < MiniTest::Spec
+  let (:songs) { [song, Song.new("Can't Take Them All")] }
+  let (:song) { Song.new("Days Go By") }
+
+  for_formats(
+    :hash => [Representable::Hash, out=[{"name" => "Days Go By"}, {"name"=>"Can't Take Them All"}], out],
+    # :json => [Representable::JSON, out="[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]", out],
+    # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
+  ) do |format, mod, output, input|
+
+    # Representer.represents detects collection.
+    describe "Module#to_/from_#{format}" do
+      let (:format) { format }
+
+      let (:representer) {
+        Module.new do
+          include mod
+          property :name
+
+          collection_representer :class => Song # TODOOOOOOOOOOOO: test without Song and fix THIS FUCKINGNoMethodError: undefined method `name=' for {"name"=>"Days Go By"}:Hash ERROR!!!!!!!!!!!!!!!
+        end
+      }
+
+      it { render(representer.represent(songs)).must_equal_document output }
+      it { parse(representer.represent([]), input).must_equal songs }
+    end
+
+    # Decorator.represents detects collection.
+    describe "Decorator#to_/from_#{format}" do
+      let (:format) { format }
+      let (:representer) {
+        Class.new(Representable::Decorator) do
+          include mod
+          property :name
+
+          collection_representer :class => Song
+        end
+      }
+
+      it { render(representer.represent(songs)).must_equal_document output }
+      it("ficken") { parse(representer.represent([]), input).must_equal songs }
+    end
+  end
+
+
+  for_formats(
+    :hash => [Representable::Hash, out={"name" => "Days Go By"}, out],
+    :json => [Representable::JSON, out="{\"name\":\"Days Go By\"}", out],
+    # :xml  => [Representable::XML,  out="<a><song></song><song></song></a>", out]
+  ) do |format, mod, output, input|
+
+    # Representer.represents detects singular.
+    describe "Module#to_/from_#{format}" do
+      let (:format) { format }
+
+      let (:representer) {
+        Module.new do
+          include mod
+          property :name
+
+          collection_representer :class => Song
+        end
+      }
+
+      it { render(representer.represent(song)).must_equal_document output }
+      it { parse(representer.represent(Song.new), input).must_equal song }
+    end
+
+
+    # Decorator.represents detects singular.
+    describe "Decorator#to_/from_#{format}" do
+      let (:format) { format }
+      let (:representer) {
+        Class.new(Representable::Decorator) do
+          include mod
+          property :name
+
+          collection_representer :class => Song
+        end
+      }
+
+      it { render(representer.represent(song)).must_equal_document output }
+      it { parse(representer.represent(Song.new), input).must_equal song }
+    end
+  end
+end

data/test-with-deprecations/representable_test.rb

@@ -0,0 +1,511 @@
+require 'test_helper'
+
+class RepresentableTest < MiniTest::Spec
+  class Band
+    include Representable::Hash
+    property :name
+    attr_accessor :name
+  end
+
+  class PunkBand < Band
+    property :street_cred
+    attr_accessor :street_cred
+  end
+
+  module BandRepresentation
+    include Representable
+
+    property :name
+  end
+
+  module PunkBandRepresentation
+    include Representable
+    include BandRepresentation
+
+    property :street_cred
+  end
+
+
+  describe "#representable_attrs" do
+    describe "in module" do
+      it "allows including the concrete representer module later" do
+        vd = class VD
+          attr_accessor :name, :street_cred
+          include Representable::JSON
+          include PunkBandRepresentation
+        end.new
+        vd.name        = "Vention Dention"
+        vd.street_cred = 1
+        assert_json "{\"name\":\"Vention Dention\",\"street_cred\":1}", vd.to_json
+      end
+
+      #it "allows including the concrete representer module only" do
+      #  require 'representable/json'
+      #  module RockBandRepresentation
+      #    include Representable::JSON
+      #    property :name
+      #  end
+      #  vd = class VH
+      #    include RockBandRepresentation
+      #  end.new
+      #  vd.name        = "Van Halen"
+      #  assert_equal "{\"name\":\"Van Halen\"}", vd.to_json
+      #end
+    end
+  end
+
+
+  describe "inheritance" do
+    class CoverSong < OpenStruct
+    end
+
+    module SongRepresenter
+      include Representable::Hash
+      property :name
+    end
+
+    module CoverSongRepresenter
+      include Representable::Hash
+      include SongRepresenter
+      property :by
+    end
+
+    it "merges properties from all ancestors" do
+      props = {"name"=>"The Brews", "by"=>"Nofx"}
+      assert_equal(props, CoverSong.new(props).extend(CoverSongRepresenter).to_hash)
+    end
+
+    it "allows mixing in multiple representers" do
+      require 'representable/json'
+      require 'representable/xml'
+      class Bodyjar
+        include Representable::XML
+        include Representable::JSON
+        include PunkBandRepresentation
+
+        self.representation_wrap = "band"
+        attr_accessor :name, :street_cred
+      end
+
+      band = Bodyjar.new
+      band.name = "Bodyjar"
+
+      assert_json "{\"band\":{\"name\":\"Bodyjar\"}}", band.to_json
+      assert_xml_equal "<band><name>Bodyjar</name></band>", band.to_xml
+    end
+
+    it "allows extending with different representers subsequentially" do
+      module SongXmlRepresenter
+        include Representable::XML
+        property :name, :as => "name", :attribute => true
+      end
+
+      module SongJsonRepresenter
+        include Representable::JSON
+        property :name
+      end
+
+      @song = Song.new("Days Go By")
+      assert_xml_equal "<song name=\"Days Go By\"/>", @song.extend(SongXmlRepresenter).to_xml
+      assert_json "{\"name\":\"Days Go By\"}", @song.extend(SongJsonRepresenter).to_json
+    end
+
+
+    # test if we call super in
+    #   ::inherited
+    #   ::included
+    #   ::extended
+    module Representer
+      include Representable # overrides ::inherited.
+    end
+
+    class BaseClass
+      def self.inherited(subclass)
+        super
+        subclass.instance_eval { def other; end }
+      end
+
+      include Representable # overrides ::inherited.
+      include Representer
+    end
+
+    class SubClass < BaseClass # triggers Representable::inherited, then OtherModule::inherited.
+    end
+
+    # test ::inherited.
+    it do
+      BaseClass.respond_to?(:other).must_equal false
+      SubClass.respond_to?(:other).must_equal true
+    end
+
+    module DifferentIncluded
+      def included(includer)
+        includer.instance_eval { def different; end }
+      end
+    end
+
+    module CombinedIncluded
+      extend DifferentIncluded # defines ::included.
+      include Representable    # overrides ::included.
+    end
+
+    class IncludingClass
+      include Representable
+      include CombinedIncluded
+    end
+
+    # test ::included.
+    it do
+      IncludingClass.respond_to?(:representable_attrs) # from Representable
+      IncludingClass.respond_to?(:different)
+    end
+  end
+
+
+  describe "#property" do
+    it "doesn't modify options hash" do
+      options = {}
+      representer.property(:title, options)
+      options.must_equal({})
+    end
+
+    representer! {}
+
+    it "returns the Definition instance" do
+      representer.property(:name).must_be_kind_of Representable::Definition
+    end
+  end
+
+  describe "#collection" do
+    class RockBand < Band
+      collection :albums
+    end
+
+    it "creates correct Definition" do
+      assert_equal "albums", RockBand.representable_attrs.get(:albums).name
+      assert RockBand.representable_attrs.get(:albums).array?
+    end
+  end
+
+  describe "#hash" do
+    it "also responds to the original method" do
+      assert_kind_of Integer, BandRepresentation.hash
+    end
+  end
+
+  class Hometown
+    attr_accessor :name
+  end
+
+  module HometownRepresentable
+    include Representable::JSON
+    property :name
+  end
+
+  # DISCUSS: i don't like the JSON requirement here, what about some generic test module?
+  class PopBand
+    include Representable::JSON
+    property :name
+    property :groupies
+    property :hometown, class: Hometown, extend: HometownRepresentable
+    attr_accessor :name, :groupies, :hometown
+  end
+
+  describe "#update_properties_from" do
+    before do
+      @band = PopBand.new
+    end
+
+    it "copies values from document to object" do
+      @band.from_hash({"name"=>"No One's Choice", "groupies"=>2})
+      assert_equal "No One's Choice", @band.name
+      assert_equal 2, @band.groupies
+    end
+
+    it "ignores non-writeable properties" do
+      @band = Class.new(Band) { property :name; collection :founders, :writeable => false; attr_accessor :founders }.new
+      @band.from_hash("name" => "Iron Maiden", "groupies" => 2, "founders" => ["Steve Harris"])
+      assert_equal "Iron Maiden", @band.name
+      assert_equal nil, @band.founders
+    end
+
+    it "always returns the represented" do
+      assert_equal @band, @band.from_hash({"name"=>"Nofx"})
+    end
+
+    it "includes false attributes" do
+      @band.from_hash({"groupies"=>false})
+      assert_equal false, @band.groupies
+    end
+
+    it "ignores properties not present in the incoming document" do
+      @band.instance_eval do
+        def name=(*); raise "I should never be called!"; end
+      end
+      @band.from_hash({})
+    end
+
+
+    # FIXME: do we need this test with XML _and_ JSON?
+    it "ignores (no-default) properties not present in the incoming document" do
+      { Representable::Hash => [:from_hash, {}],
+        Representable::XML  => [:from_xml,  xml(%{<band/>}).to_s]
+      }.each do |format, config|
+        nested_repr = Module.new do # this module is never applied. # FIXME: can we make that a simpler test?
+          include format
+          property :created_at
+        end
+
+        repr = Module.new do
+          include format
+          property :name, :class => Object, :extend => nested_repr
+        end
+
+        @band = Band.new.extend(repr)
+        @band.send(config.first, config.last)
+        assert_equal nil, @band.name, "Failed in #{format}"
+      end
+    end
+
+    describe "passing options" do
+      module TrackRepresenter
+        include Representable::Hash
+
+      end
+
+      representer! do
+        property :track, class: OpenStruct do
+          property :nr
+
+          property :length, class: OpenStruct do
+            def to_hash(options)
+              {seconds: options[:user_options][:nr]}
+            end
+
+            def from_hash(hash, options)
+              super.tap do
+                self.seconds = options[:user_options][:nr]
+              end
+            end
+          end
+
+          def to_hash(options)
+            super.merge({"nr" => options[:user_options][:nr]})
+          end
+
+          def from_hash(data, options)
+            super.tap do
+              self.nr = options[:user_options][:nr]
+            end
+          end
+        end
+      end
+
+      it "#to_hash propagates to nested objects" do
+        OpenStruct.new(track: OpenStruct.new(nr: 1, length: OpenStruct.new(seconds: nil))).extend(representer).extend(Representable::Debug).
+          to_hash(nr: 9).must_equal({"track"=>{"nr"=>9, "length"=>{seconds: 9}}})
+      end
+
+      it "#from_hash propagates to nested objects" do
+        song = OpenStruct.new.extend(representer).from_hash({"track"=>{"nr" => "replace me", "length"=>{"seconds"=>"replacing"}}}, :nr => 9)
+        song.track.nr.must_equal 9
+        song.track.length.seconds.must_equal 9
+      end
+    end
+  end
+
+  describe "#create_representation_with" do
+    before do
+      @band = PopBand.new
+      @band.name = "No One's Choice"
+      @band.groupies = 2
+    end
+
+    it "compiles document from properties in object" do
+      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.to_hash)
+    end
+
+    it "ignores non-readable properties" do
+      @band = Class.new(Band) { property :name; collection :founder_ids, :readable => false; attr_accessor :founder_ids }.new
+      @band.name = "Iron Maiden"
+      @band.founder_ids = [1,2,3]
+
+      hash = @band.to_hash
+      assert_equal({"name" => "Iron Maiden"}, hash)
+    end
+
+    it "does not write nil attributes" do
+      @band.groupies = nil
+      assert_equal({"name"=>"No One's Choice"}, @band.to_hash)
+    end
+
+    it "writes false attributes" do
+      @band.groupies = false
+      assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.to_hash)
+    end
+  end
+
+
+  describe ":extend and :class" do
+    module UpcaseRepresenter
+      include Representable
+      def to_hash(*); upcase; end
+      def from_hash(hsh, *args); replace hsh.upcase; end   # DISCUSS: from_hash must return self.
+    end
+    module DowncaseRepresenter
+      include Representable
+      def to_hash(*); downcase; end
+      def from_hash(hsh, *args); replace hsh.downcase; end
+    end
+    class UpcaseString < String; end
+
+
+    describe "lambda blocks" do
+      representer! do
+        property :name, :extend => lambda { |name, *| compute_representer(name) }
+      end
+
+      it "executes lambda in represented instance context" do
+        Song.new("Carnage").instance_eval do
+          def compute_representer(name)
+            UpcaseRepresenter
+          end
+          self
+        end.extend(representer).to_hash.must_equal({"name" => "CARNAGE"})
+      end
+    end
+
+    describe ":instance" do
+      obj = String.new("Fate")
+      mod = Module.new { include Representable; def from_hash(*); self; end }
+      representer! do
+        property :name, :extend => mod, :instance => lambda { |*| obj }
+      end
+
+      it "uses object from :instance but still extends it" do
+        song = Song.new.extend(representer).from_hash("name" => "Eric's Had A Bad Day")
+        song.name.must_equal obj
+        song.name.must_be_kind_of mod
+      end
+    end
+
+    describe "property with :extend" do
+      representer! do
+        property :name, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
+      end
+
+      it "uses lambda when rendering" do
+        assert_equal({"name" => "you make me thick"}, Song.new("You Make Me Thick").extend(representer).to_hash )
+        assert_equal({"name" => "STEPSTRANGER"}, Song.new(UpcaseString.new "Stepstranger").extend(representer).to_hash )
+      end
+
+      it "uses lambda when parsing" do
+        Song.new.extend(representer).from_hash({"name" => "You Make Me Thick"}).name.must_equal "you make me thick"
+        Song.new.extend(representer).from_hash({"name" => "Stepstranger"}).name.must_equal "stepstranger" # DISCUSS: we compare "".is_a?(UpcaseString)
+      end
+
+      describe "with :class lambda" do
+        representer! do
+          property :name, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
+                          :class  => lambda { |fragment, *| fragment == "Still Failing?" ? String : UpcaseString }
+        end
+
+        it "creates instance from :class lambda when parsing" do
+          song = OpenStruct.new.extend(representer).from_hash({"name" => "Quitters Never Win"})
+          song.name.must_be_kind_of UpcaseString
+          song.name.must_equal "QUITTERS NEVER WIN"
+
+          song = OpenStruct.new.extend(representer).from_hash({"name" => "Still Failing?"})
+          song.name.must_be_kind_of String
+          song.name.must_equal "still failing?"
+        end
+      end
+    end
+
+
+    describe "collection with :extend" do
+      representer! do
+        collection :songs, :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
+      end
+
+      it "uses lambda for each item when rendering" do
+        Album.new([UpcaseString.new("Dean Martin"), "Charlie Still Smirks"]).extend(representer).to_hash.must_equal("songs"=>["DEAN MARTIN", "charlie still smirks"])
+      end
+
+      it "uses lambda for each item when parsing" do
+        album = Album.new.extend(representer).from_hash("songs"=>["DEAN MARTIN", "charlie still smirks"])
+        album.songs.must_equal ["dean martin", "charlie still smirks"] # DISCUSS: we compare "".is_a?(UpcaseString)
+      end
+
+      describe "with :class lambda" do
+        representer! do
+          collection :songs,  :extend => lambda { |name, *| name.is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
+                              :class  => lambda { |fragment, *| fragment == "Still Failing?" ? String : UpcaseString }
+        end
+
+        it "creates instance from :class lambda for each item when parsing" do
+          album = Album.new.extend(representer).from_hash("songs"=>["Still Failing?", "charlie still smirks"])
+          album.songs.must_equal ["still failing?", "CHARLIE STILL SMIRKS"]
+        end
+      end
+    end
+
+    describe ":decorator" do
+      let (:extend_rpr) { Module.new { include Representable::Hash; collection :songs, :extend => SongRepresenter } }
+      let (:decorator_rpr) { Module.new { include Representable::Hash; collection :songs, :decorator => SongRepresenter } }
+      let (:songs) { [Song.new("Bloody Mary")] }
+
+      it "is aliased to :extend" do
+        Album.new(songs).extend(extend_rpr).to_hash.must_equal Album.new(songs).extend(decorator_rpr).to_hash
+      end
+    end
+
+    describe ":binding" do
+      representer! do
+        class MyBinding < Representable::Binding
+          def write(doc, *args)
+            doc[:title] = represented.title
+          end
+        end
+        property :title, :binding => lambda { |*args| MyBinding.new(*args) }
+      end
+
+      it "uses the specified binding instance" do
+        OpenStruct.new(:title => "Affliction").extend(representer).to_hash.must_equal({:title => "Affliction"})
+      end
+    end
+
+
+    # TODO: Move to global place since it's used twice.
+    class SongRepresentation < Representable::Decorator
+      include Representable::JSON
+      property :name
+    end
+    class AlbumRepresentation < Representable::Decorator
+      include Representable::JSON
+
+      collection :songs, :class => Song, :extend => SongRepresentation
+    end
+
+    describe "::prepare" do
+      let (:song) { Song.new("Still Friends In The End") }
+      let (:album) { Album.new([song]) }
+
+      describe "module including Representable" do
+        it "uses :extend strategy" do
+          album_rpr = Module.new { include Representable::Hash; collection :songs, :class => Song, :extend => SongRepresenter}
+
+          album_rpr.prepare(album).to_hash.must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
+          album.must_respond_to :to_hash
+        end
+      end
+
+      describe "Decorator subclass" do
+        it "uses :decorate strategy" do
+          AlbumRepresentation.prepare(album).to_hash.must_equal({"songs"=>[{"name"=>"Still Friends In The End"}]})
+          album.wont_respond_to :to_hash
+        end
+      end
+    end
+  end
+end