activerecord 1.11.1 → 1.12.1

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -16,7 +16,7 @@ module ActiveRecord
     def self.sqlserver_connection(config) #:nodoc:
       require_library_or_gem 'dbi' unless self.class.const_defined?(:DBI)
       
-      symbolize_strings_in_hash(config)
+      config = config.symbolize_keys
 
       mode        = config[:mode] ? config[:mode].to_s.upcase : 'ADO'
       username    = config[:username] ? config[:username].to_s : 'sa'
@@ -98,7 +98,7 @@ module ActiveRecord
 
       # These methods will only allow the adapter to insert binary data with a length of 7K or less
       # because of a SQL Server statement length policy.
-      def string_to_binary(value)
+      def self.string_to_binary(value)
         value.gsub(/(\r|\n|\0|\x1a)/) do
           case $1
             when "\r"   then  "%00"
@@ -109,7 +109,7 @@ module ActiveRecord
         end
       end
 
-      def binary_to_string(value)
+      def self.binary_to_string(value)
         value.gsub(/(%00|%01|%02|%03)/) do
           case $1
             when "%00"    then  "\r"
@@ -165,16 +165,16 @@ module ActiveRecord
       def native_database_types
         {
           :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
-          :string      => { :name => "varchar(255)" },
-          :text        => { :name => "text(16)" },
-          :integer     => { :name => "int(4)", :limit => 11 },
-          :float       => { :name => "float(8)" },
-          :datetime    => { :name => "datetime(8)" },
-          :timestamp   => { :name => "datetime(8)" },
-          :time        => { :name => "datetime(8)" },
-          :date        => { :name => "datetime(8)" },
-          :binary      => { :name => "image(16)" },
-          :boolean     => { :name => "bit(1)" }
+          :string      => { :name => "varchar", :limit => 255  },
+          :text        => { :name => "text" },
+          :integer     => { :name => "int"},
+          :float       => { :name => "float", :limit => 8 },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "datetime" },
+          :time        => { :name => "datetime" },
+          :date        => { :name => "datetime" },
+          :binary      => { :name => "image"},
+          :boolean     => { :name => "bit"}
         }
       end
 
@@ -204,7 +204,7 @@ module ActiveRecord
         columns
       end
 
-      def insert(sql, name = nil, pk = nil, id_value = nil)
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         begin
           table_name = get_table_name(sql)
           col = get_identity_column(table_name)
@@ -275,7 +275,7 @@ module ActiveRecord
         case value
           when String                
             if column && column.type == :binary
-              "'#{quote_string(column.string_to_binary(value))}'"
+              "'#{quote_string(column.class.string_to_binary(value))}'"
             else
               "'#{quote_string(value)}'"
             end
@@ -293,6 +293,14 @@ module ActiveRecord
         string.gsub(/\'/, "''")
       end
 
+      def quoted_true
+        "1"
+      end
+      
+      def quoted_false
+        "0"
+      end
+
       def quote_column_name(name)
         "[#{name}]"
       end
@@ -332,6 +340,7 @@ module ActiveRecord
               record = {}
               row.column_names.each do |col|
                 record[col] = row[col]
+                record[col] = record[col].to_time if record[col].is_a? DBI::Timestamp
               end
               rows << record
             end

data/lib/active_record/fixtures.rb

@@ -2,6 +2,13 @@ require 'erb'
 require 'yaml'
 require 'csv'
 
+module YAML #:nodoc:
+  class Omap #:nodoc:
+    def keys;   map { |k, v| k } end
+    def values; map { |k, v| v } end
+  end
+end
+
 # Fixtures are a way of organizing data that you want to test against; in short, sample data. They come in 3 flavours:
 #
 #   1.  YAML fixtures
@@ -32,6 +39,20 @@ require 'csv'
 # indented list of key/value pairs in the "key: value" format.  Records are separated by a blank line for your viewing
 # pleasure.
 #
+# Note that YAML fixtures are unordered. If you want ordered fixtures, use the omap YAML type.  See http://yaml.org/type/omap.html
+# for the specification.  You will need ordered fixtures when you have foreign key constraints on keys in the same table.
+# This is commonly needed for tree structures.  Example:
+#
+#    --- !omap
+#    - parent:
+#        id:         1
+#        parent_id:  NULL
+#        title:      Parent
+#    - child:
+#        id:         2
+#        parent_id:  1
+#        title:      Child
+#
 # = CSV fixtures
 #
 # Fixtures can also be kept in the Comma Separated Value format. Akin to YAML fixtures, CSV fixtures are stored
@@ -191,7 +212,7 @@ require 'csv'
 #      the results of your transaction until Active Record supports nested transactions or savepoints (in progress.) 
 #   2. Your database does not support transactions. Every Active Record database supports transactions except MySQL MyISAM. 
 #      Use InnoDB, MaxDB, or NDB instead.
-class Fixtures < Hash
+class Fixtures < YAML::Omap
   DEFAULT_FILTER_RE = /\.ya?ml$/
 
   def self.instantiate_fixtures(object, table_name, fixtures, load_instances=true)
@@ -232,12 +253,18 @@ class Fixtures < Hash
       end               
       all_loaded_fixtures.merge! fixtures_map  
       
+      
       connection.transaction do
         fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures }
         fixtures.each { |fixture| fixture.insert_fixtures }
       end
-      
-      reset_sequences(connection, table_names) if connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+
+      # Cap primary key sequences to max(pk).
+      if connection.respond_to?(:reset_pk_sequence!)
+        table_names.flatten.each do |table_name|
+          connection.reset_pk_sequence!(table_name)
+        end
+      end
 
       return fixtures.size > 1 ? fixtures : fixtures.first
     ensure
@@ -245,28 +272,14 @@ class Fixtures < Hash
     end
   end
 
-  # Work around for PostgreSQL to have new fixtures created from id 1 and running.
-  def self.reset_sequences(connection, table_names)
-    table_names.flatten.each do |table|
-      table_class = Inflector.classify(table.to_s)
-      if Object.const_defined?(table_class)
-        pk = eval("#{table_class}::primary_key")
-        if pk == 'id'
-          connection.execute(
-            "SELECT setval('#{table.to_s}_id_seq', (SELECT MAX(id) FROM #{table.to_s}), true)", 
-            'Setting Sequence'
-          )
-        end
-      end
-    end
-  end
 
   attr_reader :table_name
 
   def initialize(connection, table_name, fixture_path, file_filter = DEFAULT_FILTER_RE)
     @connection, @table_name, @fixture_path, @file_filter = connection, table_name, fixture_path, file_filter
-    @class_name = Inflector.classify(@table_name)
 
+    @class_name = Inflector.classify(@table_name)
+    @table_name = ActiveRecord::Base.table_name_prefix + @table_name + ActiveRecord::Base.table_name_suffix
     read_fixture_files
   end
 
@@ -285,8 +298,12 @@ class Fixtures < Hash
       if File.file?(yaml_file_path)
         # YAML fixtures
         begin
-          yaml = YAML::load(erb_render(IO.read(yaml_file_path)))
-          yaml.each { |name, data| self[name] = Fixture.new(data, @class_name) } if yaml
+          if yaml = YAML::load(erb_render(IO.read(yaml_file_path)))
+            yaml = yaml.value if yaml.respond_to?(:type_id) and yaml.respond_to?(:value)
+            yaml.each do |name, data|
+              self[name] = Fixture.new(data, @class_name)
+            end
+          end
         rescue Exception=>boom
           raise Fixture::FormatError, "a YAML error occured parsing #{yaml_file_path}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{boom.class}: #{boom}"
         end
@@ -342,7 +359,15 @@ class Fixture #:nodoc:
   end
 
   def initialize(fixture, class_name)
-    @fixture = fixture.is_a?(Hash) ? fixture : read_fixture_file(fixture)
+    case fixture
+      when Hash, YAML::Omap
+        @fixture = fixture
+      when String
+        @fixture = read_fixture_file(fixture)
+      else
+        raise ArgumentError, "Bad fixture argument #{fixture.inspect}"
+    end
+
     @class_name = class_name
   end
 
@@ -397,8 +422,6 @@ end
 module Test #:nodoc:
   module Unit #:nodoc:
     class TestCase #:nodoc:
-      include ClassInheritableAttributes
-
       cattr_accessor :fixture_path
       class_inheritable_accessor :fixture_table_names
       class_inheritable_accessor :use_transactional_fixtures

data/lib/active_record/migration.rb

@@ -63,7 +63,7 @@ module ActiveRecord
   # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes the column to a different type using the same
   #   parameters as add_column.
   # * <tt>remove_column(table_name, column_name)</tt>: Removes the column named +column_name+ from the table called +table_name+.
-  # * <tt>add_index(table_name, column_name)</tt>: Add a new index with the name of the column on the column.
+  # * <tt>add_index(table_name, column_name, index_type)</tt>: Add a new index with the name of the column on the column. Specify an optional index_type (e.g. UNIQUE).
   # * <tt>remove_index(table_name, column_name)</tt>: Remove the index called the same as the column.
   #
   # == Irreversible transformations
@@ -120,6 +120,21 @@ module ActiveRecord
   #       execute "ALTER TABLE `pages_linked_pages` DROP INDEX `page_id_linked_page_id`"
   #     end
   #   end
+  #
+  # == Using the class after changing table
+  #
+  # Some times you'll want to add a column in a migration and populate it immediately after. In that case, you'll need
+  # to make a call to Base#reset_column_information in order to ensure that the class has the latest column data from 
+  # after the new column was added. Example:
+  #
+  #   class MakeJoinUnique < ActiveRecord::Migration
+  #     def self.up
+  #       add_column :people, :salary, :integer
+  #       Person.find(:all).each do |p|
+  #         p.salary = SalaryCalculator.compute(p)
+  #       end
+  #     end
+  #   end  
   class Migration
     class << self
       def up() end
@@ -127,6 +142,7 @@ module ActiveRecord
 
       private
         def method_missing(method, *arguments, &block)
+          arguments[0] = Migrator.proper_table_name(arguments.first) unless arguments.empty?
           ActiveRecord::Base.connection.send(method, *arguments, &block)
         end
     end
@@ -135,6 +151,7 @@ module ActiveRecord
   class Migrator#:nodoc:
     class << self
       def migrate(migrations_path, target_version = nil)
+        Base.connection.initialize_schema_information
         case
           when target_version.nil?, current_version < target_version
             up(migrations_path, target_version)
@@ -153,9 +170,19 @@ module ActiveRecord
         self.new(:down, migrations_path, target_version).migrate
       end
       
+      def schema_info_table_name
+        Base.table_name_prefix + "schema_info" + Base.table_name_suffix
+      end
+
       def current_version
-        Base.connection.select_one("SELECT version FROM schema_info")["version"].to_i
+        (Base.connection.select_one("SELECT version FROM #{schema_info_table_name}") || {"version" => 0})["version"].to_i
+      end
+
+      def proper_table_name(name)
+        # Use the ActiveRecord objects own table_name, or pre/suffix from ActiveRecord::Base if name is a symbol/string
+        name.table_name rescue "#{ActiveRecord::Base.table_name_prefix}#{name}#{ActiveRecord::Base.table_name_suffix}"
       end
+        
     end
     
     def initialize(direction, migrations_path, target_version = nil)
@@ -191,10 +218,12 @@ module ActiveRecord
       end
     
       def migration_files
-        files = Dir["#{@migrations_path}/[0-9]*_*.rb"].sort
+        files = Dir["#{@migrations_path}/[0-9]*_*.rb"].sort_by do |f|
+          migration_version_and_name(f).first.to_i
+        end
         down? ? files.reverse : files
       end
-      
+                 
       def migration_class(migration_name)
         migration_name.camelize.constantize
       end
@@ -204,7 +233,7 @@ module ActiveRecord
       end
       
       def set_schema_version(version)
-        Base.connection.update("UPDATE schema_info SET version = #{down? ? version.to_i - 1 : version.to_i}")
+        Base.connection.update("UPDATE #{self.class.schema_info_table_name} SET version = #{down? ? version.to_i - 1 : version.to_i}")
       end
       
       def up?

data/lib/active_record/observer.rb

@@ -1,6 +1,33 @@
 require 'singleton'
 
 module ActiveRecord
+  module Observing # :nodoc:
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Activates the observers assigned. Examples:
+      #
+      #   # Calls PersonObserver.instance
+      #   ActiveRecord::Base.observers = :person_observer
+      #
+      #   # Calls Cacher.instance and GarbageCollector.instance 
+      #   ActiveRecord::Base.observers = :cacher, :garbage_collector
+      #
+      #   # Same as above, just using explicit class references
+      #   ActiveRecord::Base.observers = Cacher, GarbageCollector
+      def observers=(*observers)
+        observers = [ observers ].flatten.each do |observer| 
+          observer.is_a?(Symbol) ? 
+            observer.to_s.camelize.constantize.instance :
+            observer.instance
+        end
+      end
+    end
+  end
+
   # Observer classes respond to lifecycle callbacks to implement trigger-like
   # behavior outside the original class. This is a great way to reduce the
   # clutter that normally comes when the model class is burdened with
@@ -48,7 +75,8 @@ module ActiveRecord
   # == Triggering Observers
   # 
   # In order to activate an observer, you need to call Observer.instance. In Rails, this can be done in controllers
-  # using the short-hand of for example observer :comment_observer.
+  # using the short-hand of for example observer :comment_observer. Or directly from Active Record, with
+  # ActiveRecord::Base.observer(:comment_observer).
   class Observer
     include Singleton
 
@@ -58,7 +86,9 @@ module ActiveRecord
     end
 
     def initialize
-      [ observed_class ].flatten.each do |klass| 
+      observed_classes = [ observed_class ].flatten
+      observed_subclasses_class = observed_classes.collect {|c| c.send(:subclasses) }.flatten!
+      (observed_classes + observed_subclasses_class).each do |klass| 
         klass.add_observer(self)
         klass.send(:define_method, :after_find) unless klass.respond_to?(:after_find)
       end

data/lib/active_record/query_cache.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     end
 
     def select_all(sql, name = nil)
-      @query_cache[sql] ||= @connection.select_all(sql, name)
+      (@query_cache[sql] ||= @connection.select_all(sql, name)).dup
     end
 
     def select_one(sql, name = nil)
@@ -37,21 +37,22 @@ module ActiveRecord
     end
     
     private
-      def method_missing(method, *arguments)
-        @connection.send(method, *arguments)
+      def method_missing(method, *arguments, &proc)
+        @connection.send(method, *arguments, &proc)
       end
   end
   
   class Base
     # Set the connection for the class with caching on
-    def self.connection=(spec)
-      raise ConnectionNotEstablished unless spec
-
-      conn = spec.config[:query_cache] ?
-        QueryCache.new(self.send(spec.adapter_method, spec.config)) :
-        self.send(spec.adapter_method, spec.config)
-      
-      active_connections[self] = conn
+    class << self
+      alias_method :connection_without_query_cache=, :connection=
+
+      def connection=(spec)
+        if spec.is_a?(ConnectionSpecification) and spec.config[:query_cache]
+          spec = QueryCache.new(self.send(spec.adapter_method, spec.config))
+        end
+        self.connection_without_query_cache = spec
+      end
     end
   end
   

data/lib/active_record/schema.rb

@@ -0,0 +1,58 @@
+module ActiveRecord
+  # Allows programmers to programmatically define a schema in a portable
+  # DSL. This means you can define tables, indexes, etc. without using SQL
+  # directly, so your applications can more easily support multiple
+  # databases.
+  #
+  # Usage:
+  #
+  #   ActiveRecord::Schema.define do
+  #     create_table :authors do |t|
+  #       t.column :name, :string, :null => false
+  #     end
+  #
+  #     add_index :authors, :name, :unique
+  #
+  #     create_table :posts do |t|
+  #       t.column :author_id, :integer, :null => false
+  #       t.column :subject, :string
+  #       t.column :body, :text
+  #       t.column :private, :boolean, :default => false
+  #     end
+  #
+  #     add_index :posts, :author_id
+  #   end
+  #
+  # ActiveRecord::Schema is only supported by database adapters that also
+  # support migrations, the two features being very similar.
+  class Schema < Migration
+    private_class_method :new
+
+    # Eval the given block. All methods available to the current connection
+    # adapter are available within the block, so you can easily use the
+    # database definition DSL to build up your schema (#create_table,
+    # #add_index, etc.).
+    #
+    # The +info+ hash is optional, and if given is used to define metadata
+    # about the current schema (like the schema's version):
+    #
+    #   ActiveRecord::Schema.define(:version => 15) do
+    #     ...
+    #   end
+    def self.define(info={}, &block)
+      instance_eval(&block)
+
+      unless info.empty?
+        initialize_schema_information
+        cols = columns('schema_info')
+
+        info = info.map do |k,v|
+          v = quote(v, cols.detect { |c| c.name == k.to_s })
+          "#{k} = #{v}"
+        end
+
+        update "UPDATE schema_info SET #{info.join(", ")}"
+      end
+    end
+  end
+end