fix build in jruby && truffleruby

.github/workflows/ci_jruby.yml

@@ -17,3 +17,5 @@ jobs:
         ruby-version: ${{ matrix.ruby }}
         bundler-cache: true
     - run: bundle exec rake
+      env:
+        JRUBY_OPTS: --profile

.gitignore

@@ -10,3 +10,7 @@ Gemfile.lock
 *.swp
 *.swo
 bin
+# Jetbrains IDEs
+.idea
+*.iml
+/out

Gemfile

@@ -7,5 +7,5 @@ group :test do
   gem "multi_json", require: false
   gem "nokogiri", require: false
 end
-gem 'pry-byebug'
+gem 'pry-byebug', platform: :mri
 

test/as_test.rb

@@ -1,39 +1,43 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class AsTest < MiniTest::Spec
   for_formats(
-    :hash => [Representable::Hash, {"title" => "Wie Es Geht"}, {"title" => "Revolution"}]
+    hash: [Representable::Hash, {"title" => "Wie Es Geht"}, {"title" => "Revolution"}]
     # :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song>/open_struct>"],
     # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
   ) do |format, mod, input, output|
     let(:song) { representer.prepare(Song.new("Revolution")) }
     let(:format) { format }
 
     describe "as: with :symbol" do
-      representer!(:module => mod) do
-        property :name, :as => :title
+      representer!(module: mod) do
+        property :name, as: :title
       end
 
-      it { render(song).must_equal_document output }
+      it { assert_equal_document render(song), output }
       it { _(parse(song, input).name).must_equal "Wie Es Geht" }
     end
 
     describe "as: with lambda" do
-      representer!(:module => mod) do
-        property :name, :as => ->(*) { self.class.to_s }
+      representer!(module: mod) do
+        property :name, as: ->(*) { self.class.to_s }
       end
 
-      it { render(song).must_equal_document({"Song" => "Revolution"}) }
+      it { assert_equal_document(render(song), {"Song" => "Revolution"}) }
       it { _(parse(song, {"Song" => "Wie Es Geht"}).name).must_equal "Wie Es Geht" }
     end
 
     describe "lambda arguments" do
       representer! do
-        property :name, :as => ->(options) { options[:user_options].inspect }
+        property :name, as: ->(options) { options[:user_options].inspect }
       end
 
-      it { render(song, user_options: {volume: 1}).must_equal_document({"{:volume=>1}" => "Revolution"}) }
-      it { _(parse(song, {"{:volume=>1}" => "Wie Es Geht"}, user_options: {volume: 1}).name).must_equal "Wie Es Geht" }
+      it { assert_equal_document(render(song, user_options: {volume: 1}), {"{:volume=>1}" => "Revolution"}) }
+      it {
+        _(parse(song, {"{:volume=>1}" => "Wie Es Geht"}, user_options: {volume: 1}).name).must_equal "Wie Es Geht"
+      }
     end
   end
 end
@@ -54,7 +58,10 @@ class AsXmlTest < MiniTest::Spec
   end
 
   it do
-    skip
-    _(representer.new(Album.new(Band.new("Offspring"))).to_xml).must_equal ""
+    assert_xml_equal "<album>
+  <combo>
+    <name>Offspring</name>
+  </combo>
+</album>", representer.new(Album.new(Band.new("Offspring"))).to_xml
   end
 end

test/benchmarking.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "benchmark"
 
-SONG_PROPERTIES = 1000.times.collect do |i|
+SONG_PROPERTIES = Array.new(1000) do |i|
   "property_#{i}"
 end
 
@@ -25,22 +27,22 @@ module AlbumRepresenter
 end
 
 def random_song
-  attrs = Hash[SONG_PROPERTIES.collect { |n| [n, n] }]
+  attrs = SONG_PROPERTIES.to_h { |n| [n, n] }
   OpenStruct.new(attrs)
 end
 
 times = []
 
 3.times.each do
-  album = OpenStruct.new(songs: 100.times.collect { random_song })
+  album = OpenStruct.new(songs: Array.new(100) { random_song })
 
   times << Benchmark.measure do
     puts "================ next!"
     album.extend(AlbumRepresenter).to_json
   end
 end
 
-puts times.join("")
+puts times.join
 
 # 100 songs, 100 attrs
 #  0.050000   0.000000   0.050000 (  0.093157)

test/binding_test.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 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) }
@@ -21,7 +23,7 @@ class BindingTest < MiniTest::Spec
   end
 
   describe "#default_for" do
-    let(:definition) { Representable::Definition.new(:song, :default => "Insider") }
+    let(:definition) { Representable::Definition.new(:song, default: "Insider") }
     let(:binding) { Binding.new(definition) }
 
     # return value when value present.
@@ -41,8 +43,8 @@ class BindingTest < MiniTest::Spec
       _(
         Binding.new(
           Representable::Definition.new(
-            :song, :render_nil => true,
-                   :default    => "The Quest"
+            :song, render_nil: true,
+                   default: "The Quest"
           )
         ).default_for(nil)
       ).must_be_nil

test/cached_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class Profiler
@@ -54,8 +56,8 @@ class AlbumRepresenter < Representable::Decorator
   describe "serialization" do
     let(:album_hash) do
       {
-        "name"  => "Louder And Even More Dangerous",
-        "songs" => [{"title"=>"Southbound:{:volume=>10}"}, {"title"=>"Jailbreak:{:volume=>10}"}]
+        "name" => "Louder And Even More Dangerous",
+        "songs" => [{"title" => "Southbound:{:volume=>10}"}, {"title" => "Jailbreak:{:volume=>10}"}]
       }
     end
 
@@ -70,10 +72,10 @@ class AlbumRepresenter < Representable::Decorator
       # makes sure options are passed correctly.
       _(representer.to_hash(user_options: {volume: 9})).must_equal(
         {
-          "name"  => "Live And Dangerous",
+          "name" => "Live And Dangerous",
           "songs" => [
-            {"title"=>"Jailbreak:{:volume=>9}"}, {"title"=>"Southbound:{:volume=>9}"},
-            {"title"=>"Emerald:{:volume=>9}"}
+            {"title" => "Jailbreak:{:volume=>9}"}, {"title" => "Southbound:{:volume=>9}"},
+            {"title" => "Emerald:{:volume=>9}"}
           ]
         }
       ) # called in Deserializer/Serializer
@@ -87,6 +89,7 @@ class AlbumRepresenter < Representable::Decorator
 
     # profiling
     it do
+      skip("TruffleRuby profiler is not implemented yet") if RUBY_ENGINE == "truffleruby"
       representer.to_hash
 
       data = Profiler.profile { representer.to_hash }
@@ -114,11 +117,11 @@ class AlbumRepresenter < Representable::Decorator
   describe "deserialization" do
     let(:album_hash) do
       {
-        "name"  => "Louder And Even More Dangerous",
+        "name" => "Louder And Even More Dangerous",
         "songs" => [
-          {"title" => "Southbound", "composer" => {"name"=>"Lynott"}},
-          {"title" => "Jailbreak", "composer" => {"name"=>"Phil Lynott"}},
-          {"title"=>"Emerald"}
+          {"title" => "Southbound", "composer" => {"name" => "Lynott"}},
+          {"title" => "Jailbreak", "composer" => {"name" => "Phil Lynott"}},
+          {"title" => "Emerald"}
         ]
       }
     end
@@ -141,6 +144,7 @@ class AlbumRepresenter < Representable::Decorator
     end
 
     it "xxx" do
+      skip("TruffleRuby profiler is not implemented yet") if RUBY_ENGINE == "truffleruby"
       representer = AlbumRepresenter.new(Model::Album.new)
       representer.from_hash(album_hash)
 

test/class_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class ClassTest < BaseTest
@@ -13,7 +15,7 @@ def from_hash(doc, *)
 
   describe "class: ClassName, only" do
     representer! do
-      property :song, :class => RepresentingSong # supposed this class exposes #from_hash itself.
+      property :song, class: RepresentingSong # supposed this class exposes #from_hash itself.
     end
 
     it "creates fresh instance and doesn't extend" do
@@ -25,7 +27,7 @@ def from_hash(doc, *)
 
   describe "class: lambda, only" do
     representer! do
-      property :song, :class => ->(*) { RepresentingSong }
+      property :song, class: ->(*) { RepresentingSong }
     end
 
     it "creates fresh instance and doesn't extend" do
@@ -38,7 +40,7 @@ def from_hash(doc, *)
   # this throws a DeserializationError now.
   describe "lambda { nil }" do
     representer! do
-      property :title, :class => nil
+      property :title, class: nil
     end
 
     it do
@@ -61,9 +63,12 @@ def from_hash(*)
       end
     end
 
-    representer!(:inject => :klass) do
+    representer!(inject: :klass) do
       _klass = klass
-      property :song, :class => ->(options) { _klass.args = ([options[:fragment], options[:user_options]]); _klass }
+      property :song, class: ->(options) {
+                               _klass.args = ([options[:fragment], options[:user_options]])
+                               _klass
+                             }
     end
 
     it {
@@ -73,7 +78,7 @@ def from_hash(*)
           user_options: {volume: true}
         ).song.class.args
       )
-        .must_equal([{"name"=>"Captured"}, {:volume=>true}])
+        .must_equal([{"name" => "Captured"}, {volume: true}])
     }
   end
 
@@ -90,10 +95,11 @@ def from_hash(*)
       end
     end
 
-    representer!(:inject => :klass) do
+    representer!(inject: :klass) do
       _klass = klass
       collection :songs, class: ->(options) {
-                                  _klass.args = ([options[:fragment], options[:index], options[:user_options]]); _klass
+                                  _klass.args = ([options[:fragment], options[:index], options[:user_options]])
+                                  _klass
                                 }
     end
 
@@ -104,7 +110,7 @@ def from_hash(*)
           user_options: {volume: true}
         ).songs.first.class.args
       )
-        .must_equal([{"name"=>"Captured"}, 0, {:volume=>true}])
+        .must_equal([{"name" => "Captured"}, 0, {volume: true}])
     }
   end
 
@@ -117,8 +123,8 @@ def from_hash(*)
       end
     end
 
-    representer!(:inject => :parser) do
-      property :song, :class => parser # supposed this class exposes #from_hash itself.
+    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

test/coercion_test.rb

@@ -30,10 +30,10 @@ class CoercionTest < MiniTest::Spec
   it do
     _(album.extend(representer).to_hash).must_equal(
       {
-        "title"  => "Dire Straits",
+        "title" => "Dire Straits",
         "length" => 41.34,
-        "band"   => {"founded" => 1977},
-        "songs"  => [{"ok" => true}, {"ok" => false}]
+        "band" => {"founded" => 1977},
+        "songs" => [{"ok" => true}, {"ok" => false}]
       }
     )
   end
@@ -43,10 +43,10 @@ class CoercionTest < MiniTest::Spec
     album.extend(representer)
     album.from_hash(
       {
-        "title"  => "Dire Straits",
+        "title" => "Dire Straits",
         "length" => "41.34",
-        "band"   => {"founded" => "1977"},
-        "songs"  => [{"ok" => 1}, {"ok" => 0}]
+        "band" => {"founded" => "1977"},
+        "songs" => [{"ok" => 1}, {"ok" => 0}]
       }
     )
 
@@ -60,8 +60,8 @@ class CoercionTest < MiniTest::Spec
     representer! do
       include Representable::Coercion
 
-      property :length, type:          Representable::Coercion::Types::Params::Float,
-                        parse_filter:  ->(input, _options) { "#{input}.1" }, # happens BEFORE coercer.
+      property :length, type: Representable::Coercion::Types::Params::Float,
+                        parse_filter: ->(input, _options) { "#{input}.1" }, # happens BEFORE coercer.
                         render_filter: ->(fragment, *) { "#{fragment}.1" }
     end