activerecord 1.9.1 → 1.10.0

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -186,7 +186,7 @@ module ActiveRecord
           when :time      then string_to_dummy_time(value)
           when :date      then string_to_date(value)
           when :binary    then binary_to_string(value)
-          when :boolean   then (value == "t" or value == true ? true : false)
+          when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or value.to_s == '1'
           else value
         end
       end
@@ -205,22 +205,22 @@ module ActiveRecord
 
       private
         def string_to_date(string)
-          return string if string.is_a?(Date)
-          date_array = ParseDate.parsedate(string)
+          return string unless string.is_a?(String)
+          date_array = ParseDate.parsedate(string.to_s)
           # treat 0000-00-00 as nil
           Date.new(date_array[0], date_array[1], date_array[2]) rescue nil
         end
         
         def string_to_time(string)
-          return string if string.is_a?(Time)
-          time_array = ParseDate.parsedate(string).compact
+          return string unless string.is_a?(String)
+          time_array = ParseDate.parsedate(string.to_s).compact
           # treat 0000-00-00 00:00:00 as nil
           Time.send(Base.default_timezone, *time_array) rescue nil
         end
 
         def string_to_dummy_time(string)
-          return string if string.is_a?(Time)
-          time_array = ParseDate.parsedate(string)
+          return string unless string.is_a?(String)
+          time_array = ParseDate.parsedate(string.to_s)
           # pad the resulting array with dummy date information
           time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;
           Time.send(Base.default_timezone, *time_array) rescue nil
@@ -378,8 +378,8 @@ module ActiveRecord
         end
       end
 
-      def create_table(name)
-        execute "CREATE TABLE #{name} (id #{native_database_types[:primary_key]})"
+      def create_table(name, options = "")
+        execute "CREATE TABLE #{name} (id #{native_database_types[:primary_key]}) #{options}"
         table_definition = yield TableDefinition.new
         table_definition.columns.each { |column_name, type, options| add_column(name, column_name, type, options) }
       end

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -190,6 +190,10 @@ module ActiveRecord
         execute "CREATE DATABASE #{name}"
       end
 
+      
+      def create_table(name)
+        super(name, "ENGINE=InnoDB")
+      end
 
       private
         def select(sql, name = nil)

data/lib/active_record/connection_adapters/oci_adapter.rb

@@ -45,7 +45,7 @@ begin
           return nil if value.nil? || value =~ /^\s*null\s*$/i
           case type
           when :string   then value
-          when :integer  then value.to_i
+          when :integer  then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
           when :float    then value.to_f
           when :datetime then cast_to_date_or_time(value)
           when :time     then cast_to_time(value)
@@ -261,4 +261,4 @@ begin
   end
 rescue LoadError
   # OCI8 driver is unavailable.
-end
+end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -203,7 +203,6 @@ module ActiveRecord
               end
             end
           end
-
           log(sql, name, @connection) do |conn|
             conn.execute(sql)
             select_one("SELECT @@IDENTITY AS Ident")["Ident"]
@@ -362,7 +361,7 @@ module ActiveRecord
         end
 
         def query_contains_identity_column(sql, col)
-          return sql =~ /[\(\.\,]\s*#{col}/
+          return sql =~ /[\[.,]\s*#{col}/
         end
 
         def get_order_by(sql)

data/lib/active_record/deprecated_associations.rb

@@ -84,25 +84,7 @@ module ActiveRecord
             !#{association_name}(force_reload).nil?
           end
         end_eval
-      end
-      
-      def deprecated_build_method(method_prefix, collection_name, collection_class_name, class_primary_key_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def #{method_prefix + collection_name}(attributes = {})
-            association = #{collection_class_name}.new
-            association.attributes = attributes.merge({ "#{class_primary_key_name}" => id})
-            association
-          end
-        end_eval
-      end
-
-      def deprecated_create_method(method_prefix, collection_name, collection_class_name, class_primary_key_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def #{method_prefix + collection_name}(attributes = nil)
-            #{collection_class_name}.create((attributes || {}).merge({ "#{class_primary_key_name}" => id}))
-          end
-        end_eval
-      end
+      end      
     end
   end
 end

data/lib/active_record/deprecated_finders.rb

@@ -0,0 +1,41 @@
+module ActiveRecord
+  class Base
+    class << self
+      # This method is deprecated in favor of find with the :conditions option.
+      #
+      # Works like find, but the record matching +id+ must also meet the +conditions+.
+      # +RecordNotFound+ is raised if no record can be found matching the +id+ or meeting the condition.
+      # Example:
+      #   Person.find_on_conditions 5, "first_name LIKE '%dav%' AND last_name = 'heinemeier'"
+      def find_on_conditions(ids, conditions) # :nodoc:
+        find(ids, :conditions => conditions)
+      end
+
+      # This method is deprecated in favor of find(:first, options).
+      #
+      # Returns the object for the first record responding to the conditions in +conditions+, 
+      # such as "group = 'master'". If more than one record is returned from the query, it's the first that'll
+      # be used to create the object. In such cases, it might be beneficial to also specify 
+      # +orderings+, like "income DESC, name", to control exactly which record is to be used. Example: 
+      #   Employee.find_first "income > 50000", "income DESC, name"
+      def find_first(conditions = nil, orderings = nil, joins = nil) # :nodoc:
+        find(:first, :conditions => conditions, :order => orderings, :joins => joins)
+      end
+
+      # This method is deprecated in favor of find(:all, options).
+      #
+      # Returns an array of all the objects that could be instantiated from the associated
+      # table in the database. The +conditions+ can be used to narrow the selection of objects (WHERE-part),
+      # such as by "color = 'red'", and arrangement of the selection can be done through +orderings+ (ORDER BY-part),
+      # such as by "last_name, first_name DESC". A maximum of returned objects and their offset can be specified in 
+      # +limit+ with either just a single integer as the limit or as an array with the first element as the limit, 
+      # the second as the offset. Examples:
+      #   Project.find_all "category = 'accounts'", "last_accessed DESC", 15
+      #   Project.find_all ["category = ?", category_name], "created ASC", [15, 20]
+      def find_all(conditions = nil, orderings = nil, limit = nil, joins = nil) # :nodoc:
+        limit, offset = limit.is_a?(Array) ? limit : [ limit, nil ]
+        find(:all, :conditions => conditions, :order => orderings, :joins => joins, :limit => limit, :offset => offset)
+      end
+    end
+  end
+end

data/lib/active_record/fixtures.rb

@@ -185,7 +185,10 @@ class Fixtures < Hash
   DEFAULT_FILTER_RE = /\.ya?ml$/
 
   def self.instantiate_fixtures(object, table_name, fixtures, load_instances=true)
-    object.instance_variable_set "@#{table_name}", fixtures
+    old_logger_level = ActiveRecord::Base.logger.level
+    ActiveRecord::Base.logger.level = Logger::ERROR
+
+    object.instance_variable_set "@#{table_name.to_s.gsub('.','_')}", fixtures
     if load_instances
       fixtures.each do |name, fixture|
         if model = fixture.find
@@ -193,12 +196,14 @@ class Fixtures < Hash
         end
       end
     end
+
+    ActiveRecord::Base.logger.level = old_logger_level
   end
   
   def self.instantiate_all_loaded_fixtures(object, load_instances=true)
     all_loaded_fixtures.each do |table_name, fixtures|
       Fixtures.instantiate_fixtures(object, table_name, fixtures, load_instances)
-    end  
+    end
   end
   
   cattr_accessor :all_loaded_fixtures
@@ -238,7 +243,7 @@ class Fixtures < Hash
         pk = eval("#{table_class}::primary_key")
         if pk == 'id'
           connection.execute(
-            "SELECT setval('public.#{table.to_s}_id_seq', (SELECT MAX(id) FROM #{table.to_s}), true)", 
+            "SELECT setval('#{table.to_s}_id_seq', (SELECT MAX(id) FROM #{table.to_s}), true)", 
             'Setting Sequence'
           )
         end
@@ -246,6 +251,8 @@ class Fixtures < Hash
     end
   end
 
+  attr_reader :table_name
+
   def initialize(connection, table_name, fixture_path, file_filter = DEFAULT_FILTER_RE)
     @connection, @table_name, @fixture_path, @file_filter = connection, table_name, fixture_path, file_filter
     @class_name = Inflector.classify(@table_name)
@@ -342,7 +349,8 @@ class Fixture #:nodoc:
   end
 
   def key_list
-    @fixture.keys.join(", ")
+    columns = @fixture.keys.collect{ |column_name| ActiveRecord::Base.connection.quote_column_name(column_name) }
+    columns.join(", ")
   end
 
   def value_list
@@ -464,30 +472,35 @@ module Test #:nodoc:
       private
         def load_fixtures
           @loaded_fixtures = {}
-          fixture_table_names.each do |table_name|
-            @loaded_fixtures[table_name] = Fixtures.create_fixtures(fixture_path, table_name)
+          fixtures = Fixtures.create_fixtures(fixture_path, fixture_table_names)
+          unless fixtures.nil?
+            if fixtures.instance_of?(Fixtures)
+              @loaded_fixtures[fixtures.table_name] = fixtures
+            else
+              fixtures.each { |f| @loaded_fixtures[f.table_name] = f }
+            end
           end
         end
-        
+
         # for pre_loaded_fixtures, only require the classes once. huge speed improvement
         @@required_fixture_classes = false
-        
+
         def instantiate_fixtures
           if pre_loaded_fixtures
             raise RuntimeError, 'Load fixtures before instantiating them.' if Fixtures.all_loaded_fixtures.empty?
             unless @@required_fixture_classes
-              self.class.require_fixture_classes Fixtures.all_loaded_fixtures.keys 
+              self.class.require_fixture_classes Fixtures.all_loaded_fixtures.keys
               @@required_fixture_classes = true
             end
             Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
-          else 
+          else
             raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
             @loaded_fixtures.each do |table_name, fixtures|
               Fixtures.instantiate_fixtures(self, table_name, fixtures, load_instances?)
             end
           end
         end
-        
+
         def load_instances?
           use_instantiated_fixtures != :no_instances
         end

data/lib/active_record/observer.rb

@@ -1,10 +1,11 @@
 require 'singleton'
 
 module ActiveRecord
-  # Observers can be programmed to react to lifecycle callbacks in another class to implement
-  # trigger-like behavior outside the original class. This is a great way to reduce the clutter that
-  # normally comes when the model class is burdened with excess responsibility that doesn't pertain to
-  # the core and nature of the class. Example:
+  # Observer classes respond to lifecycle callbacks to implement trigger-like
+  # behavior outside the original class. This is a great way to reduce the
+  # clutter that normally comes when the model class is burdened with
+  # functionality that doesn't pertain to the core responsibility of the
+  # class. Example:
   #
   #   class CommentObserver < ActiveRecord::Observer
   #     def after_save(comment)
@@ -12,13 +13,13 @@ module ActiveRecord
   #     end
   #   end
   #
-  # This Observer is triggered when a Comment#save is finished and sends a notification about it to the administrator.
+  # This Observer sends an email when a Comment#save is finished.
   #
-  # == Observing a class that can't be infered
+  # == Observing a class that can't be inferred
   #
   # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
   # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
-  # something else than the class you're interested in observing, you can implement the observed_class class method. Like this:
+  # differently than the class you're interested in observing, you can use the Observer.observe class method:
   #
   #   class AuditObserver < ActiveRecord::Observer
   #     observe Account
@@ -28,9 +29,7 @@ module ActiveRecord
   #     end
   #   end
   #
-  # == Observing multiple classes at once
-  #
-  # If the audit observer needs to watch more than one kind of object, this can be specified in an array, like this:
+  # If the audit observer needs to watch more than one kind of object, this can be specified with multiple arguments:
   #
   #   class AuditObserver < ActiveRecord::Observer
   #     observe Account, Balance
@@ -42,7 +41,14 @@ module ActiveRecord
   #
   # The AuditObserver will now act on both updates to Account and Balance by treating them both as records.
   #
+  # == Available callback methods
+  #
   # The observer can implement callback methods for each of the methods described in the Callbacks module.
+  #
+  # == Triggering Observers
+  # 
+  # In order to activate an observer, you need to call Observer.instance. In Rails, this can be done in controllers
+  # using the short-hand of for example observer :comment_observer.
   class Observer
     include Singleton
 
@@ -75,4 +81,4 @@ module ActiveRecord
         self.class.name.scan(/(.*)Observer/)[0][0]
       end
   end
-end
+end

data/lib/active_record/reflection.rb

@@ -114,7 +114,11 @@ module ActiveRecord
     # Holds all the meta-data about an association as it was specified in the Active Record class.
     class AssociationReflection < MacroReflection #:nodoc:
       def klass
-        active_record.send(:compute_type, (name_to_class_name(name.id2name)))
+        @klass ||= active_record.send(:compute_type, (name_to_class_name(name.id2name)))
+      end
+      
+      def table_name
+        @table_name ||= klass.table_name
       end
 
       private

data/lib/active_record/transactions.rb

@@ -6,6 +6,9 @@ module ActiveRecord
   module Transactions # :nodoc:
     TRANSACTION_MUTEX = Mutex.new
 
+    class TransactionError < ActiveRecordError # :nodoc:
+    end
+
     def self.append_features(base)
       super
       base.extend(ClassMethods)
@@ -78,6 +81,9 @@ module ActiveRecord
     # Tribute: Object-level transactions are implemented by Transaction::Simple by Austin Ziegler.
     module ClassMethods
       def transaction(*objects, &block)
+        previous_handler = trap('TERM') do
+          raise TransactionError, "Transaction aborted"
+        end
         lock_mutex
         
         begin
@@ -93,6 +99,7 @@ module ActiveRecord
           raise
         ensure
           unlock_mutex
+          trap('TERM', previous_handler)
         end
       end
       

data/lib/active_record/validations.rb

@@ -1,4 +1,7 @@
 module ActiveRecord
+  class RecordInvalid < ActiveRecordError #:nodoc:
+  end
+  
   # Active Record validation is reported to and from this object, which is used by Base#save to
   # determine whether the object in a valid state to be saved. See usage example in Validations.
   class Errors
@@ -291,16 +294,18 @@ module ActiveRecord
       # Configuration options:
       # * <tt>message</tt> - A custom error message (default is: "can't be empty")
       # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
+      # * <tt>accept</tt> - Specifies value that is considered accepted.  The default value is a string "1", which
+      # makes it easy to relate to an HTML checkbox.
       #
-      # NOTE: The agreement is considered valid if it's set to the string "1". This makes it easy to relate it to an HTML checkbox.
+
       def validates_acceptance_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save, :allow_nil => true }
+        configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save, :allow_nil => true, :accept => "1" }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
         attr_accessor *attr_names
 	
         validates_each(attr_names,configuration) do |record, attr_name, value|
-          record.errors.add(attr_name, configuration[:message]) unless value == "1"	  
+          record.errors.add(attr_name, configuration[:message]) unless value == configuration[:accept]
         end
       end
 
@@ -354,12 +359,12 @@ module ActiveRecord
         # Ensure that one and only one range option is specified.
         range_options = ALL_RANGE_OPTIONS & options.keys
         case range_options.size
-        when 0
-          raise ArgumentError, 'Range unspecified.  Specify the :within, :maximum, :minimum, or :is option.'
-        when 1
-          # Valid number of options; do nothing.
-        else
-          raise ArgumentError, 'Too many range options specified.  Choose only one.'
+          when 0
+            raise ArgumentError, 'Range unspecified.  Specify the :within, :maximum, :minimum, or :is option.'
+          when 1
+            # Valid number of options; do nothing.
+          else
+            raise ArgumentError, 'Too many range options specified.  Choose only one.'
         end
 
         # Get range option and value.
@@ -367,33 +372,21 @@ module ActiveRecord
         option_value = options[range_options.first]
 
         # Declare different validations per option.
-        case range_options.first
+        
+        validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
+        message_options = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }
+
+        case option
         when :within, :in
-          raise ArgumentError, ':within must be a Range' unless option_value.is_a?(Range)
-          validates_each(attrs, options) do |record, attr|
-            next if record.send(attr).nil? and options[:allow_nil]
-            record.errors.add_on_boundary_breaking(attr, option_value, options[:too_long], options[:too_short])
-          end
-        when :is
-          raise ArgumentError, ':is must be a nonnegative Integer' unless option_value.is_a?(Integer) and option_value >= 0
-          message = options[:message] || options[:wrong_length]
-          message = (message % option_value) rescue message
-          validates_each(attrs, options) do |record, attr, value|
-            record.errors.add(attr, message) if value.nil? or value.size != option_value
-          end
-        when :minimum
-          raise ArgumentError, ':minimum must be a nonnegative Integer' unless option_value.is_a?(Integer) and option_value >= 0
-          message = options[:message] || options[:too_short]
+          raise ArgumentError, ':within must be a Range' unless option_value.is_a?(Range) # '
+          validates_length_of attrs, :minimum => option_value.begin, :allow_nil => options[:allow_nil]
+          validates_length_of attrs, :maximum => option_value.end, :allow_nil => options[:allow_nil]
+        when :is, :minimum, :maximum
+          raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0 # '
+          message = options[:message] || options[message_options[option]]
           message = (message % option_value) rescue message
           validates_each(attrs, options) do |record, attr, value|
-            record.errors.add(attr, message) if value.nil? or value.size < option_value
-          end
-        when :maximum
-          raise ArgumentError, ':maximum must be a nonnegative Integer' unless option_value.is_a?(Integer) and option_value >= 0
-          message = options[:message] || options[:too_long]
-          message = (message % option_value) rescue message
-          validates_each(attrs, options) do |record, attr, value|
-            record.errors.add(attr, message) if value.nil? or value.size > option_value
+            record.errors.add(attr, message) if value.nil? or !value.size.method(validity_checks[option])[option_value]
           end
         end
       end
@@ -562,6 +555,12 @@ module ActiveRecord
       if perform_validation && valid? || !perform_validation then save_without_validation else false end
     end
 
+    # Attempts to save the record just like Base.save but will raise a RecordInvalid exception instead of returning false
+    # if the record is not valid.
+    def save!
+      valid? ? save_without_validation : raise(RecordInvalid)
+    end
+
     # Updates a single attribute and saves the record without going through the normal validation procedure.
     # This is especially useful for boolean flags on existing records. The regular +update_attribute+ method
     # in Base is replaced with this when the validations module is mixed in, which it is by default.