representable 3.0.0 → 3.1.0

data/test/xml_test.rb

@@ -1,22 +1,41 @@
 require 'test_helper'
-require 'representable/xml'
 
-class Band
-  include Representable::XML
-  property :name
-  attr_accessor :name
 
-  def initialize(name=nil)
-    name and self.name = name
+class XmlPublicMethodsTest < Minitest::Spec
+  #---
+  # from_hash
+  class BandRepresenter < Representable::Decorator
+    include Representable::XML
+    property :id
+    property :name
   end
-end
 
-class Album
-  attr_accessor :songs
-end
+  let(:data) { %{<data><id>1</id><name>Rancid</name></data>} }
+
+  it { _(BandRepresenter.new(Band.new).from_xml(data)[:id, :name]).must_equal ["1", "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).parse(data)[:id, :name]).must_equal ["1", "Rancid"] }
 
+  #---
+  # to_hash
+  let(:band) { Band.new("1", "Rancid") }
+
+  it { BandRepresenter.new(band).to_xml.must_equal_xml data }
+  it { BandRepresenter.new(band).render.must_equal_xml data }
+end
 
 class XmlTest < MiniTest::Spec
+
+  class Band
+    include Representable::XML
+    property :name
+    attr_accessor :name
+
+    def initialize(name=nil)
+      name and self.name = name
+    end
+  end
+
+
   XML = Representable::XML
   Def = Representable::Definition
 
@@ -126,14 +145,12 @@ class XmlTest < MiniTest::Spec
       module SongRepresenter
         include Representable::XML
         property :name
-        representation_wrap = :song
       end
 
       module AlbumRepresenter
         include Representable::XML
         property :best_song, :class => Song, :extend => SongRepresenter
         collection :songs, :class => Song, :as => :song, :extend => SongRepresenter
-        representation_wrap = :album
       end
 
 
@@ -156,14 +173,15 @@ class XmlTest < MiniTest::Spec
       end
 
       it "extends contained models when serializing" do
-        @album = Album.new([Song.new("I Hate My Brain"), mr=Song.new("Mr. Charisma")], mr)
+        @album = Album.new(
+          [Song.new("I Hate My Brain"), mr=Song.new("Mr. Charisma")], mr)
         @album.extend(AlbumRepresenter)
 
-        assert_xml_equal "<album>
+        @album.to_xml.must_equal_xml "<album>
   <song><name>Mr. Charisma</name></song>
   <song><name>I Hate My Brain</name></song>
   <song><name>Mr. Charisma</name></song>
-</album>", @album.to_xml
+</album>"
       end
 
       it "extends contained models when deserializing" do
@@ -222,6 +240,16 @@ class CDataBand
 end
 
 class TypedPropertyTest < MiniTest::Spec
+  class Band
+    include Representable::XML
+    property :name
+    attr_accessor :name
+
+    def initialize(name=nil)
+      name and self.name = name
+    end
+  end
+
   module AlbumRepresenter
     include Representable::XML
     property :band, :class => Band
@@ -286,21 +314,54 @@ class TypedPropertyTest < MiniTest::Spec
   end
 end
 
+# TODO: add parsing tests.
+class XMLPropertyTest < Minitest::Spec
+  Band = Struct.new(:name, :genre)
+  Manager = Struct.new(:managed)
+
+  #---
+  #- :as with scalar
+  class BandRepresenter < Representable::Decorator
+    include Representable::XML
+    property :name, as: :theyCallUs
+    property :genre, attribute: true
+  end
+
+  it { BandRepresenter.new(Band.new("Mute")).to_xml.must_equal_xml %{<band><theyCallUs>Mute</theyCallUs></band>} }
+
+  class ManagerRepresenter < Representable::Decorator
+    include Representable::XML
+    property :managed, as: :band, decorator: BandRepresenter
+  end
 
-class CollectionTest < MiniTest::Spec
+  #- :as with nested property
+  it { ManagerRepresenter.new(Manager.new(Band.new("Mute", "Punkrock"))).to_xml.must_equal_xml %{<manager><band genre="Punkrock"><theyCallUs>Mute</theyCallUs></band></manager>} }
+end
+
+
+class XMLCollectionTest < MiniTest::Spec
+  Band        = Struct.new(:name)
+  Compilation = Struct.new(:bands)
+
+  class BandRepresenter < Representable::Decorator
+    include Representable::XML
+    property :name
+  end
+
+  #---
+  #- :as, :decorator, :class
   describe ":class => Band, :as => :band, :collection => true" do
-    class Compilation
+    class CompilationRepresenter < Representable::Decorator
       include Representable::XML
-      collection :bands, :class => Band, :as => :band
-      attr_accessor :bands
+      collection :bands, class: Band, as: :group, decorator: BandRepresenter
     end
 
     describe "#from_xml" do
       it "pushes collection items to array" do
-        cd = Compilation.new.from_xml(%{
+        cd = CompilationRepresenter.new(Compilation.new).from_xml(%{
           <compilation>
-            <band><name>Diesel Boy</name></band>
-            <band><name>Cobra Skulls</name></band>
+            <group><name>Diesel Boy</name></group>
+            <group><name>Cobra Skulls</name></group>
           </compilation>
         })
         assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
@@ -308,13 +369,12 @@ class CollectionTest < MiniTest::Spec
     end
 
     it "responds to #to_xml" do
-      cd = Compilation.new
-      cd.bands = [Band.new("Diesel Boy"), Band.new("Bad Religion")]
+      cd = Compilation.new([Band.new("Diesel Boy"), Band.new("Bad Religion")])
 
-      assert_xml_equal %{<compilation>
-        <band><name>Diesel Boy</name></band>
-        <band><name>Bad Religion</name></band>
-      </compilation>}, cd.to_xml
+      CompilationRepresenter.new(cd).to_xml.must_equal_xml %{<compilation>
+        <group><name>Diesel Boy</name></group>
+        <group><name>Bad Religion</name></group>
+      </compilation>}
     end
   end
 
@@ -340,8 +400,8 @@ class CollectionTest < MiniTest::Spec
 
 
   describe ":wrap" do
-    let (:album) { Album.new.extend(xml_doc) }
-    let (:xml_doc) {
+    let(:album) { Album.new.extend(xml_doc) }
+    let(:xml_doc) {
       Module.new do
         include Representable::XML
         collection :songs, :as => :song, :wrap => :songs
@@ -387,7 +447,7 @@ class CollectionTest < MiniTest::Spec
       self.representation_wrap = :song
     end
 
-    let (:decorator) { rpr = representer; Class.new(Representable::Decorator) { include Representable::XML; include rpr } }
+    let(:decorator) { rpr = representer; Class.new(Representable::Decorator) { include Representable::XML; include rpr } }
 
     describe "XML::Collection" do
       describe "with contained objects" do
@@ -396,8 +456,8 @@ class CollectionTest < MiniTest::Spec
           self.representation_wrap= :songs
         end
 
-        let (:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
-        let (:xml_doc)   { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
+        let(:songs) { [Song.new("Days Go By"), Song.new("Can't Take Them All")] }
+        let(:xml_doc)   { "<songs><song><name>Days Go By</name></song><song><name>Can't Take Them All</name></song></songs>" }
 
         it "renders array" do
           songs.extend(representer).to_xml.must_equal_xml xml_doc
@@ -408,11 +468,11 @@ class CollectionTest < MiniTest::Spec
         end
 
         it "parses array" do
-          [].extend(representer).from_xml(xml_doc).must_equal songs
+          _([].extend(representer).from_xml(xml_doc)).must_equal songs
         end
 
         it "parses array with decorator" do
-          decorator.new([]).from_xml(xml_doc).must_equal songs
+          _(decorator.new([]).from_xml(xml_doc)).must_equal songs
         end
       end
     end
@@ -422,8 +482,8 @@ class CollectionTest < MiniTest::Spec
         self.representation_wrap= :songs
       end
 
-      let (:songs) { {"one" => "Graveyards", "two" => "Can't Take Them All"} }
-      let (:xml_doc)   { "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
+      let(:songs) { {"one" => "Graveyards", "two" => "Can't Take Them All"} }
+      let(:xml_doc)   { "<favs one=\"Graveyards\" two=\"Can't Take Them All\" />" }
 
       describe "#to_xml" do
         it "renders hash" do
@@ -445,7 +505,7 @@ class CollectionTest < MiniTest::Spec
 
       describe "#from_json" do
         it "returns hash" do
-          {}.extend(representer).from_xml(xml_doc).must_equal songs
+          _({}.extend(representer).from_xml(xml_doc)).must_equal songs
         end
 
         it "respects :exclude" do
@@ -457,7 +517,7 @@ class CollectionTest < MiniTest::Spec
         end
 
         it "parses hash with decorator" do
-          decorator.new({}).from_xml(xml_doc).must_equal songs
+          _(decorator.new({}).from_xml(xml_doc)).must_equal songs
         end
       end
     end
@@ -471,7 +531,7 @@ class XmlHashTest < MiniTest::Spec
       hash :songs
     end
 
-    let (:doc) { "<open_struct><first>The Gargoyle</first><second>Bronx</second></open_struct>" }
+    let(:doc) { "<open_struct><first>The Gargoyle</first><second>Bronx</second></open_struct>" }
 
     # to_xml
     it { OpenStruct.new(songs: {"first" => "The Gargoyle", "second" => "Bronx"}).extend(representer).to_xml.must_equal_xml(doc) }
@@ -486,7 +546,7 @@ class XmlHashTest < MiniTest::Spec
       end
     end
 
-    let (:doc) { "<open_struct>
+    let(:doc) { "<open_struct>
   <open_struct>
     <title>The Gargoyle</title>
   </open_struct>
@@ -500,4 +560,4 @@ class XmlHashTest < MiniTest::Spec
     # FIXME: this NEVER worked!
     # it { OpenStruct.new.extend(representer).from_xml(doc).songs.must_equal({"first" => "The Gargoyle", "second" => "Bronx"}) }
   end
-end
+end

data/test/yaml_test.rb

@@ -1,10 +1,35 @@
 require 'test_helper'
 
+class YamlPublicMethodsTest < Minitest::Spec
+  #---
+  # from_yaml
+  class BandRepresenter < Representable::Decorator
+    include Representable::YAML
+    property :id
+    property :name
+  end
+
+  let(:data) { %{---
+id: 1
+name: Rancid
+} }
+
+  it { _(BandRepresenter.new(Band.new).from_yaml(data)[:id, :name]).must_equal [1, "Rancid"] }
+  it { _(BandRepresenter.new(Band.new).parse(data)[:id, :name]).must_equal [1, "Rancid"] }
+
+  #---
+  # to_yaml
+  let(:band) { Band.new("1", "Rancid") }
+
+  it { _(BandRepresenter.new(band).to_yaml).must_equal data }
+  it { _(BandRepresenter.new(band).render).must_equal data }
+end
+
 class YamlTest < MiniTest::Spec
   def self.yaml_representer(&block)
     Module.new do
       include Representable::YAML
-      instance_exec &block
+      instance_exec(&block)
     end
   end
 
@@ -14,22 +39,22 @@ class YamlTest < MiniTest::Spec
 
 
   describe "property" do
-    let (:yaml) { yaml_representer do property :best_song end }
+    let(:yaml) { yaml_representer do property :best_song end }
 
-    let (:album) { Album.new.tap do |album|
+    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(
+        _(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(
+        _(Album.new.tap { |a| a.best_song = 8675309 }.extend(yaml).to_yaml).must_equal(
 "---
 best_song: 8675309
 "
@@ -40,29 +65,29 @@ best_song: 8675309
 
     describe "#from_yaml" do
       it "parses plain property" do
-        album.extend(yaml).from_yaml(
+        _(album.extend(yaml).from_yaml(
 "---
 best_song: This Song Is Recycled
-").best_song.must_equal "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
+      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|
+      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 "---
+          _(album.extend(yaml_album).to_yaml).must_equal "---
 best_song:
   name: Liar
 "
@@ -71,10 +96,10 @@ best_song:
 
       describe "#from_yaml" do
         it "parses embedded typed property" do
-          album.extend(yaml_album).from_yaml("---
+          _(album.extend(yaml_album).from_yaml("---
 best_song:
   name: Go With Me
-").must_equal Album.new(nil,Song.new("Go With Me"))
+")).must_equal Album.new(nil,Song.new("Go With Me"))
         end
       end
     end
@@ -82,16 +107,16 @@ best_song:
 
 
   describe "collection" do
-    let (:yaml) { yaml_representer do collection :songs end }
+    let(:yaml) { yaml_representer do collection :songs end }
 
-    let (:album) { Album.new.tap do |album|
+    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 "---
+        _(album.extend(yaml).to_yaml).must_equal "---
 songs:
 - Jackhammer
 - Terrible Man
@@ -100,7 +125,7 @@ songs:
 
       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 "---
+        _(album.extend(yaml).to_yaml).must_equal "---
 songs: [Jackhammer, Terrible Man]
 "
       end
@@ -109,22 +134,22 @@ songs: [Jackhammer, Terrible Man]
 
     describe "#from_yaml" do
       it "parses a block style list" do
-        album.extend(yaml).from_yaml("---
+        _(album.extend(yaml).from_yaml("---
 songs:
 - Off Key Melody
-- Sinking").must_equal Album.new(["Off Key Melody", "Sinking"])
+- 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"])
+        _(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
+      let(:yaml_album) { Module.new do
         include Representable::YAML
         collection :songs, :class => Song do
           property :name
@@ -132,12 +157,12 @@ songs: [Off Key Melody, Sinking]").must_equal Album.new(["Off Key Melody", "Sink
         end
       end }
 
-      let (:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
+      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 "---
+          _(album.extend(yaml_album).to_yaml).must_equal "---
 songs:
 - name: Liar
   track: 1
@@ -149,14 +174,14 @@ songs:
 
       describe "#from_yaml" do
         it "parses collection of typed property" do
-          album.extend(yaml_album).from_yaml("---
+          _(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)])
+  track: 5")).must_equal Album.new([Song.new("One Shot Deal", 4), Song.new("Three Way Dance", 5)])
         end
       end
     end
   end
-end
+end