representable 3.2.0 → 3.3.0

data/test/json_test.rb

@@ -1,34 +1,33 @@
-require 'test_helper'
-require 'json'
+require "test_helper"
+require "json"
 
 module JsonTest
-class JSONPublicMethodsTest < Minitest::Spec
-  #---
-  # from_json
-  class BandRepresenter < Representable::Decorator
-    include Representable::JSON
-    property :id
-    property :name
-  end
+  class JSONPublicMethodsTest < Minitest::Spec
+    #---
+    # from_json
+    class BandRepresenter < Representable::Decorator
+      include Representable::JSON
+      property :id
+      property :name
+    end
 
-  let(:json) { '{"id":1,"name":"Rancid"}' }
+    let(:json) { '{"id":1,"name":"Rancid"}' }
 
-  it { _(BandRepresenter.new(Band.new).from_json(json)[:id, :name]).must_equal [1, "Rancid"] }
-  it { _(BandRepresenter.new(Band.new).parse(json)[:id, :name]).must_equal [1, "Rancid"] }
+    it { _(BandRepresenter.new(Band.new).from_json(json)[:id, :name]).must_equal [1, "Rancid"] }
+    it { _(BandRepresenter.new(Band.new).parse(json)[:id, :name]).must_equal [1, "Rancid"] }
 
-  #---
-  # to_json
-  let(:band) { Band.new(1, "Rancid") }
+    #---
+    # to_json
+    let(:band) { Band.new(1, "Rancid") }
 
-  it { _(BandRepresenter.new(band).to_json).must_equal json }
-  it { _(BandRepresenter.new(band).render).must_equal json }
-end
+    it { _(BandRepresenter.new(band).to_json).must_equal json }
+    it { _(BandRepresenter.new(band).render).must_equal json }
+  end
 
-  class APITest < MiniTest::Spec
+  class APITest < Minitest::Spec
     Json = Representable::JSON
     Def = Representable::Definition
 
-
     describe "JSON module" do
       before do
         @Band = Class.new do
@@ -37,7 +36,7 @@ end
           property :label
           attr_accessor :name, :label
 
-          def initialize(name=nil)
+          def initialize(name = nil)
             self.name = name if name
           end
         end
@@ -45,29 +44,27 @@ end
         @band = @Band.new
       end
 
-
       describe "#from_json" do
         before do
           @band = @Band.new
-          @json  = {:name => "Nofx", :label => "NOFX"}.to_json
+          @json = {:name => "Nofx", :label => "NOFX"}.to_json
         end
 
         it "parses JSON and assigns properties" do
           @band.from_json(@json)
-          assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+          assert_equal %w[Nofx NOFX], [@band.name, @band.label]
         end
       end
 
-
       describe "#from_hash" do
         before do
           @band = @Band.new
-          @hash  = {"name" => "Nofx", "label" => "NOFX"}
+          @hash = {"name" => "Nofx", "label" => "NOFX"}
         end
 
         it "receives hash and assigns properties" do
           @band.from_hash(@hash)
-          assert_equal ["Nofx", "NOFX"], [@band.name, @band.label]
+          assert_equal %w[Nofx NOFX], [@band.name, @band.label]
         end
 
         it "respects :wrap option" do
@@ -84,14 +81,12 @@ end
         end
       end
 
-
       describe "#to_json" do
         it "delegates to #to_hash and returns string" do
           assert_json "{\"name\":\"Rise Against\"}", @Band.new("Rise Against").to_json
         end
       end
 
-
       describe "#to_hash" do
         it "returns unwrapped hash" do
           hash = @Band.new("Rise Against").to_hash
@@ -116,12 +111,12 @@ end
         end
 
         it "returns CollectionBinding" do
-          assert_kind_of Representable::Hash::Binding::Collection, Representable::Hash::Binding.build_for(Def.new(:band, :collection => true))
+          assert_kind_of Representable::Hash::Binding::Collection,
+                         Representable::Hash::Binding.build_for(Def.new(:band, :collection => true))
         end
       end
     end
 
-
     describe "DCI" do
       module SongRepresenter
         include Representable::JSON
@@ -134,7 +129,6 @@ end
         collection :songs, :class => Song, :extend => SongRepresenter
       end
 
-
       it "allows adding the representer by using #extend" do
         module BandRepresenter
           include Representable::JSON
@@ -144,6 +138,7 @@ end
         civ = Object.new
         civ.instance_eval do
           def name; "CIV"; end
+
           def name=(v)
             @name = v
           end
@@ -154,14 +149,15 @@ end
       end
 
       it "extends contained models when serializing" do
-        @album = Album.new([Song.new("I Hate My Brain"), mr=Song.new("Mr. Charisma")], mr)
+        @album = Album.new([Song.new("I Hate My Brain"), mr = Song.new("Mr. Charisma")], mr)
         @album.extend(AlbumRepresenter)
 
-        assert_json "{\"best_song\":{\"name\":\"Mr. Charisma\"},\"songs\":[{\"name\":\"I Hate My Brain\"},{\"name\":\"Mr. Charisma\"}]}", @album.to_json
+        assert_json "{\"best_song\":{\"name\":\"Mr. Charisma\"},\"songs\":[{\"name\":\"I Hate My Brain\"},{\"name\":\"Mr. Charisma\"}]}",
+                    @album.to_json
       end
 
       it "extends contained models when deserializing" do
-        #@album = Album.new(Song.new("I Hate My Brain"), Song.new("Mr. Charisma"))
+        # @album = Album.new(Song.new("I Hate My Brain"), Song.new("Mr. Charisma"))
         @album = Album.new
         @album.extend(AlbumRepresenter)
 
@@ -171,8 +167,7 @@ end
     end
   end
 
-
-  class PropertyTest < MiniTest::Spec
+  class PropertyTest < Minitest::Spec
     describe "property :name" do
       class Band
         include Representable::JSON
@@ -255,7 +250,7 @@ end
     end
   end
 
-  class CollectionTest < MiniTest::Spec
+  class CollectionTest < Minitest::Spec
     describe "collection :name" do
       class CD
         include Representable::JSON
@@ -282,7 +277,7 @@ end
         property :name
         attr_accessor :name
 
-        def initialize(name="")
+        def initialize(name = "")
           self.name = name
         end
       end
@@ -295,9 +290,14 @@ end
 
       describe "#from_json" do
         it "pushes collection items to array" do
-          cd = Compilation.new.from_json({:bands => [
-            {:name => "Cobra Skulls"},
-            {:name => "Diesel Boy"}]}.to_json)
+          cd = Compilation.new.from_json(
+            {
+              :bands => [
+                {:name => "Cobra Skulls"},
+                {:name => "Diesel Boy"}
+              ]
+            }.to_json
+          )
           assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
         end
       end
@@ -310,7 +310,6 @@ end
       end
     end
 
-
     describe ":as => :songList" do
       class Songs
         include Representable::JSON
@@ -332,7 +331,7 @@ end
     end
   end
 
-  class HashTest < MiniTest::Spec
+  class HashTest < Minitest::Spec
     describe "hash :songs" do
       representer!(:module => Representable::JSON) do
         hash :songs
@@ -346,7 +345,10 @@ end
       end
 
       it "parses with #from_json" do
-        assert_equal({"one" => "65", "two" => ["Emo Boy"]}, subject.from_json("{\"songs\":{\"one\":\"65\",\"two\":[\"Emo Boy\"]}}").songs)
+        assert_equal(
+          {"one" => "65", "two" => ["Emo Boy"]},
+          subject.from_json("{\"songs\":{\"one\":\"65\",\"two\":[\"Emo Boy\"]}}").songs
+        )
       end
     end
 

data/test/lonely_test.rb

@@ -1,16 +1,17 @@
-require 'test_helper'
+require "test_helper"
 
-require 'representable/json/hash'
-
-class LonelyRepresenterTest < MiniTest::Spec
+require "representable/json/hash"
 
+class LonelyRepresenterTest < Minitest::Spec
   # test ::items without arguments, render-only.
   for_formats(
     :hash => [Representable::Hash::Collection, [{"name"=>"Resist Stance"}, {"name"=>"Suffer"}]],
     :json => [Representable::JSON::Collection, "[{\"name\":\"Resist Stance\"},{\"name\":\"Suffer\"}]"],
-    :xml  => [Representable::XML::Collection, "<array><song><name>Resist Stance</name></song><song><name>Suffer</name></song></array>"],
-  ) do |format, mod, output, input|
-
+    :xml  => [
+      Representable::XML::Collection,
+      "<array><song><name>Resist Stance</name></song><song><name>Suffer</name></song></array>"
+    ]
+  ) do |format, mod, output, _input|
     describe "[#{format}] lonely collection, render-only" do # TODO: introduce :representable option?
       let(:format) { format }
 
@@ -28,8 +29,6 @@ class LonelyRepresenterTest < MiniTest::Spec
     end
   end
 
-
-
   module SongRepresenter
     include Representable::JSON
 
@@ -43,13 +42,12 @@ class LonelyRepresenterTest < MiniTest::Spec
     let(:json)  { "[{\"name\":\"Days Go By\"},{\"name\":\"Can't Take Them All\"}]" }
 
     describe "with contained objects" do
-      let(:representer) {
+      let(:representer) do
         Module.new do
           include Representable::JSON::Collection
           items :class => Song, :extend => SongRepresenter
         end
-      }
-
+      end
 
       it "renders array" do
         assert_json json, songs.extend(representer).to_json
@@ -80,11 +78,11 @@ class LonelyRepresenterTest < MiniTest::Spec
     end
 
     describe "with contained text" do
-      let(:representer) {
+      let(:representer) do
         Module.new do
           include Representable::JSON::Collection
         end
-      }
+      end
       let(:songs) { ["Days Go By", "Can't Take Them All"] }
       let(:json)  { "[\"Days Go By\",\"Can't Take Them All\"]" }
 
@@ -111,19 +109,17 @@ class LonelyRepresenterTest < MiniTest::Spec
       items extend: ->(options) { options[:input] == 1 ? options[:user_options][:one] : options[:user_options][:two] }
     end
 
-
-    it { _([1,2].extend(representer).to_hash(user_options: {one: One, two: Two})).must_equal(["One: 1", "Two: 2"]) }
+    it { _([1, 2].extend(representer).to_hash(user_options: {one: One, two: Two})).must_equal(["One: 1", "Two: 2"]) }
   end
 
-
-  describe "JSON::Hash" do  # TODO: move to HashTest.
+  describe "JSON::Hash" do # TODO: move to HashTest.
     describe "with contained objects" do
-      let(:representer) {
+      let(:representer) do
         Module.new do
           include Representable::JSON::Hash
           values :class => Song, :extend => SongRepresenter
         end
-      }
+      end
       let(:json)  { "{\"one\":{\"name\":\"Days Go By\"},\"two\":{\"name\":\"Can't Take Them All\"}}" }
       let(:songs) { {"one" => Song.new("Days Go By"), "two" => Song.new("Can't Take Them All")} }
 
@@ -137,11 +133,19 @@ class LonelyRepresenterTest < MiniTest::Spec
         end
 
         it "respects :exclude" do
-          assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:exclude => [:one])
+          assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}",
+                      {
+                        :one => Song.new("Days Go By"),
+                        :two => Song.new("Can't Take Them All")
+                      }.extend(representer).to_json(:exclude => [:one])
         end
 
         it "respects :include" do
-          assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}", {:one => Song.new("Days Go By"), :two => Song.new("Can't Take Them All")}.extend(representer).to_json(:include => [:two])
+          assert_json "{\"two\":{\"name\":\"Can't Take Them All\"}}",
+                      {
+                        :one => Song.new("Days Go By"),
+                        :two => Song.new("Can't Take Them All")
+                      }.extend(representer).to_json(:include => [:two])
         end
       end
 
@@ -163,7 +167,6 @@ class LonelyRepresenterTest < MiniTest::Spec
         end
       end
 
-
       describe "with inline representer" do
         representer!(:module => Representable::JSON::Hash) do
           values :class => Song do
@@ -176,14 +179,13 @@ class LonelyRepresenterTest < MiniTest::Spec
       end
     end
 
-
     describe "with scalar" do
-      let(:representer) {
+      let(:representer) do
         Module.new do
           include Representable::JSON::Hash
         end
-      }
-      let(:json)  { %{{"one":1,"two":2}} }
+      end
+      let(:json) { %{{"one":1,"two":2}} }
       let(:data) { {one: 2, two: 3} }
 
       describe "#to_json" do
@@ -203,7 +205,6 @@ class LonelyRepresenterTest < MiniTest::Spec
       end
     end
 
-
     describe "with contained text" do
       before do
         @songs_representer = Module.new do
@@ -212,19 +213,20 @@ class LonelyRepresenterTest < MiniTest::Spec
       end
 
       it "renders contained items #to_json" do
-        assert_json "[\"Days Go By\",\"Can't Take Them All\"]", ["Days Go By", "Can't Take Them All"].extend(@songs_representer).to_json
+        assert_json "[\"Days Go By\",\"Can't Take Them All\"]",
+                    ["Days Go By", "Can't Take Them All"].extend(@songs_representer).to_json
       end
 
       it "returns objects array from #from_json" do
-        assert_equal ["Days Go By", "Can't Take Them All"], [].extend(@songs_representer).from_json("[\"Days Go By\",\"Can't Take Them All\"]")
+        assert_equal ["Days Go By", "Can't Take Them All"],
+                     [].extend(@songs_representer).from_json("[\"Days Go By\",\"Can't Take Them All\"]")
       end
     end
   end
 end
 
-
 # describe "Hash::Collection with :include" do
-class CollectionWithIncludeTest < MiniTest::Spec
+class CollectionWithIncludeTest < Minitest::Spec
   Song = Struct.new(:id, :title)
 
   representer!(decorator: true, module: Representable::Hash::Collection) do
@@ -234,6 +236,6 @@ class CollectionWithIncludeTest < MiniTest::Spec
     end
   end
 
-  it { _(representer.new([Song.new(1, "ACAB")]).to_hash).must_equal([{"id"=>1, "title"=>"ACAB"}]) }
+  it { _(representer.new([Song.new(1, "ACAB")]).to_hash).must_equal([{"id" => 1, "title" => "ACAB"}]) }
   it { _(representer.new([Song.new(1, "ACAB")]).to_hash(include: [:title])).must_equal([{"title"=>"ACAB"}]) }
 end

data/test/nested_test.rb

@@ -1,14 +1,16 @@
-require 'test_helper'
+require "test_helper"
 
-class NestedTest < MiniTest::Spec
-	Album = Struct.new(:label, :owner, :amount)
+class NestedTest < Minitest::Spec
+  Album = Struct.new(:label, :owner, :amount)
 
-	for_formats(
-    :hash => [Representable::Hash, {"label" => {"label"=>"Epitaph", "owner"=>"Brett Gurewitz", "releases"=>{"amount"=>19}}}],
+  for_formats(
+    :hash => [
+      Representable::Hash,
+      {"label" => {"label" => "Epitaph", "owner" => "Brett Gurewitz", "releases" => {"amount"=>19}}}
+    ],
     # :xml  => [Representable::XML, "<open_struct></open_struct>"],
     :yaml => [Representable::YAML, "---\nlabel:\n  label: Epitaph\n  owner: Brett Gurewitz\n  releases:\n    amount: 19\n"]
-  ) do |format, mod, output, input|
-
+  ) do |format, mod, output, _input|
     [false, true].each do |is_decorator|
       describe "::nested with (inline representer|decorator): #{is_decorator}" do
         let(:format) { format }
@@ -34,9 +36,7 @@ class NestedTest < MiniTest::Spec
           render(decorator).must_equal_document output
 
           # do not use extend on the nested object. # FIXME: make this a proper test with two describes instead of this pseudo-meta stuff.
-          if is_decorator==true
-            _(album).wont_be_kind_of(Representable::Hash)
-          end
+          _(album).wont_be_kind_of(Representable::Hash) if is_decorator == true
         end
 
         it "parses nested properties to Album instance" do
@@ -47,13 +47,12 @@ class NestedTest < MiniTest::Spec
       end
     end
 
-
     describe "Decorator ::nested with extend:" do
       let(:format) { format }
 
       representer!(:name => :label_rpr) do
-      	include mod
-      	property :label
+        include mod
+        property :label
         property :owner
 
         nested :releases do # DISCUSS: do we need to test this?
@@ -75,17 +74,15 @@ class NestedTest < MiniTest::Spec
       end
 
       it "parses nested properties to Album instance" do
-      	album = parse(representer.prepare(Album.new), output)
-      	_(album.label).must_equal "Epitaph"
-      	_(album.owner).must_equal "Brett Gurewitz"
+        album = parse(representer.prepare(Album.new), output)
+        _(album.label).must_equal "Epitaph"
+        _(album.owner).must_equal "Brett Gurewitz"
         _(album.amount).must_equal 19
       end
     end
   end
 
-
   describe "::nested without block but with inherit:" do
-
     representer!(:name => :parent) do
       include Representable::Hash
 
@@ -112,4 +109,4 @@ class NestedTest < MiniTest::Spec
     #   album.amount.must_equal 19
     # end
   end
-end
+end

data/test/object_test.rb

@@ -1,17 +1,17 @@
 require "test_helper"
 require "representable/object"
 
-class ObjectTest < MiniTest::Spec
+class ObjectTest < Minitest::Spec
   Song  = Struct.new(:title, :album)
   Album = Struct.new(:name, :songs)
 
   representer!(module: Representable::Object) do
     property :title
 
-    property :album, instance: lambda { |options| options[:fragment].name.upcase!; options[:fragment] } do
+    property :album, instance: ->(options) { options[:fragment].name.upcase!; options[:fragment] } do
       property :name
 
-      collection :songs, instance: lambda { |options| options[:fragment].title.upcase!; options[:fragment] } do
+      collection :songs, instance: ->(options) { options[:fragment].title.upcase!; options[:fragment] } do
         property :title
       end
     end
@@ -42,10 +42,10 @@ class ObjectTest < MiniTest::Spec
     representer!(module: Representable::Object) do
       property :title
 
-      property :album, render_filter: lambda { |input, options|input.name = "Live";input } do
+      property :album, render_filter: ->(input, _options) { input.name = "Live"; input } do
         property :name
 
-        collection :songs, render_filter: lambda { |input, options|input[0].title = 1;input } do
+        collection :songs, render_filter: ->(input, _options) { input[0].title = 1; input } do
           property :title
         end
       end
@@ -57,4 +57,4 @@ class ObjectTest < MiniTest::Spec
       _(source.album.songs[0].title).must_equal 1
     end
   end
-end
+end

data/test/option_test.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
-class OptionTest < MiniTest::Spec
+class OptionTest < Minitest::Spec
   class Callable
     include Uber::Callable
     def call(*); "callable" end
@@ -25,12 +25,14 @@ class OptionTest < MiniTest::Spec
 
   describe ::Representable::Option do
     it "supports all types of callables (method, proc, static etc)" do
-      _(album_representer.to_hash).must_equal({
-        "static"    => "static",
-        "symbol"    => "symbol",
-        "proc"      => "proc",
-        "callable"  => "callable",
-      })
+      _(album_representer.to_hash).must_equal(
+        {
+          "static"   => "static",
+          "symbol"   => "symbol",
+          "proc"     => "proc",
+          "callable" => "callable"
+        }
+      )
     end
   end
 end

data/test/parse_pipeline_test.rb

@@ -1,6 +1,6 @@
 require "test_helper"
 
-class ParsePipelineTest < MiniTest::Spec
+class ParsePipelineTest < Minitest::Spec
   Album  = Struct.new(:id, :artist, :songs)
   Artist = Struct.new(:email)
   Song   = Struct.new(:title)
@@ -8,14 +8,14 @@ class ParsePipelineTest < MiniTest::Spec
   describe "transforming nil to [] when parsing" do
     representer!(decorator: true) do
       collection :songs,
-          parse_pipeline: ->(*) {
-            Representable::Pipeline.insert(
-              parse_functions,                                # original function list from Binding#parse_functions.
-              ->(input, options) { input.nil? ? [] : input }, # your new function (can be any callable object)..
-              replace: Representable::OverwriteOnNil          # ..that replaces the original function.
-            )
-          },
-          class: Song do
+                 parse_pipeline: ->(*) {
+                   Representable::Pipeline.insert(
+                     parse_functions,                                # original function list from Binding#parse_functions.
+                     ->(input, _options) { input.nil? ? [] : input }, # your new function (can be any callable object)..
+                     replace: Representable::OverwriteOnNil # ..that replaces the original function.
+                   )
+                 },
+                 class:          Song do
         property :title
       end
     end
@@ -31,7 +31,6 @@ class ParsePipelineTest < MiniTest::Spec
     end
   end
 
-
   # tests [Collect[Instance, Prepare, Deserialize], Setter]
   class Representer < Representable::Decorator
     include Representable::Hash
@@ -40,23 +39,30 @@ class ParsePipelineTest < MiniTest::Spec
     #   property :email
     # end
     # DISCUSS: rename to populator_pipeline ?
-    collection :songs, parse_pipeline: ->(*) { [Collect[Instance, Prepare, Deserialize], Setter] }, instance: :instance!, exec_context: :decorator, pass_options: true do
+    collection :songs, parse_pipeline: ->(*) {
+                                         [Collect[Instance, Prepare, Deserialize], Setter]
+                                       }, instance: :instance!, exec_context: :decorator, pass_options: true do
       property :title
     end
 
-    def instance!(*options)
+    def instance!(*_options)
       Song.new
     end
 
     def songs=(array)
-      represented.songs=array
+      represented.songs = array
     end
   end
 
   it do
     skip "TODO: implement :parse_pipeline and :render_pipeline, and before/after/replace semantics"
     album = Album.new
-    Representer.new(album).from_hash({"artist"=>{"email"=>"yo"}, "songs"=>[{"title"=>"Affliction"}, {"title"=>"Dream Beater"}]})
+    Representer.new(album).from_hash(
+      {
+        "artist" => {"email"=>"yo"},
+        "songs"  => [{"title"=>"Affliction"}, {"title"=>"Dream Beater"}]
+      }
+    )
     _(album.songs).must_equal([Song.new("Affliction"), Song.new("Dream Beater")])
   end
-end
+end