activerecord 3.1.11 → 3.2.0

data/lib/active_record/scoping.rb

@@ -0,0 +1,152 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      include Default
+      include Named
+    end
+
+    module ClassMethods
+      # with_scope lets you apply options to inner block incrementally. It takes a hash and the keys must be
+      # <tt>:find</tt> or <tt>:create</tt>. <tt>:find</tt> parameter is <tt>Relation</tt> while
+      # <tt>:create</tt> parameters are an attributes hash.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.create_with_scope
+      #       with_scope(:find => where(:blog_id => 1), :create => { :blog_id => 1 }) do
+      #         find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1
+      #         a = create(1)
+      #         a.blog_id # => 1
+      #       end
+      #     end
+      #   end
+      #
+      # In nested scopings, all previous parameters are overwritten by the innermost rule, with the exception of
+      # <tt>where</tt>, <tt>includes</tt>, and <tt>joins</tt> operations in <tt>Relation</tt>, which are merged.
+      #
+      # <tt>joins</tt> operations are uniqued so multiple scopes can join in the same table without table aliasing
+      # problems. If you need to join multiple tables, but still want one of the tables to be uniqued, use the
+      # array of strings format for your joins.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.find_with_scope
+      #       with_scope(:find => where(:blog_id => 1).limit(1), :create => { :blog_id => 1 }) do
+      #         with_scope(:find => limit(10)) do
+      #           all # => SELECT * from articles WHERE blog_id = 1 LIMIT 10
+      #         end
+      #         with_scope(:find => where(:author_id => 3)) do
+      #           all # => SELECT * from articles WHERE blog_id = 1 AND author_id = 3 LIMIT 1
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # You can ignore any previous scopings by using the <tt>with_exclusive_scope</tt> method.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.find_with_exclusive_scope
+      #       with_scope(:find => where(:blog_id => 1).limit(1)) do
+      #         with_exclusive_scope(:find => limit(10)) do
+      #           all # => SELECT * from articles LIMIT 10
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
+      def with_scope(scope = {}, action = :merge, &block)
+        # If another Active Record class has been passed in, get its current scope
+        scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
+
+        previous_scope = self.current_scope
+
+        if scope.is_a?(Hash)
+          # Dup first and second level of hash (method and params).
+          scope = scope.dup
+          scope.each do |method, params|
+            scope[method] = params.dup unless params == true
+          end
+
+          scope.assert_valid_keys([ :find, :create ])
+          relation = construct_finder_arel(scope[:find] || {})
+          relation.default_scoped = true unless action == :overwrite
+
+          if previous_scope && previous_scope.create_with_value && scope[:create]
+            scope_for_create = if action == :merge
+              previous_scope.create_with_value.merge(scope[:create])
+            else
+              scope[:create]
+            end
+
+            relation = relation.create_with(scope_for_create)
+          else
+            scope_for_create = scope[:create]
+            scope_for_create ||= previous_scope.create_with_value if previous_scope
+            relation = relation.create_with(scope_for_create) if scope_for_create
+          end
+
+          scope = relation
+        end
+
+        scope = previous_scope.merge(scope) if previous_scope && action == :merge
+
+        self.current_scope = scope
+        begin
+          yield
+        ensure
+          self.current_scope = previous_scope
+        end
+      end
+
+      protected
+
+      # Works like with_scope, but discards any nested properties.
+      def with_exclusive_scope(method_scoping = {}, &block)
+        if method_scoping.values.any? { |e| e.is_a?(ActiveRecord::Relation) }
+          raise ArgumentError, <<-MSG
+  New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
+
+  User.unscoped.where(:active => true)
+
+  Or call unscoped with a block:
+
+  User.unscoped do
+  User.where(:active => true).all
+  end
+
+  MSG
+        end
+        with_scope(method_scoping, :overwrite, &block)
+      end
+
+      def current_scope #:nodoc:
+        Thread.current["#{self}_current_scope"]
+      end
+
+      def current_scope=(scope) #:nodoc:
+        Thread.current["#{self}_current_scope"] = scope
+      end
+
+      private
+
+      def construct_finder_arel(options = {}, scope = nil)
+        relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
+        relation = scope.merge(relation) if scope
+        relation
+      end
+
+    end
+
+    def populate_with_current_scope_attributes
+      return unless self.class.scope_attributes?
+
+      self.class.scope_attributes.each do |att,value|
+        send("#{att}=", value) if respond_to?("#{att}=")
+      end
+    end
+
+  end
+end

data/lib/active_record/serialization.rb

@@ -10,50 +10,8 @@ module ActiveRecord #:nodoc:
       options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
       options[:except] |= Array.wrap(self.class.inheritance_column)
 
-      hash = super(options)
-
-      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
-
-      hash
+      super(options)
     end
-
-    private
-      # Add associations specified via the <tt>:include</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 serializable_add_includes(options = {})
-        return unless include_associations = options.delete(:include)
-
-        base_only_or_except = { :except => options[:except],
-                                :only => options[:only] }
-
-        include_has_options = include_associations.is_a?(Hash)
-        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
-
-        associations.each do |association|
-          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
-
-          if records
-            association_options = include_has_options ? include_associations[association] : base_only_or_except
-            opts = options.merge(association_options)
-            yield(association, records, opts)
-          end
-        end
-
-        options[:include] = include_associations
-      end
   end
 end
 

data/lib/active_record/serializers/xml_serializer.rb

@@ -75,7 +75,7 @@ module ActiveRecord #:nodoc:
     #   </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
+    # 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
@@ -179,49 +179,7 @@ module ActiveRecord #:nodoc:
   class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
     def initialize(*args)
       super
-      options[:except] |= Array.wrap(@serializable.class.inheritance_column)
-    end
-
-    def add_extra_behavior
-      add_includes
-    end
-
-    def add_includes
-      procs = options.delete(:procs)
-      @serializable.send(:serializable_add_includes, options) do |association, records, opts|
-        add_associations(association, records, opts)
-      end
-      options[:procs] = procs
-    end
-
-    # TODO This can likely be cleaned up to simple use ActiveSupport::XmlMini.to_tag as well.
-    def add_associations(association, records, opts)
-      association_name = association.to_s.singularize
-      merged_options   = options.merge(opts).merge!(:root => association_name, :skip_instruct => true)
-
-      if records.is_a?(Enumerable)
-        tag  = ActiveSupport::XmlMini.rename_key(association.to_s, options)
-        type = options[:skip_types] ? { } : {:type => "array"}
-
-        if records.empty?
-          @builder.tag!(tag, type)
-        else
-          @builder.tag!(tag, type) do
-            records.each do |record|
-              if options[:skip_types]
-                record_type = {}
-              else
-                record_class = (record.class.to_s.underscore == association_name) ? nil : record.class.name
-                record_type = {:type => record_class}
-              end
-
-              record.to_xml merged_options.merge(record_type)
-            end
-          end
-        end
-      elsif record = @serializable.send(association)
-        record.to_xml(merged_options)
-      end
+      options[:except] = Array.wrap(options[:except]) | Array.wrap(@serializable.class.inheritance_column)
     end
 
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:

data/lib/active_record/session_store.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   # = Active Record Session Store
   #
-  # A session store backed by an Active Record class.  A default class is
+  # A session store backed by an Active Record class. A default class is
   # provided, but any object duck-typing to an Active Record Session class
   # with text +session_id+ and +data+ attributes is sufficient.
   #
@@ -23,7 +23,7 @@ module ActiveRecord
   #   ActiveRecord::SessionStore::Session.data_column_name = 'legacy_session_data'
   #
   # Note that setting the primary key to the +session_id+ frees you from
-  # having a separate +id+ column if you don't want it.  However, you must
+  # having a separate +id+ column if you don't want it. However, you must
   # set <tt>session.model.id = session.session_id</tt> by hand!  A before filter
   # on ApplicationController is a good place.
   #
@@ -46,25 +46,25 @@ module ActiveRecord
   #   save
   #   destroy
   #
-  # The example SqlBypass class is a generic SQL session store.  You may
+  # The example SqlBypass class is a generic SQL session store. You may
   # use it as a basis for high-performance database-specific stores.
   class SessionStore < ActionDispatch::Session::AbstractStore
     module ClassMethods # :nodoc:
       def marshal(data)
-        ActiveSupport::Base64.encode64(Marshal.dump(data)) if data
+        ::Base64.encode64(Marshal.dump(data)) if data
       end
 
       def unmarshal(data)
-        Marshal.load(ActiveSupport::Base64.decode64(data)) if data
+        Marshal.load(::Base64.decode64(data)) if data
       end
 
       def drop_table!
-        connection_pool.clear_table_cache!(table_name)
+        connection.schema_cache.clear_table_cache!(table_name)
         connection.drop_table table_name
       end
 
       def create_table!
-        connection_pool.clear_table_cache!(table_name)
+        connection.schema_cache.clear_table_cache!(table_name)
         connection.create_table(table_name) do |t|
           t.string session_id_column, :limit => 255
           t.text data_column_name
@@ -79,7 +79,7 @@ module ActiveRecord
 
       ##
       # :singleton-method:
-      # Customizable data column name.  Defaults to 'data'.
+      # Customizable data column name. Defaults to 'data'.
       cattr_accessor :data_column_name
       self.data_column_name = 'data'
 
@@ -161,22 +161,22 @@ module ActiveRecord
     end
 
     # A barebones session store which duck-types with the default session
-    # store but bypasses Active Record and issues SQL directly.  This is
+    # store but bypasses Active Record and issues SQL directly. This is
     # an example session model class meant as a basis for your own classes.
     #
     # The database connection, table name, and session id and data columns
-    # are configurable class attributes.  Marshaling and unmarshaling
-    # are implemented as class methods that you may override.  By default,
+    # are configurable class attributes. Marshaling and unmarshaling
+    # are implemented as class methods that you may override. By default,
     # marshaling data is
     #
-    #   ActiveSupport::Base64.encode64(Marshal.dump(data))
+    #   ::Base64.encode64(Marshal.dump(data))
     #
     # and unmarshaling data is
     #
-    #   Marshal.load(ActiveSupport::Base64.decode64(data))
+    #   Marshal.load(::Base64.decode64(data))
     #
     # This marshaling behavior is intended to store the widest range of
-    # binary session data in a +text+ column.  For higher performance,
+    # binary session data in a +text+ column. For higher performance,
     # store in a +blob+ column instead and forgo the Base64 encoding.
     class SqlBypass
       extend ClassMethods
@@ -292,7 +292,7 @@ module ActiveRecord
       end
     end
 
-    # The class used for session storage.  Defaults to
+    # The class used for session storage. Defaults to
     # ActiveRecord::SessionStore::Session
     cattr_accessor :session_class
     self.session_class = Session

data/lib/active_record/store.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
+  # It's like a simple key/value store backed into your record when you don't care about being able to
+  # query that store outside the context of a single record.
+  #
+  # You can then declare accessors to this store that are then accessible just like any other attribute
+  # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
+  # already built around just accessing attributes on the model.
+  #
+  # Make sure that you declare the database column used for the serialized store as a text, so there's
+  # plenty of room.
+  #
+  # Examples:
+  #
+  #   class User < ActiveRecord::Base
+  #     store :settings, accessors: [ :color, :homepage ]
+  #   end
+  #   
+  #   u = User.new(color: 'black', homepage: '37signals.com')
+  #   u.color                          # Accessor stored attribute
+  #   u.settings[:country] = 'Denmark' # Any attribute, even if not specified with an accessor
+  #
+  #   # Add additional accessors to an existing store through store_accessor
+  #   class SuperUser < User
+  #     store_accessor :settings, :privileges, :servants
+  #   end
+  module Store
+    extend ActiveSupport::Concern
+  
+    module ClassMethods
+      def store(store_attribute, options = {})
+        serialize store_attribute, Hash
+        store_accessor(store_attribute, options[:accessors]) if options.has_key? :accessors
+      end
+
+      def store_accessor(store_attribute, *keys)
+        Array(keys).flatten.each do |key|
+          define_method("#{key}=") do |value|
+            send(store_attribute)[key] = value
+            send("#{store_attribute}_will_change!")
+          end
+    
+          define_method(key) do
+            send(store_attribute)[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/test_case.rb

@@ -13,7 +13,7 @@ module ActiveRecord
       ActiveRecord::IdentityMap.clear
     end
 
-    # Backport skip to Ruby 1.8.  test/unit doesn't support it, so just
+    # Backport skip to Ruby 1.8. test/unit doesn't support it, so just
     # make it a noop.
     unless instance_methods.map(&:to_s).include?("skip")
       def skip(message)
@@ -31,26 +31,30 @@ module ActiveRecord
     end
 
     def assert_sql(*patterns_to_match)
-      $queries_executed = []
+      ActiveRecord::SQLCounter.log = []
       yield
-      $queries_executed
+      ActiveRecord::SQLCounter.log
     ensure
       failed_patterns = []
       patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless $queries_executed.any?{ |sql| pattern === sql }
+        failed_patterns << pattern unless ActiveRecord::SQLCounter.log.any?{ |sql| pattern === sql }
       end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
+      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
     end
 
     def assert_queries(num = 1)
-      $queries_executed = []
+      ActiveRecord::SQLCounter.log = []
       yield
     ensure
-      assert_equal num, $queries_executed.size, "#{$queries_executed.size} instead of #{num} queries were executed.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
+      assert_equal num, ActiveRecord::SQLCounter.log.size, "#{ActiveRecord::SQLCounter.log.size} instead of #{num} queries were executed.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
     end
 
     def assert_no_queries(&block)
+      prev_ignored_sql = ActiveRecord::SQLCounter.ignored_sql
+      ActiveRecord::SQLCounter.ignored_sql = []
       assert_queries(0, &block)
+    ensure
+      ActiveRecord::SQLCounter.ignored_sql = prev_ignored_sql
     end
 
     def with_kcode(kcode)

data/lib/active_record/timestamp.rb

@@ -33,10 +33,14 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :record_timestamps, :instance_writer => false
+      class_attribute :record_timestamps
       self.record_timestamps = true
     end
 
+    def initialize_dup(other)
+      clear_timestamp_attributes
+    end
+
   private
 
     def create #:nodoc:
@@ -44,7 +48,9 @@ module ActiveRecord
         current_time = current_time_from_proper_timezone
 
         all_timestamp_attributes.each do |column|
-          write_attribute(column.to_s, current_time) if respond_to?(column) && self.send(column).nil?
+          if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
+            write_attribute(column.to_s, current_time)
+          end
         end
       end
 
@@ -95,6 +101,13 @@ module ActiveRecord
     def current_time_from_proper_timezone #:nodoc:
       self.class.default_timezone == :utc ? Time.now.utc : Time.now
     end
+
+    # Clear attributes and changed_attributes
+    def clear_timestamp_attributes
+      all_timestamp_attributes_in_model.each do |attribute_name|
+        self[attribute_name] = nil
+        changed_attributes.delete(attribute_name)
+      end
+    end
   end
 end
-

data/lib/active_record/transactions.rb

@@ -301,7 +301,7 @@ module ActiveRecord
     protected
 
     # Save the new record state and id of a record so it can be restored later if a transaction fails.
-    def remember_transaction_record_state #:nodoc
+    def remember_transaction_record_state #:nodoc:
       @_start_transaction_state ||= {}
       @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
       unless @_start_transaction_state.include?(:new_record)
@@ -314,7 +314,7 @@ module ActiveRecord
     end
 
     # Clear the new record state and id of a record.
-    def clear_transaction_record_state #:nodoc
+    def clear_transaction_record_state #:nodoc:
       if defined?(@_start_transaction_state)
         @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
         remove_instance_variable(:@_start_transaction_state) if @_start_transaction_state[:level] < 1
@@ -322,7 +322,7 @@ module ActiveRecord
     end
 
     # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
-    def restore_transaction_record_state(force = false) #:nodoc
+    def restore_transaction_record_state(force = false) #:nodoc:
       if defined?(@_start_transaction_state)
         @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
         if @_start_transaction_state[:level] < 1
@@ -341,12 +341,12 @@ module ActiveRecord
     end
 
     # Determine if a record was created or destroyed in a transaction. State should be one of :new_record or :destroyed.
-    def transaction_record_state(state) #:nodoc
+    def transaction_record_state(state) #:nodoc:
       @_start_transaction_state[state] if defined?(@_start_transaction_state)
     end
 
     # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
-    def transaction_include_action?(action) #:nodoc
+    def transaction_include_action?(action) #:nodoc:
       case action
       when :create
         transaction_record_state(:new_record)

data/lib/active_record/translation.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Translation
+    include ActiveModel::Translation
+
+    # Set the lookup ancestors for ActiveModel.
+    def lookup_ancestors #:nodoc:
+      klass = self
+      classes = [klass]
+      return classes if klass == ActiveRecord::Base
+
+      while klass != klass.base_class
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope #:nodoc:
+      :activerecord
+    end
+  end
+end

data/lib/active_record/validations/associated.rb

@@ -2,8 +2,9 @@ module ActiveRecord
   module Validations
     class AssociatedValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        return if (value.is_a?(Array) ? value : [value]).collect{ |r| r.nil? || r.valid? }.all?
-        record.errors.add(attribute, :invalid, options.merge(:value => value))
+        if Array.wrap(value).reject {|r| r.marked_for_destruction? || r.valid?}.any?
+          record.errors.add(attribute, :invalid, options.merge(:value => value))
+        end
       end
     end
 
@@ -29,10 +30,10 @@ module ActiveRecord
       #   validation contexts by default (+nil+), other options are <tt>:create</tt>
       #   and <tt>:update</tt>.
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
       #   method, proc or string should return or evaluate to a true or false value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_associated(*attr_names)
         validates_with AssociatedValidator, _merge_attributes(attr_names)

data/lib/active_record/validations/uniqueness.rb

@@ -57,8 +57,8 @@ module ActiveRecord
         value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
 
         if !options[:case_sensitive] && value && column.text?
-          # will use SQL LOWER function before comparison
-          relation = table[attribute].lower.eq(table.lower(value))
+          # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+          relation = klass.connection.case_insensitive_comparison(table, attribute, column, value)
         else
           value    = klass.connection.case_sensitive_modifier(value)
           relation = table[attribute].eq(value)
@@ -83,7 +83,7 @@ module ActiveRecord
       #     validates_uniqueness_of :user_name, :scope => :account_id
       #   end 
       #
-      # Or even multiple scope parameters.  For example, making sure that a teacher can only be on the schedule once
+      # Or even multiple scope parameters. For example, making sure that a teacher can only be on the schedule once
       # per semester for a particular class.
       #
       #   class TeacherSchedule < ActiveRecord::Base
@@ -105,7 +105,7 @@ module ActiveRecord
       #   The method, proc or string should return or evaluate to a true or false value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
-      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The method, proc or string should
+      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method, proc or string should
       #   return or evaluate to a true or false value.
       #
       # === Concurrency and integrity

data/lib/active_record/validations.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   # = Active Record RecordInvalid
   #
-  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid.  Use the
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
   # +record+ method to retrieve the record which did not validate.
   #
   #   begin

data/lib/active_record/version.rb

@@ -1,8 +1,8 @@
 module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 1
-    TINY  = 11
+    MINOR = 2
+    TINY  = 0
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')