Initial extraction of AMo xml serializer

4 files changed, 243 insertions, 15 deletions

diff --git a/activemodel/lib/active_model.rb b/activemodel/lib/active_model.rb
index 544121c593..f988cd71b8 100644
--- a/activemodel/lib/active_model.rb
+++ b/activemodel/lib/active_model.rb
@@ -34,6 +34,7 @@ module ActiveModel
   autoload :Naming, 'active_model/naming'
   autoload :Observer, 'active_model/observing'
   autoload :Observing, 'active_model/observing'
+  autoload :Serializer, 'active_model/serializer'
   autoload :StateMachine, 'active_model/state_machine'
   autoload :TestCase, 'active_model/test_case'
   autoload :Validations, 'active_model/validations'
@@ -41,6 +42,7 @@ module ActiveModel
 
   module Serializers
     autoload :JSON, 'active_model/serializers/json'
+    autoload :Xml, 'active_model/serializers/xml'
   end
 end
 
diff --git a/activemodel/lib/active_model/serializer.rb b/activemodel/lib/active_model/serializer.rb
new file mode 100644
index 0000000000..7a55921e85
--- /dev/null
+++ b/activemodel/lib/active_model/serializer.rb
@@ -0,0 +1,54 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+
+module ActiveModel
+  class Serializer
+    attr_reader :options
+
+    def initialize(serializable, options = nil)
+      @serializable = serializable
+      @options = options ? options.dup : {}
+    end
+
+    def serialize
+      raise NotImplemented
+    end
+
+    def to_s(&block)
+      serialize(&block)
+    end
+
+    protected
+      def serializable_attribute_names
+        attribute_names = @serializable.attributes.keys
+
+        if options[:only]
+          only = Array.wrap(options[:only]).map { |n| n.to_s }
+          attribute_names &= only
+        elsif options[:except]
+          except = Array.wrap(options[:except]).map { |n| n.to_s }
+          attribute_names -= except
+        end
+
+        attribute_names
+      end
+
+      def serializable_method_names
+        Array.wrap(options[:methods]).inject([]) do |methods, name|
+          methods << name if @serializable.respond_to?(name.to_s)
+          methods
+        end
+      end
+
+      def serializable_names
+        serializable_attribute_names + serializable_method_names
+      end
+
+      def serializable_hash
+        serializable_names.inject({}) { |hash, name|
+          hash[name] = @serializable.send(name)
+          hash
+        }
+      end
+  end
+end
diff --git a/activemodel/lib/active_model/serializers/json.rb b/activemodel/lib/active_model/serializers/json.rb
index 440fe47e34..0636e8c330 100644
--- a/activemodel/lib/active_model/serializers/json.rb
+++ b/activemodel/lib/active_model/serializers/json.rb
@@ -1,7 +1,5 @@
 require 'active_support/json'
 require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
 
 module ActiveModel
   module Serializers
@@ -15,26 +13,32 @@ module ActiveModel
         cattr_accessor :include_root_in_json, :instance_writer => false
       end
 
-      def encode_json(encoder)
-        options = encoder.options || {}
-
-        hash = if options[:only]
-          only = Array.wrap(options[:only]).map { |attr| attr.to_s }
-          attributes.slice(*only)
-        elsif options[:except]
-          except = Array.wrap(options[:except]).map { |attr| attr.to_s }
-          attributes.except(*except)
-        else
-          attributes
+      class Serializer < ActiveModel::Serializer
+        def serializable_hash
+          model = super
+          if @serializable.include_root_in_json
+            model = { @serializable.class.model_name.element => model }
+          end
+          model
+        end
+
+        def serialize
+          ActiveSupport::JSON.encode(serializable_hash)
         end
+      end
 
-        hash = { self.class.model_name.element => hash } if include_root_in_json
-        ActiveSupport::JSON.encode(hash)
+      def encode_json(encoder)
+        Serializer.new(self, encoder.options).to_s
       end
 
       def as_json(options = nil)
         self
       end
+
+      def from_json(json)
+        self.attributes = ActiveSupport::JSON.decode(json)
+        self
+      end
     end
   end
 end
diff --git a/activemodel/lib/active_model/serializers/xml.rb b/activemodel/lib/active_model/serializers/xml.rb
new file mode 100644
index 0000000000..d187859b44
--- /dev/null
+++ b/activemodel/lib/active_model/serializers/xml.rb
@@ -0,0 +1,168 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/hash/conversions'
+
+module ActiveModel
+  module Serializers
+    module Xml
+      extend ActiveSupport::Concern
+      include ActiveModel::Attributes
+
+      class Serializer < ActiveModel::Serializer #:nodoc:
+        class Attribute #:nodoc:
+          attr_reader :name, :value, :type
+
+          def initialize(name, serializable)
+            @name, @serializable = name, serializable
+            @type  = compute_type
+            @value = compute_value
+          end
+
+          def needs_encoding?
+            ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
+          end
+
+          def decorations(include_types = true)
+            decorations = {}
+
+            if type == :binary
+              decorations[:encoding] = 'base64'
+            end
+
+            if include_types && type != :string
+              decorations[:type] = type
+            end
+
+            if value.nil?
+              decorations[:nil] = true
+            end
+
+            decorations
+          end
+
+          protected
+            def compute_type
+              value = @serializable.send(name)
+              type = Hash::XML_TYPE_NAMES[value.class.name]
+              type ||= :string if value.respond_to?(:to_str)
+              type ||= :yaml
+              type
+            end
+
+            def compute_value
+              value = @serializable.send(name)
+
+              if formatter = Hash::XML_FORMATTING[type.to_s]
+                value ? formatter.call(value) : nil
+              else
+                value
+              end
+            end
+        end
+
+        class MethodAttribute < Attribute #:nodoc:
+          protected
+            def compute_type
+              Hash::XML_TYPE_NAMES[@serializable.send(name).class.name] || :string
+            end
+        end
+
+        def builder
+          @builder ||= begin
+            require 'builder' unless defined? ::Builder
+            options[:indent] ||= 2
+            builder = options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
+
+            unless options[:skip_instruct]
+              builder.instruct!
+              options[:skip_instruct] = true
+            end
+
+            builder
+          end
+        end
+
+        def root
+          root = (options[:root] || @serializable.class.to_s.underscore).to_s
+          reformat_name(root)
+        end
+
+        def dasherize?
+          !options.has_key?(:dasherize) || options[:dasherize]
+        end
+
+        def camelize?
+          options.has_key?(:camelize) && options[:camelize]
+        end
+
+        def serializable_attributes
+          serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
+        end
+
+        def serializable_method_attributes
+          Array(options[:methods]).inject([]) do |methods, name|
+            methods << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
+            methods
+          end
+        end
+
+        def add_attributes
+          (serializable_attributes + serializable_method_attributes).each do |attribute|
+            add_tag(attribute)
+          end
+        end
+
+        def add_procs
+          if procs = options.delete(:procs)
+            [ *procs ].each do |proc|
+              proc.call(options)
+            end
+          end
+        end
+
+        def add_tag(attribute)
+          builder.tag!(
+            reformat_name(attribute.name),
+            attribute.value.to_s,
+            attribute.decorations(!options[:skip_types])
+          )
+        end
+
+        def serialize
+          args = [root]
+
+          if options[:namespace]
+            args << {:xmlns => options[:namespace]}
+          end
+
+          if options[:type]
+            args << {:type => options[:type]}
+          end
+
+          builder.tag!(*args) do
+            add_attributes
+            procs = options.delete(:procs)
+            options[:procs] = procs
+            add_procs
+            yield builder if block_given?
+          end
+        end
+
+        private
+          def reformat_name(name)
+            name = name.camelize if camelize?
+            dasherize? ? name.dasherize : name
+          end
+      end
+
+      def to_xml(options = {}, &block)
+        serializer = Serializer.new(self, options)
+        block_given? ? serializer.to_s(&block) : serializer.to_s
+      end
+
+      def from_xml(xml)
+        self.attributes = Hash.from_xml(xml).values.first
+        self
+      end
+    end
+  end
+end