representable 3.0.0 → 3.1.0

data/test/config_test.rb

@@ -7,7 +7,7 @@ class ConfigTest < MiniTest::Spec
 
   describe "wrapping" do
     it "returns false per default" do
-      assert_equal nil, subject.wrap_for("Punk", nil)
+      assert_nil subject.wrap_for("Punk", nil)
     end
 
     # it "infers a printable class name if set to true" do
@@ -23,13 +23,13 @@ class ConfigTest < MiniTest::Spec
 
   describe "#[]" do
     # does return nil for non-existent
-    it { subject[:hello].must_equal nil }
+    it { _(subject[:hello]).must_be_nil }
   end
 
   # describe "#[]" do
   #   before { subject.add(:title, {:me => true}) }
 
-  #   it { subject[:unknown].must_equal     nil }
+  #   it { subject[:unknown].must_be_nil }
   #   it { subject.get(:title)[:me].must_equal  true }
   #   it { subject["title"][:me].must_equal true }
   # end
@@ -44,23 +44,23 @@ class ConfigTest < MiniTest::Spec
         # #add returns Definition.`
         subject = Representable::Config.new(Representable::Definition).add(:title, {:me => true})
 
-        subject.must_be_kind_of Representable::Definition
-        subject[:me].must_equal true
+        _(subject).must_be_kind_of Representable::Definition
+        _(subject[:me]).must_equal true
       end
     end
 
     before { subject.add(:title, {:me => true}) }
 
     # must be kind of Definition
-    it { subject.size.must_equal 1 }
-    it { subject.get(:title).name.must_equal "title" }
-    it { subject.get(:title)[:me].must_equal true }
+    it { _(subject.size).must_equal 1 }
+    it { _(subject.get(:title).name).must_equal "title" }
+    it { _(subject.get(:title)[:me]).must_equal true }
 
     # this is actually tested in context in inherit_test.
     it "overrides former definition" do
       subject.add(:title, {:peer => Module})
-      subject.get(:title)[:me].must_equal nil
-      subject.get(:title)[:peer].must_equal Module
+      _(subject.get(:title)[:me]).must_be_nil
+      _(subject.get(:title)[:peer]).must_equal Module
     end
 
     describe "inherit: true" do
@@ -69,8 +69,8 @@ class ConfigTest < MiniTest::Spec
         subject.add(:title, {:peer => Module, :inherit => true})
       }
 
-      it { subject.get(:title)[:me].must_equal true }
-      it { subject.get(:title)[:peer].must_equal Module }
+      it { _(subject.get(:title)[:me]).must_equal true }
+      it { _(subject.get(:title)[:peer]).must_equal Module }
     end
   end
 
@@ -81,10 +81,10 @@ class ConfigTest < MiniTest::Spec
     it do
       subject.add(:title, {:me => true})
       subject.add(:genre, {})
-      subject.get(:genre).must_be_kind_of Representable::Definition
+      _(subject.get(:genre)).must_be_kind_of Representable::Definition
 
       subject.remove(:genre)
-      subject.get(:genre).must_equal nil
+      _(subject.get(:genre)).must_be_nil
     end
   end
 
@@ -95,16 +95,16 @@ class ConfigTest < MiniTest::Spec
     it "what" do
       definitions = []
       subject.each { |dfn| definitions << dfn }
-      definitions.size.must_equal 1
-      definitions[0][:me].must_equal true
+      _(definitions.size).must_equal 1
+      _(definitions[0][:me]).must_equal true
     end
   end
 
   describe "#options" do
-    it { subject.options.must_equal({}) }
+    it { _(subject.options).must_equal({}) }
     it do
       subject.options[:namespacing] = true
-      subject.options[:namespacing].must_equal true
+      _(subject.options[:namespacing]).must_equal true
     end
   end
 
@@ -115,8 +115,8 @@ class ConfigTest < MiniTest::Spec
       title  = subject.add(:title, {})
       length = subject.add(:length, {})
 
-      subject.get(:title).must_equal title
-      subject.get(:length).must_equal length
+      _(subject.get(:title)).must_equal title
+      _(subject.get(:length)).must_equal length
     end
   end
 end

data/test/decorator_scope_test.rb

@@ -6,7 +6,7 @@ class DecoratorScopeTest < MiniTest::Spec
     property :title, :getter => lambda { |*| title_from_representer }, :decorator_scope => true
   end
 
-  let (:representer_with_method) {
+  let(:representer_with_method) {
     Module.new do
       include Representable::Hash
       property :title, :decorator_scope => true
@@ -15,14 +15,14 @@ class DecoratorScopeTest < MiniTest::Spec
    }
 
   it "executes lambdas in represented context" do
-    Class.new do
+    _(Class.new do
       def title_from_representer
         "Sounds Of Silence"
       end
-    end.new.extend(representer).to_hash.must_equal({"title"=>"Sounds Of Silence"})
+    end.new.extend(representer).to_hash).must_equal({"title"=>"Sounds Of Silence"})
   end
 
   it "executes method in represented context" do
-    Object.new.extend(representer_with_method).to_hash.must_equal({"title"=>"Crystal Planet"})
+    _(Object.new.extend(representer_with_method).to_hash).must_equal({"title"=>"Crystal Planet"})
   end
 end

data/test/decorator_test.rb

@@ -12,46 +12,59 @@ class DecoratorTest < MiniTest::Spec
     collection :songs, :class => Song, :extend => SongRepresentation
   end
 
-  let (:song) { Song.new("Mama, I'm Coming Home") }
-  let (:album) { Album.new([song]) }
+  class RatingRepresentation < Representable::Decorator
+    include Representable::JSON
+
+    property :system
+    property :value
+  end
+
+  let(:song) { Song.new("Mama, I'm Coming Home") }
+  let(:album) { Album.new([song]) }
+
+  let(:rating) { OpenStruct.new(system: 'MPAA', value: 'R') }
 
   describe "inheritance" do
-    let (:inherited_decorator) do
+    let(:inherited_decorator) do
       Class.new(AlbumRepresentation) do
         property :best_song
       end.new(Album.new([song], "Stand Up"))
     end
 
-    it { inherited_decorator.to_hash.must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}], "best_song"=>"Stand Up"}) }
+    it { _(inherited_decorator.to_hash).must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}], "best_song"=>"Stand Up"}) }
   end
 
-  let (:decorator) { AlbumRepresentation.new(album) }
+  let(:decorator) { AlbumRepresentation.new(album) }
+
+  let(:rating_decorator) { RatingRepresentation.new(rating) }
 
   it "renders" do
-    decorator.to_hash.must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}]})
-    album.wont_respond_to :to_hash
-    song.wont_respond_to :to_hash # DISCUSS: weak test, how to assert blank slate?
+    _(decorator.to_hash).must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}]})
+    _(album).wont_respond_to :to_hash
+    _(song).wont_respond_to :to_hash # DISCUSS: weak test, how to assert blank slate?
     # no @representable_attrs in decorated objects
-    song.instance_variable_get(:@representable_attrs).must_equal nil
+    _(song).wont_be(:instance_variable_defined?, :@representable_attrs)
+
+    _(rating_decorator.to_hash).must_equal({"system" => "MPAA", "value" => "R"})
   end
 
   describe "#from_hash" do
     it "returns represented" do
-      decorator.from_hash({"songs"=>[{"name"=>"Mama, I'm Coming Home"}]}).must_equal album
+      _(decorator.from_hash({"songs"=>[{"name"=>"Mama, I'm Coming Home"}]})).must_equal album
     end
 
     it "parses" do
       decorator.from_hash({"songs"=>[{"name"=>"Atomic Garden"}]})
-      album.songs.first.must_be_kind_of Song
-      album.songs.must_equal [Song.new("Atomic Garden")]
-      album.wont_respond_to :to_hash
-      song.wont_respond_to :to_hash # DISCUSS: weak test, how to assert blank slate?
+      _(album.songs.first).must_be_kind_of Song
+      _(album.songs).must_equal [Song.new("Atomic Garden")]
+      _(album).wont_respond_to :to_hash
+      _(song).wont_respond_to :to_hash # DISCUSS: weak test, how to assert blank slate?
     end
   end
 
   describe "#decorated" do
     it "is aliased to #represented" do
-      AlbumRepresentation.prepare(album).decorated.must_equal album
+      _(AlbumRepresentation.prepare(album).decorated).must_equal album
     end
   end
 
@@ -67,8 +80,8 @@ class DecoratorTest < MiniTest::Spec
       representer.new(album).from_hash({"songs"=>[{"name"=>"Atomic Garden"}]})
 
       # no @representable_attrs in decorated objects
-      song.instance_variable_get(:@representable_attrs).must_equal nil
-      album.instance_variable_get(:@representable_attrs).must_equal nil
+      _(song).wont_be(:instance_variable_defined?, :@representable_attrs)
+      _(album).wont_be(:instance_variable_defined?, :@representable_attrs)
     end
   end
 end
@@ -89,8 +102,8 @@ class InheritanceWithDecoratorTest < MiniTest::Spec
   end
 
   it do
-    Twin.representer_class.definitions.size.must_equal 0
-    Album.representer_class.definitions.size.must_equal 1
-    Song.representer_class.definitions.size.must_equal 0
+    _(Twin.representer_class.definitions.size).must_equal 0
+    _(Album.representer_class.definitions.size).must_equal 1
+    _(Song.representer_class.definitions.size).must_equal 0
   end
 end

data/test/default_test.rb

@@ -9,26 +9,26 @@ class DefaultTest < MiniTest::Spec
   end
 
   describe "#from_hash" do
-    let (:song) { Song.new.extend(representer) }
+    let(:song) { Song.new.extend(representer) }
 
-    it { song.from_hash({}).must_equal Song.new(nil, "Huber Breeze") }
+    it { _(song.from_hash({})).must_equal Song.new(nil, "Huber Breeze") }
     # default doesn't apply when empty string.
-    it { song.from_hash({"title"=>""}).must_equal Song.new(nil, "") }
-    it { song.from_hash({"title"=>nil}).must_equal Song.new(nil, nil) }
-    it { song.from_hash({"title"=>"Blindfold"}).must_equal Song.new(nil, "Blindfold") }
+    it { _(song.from_hash({"title"=>""})).must_equal Song.new(nil, "") }
+    it { _(song.from_hash({"title"=>nil})).must_equal Song.new(nil, nil) }
+    it { _(song.from_hash({"title"=>"Blindfold"})).must_equal Song.new(nil, "Blindfold") }
   end
 
   describe "#to_json" do
     it "uses :default when not available from object" do
-      Song.new.extend(representer).to_hash.must_equal({"title"=>"Huber Breeze"})
+      _(Song.new.extend(representer).to_hash).must_equal({"title"=>"Huber Breeze"})
     end
 
     it "uses value from represented object when present" do
-      Song.new(nil, "After The War").extend(representer).to_hash.must_equal({"title"=>"After The War"})
+      _(Song.new(nil, "After The War").extend(representer).to_hash).must_equal({"title"=>"After The War"})
     end
 
     it "uses value from represented object when emtpy string" do
-      Song.new(nil, "").extend(representer).to_hash.must_equal({"title"=>""})
+      _(Song.new(nil, "").extend(representer).to_hash).must_equal({"title"=>""})
     end
   end
 end

data/test/defaults_options_test.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
 
 class DefaultsOptionsTest < BaseTest
-  let (:format) { :hash }
-  let (:song) { Struct.new(:title, :author_name, :song_volume, :description).new("Revolution", "Some author", 20, nil) }
-  let (:prepared) { representer.prepare song }
+  let(:format) { :hash }
+  let(:song) { Struct.new(:title, :author_name, :song_volume, :description).new("Revolution", "Some author", 20, nil) }
+  let(:prepared) { representer.prepare song }
 
   describe "hash options combined with dynamic options" do
     representer! do

data/test/definition_test.rb

@@ -6,42 +6,40 @@ class DefinitionTest < MiniTest::Spec
   # TODO: test that we DON'T clone options, that must happen in
   describe "#initialize" do
     it do
-      opts = nil
-
       # new yields the defaultized options HASH.
       definition = Definition.new(:song, :extend => Module) do |options|
         options[:awesome] = true
         options[:parse_filter] << 1
 
         # default variables
-        options[:as].must_equal nil
-        options[:extend].must_equal Module
+        _(options[:as]).must_be_nil
+        _(options[:extend]).must_equal Module
       end
-      definition.name.must_equal "song"
+      _(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[]
+      _(definition[:awesome]).must_equal true
+      _(definition[:parse_filter]).must_equal Representable::Pipeline[1]
+      _(definition[:render_filter]).must_equal Representable::Pipeline[]
     end
   end
 
   describe "#[]" do
-    let (:definition) { Definition.new(:song) }
+    let(:definition) { Definition.new(:song) }
     # default is nil.
-    it { definition[:bla].must_equal nil }
+    it { _(definition[:bla]).must_be_nil }
   end
 
   # merge!
   describe "#merge!" do
-    let (:definition) { Definition.new(:song, :whatever => true) }
+    let(:definition) { Definition.new(:song, :whatever => true) }
 
     # merges new options.
-    it { definition.merge!(:something => true)[:something].must_equal true }
+    it { _(definition.merge!(:something => true)[:something]).must_equal true }
     # doesn't override original options.
-    it { definition.merge!({:something => true})[:whatever].must_equal true }
+    it { _(definition.merge!({:something => true})[:whatever]).must_equal true }
     # override original when passed in #merge!.
-    it { definition.merge!({:whatever => false})[:whatever].must_equal false }
+    it { _(definition.merge!({:whatever => false})[:whatever]).must_equal false }
 
     # with block
     it do
@@ -54,47 +52,47 @@ class DefinitionTest < MiniTest::Spec
         # options[:extend].must_equal Module
       end
 
-      definition[:awesome].must_equal true
-      definition[:something].must_equal true
-      definition[:render_filter].must_equal Representable::Pipeline[1]
-      definition[:parse_filter].must_equal Representable::Pipeline[]
+      _(definition[:awesome]).must_equal true
+      _(definition[:something]).must_equal true
+      _(definition[:render_filter]).must_equal Representable::Pipeline[1]
+      _(definition[:parse_filter]).must_equal Representable::Pipeline[]
     end
 
     describe "with :parse_filter" do
-      let (:definition) { Definition.new(:title, :parse_filter => 1) }
+      let(:definition) { Definition.new(:title, :parse_filter => 1) }
 
       # merges :parse_filter and :render_filter.
       it do
         merged = definition.merge!(:parse_filter => 2)[:parse_filter]
 
-        merged.must_be_kind_of Representable::Pipeline
-        merged.size.must_equal 2
+        _(merged).must_be_kind_of Representable::Pipeline
+        _(merged.size).must_equal 2
       end
 
       # :parse_filter can also be array.
-      it { definition.merge!(:parse_filter => [2, 3])[:parse_filter].size.must_equal 3 }
+      it { _(definition.merge!(:parse_filter => [2, 3])[:parse_filter].size).must_equal 3 }
     end
 
     # does not change arguments
     it do
       Definition.new(:title).merge!(options = {:whatever => 1})
-      options.must_equal(:whatever => 1)
+      _(options).must_equal(:whatever => 1)
     end
   end
 
 
   # delete!
   describe "#delete!" do
-    let (:definition) { Definition.new(:song, serialize: "remove me!") }
+    let(:definition) { Definition.new(:song, serialize: "remove me!") }
 
-    before { definition[:serialize].evaluate(nil).must_equal "remove me!" }
+    before { _(definition[:serialize].(nil)).must_equal "remove me!" }
 
-    it { definition.delete!(:serialize)[:serialize].must_equal nil }
+    it { _(definition.delete!(:serialize)[:serialize]).must_be_nil }
   end
 
   # #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=>[]}>" }
   end
 
 
@@ -104,13 +102,13 @@ class DefinitionTest < MiniTest::Spec
     end
 
     it "responds to #representer_module" do
-      assert_equal nil, Representable::Definition.new(:song).representer_module
+      assert_nil Representable::Definition.new(:song).representer_module
       assert_equal Hash, Representable::Definition.new(:song, :extend => Hash).representer_module
     end
 
     describe "#typed?" do
       it "is false per default" do
-        assert ! @def.typed?
+        refute @def.typed?
       end
 
       it "is true when :class is present" do
@@ -129,7 +127,7 @@ class DefinitionTest < MiniTest::Spec
 
     describe "#representable?" do
       it { assert Definition.new(:song, :representable => true).representable? }
-      it { Definition.new(:song, :representable => true, :extend => Object).representable?.must_equal true }
+      it { _(Definition.new(:song, :representable => true, :extend => Object).representable?).must_equal true }
       it { refute Definition.new(:song, :representable => false, :extend => Object).representable? }
       it { assert Definition.new(:song, :extend => Object).representable? }
       it { refute Definition.new(:song).representable? }
@@ -152,16 +150,16 @@ class DefinitionTest < MiniTest::Spec
       it do
         dfn = Representable::Definition.new(:songs, nested: Module)
         assert dfn.typed?
-        dfn[:extend].(nil).must_equal Module
+        _(dfn[:extend].(nil)).must_equal Module
       end
     end
 
 
     describe "#clone" do
-      subject { Representable::Definition.new(:title, :volume => 9, :clonable => Uber::Options::Value.new(1)) }
+      subject { Representable::Definition.new(:title, :volume => 9, :clonable => ::Representable::Option(1)) }
 
-      it { subject.clone.must_be_kind_of Representable::Definition }
-      it { subject.clone[:clonable].evaluate(nil).must_equal 1 }
+      it { _(subject.clone).must_be_kind_of Representable::Definition }
+      it { _(subject.clone[:clonable].(nil)).must_equal 1 }
 
       it "clones @options" do
         @def.merge!(:volume => 9)
@@ -177,11 +175,11 @@ class DefinitionTest < MiniTest::Spec
 
   describe "#has_default?" do
     it "returns false if no :default set" do
-      assert_equal false, Representable::Definition.new(:song).has_default?
+      refute Representable::Definition.new(:song).has_default?
     end
 
     it "returns true if :default set" do
-      assert_equal true, Representable::Definition.new(:song, :default => nil).has_default?
+      assert Representable::Definition.new(:song, :default => nil).has_default?
     end
   end
 
@@ -192,14 +190,14 @@ class DefinitionTest < MiniTest::Spec
     end
 
     it "returns false when :binding is not set" do
-      assert !Representable::Definition.new(:songs)[:binding]
+      refute Representable::Definition.new(:songs)[:binding]
     end
   end
 
   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.create_binding.must_equal @binding
+      _(definition.create_binding).must_equal @binding
     end
   end
 
@@ -217,7 +215,7 @@ class DefinitionTest < MiniTest::Spec
   describe ":default => value" do
     it "responds to #default" do
       @def = Representable::Definition.new(:song)
-      assert_equal nil, @def[:default]
+      assert_nil @def[:default]
     end
 
     it "accepts a default value" do
@@ -233,7 +231,7 @@ class DefinitionTest < MiniTest::Spec
 
     it "responds to #hash?" do
       assert @def.hash?
-      assert ! Representable::Definition.new(:songs).hash?
+      refute Representable::Definition.new(:songs).hash?
     end
   end