representable 3.0.0 → 3.1.0

data/test/binding_test.rb

@@ -2,45 +2,45 @@ require 'test_helper'
 
 class BindingTest < MiniTest::Spec
   Binding = Representable::Binding
-  let (:render_nil_definition) { Representable::Definition.new(:song, :render_nil => true) }
+  let(:render_nil_definition) { Representable::Definition.new(:song, :render_nil => true) }
 
   describe "#skipable_empty_value?" do
-    let (:binding) { Binding.new(render_nil_definition) }
+    let(:binding) { Binding.new(render_nil_definition) }
 
     # don't skip when present.
-    it { binding.skipable_empty_value?("Disconnect, Disconnect").must_equal false }
+    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 }
+    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 }
+    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 }
+    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) }
+    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" }
+    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 }
+    it { _(binding.default_for(false)).must_equal false }
 
     # return default when value nil.
-    it { binding.default_for(nil).must_equal "Insider" }
+    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 }
+    it { _(Binding.new(render_nil_definition).default_for(nil)).must_be_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 }
+    it { _(Binding.new(Representable::Definition.new(:song, :render_nil => true, :default => "The Quest")).default_for(nil)).must_be_nil }
 
     # return nil if no :default
-    it { Binding.new(Representable::Definition.new(:song)).default_for(nil).must_equal nil }
+    it { _(Binding.new(Representable::Definition.new(:song)).default_for(nil)).must_be_nil }
   end
 end

data/test/cached_test.rb

@@ -1,5 +1,28 @@
 require "test_helper"
-require 'ruby-prof'
+
+class Profiler
+  def self.profile(&block)
+    case RUBY_ENGINE
+    when "ruby"
+      require 'ruby-prof'
+
+      output = StringIO.new
+      profile_result = RubyProf.profile(&block)
+      printer = RubyProf::FlatPrinter.new(profile_result)
+      printer.print(output)
+      output.string
+    when "jruby"
+      require 'jruby/profiler'
+
+      output_stream  = java.io.ByteArrayOutputStream.new
+      print_stream   = java.io.PrintStream.new(output_stream)
+      profile_result = JRuby::Profiler.profile(&block)
+      printer = JRuby::Profiler::FlatProfilePrinter.new(profile_result)
+      printer.printProfile(print_stream)
+      output_stream.toString
+    end
+  end
+end
 
 class CachedTest < MiniTest::Spec
   # TODO: also test with feature(Cached)
@@ -30,18 +53,18 @@ class CachedTest < MiniTest::Spec
 
 
   describe "serialization" do
-    let (:album_hash) { {"name"=>"Louder And Even More Dangerous", "songs"=>[{"title"=>"Southbound:{:volume=>10}"}, {"title"=>"Jailbreak:{:volume=>10}"}]} }
+    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) }
+    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])
+      # album2 = Model::Album.new("Louder And Even More Dangerous", [song2, song])
 
       # makes sure options are passed correctly.
-      representer.to_hash(user_options: {volume: 9}).must_equal({"name"=>"Live And Dangerous",
+      _(representer.to_hash(user_options: {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.
@@ -55,36 +78,31 @@ class CachedTest < MiniTest::Spec
     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)
+      data = Profiler.profile { representer.to_hash }
 
       # 3 songs get decorated.
-      data.must_match "3   Representable::Function::Decorate#call"
+      _(data).must_match(/3\s*Representable::Function::Decorate#call/m)
+      # These weird Regexp bellow are a quick workaround to accomodate
+      # the different profiler result formats.
+      #   - "3   <Class::Representable::Decorator>#prepare" -> At MRI Ruby
+      #   - "3  Representable::Decorator.prepare"           -> At JRuby
+
       # 3 nested decorator is instantiated for 3 Songs, though.
-      data.must_match "3   <Class::Representable::Decorator>#prepare"
+      _(data).must_match(/3\s*(<Class::)?Representable::Decorator\>?[\#.]prepare/m)
       # no Binding is instantiated at runtime.
-      data.wont_match "Representable::Binding#initialize"
+      _(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"
+      _(data).must_match(/8\s*Representable::Binding[#\.]render_pipeline/m)
+      _(data).wont_match "render_functions"
+      _(data).wont_match "Representable::Binding::Factories#render_functions"
     end
   end
 
 
   describe "deserialization" do
-    let (:album_hash) {
+    let(:album_hash) {
       {
         "name"=>"Louder And Even More Dangerous",
         "songs"=>[
@@ -100,14 +118,14 @@ class CachedTest < MiniTest::Spec
 
       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
+      _(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_be_nil
 
       # TODO: test options.
     end
@@ -116,25 +134,17 @@ class CachedTest < MiniTest::Spec
       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
+      data = Profiler.profile { representer.from_hash(album_hash) }
 
       # only 2 nested decorators are instantiated, Song, and Artist.
-      data.must_match "5   <Class::Representable::Decorator>#prepare"
+      # Didn't like the regexp?
+      # MRI and JRuby has different output formats. See note above.
+      _(data).must_match(/5\s*(<Class::)?Representable::Decorator>?[#\.]prepare/)
       # a total of 5 properties in the object graph.
-      data.wont_match "Representable::Binding#initialize"
-
+      _(data).wont_match "Representable::Binding#initialize"
 
-      data.wont_match "parse_functions" # no pipeline creation.
-      data.must_match "10   Representable::Binding#parse_pipeline"
+      _(data).wont_match "parse_functions" # no pipeline creation.
+      _(data).must_match(/10\s*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/test/class_test.rb

@@ -20,8 +20,8 @@ class ClassTest < BaseTest
 
     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"
+      _(song).must_be_instance_of RepresentingSong
+      _(song.name).must_equal "Captured"
     end
   end
 
@@ -33,8 +33,8 @@ class ClassTest < BaseTest
 
     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"
+      _(song).must_be_instance_of RepresentingSong
+      _(song.name).must_equal "Captured"
     end
   end
 
@@ -54,7 +54,7 @@ class ClassTest < BaseTest
 
 
   describe "lambda receiving fragment and args" do
-    let (:klass) { Class.new do
+    let(:klass) { Class.new do
       class << self
         attr_accessor :args
       end
@@ -69,13 +69,13 @@ class ClassTest < BaseTest
       property :song, :class => lambda { |options| _klass.args=([options[:fragment],options[:user_options]]); _klass }
     end
 
-    it { representer.prepare(OpenStruct.new).from_hash({"song" => {"name" => "Captured"}}, user_options: {volume: true}).song.class.args.
+    it { _(representer.prepare(OpenStruct.new).from_hash({"song" => {"name" => "Captured"}}, user_options: {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
+    let(:klass) { Class.new do
       class << self
         attr_accessor :args
       end
@@ -90,7 +90,7 @@ class ClassTest < BaseTest
       collection :songs, :class => lambda { |options| _klass.args=([options[:fragment],options[:index],options[:user_options]]); _klass }
     end
 
-    it { representer.prepare(OpenStruct.new).from_hash({"songs" => [{"name" => "Captured"}]}, user_options: {volume: true}).songs.first.class.args.
+    it { _(representer.prepare(OpenStruct.new).from_hash({"songs" => [{"name" => "Captured"}]}, user_options: {volume: true}).songs.first.class.args).
       must_equal([{"name"=>"Captured"}, 0, {:volume=>true}]) }
   end
 
@@ -109,7 +109,7 @@ class ClassTest < BaseTest
     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]
+      _(representer.prepare(OpenStruct.new).from_hash({"song" => 1}).song).must_equal [1,2,3,4]
     end
   end
 end

data/test/coercion_test.rb

@@ -1,52 +1,63 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'representable/coercion'
 
-class VirtusCoercionTest < MiniTest::Spec
+class CoercionTest < MiniTest::Spec
   representer! do
     include Representable::Coercion
 
     property :title # no coercion.
-    property :length, :type => Float
+    property :length, type: Representable::Coercion::Types::Params::Float
 
-    property :band, :class => OpenStruct do
-      property :founded, :type => Integer
+    property :band, class: OpenStruct do
+      property :founded, type: Representable::Coercion::Types::Params::Integer
     end
 
-    collection :songs, :class => OpenStruct do
-      property :ok, :type => Virtus::Attribute::Boolean
+    collection :songs, class: OpenStruct do
+      property :ok, type: Representable::Coercion::Types::Params::Bool
     end
   end
 
-  let (:album) { OpenStruct.new(:title => "Dire Straits", :length => 41.34,
-    :band  => OpenStruct.new(:founded => "1977"),
-    :songs => [OpenStruct.new(:ok => 1), OpenStruct.new(:ok => 0)]) }
+  let(:album) do
+    OpenStruct.new(title: 'Dire Straits', length: 41.34,
+                   band: OpenStruct.new(founded: '1977'),
+                   songs: [OpenStruct.new(ok: 1), OpenStruct.new(ok: 0)])
+  end
 
-  it { album.extend(representer).to_hash.must_equal({"title"=>"Dire Straits", "length"=>41.34, "band"=>{"founded"=>1977}, "songs"=>[{"ok"=>true}, {"ok"=>false}]}) }
+  it do
+    _(album.extend(representer).to_hash).must_equal({ 'title' => 'Dire Straits',
+                                                      'length' => 41.34,
+                                                      'band' => { 'founded' => 1977 },
+                                                      'songs' => [{ 'ok' => true }, { 'ok' => false }] })
+  end
 
   it {
     album = OpenStruct.new
     album.extend(representer)
-    album.from_hash({"title"=>"Dire Straits", "length"=>"41.34", "band"=>{"founded"=>"1977"}, "songs"=>[{"ok"=>1}, {"ok"=>0}]})
+    album.from_hash({ 'title' => 'Dire Straits',
+                      'length' => '41.34',
+                      'band' => { 'founded' => '1977' },
+                      'songs' => [{ 'ok' => 1 }, { 'ok' => 0 }] })
 
     # it
-    album.length.must_equal 41.34
-    album.band.founded.must_equal 1977
-    album.songs[0].ok.must_equal true
+    _(album.length).must_equal 41.34
+    _(album.band.founded).must_equal 1977
+    _(album.songs[0].ok).must_equal true
   }
 
-
-  describe "with user :parse_filter and :render_filter" do
+  describe 'with user :parse_filter and :render_filter' do
     representer! do
       include Representable::Coercion
 
-      property :length, :type => Float,
-      :parse_filter  => lambda { |input, options| "#{input}.1" }, # happens BEFORE coercer.
-      :render_filter => lambda { |fragment,*| "#{fragment}.1" }
+      property :length, type: Representable::Coercion::Types::Params::Float,
+                        parse_filter: ->(input, _options) { "#{input}.1" }, # happens BEFORE coercer.
+                        render_filter: ->(fragment, *) { "#{fragment}.1" }
     end
 
     # user's :parse_filter(s) are run before coercion.
-    it { OpenStruct.new.extend(representer).from_hash("length"=>"1").length.must_equal 1.1 }
+    it { _(OpenStruct.new.extend(representer).from_hash('length' => '1').length).must_equal 1.1 }
     # user's :render_filter(s) are run before coercion.
-    it { OpenStruct.new(:length=>1).extend(representer).to_hash.must_equal({"length" => 1.1}) }
+    it { _(OpenStruct.new(length: 1).extend(representer).to_hash).must_equal({ 'length' => 1.1 }) }
   end
-end
+end

data/test/config/inherit_test.rb

@@ -9,8 +9,8 @@ class ConfigInheritTest < MiniTest::Spec
 
     child_def.merge!(:alias => property)
 
-    child_def[:alias].wont_equal parent_def[:alias]
-    child_def.object_id.wont_equal parent_def.object_id
+    _(child_def[:alias]).wont_equal parent_def[:alias]
+    _(child_def.object_id).wont_equal parent_def.object_id
   end
   # class Object
 
@@ -30,7 +30,7 @@ class ConfigInheritTest < MiniTest::Spec
     end
   end
 
-  it { Decorator.definitions.keys.must_equal ["title", "artist"] }
+  it { _(Decorator.definitions.keys).must_equal ["title", "artist"] }
 
   # in inheriting Decorator
 
@@ -38,10 +38,10 @@ class ConfigInheritTest < MiniTest::Spec
     property :location
   end
 
-  it { InheritingDecorator.definitions.keys.must_equal ["title", "artist", "location"] }
+  it { _(InheritingDecorator.definitions.keys).must_equal ["title", "artist", "location"] }
   it { assert_cloned(InheritingDecorator, Decorator, "title") }
   it do
-    InheritingDecorator.representable_attrs.get(:artist).representer_module.object_id.wont_equal Decorator.representable_attrs.get(:artist).representer_module.object_id
+    _(InheritingDecorator.representable_attrs.get(:artist).representer_module.object_id).wont_equal Decorator.representable_attrs.get(:artist).representer_module.object_id
   end
 
   # in inheriting and including Decorator
@@ -51,7 +51,7 @@ class ConfigInheritTest < MiniTest::Spec
     property :location
   end
 
-  it { InheritingAndIncludingDecorator.definitions.keys.must_equal ["title", "artist", "genre", "location"] }
+  it { _(InheritingAndIncludingDecorator.definitions.keys).must_equal ["title", "artist", "genre", "location"] }
   it { assert_cloned(InheritingAndIncludingDecorator, GenreModule, :genre) }
 
 
@@ -61,7 +61,7 @@ class ConfigInheritTest < MiniTest::Spec
     property :title
   end
 
-  it { Module.definitions.keys.must_equal ["title"] }
+  it { _(Module.definitions.keys).must_equal ["title"] }
 
 
   # in module including module
@@ -72,7 +72,7 @@ class ConfigInheritTest < MiniTest::Spec
     property :location
   end
 
-  it { SubModule.definitions.keys.must_equal ["title", "location"] }
+  it { _(SubModule.definitions.keys).must_equal ["title", "location"] }
   it { assert_cloned(SubModule, Module, :title) }
 
   # including preserves order
@@ -84,7 +84,7 @@ class ConfigInheritTest < MiniTest::Spec
     property :location
   end
 
-  it { IncludingModule.definitions.keys.must_equal ["genre", "title", "location"] }
+  it { _(IncludingModule.definitions.keys).must_equal ["genre", "title", "location"] }
 
 
   # included in class -------------------------------------------
@@ -93,7 +93,7 @@ class ConfigInheritTest < MiniTest::Spec
     include IncludingModule
   end
 
-  it { Class.definitions.keys.must_equal ["genre", "title", "location"] }
+  it { _(Class.definitions.keys).must_equal ["genre", "title", "location"] }
   it { assert_cloned(Class, IncludingModule, :title) }
   it { assert_cloned(Class, IncludingModule, :location) }
   it { assert_cloned(Class, IncludingModule, :genre) }
@@ -105,7 +105,7 @@ class ConfigInheritTest < MiniTest::Spec
     include IncludingModule
   end
 
-  it { DefiningClass.definitions.keys.must_equal ["street_cred", "genre", "title", "location"] }
+  it { _(DefiningClass.definitions.keys).must_equal ["street_cred", "genre", "title", "location"] }
 
   # in class
   class RepresenterClass
@@ -113,7 +113,7 @@ class ConfigInheritTest < MiniTest::Spec
     property :title
   end
 
-  it { RepresenterClass.definitions.keys.must_equal ["title"] }
+  it { _(RepresenterClass.definitions.keys).must_equal ["title"] }
 
 
   # in inheriting class
@@ -122,7 +122,7 @@ class ConfigInheritTest < MiniTest::Spec
     property :location
   end
 
-  it { InheritingClass.definitions.keys.must_equal ["title", "location"] }
+  it { _(InheritingClass.definitions.keys).must_equal ["title", "location"] }
   it { assert_cloned(InheritingClass, RepresenterClass, :title) }
 
   # in inheriting class and including
@@ -131,5 +131,5 @@ class ConfigInheritTest < MiniTest::Spec
     include GenreModule
   end
 
-  it { InheritingAndIncludingClass.definitions.keys.must_equal ["title", "location", "genre"] }
+  it { _(InheritingAndIncludingClass.definitions.keys).must_equal ["title", "location", "genre"] }
 end