representable 3.2.0 → 3.3.0

data/test/instance_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class InstanceTest < BaseTest
   Song = Struct.new(:id, :title)
@@ -10,13 +10,13 @@ class InstanceTest < BaseTest
 
   describe "lambda { fragment } (new way of class: lambda { nil })" do
     representer! do
-      property :title, :instance  => lambda { |options| options[:fragment] }
+      property :title, :instance => ->(options) { options[:fragment] }
     end
 
     it "skips creating new instance" do
       object = Object.new
       object.instance_eval do
-        def from_hash(hash, *args)
+        def from_hash(hash, *_args)
           hash
         end
       end
@@ -26,53 +26,71 @@ class InstanceTest < BaseTest
     end
   end
 
-
-# TODO: use *args in from_hash.
-# DISCUSS: do we need parse_strategy?
+  # TODO: use *args in from_hash.
+  # DISCUSS: do we need parse_strategy?
   describe "property with :instance" do
     representer!(:inject => :song_representer) do
       property :song,
-        :instance => lambda { |options| options[:fragment]["id"] == song.id ? song : Song.find(options[:fragment]["id"]) },
-        :extend => song_representer
+               :instance => ->(options) { options[:fragment]["id"] == song.id ? song : Song.find(options[:fragment]["id"]) },
+               :extend   => song_representer
     end
 
-    it( "xxx") { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash("song" => {"id" => 1}).song).must_equal Song.new(1, "The Answer Is Still No") }
+    it("xxx") {
+      _(
+        OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer)
+          .from_hash("song" => {"id" => 1}).song
+      ).must_equal Song.new(1, "The Answer Is Still No")
+    }
 
-    it { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash("song" => {"id" => 2}).song).must_equal Song.new(2, "Invincible") }
+    it {
+      _(
+        OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer)
+          .from_hash("song" => {"id" => 2}).song
+      ).must_equal Song.new(2, "Invincible")
+    }
   end
 
-
   describe "collection with :instance" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |options|
-          options[:fragment]["id"] == songs[options[:index]].id ? songs[options[:index]] : Song.find(options[:fragment]["id"])
-        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+                 :instance => ->(options) {
+                   options[:fragment]["id"] == songs[options[:index]].id ? songs[options[:index]] : Song.find(options[:fragment]["id"])
+                 }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
 
-        :extend => song_representer
+                 :extend   => song_representer
     end
 
     it {
-      album= Struct.new(:songs).new([
-      Song.new(1, "The Answer Is Still No"),
-      Song.new(2, "")])
-
-      _(album.
-        extend(representer).
-        from_hash("songs" => [{"id" => 2},{"id" => 2, "title"=>"The Answer Is Still No"}]).songs).must_equal [
-          Song.new(2, "Invincible"), Song.new(2, "The Answer Is Still No")]
+      album = Struct.new(:songs).new(
+        [
+          Song.new(1, "The Answer Is Still No"),
+          Song.new(2, "")
+        ]
+      )
+
+      _(
+        album
+                .extend(representer)
+                .from_hash("songs" => [{"id" => 2}, {"id" => 2, "title" => "The Answer Is Still No"}]).songs
+      ).must_equal [
+        Song.new(2, "Invincible"), Song.new(2, "The Answer Is Still No")
+      ]
     }
   end
 
   describe "property with lambda receiving fragment and args" do
     representer!(:inject => :song_representer) do
-      property :song, :instance => lambda { |options| Struct.new(:args, :id).new([options[:fragment], options[:user_options]]) }, :extend => song_representer
+      property :song, :instance => ->(options) {
+                                     Struct.new(:args, :id).new([options[:fragment], options[:user_options]])
+                                   }, :extend => song_representer
     end
 
-    it { _(OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer).
-      from_hash({"song" => {"id" => 1}}, user_options: { volume: 1 }).song.args).must_equal([{"id"=>1}, {:volume=>1}]) }
+    it {
+      _(
+        OpenStruct.new(:song => Song.new(1, "The Answer Is Still No")).extend(representer)
+          .from_hash({"song" => {"id" => 1}}, user_options: {volume: 1}).song.args
+      ).must_equal([{"id"=>1}, {:volume=>1}])
+    }
   end
 
   # TODO: raise and test instance:{nil}
@@ -100,26 +118,30 @@ class InstanceTest < BaseTest
   describe "sync" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |options|
-          songs[options[:index]]
-        },
-        :extend => song_representer,
-        # :parse_strategy => :sync
-        :setter => lambda { |*|  }
+                 :instance => ->(options) {
+                   songs[options[:index]]
+                 },
+                 :extend   => song_representer,
+                 # :parse_strategy => :sync
+                 :setter   => ->(*) {}
     end
 
     it {
-      album= Struct.new(:songs).new(songs = [
-      Song.new(1, "The Answer Is Still No"),
-      Song.new(2, "Invncble")])
+      album = Struct.new(:songs).new(
+        songs = [
+          Song.new(1, "The Answer Is Still No"),
+          Song.new(2, "Invncble")
+        ]
+      )
 
-      album.
-        extend(representer).
-        from_hash("songs" => [{"title" => "The Answer Is Still No"}, {"title" => "Invincible"}])
+      album
+        .extend(representer)
+        .from_hash("songs" => [{"title" => "The Answer Is Still No"}, {"title" => "Invincible"}])
 
       _(album.songs).must_equal [
         Song.new(1, "The Answer Is Still No"),
-        Song.new(2, "Invincible")]
+        Song.new(2, "Invincible")
+      ]
 
       _(songs.object_id).must_equal album.songs.object_id
       _(songs[0].object_id).must_equal album.songs[0].object_id
@@ -130,29 +152,34 @@ class InstanceTest < BaseTest
   describe "update existing elements, only" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |options|
-
-          #fragment["id"] == songs[i].id ? songs[i] : Song.find(fragment["id"])
-          songs.find { |s| s.id == options[:fragment]["id"] }
-        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
-
-        :extend => song_representer,
-        # :parse_strategy => :sync
-        :setter => lambda { |*|  }
+                 :instance => ->(options) {
+                   # fragment["id"] == songs[i].id ? songs[i] : Song.find(fragment["id"])
+                   songs.find { |s| s.id == options[:fragment]["id"] }
+                 }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+
+                 :extend   => song_representer,
+                 # :parse_strategy => :sync
+                 :setter   => ->(*) {}
     end
 
     it("hooray") {
-      album= Struct.new(:songs).new(songs = [
-      Song.new(1, "The Answer Is Still No"),
-      Song.new(2, "Invncble")])
-
-      _(album.
-        extend(representer).
-        from_hash("songs" => [{"id" => 2, "title" => "Invincible"}]).
-        songs).must_equal [
+      album = Struct.new(:songs).new(
+        songs = [
           Song.new(1, "The Answer Is Still No"),
-          Song.new(2, "Invincible")]
-          # TODO: check elements object_id!
+          Song.new(2, "Invncble")
+        ]
+      )
+
+      _(
+        album
+                .extend(representer)
+                .from_hash("songs" => [{"id" => 2, "title" => "Invincible"}])
+                .songs
+      ).must_equal [
+        Song.new(1, "The Answer Is Still No"),
+        Song.new(2, "Invincible")
+      ]
+      # TODO: check elements object_id!
 
       _(songs.object_id).must_equal album.songs.object_id
       _(songs[0].object_id).must_equal album.songs[0].object_id
@@ -160,88 +187,103 @@ class InstanceTest < BaseTest
     }
   end
 
-
   describe "add incoming elements, only" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |options|
-          songs << song=Song.new(2)
-          song
-        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
-
-        :extend => song_representer,
-        # :parse_strategy => :sync
-        :setter => lambda { |*|  }
+                 :instance => ->(_options) {
+                   songs << song = Song.new(2)
+                   song
+                 }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+
+                 :extend   => song_representer,
+                 # :parse_strategy => :sync
+                 :setter   => ->(*) {}
     end
 
     it {
-      album= Struct.new(:songs).new(songs = [
-        Song.new(1, "The Answer Is Still No")])
-
-      _(album.
-        extend(representer).
-        from_hash("songs" => [{"title" => "Invincible"}]).
-        songs).must_equal [
-          Song.new(1, "The Answer Is Still No"),
-          Song.new(2, "Invincible")]
+      album = Struct.new(:songs).new(
+        songs = [
+          Song.new(1, "The Answer Is Still No")
+        ]
+      )
+
+      _(
+        album
+                .extend(representer)
+                .from_hash("songs" => [{"title" => "Invincible"}])
+                .songs
+      ).must_equal [
+        Song.new(1, "The Answer Is Still No"),
+        Song.new(2, "Invincible")
+      ]
 
       _(songs.object_id).must_equal album.songs.object_id
       _(songs[0].object_id).must_equal album.songs[0].object_id
     }
   end
 
-
   # not sure if this must be a library strategy
   describe "replace existing element" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |options|
-          id = options[:fragment].delete("replace_id")
-          replaced = songs.find { |s| s.id == id }
-          songs[songs.index(replaced)] = song=Song.new(3)
-          song
-        }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
-
-        :extend => song_representer,
-        # :parse_strategy => :sync
-        :setter => lambda { |*|  }
+                 :instance => ->(options) {
+                   id = options[:fragment].delete("replace_id")
+                   replaced = songs.find { |s| s.id == id }
+                   songs[songs.index(replaced)] = song = Song.new(3)
+                   song
+                 }, # let's not allow returning nil anymore. make sure we can still do everything as with nil. also, let's remove parse_strategy: sync.
+
+                 :extend   => song_representer,
+                 # :parse_strategy => :sync
+                 :setter   => ->(*) {}
     end
 
     it {
-      album= Struct.new(:songs).new(songs = [
-        Song.new(1, "The Answer Is Still No"),
-        Song.new(2, "Invincible")])
-
-      _(album.
-        extend(representer).
-        from_hash("songs" => [{"replace_id"=>2, "id" => 3, "title" => "Soulmate"}]).
-        songs).must_equal [
+      album = Struct.new(:songs).new(
+        songs = [
           Song.new(1, "The Answer Is Still No"),
-          Song.new(3, "Soulmate")]
+          Song.new(2, "Invincible")
+        ]
+      )
+
+      _(
+        album
+                .extend(representer)
+                .from_hash("songs" => [{"replace_id" => 2, "id" => 3, "title" => "Soulmate"}])
+                .songs
+      ).must_equal [
+        Song.new(1, "The Answer Is Still No"),
+        Song.new(3, "Soulmate")
+      ]
 
       _(songs.object_id).must_equal album.songs.object_id
       _(songs[0].object_id).must_equal album.songs[0].object_id
     }
   end
 
-
   describe "replace collection" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :extend => song_representer, :class => Song
+                 :extend => song_representer, :class => Song
     end
 
     it {
-      album= Struct.new(:songs).new(songs = [
-        Song.new(1, "The Answer Is Still No")])
-
-      _(album.
-        extend(representer).
-        from_hash("songs" => [{"title" => "Invincible"}]).
-        songs).must_equal [
-          Song.new(nil, "Invincible")]
+      album = Struct.new(:songs).new(
+        songs = [
+          Song.new(1, "The Answer Is Still No")
+        ]
+      )
+
+      _(
+        album
+                .extend(representer)
+                .from_hash("songs" => [{"title" => "Invincible"}])
+                .songs
+      ).must_equal [
+        Song.new(nil, "Invincible")
+      ]
 
       _(songs.object_id).wont_equal album.songs.object_id
     }
   end
-end
+end

data/test/is_representable_test.rb

@@ -1,25 +1,26 @@
-require 'test_helper'
+require "test_helper"
 
 class IsRepresentableTest < BaseTest
   describe "representable: false, extend:" do
     representer!(:inject => :song_representer) do
       property :song,
-        :representable => false,
-        :extend        => song_representer
+               :representable => false,
+               :extend        => song_representer
     end
 
     it "does extend but doesn't call #to_hash" do
-      _(Struct.new(:song).new(song = Object.new).extend(representer).
-        to_hash).must_equal("song" => song)
+      _(
+        Struct.new(:song).new(song = Object.new).extend(representer)
+                .to_hash
+      ).must_equal("song" => song)
       _(song).must_be_kind_of Representable::Hash
     end
   end
 
-
   describe "representable: true, no extend:" do
     representer!(:inject => :song_representer) do
       property :song,
-        :representable => true
+               :representable => true
     end
 
     it "doesn't extend but calls #to_hash" do
@@ -30,8 +31,10 @@ class IsRepresentableTest < BaseTest
         end
       end
 
-      _(Struct.new(:song).new(song).extend(representer).
-        to_hash).must_equal("song" => 1)
+      _(
+        Struct.new(:song).new(song).extend(representer)
+                .to_hash
+      ).must_equal("song" => 1)
       _(song).wont_be_kind_of Representable::Hash
     end
   end
@@ -41,19 +44,18 @@ class IsRepresentableTest < BaseTest
   describe "representable: false, with class:" do
     representer!(:inject => :song_representer) do
       property :song,
-        :representable => false, :class => OpenStruct, :extend => song_representer
+               :representable => false, :class => OpenStruct, :extend => song_representer
     end
 
     it "does extend but doesn't call #from_hash" do
-      hit = Struct.new(:song).new.extend(representer).
-        from_hash("song" => 1)
+      hit = Struct.new(:song).new.extend(representer)
+                  .from_hash("song" => 1)
 
       _(hit.song).must_equal OpenStruct.new
       _(hit.song).must_be_kind_of Representable::Hash
     end
   end
 
-
   describe "representable: true, without extend: but class:" do
     SongReader = Class.new do
       def from_hash(*)
@@ -63,15 +65,15 @@ class IsRepresentableTest < BaseTest
 
     representer!(:inject => :song_representer) do
       property :song,
-        :representable => true, :class => SongReader
+               :representable => true, :class => SongReader
     end
 
     it "doesn't extend but calls #from_hash" do
-      hit = Struct.new(:song).new.extend(representer).
-        from_hash("song" => "Sonata No.2")
+      hit = Struct.new(:song).new.extend(representer)
+                  .from_hash("song" => "Sonata No.2")
 
       _(hit.song).must_equal "Piano?"
       _(hit.song).wont_be_kind_of Representable::Hash
     end
   end
-end
+end