representable 3.2.0 → 3.3.0

data/test/represent_test.rb

@@ -1,27 +1,26 @@
-require 'test_helper'
+require "test_helper"
 
-class RepresentTest < MiniTest::Spec
+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],
+    :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) {
+      let(:representer) do
         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
-      }
+      end
 
       it { render(representer.represent(songs)).must_equal_document output }
       it { _(parse(representer.represent([]), input)).must_equal songs }
@@ -30,59 +29,56 @@ class RepresentTest < MiniTest::Spec
     # Decorator.represents detects collection.
     describe "Decorator#to_/from_#{format}" do
       let(:format) { format }
-      let(:representer) {
+      let(:representer) do
         Class.new(Representable::Decorator) do
           include mod
           property :name
 
           collection_representer :class => Song
         end
-      }
+      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],
+    :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) {
+      let(:representer) do
         Module.new do
           include mod
           property :name
 
           collection_representer :class => Song
         end
-      }
+      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) {
+      let(:representer) do
         Class.new(Representable::Decorator) do
           include mod
           property :name
 
           collection_representer :class => Song
         end
-      }
+      end
 
       it { render(representer.represent(song)).must_equal_document output }
       it { _(parse(representer.represent(Song.new), input)).must_equal song }
     end
   end
-end
+end

data/test/representable_test.rb

@@ -1,6 +1,6 @@
-require 'test_helper'
+require "test_helper"
 
-class RepresentableTest < MiniTest::Spec
+class RepresentableTest < Minitest::Spec
   class Band
     include Representable::Hash
     property :name
@@ -25,21 +25,21 @@ class RepresentableTest < MiniTest::Spec
     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
+               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
+      # it "allows including the concrete representer module only" do
       #  require 'representable/json'
       #  module RockBandRepresentation
       #    include Representable::JSON
@@ -50,11 +50,10 @@ class RepresentableTest < MiniTest::Spec
       #  end.new
       #  vd.name        = "Van Halen"
       #  assert_equal "{\"name\":\"Van Halen\"}", vd.to_json
-      #end
+      # end
     end
   end
 
-
   describe "inheritance" do
     class CoverSong < OpenStruct
     end
@@ -71,7 +70,7 @@ class RepresentableTest < MiniTest::Spec
     end
 
     it "merges properties from all ancestors" do
-      props = {"name"=>"The Brews", "by"=>"Nofx"}
+      props = {"name" => "The Brews", "by" => "Nofx"}
       assert_equal(props, CoverSong.new(props).extend(CoverSongRepresenter).to_hash)
     end
 
@@ -89,7 +88,7 @@ class RepresentableTest < MiniTest::Spec
       band.name = "Bodyjar"
 
       assert_json "{\"band\":{\"name\":\"Bodyjar\"}}", band.to_json
-      assert_xml_equal "<band><name>Bodyjar</name></band>", band.to_xml
+      assert_xml_equal(band.to_xml, "<band><name>Bodyjar</name></band>")
     end
 
     it "allows extending with different representers subsequentially" do
@@ -104,11 +103,10 @@ class RepresentableTest < MiniTest::Spec
       end
 
       @song = Song.new("Days Go By")
-      assert_xml_equal "<song name=\"Days Go By\"/>", @song.extend(SongXmlRepresenter).to_xml
+      assert_xml_equal(@song.extend(SongXmlRepresenter).to_xml, "<song name=\"Days Go By\"/>")
       assert_json "{\"name\":\"Days Go By\"}", @song.extend(SongJsonRepresenter).to_json
     end
 
-
     # test if we call super in
     #   ::inherited
     #   ::included
@@ -120,14 +118,18 @@ class RepresentableTest < MiniTest::Spec
     class BaseClass
       def self.inherited(subclass)
         super
-        subclass.instance_eval { def other; end }
+        subclass.instance_eval do
+          def other
+          end
+        end
       end
 
       include Representable # overrides ::inherited.
       include Representer
     end
 
-    class SubClass < BaseClass # triggers Representable::inherited, then OtherModule::inherited.
+    # triggers Representable::inherited, then OtherModule::inherited.
+    class SubClass < BaseClass
     end
 
     # test ::inherited.
@@ -138,7 +140,10 @@ class RepresentableTest < MiniTest::Spec
 
     module DifferentIncluded
       def included(includer)
-        includer.instance_eval { def different; end }
+        includer.instance_eval do
+          def different
+          end
+        end
       end
     end
 
@@ -159,7 +164,6 @@ class RepresentableTest < MiniTest::Spec
     end
   end
 
-
   describe "#property" do
     it "doesn't modify options hash" do
       options = {}
@@ -215,7 +219,7 @@ class RepresentableTest < MiniTest::Spec
     end
 
     it "copies values from document to object" do
-      @band.from_hash({"name"=>"No One's Choice", "groupies"=>2})
+      @band.from_hash({"name" => "No One's Choice", "groupies" => 2})
       assert_equal "No One's Choice", @band.name
       assert_equal 2, @band.groupies
     end
@@ -238,16 +242,16 @@ class RepresentableTest < MiniTest::Spec
 
     it "ignores properties not present in the incoming document" do
       @band.instance_eval do
-        def name=(*); raise "I should never be called!"; end
+        def name=(*); fail "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]
+      {
+        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
@@ -268,7 +272,6 @@ class RepresentableTest < MiniTest::Spec
     describe "passing options" do
       module TrackRepresenter
         include Representable::Hash
-
       end
 
       representer! do
@@ -300,12 +303,21 @@ class RepresentableTest < MiniTest::Spec
       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(user_options: {nr: 9})).must_equal({"track"=>{"nr"=>9, "length"=>{seconds: 9}}})
+        _(
+          OpenStruct.new(
+            track: OpenStruct.new(
+              nr:     1,
+              length: OpenStruct.new(seconds: nil)
+            )
+          ).extend(representer).extend(Representable::Debug)
+                    .to_hash(user_options: {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"}}}, user_options: {nr: 9})
+        song = OpenStruct.new.extend(representer).from_hash(
+          {"track"=>{"nr" => "replace me", "length" => {"seconds"=>"replacing"}}}, user_options: {nr: 9}
+        )
         _(song.track.nr).must_equal 9
         _(song.track.length.seconds).must_equal 9
       end
@@ -320,13 +332,13 @@ class RepresentableTest < MiniTest::Spec
     end
 
     it "compiles document from properties in object" do
-      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.to_hash)
+      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]
+      @band.founder_ids = [1, 2, 3]
 
       hash = @band.to_hash
       assert_equal({"name" => "Iron Maiden"}, hash)
@@ -339,37 +351,40 @@ class RepresentableTest < MiniTest::Spec
 
     it "writes false attributes" do
       @band.groupies = false
-      assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.to_hash)
+      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.
+      # DISCUSS: from_hash must return self.
+      def from_hash(hsh, *_args); replace hsh.upcase; end
     end
+
     module DowncaseRepresenter
       include Representable
       def to_hash(*); downcase; end
-      def from_hash(hsh, *args); replace hsh.downcase; end
+      def from_hash(hsh, *_args); replace hsh.downcase; end
     end
-    class UpcaseString < String; end
 
+    class UpcaseString < String; end
 
     describe "lambda blocks" do
       representer! do
-        property :name, :extend => lambda { |name, *| compute_representer(name) }
+        property :name, :extend => ->(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"})
+        _(
+          Song.new("Carnage").instance_eval {
+            def compute_representer(_name)
+              UpcaseRepresenter
+            end
+            self
+          }.extend(representer).to_hash
+        ).must_equal({"name" => "CARNAGE"})
       end
     end
 
@@ -377,7 +392,7 @@ class RepresentableTest < MiniTest::Spec
       obj = String.new("Fate")
       mod = Module.new { include Representable; def from_hash(*); self; end }
       representer! do
-        property :name, :extend => mod, :instance => lambda { |*| obj }
+        property :name, :extend => mod, :instance => ->(*) { obj }
       end
 
       it "uses object from :instance but still extends it" do
@@ -389,12 +404,14 @@ class RepresentableTest < MiniTest::Spec
 
     describe "property with :extend" do
       representer! do
-        property :name, :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
+        property :name, :extend => ->(options) {
+                                     options[:input].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 )
+        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
@@ -404,8 +421,10 @@ class RepresentableTest < MiniTest::Spec
 
       describe "with :class lambda" do
         representer! do
-          property :name, :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
-                          :class  => lambda { |options| options[:fragment] == "Still Failing?" ? String : UpcaseString }
+          property :name, :extend => ->(options) {
+                                       options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter
+                                     },
+                          :class  => ->(options) { options[:fragment] == "Still Failing?" ? String : UpcaseString }
         end
 
         it "creates instance from :class lambda when parsing" do
@@ -420,14 +439,25 @@ class RepresentableTest < MiniTest::Spec
       end
     end
 
-
     describe "collection with :extend" do
       representer! do
-        collection :songs, :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter }, :class => String
+        collection :songs, :extend => ->(options) {
+                                        options[:input].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"])
+        _(
+          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
@@ -437,8 +467,10 @@ class RepresentableTest < MiniTest::Spec
 
       describe "with :class lambda" do
         representer! do
-          collection :songs,  :extend => lambda { |options| options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter },
-                              :class  => lambda { |options| options[:input] == "Still Failing?" ? String : UpcaseString }
+          collection :songs, :extend => ->(options) {
+                                          options[:input].is_a?(UpcaseString) ? UpcaseRepresenter : DowncaseRepresenter
+                                        },
+                             :class  => ->(options) { options[:input] == "Still Failing?" ? String : UpcaseString }
         end
 
         it "creates instance from :class lambda for each item when parsing" do
@@ -463,6 +495,7 @@ class RepresentableTest < MiniTest::Spec
       include Representable::JSON
       property :name
     end
+
     class AlbumRepresentation < Representable::Decorator
       include Representable::JSON
 
@@ -475,7 +508,7 @@ class RepresentableTest < MiniTest::Spec
 
       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 = 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

data/test/schema_test.rb

@@ -1,7 +1,7 @@
-require 'test_helper'
+require "test_helper"
 
 # Include Inherit Module And Decorator Test
-class SchemaTest < MiniTest::Spec
+class SchemaTest < Minitest::Spec
   module Genre
     include Representable
     property :genre
@@ -18,7 +18,6 @@ class SchemaTest < MiniTest::Spec
     end
   end
 
-
   module Module
     include Representable::Hash
     feature LinkFeature
@@ -34,13 +33,11 @@ class SchemaTest < MiniTest::Spec
       end
     end
 
-    property :album, :extend => lambda { raise "don't manifest me!" } # this is not an inline decorator, don't manifest it.
-
+    property :album, :extend => -> { fail "don't manifest me!" } # this is not an inline decorator, don't manifest it.
 
     include Genre # Schema::Included::included is called!
   end
 
-
   class WithLocationStreetRepresenter < Representable::Decorator
     include Representable::Hash
     feature LinkFeature
@@ -61,14 +58,26 @@ class SchemaTest < MiniTest::Spec
     let(:label) { OpenStruct.new(:name => "Epitaph", :location => OpenStruct.new(:city => "Sanfran", :name => "DON'T SHOW ME!")) }
 
     # Module does correctly include features in inlines.
-    it { _(band.extend(Module).to_hash).must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
+    it {
+      _(band.extend(Module).to_hash).must_equal(
+        {
+          "label" => {"name" => "Epitaph", "location" => {"city"=>"Sanfran"}},
+          "genre" => "Punkrock"
+        }
+      )
+    }
 
     # Decorator does correctly include features in inlines.
-    it { _(Decorator.new(band).to_hash).must_equal({"label"=>{"name"=>"Epitaph", "location"=>{"city"=>"Sanfran"}}, "genre"=>"Punkrock"}) }
+    it {
+      _(Decorator.new(band).to_hash).must_equal(
+        {
+          "label" => {"name" => "Epitaph", "location" => {"city"=>"Sanfran"}},
+          "genre" => "Punkrock"
+        }
+      )
+    }
   end
 
-
-
   class Decorator < Representable::Decorator
     feature Representable::Hash
 
@@ -77,17 +86,25 @@ class SchemaTest < MiniTest::Spec
 
   # puts Decorator.representable_attrs[:definitions].inspect
 
-  let(:label) { OpenStruct.new(:name => "Fat Wreck", :city => "San Francisco", :employees => [OpenStruct.new(:name => "Mike")], :location => OpenStruct.new(:city => "Sanfran")) }
+  let(:label) do
+    OpenStruct.new(
+      :name => "Fat Wreck", :city => "San Francisco", :employees => [OpenStruct.new(:name => "Mike")],
+      :location => OpenStruct.new(:city => "Sanfran")
+    )
+  end
   let(:band) { OpenStruct.new(:genre => "Punkrock", :label => label) }
 
-
   # it { FlatlinersDecorator.new( OpenStruct.new(label: OpenStruct.new) ).
   #   to_hash.must_equal({}) }
   it do
-    _(Decorator.new(band).to_hash).must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "location"=>{"city"=>"Sanfran"}}})
+    _(Decorator.new(band).to_hash).must_equal(
+      {
+        "genre" => "Punkrock",
+        "label" => {"name" => "Fat Wreck", "location" => {"city"=>"Sanfran"}}
+      }
+    )
   end
 
-
   class InheritDecorator < Representable::Decorator
     include Representable::Hash
 
@@ -103,11 +120,17 @@ class SchemaTest < MiniTest::Spec
   end
 
   it do
-    _(InheritDecorator.new(band).to_hash).must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "location"=>{"city"=>"Sanfran"}}})
+    _(InheritDecorator.new(band).to_hash).must_equal(
+      {
+        "genre" => "Punkrock",
+        "label" => {
+          "name" => "Fat Wreck", "city" => "San Francisco",
+"location" => {"city"=>"Sanfran"}
+        }
+      }
+    )
   end
 
-
-
   class InheritFromDecorator < InheritDecorator
     property :label, inherit: true do
       collection :employees do
@@ -117,12 +140,19 @@ class SchemaTest < MiniTest::Spec
   end
 
   it do
-    _(InheritFromDecorator.new(band).to_hash).must_equal({"genre"=>"Punkrock", "label"=>{"name"=>"Fat Wreck", "city"=>"San Francisco", "employees"=>[{"name"=>"Mike"}], "location"=>{"city"=>"Sanfran"}}})
+    _(InheritFromDecorator.new(band).to_hash).must_equal(
+      {
+        "genre" => "Punkrock",
+        "label" => {
+          "name" => "Fat Wreck", "city" => "San Francisco", "employees" => [{"name"=>"Mike"}],
+      "location" => {"city"=>"Sanfran"}
+        }
+      }
+    )
   end
 end
 
-
-class ApplyTest < MiniTest::Spec
+class ApplyTest < Minitest::Spec
   class AlbumDecorator < Representable::Decorator
     include Representable::Hash
 
@@ -142,4 +172,4 @@ class ApplyTest < MiniTest::Spec
       end
     end
   end
-end
+end

data/test/serialize_deserialize_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class SerializeDeserializeTest < BaseTest
   subject { Struct.new(:song).new.extend(representer) }
@@ -6,28 +6,28 @@ class SerializeDeserializeTest < BaseTest
   describe "deserialize" do
     representer! do
       property :song,
-        :instance => lambda { |options| options[:input].to_s.upcase },
-        :prepare  => lambda { |options| options[:input] },
-        :deserialize => lambda { |options|
-          "#{options[:input]} #{options[:fragment]} #{options[:user_options].inspect}"
-        }
+               :instance    => ->(options) { options[:input].to_s.upcase },
+               :prepare     => ->(options) { options[:input] },
+               :deserialize => ->(options) {
+                 "#{options[:input]} #{options[:fragment]} #{options[:user_options].inspect}"
+               }
     end
 
-    it { _(subject.from_hash({"song" => Object}, user_options: {volume: 9}).song).must_equal "OBJECT Object {:volume=>9}" }
+    it { _(subject.from_hash({"song" => Object}, user_options: {volume: 9}).song).must_equal "OBJECT Object #{{volume: 9}.inspect}" }
   end
 
   describe "serialize" do
     representer! do
       property :song,
-        :representable => true,
-        :prepare  => lambda { |options| options[:fragment] },
-        :serialize => lambda { |options|
-          "#{options[:input]} #{options[:user_options].inspect}"
-        }
+               :representable => true,
+               :prepare       => ->(options) { options[:fragment] },
+               :serialize     => ->(options) {
+                 "#{options[:input]} #{options[:user_options].inspect}"
+               }
     end
 
     before { subject.song = "Arrested In Shanghai" }
 
-    it { _(subject.to_hash(user_options: {volume: 9})).must_equal({"song"=>"Arrested In Shanghai {:volume=>9}"}) }
+    it { _(subject.to_hash(user_options: {volume: 9})).must_equal({"song" => "Arrested In Shanghai #{{volume: 9}.inspect}"}) }
   end
-end
+end