activerecord 2.3.18 → 3.2.22

data/lib/active_record/store.rb

@@ -0,0 +1,52 @@
+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}=", {}) unless send(store_attribute).is_a?(Hash)
+            send("#{store_attribute}_will_change!")
+            send(store_attribute)[key] = value
+          end
+    
+          define_method(key) do
+            send("#{store_attribute}=", {}) unless send(store_attribute).is_a?(Hash)
+            send(store_attribute)[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/test_case.rb

@@ -1,7 +1,25 @@
-require "active_support/test_case"
-
 module ActiveRecord
+  # = Active Record Test Case
+  #
+  # Defines some test assertions to test against SQL queries.
   class TestCase < ActiveSupport::TestCase #:nodoc:
+    setup :cleanup_identity_map
+
+    def setup
+      cleanup_identity_map
+    end
+
+    def cleanup_identity_map
+      ActiveRecord::IdentityMap.clear
+    end
+
+    # 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)
+      end
+    end
+
     def assert_date_from_db(expected, actual, message = nil)
       # SybaseAdapter doesn't have a separate column type just for dates,
       # so the time is in the string and incorrectly formatted
@@ -13,41 +31,30 @@ module ActiveRecord
     end
 
     def assert_sql(*patterns_to_match)
-      $queries_executed = []
+      ActiveRecord::SQLCounter.log = []
       yield
+      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(&:inspect).join(', ')} not found."
+      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
-      %w{ BEGIN COMMIT }.each { |x| $queries_executed.delete(x) }
-      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)
-    end
-
-    def self.use_concurrent_connections
-      setup :connection_allow_concurrency_setup
-      teardown :connection_allow_concurrency_teardown
-    end
-
-    def connection_allow_concurrency_setup
-      @connection = ActiveRecord::Base.remove_connection
-      ActiveRecord::Base.establish_connection(@connection.merge({:allow_concurrency => true}))
-    end
-
-    def connection_allow_concurrency_teardown
-      ActiveRecord::Base.clear_all_connections!
-      ActiveRecord::Base.establish_connection(@connection)
+    ensure
+      ActiveRecord::SQLCounter.ignored_sql = prev_ignored_sql
     end
 
     def with_kcode(kcode)

data/lib/active_record/timestamp.rb

@@ -1,71 +1,114 @@
+require 'active_support/core_ext/class/attribute'
+
 module ActiveRecord
-  # Active Record automatically timestamps create and update operations if the table has fields
-  # named created_at/created_on or updated_at/updated_on.
+  # = Active Record Timestamp
+  #
+  # Active Record automatically timestamps create and update operations if the
+  # table has fields named <tt>created_at/created_on</tt> or
+  # <tt>updated_at/updated_on</tt>.
+  #
+  # Timestamping can be turned off by setting:
+  #
+  #   config.active_record.record_timestamps = false
+  #
+  # Timestamps are in the local timezone by default but you can use UTC by setting:
+  #
+  #   config.active_record.default_timezone = :utc
+  #
+  # == Time Zone aware attributes
+  #
+  # By default, ActiveRecord::Base keeps all the datetime columns time zone aware by executing following code.
+  #
+  #   config.active_record.time_zone_aware_attributes = true
   #
-  # Timestamping can be turned off by setting
-  #   <tt>ActiveRecord::Base.record_timestamps = false</tt>
+  # This feature can easily be turned off by assigning value <tt>false</tt> .
   #
-  # Timestamps are in the local timezone by default but you can use UTC by setting
-  #   <tt>ActiveRecord::Base.default_timezone = :utc</tt>
+  # If your attributes are time zone aware and you desire to skip time zone conversion to the current Time.zone
+  # when reading certain attributes then you can do following:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     self.skip_time_zone_conversion_for_attributes = [:written_on]
+  #   end
   module Timestamp
-    def self.included(base) #:nodoc:
-      base.alias_method_chain :create, :timestamps
-      base.alias_method_chain :update, :timestamps
+    extend ActiveSupport::Concern
 
-      base.class_inheritable_accessor :record_timestamps, :instance_writer => false
-      base.record_timestamps = true
+    included do
+      class_attribute :record_timestamps
+      self.record_timestamps = true
     end
-    
-    # Saves the record with the updated_at/on attributes set to the current time.
-    # If the save fails because of validation errors, an ActiveRecord::RecordInvalid exception is raised.
-    # If an attribute name is passed, that attribute is used for the touch instead of the updated_at/on attributes.
-    #
-    # Examples:
-    #
-    #   product.touch               # updates updated_at
-    #   product.touch(:designed_at) # updates the designed_at attribute
-    def touch(attribute = nil)
-      current_time = current_time_from_proper_timezone
-
-      if attribute
-        write_attribute(attribute, current_time)
-      else
-        write_attribute('updated_at', current_time) if respond_to?(:updated_at)
-        write_attribute('updated_on', current_time) if respond_to?(:updated_on)
-      end
 
-      save!
+    def initialize_dup(other)
+      clear_timestamp_attributes
+      super
     end
 
+  private
 
-    private
-      def create_with_timestamps #:nodoc:
-        if record_timestamps
-          current_time = current_time_from_proper_timezone
-
-          write_attribute('created_at', current_time) if respond_to?(:created_at) && created_at.nil?
-          write_attribute('created_on', current_time) if respond_to?(:created_on) && created_on.nil?
+    def create #:nodoc:
+      if self.record_timestamps
+        current_time = current_time_from_proper_timezone
 
-          write_attribute('updated_at', current_time) if respond_to?(:updated_at) && updated_at.nil?
-          write_attribute('updated_on', current_time) if respond_to?(:updated_on) && updated_on.nil?
+        all_timestamp_attributes.each do |column|
+          if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
+            write_attribute(column.to_s, current_time)
+          end
         end
-
-        create_without_timestamps
       end
 
-      def update_with_timestamps(*args) #:nodoc:
-        if record_timestamps && (!partial_updates? || changed?)
-          current_time = current_time_from_proper_timezone
+      super
+    end
 
-          write_attribute('updated_at', current_time) if respond_to?(:updated_at)
-          write_attribute('updated_on', current_time) if respond_to?(:updated_on)
-        end
+    def update(*args) #:nodoc:
+      if should_record_timestamps?
+        current_time = current_time_from_proper_timezone
 
-        update_without_timestamps(*args)
+        timestamp_attributes_for_update_in_model.each do |column|
+          column = column.to_s
+          next if attribute_changed?(column)
+          write_attribute(column, current_time)
+        end
       end
-      
-      def current_time_from_proper_timezone
-        self.class.default_timezone == :utc ? Time.now.utc : Time.now
+      super
+    end
+
+    def should_record_timestamps?
+      self.record_timestamps && (!partial_updates? || changed? || (attributes.keys & self.class.serialized_attributes.keys).present?)
+    end
+
+    def timestamp_attributes_for_create_in_model
+      timestamp_attributes_for_create.select { |c| self.class.column_names.include?(c.to_s) }
+    end
+
+    def timestamp_attributes_for_update_in_model
+      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
+    end
+
+    def all_timestamp_attributes_in_model
+      timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+    end
+
+    def timestamp_attributes_for_update #:nodoc:
+      [:updated_at, :updated_on]
+    end
+
+    def timestamp_attributes_for_create #:nodoc:
+      [:created_at, :created_on]
+    end
+
+    def all_timestamp_attributes #:nodoc:
+      timestamp_attributes_for_create + timestamp_attributes_for_update
+    end
+
+    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
+end