activerecord 1.1.0 → 1.2.0

data/lib/active_record/callbacks.rb

@@ -2,7 +2,7 @@ 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 
+  # 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:
@@ -14,19 +14,19 @@ module ActiveRecord
   # * (-) validate
   # * (-) validate_on_create
   # * (4) after_validation
-  # * (5) after_validation_on_create 
+  # * (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 
+  #     # 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")
@@ -73,13 +73,13 @@ module ActiveRecord
   #     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 
+  # 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, 
+  # 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.
@@ -115,7 +115,7 @@ module ActiveRecord
   #     def after_save(record)
   #       record.credit_card_number = decrypt(record.credit_card_number)
   #     end
-  #     
+  #
   #     alias_method :after_initialize, :after_save
   #
   #     private
@@ -142,7 +142,7 @@ module ActiveRecord
   # inline callbacks can be stacked just like the regular ones:
   #
   #   class Topic < ActiveRecord::Base
-  #     before_destroy 'self.class.delete_all "parent_id = #{id}"', 
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"',
   #                    'puts "Evaluated after parents are destroyed"'
   #   end
   #
@@ -153,8 +153,8 @@ module ActiveRecord
   # 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 
+    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
     )
@@ -210,10 +210,11 @@ module ActiveRecord
     # def after_initialize() end
     def initialize_with_callbacks(attributes = nil) #:nodoc:
       initialize_without_callbacks(attributes)
-      yield self if block_given?
+      result = yield self if block_given?
       after_initialize if respond_to_without_attributes?(:after_initialize)
+      result
     end
-    
+
     # Is called _before_ Base.save (regardless of whether it's a create or update save).
     def before_save() end
 
@@ -221,8 +222,9 @@ module ActiveRecord
     def after_save()  end
     def create_or_update_with_callbacks #:nodoc:
       callback(:before_save)
-      create_or_update_without_callbacks
+      result = create_or_update_without_callbacks
       callback(:after_save)
+      result
     end
 
     # Is called _before_ Base.save on new objects that haven't been saved yet (no record exists).
@@ -232,8 +234,9 @@ module ActiveRecord
     def after_create() end
     def create_with_callbacks #:nodoc:
       callback(:before_create)
-      create_without_callbacks
+      result = create_without_callbacks
       callback(:after_create)
+      result
     end
 
     # Is called _before_ Base.save on existing objects that has a record.
@@ -244,8 +247,9 @@ module ActiveRecord
 
     def update_with_callbacks #:nodoc:
       callback(:before_update)
-      update_without_callbacks
+      result = update_without_callbacks
       callback(:after_update)
+      result
     end
 
     # Is called _before_ Validations.validate (which is part of the Base.save call).
@@ -262,11 +266,11 @@ module ActiveRecord
     # 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 
+    # 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 
+    # 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
 
@@ -278,7 +282,7 @@ module ActiveRecord
 
       callback(:after_validation)
       if new_record? then callback(:after_validation_on_create) else callback(:after_validation_on_update) end
-      
+
       return result
     end
 
@@ -289,8 +293,9 @@ module ActiveRecord
     def after_destroy()  end
     def destroy_with_callbacks #:nodoc:
       callback(:before_destroy)
-      destroy_without_callbacks
+      result = destroy_without_callbacks
       callback(:after_destroy)
+      result
     end
 
     def callback(callback_method) #:nodoc:
@@ -302,7 +307,7 @@ module ActiveRecord
     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| 
+      filters.each do |filter|
         if Symbol === filter
           self.send(filter)
         elsif String === filter
@@ -313,25 +318,25 @@ module ActiveRecord
           filter.send(callback_method, self)
         else
           raise(
-            ActiveRecordError, 
+            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
+end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -75,21 +75,30 @@ module ActiveRecord
     #   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)
+    def self.establish_connection(spec = nil)
+      case spec
+        when nil
+          raise AdapterNotSpecified unless defined? RAILS_ENV
+          establish_connection(RAILS_ENV)
+        when ConnectionSpecification
+          @@defined_connections[self] = spec
+        when Symbol, String
+          if configuration = configurations[spec.to_s]
+            establish_connection(configuration)
+          else
+            raise AdapterNotSpecified
+          end
+        else
+          spec = symbolize_strings_in_hash(spec)
+          unless spec.key?(:adapter) then raise AdapterNotSpecified end
+
+          adapter_method = "#{spec[:adapter]}_connection"
+          unless respond_to?(adapter_method) then raise AdapterNotFound end
+          remove_connection
+          establish_connection(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
@@ -144,11 +153,9 @@ module ActiveRecord
 
     # 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
+      hash.inject({}) do |hash_with_symbolized_strings, pair|
+        hash_with_symbolized_strings[pair.first.to_sym] = pair.last
+        hash_with_symbolized_strings
       end
     end
   end
@@ -175,6 +182,8 @@ module ActiveRecord
           when :float         then Float
           when :datetime      then Time
           when :date          then Date
+          when :timestamp     then Time
+          when :time          then Time
           when :text, :string then String
           when :boolean       then Object
         end
@@ -183,13 +192,15 @@ module ActiveRecord
       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)
+          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 :timestamp then string_to_time(value)
+          when :time      then string_to_dummy_time(value)
+          when :date      then string_to_date(value)
+          when :boolean   then (value == "t" or value == true ? true : false)
           else value
         end
       end
@@ -213,6 +224,14 @@ module ActiveRecord
           Time.local(*time_array) rescue nil
         end
 
+       def string_to_dummy_time(string)
+         return string if Time === string
+         time_array = ParseDate.parsedate(string)
+         # pad the resulting array with dummy date information
+         time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;
+         Time.local(*time_array) rescue nil
+       end
+
         def extract_limit(sql_type)
           $1.to_i if sql_type =~ /\((.*)\)/
         end
@@ -223,8 +242,12 @@ module ActiveRecord
               :integer
             when /float|double|decimal|numeric/i
               :float
-            when /time/i
+            when /datetime/i
               :datetime
+            when /timestamp/i
+              :timestamp
+            when /time/i
+              :time
             when /date/i
               :date
             when /(c|b)lob/i, /text/i
@@ -301,13 +324,14 @@ module ActiveRecord
 
       def quote(value, column = nil)
         case value
-          when String                      then "'#{quote_string(value)}'" # ' (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                                  "'#{quote_string(value.to_yaml)}'"
+          when String                then "'#{quote_string(value)}'" # ' (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 then value.to_s
+          when Date                  then "'#{value.to_s}'" 
+          when Time, DateTime        then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+          else                            "'#{quote_string(value.to_yaml)}'"
         end
       end
 

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -117,6 +117,10 @@ module ActiveRecord
         execute "CREATE DATABASE #{name}"
       end
       
+      def quote_string(s)
+        Mysql::quote(s)
+      end
+
       private
         def select(sql, name = nil)
           result = nil

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -12,7 +12,8 @@ module ActiveRecord
       unless config.has_key?(:dbfile)
         raise ArgumentError, "No database file specified. Missing argument: dbfile"
       end
-
+      
+      config[:dbfile] = File.expand_path(config[:dbfile], RAILS_ROOT) if Object.const_defined?(:RAILS_ROOT)
       db = SQLite::Database.new(config[:dbfile], 0)
 
       db.show_datatypes   = "ON" if !defined? SQLite::Version
@@ -102,4 +103,4 @@ module ActiveRecord
         end
     end
   end
-end
+end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1,298 @@
+require 'active_record/connection_adapters/abstract_adapter'
+
+# sqlserver_adapter.rb -- ActiveRecord adapter for Microsoft SQL Server
+#
+# Author: Joey Gibson <joey@joeygibson.com>
+# Date:   10/14/2004
+#
+# REQUIREMENTS:
+#
+# This adapter will ONLY work on Windows systems, since it relies on Win32OLE, which,
+# to my knowledge, is only available on Window.
+#
+# It relies on the ADO support in the DBI module. If you are using the
+# one-click installer of Ruby, then you already have DBI installed, but
+# the ADO module is *NOT* installed. You will need to get the latest
+# source distribution of Ruby-DBI from http://ruby-dbi.sourceforge.net/
+# unzip it, and copy the file src/lib/dbd_ado/ADO.rb to
+# X:/Ruby/lib/ruby/site_ruby/1.8/DBD/ADO/ADO.rb (you will need to create
+# the ADO directory). Once you've installed that file, you are ready to go.
+#
+# This module uses the ADO-style DSNs for connection. For example:
+# "DBI:ADO:Provider=SQLOLEDB;Data Source=(local);Initial Catalog=test;User Id=sa;Password=password;"
+# with User Id replaced with your proper login, and Password with your
+# password.
+#
+# I have tested this code on a WindowsXP Pro SP1 system,
+# ruby 1.8.2 (2004-07-29) [i386-mswin32], SQL Server 2000.
+#
+module ActiveRecord
+  class Base
+    def self.sqlserver_connection(config)
+      require_library_or_gem 'dbi' unless self.class.const_defined?(:DBI)
+      class_eval { include ActiveRecord::SQLServerBaseExtensions }
+      
+      symbolize_strings_in_hash(config)
+
+      if config.has_key? :dsn
+        dsn = config[:dsn]
+      else
+        raise ArgumentError, "No DSN specified"
+      end
+
+      conn = DBI.connect(dsn)
+      conn["AutoCommit"] = true
+
+      ConnectionAdapters::SQLServerAdapter.new(conn, logger)
+    end
+  end
+
+  module SQLServerBaseExtensions #:nodoc:
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods #:nodoc:
+      def find_first(conditions = nil, orderings = nil)
+        sql  = "SELECT TOP 1 * FROM #{table_name} "
+        add_conditions!(sql, conditions)
+        sql << "ORDER BY #{orderings} " unless orderings.nil?
+
+        record = connection.select_one(sql, "#{name} Load First")
+        instantiate(record) unless record.nil?
+      end
+
+      def find_all(conditions = nil, orderings = nil, limit = nil, joins = nil)
+        sql  = "SELECT "
+        sql << "TOP #{limit} " unless limit.nil?
+        sql << " * FROM #{table_name} " 
+        sql << "#{joins} " if joins
+        add_conditions!(sql, conditions)
+        sql << "ORDER BY #{orderings} " unless orderings.nil?
+
+        find_by_sql(sql)
+      end
+    end
+
+    def attributes_with_quotes
+      columns_hash = self.class.columns_hash
+
+      attrs = @attributes.dup
+
+      attrs = attrs.reject do |name, value|
+        columns_hash[name].identity
+      end
+
+      attrs.inject({}) do |attrs_quoted, pair|
+        attrs_quoted[pair.first] = quote(pair.last, columns_hash[pair.first])
+        attrs_quoted
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    class ColumnWithIdentity < Column# :nodoc:
+      attr_reader :identity
+
+      def initialize(name, default, sql_type = nil, is_identity = false)
+        super(name, default, sql_type)
+
+        @identity = is_identity
+      end
+    end
+
+    class SQLServerAdapter < AbstractAdapter # :nodoc:
+      def quote_column_name(name)
+        " [#{name}] "
+      end
+
+      def select_all(sql, name = nil)
+        select(sql, name)
+      end
+
+      def select_one(sql, name = nil)
+        result = select(sql, name)
+        result.nil? ? nil : result.first
+      end
+
+      def columns(table_name, name = nil)
+        sql = <<EOL
+SELECT s.name AS TableName, c.id AS ColId, c.name AS ColName, t.name AS ColType, c.length AS Length,
+c.AutoVal AS IsIdentity,
+c.cdefault AS DefaultId, com.text AS DefaultValue
+FROM syscolumns AS c
+JOIN systypes AS t ON (c.xtype = t.xtype AND c.usertype = t.usertype)
+JOIN sysobjects AS s ON (c.id = s.id)
+LEFT OUTER JOIN syscomments AS com ON (c.cdefault = com.id)
+WHERE s.name = '#{table_name}'
+EOL
+
+        columns = []
+
+        log(sql, name, @connection) do |conn|
+          conn.select_all(sql) do |row|
+            default_value = row[:DefaultValue]
+
+            if default_value =~ /null/i
+              default_value = nil
+            else
+              default_value =~ /\(([^)]+)\)/
+              default_value = $1
+            end
+
+            col = ColumnWithIdentity.new(row[:ColName], default_value, "#{row[:ColType]}(#{row[:Length]})", row[:IsIdentity] != nil)
+
+            columns << col
+          end
+        end
+
+        columns
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil)
+        begin
+          table_name = get_table_name(sql)
+
+          col = get_identity_column(table_name)
+
+          ii_enabled = false
+
+          if col != nil
+            if query_contains_identity_column(sql, col)
+              begin
+                execute enable_identity_insert(table_name, true)
+                ii_enabled = true
+              rescue Exception => e
+                # Coulnd't turn on IDENTITY_INSERT
+              end
+            end
+          end
+
+          log(sql, name, @connection) do |conn|
+            conn.execute(sql)
+
+            select_one("SELECT @@IDENTITY AS Ident")["Ident"]
+          end
+        ensure
+          if ii_enabled
+            begin
+              execute enable_identity_insert(table_name, false)
+
+            rescue Exception => e
+              # Couldn't turn off IDENTITY_INSERT
+            end
+          end
+        end
+      end
+
+      def execute(sql, name = nil)
+        if sql =~ /^INSERT/i
+          insert(sql, name)
+        else
+          log(sql, name, @connection) do |conn|
+            conn.execute(sql)
+          end
+        end
+      end
+
+      alias_method :update, :execute
+      alias_method :delete, :execute
+
+      def begin_db_transaction
+        begin
+          @connection["AutoCommit"] = false
+        rescue Exception => e
+          @connection["AutoCommit"] = true
+        end
+      end
+
+      def commit_db_transaction
+        begin
+          @connection.commit
+        ensure
+          @connection["AutoCommit"] = true
+        end
+      end
+
+      def rollback_db_transaction
+        begin
+          @connection.rollback
+        ensure
+          @connection["AutoCommit"] = true
+        end
+      end
+
+      def recreate_database(name)
+        drop_database(name)
+        create_database(name)
+      end
+
+      def drop_database(name)
+        execute "DROP DATABASE #{name}"
+      end
+
+      def create_database(name)
+        execute "CREATE DATABASE #{name}"
+      end
+
+      private
+      def select(sql, name = nil)
+        rows = []
+
+        log(sql, name, @connection) do |conn|
+          conn.select_all(sql) do |row|
+            record = {}
+
+            row.column_names.each do |col|
+              record[col] = row[col]
+            end
+
+            rows << record
+          end
+        end
+
+        rows
+      end
+
+      def enable_identity_insert(table_name, enable = true)
+        if has_identity_column(table_name)
+          "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+        end
+      end
+
+      def get_table_name(sql)
+        if sql =~ /into\s*([^\s]+)\s*/i or
+            sql =~ /update\s*([^\s]+)\s*/i
+          $1
+        else
+          nil
+        end
+      end
+
+      def has_identity_column(table_name)
+        return get_identity_column(table_name) != nil
+      end
+
+      def get_identity_column(table_name)
+        if not @table_columns
+          @table_columns = {}
+        end
+
+        if @table_columns[table_name] == nil
+          @table_columns[table_name] = columns(table_name)
+        end
+
+        @table_columns[table_name].each do |col|
+          return col.name if col.identity
+        end
+
+        return nil
+      end
+
+      def query_contains_identity_column(sql, col)
+        return sql =~ /[\(\.\,]\s*#{col}/
+      end
+    end
+  end
+end