representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/yaml_test.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+
+class YamlTest < MiniTest::Spec
+  def self.yaml_representer(&block)
+    Module.new do
+      include Representable::YAML
+      instance_exec &block
+    end
+  end
+
+  def yaml_representer(&block)
+    self.class.yaml_representer(&block)
+  end
+
+
+  describe "property" do
+    let (:yaml) { yaml_representer do property :best_song end }
+
+    let (:album) { Album.new.tap do |album|
+      album.best_song = "Liar"
+    end }
+
+    describe "#to_yaml" do
+      it "renders plain property" do
+        album.extend(yaml).to_yaml.must_equal(
+"---
+best_song: Liar
+")
+      end
+
+      it "always renders values into strings" do
+        Album.new.tap { |a| a.best_song = 8675309 }.extend(yaml).to_yaml.must_equal(
+"---
+best_song: 8675309
+"
+)
+      end
+    end
+
+
+    describe "#from_yaml" do
+      it "parses plain property" do
+        album.extend(yaml).from_yaml(
+"---
+best_song: This Song Is Recycled
+").best_song.must_equal "This Song Is Recycled"
+      end
+    end
+
+
+    describe "with :class and :extend" do
+      yaml_song = yaml_representer do property :name end
+      let (:yaml_album) { Module.new do
+        include Representable::YAML
+        property :best_song, :extend => yaml_song, :class => Song
+      end }
+
+      let (:album) { Album.new.tap do |album|
+        album.best_song = Song.new("Liar")
+      end }
+
+
+      describe "#to_yaml" do
+        it "renders embedded typed property" do
+          album.extend(yaml_album).to_yaml.must_equal "---
+best_song:
+  name: Liar
+"
+        end
+      end
+
+      describe "#from_yaml" do
+        it "parses embedded typed property" do
+          album.extend(yaml_album).from_yaml("---
+best_song:
+  name: Go With Me
+").must_equal Album.new(nil,Song.new("Go With Me"))
+        end
+      end
+    end
+  end
+
+
+  describe "collection" do
+    let (:yaml) { yaml_representer do collection :songs end }
+
+    let (:album) { Album.new.tap do |album|
+      album.songs = ["Jackhammer", "Terrible Man"]
+    end }
+
+
+    describe "#to_yaml" do
+      it "renders a block style list per default" do
+        album.extend(yaml).to_yaml.must_equal "---
+songs:
+- Jackhammer
+- Terrible Man
+"
+      end
+
+      it "renders a flow style list when :style => :flow set" do
+        yaml = yaml_representer { collection :songs, :style => :flow }
+        album.extend(yaml).to_yaml.must_equal "---
+songs: [Jackhammer, Terrible Man]
+"
+      end
+    end
+
+
+    describe "#from_yaml" do
+      it "parses a block style list" do
+        album.extend(yaml).from_yaml("---
+songs:
+- Off Key Melody
+- Sinking").must_equal Album.new(["Off Key Melody", "Sinking"])
+
+      end
+
+      it "parses a flow style list" do
+        album.extend(yaml).from_yaml("---
+songs: [Off Key Melody, Sinking]").must_equal Album.new(["Off Key Melody", "Sinking"])
+      end
+    end
+
+
+    describe "with :class and :extend" do
+      let (:yaml_album) { Module.new do
+        include Representable::YAML
+        collection :songs, :class => Song do
+          property :name
+          property :track
+        end
+      end }
+
+      let (:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
+
+
+      describe "#to_yaml" do
+        it "renders collection of typed property" do
+          album.extend(yaml_album).to_yaml.must_equal "---
+songs:
+- name: Liar
+  track: 1
+- name: What I Know
+  track: 2
+"
+        end
+      end
+
+      describe "#from_yaml" do
+        it "parses collection of typed property" do
+          album.extend(yaml_album).from_yaml("---
+songs:
+- name: One Shot Deal
+  track: 4
+- name: Three Way Dance
+  track: 5").must_equal Album.new([Song.new("One Shot Deal", 4), Song.new("Three Way Dance", 5)])
+        end
+      end
+    end
+  end
+end

data/test/as_test.rb

@@ -33,11 +33,11 @@ class AsTest < MiniTest::Spec
 
     describe "lambda arguments" do
       representer! do
-        property :name, :as => lambda { |*args| args.inspect }
+        property :name, :as => lambda { |options| options[:user_options].inspect }
       end
 
-      it { render(song, :volume => 1).must_equal_document({"[{:volume=>1}]" => "Revolution"}) }
-      it { parse(song, {"[{:volume=>1}]" => "Wie Es Geht"}, :volume => 1).name.must_equal "Wie Es Geht" }
+      it { render(song, user_options:{volume: 1}).must_equal_document({"{:volume=>1}" => "Revolution"}) }
+      it { parse(song, {"{:volume=>1}" => "Wie Es Geht"}, user_options: {volume: 1}).name.must_equal "Wie Es Geht" }
     end
   end
 end

data/test/cached_test.rb

@@ -14,7 +14,7 @@ class CachedTest < MiniTest::Spec
     include Representable::Hash
     feature Representable::Cached
 
-    property :title, render_filter: lambda { |input, options| "#{input}:#{options[:user_options]}" }, pass_options: true
+    property :title, render_filter: lambda { |input, options| "#{input}:#{options[:options][:user_options]}" }
     property :composer, class: Model::Artist do
       property :name
     end
@@ -41,7 +41,7 @@ class CachedTest < MiniTest::Spec
       album2 = Model::Album.new("Louder And Even More Dangerous", [song2, song])
 
       # makes sure options are passed correctly.
-      representer.to_hash(volume: 9).must_equal({"name"=>"Live And Dangerous",
+      representer.to_hash(user_options: {volume: 9}).must_equal({"name"=>"Live And Dangerous",
         "songs"=>[{"title"=>"Jailbreak:{:volume=>9}"}, {"title"=>"Southbound:{:volume=>9}"}, {"title"=>"Emerald:{:volume=>9}"}]}) # called in Deserializer/Serializer
 
       # representer becomes reusable as it is stateless.

data/test/class_test.rb

@@ -5,7 +5,7 @@ class ClassTest < BaseTest
   class RepresentingSong
     attr_reader :name
 
-    def from_hash(doc, *args)
+    def from_hash(doc, *)
       @name = doc["__name__"]
 
       self # DISCUSS: do we wanna be able to return whatever we want here? this is a trick to replace the actual object
@@ -66,10 +66,10 @@ class ClassTest < BaseTest
 
     representer!(:inject => :klass) do
       _klass = klass
-      property :song, :class => lambda { |fragment, args| _klass.args=([fragment,args]); _klass }
+      property :song, :class => lambda { |options| _klass.args=([options[:fragment],options[:user_options]]); _klass }
     end
 
-    it { representer.prepare(OpenStruct.new).from_hash({"song" => {"name" => "Captured"}}, :volume => true).song.class.args.
+    it { representer.prepare(OpenStruct.new).from_hash({"song" => {"name" => "Captured"}}, user_options: {volume: true}).song.class.args.
       must_equal([{"name"=>"Captured"}, {:volume=>true}]) }
   end
 
@@ -87,10 +87,10 @@ class ClassTest < BaseTest
 
     representer!(:inject => :klass) do
       _klass = klass
-      collection :songs, :class => lambda { |fragment, i, args| _klass.args=([fragment,i,args]); _klass }
+      collection :songs, :class => lambda { |options| _klass.args=([options[:fragment],options[:index],options[:user_options]]); _klass }
     end
 
-    it { representer.prepare(OpenStruct.new).from_hash({"songs" => [{"name" => "Captured"}]}, :volume => true).songs.first.class.args.
+    it { representer.prepare(OpenStruct.new).from_hash({"songs" => [{"name" => "Captured"}]}, user_options: {volume: true}).songs.first.class.args.
       must_equal([{"name"=>"Captured"}, 0, {:volume=>true}]) }
   end
 

data/test/exec_context_test.rb

@@ -36,7 +36,7 @@ class ExecContextTest < MiniTest::Spec
         property :name,
           :as           => lambda { |*| self.class }, # to actually test
           :exec_context => :binding,
-          :setter        => lambda { |v, *args| represented.name = v # to make parsing work.
+          :setter        => lambda { |options| represented.name = options[:fragment] # to make parsing work.
         }
       end
 
@@ -81,7 +81,7 @@ class ExecContextTest < MiniTest::Spec
           property :name,
             :as           => lambda { |*| self.class }, # to actually test
             :exec_context => :binding,
-            :setter        => lambda { |v, *args| represented.name = v # to make parsing work.
+            :setter        => lambda { |options| represented.name = options[:fragment ] # to make parsing work.
           }
         end
 

data/test/filter_test.rb

@@ -16,7 +16,7 @@ class FilterTest < MiniTest::Spec
 
     property :track,
       :parse_filter  => lambda { |input, options| "#{input.downcase},#{options[:doc]}" },
-      :render_filter => lambda { |val, options| "#{val.upcase},#{options[:doc]},#{options[:user_options]}" }
+      :render_filter => lambda { |val, options| "#{val.upcase},#{options[:doc]},#{options[:options][:user_options]}" }
   end
 
   # gets doc and options.

data/test/getter_setter_test.rb

@@ -3,19 +3,19 @@ require 'test_helper'
 class GetterSetterTest < BaseTest
   representer! do
     property :name, # key under :name.
-      :getter => lambda { |args| "#{args[:welcome]} #{song_name}" },
-      :setter => lambda { |val, args| self.song_name = "#{args[:welcome]} #{val}" }
+      :getter => lambda { |options| "#{options[:user_options][:welcome]} #{song_name}" },
+      :setter => lambda { |options| self.song_name = "#{options[:user_options][:welcome]} #{options[:input]}" }
   end
 
   subject { Struct.new(:song_name).new("Mony Mony").extend(representer) }
 
   it "uses :getter when rendering" do
     subject.instance_eval { def name; raise; end }
-    subject.to_hash(:welcome => "Hi").must_equal({"name" => "Hi Mony Mony"})
+    subject.to_hash(user_options: {welcome: "Hi"}).must_equal({"name" => "Hi Mony Mony"})
   end
 
   it "uses :setter when parsing" do
     subject.instance_eval { def name=(*); raise; end; self }
-    subject.from_hash({"name" => "Eyes Without A Face"}, :welcome => "Hello").song_name.must_equal "Hello Eyes Without A Face"
+    subject.from_hash({"name" => "Eyes Without A Face"}, user_options: {welcome: "Hello"}).song_name.must_equal "Hello Eyes Without A Face"
   end
 end

data/test/if_test.rb

@@ -64,7 +64,7 @@ class IfTest < MiniTest::Spec
 
   describe "propagating user options to the block" do
     representer! do
-      property :name, :if => lambda { |opts| opts[:include_name] }
+      property :name, :if => lambda { |opts| opts[:user_options][:include_name] }
     end
     subject { OpenStruct.new(:name => "Outbound").extend(representer) }
 
@@ -73,7 +73,7 @@ class IfTest < MiniTest::Spec
     end
 
     it "passes user options to block" do
-      subject.to_hash(:include_name => true).must_equal({"name" => "Outbound"})
+      subject.to_hash(user_options: { include_name: true }).must_equal({"name" => "Outbound"})
     end
   end
 end

data/test/include_exclude_test.rb

@@ -0,0 +1,88 @@
+require "test_helper"
+
+class IncludeExcludeTest < Minitest::Spec
+  Song   = Struct.new(:title, :artist, :id)
+  Artist = Struct.new(:name, :id, :songs)
+
+  representer!(decorator: true) do
+    property :title
+    property :artist, class: Artist do
+      property :name
+      property :id
+
+      collection :songs, class: Song do
+        property :title
+        property :id
+      end
+    end
+  end
+
+  let (:song) { Song.new("Listless", Artist.new("7yearsbadluck", 1  )) }
+  let (:decorator) { representer.new(song) }
+
+  describe "#from_hash" do
+    it "accepts :exclude option" do
+      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, exclude: [:title])
+
+      song.title.must_equal "Listless"
+      song.artist.must_equal Artist.new(nil, 2)
+    end
+
+    it "accepts :include option" do
+      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"id"=>2}}, include: [:title])
+
+      song.title.must_equal "Don't Smile In Trouble"
+      song.artist.must_equal Artist.new("7yearsbadluck", 1)
+    end
+
+    it "accepts nested :exclude/:include option" do
+      decorator.from_hash({"title"=>"Don't Smile In Trouble", "artist"=>{"name"=>"Foo", "id"=>2, "songs"=>[{"id"=>1, "title"=>"Listless"}]}},
+        exclude: [:title],
+        artist: {
+          exclude: [:id],
+          songs: { include: [:title] }
+        }
+      )
+
+      song.title.must_equal "Listless"
+      song.artist.must_equal Artist.new("Foo", nil, [Song.new("Listless", nil, nil)])
+    end
+  end
+
+  describe "#to_hash" do
+    it "accepts :exclude option" do
+      decorator.to_hash(exclude: [:title]).must_equal({"artist"=>{"name"=>"7yearsbadluck", "id"=>1}})
+    end
+
+    it "accepts :include option" do
+      decorator.to_hash(include: [:title]).must_equal({"title"=>"Listless"})
+    end
+
+    it "accepts nested :exclude/:include option" do
+      decorator = representer.new(Song.new("Listless", Artist.new("7yearsbadluck", 1, [Song.new("C.O.A.B.I.E.T.L.")])))
+
+      decorator.to_hash(
+        exclude: [:title],
+        artist: {
+          exclude: [:id],
+          songs: { include: [:title] }
+        }
+      ).must_equal({"artist"=>{"name"=>"7yearsbadluck", "songs"=>[{"title"=>"C.O.A.B.I.E.T.L."}]}})
+    end
+  end
+
+  it "xdoes not propagate private options to nested objects" do
+    Cover = Struct.new(:title, :original)
+
+    cover_rpr = Module.new do
+      include Representable::Hash
+      property :title
+      property :original, extend: self
+    end
+
+    # FIXME: we should test all representable-options (:include, :exclude, ?)
+
+    Cover.new("Roxanne", Cover.new("Roxanne (Don't Put On The Red Light)")).extend(cover_rpr).
+      to_hash(:include => [:original]).must_equal({"original"=>{"title"=>"Roxanne (Don't Put On The Red Light)"}})
+  end
+end

data/test/instance_test.rb

@@ -10,7 +10,7 @@ class InstanceTest < BaseTest
 
   describe "lambda { fragment } (new way of class: lambda { nil })" do
     representer! do
-      property :title, :instance  => lambda { |fragment, args| fragment }
+      property :title, :instance  => lambda { |options| options[:fragment] }
     end
 
     it "skips creating new instance" do
@@ -21,7 +21,7 @@ class InstanceTest < BaseTest
         end
       end
 
-      song = OpenStruct.new.extend(representer).from_hash(hash = {"title" => object})
+      song = OpenStruct.new.extend(representer).from_hash({"title" => object})
       song.title.must_equal object
     end
   end
@@ -32,7 +32,7 @@ class InstanceTest < BaseTest
   describe "property with :instance" do
     representer!(:inject => :song_representer) do
       property :song,
-        :instance => lambda { |fragment, *args| fragment["id"] == song.id ? song : Song.find(fragment["id"]) },
+        :instance => lambda { |options| options[:fragment]["id"] == song.id ? song : Song.find(options[:fragment]["id"]) },
         :extend => song_representer
     end
 
@@ -47,8 +47,8 @@ class InstanceTest < BaseTest
   describe "collection with :instance" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |fragment, i, *args|
-          fragment["id"] == songs[i].id ? songs[i] : Song.find(fragment["id"])
+        :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.
 
         :extend => song_representer
@@ -68,11 +68,11 @@ class InstanceTest < BaseTest
 
   describe "property with lambda receiving fragment and args" do
     representer!(:inject => :song_representer) do
-      property :song, :instance => lambda { |fragment, args| Struct.new(:args, :id).new([fragment, args]) }, :extend => song_representer
+      property :song, :instance => lambda { |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}}, {:volume => 1}).song.args.must_equal([{"id"=>1}, {:volume=>1}]) }
+      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,8 +100,8 @@ class InstanceTest < BaseTest
   describe "sync" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |fragment, i, *args|
-          songs[i]
+        :instance => lambda { |options|
+          songs[options[:index]]
         },
         :extend => song_representer,
         # :parse_strategy => :sync
@@ -130,10 +130,10 @@ class InstanceTest < BaseTest
   describe "update existing elements, only" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |fragment, i, *args|
+        :instance => lambda { |options|
 
           #fragment["id"] == songs[i].id ? songs[i] : Song.find(fragment["id"])
-          songs.find { |s| s.id == 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,
@@ -164,7 +164,7 @@ class InstanceTest < BaseTest
   describe "add incoming elements, only" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |fragment, i, *args|
+        :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.
@@ -195,8 +195,8 @@ class InstanceTest < BaseTest
   describe "replace existing element" do
     representer!(:inject => :song_representer) do
       collection :songs,
-        :instance => lambda { |fragment, i, *args|
-          id = fragment.delete("replace_id")
+        :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
@@ -249,7 +249,7 @@ class InstanceTest < BaseTest
   describe "new syntax for instance: true" do
     representer!(:inject => :song_representer) do
       property :song, :pass_options => true,
-        :extend => song_representer, :instance => lambda { |fragment, args| args.binding.get(represented: args.represented) }
+        :extend => song_representer, :instance => lambda { |options| options[:binding].get(represented: options[:represented]) }
     end
 
     it "uses Binding#get instead of creating an instance, but deprecates" do