activerecord 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/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/rails/generators/active_record.rb

@@ -0,0 +1,27 @@
+require 'rails/generators/named_base'
+require 'rails/generators/migration'
+require 'rails/generators/active_model'
+require 'active_record'
+
+module ActiveRecord
+  module Generators
+    class Base < Rails::Generators::NamedBase #:nodoc:
+      include Rails::Generators::Migration
+
+      # Set the current directory as base for the inherited generators.
+      def self.base_root
+        File.dirname(__FILE__)
+      end
+
+      # Implement the required interface for Rails::Generators::Migration.
+      def self.next_migration_number(dirname) #:nodoc:
+        next_migration_number = current_migration_number(dirname) + 1
+        if ActiveRecord::Base.timestamped_migrations
+          [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+        else
+          "%.3d" % next_migration_number
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,16 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %> do |t|
+<% for attribute in attributes -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+<% if options[:timestamps] %>
+      t.timestamps
+<% end -%>
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

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

@@ -0,0 +1,5 @@
+class <%= class_name %> < <%= parent_class_name.classify %>
+<% attributes.select {|attr| attr.reference? }.each do |attribute| -%>
+  belongs_to :<%= attribute.name %>
+<% end -%>
+end

data/lib/rails/generators/active_record/model/templates/module.rb

@@ -0,0 +1,5 @@
+module <%= class_path.map(&:camelize).join('::') %>
+  def self.table_name_prefix
+    '<%= class_path.join('_') %>_'
+  end
+end

data/lib/rails/generators/active_record/observer/observer_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class ObserverGenerator < Base
+      check_class_collision :suffix => "Observer"
+
+      def create_observer_file
+        template 'observer.rb', File.join('app/models', class_path, "#{file_name}_observer.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+class <%= class_name %>Observer < ActiveRecord::Observer
+end

data/lib/rails/generators/active_record/session_migration/session_migration_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class SessionMigrationGenerator < Base
+      argument :name, :type => :string, :default => "add_sessions_table"
+
+      def create_migration_file
+        migration_template "migration.rb", "db/migrate/#{file_name}.rb"
+      end
+
+      protected
+
+        def session_table_name
+          current_table_name = ActiveRecord::SessionStore::Session.table_name
+          if ["sessions", "session"].include?(current_table_name)
+            current_table_name = (ActiveRecord::Base.pluralize_table_names ? 'session'.pluralize : 'session')
+          end
+          current_table_name
+        end
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= session_table_name %> do |t|
+      t.string :session_id, :null => false
+      t.text :data
+      t.timestamps
+    end
+
+    add_index :<%= session_table_name %>, :session_id
+    add_index :<%= session_table_name %>, :updated_at
+  end
+
+  def self.down
+    drop_table :<%= session_table_name %>
+  end
+end

metadata

@@ -0,0 +1,224 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord
+version: !ruby/object:Gem::Version 
+  hash: 7
+  prerelease: false
+  segments: 
+  - 3
+  - 0
+  - 0
+  version: 3.0.0
+platform: ruby
+authors: 
+- David Heinemeier Hansson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-29 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: arel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: tzinfo
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 3
+        - 23
+        version: 0.3.23
+  type: :runtime
+  version_requirements: *id004
+description: Databases on Rails. Build a persistent domain model by mapping database tables to Ruby classes. Strong conventions for associations, validations, aggregations, migrations, and testing come baked-in.
+email: david@loudthinking.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- CHANGELOG
+- README.rdoc
+- examples/associations.png
+- examples/performance.rb
+- examples/simple.rb
+- lib/active_record/aggregations.rb
+- lib/active_record/association_preload.rb
+- lib/active_record/associations/association_collection.rb
+- lib/active_record/associations/association_proxy.rb
+- lib/active_record/associations/belongs_to_association.rb
+- lib/active_record/associations/belongs_to_polymorphic_association.rb
+- lib/active_record/associations/has_and_belongs_to_many_association.rb
+- lib/active_record/associations/has_many_association.rb
+- lib/active_record/associations/has_many_through_association.rb
+- lib/active_record/associations/has_one_association.rb
+- lib/active_record/associations/has_one_through_association.rb
+- lib/active_record/associations/through_association_scope.rb
+- lib/active_record/associations.rb
+- lib/active_record/attribute_methods/before_type_cast.rb
+- lib/active_record/attribute_methods/dirty.rb
+- lib/active_record/attribute_methods/primary_key.rb
+- lib/active_record/attribute_methods/query.rb
+- lib/active_record/attribute_methods/read.rb
+- lib/active_record/attribute_methods/time_zone_conversion.rb
+- lib/active_record/attribute_methods/write.rb
+- lib/active_record/attribute_methods.rb
+- lib/active_record/autosave_association.rb
+- lib/active_record/base.rb
+- lib/active_record/callbacks.rb
+- lib/active_record/connection_adapters/abstract/connection_pool.rb
+- lib/active_record/connection_adapters/abstract/connection_specification.rb
+- lib/active_record/connection_adapters/abstract/database_limits.rb
+- lib/active_record/connection_adapters/abstract/database_statements.rb
+- lib/active_record/connection_adapters/abstract/query_cache.rb
+- lib/active_record/connection_adapters/abstract/quoting.rb
+- lib/active_record/connection_adapters/abstract/schema_definitions.rb
+- lib/active_record/connection_adapters/abstract/schema_statements.rb
+- lib/active_record/connection_adapters/abstract_adapter.rb
+- lib/active_record/connection_adapters/mysql_adapter.rb
+- lib/active_record/connection_adapters/postgresql_adapter.rb
+- lib/active_record/connection_adapters/sqlite3_adapter.rb
+- lib/active_record/connection_adapters/sqlite_adapter.rb
+- lib/active_record/counter_cache.rb
+- lib/active_record/dynamic_finder_match.rb
+- lib/active_record/dynamic_scope_match.rb
+- lib/active_record/errors.rb
+- lib/active_record/fixtures.rb
+- lib/active_record/locale/en.yml
+- lib/active_record/locking/optimistic.rb
+- lib/active_record/locking/pessimistic.rb
+- lib/active_record/log_subscriber.rb
+- lib/active_record/migration.rb
+- lib/active_record/named_scope.rb
+- lib/active_record/nested_attributes.rb
+- lib/active_record/observer.rb
+- lib/active_record/persistence.rb
+- lib/active_record/query_cache.rb
+- lib/active_record/railtie.rb
+- lib/active_record/railties/controller_runtime.rb
+- lib/active_record/railties/databases.rake
+- lib/active_record/reflection.rb
+- lib/active_record/relation/batches.rb
+- lib/active_record/relation/calculations.rb
+- lib/active_record/relation/finder_methods.rb
+- lib/active_record/relation/predicate_builder.rb
+- lib/active_record/relation/query_methods.rb
+- lib/active_record/relation/spawn_methods.rb
+- lib/active_record/relation.rb
+- lib/active_record/schema.rb
+- lib/active_record/schema_dumper.rb
+- lib/active_record/serialization.rb
+- lib/active_record/serializers/xml_serializer.rb
+- lib/active_record/session_store.rb
+- lib/active_record/test_case.rb
+- lib/active_record/timestamp.rb
+- lib/active_record/transactions.rb
+- lib/active_record/validations/associated.rb
+- lib/active_record/validations/uniqueness.rb
+- lib/active_record/validations.rb
+- lib/active_record/version.rb
+- lib/active_record.rb
+- lib/rails/generators/active_record/migration/migration_generator.rb
+- lib/rails/generators/active_record/migration/templates/migration.rb
+- lib/rails/generators/active_record/model/model_generator.rb
+- lib/rails/generators/active_record/model/templates/migration.rb
+- lib/rails/generators/active_record/model/templates/model.rb
+- lib/rails/generators/active_record/model/templates/module.rb
+- lib/rails/generators/active_record/observer/observer_generator.rb
+- lib/rails/generators/active_record/observer/templates/observer.rb
+- lib/rails/generators/active_record/session_migration/session_migration_generator.rb
+- lib/rails/generators/active_record/session_migration/templates/migration.rb
+- lib/rails/generators/active_record.rb
+has_rdoc: true
+homepage: http://www.rubyonrails.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: activerecord
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Object-relational mapper framework (part of Rails).
+test_files: []
+