activerecord 1.11.1 → 1.12.1

data/lib/active_record/schema_dumper.rb

@@ -0,0 +1,84 @@
+module ActiveRecord
+  # This class is used to dump the database schema for some connection to some
+  # output format (i.e., ActiveRecord::Schema).
+  class SchemaDumper #:nodoc:
+    private_class_method :new
+
+    def self.dump(connection=ActiveRecord::Base.connection, stream=STDOUT)
+      new(connection).dump(stream)
+      stream
+    end
+
+    def dump(stream)
+      header(stream)
+      tables(stream)
+      trailer(stream)
+      stream
+    end
+
+    private
+
+      def initialize(connection)
+        @connection = connection
+        @types = @connection.native_database_types
+        @info = @connection.select_one("SELECT * FROM schema_info") rescue nil
+      end
+
+      def header(stream)
+        define_params = @info ? ":version => #{@info['version']}" : ""
+
+        stream.puts <<HEADER
+# This file is autogenerated. Instead of editing this file, please use the
+# migrations feature of ActiveRecord to incrementally modify your database, and
+# then regenerate this schema definition.
+
+ActiveRecord::Schema.define(#{define_params}) do
+
+HEADER
+      end
+
+      def trailer(stream)
+        stream.puts "end"
+      end
+
+      def tables(stream)
+        @connection.tables.sort.each do |tbl|
+          next if tbl == "schema_info"
+          table(tbl, stream)
+        end
+      end
+
+      def table(table, stream)
+        columns = @connection.columns(table)
+
+        stream.print "  create_table #{table.inspect}"
+        stream.print ", :id => false" if !columns.detect { |c| c.name == "id" }
+        stream.print ", :force => true"
+        stream.puts " do |t|"
+
+        columns.each do |column|
+          next if column.name == "id"
+          stream.print "    t.column #{column.name.inspect}, #{column.type.inspect}"
+          stream.print ", :limit => #{column.limit.inspect}" if column.limit != @types[column.type][:limit] 
+          stream.print ", :default => #{column.default.inspect}" if !column.default.nil?
+          stream.print ", :null => false" if !column.null
+          stream.puts
+        end
+
+        stream.puts "  end"
+        stream.puts
+
+        indexes(table, stream)
+      end
+
+      def indexes(table, stream)
+        indexes = @connection.indexes(table)
+        indexes.each do |index|
+          stream.print "  add_index #{index.table.inspect}, #{index.columns.inspect}, :name => #{index.name.inspect}"
+          stream.print ", :unique => true" if index.unique
+          stream.puts
+        end
+        stream.puts unless indexes.empty?
+      end
+  end
+end

data/lib/active_record/transactions.rb

@@ -81,9 +81,7 @@ module ActiveRecord
     # Tribute: Object-level transactions are implemented by Transaction::Simple by Austin Ziegler.
     module ClassMethods
       def transaction(*objects, &block)
-        previous_handler = trap('TERM') do
-          raise TransactionError, "Transaction aborted"
-        end
+        previous_handler = trap('TERM') { raise TransactionError, "Transaction aborted" }
         lock_mutex
         
         begin

data/lib/active_record/validations.rb

@@ -21,8 +21,8 @@ module ActiveRecord
       :too_short => "is too short (min is %d characters)", 
       :wrong_length => "is the wrong length (should be %d characters)", 
       :taken => "has already been taken",
-      :not_a_number => "is not a number",
-      }
+      :not_a_number => "is not a number"
+    }
       
     # Holds a hash with all the default error messages, such that they can be replaced by your own copy or localizations.
     cattr_accessor :default_error_messages
@@ -179,7 +179,8 @@ module ActiveRecord
   #   person.count                        # => 2
   #   person.errors.on "last_name"        # => "can't be empty"
   #   person.errors.on "phone_number"     # => "has invalid format"
-  #   person.each_full { |msg| puts msg } # => "Last name can't be empty\n" +
+  #   person.errors.each_full { |msg| puts msg } 
+  #                                       # => "Last name can't be empty\n" +
   #                                            "Phone number has invalid format"
   #
   #   person.attributes = { "last_name" => "Heinemeier", "phone_number" => "555-555" }
@@ -398,9 +399,11 @@ module ActiveRecord
       # method, proc or string should return or evaluate to a true or false value.
       def validates_length_of(*attrs)
         # Merge given options with defaults.
-        options = {:too_long     => ActiveRecord::Errors.default_error_messages[:too_long],
-                   :too_short    => ActiveRecord::Errors.default_error_messages[:too_short],
-                   :wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length]}.merge(DEFAULT_VALIDATION_OPTIONS)
+        options = {
+          :too_long     => ActiveRecord::Errors.default_error_messages[:too_long],
+          :too_short    => ActiveRecord::Errors.default_error_messages[:too_short],
+          :wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length]
+        }.merge(DEFAULT_VALIDATION_OPTIONS)
         options.update(attrs.pop.symbolize_keys) if attrs.last.is_a?(Hash)
 
         # Ensure that one and only one range option is specified.
@@ -418,24 +421,31 @@ module ActiveRecord
         option = range_options.first
         option_value = options[range_options.first]
 
-        # Declare different validations per option.
-        validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
-        message_options = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }
-
         case option
         when :within, :in
-          raise ArgumentError, ':within must be a Range' unless option_value.is_a?(Range) # '
-          (options_without_range = options.dup).delete(option)
-          (options_with_minimum = options_without_range.dup).store(:minimum, option_value.begin)
-          validates_length_of attrs, options_with_minimum
-          (options_with_maximum = options_without_range.dup).store(:maximum, option_value.end)
-          validates_length_of attrs, options_with_maximum
+          raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range) 
+
+          too_short = options[:too_short] % option_value.begin
+          too_long  = options[:too_long]  % option_value.end
+
+          validates_each(attrs, options) do |record, attr, value|
+            if value.nil? or value.size < option_value.begin
+              record.errors.add(attr, too_short)
+            elsif value.size > option_value.end
+              record.errors.add(attr, too_long)
+            end
+          end
         when :is, :minimum, :maximum
-          raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0 # '
-          message = options[:message] || options[message_options[option]]
-          message = (message % option_value) rescue message
+          raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0
+
+          # Declare different validations per option.
+          validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
+          message_options = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }
+
+          message = (options[:message] || options[message_options[option]]) % option_value
+
           validates_each(attrs, options) do |record, attr, value|
-            record.errors.add(attr, message) if value.nil? or !value.size.method(validity_checks[option])[option_value]
+            record.errors.add(attr, message) unless !value.nil? and value.size.method(validity_checks[option])[option_value]
           end
         end
       end
@@ -588,7 +598,7 @@ module ActiveRecord
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
           record.errors.add(attr_name, configuration[:message]) unless 
-            (value.is_a?(Array) ? value : [value]).inject(true) { |memo, r| (r.nil? or r.valid?) and memo }
+            (value.is_a?(Array) ? value : [value]).all? { |r| r.nil? or r.valid? }
         end
       end
       
@@ -604,7 +614,7 @@ module ActiveRecord
       # * <tt>message</tt> - A custom error message (default is: "is not a number")
       # * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
       # * <tt>only_integer</tt> Specifies whether the value has to be an integer, e.g. an integral value (default is false)
-      # * <tt>allow_nil</tt> Skip validation if attribute is nil (default is false). Notice that for fixnum and float columsn empty strings are converted to nil
+      # * <tt>allow_nil</tt> Skip validation if attribute is nil (default is false). Notice that for fixnum and float columns empty strings are converted to nil
       # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
       # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
       # method, proc or string should return or evaluate to a true or false value.
@@ -647,7 +657,12 @@ module ActiveRecord
     # The validation process on save can be skipped by passing false. The regular Base#save method is
     # replaced with this when the validations module is mixed in, which it is by default.
     def save_with_validation(perform_validation = true)
-      if perform_validation && valid? || !perform_validation then save_without_validation else false end
+      if perform_validation && valid? || !perform_validation
+        save_without_validation
+        true
+      else
+        false
+      end
     end
 
     # Attempts to save the record just like Base.save but will raise a RecordInvalid exception instead of returning false
@@ -660,7 +675,7 @@ module ActiveRecord
     # This is especially useful for boolean flags on existing records. The regular +update_attribute+ method
     # in Base is replaced with this when the validations module is mixed in, which it is by default.
     def update_attribute_with_validation_skipping(name, value)
-      self[name] = value
+      send(name.to_s + '=', value)
       save(false)
     end
 
@@ -684,8 +699,7 @@ module ActiveRecord
 
     # Returns the Errors object that holds all information about attribute error messages.
     def errors
-      @errors = Errors.new(self) if @errors.nil?
-      @errors
+      @errors ||= Errors.new(self)
     end
 
     protected

data/lib/active_record/vendor/mysql.rb

@@ -1022,6 +1022,9 @@ class Mysql
       end
       @sock.sync = true
       buf.join
+    rescue
+      errno = Error::CR_SERVER_LOST
+      raise Error::new(errno, Error::err(errno))
     end
     
     def write(data)
@@ -1039,6 +1042,9 @@ class Mysql
       @pkt_nr = @pkt_nr + 1 & 0xff
       @sock.sync = true
       @sock.flush
+    rescue
+      errno = Error::CR_SERVER_LOST
+      raise Error::new(errno, Error::err(errno))
     end
 
     def close()

data/lib/active_record/version.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module Version #:nodoc:
+    MAJOR = 1
+    MINOR = 12
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/rakefile

@@ -5,10 +5,11 @@ require 'rake/rdoctask'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'active_record', 'version')
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.11.1' + PKG_BUILD
+PKG_VERSION   = ActiveRecord::Version::STRING + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -22,23 +23,11 @@ PKG_FILES = FileList[
 
 
 desc "Default Task"
-task :default => [ :test_ruby_mysql, :test_mysql_ruby, :test_sqlite, :test_sqlite3, :test_postgresql ]
+task :default => [ :test_mysql, :test_sqlite, :test_postgresql ]
 
 # Run the unit tests
 
-Rake::TestTask.new("test_ruby_mysql") { |t|
-  t.libs << "test" << "test/connections/native_mysql"
-  t.pattern = 'test/*_test{,_mysql}.rb'
-  t.verbose = true
-}
-
-Rake::TestTask.new("test_mysql_ruby") { |t|
-  t.libs << "test" << "test/connections/native_mysql"
-  t.pattern = 'test/*_test{,_mysql}.rb'
-  t.verbose = true
-}
-
-for adapter in %w( postgresql sqlite sqlite3 sqlserver sqlserver_odbc db2 oci )
+for adapter in %w( mysql postgresql sqlite sqlite3 sqlserver sqlserver_odbc db2 oci )
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" << "test/connections/native_#{adapter}"
     t.pattern = "test/*_test{,_#{adapter}}.rb"
@@ -82,7 +71,7 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   
-  s.add_dependency('activesupport', '= 1.1.1' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.2.1' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"

data/test/abstract_unit.rb

@@ -9,16 +9,11 @@ require 'active_support/breakpoint'
 require 'connection'
 
 class Test::Unit::TestCase #:nodoc:
-  def create_fixtures(*table_names)
-    if block_given?
-      Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names) { yield }
-    else
-      Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names)
-    end
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+  self.use_instantiated_fixtures = false
+  self.use_transactional_fixtures = (ENV['AR_NO_TX_FIXTURES'] != "yes")
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names, &block)
   end
 end
-
-Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
-Test::Unit::TestCase.use_instantiated_fixtures = false
-Test::Unit::TestCase.use_transactional_fixtures = (ENV['AR_TX_FIXTURES'] == "yes")
-

data/test/adapter_test.rb

@@ -0,0 +1,58 @@
+require 'abstract_unit'
+
+class AdapterTest < Test::Unit::TestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def test_tables
+    if @connection.respond_to?(:tables)
+      tables = @connection.tables
+      assert tables.include?("accounts")
+      assert tables.include?("authors")
+      assert tables.include?("tasks")
+      assert tables.include?("topics")
+    else
+      warn "#{@connection.class} does not respond to #tables"
+    end
+  end
+
+  def test_indexes
+    if @connection.respond_to?(:indexes)
+      indexes = @connection.indexes("accounts")
+      assert indexes.empty?
+
+      @connection.add_index :accounts, :firm_id
+      indexes = @connection.indexes("accounts")
+      assert_equal "accounts", indexes.first.table
+      assert_equal "accounts_firm_id_index", indexes.first.name
+      assert !indexes.first.unique
+      assert_equal ["firm_id"], indexes.first.columns
+    else
+      warn "#{@connection.class} does not respond to #indexes"
+    end
+
+  ensure
+    @connection.remove_index :accounts, :firm_id rescue nil
+  end
+
+  # test resetting sequences in odd tables in postgreSQL
+  if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
+    require 'fixtures/movie'
+    require 'fixtures/subscriber'
+    def test_reset_empty_table_with_custom_pk
+      Movie.delete_all
+      Movie.connection.reset_pk_sequence! 'movies'
+      assert_equal 1, Movie.create(:name => 'fight club').id
+    end
+
+    def test_reset_table_with_non_integer_pk
+      Subscriber.delete_all
+      Subscriber.connection.reset_pk_sequence! 'subscribers'
+
+      sub = Subscriber.new(:name => 'robert drake')
+      sub.id = 'bob drake'
+      assert sub.save!
+    end
+  end
+end

data/test/ar_schema_test.rb

@@ -0,0 +1,33 @@
+require 'abstract_unit'
+require "#{File.dirname(__FILE__)}/../lib/active_record/schema"
+
+if ActiveRecord::Base.connection.supports_migrations? 
+
+  class ActiveRecordSchemaTest < Test::Unit::TestCase
+    self.use_transactional_fixtures = false
+
+    def setup
+      @connection = ActiveRecord::Base.connection
+    end
+
+    def teardown
+      @connection.drop_table :fruits rescue nil
+    end
+
+    def test_schema_define
+      ActiveRecord::Schema.define(:version => 7) do
+        create_table :fruits do |t|
+          t.column :color, :string
+          t.column :size, :string
+          t.column :texture, :string
+          t.column :flavor, :string
+        end
+      end
+
+      assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+      assert_nothing_raised { @connection.select_all "SELECT * FROM schema_info" }
+      assert_equal 7, @connection.select_one("SELECT version FROM schema_info")['version'].to_i
+    end
+  end
+
+end

data/test/association_callbacks_test.rb

@@ -83,6 +83,20 @@ class AssociationCallbacksTest < Test::Unit::TestCase
     assert_equal ["before_removing#{david.id}", "after_removing#{david.id}", "before_removing#{jamis.id}", 
                   "after_removing#{jamis.id}"], activerecord.developers_log
   end
+
+  def test_has_and_belongs_to_many_remove_callback_on_clear
+    activerecord = projects(:active_record)
+    assert activerecord.developers_log.empty?
+    if activerecord.developers_with_callbacks.size == 0
+      activerecord.developers << developers(:david)
+      activerecord.developers << developers(:jamis)
+      activerecord.reload
+      assert activerecord.developers_with_callbacks.size == 2
+    end
+    log_array = activerecord.developers_with_callbacks.collect {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.flatten.sort
+    assert activerecord.developers_with_callbacks.clear
+    assert_equal log_array, activerecord.developers_log.sort
+  end
   
   def test_dont_add_if_before_callback_raises_exception
     assert !@david.unchangable_posts.include?(@authorless)

data/test/associations_go_eager_test.rb

@@ -20,14 +20,19 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert post.comments.include?(comments(:greetings))
   end
 
+  def test_loading_conditions_with_or
+    posts = authors(:david).posts.find(:all, :include => :comments, :conditions => "comments.body like 'Normal%' OR comments.type = 'SpecialComment'")
+    assert_nil posts.detect { |p| p.author_id != authors(:david).id },
+      "expected to find only david's posts"
+  end
+
   def test_with_ordering
-    posts = Post.find(:all, :include => :comments, :order => "posts.id DESC")
-    assert_equal posts(:sti_habtm), posts[0]
-    assert_equal posts(:sti_post_and_comments), posts[1]
-    assert_equal posts(:sti_comments), posts[2]
-    assert_equal posts(:authorless), posts[3]
-    assert_equal posts(:thinking), posts[4]
-    assert_equal posts(:welcome), posts[5]
+    list = Post.find(:all, :include => :comments, :order => "posts.id DESC")
+    [:eager_other, :sti_habtm, :sti_post_and_comments, :sti_comments,
+     :authorless, :thinking, :welcome
+    ].each_with_index do |post, index|
+      assert_equal posts(post), list[index]
+    end
   end
 
   def test_loading_with_multiple_associations
@@ -48,32 +53,32 @@ class EagerAssociationTest < Test::Unit::TestCase
 
   def test_eager_association_loading_with_belongs_to
     comments = Comment.find(:all, :include => :post)
-    assert_equal 9, comments.length
+    assert_equal 10, comments.length
     titles = comments.map { |c| c.post.title }
     assert titles.include?(posts(:welcome).title)
     assert titles.include?(posts(:sti_post_and_comments).title)
   end
   
   def test_eager_association_loading_with_belongs_to_and_limit
-    comments = Comment.find(:all, :include => :post, :limit => 5)
+    comments = Comment.find(:all, :include => :post, :limit => 5, :order => 'comments.id')
     assert_equal 5, comments.length
     assert_equal [1,2,3,5,6], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
-    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3)
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :order => 'comments.id')
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset
-    comments = Comment.find(:all, :include => :post, :limit => 3, :offset => 2)
+    comments = Comment.find(:all, :include => :post, :limit => 3, :offset => 2, :order => 'comments.id')
     assert_equal 3, comments.length
     assert_equal [3,5,6], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
-    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :offset => 1)
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :offset => 1, :order => 'comments.id')
     assert_equal 3, comments.length
     assert_equal [6,7,8], comments.collect { |c| c.id }
   end
@@ -90,8 +95,35 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal [], posts
   end
   
-  def test_eager_association_raise_on_limit
-    assert_raises(ActiveRecord::ConfigurationError) { Post.find(:all, :include => [:author, :comments], :limit => 1) }
+  def test_eager_with_has_many_and_limit
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2)
+    assert_equal 2, posts.size
+    assert_equal 3, posts.inject(0) { |sum, post| sum += post.comments.size }
+  end
+
+  def test_eager_with_has_many_and_limit_with_no_results
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.title = 'magic forest'")
+    assert_equal 0, posts.size
+  end
+
+  def test_eager_with_has_and_belongs_to_many_and_limit
+    posts = Post.find(:all, :include => :categories, :order => "posts.id", :limit => 3)
+    assert_equal 3, posts.size
+    assert_equal 2, posts[0].categories.size
+    assert_equal 1, posts[1].categories.size
+    assert_equal 0, posts[2].categories.size
+    assert posts[0].categories.include?(categories(:technology))
+    assert posts[1].categories.include?(categories(:general))
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions_on_the_eagers
+    assert_raises(ArgumentError) do
+      posts = authors(:david).posts.find(:all, 
+        :include    => :comments, 
+        :conditions => "comments.body like 'Normal%' OR comments.type = 'SpecialComment'",
+        :limit      => 2
+      )
+    end
   end
 
   def test_eager_association_loading_with_habtm
@@ -136,12 +168,22 @@ class EagerAssociationTest < Test::Unit::TestCase
   end
 
   def test_eager_with_invalid_association_reference
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+      post = Post.find(6, :include=> :monkeys )
+    }
     assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
       post = Post.find(6, :include=>[ :monkeys ])
     }
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+      post = Post.find(6, :include=>[ 'monkeys' ])
+    }
     assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
       post = Post.find(6, :include=>[ :monkeys, :elephants ])
     }
   end
 
+  def test_eager_with_valid_association_as_string_not_symbol
+    assert_nothing_raised { Post.find(:all, :include => 'comments') }
+  end
+
 end