activerecord 2.0.1 → 2.0.2

data/lib/active_record/calculations.rb

@@ -15,12 +15,10 @@ module ActiveRecord
       # The third approach, count using options, accepts an option hash as the only parameter. The options are:
       #
       # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro.
-      # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
-      #    or names associations in the same form used for the :include option.
+      # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
+      #   or named associations in the same form used for the :include option, which will perform an INNER JOIN on the associated table(s).
       #   If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
       #   Pass :readonly => false to override.
-      #   See adding joins for associations under Associations.
-      #
       # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
       #   to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
       #   See eager loading under Associations.

data/lib/active_record/fixtures.rb

@@ -9,7 +9,12 @@ module YAML #:nodoc:
   end
 end
 
-class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
+if defined? ActiveRecord
+  class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
+  end
+else
+  class FixtureClassNotFound < StandardError #:nodoc:
+  end
 end
 
 # Fixtures are a way of organizing data that you want to test against; in short, sample data. They come in 3 flavors:
@@ -911,6 +916,8 @@ module Test #:nodoc:
       end
 
       def setup_with_fixtures
+        return if @fixtures_setup
+        @fixtures_setup = true
         return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
 
         if pre_loaded_fixtures && !use_transactional_fixtures
@@ -942,6 +949,8 @@ module Test #:nodoc:
       alias_method :setup, :setup_with_fixtures
 
       def teardown_with_fixtures
+        return if @fixtures_teardown
+        @fixtures_teardown = true
         return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
 
         unless use_transactional_fixtures?
@@ -958,24 +967,31 @@ module Test #:nodoc:
       alias_method :teardown, :teardown_with_fixtures
 
       def self.method_added(method)
+        return if @__disable_method_added__
+        @__disable_method_added__ = true
+        
         case method.to_s
         when 'setup'
           unless method_defined?(:setup_without_fixtures)
             alias_method :setup_without_fixtures, :setup
-            define_method(:setup) do
+            define_method(:full_setup) do
               setup_with_fixtures
               setup_without_fixtures
             end
           end
+          alias_method :setup, :full_setup
         when 'teardown'
           unless method_defined?(:teardown_without_fixtures)
             alias_method :teardown_without_fixtures, :teardown
-            define_method(:teardown) do
+            define_method(:full_teardown) do
               teardown_without_fixtures
               teardown_with_fixtures
             end
           end
+          alias_method :teardown, :full_teardown
         end
+        
+        @__disable_method_added__ = false
       end
 
       private

data/lib/active_record/locking/optimistic.rb

@@ -70,7 +70,7 @@ module ActiveRecord
           return update_without_lock unless locking_enabled?
 
           lock_col = self.class.locking_column
-          previous_value = send(lock_col)
+          previous_value = send(lock_col).to_i
           send(lock_col + '=', previous_value + 1)
 
           begin

data/lib/active_record/validations.rb

@@ -297,7 +297,33 @@ module ActiveRecord
                                   :equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
                                   :odd => 'odd?', :even => 'even?' }.freeze
 
-
+      # Adds a validation method or block to the class. This is useful when
+      # overriding the #validate instance method becomes too unwieldly and
+      # you're looking for more descriptive declaration of your validations.
+      #
+      # This can be done with a symbol pointing to a method:
+      #
+      #   class Comment < ActiveRecord::Base
+      #     validate :must_be_friends
+      #
+      #     def must_be_friends
+      #       errors.add_to_base("Must be friends to leave a comment") unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # Or with a block which is passed the current record to be validated:
+      #
+      #   class Comment < ActiveRecord::Base
+      #     validate do |comment|
+      #       comment.must_be_friends
+      #     end
+      #
+      #     def must_be_friends
+      #       errors.add_to_base("Must be friends to leave a comment") unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # This usage applies to #validate_on_create and #validate_on_update as well.
       def validate(*methods, &block)
         methods << block if block_given?
         write_inheritable_set(:validate, methods)
@@ -403,7 +429,7 @@ module ActiveRecord
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:confirmation], :on => :save }
         configuration.update(attr_names.extract_options!)
 
-        attr_accessor *(attr_names.map { |n| "#{n}_confirmation" })
+        attr_accessor(*(attr_names.map { |n| "#{n}_confirmation" }))
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
           record.errors.add(attr_name, configuration[:message]) unless record.send("#{attr_name}_confirmation").nil? or value == record.send("#{attr_name}_confirmation")
@@ -425,7 +451,8 @@ module ActiveRecord
       # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
       # * <tt>allow_nil</tt> - Skip validation if attribute is nil. (default is true)
       # * <tt>accept</tt> - Specifies value that is considered accepted.  The default value is a string "1", which
-      #   makes it easy to relate to an HTML checkbox.
+      #   makes it easy to relate to an HTML checkbox. This should be set to 'true' if you are validating a database
+      #   column, since the attribute is typecast from "1" to <tt>true</tt> before validation.
       # * <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.
@@ -436,7 +463,13 @@ module ActiveRecord
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save, :allow_nil => true, :accept => "1" }
         configuration.update(attr_names.extract_options!)
 
-        attr_accessor *attr_names.reject { |name| column_names.include? name.to_s }
+        db_cols = begin
+          column_names
+        rescue ActiveRecord::StatementInvalid
+          []
+        end
+        names = attr_names.reject { |name| db_cols.include?(name.to_s) }
+        attr_accessor(*names)
 
         validates_each(attr_names,configuration) do |record, attr_name, value|
           record.errors.add(attr_name, configuration[:message]) unless value == configuration[:accept]

data/lib/active_record/version.rb

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

data/test/aaa_create_tables_test.rb

@@ -33,12 +33,12 @@ class AAACreateTablesTest < Test::Unit::TestCase
   private
     def use_migrations?
       unittest_sql_filename = ActiveRecord::Base.connection.adapter_name.downcase + ".sql"
-      not File.exists? "#{@base_path}/#{unittest_sql_filename}"
+      not File.exist? "#{@base_path}/#{unittest_sql_filename}"
     end
 
     def use_migrations_for_courses?
       unittest2_sql_filename = ActiveRecord::Base.connection.adapter_name.downcase + "2.sql"
-      not File.exists? "#{@base_path}/#{unittest2_sql_filename}"
+      not File.exist? "#{@base_path}/#{unittest2_sql_filename}"
     end
 
     def recreate(base, suffix = nil)

data/test/associations/join_model_test.rb

@@ -539,6 +539,12 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   def test_has_many_through_has_many_with_sti
     assert_equal [comments(:does_it_hurt)], authors(:david).special_post_comments
   end
+  
+  def test_uniq_has_many_through_should_retain_order
+    comment_ids = authors(:david).comments.map(&:id)
+    assert_equal comment_ids.sort, authors(:david).ordered_uniq_comments.map(&:id)
+    assert_equal comment_ids.sort.reverse, authors(:david).ordered_uniq_comments_desc.map(&:id)
+  end
 
   private
     # create dynamic Post models to allow different dependency options

data/test/associations_test.rb

@@ -55,7 +55,7 @@ class AssociationsTest < Test::Unit::TestCase
   def test_storing_in_pstore
     require "tmpdir"
     store_filename = File.join(Dir.tmpdir, "ar-pstore-association-test")
-    File.delete(store_filename) if File.exists?(store_filename)
+    File.delete(store_filename) if File.exist?(store_filename)
     require "pstore"
     apple = Firm.create("name" => "Apple")
     natural = Client.new("name" => "Natural Company")
@@ -133,6 +133,13 @@ class AssociationProxyTest < Test::Unit::TestCase
     assert_nil p.author.reset
   end
 
+  def test_reload_returns_assocition
+    david = developers(:david)
+    assert_nothing_raised do
+      assert_equal david.projects, david.projects.reload.reload
+    end
+  end
+
   def setup_dangling_association
     josh = Author.create(:name => "Josh")
     p = Post.create(:title => "New on Edge", :body => "More cool stuff!", :author => josh)

data/test/finder_test.rb

@@ -28,7 +28,15 @@ class FinderTest < Test::Unit::TestCase
     assert Topic.exists?(:author_name => "Mary", :approved => true)
     assert Topic.exists?(["parent_id = ?", 1])
     assert !Topic.exists?(45)
-    assert !Topic.exists?("foo")
+
+    begin
+      assert !Topic.exists?("foo")
+    rescue ActiveRecord::StatementInvalid
+      # PostgreSQL complains about string comparison with integer field
+    rescue Exception
+      flunk
+    end
+
     assert_raise(NoMethodError) { Topic.exists?([1,2]) }
   end
 

data/test/fixtures/author.rb

@@ -18,6 +18,8 @@ class Author < ActiveRecord::Base
   has_many :comments_desc, :through => :posts, :source => :comments, :order => 'comments.id DESC'
   has_many :limited_comments, :through => :posts, :source => :comments, :limit => 1
   has_many :funky_comments, :through => :posts, :source => :comments
+  has_many :ordered_uniq_comments, :through => :posts, :source => :comments, :uniq => true, :order => 'comments.id'
+  has_many :ordered_uniq_comments_desc, :through => :posts, :source => :comments, :uniq => true, :order => 'comments.id DESC'
 
   has_many :special_posts
   has_many :special_post_comments, :through => :special_posts, :source => :comments

data/test/fixtures_test.rb

@@ -324,6 +324,22 @@ class MultipleFixturesTest < Test::Unit::TestCase
   end
 end
 
+# This is to reproduce a bug where if a TestCase is loaded
+# twice by Ruby, it loses its fixture setup hook.
+class_def = <<-CODE
+  class DoubleLoadedTestCase < Test::Unit::TestCase
+    fixtures :topics
+
+    def setup
+    end
+  
+    def test_should_properly_setup_fixtures
+      assert_nothing_raised { topics(:first) }
+    end
+  end
+CODE
+2.times { eval(class_def) }
+
 class OverlappingFixturesTest < Test::Unit::TestCase
   fixtures :topics, :developers
   fixtures :developers, :accounts

data/test/locking_test.rb

@@ -64,6 +64,15 @@ class OptimisticLockingTest < Test::Unit::TestCase
 
     assert_raises(ActiveRecord::StaleObjectError) { p2.save! }
   end
+  
+  def test_lock_new_with_nil
+    p1 = Person.new(:first_name => 'anika')
+    p1.save!
+    p1.lock_version = nil # simulate bad fixture or column with no default
+    p1.save!
+    assert_equal 1, p1.lock_version
+  end
+    
 
   def test_lock_column_name_existing
     t1 = LegacyThing.find(1)

data/test/validations_test.rb

@@ -301,6 +301,14 @@ class ValidationsTest < Test::Unit::TestCase
     assert_equal "Dan Brown", reply["author_name"]
   end
 
+  def test_validates_acceptance_of_with_non_existant_table 
+    Object.const_set :IncorporealModel, Class.new(ActiveRecord::Base) 
+ 
+    assert_nothing_raised ActiveRecord::StatementInvalid do 
+      IncorporealModel.validates_acceptance_of(:incorporeal_column) 
+    end 
+  end 
+
   def test_validate_presences
     Topic.validates_presence_of(:title, :content)
 

metadata

@@ -1,33 +1,34 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: activerecord
 version: !ruby/object:Gem::Version 
-  version: 2.0.1
-date: 2007-12-07 00:00:00 -06:00
-summary: Implements the ActiveRecord pattern for ORM.
-require_paths: 
-- lib
-email: david@loudthinking.com
-homepage: http://www.rubyonrails.org
-rubyforge_project: activerecord
-description: Implements the ActiveRecord pattern (Fowler, PoEAA) for ORM. It ties database tables and classes together for business objects, like Customer or Subscription, that can find, save, and destroy themselves without resorting to manual SQL.
-autorequire: active_record
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 2.0.2
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - David Heinemeier Hansson
+autorequire: active_record
+bindir: bin
+cert_chain: []
+
+date: 2007-12-20 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 
+description: Implements the ActiveRecord pattern (Fowler, PoEAA) for ORM. It ties database tables and classes together for business objects, like Customer or Subscription, that can find, save, and destroy themselves without resorting to manual SQL.
+email: david@loudthinking.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
 files: 
 - Rakefile
 - install.rb
@@ -96,7 +97,6 @@ files:
 - test/ar_schema_test.rb
 - test/association_inheritance_reload.rb
 - test/associations
-- test/associations/ar_joins_test.rb
 - test/associations/callbacks_test.rb
 - test/associations/cascaded_eager_loading_test.rb
 - test/associations/eager_singularization_test.rb
@@ -345,26 +345,32 @@ files:
 - test/validations_test.rb
 - test/xml_serialization_test.rb
 - examples/associations.png
-test_files: []
-
+has_rdoc: true
+homepage: http://www.rubyonrails.org
+post_install_message: 
 rdoc_options: 
 - --main
 - README
-extra_rdoc_files: 
-- README
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        version: 2.0.1
-    version: 
+rubyforge_project: activerecord
+rubygems_version: 1.0.0
+signing_key: 
+specification_version: 2
+summary: Implements the ActiveRecord pattern for ORM.
+test_files: []
+