activerecord 1.7.0 → 1.8.0

data/lib/active_record/fixtures.rb

@@ -1,8 +1,6 @@
 require 'erb'
 require 'yaml'
 require 'csv'
-require 'active_support/class_inheritable_attributes'
-require 'active_support/inflector'
 
 # Fixtures are a way of organizing data that you want to test against; in short, sample data. They come in 3 flavours:
 #
@@ -140,16 +138,46 @@ require 'active_support/inflector'
 # This is however a feature to be used with some caution. The point of fixtures are that they're stable units of predictable
 # sample data. If you feel that you need to inject dynamic values, then perhaps you should reexamine whether your application
 # is properly testable. Hence, dynamic values in fixtures are to be considered a code smell.
+#
+# = Transactional fixtures
+#
+# TestCases can use begin+rollback to isolate their changes to the database instead of having to delete+insert for every test case. 
+# They can also turn off auto-instantiation of fixture data since the feature is costly and often unused.
+#
+#   class FooTest < Test::Unit::TestCase
+#     self.use_transactional_fixtures = true
+#     self.use_instantiated_fixtures = false
+#   
+#     fixtures :foos
+#   
+#     def test_godzilla
+#       assert !Foo.find_all.emtpy?
+#       Foo.destroy_all
+#       assert Foo.find_all.emtpy?
+#     end
+#   
+#     def test_godzilla_aftermath
+#       assert !Foo.find_all.emtpy?
+#     end
+#   end
+#   
+# If you preload your test database with all fixture data (probably in the Rakefile task) and use transactional fixtures, 
+# then you may omit all fixtures declarations in your test cases since all the data's already there and every case rolls back its changes.
+#
+# When *not* to use transactional fixtures: 
+#   1. You're testing whether a transaction works correctly. Nested transactions don't commit until all parent transactions commit, 
+#      particularly, the fixtures transaction which is begun in setup and rolled back in teardown. Thus, you won't be able to verify 
+#      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
   DEFAULT_FILTER_RE = /\.ya?ml$/
 
-  def self.instantiate_fixtures(object, fixtures_directory, *table_names)
-    [ create_fixtures(fixtures_directory, *table_names) ].flatten.each_with_index do |fixtures, idx|
-      object.instance_variable_set "@#{table_names[idx]}", fixtures
-      fixtures.each do |name, fixture|
-        if model = fixture.find
-          object.instance_variable_set "@#{name}", model
-        end
+  def self.instantiate_fixtures(object, table_name, fixtures)
+    object.instance_variable_set "@#{table_name}", fixtures
+    fixtures.each do |name, fixture|
+      if model = fixture.find
+        object.instance_variable_set "@#{name}", model
       end
     end
   end
@@ -219,7 +247,7 @@ class Fixtures < Hash
           yaml = YAML::load(erb_render(IO.read(yaml_file_path)))
           yaml.each { |name, data| self[name] = Fixture.new(data, @class_name) } if yaml
         rescue Exception=>boom
-          raise Fixture::FormatError, "a YAML error occured parsing #{yaml_file_path}"
+          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"
         end
       elsif File.file?(csv_file_path)
         # CSV fixtures
@@ -324,51 +352,100 @@ class Fixture #:nodoc:
     end
 end
 
-module Test#:nodoc:
-  module Unit#:nodoc:
+module Test #:nodoc:
+  module Unit #:nodoc:
     class TestCase #:nodoc:
       include ClassInheritableAttributes
 
       cattr_accessor :fixture_path
-      cattr_accessor :fixture_table_names
+      class_inheritable_accessor :fixture_table_names
+      class_inheritable_accessor :use_transactional_fixtures
+      class_inheritable_accessor :use_instantiated_fixtures
+
+      self.fixture_table_names = []
+      self.use_transactional_fixtures = false
+      self.use_instantiated_fixtures = true
 
       def self.fixtures(*table_names)
-        require_fixture_classes(table_names)
-        write_inheritable_attribute("fixture_table_names", table_names)
+        self.fixture_table_names = table_names.flatten
+        require_fixture_classes
       end
 
-      def self.require_fixture_classes(table_names)
-        table_names.each do |table_name| 
+      def self.require_fixture_classes
+        fixture_table_names.each do |table_name| 
           begin
-            require(Inflector.singularize(table_name.to_s))
+            require Inflector.singularize(table_name.to_s)
           rescue LoadError
-            # Let's hope the developer is included it himself
+            # Let's hope the developer has included it himself
           end
         end
       end
 
-      def setup
-        instantiate_fixtures(*fixture_table_names) if fixture_table_names
+      def setup_with_fixtures
+        # Load fixtures once and begin transaction.
+        if use_transactional_fixtures
+          load_fixtures unless @already_loaded_fixtures
+          @already_loaded_fixtures = true
+          ActiveRecord::Base.lock_mutex
+          ActiveRecord::Base.connection.begin_db_transaction
+
+        # Load fixtures for every test.
+        else
+          load_fixtures
+        end
+
+        # Instantiate fixtures for every test if requested.
+        instantiate_fixtures if use_instantiated_fixtures
+      end
+
+      alias_method :setup, :setup_with_fixtures
+
+      def teardown_with_fixtures
+        # Rollback changes.
+        if use_transactional_fixtures
+          ActiveRecord::Base.connection.rollback_db_transaction
+          ActiveRecord::Base.unlock_mutex
+        end
       end
 
-      def self.method_added(method_symbol)
-        if method_symbol == :setup && !method_defined?(:setup_without_fixtures)
-          alias_method :setup_without_fixtures, :setup
-          define_method(:setup) do
-            instantiate_fixtures(*fixture_table_names) if fixture_table_names
-            setup_without_fixtures
+      alias_method :teardown, :teardown_with_fixtures
+
+      def self.method_added(method)
+        case method.to_s
+        when 'setup'
+          unless method_defined?(:setup_without_fixtures)
+            alias_method :setup_without_fixtures, :setup
+            define_method(:setup) do
+              setup_with_fixtures
+              setup_without_fixtures
+            end
+          end
+        when 'teardown'
+          unless method_defined?(:teardown_without_fixtures)
+            alias_method :teardown_without_fixtures, :teardown
+            define_method(:teardown) do
+              teardown_without_fixtures
+              teardown_with_fixtures
+            end
           end
         end
       end
 
       private
-        def instantiate_fixtures(*table_names)
-          Fixtures.instantiate_fixtures(self, fixture_path, *table_names)
+        def load_fixtures
+          @loaded_fixtures = {}
+          fixture_table_names.each do |table_name|
+            @loaded_fixtures[table_name] = Fixtures.create_fixtures(fixture_path, table_name)
+          end
         end
 
-        def fixture_table_names
-          self.class.read_inheritable_attribute("fixture_table_names")
+        def instantiate_fixtures
+          raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
+          @loaded_fixtures.each do |table_name, fixtures|
+            Fixtures.instantiate_fixtures(self, table_name, fixtures)
+          end
         end
     end
+
   end
 end

data/lib/active_record/migration.rb

@@ -0,0 +1,94 @@
+module ActiveRecord
+  class IrreversibleMigration < ActiveRecordError
+  end
+  
+  class Migration
+    class << self
+      def up() end
+      def down() end
+
+      private
+        def method_missing(method, *arguments, &block)
+          ActiveRecord::Base.connection.send(method, *arguments, &block)
+        end
+    end
+  end
+
+  class Migrator
+    class << self
+      def up(migrations_path, target_version = nil)
+        new(:up, migrations_path, target_version).migrate
+      end
+      
+      def down(migrations_path, target_version = nil)
+        new(:down, migrations_path, target_version).migrate
+      end
+      
+      def current_version
+        Base.connection.select_one("SELECT version FROM schema_info")["version"].to_i
+      end
+    end
+    
+    def initialize(direction, migrations_path, target_version = nil)
+      @direction, @migrations_path, @target_version = direction, migrations_path, target_version
+      Base.connection.initialize_schema_information
+    end
+
+    def current_version
+      self.class.current_version
+    end
+
+    def migrate
+      migration_classes do |version, migration_class|
+        Base.logger.info("Reached target version: #{@target_version}") and break if reached_target_version?(version)
+        next if irrelevant_migration?(version)
+
+        Base.logger.info "Migrating to #{migration_class} (#{version})"
+        migration_class.send(@direction)
+        set_schema_version(version)
+      end
+    end
+
+    private
+      def migration_classes
+        for migration_file in migration_files
+          load(migration_file)
+          version, name = migration_version_and_name(migration_file)
+          yield version, migration_class(name)
+        end
+      end
+    
+      def migration_files
+        files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
+        down? ? files.reverse : files
+      end
+      
+      def migration_class(migration_name)
+        migration_name.camelize.constantize
+      end
+    
+      def migration_version_and_name(migration_file)
+        return *migration_file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+      end
+      
+      def set_schema_version(version)
+        Base.connection.update("UPDATE schema_info SET version = #{down? ? version.to_i - 1 : version.to_i}")
+      end
+      
+      def up?
+        @direction == :up
+      end
+      
+      def down?
+        @direction == :down
+      end
+      
+      def reached_target_version?(version)
+        (up? && version.to_i - 1 == @target_version) || (down? && version.to_i == @target_version)
+      end
+      
+      def irrelevant_migration?(version)
+        (up? && version.to_i <= current_version) || (down? && version.to_i > current_version)
+      end
+  end
+end

data/lib/active_record/reflection.rb

@@ -10,7 +10,7 @@ module ActiveRecord
 
           def composed_of_with_reflection(part_id, options = {})
             composed_of_without_reflection(part_id, options)
-            write_inheritable_array "aggregations", [ AggregateReflection.new(part_id, options, self) ]
+            write_inheritable_array "aggregations", [ AggregateReflection.new(:composed_of, part_id, options, self) ]
           end
 
           alias_method :composed_of, :composed_of_with_reflection          
@@ -24,7 +24,7 @@ module ActiveRecord
 
             def #{association_type}_with_reflection(association_id, options = {})
               #{association_type}_without_reflection(association_id, options)
-              write_inheritable_array "associations", [ AssociationReflection.new(association_id, options, self) ]
+              write_inheritable_array "associations", [ AssociationReflection.new(:#{association_type}, association_id, options, self) ]
             end
 
             alias_method :#{association_type}, :#{association_type}_with_reflection          
@@ -67,8 +67,8 @@ module ActiveRecord
     # those classes. Objects of AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       attr_reader :active_record
-      def initialize(name, options, active_record)
-        @name, @options, @active_record = name, options, active_record
+      def initialize(macro, name, options, active_record)
+        @macro, @name, @options, @active_record = macro, name, options, active_record
       end
       
       # Returns the name of the macro, so it would return :balance for "composed_of :balance, :class_name => 'Money'" or
@@ -77,6 +77,12 @@ module ActiveRecord
         @name
       end
       
+      # Returns the name of the macro, so it would return :composed_of for 
+      # "composed_of :balance, :class_name => 'Money'" or :has_many for "has_many :clients".
+      def macro
+        @macro
+      end
+      
       # Returns the hash of options used for the macro, so it would return { :class_name => "Money" } for 
       # "composed_of :balance, :class_name => 'Money'" or {} for "has_many :clients".
       def options

data/lib/active_record/validations.rb

@@ -16,6 +16,7 @@ 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",
       }
       
     # Holds a hash with all the default error messages, such that they can be replaced by your own copy or localizations.
@@ -193,6 +194,20 @@ module ActiveRecord
     # They offer a more declarative way of specifying when the model is valid and when it is not. It is recommended to use
     # these over the low-level calls to validate and validate_on_create when possible.
     module ClassMethods
+      DEFAULT_VALIDATION_OPTIONS = {
+        :on => :save,
+        :allow_nil => false,
+        :message => nil
+      }.freeze
+
+      DEFAULT_SIZE_VALIDATION_OPTIONS = DEFAULT_VALIDATION_OPTIONS.merge(
+        :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]
+      ).freeze
+
+      ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
+
       def validate(*methods, &block)
         methods << block if block_given?
         write_inheritable_set(:validate, methods)
@@ -208,6 +223,31 @@ module ActiveRecord
         write_inheritable_set(:validate_on_update, methods)
       end
 
+      # Validates each attribute against a block.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_each :first_name, :last_name do |record, attr|
+      #       record.errors.add attr, 'starts with z.' if attr[0] == ?z
+      #     end
+      #   end
+      #
+      # Options:
+      # * <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.
+      def validates_each(*attrs)
+        options = attrs.last.is_a?(Hash) ? attrs.pop.symbolize_keys : {}
+        attrs = attrs.flatten
+
+        # Declare the validation.
+        send(validation_method(options[:on] || :save)) do |record|
+          attrs.each do |attr|
+            value = record.send(attr)
+            next if value.nil? && options[:allow_nil]
+            yield record, attr, value
+          end
+        end
+      end
+
       # Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
       #
       #   Model:
@@ -279,48 +319,6 @@ module ActiveRecord
         end
       end
 
-
-      DEFAULT_VALIDATION_OPTIONS = {
-        :on => :save,
-        :allow_nil => false,
-        :message => nil
-      }.freeze
-
-      DEFAULT_SIZE_VALIDATION_OPTIONS = DEFAULT_VALIDATION_OPTIONS.merge(
-        :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]
-      ).freeze
-
-      ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
-
-
-      # Validates each attribute against a block.
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_each :first_name, :last_name do |record, attr|
-      #       record.errors.add attr, 'starts with z.' if attr[0] == ?z
-      #     end
-      #   end
-      #
-      # Options:
-      # * <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.
-      def validates_each(*attrs)
-        options = attrs.last.is_a?(Hash) ? attrs.pop.symbolize_keys : {}
-        attrs = attrs.flatten
-
-        # Declare the validation.
-        send(validation_method(options[:on] || :save)) do |record|
-          attrs.each do |attr|
-            value = record.send(attr)
-            next if value.nil? && options[:allow_nil]
-            yield record, attr, value
-          end
-        end
-      end
-
-
       # Validates that the specified attribute matches the length restrictions supplied. Only one option can be used at a time:
       #
       #   class Person < ActiveRecord::Base
@@ -516,6 +514,42 @@ module ActiveRecord
         end
       end
       
+      # Validates whether the value of the specified attribute is numeric by trying to convert it to
+      # a float with Kernel.Float (if <tt>integer</tt> is false) or applying it to the regular expression
+      # <tt>/^[\+\-]?\d+$/</tt> (if <tt>integer</tt> is set to true).
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_numericality_of :value, :on => :create
+      #   end
+      #
+      # Configuration options:
+      # * <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)
+      def validates_numericality_of(*attr_names)
+        configuration = { :message => ActiveRecord::Errors.default_error_messages[:not_a_number], :on => :save,
+                           :integer => false }
+        configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+
+        for attr_name in attr_names
+          if configuration[:only_integer]
+            # we have to use a regexp here, because Kernel.Integer accepts nil and "0xdeadbeef", but does not
+            # accept "099" and String#to_i accepts everything. The string containing the regexp is evaluated twice
+            # so we have to escape everything properly
+            class_eval(%(#{validation_method(configuration[:on])} %{
+                errors.add("#{attr_name}", "#{configuration[:message]}") unless #{attr_name}_before_type_cast.to_s =~ /^[\\\\+\\\\-]?\\\\d+$/
+            }))          
+          else
+            class_eval(%(#{validation_method(configuration[:on])} %{
+                begin
+                  Kernel.Float(#{attr_name}_before_type_cast)
+                rescue ArgumentError, TypeError
+                  errors.add("#{attr_name}", "#{configuration[:message]}")
+                end
+            }))
+          end
+        end
+      end
 
       private
         def write_inheritable_set(key, methods)