representable 1.5.3 → 1.6.0

data/lib/representable/decorator/coercion.rb

@@ -1,59 +1,4 @@
 require 'representable/coercion'
 
-class Representable::Decorator
-  module Coercion
-    def self.included(base)
-      base.class_eval do
-        # DISCUSS: this assumes we have a Representer included, yet.
-        alias_method :representable_initialize, :initialize
-        alias_method :representable_to_hash,    :to_hash
-
-        # FIXME: allow including coercion only from virtus.
-        include Virtus
-        undef_method(:initialize)
-        undef_method(:to_hash)
-
-        extend Representable::Coercion::ClassMethods
-        extend ClassMethods
-
-        def initialize(*args) # override Virtus' #initialize.
-          representable_initialize(*args)
-        end
-
-        def to_hash(*args) # override Virtus' #to_hash.
-          representable_to_hash(*args)
-        end
-      end
-    end
-
-    module ClassMethods
-      def property(name, options={})
-        if options[:type]
-          options[:decorator_scope] = true # call setter on decorator so coercion kicks in.
-          create_writer(name)
-          create_reader(name)
-        end
-
-        super # Representable::Coercion.
-      end
-
-    private
-      # FIXME: dear @solnic, please make this better!
-      def create_writer(name)
-        # the call to super makes the actual coercion, which is then delegated to the represented instance.
-        define_method "#{name}=" do |v|
-          coerced_value = super(v).get(self)
-          represented.send("#{name}=", coerced_value)
-        end
-      end
-
-      def create_reader(name)
-        # the call to super makes the actual coercion, which is then delegated to the represented instance.
-        define_method "#{name}" do
-          send("#{name}=", represented.send(name))
-          super()
-        end
-      end
-    end
-  end
-end
+# TODO: deprecate for 1.7.
+Representable::Decorator::Coercion = Representable::Coercion

data/lib/representable/definition.rb

@@ -36,6 +36,7 @@ module Representable
     end
 
     def from
+      # TODO: deprecate :from.
       (options[:from] || options[:as] || name).to_s
     end
 

data/lib/representable/feature/readable_writeable.rb

@@ -14,7 +14,7 @@ module Representable
   end
 
   # TODO: i hate monkey-patching Definition here since it globally adds this options. However, for now this should be ok :-)
-  class Definition
+  Definition.class_eval do
     # Checks and returns if the property is writeable
     def writeable?
       return options[:writeable] if options.has_key?(:writeable)

data/lib/representable/hash.rb

@@ -18,6 +18,11 @@ module Representable
       def from_hash(*args, &block)
         create_represented(*args, &block).from_hash(*args)
       end
+
+    private
+      def representer_engine
+        Representable::Hash
+      end
     end
 
 

data/lib/representable/hash/collection.rb

@@ -0,0 +1,38 @@
+module Representable::Hash
+  module Collection
+    include Representable::Hash
+
+    def self.included(base)
+      base.class_eval do
+        include Representable
+        extend ClassMethods
+      end
+    end
+
+
+    module ClassMethods
+      def items(options)
+        collection :_self, options
+      end
+    end
+
+
+    def create_representation_with(doc, options, format)
+      bin   = representable_mapper(format, options).bindings.first
+      bin.write(doc, represented)
+    end
+
+    def update_properties_from(doc, options, format)
+      bin   = representable_mapper(format, options).bindings.first
+      value = bin.deserialize_from(doc)
+      represented.replace(value)
+    end
+
+    # FIXME: refactor Definition so we can simply add options in #items to existing definition.
+    def representable_attrs
+      attrs = super
+      attrs << Definition.new(:_self, :collection => true) if attrs.size == 0
+      attrs
+    end
+  end
+end

data/lib/representable/hash_methods.rb

@@ -8,13 +8,13 @@ module Representable
     end
 
     def create_representation_with(doc, options, format)
-      bin   = representable_bindings_for(format, options).first
+      bin   = representable_mapper(format, options).bindings.first
       hash  = filter_keys_for(represented, options)
       bin.write(doc, hash)
     end
 
     def update_properties_from(doc, options, format)
-      bin   = representable_bindings_for(format, options).first
+      bin   = representable_mapper(format, options).bindings.first
       hash  = filter_keys_for(doc, options)
       value = bin.deserialize_from(hash)
       represented.replace(value)

data/lib/representable/json.rb

@@ -21,6 +21,11 @@ module Representable
       def from_json(*args, &block)
         create_represented(*args, &block).from_json(*args)
       end
+
+    private
+      def representer_engine
+        Representable::JSON
+      end
     end
 
 

data/lib/representable/json/collection.rb

@@ -1,38 +1,13 @@
+require 'representable/hash/collection'
+
 module Representable::JSON
   module Collection
     include Representable::JSON
 
     def self.included(base)
       base.class_eval do
-        include Representable
-        extend ClassMethods
-      end
-    end
-
-
-    module ClassMethods
-      def items(options)
-        collection :_self, options
+        include Representable::Hash::Collection
       end
     end
-
-
-    def create_representation_with(doc, options, format)
-      bin   = representable_bindings_for(format, options).first
-      bin.serialize_for(represented)
-    end
-
-    def update_properties_from(doc, options, format)
-      bin   = representable_bindings_for(format, options).first
-      value = bin.deserialize_from(doc)
-      represented.replace(value)
-    end
-
-    # FIXME: refactor Definition so we can simply add options in #items to existing definition.
-    def representable_attrs
-      attrs = super
-      attrs << Definition.new(:_self, :collection => true) if attrs.size == 0
-      attrs
-    end
   end
 end

data/lib/representable/mapper.rb

@@ -0,0 +1,78 @@
+require 'representable/feature/readable_writeable'
+
+module Representable
+  # Render and parse by looping over the representer's properties and dispatching to bindings.
+  # Conditionals are handled here, too.
+  class Mapper
+  # DISCUSS: we need @represented here for evaluating the :if blocks. this could be done in the bindings_for asset.
+    module Methods
+      def initialize(bindings, represented, options)
+        @represented  = represented # the (extended) model.
+        @bindings     = bindings
+      end
+
+      attr_reader :bindings
+
+      def deserialize(doc, options)
+        bindings.each do |bin|
+          deserialize_property(bin, doc, options)
+        end
+        represented
+      end
+
+      def serialize(doc, options)
+        bindings.each do |bin|
+          serialize_property(bin, doc, options)
+        end
+        doc
+      end
+
+    private
+      attr_reader :represented
+
+      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
+
+        skip_conditional_property?(binding)
+      end
+
+      def skip_excluded_property?(binding, options)
+        return unless props = options[:exclude] || options[:include]
+        res   = props.include?(binding.name.to_sym)
+        options[:include] ? !res : res
+      end
+
+      def skip_conditional_property?(binding)
+        # TODO: move to Binding.
+        return unless condition = binding.options[:if]
+
+        args = []
+        args << binding.user_options if condition.arity > 0 # TODO: remove arity check. users should know whether they pass options or not.
+
+        not represented.instance_exec(*args, &condition)
+      end
+
+      def compile_fragment(bin, doc)
+        bin.compile_fragment(doc)
+      end
+
+      def uncompile_fragment(bin, doc)
+        bin.uncompile_fragment(doc)
+      end
+    end
+
+    include Methods
+    include Feature::ReadableWriteable # DISCUSS: make this pluggable.
+  end
+end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "1.5.3"
+  VERSION = "1.6.0"
 end

data/lib/representable/xml.rb

@@ -11,12 +11,12 @@ module Representable
         self.representation_wrap = true # let representable compute it.
       end
     end
-    
-    
+
+
     module ClassMethods
       # Creates a new Ruby object from XML using mapping information declared in the class.
       #
-      # Accepts a block yielding the currently iterated Definition. If the block returns false 
+      # Accepts a block yielding the currently iterated Definition. If the block returns false
       # the property is skipped.
       #
       # Example:
@@ -24,29 +24,34 @@ module Representable
       def from_xml(*args, &block)
         create_represented(*args, &block).from_xml(*args)
       end
-      
+
       def from_node(*args, &block)
         create_represented(*args, &block).from_node(*args)
       end
+
+    private
+      def representer_engine
+        Representable::XML
+      end
     end
-    
-    
+
+
     def from_xml(doc, *args)
       node = Nokogiri::XML(doc).root
       from_node(node, *args)
     end
-    
+
     def from_node(node, options={})
       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, PropertyBinding)
     end
-    
+
     def to_xml(*args)
       to_node(*args).to_s
     end

data/lib/representable/xml/collection.rb

@@ -1,38 +1,20 @@
+require 'representable/hash/collection'
+
 module Representable::XML
   module Collection
     include Representable::XML
 
     def self.included(base)
       base.class_eval do
-        include Representable
-        extend ClassMethods
+        include Representable::Hash::Collection
+        include Methods
       end
     end
 
-
-    module ClassMethods
-      def items(options)
-        collection :_self, options
+    module Methods
+      def update_properties_from(doc, *args)
+        super(doc.search("./*"), *args) # pass the list of collection items to Hash::Collection#update_properties_from.
       end
     end
-
-
-    def create_representation_with(doc, options, format)
-      bin   = representable_bindings_for(format, options).first
-      bin.write(doc, represented)
-    end
-
-    def update_properties_from(doc, options, format)
-      bin   = representable_bindings_for(format, options).first
-      value = bin.deserialize_from(doc.search("./*")) # FIXME: use Binding#read.
-      represented.replace(value)
-    end
-
-    # FIXME: refactor Definition so we can simply add options in #items to existing definition.
-    def representable_attrs
-      attrs = super
-      attrs << Definition.new(:_self, :collection => true) if attrs.size == 0
-      attrs
-    end
   end
 end

data/lib/representable/yaml.rb

@@ -4,7 +4,7 @@ require 'representable/bindings/yaml_bindings'
 module Representable
   module YAML
     include Hash
-    
+
     def self.included(base)
       base.class_eval do
         include Representable
@@ -12,12 +12,12 @@ module Representable
         #self.representation_wrap = true # let representable compute it.
       end
     end
-    
-    
+
+
     module ClassMethods
       # Creates a new Ruby object from XML using mapping information declared in the class.
       #
-      # Accepts a block yielding the currently iterated Definition. If the block returns false 
+      # Accepts a block yielding the currently iterated Definition. If the block returns false
       # the property is skipped.
       #
       # Example:
@@ -25,27 +25,32 @@ module Representable
       def from_yaml(*args, &block)
         create_represented(*args, &block).from_yaml(*args)
       end
+
+    private
+      def representer_engine
+        Representable::YAML
+      end
     end
-    
-    
+
+
     def from_yaml(doc, options={})
       hash = Psych.load(doc)
       from_hash(hash, options, PropertyBinding)
     end
-    
+
     # Returns a Nokogiri::XML object representing this object.
     def to_ast(options={})
       #root_tag = options[:wrap] || representation_wrap
-      
+
       Psych::Nodes::Mapping.new.tap do |map|
         create_representation_with(map, options, PropertyBinding)
       end
     end
-    
+
     def to_yaml(*args)
-      stream = Psych::Nodes::Stream.new 
+      stream = Psych::Nodes::Stream.new
       stream.children << doc = Psych::Nodes::Document.new
-      
+
       doc.children << to_ast(*args)
       stream.to_yaml
     end