representable 1.2.7 → 1.2.8

data/CHANGES.textile

@@ -1,3 +1,8 @@
+h2. 1.2.8
+
+* Reverting all the bullshit from 1.2.7 making it even better. @Binding@s now wrap their @Definition@ instance adopting its API. Moved the binding_for_definition mechanics to the respecting @Binding@ subclass.
+* Added :readable and :writeable to #property: while @:readable => true@ renders the property into the document @:writeable => true@ allows updating the property's value when consuming a representation. Both default to @true@.
+
 h2. 1.2.7
 
 * Moving @Format.binding_for_definition@ to @Format#{format}_binding_for_definition@, making it an instance method in its own "namespace". This allows mixing in multiple representer engines into a user's representer module.

data/lib/representable.rb

@@ -1,5 +1,6 @@
 require 'representable/deprecations'
 require 'representable/definition'
+require 'representable/feature/readable_writeable'
 
 # Representable can be used in two ways.
 #
@@ -35,15 +36,14 @@ module Representable
       extend ClassMethods::Declarations
       
       include Deprecations
+      include Feature::ReadableWriteable
     end
   end
   
   # Reads values from +doc+ and sets properties accordingly.
   def update_properties_from(doc, options, format)
     representable_bindings_for(format).each do |bin|
-      next if skip_property?(bin, options)
-      
-      uncompile_fragment(bin, doc)
+      deserialize_property(bin, doc, options)
     end
     self
   end
@@ -52,13 +52,21 @@ private
   # Compiles the document going through all properties.
   def create_representation_with(doc, options, format)
     representable_bindings_for(format).each do |bin|
-      next if skip_property?(bin, options)
-      
-      compile_fragment(bin, doc)
+      serialize_property(bin, doc, options)
     end
     doc
   end
-  
+
+  def serialize_property(binding, doc, options)
+    return if skip_property?(binding, options)
+    compile_fragment(binding, doc)
+  end
+
+  def deserialize_property(binding, doc, options)
+    return if skip_property?(binding, options)
+    uncompile_fragment(binding, doc)
+  end
+
   # Checks and returns if the property should be included.
   def skip_property?(binding, options)
     return true if skip_excluded_property?(binding, options)  # no need for further evaluation when :exclude'ed
@@ -68,19 +76,19 @@ private
   
   def skip_excluded_property?(binding, options)
     return unless props = options[:exclude] || options[:include]
-    res   = props.include?(binding.definition.name.to_sym)
+    res   = props.include?(binding.name.to_sym)
     options[:include] ? !res : res
   end
   
   def skip_conditional_property?(binding)
-    return unless condition = binding.definition.options[:if]
+    return unless condition = binding.options[:if]
     not instance_exec(&condition)
   end
   
   # Retrieve value and write fragment to the doc.
   def compile_fragment(bin, doc)
-    value = send(bin.definition.getter)
-    value = bin.definition.default_for(value)
+    value = send(bin.getter)
+    value = bin.default_for(value)
     
     write_fragment_for(bin, value, doc)
   end
@@ -90,15 +98,15 @@ private
     value = read_fragment_for(bin, doc)
     
     if value == Binding::FragmentNotFound
-      return unless bin.definition.has_default?
-      value = bin.definition.default
+      return unless bin.has_default?
+      value = bin.default
     end
     
-    send(bin.definition.setter, value)
+    send(bin.setter, value)
   end
   
   def write_fragment_for(bin, value, doc) # DISCUSS: move to Binding?
-    return if bin.definition.skipable_nil_value?(value)
+    return if bin.skipable_nil_value?(value)
     bin.write(doc, value)
   end
   
@@ -111,7 +119,7 @@ private
   end
   
   def representable_bindings_for(format)
-    representable_attrs.map {|attr| send("#{format}_binding_for_definition", attr) }  # DISCUSS: call that on attr directly?
+    representable_attrs.map {|attr| format.build_for(attr) }
   end
   
   # Returns the wrapper for the representation. Mostly used in XML.
@@ -119,7 +127,6 @@ private
     representable_attrs.wrap_for(self.class.name)
   end
   
-  
   module ClassInclusions
     def included(base)
       super
@@ -163,6 +170,8 @@ private
       #   property :name, :class => Name
       #   property :name, :default => "Mike"
       #   property :name, :render_nil => true
+      #   property :name, :readable => false
+      #   property :name, :writeable => false
       def property(name, options={})
         representable_attrs << definition_class.new(name, options)
       end

data/lib/representable/binding.rb

@@ -1,13 +1,13 @@
+require 'delegate'
+
 module Representable
-  class Binding
+  # The Binding wraps the Definition instance for this property and provides methods to read/write fragments.
+  class Binding < SimpleDelegator
     class FragmentNotFound
     end
     
-    
-    attr_reader :definition # TODO: merge Binding and Definition.
-  
-    def initialize(definition)
-      @definition = definition
+    def definition  # TODO: remove in 1.4.
+      raise "Binding#definition is no longer supported as all Definition methods are now delegated automatically."
     end
     
     # Main entry point for rendering/parsing a property object.
@@ -33,7 +33,7 @@ module Representable
       end
       
       def extend_for(object)
-        if mod = definition.representer_module
+        if mod = representer_module
           object.extend(*mod)
         end
         
@@ -56,7 +56,7 @@ module Representable
       end
       
       def create_object
-        definition.sought_type.new
+        sought_type.new
       end
     end
     

data/lib/representable/bindings/hash_bindings.rb

@@ -16,20 +16,26 @@ module Representable
     
     
     class PropertyBinding < Representable::Binding
-      def initialize(definition) # FIXME. make generic.
+      def self.build_for(definition)
+        return CollectionBinding.new(definition)  if definition.array?
+        return HashBinding.new(definition)        if definition.hash?
+        new(definition)
+      end
+
+      def initialize(*args) # FIXME. make generic.
         super
-        extend ObjectBinding if definition.typed?
+        extend ObjectBinding if typed?
       end
       
       def read(hash)
-        return FragmentNotFound unless hash.has_key?(definition.from) # DISCUSS: put it all in #read for performance. not really sure if i like returning that special thing.
+        return FragmentNotFound unless hash.has_key?(from) # DISCUSS: put it all in #read for performance. not really sure if i like returning that special thing.
         
-        fragment = hash[definition.from]
+        fragment = hash[from]
         deserialize_from(fragment)
       end
       
       def write(hash, value)
-        hash[definition.from] = serialize_for(value)
+        hash[from] = serialize_for(value)
       end
       
       def serialize_for(value)

data/lib/representable/bindings/xml_bindings.rb

@@ -24,15 +24,23 @@ module Representable
     
     
     class PropertyBinding < Binding
-      def initialize(definition)
+      def self.build_for(definition)
+        return CollectionBinding.new(definition)      if definition.array?
+        return HashBinding.new(definition)            if definition.hash? and not definition.options[:use_attributes] # FIXME: hate this.
+        return AttributeHashBinding.new(definition)   if definition.hash? and definition.options[:use_attributes]
+        return AttributeBinding.new(definition)       if definition.attribute
+        new(definition)
+      end
+
+      def initialize(*args)
         super
-        extend ObjectBinding if definition.typed? # FIXME.
+        extend ObjectBinding if typed? # FIXME.
       end
       
       def write(parent, value)
         wrap_node = parent
         
-        if wrap = definition.options[:wrap]
+        if wrap = options[:wrap]
           parent << wrap_node = node_for(parent, wrap)
         end
 
@@ -41,7 +49,7 @@ module Representable
       
       def read(node)
         selector  = "./#{xpath}"
-        selector  = "./#{definition.options[:wrap]}/#{xpath}" if definition.options[:wrap]
+        selector  = "./#{options[:wrap]}/#{xpath}" if options[:wrap]
         nodes     = node.search(selector)
 
         return FragmentNotFound if nodes.size == 0 # TODO: write dedicated test!
@@ -52,7 +60,7 @@ module Representable
       # Creates wrapped node for the property.
       def serialize_for(value, parent)
       #def serialize_for(value, parent, tag_name=definition.from)
-        node = node_for(parent, definition.from)
+        node = node_for(parent, from)
         serialize_node(node, value)
       end
       
@@ -72,7 +80,7 @@ module Representable
       
     private
       def xpath
-        definition.from
+        from
       end
 
       def node_for(parent, name)
@@ -138,11 +146,11 @@ module Representable
     # Represents a tag attribute. Currently this only works on the top-level tag.
     class AttributeBinding < PropertyBinding
       def read(node)
-        deserialize(node[definition.from])
+        deserialize(node[from])
       end
       
       def serialize_for(value, parent)
-        parent[definition.from] = serialize(value.to_s)
+        parent[from] = serialize(value.to_s)
       end
       
       def write(parent, value)

data/lib/representable/bindings/yaml_bindings.rb

@@ -19,13 +19,21 @@ module Representable
     end
 
     class PropertyBinding < Representable::Hash::PropertyBinding
-      def initialize(definition) # FIXME. make generic.
+      def self.build_for(definition)
+        return CollectionBinding.new(definition)      if definition.array?
+        #return HashBinding.new(definition)            if definition.hash? and not definition.options[:use_attributes] # FIXME: hate this.
+        #return AttributeHashBinding.new(definition)   if definition.hash? and definition.options[:use_attributes]
+        #return AttributeBinding.new(definition)       if definition.attribute
+        new(definition)
+      end
+
+      def initialize(*args) # FIXME. make generic.
         super
-        extend ObjectBinding if definition.typed?
+        extend ObjectBinding if typed?
       end
       
       def write(map, value)
-        map.children << Psych::Nodes::Scalar.new(definition.from)
+        map.children << Psych::Nodes::Scalar.new(from)
         map.children << serialize_for(value)  # FIXME: should be serialize.
       end
 
@@ -42,7 +50,7 @@ module Representable
     class CollectionBinding < PropertyBinding
       def serialize_for(value)
         Psych::Nodes::Sequence.new.tap do |seq|
-          seq.style = Psych::Nodes::Sequence::FLOW if definition.options[:style] == :flow
+          seq.style = Psych::Nodes::Sequence::FLOW if options[:style] == :flow
           value.each { |obj| seq.children << super(obj) }
         end
       end

data/lib/representable/definition.rb

@@ -8,7 +8,7 @@ module Representable
       @name     = sym.to_s
       @options  = options
       
-      options[:default] ||= [] if array?  # FIXME: move to CollectionBinding!
+      @options[:default] ||= [] if array?  # FIXME: move to CollectionBinding!
     end
     
     def clone

data/lib/representable/feature/readable_writeable.rb

@@ -0,0 +1,30 @@
+module Representable
+  module Feature
+    module ReadableWriteable
+      def deserialize_property(binding, doc, options)
+        return unless binding.writeable?
+        super
+      end
+
+      def serialize_property(binding, doc, options)
+        return unless binding.readable?
+        super
+      end
+    end
+  end
+
+  # TODO: i hate monkey-patching Definition here since it globally adds this options. However, for now this should be ok :-)
+  class Definition
+    # Checks and returns if the property is writeable
+    def writeable?
+      return options[:writeable] if options.has_key?(:writeable)
+      true
+    end
+
+    # Checks and returns if the property is readable
+    def readable?
+      return options[:readable] if options.has_key?(:readable)
+      true
+    end
+  end
+end

data/lib/representable/hash.rb

@@ -22,28 +22,20 @@ module Representable
     end
     
     
-    def from_hash(data, options={}, format=:hash)
+    def from_hash(data, options={}, binding_builder=PropertyBinding)
       if wrap = options[:wrap] || representation_wrap
         data = data[wrap.to_s]
       end
       
-      update_properties_from(data, options, format)
+      update_properties_from(data, options, binding_builder)
     end
     
-    def to_hash(options={}, format=:hash)
-      hash = create_representation_with({}, options, format)
+    def to_hash(options={}, binding_builder=PropertyBinding)
+      hash = create_representation_with({}, options, binding_builder)
       
       return hash unless wrap = options[:wrap] || representation_wrap
       
       {wrap => hash}
     end
-
-  private
-
-    def hash_binding_for_definition(definition)
-      return Representable::Hash::CollectionBinding.new(definition)  if definition.array?
-      return Representable::Hash::HashBinding.new(definition)        if definition.hash?
-      Representable::Hash::PropertyBinding.new(definition)
-    end
   end
 end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "1.2.7"
+  VERSION = "1.2.8"
 end

data/lib/representable/xml.rb

@@ -37,28 +37,18 @@ module Representable
     end
     
     def from_node(node, options={})
-      update_properties_from(node, options, :xml)
+      update_properties_from(node, options, PropertyBinding)
     end
     
     # Returns a Nokogiri::XML object representing this object.
     def to_node(options={})
       root_tag = options[:wrap] || representation_wrap
       
-      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, Nokogiri::XML::Document.new), options, :xml)
+      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, Nokogiri::XML::Document.new), options, PropertyBinding)
     end
     
     def to_xml(*args)
       to_node(*args).to_s
     end
-
-  private
-
-    def xml_binding_for_definition(definition)
-      return CollectionBinding.new(definition)      if definition.array?
-      return HashBinding.new(definition)            if definition.hash? and not definition.options[:use_attributes] # FIXME: hate this.
-      return AttributeHashBinding.new(definition)   if definition.hash? and definition.options[:use_attributes]
-      return AttributeBinding.new(definition)       if definition.attribute
-      PropertyBinding.new(definition)
-    end
   end
 end

data/lib/representable/yaml.rb

@@ -30,7 +30,7 @@ module Representable
     
     def from_yaml(doc, options={})
       hash = Psych.load(doc)
-      from_hash(hash, options, :yaml)
+      from_hash(hash, options, PropertyBinding)
     end
     
     # Returns a Nokogiri::XML object representing this object.
@@ -38,7 +38,7 @@ module Representable
       #root_tag = options[:wrap] || representation_wrap
       
       Psych::Nodes::Mapping.new.tap do |map|
-        create_representation_with(map, options, :yaml)
+        create_representation_with(map, options, PropertyBinding)
       end
     end
     
@@ -49,15 +49,5 @@ module Representable
       doc.children << to_ast(*args)
       stream.to_yaml
     end
-
-  private
-
-    def yaml_binding_for_definition(definition)
-      return CollectionBinding.new(definition)      if definition.array?
-      #return HashBinding.new(definition)            if definition.hash? and not definition.options[:use_attributes] # FIXME: hate this.
-      #return AttributeHashBinding.new(definition)   if definition.hash? and definition.options[:use_attributes]
-      #return AttributeBinding.new(definition)       if definition.attribute
-      PropertyBinding.new(definition)
-    end
   end
 end

data/test/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gem 'representable', :path => "../"

data/test/coercion_test.rb

@@ -10,34 +10,41 @@ class VirtusCoercionTest < MiniTest::Spec
       module SongRepresenter
         include Representable::JSON
         include Representable::Coercion
-        property :composed_at, :type => DateTime 
+        property :composed_at,  :type => DateTime
+        property :track,        :type => Integer
       end
      
       it "coerces properties in #from_json" do
-        song = Song.new.extend(SongRepresenter).from_json("{\"composed_at\":\"November 18th, 1983\"}")
+        song = Song.new.extend(SongRepresenter).from_json("{\"composed_at\":\"November 18th, 1983\",\"track\":\"18\"}")
         assert_kind_of DateTime, song.composed_at
+        assert_equal 18, song.track
         assert_equal DateTime.parse("Fri, 18 Nov 1983 00:00:00 +0000"), song.composed_at
       end
     end
     
     
-    class ImmigrantSong
-      include Representable::JSON
-      include Virtus
-      include Representable::Coercion
+    describe "on class level" do
+      class ImmigrantSong
+        attr_accessor :track
+        include Representable::JSON
+        include Virtus
+        include Representable::Coercion
+        
+        property :composed_at,  :type => DateTime, :default => "May 12th, 2012"
+        property :track,        :type => Integer
+      end
       
-      property :composed_at, :type => DateTime, :default => "May 12th, 2012"
-    end
-    
-    it "coerces into the provided type" do
-      song = ImmigrantSong.new.from_json("{\"composed_at\":\"November 18th, 1983\"}")
-      assert_equal DateTime.parse("Fri, 18 Nov 1983 00:00:00 +0000"), song.composed_at
-    end
-    
-    it "respects the :default options" do
-      song = ImmigrantSong.new.from_json("{}")
-      assert_kind_of DateTime, song.composed_at
-      assert_equal DateTime.parse("Mon, 12 May 2012 00:00:00 +0000"), song.composed_at
+      it "coerces into the provided type" do
+        song = ImmigrantSong.new.from_json("{\"composed_at\":\"November 18th, 1983\",\"track\":\"18\"}")
+        assert_equal DateTime.parse("Fri, 18 Nov 1983 00:00:00 +0000"), song.composed_at
+        assert_equal 18, song.track
+      end
+      
+      it "respects the :default options" do
+        song = ImmigrantSong.new.from_json("{}")
+        assert_kind_of DateTime, song.composed_at
+        assert_equal DateTime.parse("Mon, 12 May 2012 00:00:00 +0000"), song.composed_at
+      end
     end
     
   end

data/test/definition_test.rb

@@ -128,6 +128,56 @@ class DefinitionTest < MiniTest::Spec
     end
   end
     
+  
+  describe "#writeable?" do
+
+    it "returns true when :writeable is not given" do
+      @def = Representable::Definition.new(:song)
+      assert_equal true, @def.writeable?
+    end
+
+    it "returns true when :writeable => true" do
+      @def = Representable::Definition.new(:song, :writeable => true)
+      assert_equal true, @def.writeable?
+    end
+
+    it "returns false when :writeable => false" do
+      @def = Representable::Definition.new(:song, :writeable => false)
+      assert_equal false, @def.writeable?
+    end
+
+    it "returns nil when :writeable is nil" do
+      @def = Representable::Definition.new(:song, :writeable => nil)
+      assert_equal nil, @def.writeable?
+    end
+    
+  end
+
+  describe "#readable?" do
+
+    it "returns true when :readable is not given" do
+      @def = Representable::Definition.new(:song)
+      assert_equal true, @def.readable?
+    end
+
+    it "returns true when :readable => true" do
+      @def = Representable::Definition.new(:song, :readable => true)
+      assert_equal true, @def.readable?
+    end
+
+    it "returns false when :readable => false" do
+      @def = Representable::Definition.new(:song, :readable => false)
+      assert_equal false, @def.readable?
+    end
+
+    it "returns nil when :readable is nil" do
+      @def = Representable::Definition.new(:song, :readable => nil)
+      assert_equal nil, @def.readable?
+    end
+
+  end
+
+
   describe ":collection => true" do
     before do
       @def = Representable::Definition.new(:songs, :collection => true, :tag => :song)

data/test/example.rb

@@ -0,0 +1,159 @@
+require 'bundler'
+Bundler.setup
+
+require 'representable/yaml'
+require 'ostruct'
+
+class Song < OpenStruct
+end
+
+song = Song.new(:title => "Fallout", :track => 1)
+
+require 'representable/json'
+module SongRepresenter
+  include Representable::JSON
+
+  property :title
+  property :track
+end
+
+puts song.extend(SongRepresenter).to_json
+
+rox = Song.new.extend(SongRepresenter).from_json(%{ {"title":"Roxanne"} })
+puts rox.inspect
+
+module SongRepresenter
+  include Representable::JSON
+
+  self.representation_wrap= :hit
+
+  property :title
+  property :track
+end
+
+puts song.extend(SongRepresenter).to_json
+
+
+
+######### collections
+
+module SongRepresenter
+  include Representable::JSON
+
+  self.representation_wrap= false
+end
+
+module SongRepresenter
+  include Representable::JSON
+
+  property :title
+  property :track
+  collection :composers
+end
+
+
+song = Song.new(:title => "Fallout", :composers => ["Steward Copeland", "Sting"])
+puts song.extend(SongRepresenter).to_json
+
+
+######### nesting types
+
+class Album < OpenStruct
+end
+
+module AlbumRepresenter
+  include Representable::JSON
+
+  property :name
+  property :song, :extend => SongRepresenter, :class => Song
+end
+
+album = Album.new(:name => "The Police", :song => song)
+puts album.extend(AlbumRepresenter).to_json
+
+
+module AlbumRepresenter
+  include Representable::JSON
+
+  property :name
+  collection :songs, :extend => SongRepresenter, :class => Song
+end
+
+album = Album.new(:name => "The Police", :songs => [song, Song.new(:title => "Synchronicity")])
+puts album.extend(AlbumRepresenter).to_json
+
+
+SongRepresenter.module_eval do
+  @representable_attrs = nil
+end
+
+
+######### inheritance
+module SongRepresenter
+  include Representable::JSON
+
+  property :title
+  property :track
+end
+
+module CoverSongRepresenter
+  include Representable::JSON
+  include SongRepresenter
+
+  property :covered_by
+end
+
+
+song = Song.new(:title => "Truth Hits Everybody", :covered_by => "No Use For A Name")
+puts song.extend(CoverSongRepresenter).to_json
+
+
+### XML
+require 'representable/xml'
+module SongRepresenter
+  include Representable::XML
+
+  property :title
+  property :track
+  collection :composers
+end
+song = Song.new(:title => "Fallout", :composers => ["Steward Copeland", "Sting"])
+puts song.extend(SongRepresenter).to_xml
+
+
+SongRepresenter.module_eval do
+  @representable_attrs = nil
+end
+
+
+### YAML
+require 'representable/yaml'
+module SongRepresenter
+  include Representable::YAML
+
+  property :title
+  property :track
+  collection :composers
+end
+puts song.extend(SongRepresenter).to_yaml
+
+
+SongRepresenter.module_eval do
+  @representable_attrs = nil
+end
+
+
+### YAML
+module SongRepresenter
+  include Representable::YAML
+
+  property :title
+  property :track
+  collection :composers, :style => :flow
+end
+puts song.extend(SongRepresenter).to_yaml
+
+
+######### custom methods in representer (using helpers)
+######### r/w, conditions
+#########

data/test/hash_test.rb

@@ -114,4 +114,23 @@ class YamlTest < MiniTest::Spec
       end
     end
   end
+
+
+  class DefinitionTest < MiniTest::Spec
+    it "what" do
+      class Representable::Hash::Binding < SimpleDelegator
+        
+      end
+
+      definition  = Representable::Definition.new(:name)
+      wrapped     = Representable::Hash::Binding.new(definition)
+
+      wrapped.name.must_equal "name"
+      wrapped.hash?.must_equal nil
+      wrapped.array?.must_equal nil
+      wrapped.options.must_equal({})
+
+      #wrapped.
+    end
+  end
 end

data/test/json_test.rb

@@ -126,28 +126,28 @@ module JsonTest
         end
       end
 
-      describe "#binding_for_definition" do
+      describe "#build_for" do
         it "returns ObjectBinding" do
-          assert_kind_of Representable::Hash::ObjectBinding, @band.send(:hash_binding_for_definition, Def.new(:band, :class => Hash))
+          assert_kind_of Representable::Hash::ObjectBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band, :class => Hash))
         end
 
         it "returns TextBinding" do
-          assert_kind_of Representable::Hash::PropertyBinding, @band.send(:hash_binding_for_definition, Def.new(:band))
+          assert_kind_of Representable::Hash::PropertyBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band))
         end
 
         it "returns HashBinding" do
-          assert_kind_of Representable::Hash::HashBinding, @band.send(:hash_binding_for_definition, Def.new(:band, :hash => true))
+          assert_kind_of Representable::Hash::HashBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band, :hash => true))
         end
 
         it "returns CollectionBinding" do
-          assert_kind_of Representable::Hash::CollectionBinding, @band.send(:hash_binding_for_definition, Def.new(:band, :collection => true))
+          assert_kind_of Representable::Hash::CollectionBinding, Representable::Hash::PropertyBinding.build_for(Def.new(:band, :collection => true))
         end
       end
 
-      describe "#representable_bindings" do
+      describe "#representable_bindings_for" do
         it "returns bindings for each property" do
-          assert_equal 2, @band.send(:representable_bindings_for, :hash).size
-          assert_equal "name", @band.send(:representable_bindings_for, :hash).first.definition.name
+          assert_equal 2, @band.send(:representable_bindings_for, Representable::JSON::PropertyBinding).size
+          assert_equal "name", @band.send(:representable_bindings_for, Representable::JSON::PropertyBinding).first.name
         end
       end
     end

data/test/representable_test.rb

@@ -98,6 +98,25 @@ class RepresentableTest < MiniTest::Spec
   
   
   describe "Representable" do
+    describe "inheritance" do
+      class CoverSong < OpenStruct
+      end 
+      module SongRepresenter
+        include Representable::Hash
+        property :name
+      end
+      module CoverSongRepresenter
+        include Representable::Hash
+        include SongRepresenter
+        property :by
+      end
+
+      it "merges properties from all ancestors" do
+        props = {"name"=>"The Brews", "by"=>"Nofx"}
+        assert_equal(props, CoverSong.new(props).extend(CoverSongRepresenter).to_hash)
+
+      end
+    end
     it "allows mixing in multiple representers" do
       require 'representable/json'
       require 'representable/xml'
@@ -218,39 +237,46 @@ class RepresentableTest < MiniTest::Spec
     end
     
     it "copies values from document to object" do
-      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {}, :hash)
+      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {}, Representable::Hash::PropertyBinding)
       assert_equal "No One's Choice", @band.name
       assert_equal 2, @band.groupies
     end
     
     it "accepts :exclude option" do
-      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:exclude => [:groupies]}, :hash)
+      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:exclude => [:groupies]}, Representable::Hash::PropertyBinding)
       assert_equal "No One's Choice", @band.name
       assert_equal nil, @band.groupies
     end
     
     it "still accepts deprecated :except option" do # FIXME: remove :except option.
-      assert_equal @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:except => [:groupies]}, :hash), @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:exclude => [:groupies]}, :hash)
+      assert_equal @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:except => [:groupies]}, Representable::Hash::PropertyBinding), @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:exclude => [:groupies]}, Representable::Hash::PropertyBinding)
     end
     
     it "accepts :include option" do
-      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:include => [:groupies]}, :hash)
+      @band.update_properties_from({"name"=>"No One's Choice", "groupies"=>2}, {:include => [:groupies]}, Representable::Hash::PropertyBinding)
       assert_equal 2, @band.groupies
       assert_equal nil, @band.name
     end
+
+    it "ignores non-writeable properties" do
+      @band = Class.new(Band) { property :name; collection :founders, :writeable => false; attr_accessor :founders }.new
+      @band.update_properties_from({"name" => "Iron Maiden", "groupies" => 2, "founders" => [{ "name" => "Steve Harris" }] }, {}, Representable::Hash::PropertyBinding)
+      assert_equal "Iron Maiden", @band.name
+      assert_equal nil, @band.founders
+    end
     
     it "always returns self" do
-      assert_equal @band, @band.update_properties_from({"name"=>"Nofx"}, {}, :hash)
+      assert_equal @band, @band.update_properties_from({"name"=>"Nofx"}, {}, Representable::Hash::PropertyBinding)
     end
     
     it "includes false attributes" do
-      @band.update_properties_from({"groupies"=>false}, {}, :hash)
+      @band.update_properties_from({"groupies"=>false}, {}, Representable::Hash::PropertyBinding)
       assert_equal false, @band.groupies
     end
     
     it "ignores (no-default) properties not present in the incoming document" do
-      { Representable::JSON => [{}, :hash], 
-        Representable::XML  => [xml(%{<band/>}), :xml]
+      { Representable::JSON => [{}, Representable::Hash::PropertyBinding], 
+        Representable::XML  => [xml(%{<band/>}), Representable::XML::PropertyBinding]
       }.each do |format, config|
         nested_repr = Module.new do # this module is never applied.
           include format
@@ -277,31 +303,40 @@ class RepresentableTest < MiniTest::Spec
     end
     
     it "compiles document from properties in object" do
-      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.send(:create_representation_with, {}, {}, :hash))
+      assert_equal({"name"=>"No One's Choice", "groupies"=>2}, @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding))
     end
     
     it "accepts :exclude option" do
-      hash = @band.send(:create_representation_with, {}, {:exclude => [:groupies]}, :hash)
+      hash = @band.send(:create_representation_with, {}, {:exclude => [:groupies]}, Representable::Hash::PropertyBinding)
       assert_equal({"name"=>"No One's Choice"}, hash)
     end
     
     it "still accepts deprecated :except option" do # FIXME: remove :except option.
-      assert_equal @band.send(:create_representation_with, {}, {:except => [:groupies]}, :hash), @band.send(:create_representation_with, {}, {:exclude => [:groupies]}, :hash)
+      assert_equal @band.send(:create_representation_with, {}, {:except => [:groupies]}, Representable::Hash::PropertyBinding), @band.send(:create_representation_with, {}, {:exclude => [:groupies]}, Representable::Hash::PropertyBinding)
     end
     
     it "accepts :include option" do
-      hash = @band.send(:create_representation_with, {}, {:include => [:groupies]}, :hash)
+      hash = @band.send(:create_representation_with, {}, {:include => [:groupies]}, Representable::Hash::PropertyBinding)
       assert_equal({"groupies"=>2}, hash)
     end
 
+    it "ignores non-readable properties" do
+      @band = Class.new(Band) { property :name; collection :founder_ids, :readable => false; attr_accessor :founder_ids }.new
+      @band.name = "Iron Maiden"
+      @band.founder_ids = [1,2,3]
+
+      hash = @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding)
+      assert_equal({"name" => "Iron Maiden"}, hash)
+    end
+
     it "does not write nil attributes" do
       @band.groupies = nil
-      assert_equal({"name"=>"No One's Choice"}, @band.send(:create_representation_with, {}, {}, :hash))
+      assert_equal({"name"=>"No One's Choice"}, @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding))
     end
 
     it "writes false attributes" do
       @band.groupies = false
-      assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.send(:create_representation_with, {}, {}, :hash))
+      assert_equal({"name"=>"No One's Choice","groupies"=>false}, @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding))
     end
     
     describe "when :render_nil is true" do
@@ -314,7 +349,7 @@ class RepresentableTest < MiniTest::Spec
         
         @band.extend(mod) # FIXME: use clean object.
         @band.groupies = nil
-        hash = @band.send(:create_representation_with, {}, {}, :hash)
+        hash = @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding)
         assert_equal({"name"=>"No One's Choice", "groupies" => nil}, hash)
       end
       
@@ -327,7 +362,7 @@ class RepresentableTest < MiniTest::Spec
         
         @band.extend(mod) # FIXME: use clean object.
         @band.groupies = nil
-        hash = @band.send(:create_representation_with, {}, {}, :hash)
+        hash = @band.send(:create_representation_with, {}, {}, Representable::Hash::PropertyBinding)
         assert_equal({"name"=>"No One's Choice", "groupies" => nil}, hash)
       end
     end
@@ -341,21 +376,21 @@ class RepresentableTest < MiniTest::Spec
     it "respects property when condition true" do
       @pop.class_eval { property :fame, :if => lambda { true } }
       band = @pop.new
-      band.update_properties_from({"fame"=>"oh yes"}, {}, :hash)
+      band.update_properties_from({"fame"=>"oh yes"}, {}, Representable::Hash::PropertyBinding)
       assert_equal "oh yes", band.fame
     end
     
     it "ignores property when condition false" do
       @pop.class_eval { property :fame, :if => lambda { false } }
       band = @pop.new
-      band.update_properties_from({"fame"=>"oh yes"}, {}, :hash)
+      band.update_properties_from({"fame"=>"oh yes"}, {}, Representable::Hash::PropertyBinding)
       assert_equal nil, band.fame
     end
     
     it "ignores property when :exclude'ed even when condition is true" do
       @pop.class_eval { property :fame, :if => lambda { true } }
       band = @pop.new
-      band.update_properties_from({"fame"=>"oh yes"}, {:exclude => [:fame]}, :hash)
+      band.update_properties_from({"fame"=>"oh yes"}, {:exclude => [:fame]}, Representable::Hash::PropertyBinding)
       assert_equal nil, band.fame
     end
     
@@ -364,7 +399,7 @@ class RepresentableTest < MiniTest::Spec
       @pop.class_eval { property :fame, :if => lambda { groupies } }
       band = @pop.new
       band.groupies = true
-      band.update_properties_from({"fame"=>"oh yes"}, {}, :hash)
+      band.update_properties_from({"fame"=>"oh yes"}, {}, Representable::Hash::PropertyBinding)
       assert_equal "oh yes", band.fame
     end
   end

data/test/xml_test.rb

@@ -124,22 +124,22 @@ class XmlTest < MiniTest::Spec
     end
     
     
-    describe "XML#binding_for_definition" do
+    describe "XML::Binding#build_for" do
       it "returns AttributeBinding" do
-        assert_kind_of XML::AttributeBinding, @band.send(:xml_binding_for_definition, Def.new(:band, :from => "band", :attribute => true))
+        assert_kind_of XML::AttributeBinding, XML::PropertyBinding.build_for(Def.new(:band, :from => "band", :attribute => true))
       end
       
       it "returns PropertyBinding" do
-        assert_kind_of XML::PropertyBinding, @band.send(:xml_binding_for_definition, Def.new(:band, :class => Hash))
-        assert_kind_of XML::PropertyBinding, @band.send(:xml_binding_for_definition, Def.new(:band, :from => :content))
+        assert_kind_of XML::PropertyBinding, XML::PropertyBinding.build_for(Def.new(:band, :class => Hash))
+        assert_kind_of XML::PropertyBinding, XML::PropertyBinding.build_for(Def.new(:band, :from => :content))
       end
       
       it "returns CollectionBinding" do
-        assert_kind_of XML::CollectionBinding, @band.send(:xml_binding_for_definition, Def.new(:band, :collection => :true))
+        assert_kind_of XML::CollectionBinding, XML::PropertyBinding.build_for(Def.new(:band, :collection => :true))
       end
       
       it "returns HashBinding" do
-        assert_kind_of XML::HashBinding, @band.send(:xml_binding_for_definition, Def.new(:band, :hash => :true))
+        assert_kind_of XML::HashBinding, XML::PropertyBinding.build_for(Def.new(:band, :hash => :true))
       end
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: representable
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.2.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-07 00:00:00.000000000 Z
+date: 2012-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -164,6 +164,7 @@ files:
 - lib/representable/coercion.rb
 - lib/representable/definition.rb
 - lib/representable/deprecations.rb
+- lib/representable/feature/readable_writeable.rb
 - lib/representable/hash.rb
 - lib/representable/hash_methods.rb
 - lib/representable/json.rb
@@ -175,8 +176,10 @@ files:
 - lib/representable/xml/hash.rb
 - lib/representable/yaml.rb
 - representable.gemspec
+- test/Gemfile
 - test/coercion_test.rb
 - test/definition_test.rb
+- test/example.rb
 - test/hash_bindings_test.rb
 - test/hash_test.rb
 - test/json_test.rb