mongo_mapper_ign 0.7.7 → 0.7.8

data/lib/mongo_mapper/plugins/serialization/array.rb

@@ -1,56 +1,56 @@
-# Credit: http://github.com/tsxn26/array-xml_serialization
-
-# Extends the XML serialization support in activesupport to allow for 
-# arrays containing strings, symbols, and integers.
-
-# Forces elements in arrays to be output using to_xml on each element if the 
-# element responds to to_xml. If an element does not respond to to_xml then a 
-# nested XML tag is created with the element's to_s value and the singlarized name 
-# of the array as the tag name. 
-
-require 'rubygems'
-require 'activesupport'
-require 'builder'
-
-class Array
-  def to_xml(options = {})
-    #raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
-    require 'builder' unless defined?(Builder)
-
-    options = options.dup
-    options[:root] ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
-    options[:children] ||= options[:root].singularize
-    options[:indent] ||= 2
-    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-
-    root = options.delete(:root).to_s
-    children = options.delete(:children)
-
-    if !options.has_key?(:dasherize) || options[:dasherize]
-      root = root.dasherize
-    end
-
-    options[:builder].instruct! unless options.delete(:skip_instruct)
-
-    opts = options.merge({ :root => children })
-
-    root = root.pluralize
-    
-    xml = options[:builder]
-    if empty?
-      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
-    else
-      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) do
-        yield xml if block_given?
-        each do |e|
-          if e.respond_to? :to_xml
-            e.to_xml(opts.merge({ :skip_instruct => true }))
-          else
-            xml.tag!(root.singularize, e.to_s)
-          end
-        end
-      end
-    end
-  end
-end
-
+# Credit: http://github.com/tsxn26/array-xml_serialization
+
+# Extends the XML serialization support in activesupport to allow for 
+# arrays containing strings, symbols, and integers.
+
+# Forces elements in arrays to be output using to_xml on each element if the 
+# element responds to to_xml. If an element does not respond to to_xml then a 
+# nested XML tag is created with the element's to_s value and the singlarized name 
+# of the array as the tag name. 
+
+require 'rubygems'
+require 'activesupport'
+require 'builder'
+
+class Array
+  def to_xml(options = {})
+    #raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+    require 'builder' unless defined?(Builder)
+
+    options = options.dup
+    options[:root] ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
+    options[:children] ||= options[:root].singularize
+    options[:indent] ||= 2
+    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+    root = options.delete(:root).to_s
+    children = options.delete(:children)
+
+    if !options.has_key?(:dasherize) || options[:dasherize]
+      root = root.dasherize
+    end
+
+    options[:builder].instruct! unless options.delete(:skip_instruct)
+
+    opts = options.merge({ :root => children })
+
+    root = root.pluralize
+    
+    xml = options[:builder]
+    if empty?
+      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
+    else
+      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) do
+        yield xml if block_given?
+        each do |e|
+          if e.respond_to? :to_xml
+            e.to_xml(opts.merge({ :skip_instruct => true }))
+          else
+            xml.tag!(root.singularize, e.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongo_mapper/plugins/serialization/xml_serializer.rb

@@ -1,240 +1,240 @@
-module MongoMapper
-  module Plugins
-    module Serialization
-
-        class XmlSerializer #:nodoc:
-          attr_reader :options
-
-          def initialize(record, options = {})
-            @record, @options = record, options.dup
-          end
-
-          def builder
-            @builder ||= begin
-              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] || @record.class.to_s.underscore).to_s
-            dasherize? ? root.dasherize : root
-          end
-
-          def dasherize?
-            !options.has_key?(:dasherize) || options[:dasherize]
-          end
-
-
-          # To replicate the behavior in ActiveRecord#attributes,
-          # :except takes precedence over :only. If :only is not set
-          # for a N level model but is set for the N+1 level models,
-          # then because :except is set to a default value, the second
-          # level model can have both :except and :only set. So if
-          # :only is set, always delete :except.
-          def serializable_attributes
-            #attribute_names = @record.attributes.keys # This includes all attributes including associations
-            attribute_names = @record.class.keys.keys # This includes just keys
-            idex = attribute_names.index("_id")
-            attribute_names[idex] = "id" if idex
-
-            if options[:only]
-              options.delete(:except)
-              attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s }
-            else
-              options[:except] = Array(options[:except]) 
-              attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
-            end
-
-            attribute_names.collect { |name| Attribute.new(name, @record) }
-          end
-
-          def serializable_method_attributes
-            Array(options[:methods]).collect { |name| MethodAttribute.new(name.to_s, @record) }
-          end
-
-          def add_attributes
-            (serializable_attributes + serializable_method_attributes).each do |attribute|
-              add_tag(attribute)
-            end
-          end
-
-          def add_includes
-            if include_associations = options.delete(:include)
-              root_only_or_except = { :except => options[:except],
-                                      :only => options[:only] }
-
-              include_has_options = include_associations.is_a?(Hash)
-
-              for association in include_has_options ? include_associations.keys : Array(include_associations)
-                association_options = include_has_options ? include_associations[association] : root_only_or_except
-
-                opts = options.merge(association_options)
-
-                case @record.class.associations[association].type
-                when :many, :has_and_belongs_to_many
-                  records = @record.send(association).to_a
-                  unless records.empty?
-                    tag = association.to_s
-                    tag = tag.dasherize if dasherize?
-
-                    builder.tag!(tag) do
-                      records.each { |r| r.to_xml(opts.merge(:root=>r.class.to_s.underscore)) }
-                    end
-                  end
-                when :has_one, :belongs_to
-                  if record = @record.send(association)
-                    record.to_xml(opts.merge(:root => association))
-                  end
-                end
-              end
-
-              options[:include] = include_associations
-            end
-          end
-
-          def add_procs
-            if procs = options.delete(:procs)
-              [ *procs ].each do |proc|
-                proc.call(options)
-              end
-            end
-          end
-
-
-          def add_tag(attribute)
-            if attribute.type == :array 
-              builder.tag!(
-                dasherize? ? attribute.name.dasherize.pluralize : attribute.name.pluralize,
-                attribute.decorations(!options[:skip_types])
-              ) do |x|
-                attribute.value.each do |val|
-                  if val.respond_to? :to_xml
-                    x << val.to_xml(:skip_instruct => true, :root => attribute.name.dasherize.singularize)
-                  else
-                    x.tag!(
-                      dasherize? ? attribute.name.dasherize.singularize : attribute.name.singularize,
-                      val.to_s
-                    )
-                  end
-                end
-              end
-            else
-              builder.tag!(
-                dasherize? ? attribute.name.dasherize : attribute.name,
-                attribute.value.to_s,
-                attribute.decorations(!options[:skip_types])
-              )
-            end
-          end
-
-          def serialize
-            args = [root]
-            if options[:namespace]
-              args << {:xmlns=>options[:namespace]}
-            end
-
-            builder.tag!(*args) do
-              add_attributes
-              add_includes
-              add_procs
-              yield builder if block_given?
-            end
-          end
-
-          alias_method :to_s, :serialize
-
-          class Attribute #:nodoc:
-            attr_reader :name, :value, :type
-
-            def initialize(name, record)
-              @name, @record = name, record
-
-              @type = compute_type
-              @value = compute_value
-            end
-
-            # There is a significant speed improvement if the value
-            # does not need to be escaped, as #tag! escapes all values
-            # to ensure that valid XML is generated. For known binary
-            # values, it is at least an order of magnitude faster to
-            # Base64 encode binary values and directly put them in the
-            # output XML than to pass the original value or the Base64
-            # encoded value to the #tag! method. It definitely makes
-            # no sense to Base64 encode the value and then give it to
-            # #tag!, since that just adds additional overhead.
-            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
-
-              decorations
-            end
-
-            protected
-              def compute_type
-                if name == "id"
-                  return :object_id
-                end
-
-                #type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type
-                v = @record.class.keys[name]
-                #puts "Value type is...........  #{v.type.to_s} #{v.type.to_s.blank?}"
-
-                #type = @record.send(name).class
-
-                type = v.nil? ? :yaml : (v.type.to_s.blank? ? :key : v.type.to_s.underscore.to_sym)
-
-                case type
-                  when :text
-                    :string
-                  when :time
-                    :datetime
-      #            when :array
-      #              :yaml
-                  else
-                    type
-                end
-              end
-
-              def compute_value
-                n = name == "id" ? "_id" : name
-
-                value = @record.send(n)
-
-                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[@record.send(name).class.name] || :string
-              end
-          end
-      end      
-
-    end
-  end
+module MongoMapper
+  module Plugins
+    module Serialization
+
+        class XmlSerializer #:nodoc:
+          attr_reader :options
+
+          def initialize(record, options = {})
+            @record, @options = record, options.dup
+          end
+
+          def builder
+            @builder ||= begin
+              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] || @record.class.to_s.underscore).to_s
+            dasherize? ? root.dasherize : root
+          end
+
+          def dasherize?
+            !options.has_key?(:dasherize) || options[:dasherize]
+          end
+
+
+          # To replicate the behavior in ActiveRecord#attributes,
+          # :except takes precedence over :only. If :only is not set
+          # for a N level model but is set for the N+1 level models,
+          # then because :except is set to a default value, the second
+          # level model can have both :except and :only set. So if
+          # :only is set, always delete :except.
+          def serializable_attributes
+            #attribute_names = @record.attributes.keys # This includes all attributes including associations
+            attribute_names = @record.class.keys.keys # This includes just keys
+            idex = attribute_names.index("_id")
+            attribute_names[idex] = "id" if idex
+
+            if options[:only]
+              options.delete(:except)
+              attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s }
+            else
+              options[:except] = Array(options[:except]) 
+              attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
+            end
+
+            attribute_names.collect { |name| Attribute.new(name, @record) }
+          end
+
+          def serializable_method_attributes
+            Array(options[:methods]).collect { |name| MethodAttribute.new(name.to_s, @record) }
+          end
+
+          def add_attributes
+            (serializable_attributes + serializable_method_attributes).each do |attribute|
+              add_tag(attribute)
+            end
+          end
+
+          def add_includes
+            if include_associations = options.delete(:include)
+              root_only_or_except = { :except => options[:except],
+                                      :only => options[:only] }
+
+              include_has_options = include_associations.is_a?(Hash)
+
+              for association in include_has_options ? include_associations.keys : Array(include_associations)
+                association_options = include_has_options ? include_associations[association] : root_only_or_except
+
+                opts = options.merge(association_options)
+
+                case @record.class.associations[association].type
+                when :many, :has_and_belongs_to_many
+                  records = @record.send(association).to_a
+                  unless records.empty?
+                    tag = association.to_s
+                    tag = tag.dasherize if dasherize?
+
+                    builder.tag!(tag) do
+                      records.each { |r| r.to_xml(opts.merge(:root=>r.class.to_s.underscore)) }
+                    end
+                  end
+                when :has_one, :belongs_to
+                  if record = @record.send(association)
+                    record.to_xml(opts.merge(:root => association))
+                  end
+                end
+              end
+
+              options[:include] = include_associations
+            end
+          end
+
+          def add_procs
+            if procs = options.delete(:procs)
+              [ *procs ].each do |proc|
+                proc.call(options)
+              end
+            end
+          end
+
+
+          def add_tag(attribute)
+            if attribute.type == :array 
+              builder.tag!(
+                dasherize? ? attribute.name.dasherize.pluralize : attribute.name.pluralize,
+                attribute.decorations(!options[:skip_types])
+              ) do |x|
+                attribute.value.each do |val|
+                  if val.respond_to? :to_xml
+                    x << val.to_xml(:skip_instruct => true, :root => attribute.name.dasherize.singularize)
+                  else
+                    x.tag!(
+                      dasherize? ? attribute.name.dasherize.singularize : attribute.name.singularize,
+                      val.to_s
+                    )
+                  end
+                end
+              end
+            else
+              builder.tag!(
+                dasherize? ? attribute.name.dasherize : attribute.name,
+                attribute.value.to_s,
+                attribute.decorations(!options[:skip_types])
+              )
+            end
+          end
+
+          def serialize
+            args = [root]
+            if options[:namespace]
+              args << {:xmlns=>options[:namespace]}
+            end
+
+            builder.tag!(*args) do
+              add_attributes
+              add_includes
+              add_procs
+              yield builder if block_given?
+            end
+          end
+
+          alias_method :to_s, :serialize
+
+          class Attribute #:nodoc:
+            attr_reader :name, :value, :type
+
+            def initialize(name, record)
+              @name, @record = name, record
+
+              @type = compute_type
+              @value = compute_value
+            end
+
+            # There is a significant speed improvement if the value
+            # does not need to be escaped, as #tag! escapes all values
+            # to ensure that valid XML is generated. For known binary
+            # values, it is at least an order of magnitude faster to
+            # Base64 encode binary values and directly put them in the
+            # output XML than to pass the original value or the Base64
+            # encoded value to the #tag! method. It definitely makes
+            # no sense to Base64 encode the value and then give it to
+            # #tag!, since that just adds additional overhead.
+            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
+
+              decorations
+            end
+
+            protected
+              def compute_type
+                if name == "id"
+                  return :object_id
+                end
+
+                #type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type
+                v = @record.class.keys[name]
+                #puts "Value type is...........  #{v.type.to_s} #{v.type.to_s.blank?}"
+
+                #type = @record.send(name).class
+
+                type = v.nil? ? :yaml : (v.type.to_s.blank? ? :key : v.type.to_s.underscore.to_sym)
+
+                case type
+                  when :text
+                    :string
+                  when :time
+                    :datetime
+      #            when :array
+      #              :yaml
+                  else
+                    type
+                end
+              end
+
+              def compute_value
+                n = name == "id" ? "_id" : name
+
+                value = @record.send(n)
+
+                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[@record.send(name).class.name] || :string
+              end
+          end
+      end      
+
+    end
+  end
 end