activerecord 1.0.0 → 3.0.0

data/lib/active_record/validations/uniqueness.rb

@@ -0,0 +1,185 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord
+  module Validations
+    class UniquenessValidator < ActiveModel::EachValidator
+      def initialize(options)
+        super(options.reverse_merge(:case_sensitive => true))
+      end
+
+      # Unfortunately, we have to tie Uniqueness validators to a class.
+      def setup(klass)
+        @klass = klass
+      end
+
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        table = finder_class.unscoped
+
+        table_name   = record.class.quoted_table_name
+        sql, params  = mount_sql_and_params(finder_class, table_name, attribute, value)
+
+        relation = table.where(sql, *params)
+
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.where(scope_item => scope_value)
+        end
+
+        unless record.new_record?
+          # TODO : This should be in Arel
+          relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
+        end
+
+        if relation.exists?
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+        end
+      end
+
+    protected
+
+      # The check for an existing value should be run from a class that
+      # isn't abstract. This means working down from the current class
+      # (self), to the first non-abstract class. Since classes don't know
+      # their subclasses, we have to build the hierarchy between self and
+      # the record's class.
+      def find_finder_class_for(record) #:nodoc:
+        class_hierarchy = [record.class]
+
+        while class_hierarchy.first != @klass
+          class_hierarchy.insert(0, class_hierarchy.first.superclass)
+        end
+
+        class_hierarchy.detect { |klass| !klass.abstract_class? }
+      end
+
+      def mount_sql_and_params(klass, table_name, attribute, value) #:nodoc:
+        column = klass.columns_hash[attribute.to_s]
+
+        operator = if value.nil?
+          "IS ?"
+        elsif column.text?
+          value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
+          "#{klass.connection.case_sensitive_equality_operator} ?"
+        else
+          "= ?"
+        end
+
+        sql_attribute = "#{table_name}.#{klass.connection.quote_column_name(attribute)}"
+
+        if value.nil? || (options[:case_sensitive] || !column.text?)
+          sql = "#{sql_attribute} #{operator}"
+        else
+          sql = "LOWER(#{sql_attribute}) = LOWER(?)"
+        end
+
+        [sql, [value]]
+      end
+    end
+
+    module ClassMethods
+      # Validates whether the value of the specified attributes are unique across the system.
+      # Useful for making sure that only one user
+      # can be named "davidhh".
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_uniqueness_of :user_name, :scope => :account_id
+      #   end
+      #
+      # It can also validate whether the value of the specified attributes are unique based on multiple
+      # scope parameters.  For example, making sure that a teacher can only be on the schedule once
+      # per semester for a particular class.
+      #
+      #   class TeacherSchedule < ActiveRecord::Base
+      #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
+      #   end
+      #
+      # When the record is created, a check is performed to make sure that no record exists in the database
+      # with the given value for the specified attribute (that maps to a column). When the record is updated,
+      # the same check is made but disregarding the record itself.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken").
+      # * <tt>:scope</tt> - One or more columns by which to limit the scope of the uniqueness constraint.
+      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by non-text columns (+true+ by default).
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).
+      #   The method, proc or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
+      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The method, proc or string should
+      #   return or evaluate to a true or false value.
+      #
+      # === Concurrency and integrity
+      #
+      # Using this validation method in conjunction with ActiveRecord::Base#save
+      # does not guarantee the absence of duplicate record insertions, because
+      # uniqueness checks on the application level are inherently prone to race
+      # conditions. For example, suppose that two users try to post a Comment at
+      # the same time, and a Comment's title must be unique. At the database-level,
+      # the actions performed by these users could be interleaved in the following manner:
+      #
+      #               User 1                 |               User 2
+      #  ------------------------------------+--------------------------------------
+      #  # User 1 checks whether there's     |
+      #  # already a comment with the title  |
+      #  # 'My Post'. This is not the case.  |
+      #  SELECT * FROM comments              |
+      #  WHERE title = 'My Post'             |
+      #                                      |
+      #                                      | # User 2 does the same thing and also
+      #                                      | # infers that his title is unique.
+      #                                      | SELECT * FROM comments
+      #                                      | WHERE title = 'My Post'
+      #                                      |
+      #  # User 1 inserts his comment.       |
+      #  INSERT INTO comments                |
+      #  (title, content) VALUES             |
+      #  ('My Post', 'hi!')                  |
+      #                                      |
+      #                                      | # User 2 does the same thing.
+      #                                      | INSERT INTO comments
+      #                                      | (title, content) VALUES
+      #                                      | ('My Post', 'hello!')
+      #                                      |
+      #                                      | # ^^^^^^
+      #                                      | # Boom! We now have a duplicate
+      #                                      | # title!
+      #
+      # This could even happen if you use transactions with the 'serializable'
+      # isolation level. There are several ways to get around this problem:
+      #
+      # - By locking the database table before validating, and unlocking it after
+      #   saving. However, table locking is very expensive, and thus not
+      #   recommended.
+      # - By locking a lock file before validating, and unlocking it after saving.
+      #   This does not work if you've scaled your Rails application across
+      #   multiple web servers (because they cannot share lock files, or cannot
+      #   do that efficiently), and thus not recommended.
+      # - Creating a unique index on the field, by using
+      #   ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
+      #   rare case that a race condition occurs, the database will guarantee
+      #   the field's uniqueness.
+      #
+      #   When the database catches such a duplicate insertion,
+      #   ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
+      #   exception. You can either choose to let this error propagate (which
+      #   will result in the default Rails exception page being shown), or you
+      #   can catch it and restart the transaction (e.g. by telling the user
+      #   that the title already exists, and asking him to re-enter the title).
+      #   This technique is also known as optimistic concurrency control:
+      #   http://en.wikipedia.org/wiki/Optimistic_concurrency_control
+      #
+      #   Active Record currently provides no way to distinguish unique
+      #   index constraint errors from other types of database errors, so you
+      #   will have to parse the (database-specific) exception message to detect
+      #   such a case.
+      #
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_record/validations.rb

@@ -1,205 +1,84 @@
 module ActiveRecord
-  # Active Records implement validation by overwriting Base#validate (or the variations, +validate_on_create+ and 
-  # +validate_on_update+). Each of these methods can inspect the state of the object, which usually means ensuring
-  # that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
+  # = Active Record Validations
   #
-  # Example:
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid.  Use the
+  # +record+ method to retrieve the record which did not validate.
   #
-  #   class Person < ActiveRecord::Base
-  #     protected
-  #       def validate
-  #         errors.add_on_empty %w( first_name last_name )
-  #         errors.add("phone_number", "has invalid format") unless phone_number =~ /[0-9]*/
-  #       end
-  #
-  #       def validate_on_create # is only run the first time a new object is saved
-  #         unless valid_discount?(membership_discount)
-  #           errors.add("membership_discount", "has expired")
-  #         end
-  #       end
-  #
-  #       def validate_on_update
-  #         errors.add_to_base("No changes have occured") if unchanged_attributes?
-  #       end
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue ActiveRecord::RecordInvalid => invalid
+  #     puts invalid.record.errors
   #   end
-  #
-  #   person = Person.new("first_name" => "David", "phone_number" => "what?")
-  #   person.save                         # => false (and doesn't do the save)
-  #   person.errors.empty?                # => false
-  #   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" +
-  #                                            "Phone number has invalid format"
-  #
-  #   person.attributes = { "last_name" => "Heinemeier", "phone_number" => "555-555" }
-  #   person.save # => true (and person is now saved in the database)
-  #
-  # An +Errors+ object is automatically created for every Active Record.
-  module Validations
-    def self.append_features(base) # :nodoc:
-      super
-
-      base.class_eval do
-        alias_method :save_without_validation, :save
-        alias_method :save, :save_with_validation
+  class RecordInvalid < ActiveRecordError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      super(I18n.t("activerecord.errors.messages.record_invalid", :errors => errors))
+    end
+  end
 
-        alias_method :update_attribute_without_validation_skipping, :update_attribute
-        alias_method :update_attribute, :update_attribute_with_validation_skipping
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    module ClassMethods
+      # Creates an object just like Base.create but calls save! instead of save
+      # so an exception is raised if the record is invalid.
+      def create!(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, &block) }
+        else
+          object = new(attributes)
+          yield(object) if block_given?
+          object.save!
+          object
+        end
       end
     end
 
     # 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
+    def save(options={})
+      perform_validations(options) ? super : false
     end
 
-    # Updates a single attribute and saves the record without going through the normal validation procedure.
-    # 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)
-      @attributes[name] = value
-      save(false)
-    end
-
-    # Runs validate and validate_on_create or validate_on_update and returns true if no errors were added otherwise false.
-    def valid?
-      errors.clear
-      validate
-      if new_record? then validate_on_create else validate_on_update end
-      errors.empty?
-    end
-
-    # Returns the Errors object that holds all information about attribute error messages.
-    def errors
-      @errors = Errors.new(self) if @errors.nil?
-      @errors
-    end
-
-    protected
-      # Overwrite this method for validation checks on all saves and use Errors.add(field, msg) for invalid attributes.
-      def validate #:doc:
-      end 
-
-      # Overwrite this method for validation checks used only on creation.
-      def validate_on_create #:doc:
-      end
-
-      # Overwrite this method for validation checks used only on updates.
-      def validate_on_update # :doc:
-      end
-  end
-
-  # Active Record validation is reported to and from this object, which is used by Base#save to
-  # determine whether the object in a valid state to be saved. See usage example in Validations.
-  class Errors
-    def initialize(base) # :nodoc:
-      @base, @errors = base, {}
-    end
-    
-    # Adds an error to the base object instead of any particular attribute. This is used
-    # to report errors that doesn't tie to any specific attribute, but rather to the object
-    # as a whole. These error messages doesn't get prepended with any field name when iterating
-    # with each_full, so they should be complete sentences.
-    def add_to_base(msg)
-      add(:base, msg)
+    # Attempts to save the record just like Base#save but will raise a RecordInvalid exception instead of returning false
+    # if the record is not valid.
+    def save!(options={})
+      perform_validations(options) ? super : raise(RecordInvalid.new(self))
     end
 
-    # Adds an error message (+msg+) to the +attribute+, which will be returned on a call to <tt>on(attribute)</tt>
-    # for the same attribute and ensure that this error object returns false when asked if +empty?+. More than one
-    # error can be added to the same +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
-    # If no +msg+ is supplied, "invalid" is assumed.
-    def add(attribute, msg = "invalid")
-      @errors[attribute] = [] if @errors[attribute].nil?
-      @errors[attribute] << msg
-    end
+    # Runs all the specified validations and returns true if no errors were added otherwise false.
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
 
-    # Will add an error message to each of the attributes in +attributes+ that is empty (defined by <tt>attribute_present?</tt>).
-    def add_on_empty(attributes, msg = "can't be empty")
-      [attributes].flatten.each { |attr| add(attr, msg) unless @base.attribute_present?(attr) }
-    end
+      deprecated_callback_method(:validate)
+      deprecated_callback_method(:"validate_on_#{context}")
 
-    # Will add an error message to each of the attributes in +attributes+ that has a length outside of the passed boundary +range+. 
-    # If the length is above the boundary, the too_long_msg message will be used. If below, the too_short_msg.
-    def add_on_boundary_breaking(attributes, range, too_long_msg = "is too long (max is %d characters)", too_short_msg = "is too short (min is %d characters)")
-      for attr in [attributes].flatten
-        add(attr, too_short_msg % range.begin) if @base.attribute_present?(attr) && @base.send(attr).length < range.begin
-        add(attr, too_long_msg % range.end) if @base.attribute_present?(attr) && @base.send(attr).length > range.end
-      end
+      errors.empty? && output
     end
 
-    alias :add_on_boundry_breaking :add_on_boundary_breaking
+  protected
 
-    # Returns true if the specified +attribute+ has errors associated with it.
-    def invalid?(attribute)
-      !@errors[attribute].nil?
-    end
-
-    # * Returns nil, if no errors are associated with the specified +attribute+.
-    # * Returns the error message, if one error is associated with the specified +attribute+.
-    # * Returns an array of error messages, if more than one error is associated with the specified +attribute+.
-    def on(attribute)
-      if @errors[attribute].nil?
-        nil
-      elsif @errors[attribute].length == 1
-        @errors[attribute].first
+    def perform_validations(options={})
+      perform_validation = case options
+      when Hash
+        options[:validate] != false
       else
-        @errors[attribute]
+        ActiveSupport::Deprecation.warn "save(#{options}) is deprecated, please give save(:validate => #{options}) instead", caller
+        options
       end
-    end
 
-    alias :[] :on
-
-    # Returns errors assigned to base object through add_to_base according to the normal rules of on(attribute).
-    def on_base
-      on(:base)
-    end
-    
-    # Yields each attribute and associated message per error added.
-    def each
-      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
-    end
-    
-    # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
-    # through iteration as "First name can't be empty".
-    def each_full
-      full_messages.each { |msg| yield msg }
-    end
-
-    # Returns all the full error messages in an array.
-    def full_messages
-      full_messages = []
-      
-      @errors.each_key do |attr| 
-        @errors[attr].each do |msg|
-          if attr == :base
-            full_messages << msg
-          else
-            full_messages << @base.class.human_attribute_name(attr) + " " + msg
-          end
-        end
+      if perform_validation
+        valid?(options.is_a?(Hash) ? options[:context] : nil)
+      else
+        true
       end
-      
-      return full_messages
-    end
-
-    # Returns true if no errors have been added.
-    def empty?
-      return @errors.empty?
-    end
-    
-    # Removes all the errors that have been added.
-    def clear
-      @errors = {}
-    end
-    
-    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such
-    # with this as well.
-    def count
-      error_count = 0
-      @errors.each_value { |attribute| error_count += attribute.length }
-      error_count
     end
   end
 end
+
+require "active_record/validations/associated"
+require "active_record/validations/uniqueness"

data/lib/active_record/version.rb

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

data/lib/active_record.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004 David Heinemeier Hansson
+# Copyright (c) 2004-2010 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,28 +21,104 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-$:.unshift(File.dirname(__FILE__))
-
-require 'active_record/support/clean_logger'
-
-require 'active_record/base'
-require 'active_record/observer'
-require 'active_record/validations'
-require 'active_record/callbacks'
-require 'active_record/associations'
-require 'active_record/aggregations'
-require 'active_record/transactions'
-require 'active_record/reflection'
-
-ActiveRecord::Base.class_eval do
-  include ActiveRecord::Validations
-  include ActiveRecord::Callbacks
-  include ActiveRecord::Associations
-  include ActiveRecord::Aggregations
-  include ActiveRecord::Transactions
-  include ActiveRecord::Reflection
+
+activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
+$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
+
+activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
+$:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
+
+require 'active_support'
+require 'active_support/i18n'
+require 'active_model'
+require 'arel'
+
+module ActiveRecord
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :VERSION
+
+    autoload :ActiveRecordError, 'active_record/errors'
+    autoload :ConnectionNotEstablished, 'active_record/errors'
+
+    autoload :Aggregations
+    autoload :AssociationPreload
+    autoload :Associations
+    autoload :AttributeMethods
+    autoload :AutosaveAssociation
+
+    autoload :Relation
+
+    autoload_under 'relation' do
+      autoload :QueryMethods
+      autoload :FinderMethods
+      autoload :Calculations
+      autoload :PredicateBuilder
+      autoload :SpawnMethods
+      autoload :Batches
+    end
+
+    autoload :Base
+    autoload :Callbacks
+    autoload :CounterCache
+    autoload :DynamicFinderMatch
+    autoload :DynamicScopeMatch
+    autoload :Migration
+    autoload :Migrator, 'active_record/migration'
+    autoload :NamedScope
+    autoload :NestedAttributes
+    autoload :Observer
+    autoload :Persistence
+    autoload :QueryCache
+    autoload :Reflection
+    autoload :Schema
+    autoload :SchemaDumper
+    autoload :Serialization
+    autoload :SessionStore
+    autoload :Timestamp
+    autoload :Transactions
+    autoload :Validations
+  end
+
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BeforeTypeCast
+      autoload :Dirty
+      autoload :PrimaryKey
+      autoload :Query
+      autoload :Read
+      autoload :TimeZoneConversion
+      autoload :Write
+    end
+  end
+
+  module Locking
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Optimistic
+      autoload :Pessimistic
+    end
+  end
+
+  module ConnectionAdapters
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :AbstractAdapter
+      autoload :ConnectionManagement, "active_record/connection_adapters/abstract/connection_pool"
+    end
+  end
+
+  autoload :TestCase
+  autoload :TestFixtures, 'active_record/fixtures'
+end
+
+ActiveSupport.on_load(:active_record) do
+  Arel::Table.engine = Arel::Sql::Engine.new(self)
 end
 
-require 'active_record/connection_adapters/mysql_adapter'
-require 'active_record/connection_adapters/postgresql_adapter'
-require 'active_record/connection_adapters/sqlite_adapter'
+I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'

data/lib/rails/generators/active_record/migration/migration_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class MigrationGenerator < Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      def create_migration_file
+        set_local_assigns!
+        migration_template "migration.rb", "db/migrate/#{file_name}.rb"
+      end
+
+      protected
+        attr_reader :migration_action
+
+        def set_local_assigns!
+          if file_name =~ /^(add|remove)_.*_(?:to|from)_(.*)/
+            @migration_action = $1
+            @table_name       = $2.pluralize
+          end
+        end
+
+    end
+  end
+end

data/lib/rails/generators/active_record/migration/templates/migration.rb

@@ -0,0 +1,17 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+<% attributes.each do |attribute| -%>
+  <%- if migration_action -%>
+    <%= migration_action %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type %><% end %>
+  <%- end -%>
+<%- end -%>
+  end
+
+  def self.down
+<% attributes.reverse.each do |attribute| -%>
+  <%- if migration_action -%>
+    <%= migration_action == 'add' ? 'remove' : 'add' %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'remove' %>, :<%= attribute.type %><% end %>
+  <%- end -%>
+<%- end -%>
+  end
+end

data/lib/rails/generators/active_record/model/model_generator.rb

@@ -0,0 +1,38 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class ModelGenerator < Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      check_class_collision
+
+      class_option :migration,  :type => :boolean
+      class_option :timestamps, :type => :boolean
+      class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
+
+      def create_migration_file
+        return unless options[:migration] && options[:parent].nil?
+        migration_template "migration.rb", "db/migrate/create_#{table_name}.rb"
+      end
+
+      def create_model_file
+        template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+      end
+
+      def create_module_file
+        return if class_path.empty?
+        template 'module.rb', File.join('app/models', "#{class_path.join('/')}.rb") if behavior == :invoke
+      end
+
+      hook_for :test_framework
+
+      protected
+
+        def parent_class_name
+          options[:parent] || "ActiveRecord::Base"
+        end
+
+    end
+  end
+end