activerecord 1.4.0 → 1.5.0

data/lib/active_record/associations/has_many_association.rb

@@ -2,37 +2,17 @@ module ActiveRecord
   module Associations
     class HasManyAssociation < AssociationCollection #:nodoc:
       def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        super(owner, association_name, association_class_name, association_class_primary_key_name, options)
+        super
         @conditions = sanitize_sql(options[:conditions])
 
-        if options[:finder_sql]
-          @finder_sql = interpolate_sql(options[:finder_sql])
-        else
-          @finder_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}"
-          @finder_sql << " AND #{@conditions}" if @conditions
-        end
-
-        if options[:counter_sql]
-          @counter_sql = interpolate_sql(options[:counter_sql])
-        elsif options[:finder_sql]
-          options[:counter_sql] = options[:finder_sql].gsub(/SELECT (.*) FROM/i, "SELECT COUNT(*) FROM")
-          @counter_sql = interpolate_sql(options[:counter_sql])
-        else
-          @counter_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}#{@conditions ? " AND " + interpolate_sql(@conditions) : ""}"
-        end
-      end
-
-      def create(attributes = {})
-        # Can't use Base.create since the foreign key may be a protected attribute.
-        record = build(attributes)
-        record.save
-        @collection << record if loaded?
-        record
+        construct_sql
       end
 
       def build(attributes = {})
+        load_target
         record = @association_class.new(attributes)
-        record[@association_class_primary_key_name] = @owner.id
+        record[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
+        @target << record
         record
       end
 
@@ -77,10 +57,10 @@ module ActiveRecord
         elsif @options[:finder_sql]
           if ids.size == 1
             id = ids.first
-            record = load_collection.detect { |record| id == record.id }
+            record = load_target.detect { |record| id == record.id }
             expects_array? ? [record] : record
           else
-            load_collection.select { |record| ids.include?(record.id) }
+            load_target.select { |record| ids.include?(record.id) }
           end
 
         # Otherwise, delegate to association class with conditions.
@@ -94,12 +74,12 @@ module ActiveRecord
       # method calls may be chained.
       def clear
         @association_class.update_all("#{@association_class_primary_key_name} = NULL", "#{@association_class_primary_key_name} = #{@owner.quoted_id}")
-        @collection = []
+        @target = []
         self
       end
 
       protected
-        def find_all_records
+        def find_target
           find_all
         end
 
@@ -122,7 +102,8 @@ module ActiveRecord
         end
 
         def insert_record(record)
-          record.update_attribute(@association_class_primary_key_name, @owner.id)
+          record[@association_class_primary_key_name] = @owner.id
+          record.save
         end
 
         def delete_records(records)
@@ -132,6 +113,29 @@ module ActiveRecord
             "#{@association_class_primary_key_name} = #{@owner.quoted_id} AND #{@association_class.primary_key} IN (#{ids})"
           )
         end
+
+        def target_obsolete?
+          false
+        end
+
+        def construct_sql
+          if @options[:finder_sql]
+            @finder_sql = interpolate_sql(@options[:finder_sql])
+          else
+            @finder_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}"
+            @finder_sql << " AND #{interpolate_sql(@conditions)}" if @conditions
+          end
+
+          if @options[:counter_sql]
+            @counter_sql = interpolate_sql(@options[:counter_sql])
+          elsif @options[:finder_sql]
+            @options[:counter_sql] = @options[:finder_sql].gsub(/SELECT (.*) FROM/i, "SELECT COUNT(*) FROM")
+            @counter_sql = interpolate_sql(@options[:counter_sql])
+          else
+            @counter_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}"
+            @counter_sql << " AND #{interpolate_sql(@conditions)}" if @conditions
+          end
+        end
     end
   end
 end

data/lib/active_record/associations/has_one_association.rb

@@ -0,0 +1,48 @@
+module ActiveRecord
+  module Associations
+    class HasOneAssociation < BelongsToAssociation #:nodoc:
+      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
+        super
+
+        construct_sql
+      end
+
+      def replace(obj, dont_save = false)
+        load_target
+        unless @target.nil?
+          @target[@association_class_primary_key_name] = nil
+          @target.save unless @owner.new_record?
+        end
+
+        if obj.nil?
+          @target = nil
+        else
+          raise_on_type_mismatch(obj)
+          
+          obj[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
+          @target = obj
+        end
+
+        @loaded = true
+        unless @owner.new_record? or obj.nil? or dont_save
+          return (obj.save ? obj : false)
+        else
+          return obj
+        end
+      end
+      
+      private
+        def find_target
+          @association_class.find_first(@finder_sql, @options[:order])
+        end
+
+        def target_obsolete?
+          false
+        end
+
+        def construct_sql
+          @finder_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}#{@options[:conditions] ? " AND " + @options[:conditions] : ""}"
+        end
+    end
+  end
+end

data/lib/active_record/base.rb

@@ -789,7 +789,6 @@ module ActiveRecord #:nodoc:
       # * A record does exist: Updates the record with values matching those of the object attributes.
       def save
         create_or_update
-        return true
       end
     
       # Deletes the record in the database and freezes this instance to reflect that no changes should
@@ -808,17 +807,7 @@ module ActiveRecord #:nodoc:
 
       # Returns a clone of the record that hasn't been assigned an id yet and is treated as a new record.
       def clone
-        attr = Hash.new
-
-        self.attribute_names.each do |name|
-          begin
-            attr[name] = read_attribute(name).clone
-          rescue TypeError
-            attr[name] = read_attribute(name)
-          end
-        end
-
-        cloned_record = self.class.new(attr)
+        cloned_record = self.class.new(self.attributes)
         cloned_record.instance_variable_set "@new_record", true
         cloned_record.id = nil
         cloned_record
@@ -829,7 +818,7 @@ module ActiveRecord #:nodoc:
       # doesn't get subjected to validation checks. Hence, attributes can be updated even if the full object isn't valid.
       def update_attribute(name, value)
         self[name] = value
-        return true
+        save
       end
 
       # Updates all the attributes in from the passed hash and saves the record. If the object is invalid, the saving will
@@ -839,17 +828,59 @@ module ActiveRecord #:nodoc:
         return save
       end
 
+      # Initializes the +attribute+ to zero if nil and adds one. Only makes sense for number-based attributes. Returns self.
+      def increment(attribute)
+        self[attribute] ||= 0
+        self[attribute] += 1
+        self
+      end
+      
+      # Increments the +attribute+ and saves the record.
+      def increment!(attribute)
+        increment(attribute).update_attribute(attribute, self[attribute])
+      end
+
+      # Initializes the +attribute+ to zero if nil and subtracts one. Only makes sense for number-based attributes. Returns self.
+      def decrement(attribute)
+        self[attribute] ||= 0
+        self[attribute] -= 1
+        self
+      end
+
+      # Decrements the +attribute+ and saves the record.
+      def decrement!(attribute)
+        decrement(attribute).update_attribute(attribute, self[attribute])
+      end
+      
+      # Turns an +attribute+ that's currently true into false and vice versa. Returns self.
+      def toggle(attribute)
+        self[attribute] = quote(!send("#{attribute}?", column_for_attribute(attribute)))
+        self
+      end
+
+      # Toggles the +attribute+ and saves the record.
+      def toggle!(attribute)
+        toggle(attribute).update_attribute(attribute, self[attribute])
+      end
+
+      # Reloads the attributes of this object from the database.
+      def reload
+        clear_association_cache
+        @attributes.update(self.class.find(self.id).instance_variable_get('@attributes'))
+        return self
+      end
+
       # Returns the value of attribute identified by <tt>attr_name</tt> after it has been type cast (for example, 
       # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
       # (Alias for the protected read_attribute method).
       def [](attr_name) 
-        read_attribute(attr_name)
+        read_attribute(attr_name.to_s)
       end
       
       # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
       # (Alias for the protected write_attribute method).
       def []= (attr_name, value) 
-        write_attribute(attr_name, value)
+        write_attribute(attr_name.to_s, value)
       end
 
       # Allows you to set all the attributes at once by passing in a hash with keys
@@ -867,6 +898,18 @@ module ActiveRecord #:nodoc:
         assign_multiparameter_attributes(multi_parameter_attributes)
       end
 
+      # Returns a hash of all the attributes with their names as keys and clones of their objects as values.
+      def attributes
+        self.attribute_names.inject({}) do |attributes, name|
+          begin
+            attributes[name] = read_attribute(name).clone
+          rescue TypeError
+            attributes[name] = read_attribute(name)
+          end
+          attributes
+        end
+      end
+
       # Returns true if the specified +attribute+ has been set by the user or by a database load and is neither
       # nil nor empty? (the latter only applies to objects that responds to empty?, most notably Strings).
       def attribute_present?(attribute)
@@ -881,12 +924,12 @@ module ActiveRecord #:nodoc:
 
       # Returns the column object for the named attribute.
       def column_for_attribute(name)
-        self.class.columns_hash[name]
+        self.class.columns_hash[name.to_s]
       end
             
-      # Returns true if the +comparison_object+ is of the same type and has the same id.
+      # Returns true if the +comparison_object+ is the same object, or is of the same type and has the same id.
       def ==(comparison_object)
-        comparison_object.instance_of?(self.class) && comparison_object.id == id
+        comparison_object.equal?(self) or (comparison_object.instance_of?(self.class) and comparison_object.id == id)
       end
 
       # Delegates to ==
@@ -912,6 +955,7 @@ module ActiveRecord #:nodoc:
     private
       def create_or_update
         if new_record? then create else update end
+        return true
       end
 
       # Updates the associated record with values matching those of the instant attributes.

data/lib/active_record/callbacks.rb

@@ -153,6 +153,12 @@ module ActiveRecord
   # to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, after_find and
   # after_initialize can only be declared using an explicit implementation. So using the inheritable callback queue for after_find and
   # after_initialize won't work.
+  #
+  # == Cancelling callbacks
+  #
+  # If a before_* callback returns false, all the later callbacks and the associated action are cancelled. If an after_* callback returns
+  # false, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of callbacks
+  # defined as methods on the model, which are called last.
   module Callbacks
     CALLBACKS = %w(
       after_find after_initialize before_save after_save before_create after_create before_update after_update before_validation
@@ -227,7 +233,7 @@ module ActiveRecord
     # Is called _after_ Base.save (regardless of whether it's a create or update save).
     def after_save()  end
     def create_or_update_with_callbacks #:nodoc:
-      callback(:before_save)
+      return false if callback(:before_save) == false
       result = create_or_update_without_callbacks
       callback(:after_save)
       result
@@ -239,7 +245,7 @@ module ActiveRecord
     # Is called _after_ Base.save on new objects that haven't been saved yet (no record exists).
     def after_create() end
     def create_with_callbacks #:nodoc:
-      callback(:before_create)
+      return false if callback(:before_create) == false
       result = create_without_callbacks
       callback(:after_create)
       result
@@ -252,7 +258,7 @@ module ActiveRecord
     def after_update() end
 
     def update_with_callbacks #:nodoc:
-      callback(:before_update)
+      return false if callback(:before_update) == false
       result = update_without_callbacks
       callback(:after_update)
       result
@@ -281,8 +287,9 @@ module ActiveRecord
     def after_validation_on_update()  end
 
     def valid_with_callbacks #:nodoc:
-      callback(:before_validation)
-      if new_record? then callback(:before_validation_on_create) else callback(:before_validation_on_update) end
+      return false if callback(:before_validation) == false
+      if new_record? then result = callback(:before_validation_on_create) else result = callback(:before_validation_on_update) end
+      return false if result == false
 
       result = valid_without_callbacks
 
@@ -298,7 +305,7 @@ module ActiveRecord
     # Is called _after_ Base.destroy (and all the attributes have been frozen).
     def after_destroy()  end
     def destroy_with_callbacks #:nodoc:
-      callback(:before_destroy)
+      return false if callback(:before_destroy) == false
       result = destroy_without_callbacks
       callback(:after_destroy)
       result
@@ -307,7 +314,7 @@ module ActiveRecord
     private
       def callback(method)
         callbacks_for(method).each do |callback|
-          case callback
+          result = case callback
             when Symbol
               self.send(callback)
             when String
@@ -321,9 +328,11 @@ module ActiveRecord
                 raise ActiveRecordError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
               end
           end
+          return false if result == false
         end
 
         invoke_and_notify(method)
+        true
       end
 
       def callbacks_for(method)
@@ -340,4 +349,4 @@ module ActiveRecord
         self.class.notify_observers(method, self)
       end
   end
-end
+end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -89,7 +89,7 @@ module ActiveRecord
             raise AdapterNotSpecified, "#{spec} database is not configured"
           end
         else
-          spec = symbolize_strings_in_hash(spec)
+          spec = spec.symbolize_keys
           unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
           adapter_method = "#{spec[:adapter]}_connection"
           unless respond_to?(adapter_method) then raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter" end
@@ -152,10 +152,7 @@ module ActiveRecord
 
     # Converts all strings in a hash to symbols.
     def self.symbolize_strings_in_hash(hash)
-      hash.inject({}) do |hash_with_symbolized_strings, pair|
-        hash_with_symbolized_strings[pair.first.to_sym] = pair.last
-        hash_with_symbolized_strings
-      end
+      hash.symbolize_keys
     end
   end
 
@@ -356,7 +353,7 @@ module ActiveRecord
       end
 
       def quote_column_name(name)
-        return name
+        name
       end
 
       # Returns a string of the CREATE TABLE SQL statements for recreating the entire structure of the database.
@@ -367,16 +364,20 @@ module ActiveRecord
       end
 
       protected
-        def log(sql, name, connection, &action)
+        def log(sql, name, connection = nil)
+          connection ||= @connection
           begin
             if @logger.nil? || @logger.level > Logger::INFO
-              action.call(connection)
-            else
+              yield connection
+            elsif block_given?
               result = nil
-              bm = measure { result = action.call(connection) }
+              bm = measure { result = yield connection }
               @runtime += bm.real
               log_info(sql, name, bm.real)
               result
+            else
+              log_info(sql, name, 0)
+              nil
             end
           rescue => e
             log_info("#{e.message}: #{sql}", name, 0)

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -13,6 +13,7 @@ module ActiveRecord
           # Only use the supplied backup Ruby/MySQL driver if no driver is already in place
           begin 
             require 'active_record/vendor/mysql'
+            require 'active_record/vendor/mysql411'
           rescue LoadError
             raise cannot_require_mysql
           end

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -37,6 +37,7 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
+
     class PostgreSQLAdapter < AbstractAdapter # :nodoc:
       def select_all(sql, name = nil)
         select(sql, name)
@@ -76,6 +77,14 @@ module ActiveRecord
       def commit_db_transaction()   execute "COMMIT" end
       def rollback_db_transaction() execute "ROLLBACK" end
 
+      def quote(value, column = nil)
+        if value.class == String && column && column.type == :binary
+          quote_bytea(value)
+        else
+          super
+        end
+      end
+
       def quote_column_name(name)
         return "\"#{name}\""
       end
@@ -96,13 +105,31 @@ module ActiveRecord
             fields = res.fields
             results.each do |row|
               hashed_row = {}
-              row.each_index { |cel_index| hashed_row[fields[cel_index]] = row[cel_index] }
+              row.each_index do |cel_index|
+                column = row[cel_index]
+                if res.type(cel_index) == 17  # type oid for bytea
+                  column = unescape_bytea(column)
+                end
+                hashed_row[fields[cel_index]] = column
+              end
               rows << hashed_row
             end
           end
           return rows
         end
 
+        def quote_bytea(s)
+          "'#{escape_bytea(s)}'"
+        end
+
+        def escape_bytea(s)
+          s.gsub(/\\/) { '\\\\\\\\' }.gsub(/[^\\]/) { |c| sprintf('\\\\%03o', c[0].to_i) }
+        end
+
+        def unescape_bytea(s)
+          s.gsub(/\\([0-9][0-9][0-9])/) { $1.oct.chr }.gsub(/\\\\/) { '\\' }
+        end
+
         def split_table_schema(table_name)
           schema_split = table_name.split('.')
           schema_name = "public"
@@ -141,6 +168,7 @@ module ActiveRecord
             when 'numeric', 'real', 'money'      then 'float'
             when 'character varying', 'interval' then 'string'
             when 'timestamp without time zone'   then 'datetime'
+            when 'bytea'                         then 'binary'
             else field_type
           end