representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/benchmarking.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+require 'benchmark'
+
+SONG_PROPERTIES = 1000.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: 100.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-with-deprecations/binding_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class BindingTest < MiniTest::Spec
+  Binding = Representable::Binding
+  let (:render_nil_definition) { Representable::Definition.new(:song, :render_nil => true) }
+
+  describe "#skipable_empty_value?" do
+    let (:binding) { Binding.new(render_nil_definition) }
+
+    # don't skip when present.
+    it { binding.skipable_empty_value?("Disconnect, Disconnect").must_equal false }
+
+    # don't skip when it's nil and render_nil: true
+    it { binding.skipable_empty_value?(nil).must_equal false }
+
+    # skip when nil and :render_nil undefined.
+    it { Binding.new(Representable::Definition.new(:song)).skipable_empty_value?(nil).must_equal true }
+
+    # don't skip when nil and :render_nil undefined.
+    it { Binding.new(Representable::Definition.new(:song)).skipable_empty_value?("Fatal Flu").must_equal false }
+  end
+
+
+  describe "#default_for" do
+    let (:definition) { Representable::Definition.new(:song, :default => "Insider") }
+    let (:binding) { Binding.new(definition) }
+
+    # return value when value present.
+    it { binding.default_for("Black And Blue").must_equal "Black And Blue" }
+
+    # return false when value false.
+    it { binding.default_for(false).must_equal false }
+
+    # return default when value nil.
+    it { binding.default_for(nil).must_equal "Insider" }
+
+    # return nil when value nil and render_nil: true.
+    it { Binding.new(render_nil_definition).default_for(nil).must_equal nil }
+
+    # return nil when value nil and render_nil: true, even when :default is set" do
+    it { Binding.new(Representable::Definition.new(:song, :render_nil => true, :default => "The Quest")).default_for(nil).must_equal nil }
+
+    # return nil if no :default
+    it { Binding.new(Representable::Definition.new(:song)).default_for(nil).must_equal nil }
+  end
+end

data/test-with-deprecations/blaaaaaaaa_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+
+
+
+# Include Inherit Module And Decorator Test
+class SchemaTest < MiniTest::Spec
+  module Genre
+    include Representable
+    property :genre
+  end
+
+  module LinkFeature
+    def self.included(base)
+      base.extend(Link)
+    end
+
+    module Link
+      def link
+      end
+    end
+  end
+
+
+  module Module
+    include Representable::Hash
+    feature LinkFeature
+
+    property :title
+    property :label do # extend: LabelModule
+      property :name
+      link # feature
+
+      property :location do
+        property :city
+        link # feature.
+      end
+    end
+
+    property :album, :extend => lambda { raise "don't manifest me!" } # this is not an inline decorator, don't manifest it.
+
+
+    include Genre # Schema::Included::included is called!
+  end
+
+
+  class InheritDecorator < Representable::Decorator
+    include Representable::Hash
+
+    include Module
+
+    property :label, inherit: true do # decorator.rb:27:in `initialize': superclass must be a Class (Module given)
+      property :city
+
+      property :location, :inherit => true do
+        property :city
+      end
+    end
+  end
+
+
+  class InheritFromDecorator < InheritDecorator
+    property :label, inherit: true do
+      collection :employees do
+        property :name
+      end
+    end
+  end
+end

data/test-with-deprecations/cached_test.rb

@@ -0,0 +1,147 @@
+require "test_helper"
+require 'ruby-prof'
+
+class CachedTest < MiniTest::Spec
+  # TODO: also test with feature(Cached)
+
+  module Model
+    Song  = Struct.new(:title, :composer)
+    Album = Struct.new(:name, :songs, :artist)
+    Artist = Struct.new(:name, :hidden_taste)
+  end
+
+  class SongRepresenter < Representable::Decorator
+    include Representable::Hash
+    feature Representable::Cached
+
+    property :title, render_filter: lambda { |input, options| "#{input}:#{options[:options][:user_options]}" }
+    property :composer, class: Model::Artist do
+      property :name
+    end
+  end
+
+  class AlbumRepresenter < Representable::Decorator
+    include Representable::Hash
+    include Representable::Cached
+
+    property :name
+    collection :songs, decorator: SongRepresenter, class: Model::Song
+  end
+
+
+  describe "serialization" do
+    let (:album_hash) { {"name"=>"Louder And Even More Dangerous", "songs"=>[{"title"=>"Southbound:{:volume=>10}"}, {"title"=>"Jailbreak:{:volume=>10}"}]} }
+
+    let (:song) { Model::Song.new("Jailbreak") }
+    let (:song2) { Model::Song.new("Southbound") }
+    let (:album) { Model::Album.new("Live And Dangerous", [song, song2, Model::Song.new("Emerald")]) }
+    let (:representer) { AlbumRepresenter.new(album) }
+
+    it do
+      album2 = Model::Album.new("Louder And Even More Dangerous", [song2, song])
+
+      # makes sure options are passed correctly.
+      representer.to_hash(volume: 9).must_equal({"name"=>"Live And Dangerous",
+        "songs"=>[{"title"=>"Jailbreak:{:volume=>9}"}, {"title"=>"Southbound:{:volume=>9}"}, {"title"=>"Emerald:{:volume=>9}"}]}) # called in Deserializer/Serializer
+
+      # representer becomes reusable as it is stateless.
+      # representer.update!(album2)
+
+      # makes sure options are passed correctly.
+      # representer.to_hash(volume:10).must_equal(album_hash)
+    end
+
+    # profiling
+    it do
+      representer.to_hash
+
+     RubyProf.start
+        representer.to_hash
+      res = RubyProf.stop
+
+      printer = RubyProf::FlatPrinter.new(res)
+
+      data = StringIO.new
+      printer.print(data)
+      data = data.string
+
+      printer.print(STDOUT)
+
+      # 3 songs get decorated.
+      data.must_match "3   Representable::Function::Decorate#call"
+      # 3 nested decorator is instantiated for 3 Songs, though.
+      data.must_match "3   <Class::Representable::Decorator>#prepare"
+      # no Binding is instantiated at runtime.
+      data.wont_match "Representable::Binding#initialize"
+      # 2 mappers for Album, Song
+      # data.must_match "2   Representable::Mapper::Methods#initialize"
+      # title, songs, 3x title, composer
+      data.must_match "8   Representable::Binding#render_pipeline"
+      data.wont_match "render_functions"
+      data.wont_match "Representable::Binding::Factories#render_functions"
+    end
+  end
+
+
+  describe "deserialization" do
+    let (:album_hash) {
+      {
+        "name"=>"Louder And Even More Dangerous",
+        "songs"=>[
+          {"title"=>"Southbound", "composer"=>{"name"=>"Lynott"}},
+          {"title"=>"Jailbreak", "composer"=>{"name"=>"Phil Lynott"}},
+          {"title"=>"Emerald"}
+        ]
+      }
+    }
+
+    it do
+      album = Model::Album.new
+
+      AlbumRepresenter.new(album).from_hash(album_hash)
+
+      album.songs.size.must_equal 3
+      album.name.must_equal "Louder And Even More Dangerous"
+      album.songs[0].title.must_equal "Southbound"
+      album.songs[0].composer.name.must_equal "Lynott"
+      album.songs[1].title.must_equal "Jailbreak"
+      album.songs[1].composer.name.must_equal "Phil Lynott"
+      album.songs[2].title.must_equal "Emerald"
+      album.songs[2].composer.must_equal nil
+
+      # TODO: test options.
+    end
+
+    it "xxx" do
+      representer = AlbumRepresenter.new(Model::Album.new)
+      representer.from_hash(album_hash)
+
+      RubyProf.start
+        # puts "#{representer.class.representable_attrs.get(:songs).representer_module.representable_attrs.inspect}"
+        representer.from_hash(album_hash)
+      res = RubyProf.stop
+
+      printer = RubyProf::FlatPrinter.new(res)
+
+      data = StringIO.new
+      printer.print(data)
+      data = data.string
+
+      # only 2 nested decorators are instantiated, Song, and Artist.
+      data.must_match "5   <Class::Representable::Decorator>#prepare"
+      # a total of 5 properties in the object graph.
+      data.wont_match "Representable::Binding#initialize"
+
+
+      data.wont_match "parse_functions" # no pipeline creation.
+      data.must_match "10   Representable::Binding#parse_pipeline"
+      # three mappers for Album, Song, composer
+      # data.must_match "3   Representable::Mapper::Methods#initialize"
+      # # 6 deserializers as the songs collection uses 2.
+      # data.must_match "6   Representable::Deserializer#initialize"
+      # # one populater for every property.
+      # data.must_match "5   Representable::Populator#initialize"
+      # printer.print(STDOUT)
+    end
+  end
+end

data/test-with-deprecations/class_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+
+class ClassTest < BaseTest
+
+  class RepresentingSong
+    attr_reader :name
+
+    def from_hash(doc, *args)
+      @name = doc["__name__"]
+
+      self # DISCUSS: do we wanna be able to return whatever we want here? this is a trick to replace the actual object
+    end
+  end
+
+
+  describe "class: ClassName, only" do
+    representer! do
+      property :song, :class => RepresentingSong # supposed this class exposes #from_hash itself.
+    end
+
+    it "creates fresh instance and doesn't extend" do
+      song = representer.prepare(OpenStruct.new).from_hash({"song" => {"__name__" => "Captured"}}).song
+      song.must_be_instance_of RepresentingSong
+      song.name.must_equal "Captured"
+    end
+  end
+
+
+  describe "class: lambda, only" do
+    representer! do
+      property :song, :class => lambda { |*| RepresentingSong }
+    end
+
+    it "creates fresh instance and doesn't extend" do
+      song = representer.prepare(OpenStruct.new).from_hash({"song" => {"__name__" => "Captured"}}).song
+      song.must_be_instance_of RepresentingSong
+      song.name.must_equal "Captured"
+    end
+  end
+
+
+  # this throws a DeserializationError now.
+  describe "lambda { nil }" do
+    representer! do
+      property :title, :class  => nil
+    end
+
+    it do
+      assert_raises Representable::DeserializeError do
+        OpenStruct.new.extend(representer).from_hash({"title" => {}})
+      end
+    end
+  end
+
+
+  describe "lambda receiving fragment and args" do
+    let (:klass) { Class.new do
+      class << self
+        attr_accessor :args
+      end
+
+      def from_hash(*)
+        self.class.new
+      end
+    end }
+
+    representer!(:inject => :klass) do
+      _klass = klass
+      property :song, :class => lambda { |fragment, args| _klass.args=([fragment,args]); _klass }
+    end
+
+    it { representer.prepare(OpenStruct.new).from_hash({"song" => {"name" => "Captured"}}, :volume => true).song.class.args.
+      must_equal([{"name"=>"Captured"}, {:volume=>true}]) }
+  end
+
+
+  describe "collection: lambda receiving fragment and args" do
+    let (:klass) { Class.new do
+      class << self
+        attr_accessor :args
+      end
+
+      def from_hash(*)
+        self.class.new
+      end
+    end }
+
+    representer!(:inject => :klass) do
+      _klass = klass
+      collection :songs, :class => lambda { |fragment, i, args| _klass.args=([fragment,i,args]); _klass }
+    end
+
+    it { representer.prepare(OpenStruct.new).from_hash({"songs" => [{"name" => "Captured"}]}, :volume => true).songs.first.class.args.
+      must_equal([{"name"=>"Captured"}, 0, {:volume=>true}]) }
+  end
+
+
+  describe "class: implementing #from_hash" do
+    let(:parser) do
+      Class.new do
+        def from_hash(*)
+          [1,2,3,4]
+        end
+      end
+    end
+
+    representer!(:inject => :parser) do
+      property :song, :class => parser # supposed this class exposes #from_hash itself.
+    end
+
+    it "allows returning arbitrary objects in #from_hash" do
+      representer.prepare(OpenStruct.new).from_hash({"song" => 1}).song.must_equal [1,2,3,4]
+    end
+  end
+end
+
+#TODO: test fragment,
+
+# `class: Song` only, no :extend.