activerecord 1.4.0 → 1.5.0

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,33 +1,67 @@
 # sqlite_adapter.rb
-# author:   Luke Holden <lholden@cablelan.net>
+# author: Luke Holden <lholden@cablelan.net>
+# updated for SQLite3: Jamis Buck <jamis_buck@byu.edu>
 
 require 'active_record/connection_adapters/abstract_adapter'
 
 module ActiveRecord
   class Base
-    # Establishes a connection to the database that's used by all Active Record objects
-    def self.sqlite_connection(config) # :nodoc:
-      require_library_or_gem('sqlite') unless self.class.const_defined?(:SQLite)
-      symbolize_strings_in_hash(config)
-      unless config.has_key?(:dbfile)
-        raise ArgumentError, "No database file specified. Missing argument: dbfile"
+    class << self
+      # sqlite3 adapter reuses sqlite_connection.
+      def sqlite3_connection(config) # :nodoc:
+        parse_config!(config)
+
+        unless self.class.const_defined?(:SQLite3)
+          require_library_or_gem(config[:adapter])
+        end
+
+        db = SQLite3::Database.new(
+          config[:dbfile],
+          :results_as_hash => true,
+          :type_translation => false
+        )
+        ConnectionAdapters::SQLiteAdapter.new(db, logger)
+      end
+
+      # Establishes a connection to the database that's used by all Active Record objects
+      def sqlite_connection(config) # :nodoc:
+        parse_config!(config)
+
+        unless self.class.const_defined?(:SQLite)
+          require_library_or_gem(config[:adapter])
+
+          db = SQLite::Database.new(config[:dbfile], 0)
+          db.show_datatypes   = "ON" if !defined? SQLite::Version
+          db.results_as_hash  = true if defined? SQLite::Version
+          db.type_translation = false
+
+          # "Downgrade" deprecated sqlite API
+          if SQLite.const_defined?(:Version)
+            ConnectionAdapters::SQLiteAdapter.new(db, logger)
+          else
+            ConnectionAdapters::DeprecatedSQLiteAdapter.new(db, logger)
+          end
+        end
       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
-      db.results_as_hash  = true if defined? SQLite::Version
-      db.type_translation = false
+      private
+        def parse_config!(config)
+          # Require dbfile.
+          unless config.has_key?(:dbfile)
+            raise ArgumentError, "No database file specified. Missing argument: dbfile"
+          end
 
-      ConnectionAdapters::SQLiteAdapter.new(db, logger)
+          # Allow database path relative to RAILS_ROOT.
+          if Object.const_defined?(:RAILS_ROOT)
+            config[:dbfile] = File.expand_path(config[:dbfile], RAILS_ROOT)
+          end
+        end
     end
   end
 
   module ConnectionAdapters
     
     class SQLiteColumn < Column
-      
       def string_to_binary(value)
         value.gsub(/(\0|\%)/) do
           case $1
@@ -45,92 +79,79 @@ module ActiveRecord
           end
         end                
       end
-      
     end
+
     class SQLiteAdapter < AbstractAdapter # :nodoc:
-      def select_all(sql, name = nil)
-        select(sql, name)
+      def execute(sql, name = nil)
+        log(sql, name) { @connection.execute(sql) }
       end
 
-      def select_one(sql, name = nil)
-        result = select(sql, name)
-        result.nil? ? nil : result.first
+      def update(sql, name = nil)
+        execute(sql, name)
+        @connection.changes
       end
 
-      def columns(table_name, name = nil)
-        table_structure(table_name).inject([]) do |columns, field| 
-          columns << SQLiteColumn.new(field['name'], field['dflt_value'], field['type'])
-          columns
-        end
+      def delete(sql, name = nil)
+        sql += " WHERE 1=1" unless sql =~ /WHERE/i
+        execute(sql, name)
+        @connection.changes
       end
 
       def insert(sql, name = nil, pk = nil, id_value = nil)
         execute(sql, name = nil)
-        id_value || @connection.send( defined?( SQLite::Version ) ? :last_insert_row_id : :last_insert_rowid )
+        id_value || @connection.last_insert_row_id
       end
 
-      def execute(sql, name = nil)
-        log(sql, name, @connection) do |connection|
-          if defined?( SQLite::Version )
-            case sql
-              when "BEGIN" then connection.transaction
-              when "COMMIT" then connection.commit
-              when "ROLLBACK" then connection.rollback
-              else connection.execute(sql)
-            end
-          else
-            connection.execute( sql )
+      def select_all(sql, name = nil)
+        execute(sql, name).map do |row|
+          record = {}
+          row.each_key do |key|
+            record[key.sub(/\w+\./, '')] = row[key] unless key.is_a?(Fixnum)
           end
+          record
         end
       end
 
-      def update(sql, name = nil)
-        execute(sql, name)
-        @connection.changes
+      def select_one(sql, name = nil)
+        result = select_all(sql, name)
+        result.nil? ? nil : result.first
       end
-      
-      def delete(sql, name = nil)
-        sql += " WHERE 1=1" unless sql =~ /WHERE/i
-        execute(sql, name)
-        @connection.changes
+
+
+      def begin_db_transaction()    @connection.transaction end
+      def commit_db_transaction()   @connection.commit      end
+      def rollback_db_transaction() @connection.rollback    end
+
+
+      def tables
+        execute('.table').map { |table| Table.new(table) }
       end
 
-      def begin_db_transaction()    execute "BEGIN" end
-      def commit_db_transaction()   execute "COMMIT" end
-      def rollback_db_transaction() execute "ROLLBACK" end
+      def columns(table_name, name = nil)
+        table_structure(table_name).map { |field|
+          SQLiteColumn.new(field['name'], field['dflt_value'], field['type'])
+        }
+      end
 
       def quote_string(s)
-        SQLite::Database.quote(s)
+        @connection.class.quote(s)
       end
-        
+
       def quote_column_name(name)
         return "'#{name}'"
       end
 
-      private
-        def select(sql, name = nil)
-          results = nil
-          log(sql, name, @connection) { |connection| results = connection.execute(sql) }
-
-          rows = []
-
-          results.each do |row|
-            hash_only_row = {}
-            row.each_key do |key|
-              hash_only_row[key.sub(/\w+\./, "")] = row[key] unless key.class == Fixnum
-            end
-            rows << hash_only_row
-          end
-
-          return rows
-        end
-
+      protected
         def table_structure(table_name)
-          sql = "PRAGMA table_info(#{table_name});"
-          results = nil
-          log(sql, nil, @connection) { |connection| results = connection.execute(sql) }
-          return results
+          execute "PRAGMA table_info(#{table_name})"
         end
     end
+
+    class DeprecatedSQLiteAdapter < SQLiteAdapter # :nodoc:
+      def insert(sql, name = nil, pk = nil, id_value = nil)
+        execute(sql, name = nil)
+        id_value || @connection.last_insert_rowid
+      end
+    end
   end
 end

data/lib/active_record/deprecated_associations.rb

@@ -18,7 +18,7 @@ module ActiveRecord
         end_eval
       end
     
-       def deprecated_remove_association_relation(association_name)# :nodoc:
+      def deprecated_remove_association_relation(association_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def remove_#{association_name}(*items)
             #{association_name}.delete(items)
@@ -50,7 +50,7 @@ module ActiveRecord
         end_eval
       end
     
-      def deprecated_create_method(collection_name)# :nodoc:
+      def deprecated_collection_create_method(collection_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def create_in_#{collection_name}(attributes = {})
             #{collection_name}.create(attributes)
@@ -58,13 +58,51 @@ module ActiveRecord
         end_eval
       end
     
-      def deprecated_build_method(collection_name)# :nodoc:
-          module_eval <<-"end_eval", __FILE__, __LINE__
-            def build_to_#{collection_name}(attributes = {})
-              #{collection_name}.build(attributes)
+      def deprecated_collection_build_method(collection_name)# :nodoc:
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def build_to_#{collection_name}(attributes = {})
+            #{collection_name}.build(attributes)
+          end
+        end_eval
+      end
+
+      def deprecated_association_comparison_method(association_name, association_class_name)
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def #{association_name}?(comparison_object, force_reload = false)
+            if comparison_object.kind_of?(#{association_class_name})
+              #{association_name}(force_reload) == comparison_object
+            else
+              raise "Comparison object is a #{association_class_name}, should have been \#{comparison_object.class.name}"
             end
-          end_eval
-        end
+          end
+        end_eval
+      end
+        
+      def deprecated_has_association_method(association_name)
+        module_eval <<-"end_eval", __FILE__, __LINE__
+          def has_#{association_name}?(force_reload = false)
+            !#{association_name}(force_reload).nil?
+          end
+        end_eval
+      end
+      
+      def deprecated_build_method(method_prefix, collection_name, collection_class_name, class_primary_key_name)
+        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)
+        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

data/lib/active_record/fixtures.rb

@@ -158,7 +158,7 @@ class Fixtures < Hash
       ActiveRecord::Base.logger.level = Logger::ERROR
 
       fixtures = table_names.flatten.map do |table_name|
-        Fixtures.new(connection, table_name.to_s, File.join(fixtures_directory, table_name.to_s))
+        Fixtures.new(connection, File.split(table_name.to_s).last, File.join(fixtures_directory, table_name.to_s))
       end
 
       connection.transaction do

data/lib/active_record/observer.rb

@@ -43,7 +43,11 @@ module ActiveRecord
   # The observer can implement callback methods for each of the methods described in the Callbacks module.
   class Observer
     include Singleton
-  
+
+    def self.observe(*models)
+      define_method(:observed_class) { models }
+    end
+
     def initialize
       [ observed_class ].flatten.each do |klass| 
         klass.add_observer(self)

data/lib/active_record/support/binding_of_caller.rb

@@ -1,81 +1,85 @@
 begin
   require 'simplecc'
 rescue LoadError
-  def Continuation.create(*args, &block)
-    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
-    result ||= args
-    return *[cc, *result]
+  class Continuation #:nodoc:
+    def create(*args, &block)
+      cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+      result ||= args
+      return *[cc, *result]
+    end
   end
 end
 
-# This method returns the binding of the method that called your
-# method. It will raise an Exception when you're not inside a method.
-#
-# It's used like this:
-#   def inc_counter(amount = 1)
-#     Binding.of_caller do |binding|
-#       # Create a lambda that will increase the variable 'counter'
-#       # in the caller of this method when called.
-#       inc = eval("lambda { |arg| counter += arg }", binding)
-#       # We can refer to amount from inside this block safely.
-#       inc.call(amount)
-#     end
-#     # No other statements can go here. Put them inside the block.
-#   end
-#   counter = 0
-#   2.times { inc_counter }
-#   counter # => 2
-#
-# Binding.of_caller must be the last statement in the method.
-# This means that you will have to put everything you want to
-# do after the call to Binding.of_caller into the block of it.
-# This should be no problem however, because Ruby has closures.
-# If you don't do this an Exception will be raised. Because of
-# the way that Binding.of_caller is implemented it has to be
-# done this way.
-def Binding.of_caller(&block)
-  old_critical = Thread.critical
-  Thread.critical = true
-  count = 0
-  cc, result, error, extra_data = Continuation.create(nil, nil)
-  error.call if error
+class Binding #:nodoc:
+  # This method returns the binding of the method that called your
+  # method. It will raise an Exception when you're not inside a method.
+  #
+  # It's used like this:
+  #   def inc_counter(amount = 1)
+  #     Binding.of_caller do |binding|
+  #       # Create a lambda that will increase the variable 'counter'
+  #       # in the caller of this method when called.
+  #       inc = eval("lambda { |arg| counter += arg }", binding)
+  #       # We can refer to amount from inside this block safely.
+  #       inc.call(amount)
+  #     end
+  #     # No other statements can go here. Put them inside the block.
+  #   end
+  #   counter = 0
+  #   2.times { inc_counter }
+  #   counter # => 2
+  #
+  # Binding.of_caller must be the last statement in the method.
+  # This means that you will have to put everything you want to
+  # do after the call to Binding.of_caller into the block of it.
+  # This should be no problem however, because Ruby has closures.
+  # If you don't do this an Exception will be raised. Because of
+  # the way that Binding.of_caller is implemented it has to be
+  # done this way.
+  def of_caller(&block)
+    old_critical = Thread.critical
+    Thread.critical = true
+    count = 0
+    cc, result, error, extra_data = Continuation.create(nil, nil)
+    error.call if error
 
-  tracer = lambda do |*args|
-    type, context, extra_data = args[0], args[4], args
-    if type == "return"
-      count += 1
-      # First this method and then calling one will return --
-      # the trace event of the second event gets the context
-      # of the method which called the method that called this
-      # method.
-      if count == 2
-        # It would be nice if we could restore the trace_func
-        # that was set before we swapped in our own one, but
-        # this is impossible without overloading set_trace_func
-        # in current Ruby.
+    tracer = lambda do |*args|
+      type, context, extra_data = args[0], args[4], args
+      if type == "return"
+        count += 1
+        # First this method and then calling one will return --
+        # the trace event of the second event gets the context
+        # of the method which called the method that called this
+        # method.
+        if count == 2
+          # It would be nice if we could restore the trace_func
+          # that was set before we swapped in our own one, but
+          # this is impossible without overloading set_trace_func
+          # in current Ruby.
+          set_trace_func(nil)
+          cc.call(eval("binding", context), nil, extra_data)
+        end
+      elsif type == "line" then
+        nil
+      elsif type == "c-return" and extra_data[3] == :set_trace_func then
+        nil
+      else
         set_trace_func(nil)
-        cc.call(eval("binding", context), nil, extra_data)
+        error_msg = "Binding.of_caller used in non-method context or " +
+          "trailing statements of method using it aren't in the block."
+        cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
       end
-    elsif type == "line" then
-      nil
-    elsif type == "c-return" and extra_data[3] == :set_trace_func then
-      nil
-    else
-      set_trace_func(nil)
-      error_msg = "Binding.of_caller used in non-method context or " +
-        "trailing statements of method using it aren't in the block."
-      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
     end
-  end
 
-  unless result
-    set_trace_func(tracer)
-    return nil
-  else
-    Thread.critical = old_critical
-    case block.arity
-      when 1 then yield(result)
-      else yield(result, extra_data)        
+    unless result
+      set_trace_func(tracer)
+      return nil
+    else
+      Thread.critical = old_critical
+      case block.arity
+        when 1 then yield(result)
+        else yield(result, extra_data)        
+      end
     end
   end
-end
+end