activerecord 1.0.0

data/lib/active_record/callbacks.rb

@@ -0,0 +1,337 @@
+require 'observer'
+
+module ActiveRecord
+  # Callbacks are hooks into the lifecycle of an Active Record object that allows you to trigger logic
+  # before or after an alteration of the object state. This can be used to make sure that associated and 
+  # dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes
+  # before they're validated (by overwriting before_validation). As an example of the callbacks initiated, consider
+  # the Base#save call:
+  #
+  # * (-) save
+  # * (-) valid?
+  # * (1) before_validation
+  # * (2) before_validation_on_create
+  # * (-) validate
+  # * (-) validate_on_create
+  # * (4) after_validation
+  # * (5) after_validation_on_create 
+  # * (6) before_save
+  # * (7) before_create
+  # * (-) create
+  # * (8) after_create
+  # * (9) after_save
+  # 
+  # That's a total of nine callbacks, which gives you immense power to react and prepare for each state in the
+  # Active Record lifecyle.
+  #
+  # Examples:
+  #   class CreditCard < ActiveRecord::Base
+  #     # Strip everything but digits, so the user can specify "555 234 34" or 
+  #     # "5552-3434" or both will mean "55523434"
+  #     def before_validation_on_create
+  #       self.number = number.gsub(/[^0-9]/, "") if attribute_present?("number")
+  #     end
+  #   end
+  #
+  #   class Subscription < ActiveRecord::Base
+  #     # Automatically assign the signup date
+  #     def before_create
+  #       self.signed_up_on = Date.today
+  #     end
+  #   end
+  #
+  #   class Firm < ActiveRecord::Base
+  #     # Destroys the associated clients and people when the firm is destroyed
+  #     def before_destroy
+  #       Client.destroy_all "client_of = #{id}"
+  #       Person.destroy_all "firm_id = #{id}"
+  #     end
+  #
+  # == Inheritable callback queues
+  #
+  # Besides the overwriteable callback methods, it's also possible to register callbacks through the use of the callback macros.
+  # Their main advantage is that the macros add behavior into a callback queue that is kept intact down through an inheritance
+  # hierarchy. Example:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     before_destroy :destroy_author
+  #   end
+  #
+  #   class Reply < Topic
+  #     before_destroy :destroy_readers
+  #   end
+  #
+  # Now, when Topic#destroy is run only +destroy_author+ is called. When Reply#destroy is run both +destroy_author+ and
+  # +destroy_readers+ is called. Contrast this to the situation where we've implemented the save behavior through overwriteable
+  # methods:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     def before_destroy() destroy_author end
+  #   end
+  #
+  #   class Reply < Topic
+  #     def before_destroy() destroy_readers end
+  #   end
+  #
+  # In that case, Reply#destroy would only run +destroy_readers+ and _not_ +destroy_author+. So use the callback macros when 
+  # you want to ensure that a certain callback is called for the entire hierarchy and the regular overwriteable methods when you
+  # want to leave it up to each descendent to decide whether they want to call +super+ and trigger the inherited callbacks.
+  #
+  # == Types of callbacks
+  #
+  # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects, 
+  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects are the
+  # recommended approaches, inline methods using a proc is some times appropriate (such as for creating mix-ins), and inline
+  # eval methods are deprecated.
+  #
+  # The method reference callbacks work by specifying a protected or private method available in the object, like this:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     before_destroy :delete_parents
+  #
+  #     private
+  #       def delete_parents
+  #         self.class.delete_all "parent_id = #{id}"
+  #       end
+  #   end
+  #
+  # The callback objects have methods named after the callback called with the record as the only parameter, such as:
+  #
+  #   class BankAccount < ActiveRecord::Base
+  #     before_save      EncryptionWrapper.new("credit_card_number")
+  #     after_save       EncryptionWrapper.new("credit_card_number")
+  #     after_initialize EncryptionWrapper.new("credit_card_number")
+  #   end
+  #
+  #   class EncryptionWrapper
+  #     def initialize(attribute)
+  #       @attribute = attribute
+  #     end
+  #
+  #     def before_save(record)
+  #       record.credit_card_number = encrypt(record.credit_card_number)
+  #     end
+  #
+  #     def after_save(record)
+  #       record.credit_card_number = decrypt(record.credit_card_number)
+  #     end
+  #     
+  #     alias_method :after_initialize, :after_save
+  #
+  #     private
+  #       def encrypt(value)
+  #         # Secrecy is committed
+  #       end
+  #
+  #       def decrypt(value)
+  #         # Secrecy is unvieled
+  #       end
+  #   end
+  #
+  # So you specify the object you want messaged on a given callback. When that callback is triggered, the object has
+  # a method by the name of the callback messaged.
+  #
+  # The callback macros usually accept a symbol for the method they're supposed to run, but you can also pass a "method string",
+  # which will then be evaluated within the binding of the callback. Example:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"'
+  #   end
+  #
+  # Notice that single plings (') are used so the #{id} part isn't evaluated until the callback is triggered. Also note that these
+  # inline callbacks can be stacked just like the regular ones:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"', 
+  #                    'puts "Evaluated after parents are destroyed"'
+  #   end
+  #
+  # == The after_find and after_initialize exceptions
+  #
+  # Because after_find and after_initialize is called for each object instantiated found by a finder, such as Base.find_all, we've had
+  # 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.
+  module Callbacks
+    CALLBACKS = %w( 
+      after_find after_initialize before_save after_save before_create after_create before_update after_update before_validation 
+      after_validation before_validation_on_create after_validation_on_create before_validation_on_update
+      after_validation_on_update before_destroy after_destroy
+    )
+
+    def self.append_features(base) #:nodoc:
+      super
+
+      base.extend(ClassMethods)
+      base.class_eval do
+        class << self
+          include Observable
+          alias_method :instantiate_without_callbacks, :instantiate
+          alias_method :instantiate, :instantiate_with_callbacks
+        end
+      end
+
+      base.class_eval do
+        alias_method :initialize_without_callbacks, :initialize
+        alias_method :initialize, :initialize_with_callbacks
+
+        alias_method :create_or_update_without_callbacks, :create_or_update
+        alias_method :create_or_update, :create_or_update_with_callbacks
+
+        alias_method :valid_without_callbacks, :valid?
+        alias_method :valid?, :valid_with_callbacks
+
+        alias_method :create_without_callbacks, :create
+        alias_method :create, :create_with_callbacks
+
+        alias_method :update_without_callbacks, :update
+        alias_method :update, :update_with_callbacks
+
+        alias_method :destroy_without_callbacks, :destroy
+        alias_method :destroy, :destroy_with_callbacks
+      end
+
+      CALLBACKS.each { |cb| base.class_eval("def self.#{cb}(*methods) write_inheritable_array(\"#{cb}\", methods) end") }
+    end
+
+    module ClassMethods #:nodoc:
+      def instantiate_with_callbacks(record)
+        object = instantiate_without_callbacks(record)
+        object.callback(:after_find) if object.respond_to_without_attributes?(:after_find)
+        object.callback(:after_initialize) if object.respond_to_without_attributes?(:after_initialize)
+        object
+      end
+    end
+
+    # Is called when the object was instantiated by one of the finders, like Base.find.
+    # def after_find() end
+
+    # Is called after the object has been instantiated by a call to Base.new.
+    # def after_initialize() end
+    def initialize_with_callbacks(attributes = nil) #:nodoc:
+      initialize_without_callbacks(attributes)
+      yield self if block_given?
+      after_initialize if respond_to_without_attributes?(:after_initialize)
+    end
+    
+    # Is called _before_ Base.save (regardless of whether it's a create or update save).
+    def before_save() end
+
+    # 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)
+      create_or_update_without_callbacks
+      callback(:after_save)
+    end
+
+    # Is called _before_ Base.save on new objects that haven't been saved yet (no record exists).
+    def before_create() end
+
+    # 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)
+      create_without_callbacks
+      callback(:after_create)
+    end
+
+    # Is called _before_ Base.save on existing objects that has a record.
+    def before_update() end
+
+    # Is called _after_ Base.save on existing objects that has a record.
+    def after_update() end
+
+    def update_with_callbacks #:nodoc:
+      callback(:before_update)
+      update_without_callbacks
+      callback(:after_update)
+    end
+
+    # Is called _before_ Validations.validate (which is part of the Base.save call).
+    def before_validation() end
+
+    # Is called _after_ Validations.validate (which is part of the Base.save call).
+    def after_validation() end
+
+    # Is called _before_ Validations.validate (which is part of the Base.save call) on new objects
+    # that haven't been saved yet (no record exists).
+    def before_validation_on_create() end
+
+    # Is called _after_ Validations.validate (which is part of the Base.save call) on new objects
+    # that haven't been saved yet (no record exists).
+    def after_validation_on_create()  end
+
+    # Is called _before_ Validations.validate (which is part of the Base.save call) on 
+    # existing objects that has a record.
+    def before_validation_on_update() end
+
+    # Is called _after_ Validations.validate (which is part of the Base.save call) on 
+    # existing objects that has a record.
+    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
+
+      result = valid_without_callbacks
+
+      callback(:after_validation)
+      if new_record? then callback(:after_validation_on_create) else callback(:after_validation_on_update) end
+      
+      return result
+    end
+
+    # Is called _before_ Base.destroy.
+    def before_destroy() end
+
+    # Is called _after_ Base.destroy (and all the attributes have been frozen).
+    def after_destroy()  end
+    def destroy_with_callbacks #:nodoc:
+      callback(:before_destroy)
+      destroy_without_callbacks
+      callback(:after_destroy)
+    end
+
+    def callback(callback_method) #:nodoc:
+      run_callbacks(callback_method)
+      send(callback_method)
+      notify(callback_method)
+    end
+
+    def run_callbacks(callback_method)
+      filters = self.class.read_inheritable_attribute(callback_method.to_s)
+      if filters.nil? then return end
+      filters.each do |filter| 
+        if Symbol === filter
+          self.send(filter)
+        elsif String === filter
+          eval(filter, binding)
+        elsif filter_block?(filter)
+          filter.call(self)
+        elsif filter_class?(filter, callback_method)
+          filter.send(callback_method, self)
+        else
+          raise(
+            ActiveRecordError, 
+            "Filters need to be either a symbol, string (to be eval'ed), proc/method, or " +
+            "class implementing a static filter method"
+          )
+        end
+      end
+    end
+    
+    def filter_block?(filter)
+      filter.respond_to?("call") && (filter.arity == 1 || filter.arity == -1)
+    end
+    
+    def filter_class?(filter, callback_method)
+      filter.respond_to?(callback_method)
+    end
+    
+    def notify(callback_method) #:nodoc:
+      self.class.changed
+      self.class.notify_observers(callback_method, self)
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,326 @@
+require 'benchmark'
+require 'date'
+
+module ActiveRecord
+  class Base
+    class ConnectionSpecification #:nodoc:
+      attr_reader :config, :adapter_method
+      def initialize (config, adapter_method)
+        @config, @adapter_method = config, adapter_method
+      end
+    end
+
+    # The class -> [adapter_method, config] map
+    @@defined_connections = {}
+
+    # Establishes the connection to the database. Accepts a hash as input where
+    # the :adapter key must be specified with the name of a database adapter (in lower-case)
+    # example for regular databases (MySQL, Postgresql, etc):
+    #
+    #   ActiveRecord::Base.establish_connection(
+    #     :adapter  => "mysql",
+    #     :host     => "localhost",
+    #     :username => "myuser",
+    #     :password => "mypass",
+    #     :database => "somedatabase"
+    #   )
+    #
+    # Example for SQLite database:
+    #
+    #   ActiveRecord::Base.establish_connection(
+    #     :adapter => "sqlite",
+    #     :dbfile  => "path/to/dbfile"
+    #   )
+    #
+    # Also accepts keys as strings (for parsing from yaml for example):
+    #   ActiveRecord::Base.establish_connection(
+    #     "adapter" => "sqlite",
+    #     "dbfile"  => "path/to/dbfile"
+    #   )
+    #
+    # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
+    # may be returned on an error.
+    #
+    # == Connecting to another database for a single model
+    #
+    # To support different connections for different classes, you can
+    # simply call establish_connection with the classes you wish to have
+    # different connections for:
+    #
+    #   class Courses < ActiveRecord::Base
+    #    ...
+    #   end
+    #
+    #   Courses.establish_connection( ... )
+    def self.establish_connection(spec)
+      if spec.instance_of? ConnectionSpecification
+        @@defined_connections[self] = spec
+      else
+        if spec.nil? then raise AdapterNotSpecified end
+        symbolize_strings_in_hash(spec)
+        unless spec.key?(:adapter) then raise AdapterNotSpecified end
+    
+        adapter_method = "#{spec[:adapter]}_connection"
+        unless methods.include?(adapter_method) then raise AdapterNotFound end
+        remove_connection
+        @@defined_connections[self] = ConnectionSpecification.new(spec, adapter_method)
+      end
+    end
+    
+    # Locate the connection of the nearest super class. This can be an
+    # active or defined connections: if it is the latter, it will be
+    # opened and set as the active connection for the class it was defined
+    # for (not necessarily the current class).
+    def self.retrieve_connection #:nodoc:
+      klass = self
+      until klass == ActiveRecord::Base.superclass
+        Thread.current['active_connections'] ||= {}
+        if Thread.current['active_connections'][klass]
+          return Thread.current['active_connections'][klass]
+        elsif @@defined_connections[klass]
+          klass.connection = @@defined_connections[klass]
+          return self.connection
+        end
+        klass = klass.superclass
+      end
+      raise ConnectionNotEstablished
+    end
+    
+    # Returns true if a connection that's accessible to this class have already been opened.
+    def self.connected?
+      klass = self
+      until klass == ActiveRecord::Base.superclass
+        if Thread.current['active_connections'].is_a?(Hash) && Thread.current['active_connections'][klass]
+          return true 
+        else
+          klass = klass.superclass
+        end
+      end
+      return false
+    end
+    
+    # Remove the connection for this class. This will close the active
+    # connection and the defined connection (if they exist). The result
+    # can be used as argument for establish_connection, for easy
+    # re-establishing of the connection.
+    def self.remove_connection(klass=self)
+      conn = @@defined_connections[klass]
+      @@defined_connections.delete(klass)
+      Thread.current['active_connections'] ||= {}
+      Thread.current['active_connections'][klass] = nil
+      conn.config if conn
+    end
+    
+    # Set the connection for the class.
+    def self.connection=(spec)
+      raise ConnectionNotEstablished unless spec
+      conn = self.send(spec.adapter_method, spec.config)
+      Thread.current['active_connections'] ||= {}
+      Thread.current['active_connections'][self] = conn
+    end
+
+    # Converts all strings in a hash to symbols.
+    def self.symbolize_strings_in_hash(hash)
+      hash.each do |key, value|
+        if key.class == String
+          hash.delete key
+          hash[key.intern] = value
+        end
+      end
+    end
+  end
+
+  module ConnectionAdapters # :nodoc:
+    class Column # :nodoc:
+      attr_reader :name, :default, :type, :limit
+      # The name should contain the name of the column, such as "name" in "name varchar(250)"
+      # The default should contain the type-casted default of the column, such as 1 in "count int(11) DEFAULT 1"
+      # The type parameter should either contain :integer, :float, :datetime, :date, :text, or :string
+      # The sql_type is just used for extracting the limit, such as 10 in "varchar(10)"
+      def initialize(name, default, sql_type = nil)
+        @name, @default, @type = name, default, simplified_type(sql_type)
+        @limit = extract_limit(sql_type) unless sql_type.nil?
+      end
+
+      def default
+        type_cast(@default)
+      end
+
+      def klass
+        case type
+          when :integer       then Fixnum
+          when :float         then Float
+          when :datetime      then Time
+          when :date          then Date
+          when :text, :string then String
+          when :boolean       then Object
+        end
+      end
+      
+      def type_cast(value)
+        if value.nil? then return nil end
+        case type
+          when :string   then value
+          when :text     then value
+          when :integer  then value.to_i
+          when :float    then value.to_f
+          when :datetime then string_to_time(value)
+          when :date     then string_to_date(value)
+          when :boolean  then (value == "t" or value == true ? true : false)
+          else value
+        end
+      end
+      
+      def human_name
+        Base.human_attribute_name(@name)
+      end
+
+      private
+        def string_to_date(string)
+          return string if Date === string
+          date_array = ParseDate.parsedate(string)
+          # 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 Time === string
+          time_array = ParseDate.parsedate(string).compact
+          # treat 0000-00-00 00:00:00 as nil
+          Time.local(*time_array) rescue nil
+        end
+
+        def extract_limit(sql_type)
+          $1.to_i if sql_type =~ /\((.*)\)/
+        end
+
+        def simplified_type(field_type)
+          case field_type
+            when /int/i
+              :integer
+            when /float|double|decimal|numeric/i
+              :float
+            when /time/i
+              :datetime
+            when /date/i
+              :date
+            when /(c|b)lob/i, /text/i
+              :text
+            when /char/i, /string/i
+              :string
+            when /boolean/i
+              :boolean
+          end
+        end
+    end
+
+    # All the concrete database adapters follow the interface laid down in this class.
+    # You can use this interface directly by borrowing the database connection from the Base with
+    # Base.connection.
+    class AbstractAdapter
+      @@row_even = true
+
+      include Benchmark
+
+      def initialize(connection, logger = nil) # :nodoc:
+        @connection, @logger = connection, logger
+        @runtime = 0
+      end
+
+      # Returns an array of record hashes with the column names as a keys and fields as values.
+      def select_all(sql, name = nil) end
+      
+      # Returns a record hash with the column names as a keys and fields as values.
+      def select_one(sql, name = nil) end
+
+      # Returns an array of column objects for the table specified by +table_name+.
+      def columns(table_name, name = nil) end
+
+      # Returns the last auto-generated ID from the affected table.
+      def insert(sql, name = nil, pk = nil, id_value = nil) end
+
+      # Executes the update statement.
+      def update(sql, name = nil) end
+
+      # Executes the delete statement.
+      def delete(sql, name = nil) end
+
+      def reset_runtime # :nodoc:
+        rt = @runtime
+        @runtime = 0
+        return rt
+      end
+
+      # Begins the transaction (and turns off auto-committing).
+      def begin_db_transaction()    end
+      
+      # Commits the transaction (and turns on auto-committing). 
+      def commit_db_transaction()   end
+
+      # Rollsback the transaction (and turns on auto-committing). Must be done if the transaction block
+      # raises an exception or returns false.
+      def rollback_db_transaction() end
+
+      def quote(value, column = nil)
+        case value
+          when String                      then "'#{value.gsub(/\\/,'\&\&').gsub(/'/, "''")}'" # ' (for ruby-mode)
+          when NilClass                    then "NULL"
+          when TrueClass                   then (column && column.type == :boolean ? "'t'" : "1")
+          when FalseClass                  then (column && column.type == :boolean ? "'f'" : "0")
+          when Float, Fixnum, Bignum, Date then "'#{value.to_s}'" 
+          when Time, DateTime              then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+          else                                  "'#{value.to_yaml.gsub(/'/, "''")}'"
+        end
+      end
+
+      def quote_column_name(name)
+        return name
+      end
+
+      # Returns a string of the CREATE TABLE SQL statements for recreating the entire structure of the database.
+      def structure_dump() end
+
+      protected
+        def log(sql, name, connection, &action)
+          begin
+            if @logger.nil?
+              action.call(connection)
+            else
+              result = nil
+              bm = measure { result = action.call(connection) }
+              @runtime += bm.real
+              log_info(sql, name, bm.real)
+              result
+            end
+          rescue => e
+            log_info("#{e.message}: #{sql}", name, 0)
+            raise ActiveRecord::StatementInvalid, "#{e.message}: #{sql}"
+          end
+        end
+
+        def log_info(sql, name, runtime)
+          if @logger.nil? then return end
+
+          @logger.info(
+            format_log_entry(
+              "#{name.nil? ? "SQL" : name} (#{sprintf("%f", runtime)})", 
+              sql.gsub(/ +/, " ")
+            )
+          )
+        end
+
+        def format_log_entry(message, dump = nil)
+          if @@row_even then
+            @@row_even = false; caller_color = "1;32"; message_color = "4;33"; dump_color = "1;37"
+          else
+            @@row_even = true; caller_color = "1;36"; message_color = "4;35"; dump_color = "0;37"
+          end
+          
+          log_entry = "  \e[#{message_color}m#{message}\e[m"
+          log_entry << "   \e[#{dump_color}m%s\e[m" % dump if dump.kind_of?(String) && !dump.nil?
+          log_entry << "   \e[#{dump_color}m%p\e[m" % dump if !dump.kind_of?(String) && !dump.nil?
+          log_entry
+        end
+    end
+  end
+end