representable 3.0.4 → 3.2.0

data/lib/representable/object/binding.rb

@@ -1,8 +1,11 @@
+require 'representable/binding'
+
 module Representable
   module Object
     class Binding < Representable::Binding
       def self.build_for(definition)  # TODO: remove default arg.
         return Collection.new(definition)  if definition.array?
+
         new(definition)
       end
 
@@ -10,6 +13,7 @@ module Representable
         fragment = hash.send(as) # :getter? no, that's for parsing!
 
         return FragmentNotFound if fragment.nil? and typed?
+
         fragment
       end
 
@@ -31,4 +35,4 @@ module Representable
       end
     end
   end
-end
+end

data/lib/representable/object.rb

@@ -26,4 +26,4 @@ module Representable
       create_representation_with(nil, options, binding_builder)
     end
   end
-end
+end

data/lib/representable/option.rb

@@ -0,0 +1,19 @@
+require "trailblazer/option"
+
+module Representable
+  # Extend `Trailblazer::Option` to support static values as callables too.
+  class Option < ::Trailblazer::Option
+    def self.callable?(value)
+      [Proc, Symbol, Uber::Callable].any?{ |kind| value.is_a?(kind) }
+    end
+
+    def self.build(value)
+      return ->(*) { value } unless callable?(value) # Wrap static `value` into a proc. 
+      super
+    end
+  end
+
+  def self.Option(value)
+    ::Representable::Option.build(value)
+  end
+end

data/lib/representable/pipeline.rb

@@ -4,11 +4,12 @@ module Representable
   class Pipeline < Array
     Stop = Class.new
 
-    # options is mutuable.
+    # options is mutable.
     def call(input, options)
       inject(input) do |memo, block|
         res = evaluate(block, memo, options)
-        return(Stop)if Stop == res
+        return(Stop) if Stop == res
+
         res
       end
     end

data/lib/representable/pipeline_factories.rb

@@ -2,7 +2,8 @@
 module Representable
   module Binding::Factories
     def pipeline_for(name, input, options)
-      return yield unless proc = @definition[name]
+      return yield unless (proc = @definition[name])
+
       # proc.(self, options)
       instance_exec(input, options, &proc)
     end
@@ -11,6 +12,7 @@ module Representable
     def collect_for(item_functions)
       return [Collect[*item_functions]] if array?
       return [Collect::Hash[*item_functions]] if self[:hash]
+
       item_functions
     end
 
@@ -92,4 +94,4 @@ module Representable
       funcs << (self[:setter] ? Setter : SetValue)
     end
   end
-end
+end

data/lib/representable/populator.rb

@@ -21,7 +21,7 @@ module Representable
     def self.apply!(options)
       return unless populator = options[:populator]
 
-      options[:parse_pipeline] = ->(input, opts) do
+      options[:parse_pipeline] = ->(_input, _opts) do
         pipeline = Pipeline[*parse_functions] # TODO: AssignFragment
         pipeline = Pipeline::Insert.(pipeline, SetValue, delete: true) # remove the setter function.
         pipeline = Pipeline::Insert.(pipeline, populator, replace: CreateObject::Populator) # let the actual populator do the job.

data/lib/representable/represent.rb

@@ -1,6 +1,7 @@
 module Representable::Represent
   def represent(represented, array_class=Array)
     return for_collection.prepare(represented) if represented.is_a?(array_class)
+
     prepare(represented)
   end
 end

data/lib/representable/serializer.rb

@@ -3,7 +3,7 @@ module Representable
     options[:binding].evaluate_option(:getter, input, options)
   end
 
-  GetValue = ->(input, options) { options[:binding].send(:exec_context, options).public_send(options[:binding].getter) }
+  GetValue = ->(_input, options) { options[:binding].send(:exec_context, options).public_send(options[:binding].getter) }
 
   Writer = ->(input, options) do
     options[:binding].evaluate_option(:writer, input, options)
@@ -37,6 +37,7 @@ module Representable
 
   Serialize = ->(input, options) do
     return if input.nil? # DISCUSS: how can we prevent that?
+
     binding, options = options[:binding], options[:options] # FIXME: rename to :local_options.
 
     options_for_nested = OptionsForNested.(options, binding)

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "3.0.4"
+  VERSION = "3.2.0"
 end

data/lib/representable/xml/binding.rb

@@ -1,10 +1,8 @@
 require 'representable/binding'
-require 'representable/hash/binding.rb'
 
 module Representable
   module XML
-    module_function
-    def Node(document, name, attributes={})
+    module_function def Node(document, name, attributes={})
       node = Nokogiri::XML::Node.new(name.to_s, document) # Java::OrgW3cDom::DOMException: NAMESPACE_ERR: An attempt is made to create or change an object in a way which is incorrect with regard to namespaces.
 
       attributes.each { |k, v| node[k] = v } # TODO: benchmark.
@@ -18,6 +16,7 @@ module Representable
         return AttributeHash.new(definition)   if definition.hash? and definition[:use_attributes]
         return Attribute.new(definition)       if definition[:attribute]
         return Content.new(definition)         if definition[:content]
+
         new(definition)
       end
 
@@ -25,7 +24,7 @@ module Representable
         wrap_node = parent
 
         if wrap = self[:wrap]
-          parent << wrap_node = XML::Node(parent, wrap)
+          parent << wrap_node = XML::Node(parent.document, wrap)
         end
 
         wrap_node << serialize_for(fragments, parent, as)
@@ -40,7 +39,7 @@ module Representable
 
       # Creates wrapped node for the property.
       def serialize_for(value, parent, as)
-        node = XML::Node(parent, as) # node doesn't have attr="" attributes!!!
+        node = XML::Node(parent.document, as) # node doesn't have attr="" attributes!!!
         serialize_node(node, value, as)
       end
 
@@ -107,7 +106,7 @@ module Representable
       class Hash < Collection
         def serialize_for(value, parent, as)
           set_for(parent, value.collect do |k, v|
-            node = XML::Node(parent, k)
+            node = XML::Node(parent.document, k)
             serialize_node(node, v, as)
           end)
         end

data/lib/representable/xml.rb

@@ -1,13 +1,14 @@
-require 'representable'
+gem 'nokogiri', '> 1.10.8'
+require 'nokogiri'
 
-begin
-  require 'nokogiri'
-rescue LoadError => _
-  abort "Missing dependency 'nokogiri' for Representable::XML. See dependencies section in README.md for details."
-end
+require 'representable'
 
 module Representable
   module XML
+    autoload :Binding, 'representable/xml/binding'
+    autoload :Collection, 'representable/xml/collection'
+    autoload :Namespace, 'representable/xml/namespace'
+
     def self.included(base)
       base.class_eval do
         include Representable
@@ -71,7 +72,3 @@ module Representable
     end
   end
 end
-
-require "representable/xml/binding"
-require "representable/xml/collection"
-require "representable/xml/namespace"

data/lib/representable/yaml/binding.rb

@@ -5,6 +5,7 @@ module Representable
     class Binding < Representable::Hash::Binding
       def self.build_for(definition)
         return Collection.new(definition) if definition.array?
+
         new(definition)
       end
 

data/lib/representable/yaml.rb

@@ -1,9 +1,9 @@
 require 'psych'
-require 'representable/hash'
-require 'representable/yaml/binding'
+require 'representable'
 
 module Representable
   module YAML
+    autoload :Binding, 'representable/yaml/binding'
     include Hash
 
     def self.included(base)
@@ -40,7 +40,7 @@ module Representable
       stream.to_yaml
     end
 
-     alias_method :render, :to_yaml
+    alias_method :render, :to_yaml
     alias_method :parse, :from_yaml
   end
 end

data/lib/representable.rb

@@ -1,8 +1,8 @@
 require "uber/delegates"
 require "uber/callable"
-require "declarative/option"
 require "declarative/schema"
 
+require "representable/option"
 require "representable/config"
 require "representable/definition"
 require "representable/declarative"
@@ -16,6 +16,17 @@ require "representable/for_collection"
 require "representable/represent"
 
 module Representable
+  autoload :Binding, 'representable/binding'
+  autoload :HashMethods, 'representable/hash_methods'
+  autoload :Decorator, 'representable/decorator'
+
+  autoload :Hash, 'representable/hash'
+  autoload :JSON, 'representable/json'
+  autoload :Object, 'representable/object'
+  autoload :YAML, 'representable/yaml'
+  autoload :XML, 'representable/xml'
+
+
   attr_writer :representable_attrs
 
   def self.included(base)
@@ -32,7 +43,7 @@ module Representable
 private
   # Reads values from +doc+ and sets properties accordingly.
   def update_properties_from(doc, options, format)
-    propagated_options = normalize_options(options)
+    propagated_options = normalize_options(**options)
 
     representable_map!(doc, propagated_options, format, :uncompile_fragment)
     represented
@@ -40,25 +51,12 @@ private
 
   # Compiles the document going through all properties.
   def create_representation_with(doc, options, format)
-    propagated_options = normalize_options(options)
+    propagated_options = normalize_options(**options)
 
     representable_map!(doc, propagated_options, format, :compile_fragment)
     doc
   end
 
-  class Binding::Map < Array
-    def call(method, options)
-      each do |bin|
-        options[:binding] = bin # this is so much faster than options.merge().
-        bin.send(method, options)
-      end
-    end
-
-     # TODO: Merge with Definitions.
-    def <<(binding) # can be slow. this is compile time code.
-      (existing = find { |bin| bin.name == binding.name }) ? self[index(existing)] = binding : super(binding)
-    end
-  end
 
   def representable_map(options, format)
     Binding::Map.new(representable_bindings_for(format, options))
@@ -74,9 +72,8 @@ private
     representable_attrs.collect {|definition| format.build(definition) }
   end
 
-  def normalize_options(options)
-    return options if options.any?
-    {user_options: {}}.merge(options) # TODO: use keyword args once we drop 2.0.
+  def normalize_options(user_options: {}, **options)
+    { user_options: user_options }.merge(options)
   end
 
   # Prepares options for a particular nested representer.
@@ -96,8 +93,8 @@ private
     @representable_attrs ||= self.class.definitions
   end
 
-  def representation_wrap(*args)
-    representable_attrs.wrap_for(represented, *args)
+  def representation_wrap(options = {})
+    representable_attrs.wrap_for(represented, options)
   end
 
   def represented
@@ -118,8 +115,4 @@ private
       represented.extend(self)
     end
   end
-
-  # require "representable/deprecations"
 end
-
-require 'representable/autoload'

data/representable.gemspec

@@ -19,16 +19,16 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.license       = "MIT"
 
-  spec.required_ruby_version = '>= 1.9.3'
+  spec.required_ruby_version = '>= 2.4.0'
 
   spec.add_dependency "uber",               "< 0.2.0"
   spec.add_dependency "declarative",        "< 0.1.0"
-  spec.add_dependency "declarative-option", "< 0.2.0"
+  spec.add_dependency "trailblazer-option", ">= 0.1.1", "< 0.2.0"
 
   spec.add_development_dependency "rake"
   spec.add_development_dependency "test_xml", ">= 0.1.6"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "virtus"
-  spec.add_development_dependency "multi_json"
+  spec.add_development_dependency "dry-types"
   spec.add_development_dependency "ruby-prof" if RUBY_ENGINE == "ruby" # mri
 end

data/test/as_test.rb

@@ -17,7 +17,7 @@ class AsTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document output }
-      it { parse(song, input).name.must_equal "Wie Es Geht" }
+      it { _(parse(song, input).name).must_equal "Wie Es Geht" }
     end
 
 
@@ -27,7 +27,7 @@ class AsTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document({"Song" => "Revolution"}) }
-      it { parse(song, {"Song" => "Wie Es Geht"}).name.must_equal "Wie Es Geht" }
+      it { _(parse(song, {"Song" => "Wie Es Geht"}).name).must_equal "Wie Es Geht" }
     end
 
 
@@ -37,7 +37,7 @@ class AsTest < MiniTest::Spec
       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 { _(parse(song, {"{:volume=>1}" => "Wie Es Geht"}, user_options: {volume: 1}).name).must_equal "Wie Es Geht" }
     end
   end
 end
@@ -60,6 +60,6 @@ class AsXmlTest < MiniTest::Spec
 
   it do
     skip
-    representer.new(Album.new(Band.new("Offspring"))).to_xml.must_equal ""
+    _(representer.new(Album.new(Band.new("Offspring"))).to_xml).must_equal ""
   end
 end

data/test/binding_test.rb

@@ -8,16 +8,16 @@ class BindingTest < MiniTest::Spec
     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
 
 
@@ -26,21 +26,21 @@ class BindingTest < MiniTest::Spec
     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_be_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_be_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_be_nil }
+    it { _(Binding.new(Representable::Definition.new(:song)).default_for(nil)).must_be_nil }
   end
 end

data/test/cached_test.rb

@@ -64,7 +64,7 @@ class CachedTest < MiniTest::Spec
       # 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.
@@ -81,22 +81,22 @@ class CachedTest < MiniTest::Spec
       data = Profiler.profile { representer.to_hash }
 
       # 3 songs get decorated.
-      data.must_match(/3\s*Representable::Function::Decorate#call/m)
+      _(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\s*(<Class::)?Representable::Decorator\>?[\#.]prepare/m)
+      _(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\s*Representable::Binding[#\.]render_pipeline/m)
-      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
 
@@ -118,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_be_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
@@ -139,12 +139,12 @@ class CachedTest < MiniTest::Spec
       # only 2 nested decorators are instantiated, Song, and Artist.
       # Didn't like the regexp?
       # MRI and JRuby has different output formats. See note above.
-      data.must_match(/5\s*(<Class::)?Representable::Decorator>?[#\.]prepare/)
+      _(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\s*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
 
@@ -69,7 +69,7 @@ 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
 
@@ -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