root/trunk/config/active_record_patch.rb

# Patch to ActiveRecord::Base, which makes abstract models sub-classes
# using single table inheritance function correctly.
# Prevents ActiveRecord::Base#add_conditions!() from adding type conditions to
# database queries when a sub-class of an abstract model is using single table inheritance.
# Attribute abstract_class has to be set true in every abstract model.
#
# P.S.
# If one still wants to support abstract models without abstract_class set true, one can use:
#    def self.descends_from_active_record?
#      base_class == self || !column_names.include?(inheritance_column)
#    end
# Although I can't see why anyone would want to do this.
module ActiveRecord
  class Base
    class << self
      def descends_from_active_record?
        base_class == self
      end
    end
  end
end

# Patch to ActiveRecord::ConnectionAdapters.
# Fixes quoting of binary (blob) values on SQLite.
# Previous implementation freguently caused data corruption.
module ActiveRecord
  module ConnectionAdapters
    class SQLiteColumn
      class << self
        def string_to_binary(value)
          value.gsub('%', '%25').gsub("\0", '%00')
        end

        def binary_to_string(value)
          value.gsub('%00', "\0").gsub('%25', '%')
        end
      end
    end
  end
end

# Patch to ActiveRecord::ConnectionAdapters::SqliteAdapter#add_column
# Fixed a bug that made add_column to raise an error when called
# inside a transaction. The error was caused by the execution of
# 'VACUUM', which can't be called when there is an active transaction.
# This may break sqlite versions piror to 3.1.3.
module ActiveRecord
  module ConnectionAdapters
    # For some reason this is required for this to work.
    class SQLite3Adapter
      def add_column(table_name, column_name, type, options = {})
        super(table_name, column_name, type, options)
      end
    end

    # Overwrite add_column so that it only executes 'VACUUM' if there are
    # no active transactions.
    class SQLiteAdapter
      def add_column(table_name, column_name, type, options = {}) #:nodoc:
        super(table_name, column_name, type, options)
        # See last paragraph on http://www.sqlite.org/lang_altertable.html
        # and http://www.sqlite.org/lang_vacuum.html
        execute "VACUUM" unless @connection.transaction_active?
      end
    end
  end
end

# Patch to ActiveRecord::ConnectionAdapaters::PostgreSQLAdapter#quote
# Binary strings are quoted using the escape string syntax (E'...')
module ActiveRecord
  module ConnectionAdapters
    class PostgreSQLAdapter
      alias_method :quote_old, :quote

      def quote(value, column = nil)
        result = quote_old(value, column)
        if value.kind_of?(String) and result.match(/^'/) and column and column.type == :binary
          result = 'E' + result
        end
        return result
      end
    end
  end
end

# Patch to ActiveRecord::Validations::ClassMethods#validates_uniqueness_of.
# Makes the uniqueness validation work correctly with Single Table Inheritance.
# See the Rails Trac: http://dev.rubyonrails.org/ticket/3833
module ActiveRecord
  module Validations
    module ClassMethods
      def validates_uniqueness_of(*attr_names)
        configuration = { :message => ActiveRecord::Errors.default_error_messages[:taken], :case_sensitive => true }
        configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)

        validates_each(attr_names,configuration) do |record, attr_name, value|
          if value.nil? || (configuration[:case_sensitive] || !columns_hash[attr_name.to_s].text?)
            condition_sql = "#{record.class.table_name}.#{attr_name} #{attribute_condition(value)}"
            condition_params = [value]
          else
            condition_sql = "LOWER(#{record.class.table_name}.#{attr_name}) #{attribute_condition(value)}"
            condition_params = [value.downcase]
          end
          if scope = configuration[:scope]
            Array(scope).map do |scope_item|
              scope_value = record.send(scope_item)
              condition_sql << " AND #{record.class.table_name}.#{scope_item} #{attribute_condition(scope_value)}"
              condition_params << scope_value
            end
          end
          unless record.new_record?
            condition_sql << " AND #{record.class.table_name}.#{record.class.primary_key} <> ?"
            condition_params << record.send(:id)
          end
          if self.find(:first, :conditions => [condition_sql, *condition_params])
            record.errors.add(attr_name, configuration[:message])
          end
        end
      end
    end
  end
end