activerecord 2.3.18 → 3.0.0.beta

data/lib/active_record/relation/spawn_methods.rb

@@ -0,0 +1,102 @@
+module ActiveRecord
+  module SpawnMethods
+    def spawn
+      clone.reset
+    end
+
+    def merge(r)
+      merged_relation = spawn
+      return merged_relation unless r
+
+      merged_relation = merged_relation.eager_load(r.eager_load_values).preload(r.preload_values).includes(r.includes_values)
+
+      merged_relation.readonly_value = r.readonly_value unless r.readonly_value.nil?
+      merged_relation.limit_value = r.limit_value if r.limit_value.present?
+      merged_relation.lock_value = r.lock_value unless merged_relation.lock_value
+      merged_relation.offset_value = r.offset_value if r.offset_value.present?
+
+      merged_relation = merged_relation.
+        joins(r.joins_values).
+        group(r.group_values).
+        select(r.select_values).
+        from(r.from_value).
+        having(r.having_values)
+
+      merged_relation.order_values = r.order_values if r.order_values.present?
+
+      merged_relation.create_with_value = @create_with_value
+
+      if @create_with_value && r.create_with_value
+        merged_relation.create_with_value = @create_with_value.merge(r.create_with_value)
+      else
+        merged_relation.create_with_value = r.create_with_value || @create_with_value
+      end
+
+      merged_wheres = @where_values
+
+      r.where_values.each do |w|
+        if w.is_a?(Arel::Predicates::Equality)
+          merged_wheres = merged_wheres.reject {|p| p.is_a?(Arel::Predicates::Equality) && p.operand1.name == w.operand1.name }
+        end
+
+        merged_wheres += [w]
+      end
+
+      merged_relation.where_values = merged_wheres
+
+      merged_relation
+    end
+
+    alias :& :merge
+
+    def except(*skips)
+      result = self.class.new(@klass, table)
+
+      (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values")) unless skips.include?(method)
+      end
+
+      Relation::SINGLE_VALUE_METHODS.each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value")) unless skips.include?(method)
+      end
+
+      result
+    end
+
+    def only(*onlies)
+      result = self.class.new(@klass, table)
+
+      onlies.each do |only|
+        if (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).include?(only)
+          result.send(:"#{only}_values=", send(:"#{only}_values"))
+        elsif Relation::SINGLE_VALUE_METHODS.include?(only)
+          result.send(:"#{only}_value=", send(:"#{only}_value"))
+        else
+          raise "Invalid argument : #{only}"
+        end
+      end
+
+      result
+    end
+
+    VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset,
+                           :order, :select, :readonly, :group, :having, :from, :lock ]
+
+    def apply_finder_options(options)
+      relation = spawn
+      return relation unless options
+
+      options.assert_valid_keys(VALID_FIND_OPTIONS)
+
+      [:joins, :select, :group, :having, :order, :limit, :offset, :from, :lock, :readonly].each do |finder|
+        relation = relation.send(finder, options[finder]) if options.has_key?(finder)
+      end
+
+      relation = relation.where(options[:conditions]) if options.has_key?(:conditions)
+      relation = relation.includes(options[:include]) if options.has_key?(:include)
+
+      relation
+    end
+
+  end
+end

data/lib/active_record/schema_dumper.rb

@@ -1,5 +1,5 @@
 require 'stringio'
-require 'bigdecimal'
+require 'active_support/core_ext/big_decimal'
 
 module ActiveRecord
   # This class is used to dump the database schema for some connection to some
@@ -102,8 +102,15 @@ HEADER
             next if column.name == pk
             spec = {}
             spec[:name]      = column.name.inspect
-            spec[:type]      = column.type.to_s
-            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal
+            
+            # AR has an optimisation which handles zero-scale decimals as integers.  This
+            # code ensures that the dumper still dumps the column as a decimal.
+            spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
+                                 'decimal'
+                               else
+                                 column.type.to_s
+                               end
+            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
             spec[:precision] = column.precision.inspect if !column.precision.nil?
             spec[:scale]     = column.scale.inspect if !column.scale.nil?
             spec[:null]      = 'false' if !column.null
@@ -171,9 +178,6 @@ HEADER
             statment_parts << (':name => ' + index.name.inspect)
             statment_parts << ':unique => true' if index.unique
 
-            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
-            statment_parts << (':length => ' + Hash[*index.columns.zip(index.lengths).flatten].inspect) if index_lengths.present?
-
             '  ' + statment_parts.join(', ')
           end
 

data/lib/active_record/serialization.rb

@@ -1,101 +1,58 @@
-require 'active_support/json'
-
 module ActiveRecord #:nodoc:
   module Serialization
-    class Serializer #:nodoc:
-      attr_reader :options
-
-      def initialize(record, options = nil)
-        @record = record
-        @options = options ? options.dup : {}
-      end
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
 
-      # To replicate the behavior in ActiveRecord#attributes,
-      # <tt>:except</tt> takes precedence over <tt>:only</tt>.  If <tt>:only</tt> is not set
-      # for a N level model but is set for the N+1 level models,
-      # then because <tt>:except</tt> is set to a default value, the second
-      # level model can have both <tt>:except</tt> and <tt>:only</tt> set.  So if
-      # <tt>:only</tt> is set, always delete <tt>:except</tt>.
-      def serializable_attribute_names
-        attribute_names = @record.attribute_names
+    def serializable_hash(options = nil)
+      options ||= {}
 
-        if options[:only]
-          options.delete(:except)
-          attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s }
-        else
-          options[:except] = Array(options[:except]) | Array(@record.class.inheritance_column)
-          attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
-        end
+      options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+      options[:except] |= Array.wrap(self.class.inheritance_column)
 
-        attribute_names
-      end
+      hash = super(options)
 
-      def serializable_method_names
-        Array(options[:methods]).inject([]) do |method_attributes, name|
-          method_attributes << name if @record.respond_to?(name.to_s)
-          method_attributes
-        end
+      serializable_add_includes(options) do |association, records, opts|
+        hash[association] = records.is_a?(Enumerable) ?
+          records.map { |r| r.serializable_hash(opts) } :
+          records.serializable_hash(opts)
       end
 
-      def serializable_names
-        serializable_attribute_names + serializable_method_names
-      end
+      hash
+    end
 
+    private
       # Add associations specified via the <tt>:includes</tt> option.
       # Expects a block that takes as arguments:
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized
       #   +opts+        - options for the association records
-      def add_includes(&block)
-        if include_associations = options.delete(:include)
-          base_only_or_except = { :except => options[:except],
-                                  :only => options[:only] }
+      def serializable_add_includes(options = {})
+        return unless include_associations = options.delete(:include)
 
-          include_has_options = include_associations.is_a?(Hash)
-          associations = include_has_options ? include_associations.keys : Array(include_associations)
+        base_only_or_except = { :except => options[:except],
+                                :only => options[:only] }
 
-          for association in associations
-            records = case @record.class.reflect_on_association(association).macro
-            when :has_many, :has_and_belongs_to_many
-              @record.send(association).to_a
-            when :has_one, :belongs_to
-              @record.send(association)
-            end
+        include_has_options = include_associations.is_a?(Hash)
+        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
 
-            unless records.nil?
-              association_options = include_has_options ? include_associations[association] : base_only_or_except
-              opts = options.merge(association_options)
-              yield(association, records, opts)
-            end
+        for association in associations
+          records = case self.class.reflect_on_association(association).macro
+          when :has_many, :has_and_belongs_to_many
+            send(association).to_a
+          when :has_one, :belongs_to
+            send(association)
           end
 
-          options[:include] = include_associations
-        end
-      end
-
-      def serializable_record
-        {}.tap do |serializable_record|
-          serializable_names.each { |name| serializable_record[name] = @record.send(name) }
-          add_includes do |association, records, opts|
-            if records.is_a?(Enumerable)
-              serializable_record[association] = records.collect { |r| self.class.new(r, opts).serializable_record }
-            else
-              serializable_record[association] = self.class.new(records, opts).serializable_record
-            end
+          unless records.nil?
+            association_options = include_has_options ? include_associations[association] : base_only_or_except
+            opts = options.merge(association_options)
+            yield(association, records, opts)
           end
         end
-      end
 
-      def serialize
-        # overwrite to implement
+        options[:include] = include_associations
       end
-
-      def to_s(&block)
-        serialize(&block)
-      end
-    end
   end
 end
 
 require 'active_record/serializers/xml_serializer'
-require 'active_record/serializers/json_serializer'

data/lib/active_record/serializers/xml_serializer.rb

@@ -1,5 +1,9 @@
+require 'active_support/core_ext/hash/conversions'
+
 module ActiveRecord #:nodoc:
   module Serialization
+    include ActiveModel::Serializers::Xml
+
     # Builds an XML document to represent the model. Some configuration is
     # available through +options+. However more complicated cases should
     # override ActiveRecord::Base#to_xml.
@@ -69,6 +73,21 @@ module ActiveRecord #:nodoc:
     #     </account>
     #   </firm>
     #
+    # Additionally, the record being serialized will be passed to a Proc's second
+    # parameter.  This allows for ad hoc additions to the resultant document that
+    # incorporate the context of the record being serialized. And by leveraging the
+    # closure created by a Proc, to_xml can be used to add elements that normally fall
+    # outside of the scope of the model -- for example, generating and appending URLs
+    # associated with models.
+    # 
+    #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
+    #   firm.to_xml :procs => [ proc ]
+    #
+    #   <firm>
+    #     # ... normal attributes as shown above ...
+    #     <name-reverse>slangis73</name-reverse>
+    #   </firm>
+    #
     # To include deeper levels of associations pass a hash like this:
     #
     #   firm.to_xml :include => {:account => {}, :clients => {:include => :address}}
@@ -152,82 +171,27 @@ module ActiveRecord #:nodoc:
     #     end
     #   end
     def to_xml(options = {}, &block)
-      serializer = XmlSerializer.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
+      XmlSerializer.new(self, options).serialize(&block)
     end
   end
 
-  class XmlSerializer < ActiveRecord::Serialization::Serializer #:nodoc:
-    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.model_name.singular).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 reformat_name(name)
-      name = name.camelize if camelize?
-      dasherize? ? name.dasherize : name
+  class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
+    def initialize(*args)
+      super
+      options[:except] |= Array.wrap(@serializable.class.inheritance_column)
     end
 
     def serializable_attributes
-      serializable_attribute_names.collect { |name| Attribute.new(name, @record) }
+      serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
     end
 
     def serializable_method_attributes
       Array(options[:methods]).inject([]) do |method_attributes, name|
-        method_attributes << MethodAttribute.new(name.to_s, @record) if @record.respond_to?(name.to_s)
+        method_attributes << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
         method_attributes
       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 add_associations(association, records, opts)
       if records.is_a?(Enumerable)
         tag = reformat_name(association.to_s)
@@ -251,7 +215,7 @@ module ActiveRecord #:nodoc:
           end
         end
       else
-        if record = @record.send(association)
+        if record = @serializable.send(association)
           record.to_xml(opts.merge(:root => association))
         end
       end
@@ -270,61 +234,19 @@ module ActiveRecord #:nodoc:
       builder.tag!(*args) do
         add_attributes
         procs = options.delete(:procs)
-        add_includes { |association, records, opts| add_associations(association, records, opts) }
+        @serializable.send(:serializable_add_includes, options) { |association, records, opts|
+          add_associations(association, records, opts)
+        }
         options[:procs] = procs
         add_procs
         yield builder if block_given?
       end
     end
 
-    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 <tt>tag!</tt> 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 <tt>tag!</tt> method. It definitely makes
-      # no sense to Base64 encode the value and then give it to
-      # <tt>tag!</tt>, 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
-
-        if value.nil?
-          decorations[:nil] = true
-        end
-
-        decorations
-      end
-
+    class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
       protected
         def compute_type
-          type = if @record.class.serialized_attributes.has_key?(name)
-                   :yaml
-                 else
-                   @record.class.columns_hash[name].try(:type)
-                 end
+          type = @serializable.class.serialized_attributes.has_key?(name) ? :yaml : @serializable.class.columns_hash[name].type
 
           case type
             when :text
@@ -335,22 +257,12 @@ module ActiveRecord #:nodoc:
               type
           end
         end
-
-        def compute_value
-          value = @record.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[@record.send(name).class.name] || :string
+          Hash::XML_TYPE_NAMES[@serializable.send(name).class.name] || :string
         end
     end
   end