representable 3.2.0 → 3.3.0

data/test/inherit_test.rb

@@ -1,7 +1,8 @@
-require 'test_helper'
+require "test_helper"
 
-class InheritTest < MiniTest::Spec
-  module SongRepresenter # it's important to have a global module so we can test if stuff gets overridden in the original module.
+class InheritTest < Minitest::Spec
+  # it's important to have a global module so we can test if stuff gets overridden in the original module.
+  module SongRepresenter
     include Representable::Hash
     property :name, :as => :title do
       property :string, :as => :str
@@ -16,11 +17,11 @@ class InheritTest < MiniTest::Spec
     representer! do
       include SongRepresenter
 
-      property :track, :inherit => true, :getter => lambda { |*| "n/a" }
+      property :track, :inherit => true, :getter => ->(*) { "n/a" }
     end
 
-    it { _(SongRepresenter.prepare(song).to_hash).must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>1}) }
-    it { _(representer.prepare(song).to_hash).must_equal({"title"=>{"str"=>"Roxanne"}, "no"=>"n/a"}) } # as: inherited.
+    it { _(SongRepresenter.prepare(song).to_hash).must_equal({"title" => {"str"=>"Roxanne"}, "no" => 1}) }
+    it { _(representer.prepare(song).to_hash).must_equal({"title" => {"str"=>"Roxanne"}, "no" => "n/a"}) } # as: inherited.
   end
 
   describe ":inherit with empty inline representer" do
@@ -32,9 +33,27 @@ class InheritTest < MiniTest::Spec
       end
     end
 
-    it { _(SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it {
+      _(
+        SongRepresenter.prepare(
+          Song.new(
+            Struct.new(:string).new("Believe It"),
+            1
+          )
+        ).to_hash
+      ).must_equal({"title" => {"str"=>"Believe It"}, "no" => 1})
+    }
     # the block doesn't override the inline representer.
-    it { _(representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it {
+      _(
+        representer.prepare(
+          Song.new(
+            Struct.new(:string).new("Believe It"),
+            1
+          )
+        ).to_hash
+      ).must_equal({"title" => {"str"=>"Believe It"}, "no" => 1})
+    }
   end
 
   describe ":inherit with overriding inline representer" do
@@ -48,7 +67,16 @@ class InheritTest < MiniTest::Spec
       end
     end
 
-    it { _(representer.prepare( Song.new(Struct.new(:string, :length).new("Believe It", 10), 1)).to_hash).must_equal({"title"=>{"s"=>"Believe It","length"=>10}, "no"=>1}) }
+    it {
+      _(
+        representer.prepare(
+          Song.new(
+            Struct.new(:string, :length).new("Believe It", 10),
+            1
+          )
+        ).to_hash
+      ).must_equal({"title" => {"s" => "Believe It", "length" => 10}, "no" => 1})
+    }
   end
 
   describe ":inherit with empty inline and options" do
@@ -60,8 +88,26 @@ class InheritTest < MiniTest::Spec
       end
     end
 
-    it { _(SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
-    it { _(representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it {
+      _(
+        SongRepresenter.prepare(
+          Song.new(
+            Struct.new(:string).new("Believe It"),
+            1
+          )
+        ).to_hash
+      ).must_equal({"title" => {"str"=>"Believe It"}, "no" => 1})
+    }
+    it {
+      _(
+        representer.prepare(
+          Song.new(
+            Struct.new(:string).new("Believe It"),
+            1
+          )
+        ).to_hash
+      ).must_equal({"name" => {"str"=>"Believe It"}, "no" => 1})
+    }
   end
 
   describe ":inherit with inline without block but options" do
@@ -71,12 +117,28 @@ class InheritTest < MiniTest::Spec
       property :name, :inherit => true, :as => :name # FIXME: add :getter or something else dynamic since this is double-wrapped.
     end
 
-    it { _(SongRepresenter.prepare(Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"title"=>{"str"=>"Believe It"}, "no"=>1}) }
-    it { _(representer.prepare( Song.new(Struct.new(:string).new("Believe It"), 1)).to_hash).must_equal({"name"=>{"str"=>"Believe It"}, "no"=>1}) }
+    it {
+      _(
+        SongRepresenter.prepare(
+          Song.new(
+            Struct.new(:string).new("Believe It"),
+            1
+          )
+        ).to_hash
+      ).must_equal({"title" => {"str"=>"Believe It"}, "no" => 1})
+    }
+    it {
+      _(
+        representer.prepare(
+          Song.new(
+            Struct.new(:string).new("Believe It"),
+            1
+          )
+        ).to_hash
+      ).must_equal({"name" => {"str"=>"Believe It"}, "no" => 1})
+    }
   end
 
-
-
   # no :inherit
   describe "overwriting without :inherit" do
     representer! do
@@ -90,12 +152,11 @@ class InheritTest < MiniTest::Spec
 
       definition = representer.representable_attrs.get(:track) # TODO: find a better way to assert Definition identity.
       # definition.keys.size.must_equal 2
-      _(definition[:representable]).   must_equal true
+      _(definition[:representable]).must_equal true
       _(definition.name).must_equal "track" # was "no".
     end
   end
 
-
   # decorator
   describe ":inherit with decorator" do
     representer!(:decorator => true) do
@@ -108,7 +169,7 @@ class InheritTest < MiniTest::Spec
       end
     end
 
-    let(:inheriting) {
+    let(:inheriting) do
       class InheritingDecorator < representer
         include Representable::Debug
         property :hit, :inherit => true do
@@ -117,30 +178,56 @@ class InheritTest < MiniTest::Spec
         end
         self
       end
-    }
+    end
 
-    it { _(representer.new(OpenStruct.new(hit: OpenStruct.new(title: "I WILL BE OVERRIDDEN", :length => "2:59"))).to_hash).must_equal(
-      {"hit"=>{"title"=>"Cheap Transistor Radio"}}) }
+    it {
+      _(
+        representer.new(
+          OpenStruct.new(
+            hit: OpenStruct.new(
+              title: "I WILL BE OVERRIDDEN",
+              :length => "2:59"
+            )
+          )
+        ).to_hash
+      ).must_equal(
+        {"hit"=>{"title"=>"Cheap Transistor Radio"}}
+      )
+    }
 
     # inheriting decorator inherits inline representer class (InlineRepresenter#title).
     # inheriting decorator adds :length.
-    it { _(inheriting.new(OpenStruct.new(:hit => OpenStruct.new(:title => "Hole In Your Soul", :length => "2:59"))).to_hash).must_equal(
-      {"hit"=>{"title"=>"Cheap Transistor Radio", "length"=>"2:59"}}) }
+    it {
+      _(
+        inheriting.new(
+          OpenStruct.new(
+            :hit => OpenStruct.new(
+              :title  => "Hole In Your Soul",
+              :length => "2:59"
+            )
+          )
+        ).to_hash
+      ).must_equal(
+        {
+          "hit" => {
+            "title" => "Cheap Transistor Radio", "length" => "2:59"
+          }
+        }
+      )
+    }
   end
 
-
   # :inherit when property doesn't exist, yet.
   describe ":inherit without inheritable property" do
     representer! do
       property :name, :inherit => true
     end
 
-    it { _(representer.prepare(Song.new("The Beginning")).to_hash).must_equal({"name"=>"The Beginning"})}
+    it { _(representer.prepare(Song.new("The Beginning")).to_hash).must_equal({"name"=>"The Beginning"}) }
   end
 end
 
-
-# class InheritancingTest < MiniTest::Spec
+# class InheritancingTest < Minitest::Spec
 #   class SongDecorator < Representable::Decorator
 #     include Representable::Hash
 #     property :album do

data/test/inline_test.rb

@@ -1,14 +1,17 @@
-require 'test_helper'
+require "test_helper"
 
-class InlineTest < MiniTest::Spec
+class InlineTest < Minitest::Spec
   let(:song)    { Song.new("Alive") }
   let(:request) { representer.prepare(OpenStruct.new(:song => song)) }
 
   {
     :hash => [Representable::Hash, {"song"=>{"name"=>"Alive"}}, {"song"=>{"name"=>"You've Taken Everything"}}],
     :json => [Representable::JSON, "{\"song\":{\"name\":\"Alive\"}}", "{\"song\":{\"name\":\"You've Taken Everything\"}}"],
-    :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"],
+    :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"]
   }.each do |format, cfg|
     mod, output, input = cfg
 
@@ -22,15 +25,18 @@ class InlineTest < MiniTest::Spec
       let(:format) { format }
 
       it { render(request).must_equal_document output }
-      it { _(parse(request, input).song.name).must_equal "You've Taken Everything"}
+      it { _(parse(request, input).song.name).must_equal "You've Taken Everything" }
     end
   end
 
   {
     :hash => [Representable::Hash, {"songs"=>[{"name"=>"Alive"}]}, {"songs"=>[{"name"=>"You've Taken Everything"}]}],
     :json => [Representable::JSON, "{\"songs\":[{\"name\":\"Alive\"}]}", "{\"songs\":[{\"name\":\"You've Taken Everything\"}]}"],
-    :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>", { :as => :song }],
-    :yaml => [Representable::YAML, "---\nsongs:\n- name: Alive\n", "---\nsongs:\n- name: You've Taken Everything\n"],
+    :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>", {:as => :song}
+    ],
+    :yaml => [Representable::YAML, "---\nsongs:\n- name: Alive\n", "---\nsongs:\n- name: You've Taken Everything\n"]
   }.each do |format, cfg|
     mod, output, input, collection_options = cfg
     collection_options ||= {}
@@ -47,7 +53,7 @@ class InlineTest < MiniTest::Spec
       let(:format) { format } # FIXME: why do we have to define this?
 
       it { render(request).must_equal_document output }
-      it { _(parse(request, input).songs.first.name).must_equal "You've Taken Everything"}
+      it { _(parse(request, input).songs.first.name).must_equal "You've Taken Everything" }
     end
   end
 
@@ -61,13 +67,11 @@ class InlineTest < MiniTest::Spec
     it { _(request.to_hash).must_equal({"song"=>{"name"=>"Alive"}}) }
   end
 
-
   for_formats(
-    :hash => [Representable::Hash, {}],
+    :hash => [Representable::Hash, {}]
     # :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|
-
     describe "parsing [#{format}] where nested property missing" do
       representer!(:module => mod) do
         property :song do
@@ -81,7 +85,6 @@ class InlineTest < MiniTest::Spec
     end
   end
 
-
   describe "inheriting from outer representer" do
     let(:request) { Struct.new(:song, :requester).new(song, "Josephine") }
 
@@ -96,8 +99,8 @@ class InlineTest < MiniTest::Spec
 
       let(:decorator) { representer.prepare(request) }
 
-      it { _(decorator.to_hash).must_equal({"requester"=>"Josephine", "song"=>{"name"=>"Alive"}}) }
-      it { _(decorator.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name).must_equal "You've Taken Everything"}
+      it { _(decorator.to_hash).must_equal({"requester" => "Josephine", "song" => {"name"=>"Alive"}}) }
+      it { _(decorator.from_hash({"song"=>{"name"=>"You've Taken Everything"}}).song.name).must_equal "You've Taken Everything" }
     end
   end
 
@@ -144,13 +147,13 @@ class InlineTest < MiniTest::Spec
   #   end
   # end
 
-
-  for_formats({
-      :hash => [Representable::Hash, {"album" => {"artist" => {"label"=>"Epitaph"}}}],
+  for_formats(
+    {
+      :hash => [Representable::Hash, {"album" => {"artist" => {"label"=>"Epitaph"}}}]
       # :xml  => [Representable::XML, "<open_struct></open_struct>"],
-      #:yaml => [Representable::YAML, "---\nlabel:\n  label: Epitaph\n  owner: Brett Gurewitz\n"]
-    }) do |format, mod, output, input|
-
+      # :yaml => [Representable::YAML, "---\nlabel:\n  label: Epitaph\n  owner: Brett Gurewitz\n"]
+    }
+  ) do |format, mod, output, _input|
     class ArtistDecorator < Representable::Decorator
       include Representable::JSON
       property :label
@@ -162,7 +165,7 @@ class InlineTest < MiniTest::Spec
       representer!(:module => mod) do
         self.representation_wrap = "album"
 
-        property :artist, :getter => lambda { |args| represented }, :decorator => ArtistDecorator
+        property :artist, :getter => ->(_args) { represented }, :decorator => ArtistDecorator
       end
 
       let(:album) { OpenStruct.new(:label => "Epitaph").extend(representer) }
@@ -173,14 +176,14 @@ class InlineTest < MiniTest::Spec
     end
   end
 
-
   # test helper methods within inline representer
-  for_formats({
-    :hash => [Representable::Hash, {"song"=>{"name"=>"ALIVE"}}],
-    :xml  => [Representable::XML, "<request>\n  <song>\n    <name>ALIVE</name>\n  </song>\n</request>"],
-    :yaml => [Representable::YAML, "---\nsong:\n  name: ALIVE\n"],
-  }) do |format, mod, output|
-
+  for_formats(
+    {
+      :hash => [Representable::Hash, {"song"=>{"name"=>"ALIVE"}}],
+      :xml  => [Representable::XML, "<request>\n  <song>\n    <name>ALIVE</name>\n  </song>\n</request>"],
+      :yaml => [Representable::YAML, "---\nsong:\n  name: ALIVE\n"]
+    }
+  ) do |format, mod, output|
     describe "helper method within inline representer [#{format}]" do
       let(:format) { format }
 
@@ -207,7 +210,6 @@ class InlineTest < MiniTest::Spec
     end
   end
 
-
   describe "include module in inline representers" do
     representer! do
       extension = Module.new do
@@ -221,13 +223,20 @@ class InlineTest < MiniTest::Spec
       end
     end
 
-    it do _(OpenStruct.new(:song => OpenStruct.new(:title => "The Fever And The Sound", :artist => "Strung Out")).extend(representer).
-      to_hash).
-      must_equal({"song"=>{"artist"=>"Strung Out", "title"=>"The Fever And The Sound"}})
+    it do
+      _(
+        OpenStruct.new(
+          :song => OpenStruct.new(
+            :title  => "The Fever And The Sound",
+            :artist => "Strung Out"
+          )
+        ).extend(representer)
+              .to_hash
+      )
+        .must_equal({"song"=>{"artist" => "Strung Out", "title" => "The Fever And The Sound"}})
     end
   end
 
-
   # define method in inline representer
   describe "define method in inline representer" do
     Mod = Module.new do