representable 3.2.0 → 3.3.0

data/test/definition_test.rb

@@ -1,6 +1,6 @@
-require 'test_helper'
+require "test_helper"
 
-class DefinitionTest < MiniTest::Spec
+class DefinitionTest < Minitest::Spec
   Definition = Representable::Definition
 
   # TODO: test that we DON'T clone options, that must happen in
@@ -17,7 +17,6 @@ class DefinitionTest < MiniTest::Spec
       end
       _(definition.name).must_equal "song"
 
-      #
       _(definition[:awesome]).must_equal true
       _(definition[:parse_filter]).must_equal Representable::Pipeline[1]
       _(definition[:render_filter]).must_equal Representable::Pipeline[]
@@ -80,7 +79,6 @@ class DefinitionTest < MiniTest::Spec
     end
   end
 
-
   # delete!
   describe "#delete!" do
     let(:definition) { Definition.new(:song, serialize: "remove me!") }
@@ -92,10 +90,11 @@ class DefinitionTest < MiniTest::Spec
 
   # #inspect
   describe "#inspect" do
-    it { _(Definition.new(:songs).inspect).must_equal "#<Representable::Definition ==>songs @options={:name=>\"songs\", :parse_filter=>[], :render_filter=>[]}>" }
+    it {
+      _(Definition.new(:songs).inspect).must_equal "#<Representable::Definition ==>songs @options=#{{name: "songs", parse_filter: [], render_filter: []}.inspect}>"
+    }
   end
 
-
   describe "generic API" do
     before do
       @def = Representable::Definition.new(:songs)
@@ -124,7 +123,6 @@ class DefinitionTest < MiniTest::Spec
       end
     end
 
-
     describe "#representable?" do
       it { assert Definition.new(:song, :representable => true).representable? }
       it { _(Definition.new(:song, :representable => true, :extend => Object).representable?).must_equal true }
@@ -133,7 +131,6 @@ class DefinitionTest < MiniTest::Spec
       it { refute Definition.new(:song).representable? }
     end
 
-
     it "responds to #getter and returns string" do
       assert_equal "songs", @def.getter
     end
@@ -154,7 +151,6 @@ class DefinitionTest < MiniTest::Spec
       end
     end
 
-
     describe "#clone" do
       subject { Representable::Definition.new(:title, :volume => 9, :clonable => ::Representable::Option(1)) }
 
@@ -183,7 +179,6 @@ class DefinitionTest < MiniTest::Spec
     end
   end
 
-
   describe "#binding" do
     it "returns true when :binding is set" do
       assert Representable::Definition.new(:songs, :binding => Object)[:binding]
@@ -196,7 +191,11 @@ class DefinitionTest < MiniTest::Spec
 
   describe "#create_binding" do
     it "executes the block (without special context)" do
-      definition = Representable::Definition.new(:title, :binding => lambda { |*args| @binding = Representable::Binding.new(*args) })
+      definition = Representable::Definition.new(
+        :title, :binding => ->(*args) {
+                              @binding = Representable::Binding.new(*args)
+                            }
+      )
       _(definition.create_binding).must_equal @binding
     end
   end
@@ -211,7 +210,6 @@ class DefinitionTest < MiniTest::Spec
     end
   end
 
-
   describe ":default => value" do
     it "responds to #default" do
       @def = Representable::Definition.new(:song)

data/test/examples/example.rb

@@ -1,8 +1,8 @@
-require 'bundler'
+require "bundler"
 Bundler.setup
 
-require 'representable/yaml'
-require 'ostruct'
+require "representable/yaml"
+require "ostruct"
 
 def reset_representer(*module_name)
   module_name.each do |mod|
@@ -32,7 +32,7 @@ puts rox.inspect
 module SongRepresenter
   include Representable::JSON
 
-  self.representation_wrap= :hit
+  self.representation_wrap = :hit
 
   property :title
   property :track
@@ -40,8 +40,6 @@ end
 
 puts song.extend(SongRepresenter).to_json
 
-
-
 ######### collections
 
 reset_representer(SongRepresenter)
@@ -54,17 +52,15 @@ module SongRepresenter
   collection :composers
 end
 
-
 song = Song.new(:title => "Fallout", :composers => ["Stewart Copeland", "Sting"])
 puts song.extend(SongRepresenter).to_json
 
-
 ######### nesting types
 
 class Album < OpenStruct
   def name
     puts @table.inspect
-    #@attributes
+    # @attributes
     @table[:name]
   end
 end
@@ -91,14 +87,15 @@ end
 album = Album.new(:name => "The Police", :songs => [song, Song.new(:title => "Synchronicity")])
 puts album.extend(AlbumRepresenter).to_json
 
-
-album = Album.new.extend(AlbumRepresenter).from_json(%{{"name":"Offspring","songs":[{"title":"Genocide"},{"title":"Nitro","composers":["Offspring"]}]}
-})
+album = Album.new.extend(AlbumRepresenter).from_json(
+  %{{"name":"Offspring","songs":[{"title":"Genocide"},{"title":"Nitro","composers":["Offspring"]}]}
+}
+)
 puts album.inspect
 
 reset_representer(SongRepresenter)
 
-######### using helpers (customizing the rendering/parsing) 
+######### using helpers (customizing the rendering/parsing)
 module AlbumRepresenter
   include Representable::JSON
 
@@ -107,12 +104,11 @@ module AlbumRepresenter
   end
 end
 
-puts Album.new(:name => "The Police").
-  extend(AlbumRepresenter).to_json
+puts Album.new(:name => "The Police")
+          .extend(AlbumRepresenter).to_json
 
 reset_representer(SongRepresenter)
 
-
 ######### inheritance
 module SongRepresenter
   include Representable::JSON
@@ -128,13 +124,11 @@ module CoverSongRepresenter
   property :covered_by
 end
 
-
 song = Song.new(:title => "Truth Hits Everybody", :covered_by => "No Use For A Name")
 puts song.extend(CoverSongRepresenter).to_json
 
-
 ### XML
-require 'representable/xml'
+require "representable/xml"
 module SongRepresenter
   include Representable::XML
 
@@ -147,9 +141,8 @@ puts song.extend(SongRepresenter).to_xml
 
 reset_representer(SongRepresenter)
 
-
 ### YAML
-require 'representable/yaml'
+require "representable/yaml"
 module SongRepresenter
   include Representable::YAML
 
@@ -159,12 +152,10 @@ module SongRepresenter
 end
 puts song.extend(SongRepresenter).to_yaml
 
-
 SongRepresenter.module_eval do
   @representable_attrs = nil
 end
 
-
 ### YAML
 module SongRepresenter
   include Representable::YAML
@@ -214,7 +205,6 @@ end
 songs = [Song.new(title: "Weirdo", track: 5), CoverSong.new(title: "Truth Hits Everybody", track: 6, copyright: "The Police")]
 album = Album.new(name: "Incognito", songs: songs)
 
-
 reset_representer(SongRepresenter, AlbumRepresenter)
 
 module SongRepresenter
@@ -235,7 +225,7 @@ module AlbumRepresenter
   include Representable::Hash
 
   property :name
-  collection :songs, :extend => lambda { |song| song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter }
+  collection :songs, :extend => ->(song) { song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter }
 end
 
 puts album.extend(AlbumRepresenter).to_hash
@@ -246,12 +236,20 @@ module AlbumRepresenter
   include Representable::Hash
 
   property :name
-  collection :songs, 
-    :extend => lambda { |song| song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter },
-    :class  => lambda { |hsh| hsh.has_key?("copyright") ? CoverSong : Song } #=> {"title"=>"Weirdo", "track"=>5}
+  collection :songs,
+             :extend => ->(song) { song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter },
+             :class  => ->(hsh) { hsh.key?("copyright") ? CoverSong : Song } #=> {"title"=>"Weirdo", "track"=>5}
 end
 
-album = Album.new.extend(AlbumRepresenter).from_hash({"name"=>"Incognito", "songs"=>[{"title"=>"Weirdo", "track"=>5}, {"title"=>"Truth Hits Everybody", "track"=>6, "copyright"=>"The Police"}]})
+album = Album.new.extend(AlbumRepresenter).from_hash(
+  {
+    "name"  => "Incognito",
+    "songs" => [
+      {"title" => "Weirdo", "track" => 5},
+      {"title" => "Truth Hits Everybody", "track" => 6, "copyright" => "The Police"}
+    ]
+  }
+)
 puts album.inspect
 
 reset_representer(AlbumRepresenter)
@@ -260,12 +258,20 @@ module AlbumRepresenter
   include Representable::Hash
 
   property :name
-  collection :songs, 
-    :extend   => lambda { |song| song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter },
-    :instance => lambda { |hsh| hsh.has_key?("copyright") ? CoverSong.new : Song.new(original: true) }
+  collection :songs,
+             :extend   => ->(song) { song.is_a?(CoverSong) ? CoverSongRepresenter : SongRepresenter },
+             :instance => ->(hsh) { hsh.key?("copyright") ? CoverSong.new : Song.new(original: true) }
 end
 
-album = Album.new.extend(AlbumRepresenter).from_hash({"name"=>"Incognito", "songs"=>[{"title"=>"Weirdo", "track"=>5}, {"title"=>"Truth Hits Everybody", "track"=>6, "copyright"=>"The Police"}]})
+album = Album.new.extend(AlbumRepresenter).from_hash(
+  {
+    "name"  => "Incognito",
+    "songs" => [
+      {"title" => "Weirdo", "track" => 5},
+      {"title" => "Truth Hits Everybody", "track" => 6, "copyright" => "The Police"}
+    ]
+  }
+)
 puts album.inspect
 
 ######### #hash
@@ -287,19 +293,18 @@ module FavoriteSongsRepresenter
   include Representable::JSON::Hash
 end
 
-puts( {"Nick" => "Hyper Music", "El" => "Blown In The Wind"}.extend(FavoriteSongsRepresenter).to_json)
+puts({"Nick" => "Hyper Music", "El" => "Blown In The Wind"}.extend(FavoriteSongsRepresenter).to_json)
 
-require 'representable/json/hash'
+require "representable/json/hash"
 module FavoriteSongsRepresenter
   include Representable::JSON::Hash
 
   values extend: SongRepresenter, class: Song
 end
 
-puts( {"Nick" => Song.new(title: "Hyper Music")}.extend(FavoriteSongsRepresenter).to_json)
-
+puts({"Nick" => Song.new(title: "Hyper Music")}.extend(FavoriteSongsRepresenter).to_json)
 
-require 'representable/json/collection'
+require "representable/json/collection"
 module SongsRepresenter
   include Representable::JSON::Collection
 

data/test/examples/object.rb

@@ -3,9 +3,11 @@ require "test_helper"
 require "ostruct"
 require "pp"
 
-
-source = OpenStruct.new(name: "30 Years Live", songs: [
-  OpenStruct.new(id: 1, title: "Dear Beloved"), OpenStruct.new(id: 2, title: "Fuck Armageddon")])
+source = OpenStruct.new(
+  name: "30 Years Live", songs: [
+    OpenStruct.new(id: 1, title: "Dear Beloved"), OpenStruct.new(id: 2, title: "Fuck Armageddon")
+  ]
+)
 
 require "representable/object"
 
@@ -13,15 +15,14 @@ class AlbumRepresenter < Representable::Decorator
   include Representable::Object
 
   property :name
-  collection :songs, instance: ->(fragment, *) { Song.new } do
+  collection :songs, instance: ->(_fragment, *) { Song.new } do
     property :title
   end
 end
 
-
 Album = Struct.new(:name, :songs)
 Song = Struct.new(:title)
 
 target = Album.new
 
-AlbumRepresenter.new(target).from_object(source)
+AlbumRepresenter.new(target).from_object(source)

data/test/exec_context_test.rb

@@ -1,65 +1,60 @@
-require 'test_helper'
+require "test_helper"
 
-class ExecContextTest < MiniTest::Spec
+class ExecContextTest < Minitest::Spec
   for_formats(
-    :hash => [Representable::Hash, {Song => "Rebel Fate"}, {Song=>"Timing"}],
+    :hash => [Representable::Hash, {Song => "Rebel Fate"}, {Song=>"Timing"}]
     # :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("Timing")) }
     let(:format) { format }
 
-
     describe "exec_context: nil" do
       representer!(:module => mod) do
-        property :name, :as => lambda { |*| self.class }
+        property :name, :as => ->(*) { self.class }
       end
 
       it { render(song).must_equal_document output }
       it { _(parse(song, input).name).must_equal "Rebel Fate" }
     end
 
-
     describe "exec_context: :decorator" do
       representer!(:module => mod) do
-        property :name, :as => lambda { |*| self.class }, :exec_context => :decorator
+        property :name, :as => ->(*) { self.class }, :exec_context => :decorator
       end
 
       it { render(song).must_equal_document output }
       it { _(parse(song, input).name).must_equal "Rebel Fate" }
     end
 
-
     describe "exec_context: :binding" do
       representer!(:module => mod) do
         property :name,
-          :as           => lambda { |*| self.class }, # to actually test
-          :exec_context => :binding,
-          :setter        => lambda { |options| options[:represented].name = options[:fragment] # to make parsing work.
-        }
+                 :as           => ->(*) { self.class }, # to actually test
+                 :exec_context => :binding,
+                 :setter       => ->(options) {
+                                    options[:represented].name = options[:fragment] # to make parsing work.
+                                  }
       end
 
       it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
       it { _(parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name).must_equal "Rebel Fate" }
     end
 
-
     describe "Decorator" do
       # DISCUSS: do we need this test?
       describe "exec_context: nil" do
         representer!(:module => mod, :decorator => true) do
-          property :name, :as => lambda { |*| self.class }
+          property :name, :as => ->(*) { self.class }
         end
 
         it { render(song).must_equal_document output }
         it { _(parse(song, input).name).must_equal "Rebel Fate" }
       end
 
-
       describe "exec_context: :decorator" do # this tests if lambdas are run in the right context, if methods are called in the right context and if we can access the represented object.
         representer!(:module => mod, :decorator => true) do
-          property :name, :as => lambda { |*| self.class.superclass }, :exec_context => :decorator
+          property :name, :as => ->(*) { self.class.superclass }, :exec_context => :decorator
 
           define_method :name do # def in Decorator class.
             "Timebomb"
@@ -74,15 +69,15 @@ class ExecContextTest < MiniTest::Spec
         it { _(parse(song, {Representable::Decorator=>"Listless"}).name).must_equal "Listless" }
       end
 
-
       # DISCUSS: do we need this test?
       describe "exec_context: :binding" do
         representer!(:module => mod, :decorator => true) do
           property :name,
-            :as           => lambda { |*| self.class }, # to actually test
-            :exec_context => :binding,
-            :setter        => lambda { |options| options[:represented].name = options[:fragment ] # to make parsing work.
-          }
+                   :as           => ->(*) { self.class }, # to actually test
+                   :exec_context => :binding,
+                   :setter       => ->(options) {
+                                      options[:represented].name = options[:fragment] # to make parsing work.
+                                    }
         end
 
         it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
@@ -90,4 +85,4 @@ class ExecContextTest < MiniTest::Spec
       end
     end
   end
-end
+end

data/test/features_test.rb

@@ -1,14 +1,15 @@
-require 'test_helper'
+require "test_helper"
 
-class FeaturesTest < MiniTest::Spec
+class FeaturesTest < Minitest::Spec
   module Title
     def title; "Is It A Lie"; end
   end
+
   module Length
     def length; "2:31"; end
   end
 
-  definition = lambda {
+  definition = -> {
     feature Title
     feature Length
 
@@ -27,20 +28,33 @@ class FeaturesTest < MiniTest::Spec
       instance_exec(&definition)
     end
 
-    it { _(song.extend(representer).to_hash).must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
+    it {
+      _(song.extend(representer).to_hash).must_equal(
+        {
+          "title" => "Is It A Lie", "length" => "2:31",
+         "details" => {"title"=>"Is It A Lie"}
+        }
+      )
+    }
   end
 
-
   describe "Decorator" do
     representer!(:decorator => true) do
       instance_exec(&definition)
     end
 
-    it { _(representer.new(song).to_hash).must_equal({"title"=>"Is It A Lie", "length"=>"2:31", "details"=>{"title"=>"Is It A Lie"}}) }
+    it {
+      _(representer.new(song).to_hash).must_equal(
+        {
+          "title" => "Is It A Lie", "length" => "2:31",
+         "details" => {"title"=>"Is It A Lie"}
+        }
+      )
+    }
   end
 end
 
-class FeatureInclusionOrderTest < MiniTest::Spec
+class FeatureInclusionOrderTest < Minitest::Spec
   module Title
     def title
       "I was first!"
@@ -49,7 +63,7 @@ class FeatureInclusionOrderTest < MiniTest::Spec
 
   module OverridingTitle
     def title
-      "I am number two, " + super
+      "I am number two, #{super}"
     end
   end
 
@@ -65,6 +79,11 @@ class FeatureInclusionOrderTest < MiniTest::Spec
   end
 
   it do
-    _(representer.new(OpenStruct.new(song: Object)).to_hash).must_equal({"title"=>"I am number two, I was first!", "song"=>{"title"=>"I am number two, I was first!"}})
+    _(representer.new(OpenStruct.new(song: Object)).to_hash).must_equal(
+      {
+        "title" => "I am number two, I was first!",
+        "song"  => {"title"=>"I am number two, I was first!"}
+      }
+    )
   end
-end
+end

data/test/filter_test.rb

@@ -1,43 +1,53 @@
-require 'test_helper'
+require "test_helper"
 
-class FilterPipelineTest < MiniTest::Spec
-  let(:block1) { lambda { |input, options| "1: #{input}" } }
-  let(:block2) { lambda { |input, options| "2: #{input}" } }
+class FilterPipelineTest < Minitest::Spec
+  let(:block1) { ->(input, _options) { "1: #{input}" } }
+  let(:block2) { ->(input, _options) { "2: #{input}" } }
 
   subject { Representable::Pipeline[block1, block2] }
 
   it { _(subject.call("Horowitz", {})).must_equal "2: 1: Horowitz" }
 end
 
-
-class FilterTest < MiniTest::Spec
+class FilterTest < Minitest::Spec
   representer! do
     property :title
 
     property :track,
-      :parse_filter  => lambda { |input, options| "#{input.downcase},#{options[:doc]}" },
-      :render_filter => lambda { |val, options| "#{val.upcase},#{options[:doc]},#{options[:options][:user_options]}" }
+             :parse_filter  => ->(input, options) { "#{input.downcase},#{options[:doc]}" },
+             :render_filter => ->(val, options) { "#{val.upcase},#{options[:doc]},#{options[:options][:user_options]}" }
   end
 
   # gets doc and options.
   it {
     song = OpenStruct.new.extend(representer).from_hash("title" => "VULCAN EARS", "track" => "Nine")
     _(song.title).must_equal "VULCAN EARS"
-    _(song.track).must_equal "nine,{\"title\"=>\"VULCAN EARS\", \"track\"=>\"Nine\"}"
+    _(song.track).must_equal "nine,#{{"title" => "VULCAN EARS", "track" => "Nine"}.inspect}"
   }
 
-  it { _(OpenStruct.new("title" => "vulcan ears", "track" => "Nine").extend(representer).to_hash).must_equal( {"title"=>"vulcan ears", "track"=>"NINE,{\"title\"=>\"vulcan ears\"},{}"}) }
-
+  it {
+    _(
+      OpenStruct.new(
+        "title" => "vulcan ears",
+        "track" => "Nine"
+      ).extend(representer).to_hash
+    ).must_equal({
+                   "title" => "vulcan ears",
+                   "track" => "NINE,#{{"title" => "vulcan ears"}.inspect},#{{}.inspect}"
+                 })
+  }
 
   describe "#parse_filter" do
     representer! do
       property :track,
-        :parse_filter => [
-          lambda { |input, options| "#{input}-1" },
-          lambda { |input, options| "#{input}-2" }],
-        :render_filter => [
-          lambda { |val, options| "#{val}-1" },
-          lambda { |val, options| "#{val}-2" }]
+               :parse_filter  => [
+                 ->(input, _options) { "#{input}-1" },
+                 ->(input, _options) { "#{input}-2" }
+               ],
+               :render_filter => [
+                 ->(val, _options) { "#{val}-1" },
+                 ->(val, _options) { "#{val}-2" }
+               ]
     end
 
     # order matters.
@@ -46,12 +56,11 @@ class FilterTest < MiniTest::Spec
   end
 end
 
-
-# class RenderFilterTest < MiniTest::Spec
+# class RenderFilterTest < Minitest::Spec
 #   representer! do
 #     property :track, :render_filter => [lambda { |val, options| "#{val}-1" } ]
 #     property :track, :render_filter => [lambda { |val, options| "#{val}-2" } ], :inherit => true
 #   end
 
 #   it { OpenStruct.new("track" => "Nine").extend(representer).to_hash.must_equal({"track"=>"Nine-1-2"}) }
-# end
+# end