representable 3.0.0 → 3.1.0

data/test/stringify_hash_test.rb

@@ -17,11 +17,11 @@ describe "#from_hash" do
    end
 
    it "parses symbols, too" do
-     OpenStruct.new.extend(representer).from_hash({:song => {:title => "Der Optimist"}}).song.title.must_equal "Der Optimist"
+     _(OpenStruct.new.extend(representer).from_hash({:song => {:title => "Der Optimist"}}).song.title).must_equal "Der Optimist"
    end
 
    it "still parses strings" do
-     OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Der Optimist"}}).song.title.must_equal "Der Optimist"
+     _(OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Der Optimist"}}).song.title).must_equal "Der Optimist"
    end
 
    describe "with :wrap" do
@@ -33,7 +33,7 @@ describe "#from_hash" do
     end
 
      it "parses symbols, too" do
-       OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title.must_equal "Der Optimist"
+       _(OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title).must_equal "Der Optimist"
      end
    end
  end

data/test/test_helper.rb

@@ -1,16 +1,20 @@
+require 'pry-byebug'
 require 'representable'
 
-require "json"
-require "psych"
-
-require 'representable/json'
-require 'representable/xml'
-require 'representable/yaml'
 require 'minitest/autorun'
 require 'test_xml/mini_test'
 
 require "representable/debug"
+require 'minitest/assertions'
 
+module MiniTest::Assertions
+  def assert_equal_xml(text, subject)
+    assert_equal (text.gsub("\n", "").gsub(/(\s\s+)/, "")), subject.gsub("\n", "").gsub(/(\s\s+)/, "")
+  end
+end
+String.infect_an_assertion :assert_equal_xml, :must_xml
+
+# TODO: delete all that in 4.0:
 class Album
   attr_accessor :songs, :best_song
   def initialize(songs=nil, best_song=nil)
@@ -45,7 +49,7 @@ module AssertJson
   module Assertions
     def assert_json(expected, actual, msg=nil)
       msg = message(msg, "") { diff expected, actual }
-      assert(expected.split("").sort == actual.split("").sort, msg)
+      assert_equal(expected.split("").sort, actual.split("").sort, msg)
     end
   end
 end
@@ -83,7 +87,7 @@ MiniTest::Spec.class_eval do
   end
 
   def self.representer!(options={}, &block)
-    fmt = options # we need that so the 2nd call to ::let (within a ::describe) remembers the right format.
+    fmt = options # we need that so the 2nd call to ::let(within a ::describe) remembers the right format.
 
     name   = options[:name]   || :representer
     format = options[:module] || Representable::Hash
@@ -101,6 +105,8 @@ MiniTest::Spec.class_eval do
       mod
     end
 
+    undef :inject_representer if method_defined? :inject_representer
+
     def inject_representer(mod, options)
       return unless options[:inject]
 
@@ -116,7 +122,7 @@ MiniTest::Spec.class_eval do
     def representer_for(modules=[Representable::Hash], &block)
       Module.new do
         extend TestMethods
-        include *modules
+        include(*modules)
         module_exec(&block)
       end
     end
@@ -127,9 +133,15 @@ MiniTest::Spec.class_eval do
 end
 
 class BaseTest < MiniTest::Spec
-  let (:new_album)  { OpenStruct.new.extend(representer) }
-  let (:album)      { OpenStruct.new(:songs => ["Fuck Armageddon"]).extend(representer) }
-  let (:song) { OpenStruct.new(:title => "Resist Stance") }
-  let (:song_representer) { Module.new do include Representable::Hash; property :title end  }
+  let(:new_album)  { OpenStruct.new.extend(representer) }
+  let(:album)      { OpenStruct.new(:songs => ["Fuck Armageddon"]).extend(representer) }
+  let(:song) { OpenStruct.new(:title => "Resist Stance") }
+  let(:song_representer) { Module.new do include Representable::Hash; property :title end  }
 
-end
+end
+
+Band = Struct.new(:id, :name) do
+  def [](*attrs)
+    attrs.collect { |attr| send(attr) }
+  end
+end

data/test/uncategorized_test.rb

@@ -15,12 +15,12 @@ class StopWhenIncomingObjectFragmentIsNilTest < MiniTest::Spec
 
   it do
     album = Album.new
-    representer.new(album).from_hash({"id"=>1, "songs"=>[{"title"=>"Walkie Talkie"}]}).songs.must_equal [Song.new("Walkie Talkie")]
+    _(representer.new(album).from_hash({"id"=>1, "songs"=>[{"title"=>"Walkie Talkie"}]}).songs).must_equal [Song.new("Walkie Talkie")]
   end
 
   it do
     album = Album.new(2, ["original"])
-    representer.new(album).from_hash({"id"=>1, "songs"=>nil}).songs.must_equal ["original"]
+    _(representer.new(album).from_hash({"id"=>1, "songs"=>nil}).songs).must_equal ["original"]
   end
 
 end
@@ -35,13 +35,13 @@ class RenderPipelineOptionTest < MiniTest::Spec
     end
   end
 
-  it { representer.new(Album.new).to_hash(user_options: {function: NilToNA}).must_equal({"id"=>"n/a"}) }
-  it { representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA}).must_equal({"id"=>1}) }
+  it { _(representer.new(Album.new).to_hash(user_options: {function: NilToNA})).must_equal({"id"=>"n/a"}) }
+  it { _(representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA})).must_equal({"id"=>1}) }
 
   it "is cached" do
     decorator = representer.new(Album.new)
-    decorator.to_hash(user_options: {function: NilToNA}).must_equal({"id"=>"n/a"})
-    decorator.to_hash(user_options: {function: nil}).must_equal({"id"=>"n/a"}) # non-sense function is not applied.
+    _(decorator.to_hash(user_options: {function: NilToNA})).must_equal({"id"=>"n/a"})
+    _(decorator.to_hash(user_options: {function: nil})).must_equal({"id"=>"n/a"}) # non-sense function is not applied.
   end
 
 end
@@ -56,12 +56,12 @@ class ParsePipelineOptionTest < MiniTest::Spec
     end
   end
 
-  it { representer.new(Album.new).from_hash({"id"=>nil}, user_options: {function: NilToNA}).id.must_equal "n/a" }
-  it { representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA}).must_equal({"id"=>1}) }
+  it { _(representer.new(Album.new).from_hash({"id"=>nil}, user_options: {function: NilToNA}).id).must_equal "n/a" }
+  it { _(representer.new(Album.new(1)).to_hash(user_options: {function: NilToNA})).must_equal({"id"=>1}) }
 
   it "is cached" do
     decorator = representer.new(Album.new)
-    decorator.from_hash({"id"=>nil}, user_options: {function: NilToNA}).id.must_equal "n/a"
-    decorator.from_hash({"id"=>nil}, user_options: {function: "nonsense"}).id.must_equal "n/a" # non-sense function is not applied.
+    _(decorator.from_hash({"id"=>nil}, user_options: {function: NilToNA}).id).must_equal "n/a"
+    _(decorator.from_hash({"id"=>nil}, user_options: {function: "nonsense"}).id).must_equal "n/a" # non-sense function is not applied.
   end
 end

data/test/user_options_test.rb

@@ -7,9 +7,9 @@ class UserOptionsTest < Minitest::Spec
     property :title, if: ->(options) { options[:user_options][:visible] }
   end
 
-  it { Song.new("Run With It").extend(representer).to_hash.must_equal({}) }
-  it { Song.new("Run With It").extend(representer).to_hash(user_options: {visible: true}).must_equal({"title"=>"Run With It"}) }
-  it { Song.new("Run With It").extend(representer).from_hash("title"=>"Business Conduct").title.must_equal "Run With It" }
-  it { Song.new("Run With It").extend(representer).from_hash({"title"=>"Business Conduct"}, user_options: {visible: true}).title.must_equal "Business Conduct" }
+  it { _(Song.new("Run With It").extend(representer).to_hash).must_equal({}) }
+  it { _(Song.new("Run With It").extend(representer).to_hash(user_options: {visible: true})).must_equal({"title"=>"Run With It"}) }
+  it { _(Song.new("Run With It").extend(representer).from_hash("title"=>"Business Conduct").title).must_equal "Run With It" }
+  it { _(Song.new("Run With It").extend(representer).from_hash({"title"=>"Business Conduct"}, user_options: {visible: true}).title).must_equal "Business Conduct" }
 end
 # Representable.deprecations=false

data/test/virtus_coercion_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+require 'representable/virtus_coercion'
+
+class VirtusCoercionTest < MiniTest::Spec
+  representer! do
+    include Representable::VirtusCoercion
+
+    property :title # no coercion.
+    property :length, :type => Float
+
+    property :band, :class => OpenStruct do
+      property :founded, :type => Integer
+    end
+
+    collection :songs, :class => OpenStruct do
+      property :ok, :type => Virtus::Attribute::Boolean
+    end
+  end
+
+  let(:album) { OpenStruct.new(:title => "Dire Straits", :length => 41.34,
+    :band  => OpenStruct.new(:founded => "1977"),
+    :songs => [OpenStruct.new(:ok => 1), OpenStruct.new(:ok => 0)]) }
+
+  it { _(album.extend(representer).to_hash).must_equal({"title"=>"Dire Straits", "length"=>41.34, "band"=>{"founded"=>1977}, "songs"=>[{"ok"=>true}, {"ok"=>false}]}) }
+
+  it {
+    album = OpenStruct.new
+    album.extend(representer)
+    album.from_hash({"title"=>"Dire Straits", "length"=>"41.34", "band"=>{"founded"=>"1977"}, "songs"=>[{"ok"=>1}, {"ok"=>0}]})
+
+    # it
+    _(album.length).must_equal 41.34
+    _(album.band.founded).must_equal 1977
+    _(album.songs[0].ok).must_equal true
+  }
+
+
+  describe "with user :parse_filter and :render_filter" do
+    representer! do
+      include Representable::VirtusCoercion
+
+      property :length, :type => Float,
+      :parse_filter  => lambda { |input, options| "#{input}.1" }, # happens BEFORE coercer.
+      :render_filter => lambda { |fragment,*| "#{fragment}.1" }
+    end
+
+    # user's :parse_filter(s) are run before coercion.
+    it { _(OpenStruct.new.extend(representer).from_hash("length"=>"1").length).must_equal 1.1 }
+    # user's :render_filter(s) are run before coercion.
+    it { _(OpenStruct.new(:length=>1).extend(representer).to_hash).must_equal({"length" => 1.1}) }
+  end
+end

data/test/wrap_test.rb

@@ -8,10 +8,10 @@ class WrapTest < MiniTest::Spec
   class SoftcoreBand < HardcoreBand
   end
 
-  let (:band) { HardcoreBand.new }
+  let(:band) { HardcoreBand.new }
 
   it "returns false per default" do
-    assert_equal nil, SoftcoreBand.new.send(:representation_wrap)
+    assert_nil SoftcoreBand.new.send(:representation_wrap)
   end
 
   it "infers a printable class name if set to true" do
@@ -32,17 +32,17 @@ class WrapTest < MiniTest::Spec
   ) do |format, mod, output, input|
 
     describe "[#{format}] dynamic wrap" do
-      let (:band) { representer.prepare(Struct.new(:name, :genre).new("Blink", "Pop")) }
-      let (:format) { format }
+      let(:band) { representer.prepare(Struct.new(:name, :genre).new("Blink", "Pop")) }
+      let(:format) { format }
 
       representer!(:module => mod) do
-        self.representation_wrap = lambda { |args| "#{name}#{args[:number]}" }
+        self.representation_wrap = lambda { |number:, **| "#{name}#{number}" }
         property :genre
       end
 
       it { render(band, {:number => 182}).must_equal_document(output) }
 
-      it { parse(band, input, {:number => 182}).genre.must_equal "Poppunk" } # TODO: better test. also, xml parses _any_ wrap.
+      it { _(parse(band, input, {:number => 182}).genre).must_equal "Poppunk" } # TODO: better test. also, xml parses _any_ wrap.
     end
   end
 end
@@ -65,19 +65,19 @@ class HashDisableWrapTest < MiniTest::Spec
     end
   end
 
-  let (:band) { BandDecorator.prepare(Band.new("Social Distortion")) }
+  let(:band) { BandDecorator.prepare(Band.new("Social Distortion")) }
 
   # direct, local api.
   it do
-    band.to_hash.must_equal({"bands" => {"name"=>"Social Distortion"}})
-    band.to_hash(wrap: false).must_equal({"name"=>"Social Distortion"})
-    band.to_hash(wrap: :band).must_equal(:band=>{"name"=>"Social Distortion"})
+    _(band.to_hash).must_equal({"bands" => {"name"=>"Social Distortion"}})
+    _(band.to_hash(wrap: false)).must_equal({"name"=>"Social Distortion"})
+    _(band.to_hash(wrap: :band)).must_equal(:band=>{"name"=>"Social Distortion"})
   end
 
   it do
-    band.from_hash({"bands" => {"name"=>"Social Distortion"}}).name.must_equal "Social Distortion"
-    band.from_hash({"name"=>"Social Distortion"}, wrap: false).name.must_equal "Social Distortion"
-    band.from_hash({band: {"name"=>"Social Distortion"}}, wrap: :band).name.must_equal "Social Distortion"
+    _(band.from_hash({"bands" => {"name"=>"Social Distortion"}}).name).must_equal "Social Distortion"
+    _(band.from_hash({"name"=>"Social Distortion"}, wrap: false).name).must_equal "Social Distortion"
+    _(band.from_hash({band: {"name"=>"Social Distortion"}}, wrap: :band).name).must_equal "Social Distortion"
   end
 
 
@@ -90,15 +90,15 @@ class HashDisableWrapTest < MiniTest::Spec
   end
 
 
-  let (:album) { AlbumDecorator.prepare(Album.new(Band.new("Social Distortion", Label.new("Epitaph")))) }
+  let(:album) { AlbumDecorator.prepare(Album.new(Band.new("Social Distortion", Label.new("Epitaph")))) }
 
   # band has wrap turned off per property definition, however, label still has wrap.
   it "renders" do
-    album.to_hash.must_equal({"albums" => {"band" => {"name"=>"Social Distortion", "label"=>{"important"=>{"name"=>"Epitaph"}}}}})
+    _(album.to_hash).must_equal({"albums" => {"band" => {"name"=>"Social Distortion", "label"=>{"important"=>{"name"=>"Epitaph"}}}}})
   end
 
   it "parses" do
-    album.from_hash({"albums" => {"band" => {"name"=>"Rvivr"}}}).band.name.must_equal "Rvivr"
+    _(album.from_hash({"albums" => {"band" => {"name"=>"Rvivr"}}}).band.name).must_equal "Rvivr"
   end
 end
 
@@ -120,7 +120,7 @@ class XMLDisableWrapTest < MiniTest::Spec
     # end
   end
 
-  let (:band) { BandDecorator.prepare(Band.new("Social Distortion")) }
+  let(:band) { BandDecorator.prepare(Band.new("Social Distortion")) }
 
   it do
     band.to_xml.must_equal_xml "<bands><name>Social Distortion</name></bands>"
@@ -137,12 +137,12 @@ class XMLDisableWrapTest < MiniTest::Spec
   end
 
 
-  let (:album) { AlbumDecorator.prepare(Album.new(Band.new("Social Distortion", Label.new("Epitaph")))) }
+  let(:album) { AlbumDecorator.prepare(Album.new(Band.new("Social Distortion", Label.new("Epitaph")))) }
 
   # band has wrap turned of per property definition, however, label still has wrap.
   it "rendersxx" do
     skip
-    album.to_xml.must_equal({"albums" => {"band" => {"name"=>"Social Distortion", "label"=>{"important"=>{"name"=>"Epitaph"}}}}})
+    _(album.to_xml).must_equal({"albums" => {"band" => {"name"=>"Social Distortion", "label"=>{"important"=>{"name"=>"Epitaph"}}}}})
   end
 
   # it "parses" do

data/test/xml_bindings_test.rb

@@ -1,10 +1,6 @@
 require 'test_helper'
-require 'representable/json'  # FIXME.
-require 'representable/xml/collection'
 require 'representable/xml/hash'
 
-require 'representable/xml'
-
 class XMLBindingTest < MiniTest::Spec
   module SongRepresenter
     include Representable::XML

data/test/xml_namespace_test.rb

@@ -0,0 +1,186 @@
+require "test_helper"
+
+# <lib:library
+#    xmlns:lib="http://eric.van-der-vlist.com/ns/library"
+#    xmlns:hr="http://eric.van-der-vlist.com/ns/person">
+#   <lib:book id="b0836217462" available="true">
+#    <lib:isbn>0836217462</lib:isbn>
+#    <lib:title xml:lang="en">Being a Dog Is a Full-Time Job</lib:title>
+#    <hr:author id="CMS">
+#     <hr:name>Charles M Schulz</hr:name>
+#     <hr:born>1922-11-26</hr:born>
+#     <hr:dead>2000-02-12</hr:dead>
+#    </hr:author>
+#    <lib:character id="PP">
+#     <hr:name>Peppermint Patty</hr:name>
+#     <hr:born>1966-08-22</hr:born>
+#     <lib:qualification>bold, brash and tomboyish</lib:qualification>
+#     </lib:character>
+#    <lib:character id="Snoopy">
+#     <hr:name>Snoopy</hr:name>
+#     <hr:born>1950-10-04</hr:born>
+#     <lib:qualification>extroverted beagle</lib:qualification>
+#    </lib:character>
+#    <lib:character id="Schroeder">
+#     <hr:name>Schroeder</hr:name>
+#     <hr:born>1951-05-30</hr:born>
+#     <lib:qualification>brought classical music to the Peanuts strip
+#                   </lib:qualification>
+#    </lib:character>
+#    <lib:character id="Lucy">
+#     <hr:name>Lucy</hr:name>
+#     <hr:born>1952-03-03</hr:born>
+#     <lib:qualification>bossy, crabby and selfish</lib:qualification>
+#    </lib:character>
+#   </lib:book>
+#  </lib:library>
+
+  # Theoretically, every property (scalar) needs/should have a namespace.
+  # property :name, namespace: "http://eric.van-der-vlist.com/ns/person"
+  # # This is implicit if contained:
+  # class Person < Decorator
+  #   namespace: "http://eric.van-der-vlist.com/ns/person"
+  #   property :name #, namespace: "http://eric.van-der-vlist.com/ns/person"
+  # end
+  # class Library
+  #   namespace "http://eric.van-der-vlist.com/ns/library"
+
+  #   namespace_def lib:    "http://eric.van-der-vlist.com/ns/library"
+  #   namespace_def person: "http://eric.van-der-vlist.com/ns/person"
+  #   # namespace_def person: Person
+
+  #   property :person, decorator: Person
+  # end
+class NamespaceXMLTest < Minitest::Spec
+  module Model
+    Library = Struct.new(:book)
+    Book = Struct.new(:id, :isbn)
+  end
+
+  let (:book) { Model::Book.new(1, 666) }
+
+  #:simple-class
+  class Library < Representable::Decorator
+    feature Representable::XML
+    feature Representable::XML::Namespace
+
+    namespace "http://eric.van-der-vlist.com/ns/library"
+
+    property :book do
+      namespace "http://eric.van-der-vlist.com/ns/library"
+
+      property :id,  attribute: true
+      property :isbn
+    end
+  end
+  #:simple-class end
+
+
+  # default namespace for library
+  it "what" do
+    Library.new(Model::Library.new(book)).to_xml.must_xml(
+
+    #:simple-xml
+    %{<library xmlns="http://eric.van-der-vlist.com/ns/library">
+      <book id="1">
+        <isbn>666</isbn>
+      </book>
+    </library>}
+    #:simple-xml end
+    )
+  end
+end
+
+class Namespace2XMLTest < Minitest::Spec
+  module Model
+    Library   = Struct.new(:book)
+    Book      = Struct.new(:id, :isbn, :author, :character)
+    Character = Struct.new(:name, :born, :qualification)
+  end
+
+  let (:book) { Model::Book.new(1, 666, Model::Character.new("Fowler"), [Model::Character.new("Frau Java", 1991, "typed")]) }
+
+  #:map-class
+  class Library < Representable::Decorator
+    feature Representable::XML
+    feature Representable::XML::Namespace
+
+    namespace "http://eric.van-der-vlist.com/ns/library"
+    namespace_def lib: "http://eric.van-der-vlist.com/ns/library"
+    namespace_def hr: "http://eric.van-der-vlist.com/ns/person"
+
+    property :book, class: Model::Book do
+      namespace "http://eric.van-der-vlist.com/ns/library"
+
+      property :id,  attribute: true
+      property :isbn
+
+      property :author, class: Model::Character do
+        namespace "http://eric.van-der-vlist.com/ns/person"
+
+        property :name
+        property :born
+      end
+
+      collection :character, class: Model::Character do
+        namespace "http://eric.van-der-vlist.com/ns/library"
+
+        property :qualification
+
+        property :name, namespace: "http://eric.van-der-vlist.com/ns/person"
+        property :born, namespace: "http://eric.van-der-vlist.com/ns/person"
+      end
+    end
+  end
+  #:map-class end
+
+  it "renders" do
+    Library.new(Model::Library.new(book)).to_xml.must_xml(
+#:map-xml
+%{<lib:library xmlns:lib=\"http://eric.van-der-vlist.com/ns/library\" xmlns:hr=\"http://eric.van-der-vlist.com/ns/person\">
+  <lib:book id=\"1\">
+    <lib:isbn>666</lib:isbn>
+    <hr:author>
+      <hr:name>Fowler</hr:name>
+    </hr:author>
+    <lib:character>
+      <lib:qualification>typed</lib:qualification>
+      <hr:name>Frau Java</hr:name>
+      <hr:born>1991</hr:born>
+    </lib:character>
+  </lib:book>
+</lib:library>}
+#:map-xml end
+    )
+  end
+
+  it "parses" do
+    lib  = Model::Library.new
+    #:parse-call
+    Library.new(lib).from_xml(%{<lib:library
+  xmlns:lib="http://eric.van-der-vlist.com/ns/library"
+  xmlns:hr="http://eric.van-der-vlist.com/ns/person">
+  <lib:book id="1">
+    <lib:isbn>666</lib:isbn>
+    <hr:author>
+      <hr:name>Fowler</hr:name>
+    </hr:author>
+    <lib:character>
+      <lib:qualification>typed</lib:qualification>
+      <hr:name>Frau Java</hr:name>
+      <bogus:name>Mr. Ruby</hr:name>
+      <name>Dr. Elixir</hr:name>
+      <hr:born>1991</hr:born>
+    </lib:character>
+  </lib:book>
+</lib:library>}
+    #:parse-call end
+    )
+
+    _(lib.book.inspect).must_equal %{#<struct Namespace2XMLTest::Model::Book id=\"1\", isbn=\"666\", author=#<struct Namespace2XMLTest::Model::Character name=\"Fowler\", born=nil, qualification=nil>, character=[#<struct Namespace2XMLTest::Model::Character name=\"Frau Java\", born=\"1991\", qualification=\"typed\">]>}
+
+    #:parse-res
+    lib.book.character[0].name #=> "Frau Java"
+    #:parse-res end
+  end
+end