representable 2.2.3 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 700ffc8c90d1f0c6b824d39a42b8af702967f2f2
-  data.tar.gz: e593985cdb6e362606b6d4dce794f5b6b4c7af50
+  metadata.gz: 304ec8f66cc93beff15aba84d2d4b5d5214fa5d1
+  data.tar.gz: 83a928ef451bd032509abb6c41d8ababda744a97
 SHA512:
-  metadata.gz: fb0bd53d3eb6750f5ec6e238eec0335566088a9a8f2ab18482c693e3949213d97bd8873b9a0076fa174f70ad96c6db70ad0233198e1fa84c60fb3e4354e3065a
-  data.tar.gz: daa85190ef4bdc5f93f79c161e8443df77d02bfd095231cd3bc2bd5bf4ddfc347c4210b210bea2b2e29717ee088e1ecb825360fc55ec6bd299e9a893e62d33e0
+  metadata.gz: 5eb021bc55145ff44e467db742d2842c8971413b44f084df9046f9eb6ee66e5250fa523fae0f8d0f3f0f3938c2e38339ca08876bcd04f6fb291ab8fb4368b0b7
+  data.tar.gz: fc426cbb854f6aef32a99b5bdec3e0f364176cf9ece0d35f19c43200434db12a2d8f545430f139cc8f452baf3598183ba8bd1ab53b6ce6d944512a5ac31c1fa5

data/.travis.yml

@@ -1,5 +1,5 @@
 notifications:
-  irc: "irc.freenode.org#cells"
+  # irc: "irc.freenode.org#cells"
 matrix:
   include:
     - rvm: 1.9.3

data/CHANGES.md

@@ -1,3 +1,31 @@
+# 2.3.0
+
+* Remove dependency to Nokogiri and Multi_JSON. You have to add what you need to your `Gemfile`/`gemspec` now.
+* `to_*`/`from_*` with options do no longer change the hash but work on copies.
+* `to_*`/`from_*` now respect `wrap: false`. This will suppress the wrapping on the first level.
+* Introduce `property "name", wrap: false`. This allows reusing existing representers with `representation_wrap` set as nested representers but suppressing the wrapping.
+
+    ```ruby
+    class BandDecorator < Representable::Decorator
+      include Representable::Hash
+      self.representation_wrap = :bands # wrap set!
+
+      property :name
+    end
+
+    class AlbumDecorator < Representable::Decorator
+      include Representable::Hash
+      self.representation_wrap = :albums # wrap set!
+
+      property :band, decorator: BandDecorator, wrap: false # you can now set :wrap to false!
+    end
+
+    album.to_hash #=> {"albums" => {"band" => {"name"=>"Social Distortion"}}}
+    ```
+
+    Thanks to @fighella for inspiring this feature when working on [roarify](https://github.com/fighella/roarify).
+* `from_hash` no longer crashes with "NoMethodError: undefined method 'has_key?' for nil:NilClass" when an incoming nested object's value is `nil`. This was a problem with documents like `{song: nil}` where `song` is a nested property. Thanks to @mhuggins and @moxley for helping here.
+
 # 2.2.3
 
 * Introduce `Decorator::clone` to make sure cloning properly copies representable_attrs. in former versions, this would partially share definitions with subclasses when the decorator was an `inheritable_attr`.

data/Gemfile

@@ -7,3 +7,8 @@ platform :rbx do
   gem "rubysl-irb"
   gem "json_pure"
 end
+
+group :test do
+  gem "nokogiri", require: false
+  gem "multi_json", require: false
+end

data/README.md

@@ -15,6 +15,23 @@ The representable gem runs with all Ruby versions >= 1.9.3.
 gem 'representable'
 ```
 
+### Dependencies
+
+Representable does a great job with JSON, it also features support for XML, YAML and pure ruby
+hashes. But Representable did not bundle dependencies for JSON and XML.
+
+If you want to use JSON, add the following to your Gemfile:
+
+```ruby
+gem 'multi_json'
+```
+
+If you want to use XML, add the following to your Gemfile:
+
+```ruby
+gem 'nokogiri'
+```
+
 ## Example
 
 What if we're writing an API for music - songs, albums, bands.
@@ -176,6 +193,37 @@ Album.new.extend(AlbumRepresenter).
 #=> #<Album name="Offspring", songs=[#<Song title="Genocide">, #<Song title="Nitro", composers=["Offspring"]>]>
 ```
 
+## Suppressing Nested Wraps
+
+When reusing a representer for a nested document, you might want to suppress the wrap for the nested fragment.
+
+```ruby
+module SongRepresenter
+  include Representable::JSON
+
+  self.representation_wrap = :songs
+  property :title
+end
+```
+
+When reusing `SongRepresenter` in a nested setup you can suppress the wrapping using the `:wrap` option.
+
+```ruby
+module AlbumRepresenter
+  include Representable::JSON
+
+  collection :songs, extend: SongRepresenter, wrap: false
+end
+```
+
+The `representation_wrap` from the nested representer now won't be rendered and parsed.
+
+```ruby
+album.extend(AlbumRepresenter).to_json #=> "{\"songs\": [{\"name\": \"Roxanne\"}]}"
+```
+
+Note that this only works for JSON and Hash at the moment.
+
 
 ## Parse Strategies
 

data/lib/representable.rb

@@ -14,8 +14,8 @@ require "representable/serializer"
 require "representable/cached"
 
 
-require 'uber/callable'
-require 'representable/pipeline'
+require "uber/callable"
+require "representable/pipeline"
 
 module Representable
   attr_writer :representable_attrs
@@ -36,16 +36,16 @@ module Representable
 private
   # Reads values from +doc+ and sets properties accordingly.
   def update_properties_from(doc, options, format)
-    private_options = normalize_options!(options)
+    propagated_options, private_options = normalize_options!(options)
 
-    representable_mapper(format, options).deserialize(represented, doc, options, private_options)
+    representable_mapper(format, propagated_options).deserialize(represented, doc, propagated_options, private_options)
   end
 
   # Compiles the document going through all properties.
   def create_representation_with(doc, options, format)
-    private_options = normalize_options!(options)
+    propagated_options, private_options = normalize_options!(options)
 
-    representable_mapper(format, options).serialize(represented, doc, options, private_options)
+    representable_mapper(format, propagated_options).serialize(represented, doc, propagated_options, private_options)
   end
 
   def representable_bindings_for(format, options)
@@ -56,13 +56,20 @@ private
     format.build(definition, self)
   end
 
+  # Make sure we do not change original options. However, private options like :include or :wrap are
+  # not passed on to child representers.
   def normalize_options!(options)
-    # TODO: ideally, private_options would be nil if none set or so, so we could save a lot of time in nested objects.
+    # here, we could also filter out local options e.g. like options[:band].
     private_options = {}
-    # return private_options if options.size == 0
-    private_options[:include] = options.delete(:include) if options[:include]
-    private_options[:exclude] = options.delete(:exclude) if options[:exclude]
-    private_options
+    return [options, private_options] if options.size == 0
+
+    propagated_options = options.dup
+
+    private_options[:include] = propagated_options.delete(:include) if options[:include]
+    private_options[:exclude] = propagated_options.delete(:exclude) if options[:exclude]
+    propagated_options.delete(:wrap) # FIXME.
+
+    [propagated_options, private_options]
   end
 
   def representable_attrs

data/lib/representable/binding.rb

@@ -44,6 +44,9 @@ module Representable
       @as ||= evaluate_option(:as)
     end
 
+    # Single entry points for rendering and parsing a property are #compile_fragment
+    # and #uncompile_fragment in Mapper.
+    #
     # DISCUSS:
     # currently, we need to call B#update! before compile_fragment/uncompile_fragment.
     # this will change to B#renderer(represented, options).call
@@ -146,15 +149,23 @@ module Representable
 
     # Note: this method is experimental.
     def update!(represented, user_options)
-      @represented      = represented
-      @user_options     = user_options
+      @represented = represented
 
+      setup_user_options!(user_options)
       setup_exec_context!
     end
 
     attr_accessor :cached_representer
 
   private
+    def setup_user_options!(user_options)
+      @user_options  = user_options
+      # this is the propagated_options.
+      @user_options  = user_options.merge(wrap: false) if self[:wrap] == false
+
+      # @user_options  = user_options.merge(wrap: self[:wrap]) if self[:wrap]
+    end
+
     #   1.80      0.066     0.027     0.000     0.039    30002   Representable::Binding#setup_exec_context!
     #   0.98      0.034     0.014     0.000     0.020    30002   Representable::Binding#setup_exec_context!
     def setup_exec_context!

data/lib/representable/config.rb

@@ -88,10 +88,6 @@ module Representable
       value
     end
 
-    # def binding_cache
-    #   @binding_cache ||= {}
-    # end
-
   private
     def infer_name_for(name)
       name.to_s.split('::').last.

data/lib/representable/decorator.rb

@@ -2,6 +2,10 @@ require "representable"
 
 module Representable
   class Decorator
+    class << self
+      include Cloneable
+    end
+
     attr_reader :represented
     alias_method :decorated, :represented
 

data/lib/representable/definition.rb

@@ -10,7 +10,6 @@ module Representable
     alias_method :getter, :name
 
     def initialize(sym, options={}, &block)
-      @options = {}
       @options = Cloneable::Hash.new # allows deep cloning. we then had to set Pipeline cloneable.
       @name    = sym.to_s
       options  = options.clone

data/lib/representable/deserializer.rb

@@ -15,6 +15,7 @@ module Representable
 
     def call(fragment, *args) # FIXME: args is always i.
       return fragment unless @binding.typed? # customize with :extend. this is not really straight-forward.
+      return fragment if fragment.nil?
 
       # what if create_object is responsible for providing the deserialize-to object?
       object        = create_object(fragment, *args) # customize with :instance and :class.

data/lib/representable/hash.rb

@@ -22,9 +22,6 @@ module Representable
     end
 
 
-    # Note: `#from_hash` still does _not_ stringify incoming hashes. This is per design: Representable is not made for hashes, only,
-    # but for any arbitrary data structure. A generic `key.to_s` with non-hash data would result in weird issues.
-    # I decided it's more predictable to require the user to provide stringified keys.
     def from_hash(data, options={}, binding_builder=Binding)
       data = filter_wrap(data, options)
 
@@ -34,6 +31,7 @@ module Representable
     def to_hash(options={}, binding_builder=Binding)
       hash = create_representation_with({}, options, binding_builder)
 
+      return hash if options[:wrap] == false # TODO: same for parse.
       return hash unless wrap = options[:wrap] || representation_wrap(options)
 
       {wrap => hash}
@@ -41,6 +39,7 @@ module Representable
 
   private
     def filter_wrap(data, options)
+      return data if options[:wrap] == false
       return data unless wrap = options[:wrap] || representation_wrap(options)
       filter_wrap_for(data, wrap)
     end

data/lib/representable/hash/binding.rb

@@ -11,7 +11,7 @@ module Representable
       end
 
       def read(hash)
-        return FragmentNotFound unless hash.has_key?(as) # DISCUSS: put it all in #read for performance. not really sure if i like returning that special thing.
+        return FragmentNotFound unless hash.has_key?(as)
 
         hash[as] # fragment
       end

data/lib/representable/json.rb

@@ -1,7 +1,12 @@
-require 'multi_json'
 require 'representable/hash'
 require 'representable/json/collection'
 
+begin
+  require 'multi_json'
+rescue LoadError => _
+  abort "Missing dependency 'multi_json' for Representable::JSON. See dependencies section in README.md for details."
+end
+
 module Representable
   # Brings #to_json and #from_json to your object.
   module JSON

data/lib/representable/populator.rb

@@ -18,7 +18,7 @@ module Representable
         value = @binding[:default]
       else
         # DISCUSS: should we return a Skip object instead of this block trick? (same in Binding#serialize?)
-        value = deserialize(fragment) { return } # stop here if skip_parse?
+        value = deserialize(fragment) { return } # stop here if skip_parse.
       end
 
       value = @binding.parse_filter(value, doc)

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "2.2.3"
+  VERSION = "2.3.0"
 end

data/lib/representable/xml.rb

@@ -1,7 +1,12 @@
 require 'representable'
 require 'representable/xml/binding'
 require 'representable/xml/collection'
-require 'nokogiri'
+
+begin
+  require 'nokogiri'
+rescue LoadError => _
+  abort "Missing dependency 'nokogiri' for Representable::XML. See dependencies section in README.md for details."
+end
 
 module Representable
   module XML

data/representable.gemspec

@@ -20,8 +20,6 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.license       = "MIT"
 
-  s.add_dependency "nokogiri"
-  s.add_dependency "multi_json"
   s.add_dependency "uber", "~> 0.0.7"
 
   s.add_development_dependency "rake"

data/test/as_test.rb

@@ -40,4 +40,26 @@ class AsTest < MiniTest::Spec
       it { parse(song, {"[{:volume=>1}]" => "Wie Es Geht"}, :volume => 1).name.must_equal "Wie Es Geht" }
     end
   end
+end
+
+
+# hash: to_hash(wrap: ) is representation_wrap
+
+class AsXmlTest < MiniTest::Spec
+  Band  = Struct.new(:name, :label)
+  Album = Struct.new(:band)
+  Label = Struct.new(:name)
+
+  representer!(module: Representable::XML, decorator: true) do
+    self.representation_wrap = :album
+    property :band, as: :combo do
+      self.representation_wrap = :band
+      property :name
+    end
+  end
+
+  it do
+    skip
+    representer.new(Album.new(Band.new("Offspring"))).to_xml.must_equal ""
+  end
 end

data/test/config/inherit_test.rb

@@ -24,9 +24,12 @@ class ConfigInheritTest < MiniTest::Spec
   # in Decorator ------------------------------------------------
   class Decorator < Representable::Decorator
     property :title
+    property :artist do
+      property :id
+    end
   end
 
-  it { Decorator.representable_attrs[:definitions].keys.must_equal ["title"] }
+  it { Decorator.representable_attrs[:definitions].keys.must_equal ["title", "artist"] }
 
   # in inheriting Decorator
 
@@ -34,8 +37,11 @@ class ConfigInheritTest < MiniTest::Spec
     property :location
   end
 
-  it { InheritingDecorator.representable_attrs[:definitions].keys.must_equal ["title", "location"] }
+  it { InheritingDecorator.representable_attrs[:definitions].keys.must_equal ["title", "artist", "location"] }
   it { assert_cloned(InheritingDecorator, Decorator, "title") }
+  it do
+    InheritingDecorator.representable_attrs.get(:artist).representer_module.object_id.wont_equal Decorator.representable_attrs.get(:artist).representer_module.object_id
+  end
 
   # in inheriting and including Decorator
 
@@ -44,7 +50,7 @@ class ConfigInheritTest < MiniTest::Spec
     property :location
   end
 
-  it { InheritingAndIncludingDecorator.representable_attrs[:definitions].keys.must_equal ["title", "genre", "location"] }
+  it { InheritingAndIncludingDecorator.representable_attrs[:definitions].keys.must_equal ["title", "artist", "genre", "location"] }
   it { assert_cloned(InheritingAndIncludingDecorator, GenreModule, :genre) }
 
 

data/test/hash_test.rb

@@ -1,149 +1,160 @@
 require 'test_helper'
 
-class HashTest < MiniTest::Spec
-  def self.hash_representer(&block)
-    Module.new do
-      include Representable::Hash
-      instance_exec &block
+class HashWithScalarPropertyTest < MiniTest::Spec
+  Album = Struct.new(:title)
+
+  representer! do
+    property :title
+  end
+
+  let (:album) { Album.new("Liar") }
+
+  describe "#to_hash" do
+    it "renders plain property" do
+      album.extend(representer).to_hash.must_equal("title" => "Liar")
     end
   end
 
-  def hash_representer(&block)
-    self.class.hash_representer(&block)
+
+  describe "#from_hash" do
+    it "parses plain property" do
+      album.extend(representer).from_hash("title" => "This Song Is Recycled").title.must_equal "This Song Is Recycled"
+    end
+
+    # Fixes issue #115
+    it "allows nil value in the incoming document and corresponding nil value for the represented" do
+      album = Album.new
+      album.title.must_equal nil
+      album.extend(representer).from_hash("title" => nil)
+    end
   end
+end
+
 
+class HashWithTypedPropertyTest < MiniTest::Spec
+  Album = Struct.new(:best_song)
 
-  describe "property" do
-    let (:hsh) { hash_representer do property :best_song end }
+  representer! do
+    property :best_song, :class => Song do
+      property :name
+    end
+  end
 
-    let (:album) { Album.new.tap do |album|
-      album.best_song = "Liar"
-    end }
+  let (:album) { Album.new(Song.new("Liar")) }
 
-    describe "#to_hash" do
-      it "renders plain property" do
-        album.extend(hsh).to_hash.must_equal("best_song" => "Liar")
-      end
+  describe "#to_hash" do
+    it "renders embedded typed property" do
+      album.extend(representer).to_hash.must_equal("best_song" => {"name" => "Liar"})
     end
+  end
 
+  describe "#from_hash" do
+    it "parses embedded typed property" do
+      album.extend(representer).from_hash("best_song" => {"name" => "Go With Me"})
+      album.best_song.name.must_equal "Go With Me"
+    end
 
-    describe "#from_hash" do
-      it "parses plain property" do
-        album.extend(hsh).from_hash("best_song" => "This Song Is Recycled").best_song.must_equal "This Song Is Recycled"
-      end
+    # nested nil removes nested object.
+    it do
+      album = Album.new(Song.new("Pre-medicated Murder"))
+      album.extend(representer).from_hash("best_song" => nil)
+      album.best_song.must_equal nil
     end
 
+    # nested blank hash creates blank object when not populated.
+    it do
+      album = Album.new#(Song.new("Pre-medicated Murder"))
+      album.extend(representer).from_hash("best_song" => {})
+      album.best_song.name.must_equal nil
+    end
 
-    describe "with :class and :extend" do
-      hash_song = hash_representer do property :name end
-      let (:hash_album) { Module.new do
-        include Representable::Hash
-        property :best_song, :extend => hash_song, :class => Song
-      end }
+    # Fixes issue #115
+    it "allows nil value in the incoming document and corresponding nil value for the represented" do
+      album = Album.new
+      album.extend(representer).from_hash("best_song" => nil)
+      album.best_song.must_equal nil
+    end
+  end
+end
 
-      let (:album) { Album.new.tap do |album|
-        album.best_song = Song.new("Liar")
-      end }
+# TODO: move to AsTest.
+class HashWithTypedPropertyAndAs < MiniTest::Spec
+  representer! do
+    property :song, :class => Song, :as => :hit do
+      property :name
+    end
+  end
 
+  let (:album) { OpenStruct.new(:song => Song.new("Liar")).extend(representer) }
 
-      describe "#to_hash" do
-        it "renders embedded typed property" do
-          album.extend(hash_album).to_hash.must_equal("best_song" => {"name" => "Liar"})
-        end
-      end
+  it { album.to_hash.must_equal("hit" => {"name" => "Liar"}) }
+  it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
+end
+  #   # describe "FIXME COMBINE WITH ABOVE with :extend and :as" do
+  #   #   hash_song = Module.new do
+  #   #     include Representable::XML
+  #   #     self.representation_wrap = :song
+  #   #     property :name
+  #   #   end
 
-      describe "#from_hash" do
-        it "parses embedded typed property" do
-          album.extend(hash_album).from_hash("best_song" => {"name" => "Go With Me"}).must_equal Album.new(nil,Song.new("Go With Me"))
-        end
-      end
-    end
+  #   #   let (:hash_album) { Module.new do
+  #   #     include Representable::XML
+  #   #     self.representation_wrap = :album
+  #   #     property :song, :extend => hash_song, :class => Song, :as => :hit
+  #   #   end }
+
+  #   #   let (:album) { OpenStruct.new(:song => Song.new("Liar")).extend(hash_album) }
 
+  #   #   it { album.to_xml.must_equal_xml("<album><hit><name>Liar</name></hit></album>") }
+  #   #   #it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
+  #   # end
+  # end
 
-    describe "with :extend and :as" do
-      hash_song = hash_representer do property :name end
 
-      let (:hash_album) { Module.new do
-        include Representable::Hash
-        property :song, :extend => hash_song, :class => Song, :as => :hit
-      end }
 
-      let (:album) { OpenStruct.new(:song => Song.new("Liar")).extend(hash_album) }
+class HashWithTypedCollectionTest < MiniTest::Spec
+  Album = Struct.new(:songs)
 
-      it { album.to_hash.must_equal("hit" => {"name" => "Liar"}) }
-      it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
+  representer! do
+    collection :songs, class: Song do
+      property :name
+      property :track
     end
-    # describe "FIXME COMBINE WITH ABOVE with :extend and :as" do
-    #   hash_song = Module.new do
-    #     include Representable::XML
-    #     self.representation_wrap = :song
-    #     property :name
-    #   end
-
-    #   let (:hash_album) { Module.new do
-    #     include Representable::XML
-    #     self.representation_wrap = :album
-    #     property :song, :extend => hash_song, :class => Song, :as => :hit
-    #   end }
-
-    #   let (:album) { OpenStruct.new(:song => Song.new("Liar")).extend(hash_album) }
-
-    #   it { album.to_xml.must_equal_xml("<album><hit><name>Liar</name></hit></album>") }
-    #   #it { album.from_hash("hit" => {"name" => "Go With Me"}).must_equal OpenStruct.new(:song => Song.new("Go With Me")) }
-    # end
   end
 
+  let (:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
 
-  describe "collection" do
-    let (:hsh) { hash_representer do collection :songs end }
-
-    let (:album) { Album.new.tap do |album|
-      album.songs = ["Jackhammer", "Terrible Man"]
-    end }
-
+  describe "#to_hash" do
+    it "renders collection of typed property" do
+      album.extend(representer).to_hash.must_equal("songs" => [{"name" => "Liar", "track" => 1}, {"name" => "What I Know", "track" => 2}])
+    end
+  end
 
-    describe "#to_hash" do
-      it "renders a block style list per default" do
-        album.extend(hsh).to_hash.must_equal("songs" => ["Jackhammer", "Terrible Man"])
-      end
+  describe "#from_hash" do
+    it "parses collection of typed property" do
+      album.extend(representer).from_hash("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
+
+class HashWithScalarCollectionTest < MiniTest::Spec
+  Album = Struct.new(:songs)
+  representer! { collection :songs }
 
+  let (:album) { Album.new(["Jackhammer", "Terrible Man"]) }
 
-    describe "#from_hash" do
-      it "parses a block style list" do
-        album.extend(hsh).from_hash("songs" => ["Off Key Melody", "Sinking"]).must_equal Album.new(["Off Key Melody", "Sinking"])
 
-      end
+  describe "#to_hash" do
+    it "renders a block style list per default" do
+      album.extend(representer).to_hash.must_equal("songs" => ["Jackhammer", "Terrible Man"])
     end
+  end
 
 
-    describe "with :class and :extend" do
-      hash_song = hash_representer do
-        property :name
-        property :track
-      end
-      let (:hash_album) { Module.new do
-        include Representable::Hash
-        collection :songs, :extend => hash_song, :class => Song
-      end }
-
-      let (:album) { Album.new.tap do |album|
-        album.songs = [Song.new("Liar", 1), Song.new("What I Know", 2)]
-      end }
-
-
-      describe "#to_hash" do
-        it "renders collection of typed property" do
-          album.extend(hash_album).to_hash.must_equal("songs" => [{"name" => "Liar", "track" => 1}, {"name" => "What I Know", "track" => 2}])
-        end
-      end
-
-      describe "#from_hash" do
-        it "parses collection of typed property" do
-          album.extend(hash_album).from_hash("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
+  describe "#from_hash" do
+    it "parses a block style list" do
+      album.extend(representer).from_hash("songs" => ["Off Key Melody", "Sinking"]).must_equal Album.new(["Off Key Melody", "Sinking"])
     end
   end
 end

data/test/private_options_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+class PrivateOptionsTest < MiniTest::Spec # TODO: move me to separate file.
+  representer!(decorator: true) do
+  end
+
+  options = {exclude: "name"}
+
+  it "render: doesn't modify options" do
+    representer.new(nil).to_hash(options)
+    options.must_equal({exclude: "name"})
+  end
+
+  it "parse: doesn't modify options" do
+    representer.new(nil).from_hash(options)
+    options.must_equal({exclude: "name"})
+  end
+end

data/test/representable_test.rb

@@ -193,13 +193,22 @@ class RepresentableTest < MiniTest::Spec
     end
   end
 
+  class Hometown
+    attr_accessor :name
+  end
+
+  module HometownRepresentable
+    include Representable::JSON
+    property :name
+  end
 
   # DISCUSS: i don't like the JSON requirement here, what about some generic test module?
   class PopBand
     include Representable::JSON
     property :name
     property :groupies
-    attr_accessor :name, :groupies
+    property :hometown, class: Hometown, extend: HometownRepresentable
+    attr_accessor :name, :groupies, :hometown
   end
 
   describe "#update_properties_from" do
@@ -249,6 +258,7 @@ class RepresentableTest < MiniTest::Spec
       @band.from_hash({})
     end
 
+
     # FIXME: do we need this test with XML _and_ JSON?
     it "ignores (no-default) properties not present in the incoming document" do
       { Representable::Hash => [:from_hash, {}],

data/test/wrap_test.rb

@@ -46,3 +46,107 @@ class WrapTest < MiniTest::Spec
     end
   end
 end
+
+
+class HashDisableWrapTest < MiniTest::Spec
+  Band  = Struct.new(:name, :label)
+  Album = Struct.new(:band)
+  Label = Struct.new(:name)
+
+  class BandDecorator < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = :bands
+    property :name
+
+    property :label do # this should have a wrap!
+      self.representation_wrap = :important
+      property :name
+    end
+  end
+
+  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"})
+  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"
+  end
+
+
+  class AlbumDecorator < Representable::Decorator
+    include Representable::Hash
+
+    self.representation_wrap = :albums
+
+    property :band, decorator: BandDecorator, wrap: false, class: Band
+  end
+
+
+  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 "renders" do
+    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"
+  end
+end
+
+
+class XMLDisableWrapTest < MiniTest::Spec
+  Band  = Struct.new(:name, :label)
+  Album = Struct.new(:band)
+  Label = Struct.new(:name)
+
+  class BandDecorator < Representable::Decorator
+    include Representable::XML
+
+    self.representation_wrap = :bands # when nested, it uses this.
+    property :name
+
+    # property :label do # this should have a wrap!
+    #   self.representation_wrap = :important
+    #   property :name
+    # end
+  end
+
+  let (:band) { BandDecorator.prepare(Band.new("Social Distortion")) }
+
+  it do
+    band.to_xml.must_equal_xml "<bands><name>Social Distortion</name></bands>"
+    band.to_xml(wrap: "combo").must_equal_xml "<combo><name>Social Distortion</name></combo>"
+  end
+
+
+  class AlbumDecorator < Representable::Decorator
+    include Representable::XML
+
+    self.representation_wrap = :albums
+
+    property :band, decorator: BandDecorator, wrap: "po", class: Band
+  end
+
+
+  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"}}}}})
+  end
+
+  # it "parses" do
+  #   album.from_hash({"albums" => {"band" => {"name"=>"Rvivr"}}}).band.name.must_equal "Rvivr"
+  # end
+end
+

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: representable
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 2.3.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-20 00:00:00.000000000 Z
+date: 2015-08-05 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: uber
   requirement: !ruby/object:Gem::Requirement
@@ -240,6 +212,7 @@ files:
 - test/parse_strategy_test.rb
 - test/pass_options_test.rb
 - test/prepare_test.rb
+- test/private_options_test.rb
 - test/reader_writer_test.rb
 - test/realistic_benchmark.rb
 - test/represent_test.rb
@@ -274,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Renders and parses JSON/XML/YAML documents from and to Ruby objects. Includes