representable 3.0.4 → 3.1.1

data/test/config_test.rb

@@ -23,7 +23,7 @@ class ConfigTest < MiniTest::Spec
 
   describe "#[]" do
     # does return nil for non-existent
-    it { subject[:hello].must_be_nil }
+    it { _(subject[:hello]).must_be_nil }
   end
 
   # describe "#[]" do
@@ -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_be_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_be_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

@@ -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

@@ -31,7 +31,7 @@ class DecoratorTest < MiniTest::Spec
       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) }
@@ -39,32 +39,32 @@ class DecoratorTest < MiniTest::Spec
   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.wont_be(:instance_variable_defined?, :@representable_attrs)
+    _(song).wont_be(:instance_variable_defined?, :@representable_attrs)
 
-    rating_decorator.to_hash.must_equal({"system" => "MPAA", "value" => "R"})
+    _(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
 
@@ -80,8 +80,8 @@ class DecoratorTest < MiniTest::Spec
       representer.new(album).from_hash({"songs"=>[{"name"=>"Atomic Garden"}]})
 
       # no @representable_attrs in decorated objects
-      song.wont_be(:instance_variable_defined?, :@representable_attrs)
-      album.wont_be(:instance_variable_defined?, :@representable_attrs)
+      _(song).wont_be(:instance_variable_defined?, :@representable_attrs)
+      _(album).wont_be(:instance_variable_defined?, :@representable_attrs)
     end
   end
 end
@@ -102,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

@@ -11,24 +11,24 @@ class DefaultTest < MiniTest::Spec
   describe "#from_hash" do
     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/definition_test.rb

@@ -12,22 +12,22 @@ class DefinitionTest < MiniTest::Spec
         options[:parse_filter] << 1
 
         # default variables
-        options[:as].must_be_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) }
     # default is nil.
-    it { definition[:bla].must_be_nil }
+    it { _(definition[:bla]).must_be_nil }
   end
 
   # merge!
@@ -35,11 +35,11 @@ class DefinitionTest < MiniTest::Spec
     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
@@ -52,10 +52,10 @@ 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
@@ -65,18 +65,18 @@ class DefinitionTest < MiniTest::Spec
       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
 
@@ -85,14 +85,14 @@ class DefinitionTest < MiniTest::Spec
   describe "#delete!" do
     let(:definition) { Definition.new(:song, serialize: "remove me!") }
 
-    before { definition[:serialize].(nil).must_equal "remove me!" }
+    before { _(definition[:serialize].(nil)).must_equal "remove me!" }
 
-    it { definition.delete!(:serialize)[:serialize].must_be_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
 
 
@@ -108,7 +108,7 @@ class DefinitionTest < MiniTest::Spec
 
     describe "#typed?" do
       it "is false per default" do
-        assert ! @def.typed?
+        refute @def.typed?
       end
 
       it "is true when :class is present" do
@@ -127,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? }
@@ -150,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 => Declarative::Option(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].(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)
@@ -175,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
 
@@ -190,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
 
@@ -231,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
 

data/test/exec_context_test.rb

@@ -17,7 +17,7 @@ class ExecContextTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document output }
-      it { parse(song, input).name.must_equal "Rebel Fate" }
+      it { _(parse(song, input).name).must_equal "Rebel Fate" }
     end
 
 
@@ -27,7 +27,7 @@ class ExecContextTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document output }
-      it { parse(song, input).name.must_equal "Rebel Fate" }
+      it { _(parse(song, input).name).must_equal "Rebel Fate" }
     end
 
 
@@ -41,7 +41,7 @@ class ExecContextTest < MiniTest::Spec
       end
 
       it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
-      it { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+      it { _(parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name).must_equal "Rebel Fate" }
     end
 
 
@@ -53,7 +53,7 @@ class ExecContextTest < MiniTest::Spec
         end
 
         it { render(song).must_equal_document output }
-        it { parse(song, input).name.must_equal "Rebel Fate" }
+        it { _(parse(song, input).name).must_equal "Rebel Fate" }
       end
 
 
@@ -71,7 +71,7 @@ class ExecContextTest < MiniTest::Spec
         end
 
         it { render(song).must_equal_document({Representable::Decorator=>"Timebomb"}) }
-        it { parse(song, {Representable::Decorator=>"Listless"}).name.must_equal "Listless" }
+        it { _(parse(song, {Representable::Decorator=>"Listless"}).name).must_equal "Listless" }
       end
 
 
@@ -86,7 +86,7 @@ class ExecContextTest < MiniTest::Spec
         end
 
         it { render(song).must_equal_document({Representable::Hash::Binding => "name"}) }
-        it("xxx") { parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name.must_equal "Rebel Fate" }
+        it("xxx") { _(parse(song, {Representable::Hash::Binding => "Rebel Fate"}).name).must_equal "Rebel Fate" }
       end
     end
   end