representable 2.0.4 → 2.1.0

data/lib/representable/hash.rb

@@ -1,5 +1,5 @@
 require 'representable'
-require 'representable/bindings/hash_bindings'
+require 'representable/hash/binding'
 
 module Representable
   # The generic representer. Brings #to_hash and #from_hash to your object.
@@ -25,13 +25,13 @@ module Representable
     # 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=PropertyBinding)
+    def from_hash(data, options={}, binding_builder=Binding)
       data = filter_wrap(data, options)
 
       update_properties_from(data, options, binding_builder)
     end
 
-    def to_hash(options={}, binding_builder=PropertyBinding)
+    def to_hash(options={}, binding_builder=Binding)
       hash = create_representation_with({}, options, binding_builder)
 
       return hash unless wrap = options[:wrap] || representation_wrap(options)

data/lib/representable/hash/binding.rb

@@ -0,0 +1,40 @@
+require 'representable/binding'
+
+module Representable
+  module Hash
+    class Binding < Representable::Binding
+      def self.build_for(definition, *args)  # TODO: remove default arg.
+        return Collection.new(definition, *args)  if definition.array?
+        return Hash.new(definition, *args)        if definition.hash?
+        new(definition, *args)
+      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.
+
+        hash[as] # fragment
+      end
+
+      def write(hash, fragment)
+        hash[as] = fragment
+      end
+
+      def serialize_method
+        :to_hash
+      end
+
+      def deserialize_method
+        :from_hash
+      end
+
+      class Collection < self
+        include Representable::Binding::Collection
+      end
+
+
+      class Hash < self
+        include Representable::Binding::Hash
+      end
+    end
+  end
+end

data/lib/representable/hash/collection.rb

@@ -20,12 +20,13 @@ module Representable::Hash
 
     def create_representation_with(doc, options, format)
       bin   = representable_mapper(format, options).bindings.first
-      bin.write(doc, represented)
+      bin.render_fragment(represented, doc)
     end
 
     def update_properties_from(doc, options, format)
       bin   = representable_mapper(format, options).bindings.first
-      value = bin.deserialize_from(doc)
+      #value = bin.deserialize_from(doc)
+      value = Deserializer::Collection.new(bin).call(doc)
       represented.replace(value)
     end
   end

data/lib/representable/hash_methods.rb

@@ -3,13 +3,15 @@ module Representable
     def create_representation_with(doc, options, format)
       bin   = representable_mapper(format, options).bindings.first
       hash  = filter_keys_for(represented, options)
-      bin.write(doc, hash)
+      bin.render_fragment(hash, doc) # TODO: Use something along Populator, which does
     end
 
     def update_properties_from(doc, options, format)
       bin   = representable_mapper(format, options).bindings.first
       hash  = filter_keys_for(doc, options)
-      value = bin.deserialize_from(hash)
+
+      value = Deserializer::Hash.new(bin).call(hash)
+      # value = bin.deserialize_from(hash)
       represented.replace(value)
     end
 

data/lib/representable/mapper.rb

@@ -52,7 +52,7 @@ module Representable
       def skip_conditional_property?(binding)
         return unless condition = binding[:if]
 
-        not binding.send(:evaluate_option, :if)
+        not binding.evaluate_option(:if)
       end
 
       # DISCUSS: this could be just another :if option in a Pipeline?

data/lib/representable/populator.rb

@@ -0,0 +1,59 @@
+module Representable
+  #
+  # populator
+      # skip_parse? --> return
+      # deserialize (this is where additional logic can happen, e.g. Object-HAL's collection semantics).
+      # parse_filter
+      # set
+  class Populator # rename to Deserializer?
+    def initialize(binding)
+      @binding = binding
+    end
+
+    # goal of this is to have this workflow apply-able to collections AND to items per collection, or for items in hashes.
+    def call(fragment, doc)
+      # the rest should be applied per item (collection) or per fragment (collection and property)
+      if fragment == Binding::FragmentNotFound
+        return unless @binding.has_default?
+        value = @binding[:default]
+      else
+        value = deserialize(fragment) { return } # stop here if skip_parse?
+      end
+
+      value = @binding.parse_filter(value, doc)
+        # parse_filter
+        # set
+      @binding.set(value)
+    end
+
+  private
+    def deserialize(fragment)
+      return yield if @binding.evaluate_option(:skip_parse, fragment) # TODO: move this into Deserializer.
+
+      # use a Deserializer to transform fragment to/into object.
+      deserializer_class.new(@binding).call(fragment) # CollectionDeserializer/HashDeserializer/etc.
+    end
+
+    def deserializer_class
+      Deserializer
+    end
+
+
+    # A separated collection deserializer/populator allows us better dealing with populating/modifying
+    # collections of models. (e.g. replace, update, push, etc.).
+    # That also gives us a place to apply options like :parse_filter, etc. per item.
+    class Collection < self
+    private
+      def deserialize(fragment)
+        return Deserializer::Collection.new(@binding).call(fragment)
+      end
+    end
+
+    class Hash < self
+    private
+      def deserializer_class
+        Deserializer::Hash
+      end
+    end
+  end
+end

data/lib/representable/serializer.rb

@@ -1,28 +1,39 @@
 require "representable/deserializer"
 
 module Representable
-  class ObjectSerializer < ObjectDeserializer
-    def initialize(binding, object)
-      super(binding)
-      @object = object
-    end
-
-    def call
-      # return unless @binding.typed? # FIXME: fix that in XML/YAML.
-      return @object if @object.nil? # DISCUSS: move to Object#serialize ?
-
-      representable = prepare(@object)
+  class Serializer < Deserializer
+    def call(object)
+      return object if object.nil? # DISCUSS: move to Object#serialize ?
 
-      serialize(representable, @binding.user_options)
+      serialize(object, @binding.user_options)
     end
 
   private
+    # Serialize one object by calling to_json etc. on it.
     def serialize(object, user_options)
+      object = prepare(object)
+
       return object unless @binding.representable?
 
-      @binding.send(:evaluate_option, :serialize, object) do
+      @binding.evaluate_option(:serialize, object) do
         object.send(@binding.serialize_method, user_options.merge!({:wrap => false}))
       end
     end
+
+
+    class Collection < self
+      def serialize(array, *args)
+        array.collect { |item| super(item, *args) } # TODO: i don't want Array but Forms here - what now?
+      end
+    end
+
+
+    class Hash < self
+      def serialize(hash, *args)
+        {}.tap do |hsh|
+          hash.each { |key, obj| hsh[key] = super(obj, *args) }
+        end
+      end
+    end
   end
 end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "2.0.4"
+  VERSION = "2.1.0"
 end

data/lib/representable/xml.rb

@@ -1,5 +1,5 @@
 require 'representable'
-require 'representable/bindings/xml_bindings'
+require 'representable/xml/binding'
 require 'representable/xml/collection'
 require 'nokogiri'
 
@@ -32,7 +32,7 @@ module Representable
     end
 
     def from_node(node, options={})
-      update_properties_from(node, options, PropertyBinding)
+      update_properties_from(node, options, Binding)
     end
 
     # Returns a Nokogiri::XML object representing this object.
@@ -40,7 +40,7 @@ module Representable
       options[:doc] ||= Nokogiri::XML::Document.new
       root_tag = options[:wrap] || representation_wrap(options)
 
-      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, options[:doc]), options, PropertyBinding)
+      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, options[:doc]), options, Binding)
     end
 
     def to_xml(*args)

data/lib/representable/xml/binding.rb

@@ -0,0 +1,171 @@
+require 'representable/binding'
+require 'representable/hash/binding.rb'
+
+module Representable
+  module XML
+    class Binding < Representable::Binding
+      def self.build_for(definition, *args)
+        return Collection.new(definition, *args)      if definition.array?
+        return Hash.new(definition, *args)            if definition.hash? and not definition[:use_attributes] # FIXME: hate this.
+        return AttributeHash.new(definition, *args)   if definition.hash? and definition[:use_attributes]
+        return Attribute.new(definition, *args)       if definition[:attribute]
+        return Content.new(definition, *args)         if definition[:content]
+        new(definition, *args)
+      end
+
+      def write(parent, fragments)
+        wrap_node = parent
+
+        if wrap = self[:wrap]
+          parent << wrap_node = node_for(parent, wrap)
+        end
+
+        wrap_node << serialize_for(fragments, parent)
+      end
+
+      def read(node)
+        nodes = find_nodes(node)
+        return FragmentNotFound if nodes.size == 0 # TODO: write dedicated test!
+
+        deserialize_from(nodes)
+      end
+
+      # Creates wrapped node for the property.
+      def serialize_for(value, parent)
+        node = node_for(parent, as)
+        serialize_node(node, value)
+      end
+
+      def serialize_node(node, value)
+        return value if typed?
+
+        node.content = value
+        node
+      end
+
+      def deserialize_from(nodes)
+        content_for(nodes.first)
+      end
+
+      # DISCUSS: why is this public?
+      def serialize_method
+        :to_node
+      end
+
+      def deserialize_method
+        :from_node
+      end
+
+    private
+      def xpath
+        as
+      end
+
+      def find_nodes(doc)
+        selector  = xpath
+        selector  = "#{self[:wrap]}/#{xpath}" if self[:wrap]
+        nodes     = doc.xpath(selector)
+      end
+
+      def node_for(parent, name)
+        Nokogiri::XML::Node.new(name.to_s, parent.document)
+      end
+
+      def content_for(node) # TODO: move this into a ScalarDecorator.
+        return node if typed?
+
+        node.content
+      end
+
+
+      class Collection < self
+        include Representable::Binding::Collection
+
+        def serialize_for(value, parent)
+          # return NodeSet so << works.
+          set_for(parent, value.collect { |item| super(item, parent) })
+        end
+
+        def deserialize_from(nodes)
+          content_nodes = nodes.collect do |item| # TODO: move this to Node?
+            content_for(item)
+          end
+
+          content_nodes
+        end
+
+      private
+        def set_for(parent, nodes)
+          Nokogiri::XML::NodeSet.new(parent.document, nodes)
+        end
+      end
+
+
+      class Hash < Collection
+        include Representable::Binding::Hash
+
+        def serialize_for(value, parent)
+          set_for(parent, value.collect do |k, v|
+            node = node_for(parent, k)
+            serialize_node(node, v)
+          end)
+        end
+
+        def deserialize_from(nodes)
+          hash = {}
+          nodes.children.each do |node|
+            hash[node.name] = content_for node
+          end
+
+          hash
+        end
+      end
+
+      class AttributeHash < Collection
+        # DISCUSS: use AttributeBinding here?
+        def write(parent, value)  # DISCUSS: is it correct overriding #write here?
+          value.collect do |k, v|
+            parent[k] = v.to_s
+          end
+          parent
+        end
+
+        # FIXME: this is not tested!
+        def deserialize_from(node)
+          HashDeserializer.new(self).deserialize(node)
+        end
+      end
+
+
+      # Represents a tag attribute. Currently this only works on the top-level tag.
+      class Attribute < self
+        def read(node)
+          node[as]
+        end
+
+        def serialize_for(value, parent)
+          parent[as] = value.to_s
+        end
+
+        def write(parent, value)
+          serialize_for(value, parent)
+        end
+      end
+
+      # Represents tag content.
+      class Content < self
+        def read(node)
+          node.content
+        end
+
+        def serialize_for(value, parent)
+          parent.content = value.to_s
+        end
+
+        def write(parent, value)
+          serialize_for(value, parent)
+        end
+      end
+    end # Binding
+  end
+end

data/lib/representable/yaml.rb

@@ -1,4 +1,4 @@
-require 'representable/bindings/yaml_bindings'
+require 'representable/yaml/binding'
 
 module Representable
   module YAML
@@ -15,7 +15,7 @@ module Representable
 
     def from_yaml(doc, options={})
       hash = Psych.load(doc)
-      from_hash(hash, options, PropertyBinding)
+      from_hash(hash, options, Binding)
     end
 
     # Returns a Nokogiri::XML object representing this object.
@@ -23,7 +23,7 @@ module Representable
       #root_tag = options[:wrap] || representation_wrap
 
       Psych::Nodes::Mapping.new.tap do |map|
-        create_representation_with(map, options, PropertyBinding)
+        create_representation_with(map, options, Binding)
       end
     end