Initial extraction of AMo xml serializer

7 files changed, 346 insertions, 20 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
diff --git a/activemodel/test/cases/json_serialization_test.rb b/activemodel/test/cases/serializeration/json_serialization_test.rb
index e50922493d..3e69db110e 100644
--- a/activemodel/test/cases/json_serialization_test.rb
+++ b/activemodel/test/cases/serializeration/json_serialization_test.rb
@@ -1,11 +1,11 @@
 require 'cases/helper'
+require 'models/contact'
 
-class JsonSerializationTest < ActiveModel::TestCase
-  class Contact
-    include ActiveModel::Serializers::JSON
-    attr_accessor :name, :age, :created_at, :awesome, :preferences
-  end
+class Contact
+  include ActiveModel::Serializers::JSON
+end
 
+class JsonSerializationTest < ActiveModel::TestCase
   def setup
     @contact = Contact.new
     @contact.name = 'Konata Izumi'
@@ -60,4 +60,18 @@ class JsonSerializationTest < ActiveModel::TestCase
     assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
+
+  test "methds are called on object" do
+    # Define methods on fixture.
+    def @contact.label; "Has cheezburger"; end
+    def @contact.favorite_quote; "Constraints are liberating"; end
+
+    # Single method.
+    assert_match %r{"label":"Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+
+    # Both methods.
+    methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+    assert_match %r{"label":"Has cheezburger"}, methods_json
+    assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
+  end
 end
diff --git a/activemodel/test/cases/serializeration/xml_serialization_test.rb b/activemodel/test/cases/serializeration/xml_serialization_test.rb
new file mode 100644
index 0000000000..57792e900e
--- /dev/null
+++ b/activemodel/test/cases/serializeration/xml_serialization_test.rb
@@ -0,0 +1,81 @@
+require 'cases/helper'
+require 'models/contact'
+
+class Contact
+  include ActiveModel::Serializers::Xml
+end
+
+class XmlSerializationTest < ActiveModel::TestCase
+  def setup
+    @contact = Contact.new
+    @contact.name = 'aaron stack'
+    @contact.age = 25
+    @contact.created_at = Time.utc(2006, 8, 1)
+    @contact.awesome = false
+    @contact.preferences = { :gem => 'ruby' }
+  end
+
+  test "should serialize default root" do
+    @xml = @contact.to_xml
+    assert_match %r{^<contact>},  @xml
+    assert_match %r{</contact>$}, @xml
+  end
+
+  test "should serialize default root with namespace" do
+    @xml = @contact.to_xml :namespace => "http://xml.rubyonrails.org/contact"
+    assert_match %r{^<contact xmlns="http://xml.rubyonrails.org/contact">}, @xml
+    assert_match %r{</contact>$}, @xml
+  end
+
+  test "should serialize custom root" do
+    @xml = @contact.to_xml :root => 'xml_contact'
+    assert_match %r{^<xml-contact>},  @xml
+    assert_match %r{</xml-contact>$}, @xml
+  end
+
+  test "should allow undasherized tags" do
+    @xml = @contact.to_xml :root => 'xml_contact', :dasherize => false
+    assert_match %r{^<xml_contact>},  @xml
+    assert_match %r{</xml_contact>$}, @xml
+    assert_match %r{<created_at},     @xml
+  end
+
+  test "should allow camelized tags" do
+    @xml = @contact.to_xml :root => 'xml_contact', :camelize => true
+    assert_match %r{^<XmlContact>},  @xml
+    assert_match %r{</XmlContact>$}, @xml
+    assert_match %r{<CreatedAt},     @xml
+  end
+
+  test "should allow skipped types" do
+    @xml = @contact.to_xml :skip_types => true
+    assert %r{<age>25</age>}.match(@xml)
+  end
+
+  test "should include yielded additions" do
+    @xml = @contact.to_xml do |xml|
+      xml.creator "David"
+    end
+    assert_match %r{<creator>David</creator>}, @xml
+  end
+
+  test "should serialize string" do
+    assert_match %r{<name>aaron stack</name>}, @contact.to_xml
+  end
+
+  test "should serialize integer" do
+    assert_match %r{<age type="integer">25</age>}, @contact.to_xml
+  end
+
+  test "should serialize datetime" do
+    assert_match %r{<created-at type=\"datetime\">2006-08-01T00:00:00Z</created-at>}, @contact.to_xml
+  end
+
+  test "should serialize boolean" do
+    assert_match %r{<awesome type=\"boolean\">false</awesome>}, @contact.to_xml
+  end
+
+  test "should serialize yaml" do
+    assert_match %r{<preferences type=\"yaml\">--- \n:gem: ruby\n</preferences>}, @contact.to_xml
+  end
+end
diff --git a/activemodel/test/models/contact.rb b/activemodel/test/models/contact.rb
new file mode 100644
index 0000000000..7d69c91996
--- /dev/null
+++ b/activemodel/test/models/contact.rb
@@ -0,0 +1,3 @@
+class Contact
+  attr_accessor :name, :age, :created_at, :awesome, :preferences
+end