sskirby-activerecord 3.2.1

data/lib/active_record/translation.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Translation
+    include ActiveModel::Translation
+
+    # Set the lookup ancestors for ActiveModel.
+    def lookup_ancestors #:nodoc:
+      klass = self
+      classes = [klass]
+      return classes if klass == ActiveRecord::Base
+
+      while klass != klass.base_class
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope #:nodoc:
+      :activerecord
+    end
+  end
+end

data/lib/active_record/validations.rb

@@ -0,0 +1,83 @@
+module ActiveRecord
+  # = Active Record RecordInvalid
+  #
+  # 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.
+  #
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue ActiveRecord::RecordInvalid => invalid
+  #     puts invalid.record.errors
+  #   end
+  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
+
+  # = Active Record Validations
+  #
+  # Active Record includes the majority of its validations from <tt>ActiveModel::Validations</tt>
+  # all of which accept the <tt>:on</tt> argument to define the context where the
+  # validations are active. Active Record will always supply either the context of
+  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # <tt>new_record?</tt>.
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    module ClassMethods
+      # Creates an object just like Base.create but calls <tt>save!</tt> instead of +save+
+      # so an exception is raised if the record is invalid.
+      def create!(attributes = nil, options = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, options, &block) }
+        else
+          object = new(attributes, options)
+          yield(object) if block_given?
+          object.save!
+          object
+        end
+      end
+    end
+
+    # The validation process on save can be skipped by passing <tt>:validate => false</tt>. The regular Base#save method is
+    # replaced with this when the validations module is mixed in, which it is by default.
+    def save(options={})
+      perform_validations(options) ? super : false
+    end
+
+    # 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
+
+    # Runs all the validations within the specified context. Returns true if no errors are found,
+    # false otherwise.
+    #
+    # If the argument is false (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is true, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    end
+
+  protected
+
+    def perform_validations(options={})
+      perform_validation = options[:validate] != false
+      perform_validation ? valid?(options[:context]) : true
+    end
+  end
+end
+
+require "active_record/validations/associated"
+require "active_record/validations/uniqueness"

data/lib/active_record/validations/associated.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module Validations
+    class AssociatedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if Array.wrap(value).reject {|r| r.marked_for_destruction? || r.valid?}.any?
+          record.errors.add(attribute, :invalid, options.merge(:value => value))
+        end
+      end
+    end
+
+    module ClassMethods
+      # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
+      #
+      #   class Book < ActiveRecord::Base
+      #     has_many :pages
+      #     belongs_to :library
+      #
+      #     validates_associated :pages, :library
+      #   end
+      #
+      # WARNING: This validation must not be used on both ends of an association. Doing so will lead to a circular dependency and cause infinite recursion.
+      #
+      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to
+      # ensure that the association is both present and guaranteed to be valid, you also need to
+      # use +validates_presence_of+.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid")
+      # * <tt>:on</tt> - Specifies when this validation is active. Runs in all
+      #   validation contexts by default (+nil+), other options are <tt>:create</tt>
+      #   and <tt>:update</tt>.
+      # * <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.
+      def validates_associated(*attr_names)
+        validates_with AssociatedValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_record/validations/uniqueness.rb

@@ -0,0 +1,180 @@
+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.arel_table
+
+        coder = record.class.serialized_attributes[attribute.to_s]
+
+        if value && coder
+          value = coder.dump value
+        end
+
+        relation = build_relation(finder_class, table, attribute, value)
+        relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.send(:id))) if record.persisted?
+
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.and(table[scope_item].eq(scope_value))
+        end
+
+        if finder_class.unscoped.where(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 build_relation(klass, table, attribute, value) #:nodoc:
+        column = klass.columns_hash[attribute.to_s]
+        value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
+
+        if !options[:case_sensitive] && value && column.text?
+          # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+          relation = klass.connection.case_insensitive_comparison(table, attribute, column, value)
+        else
+          value    = klass.connection.case_sensitive_modifier(value)
+          relation = table[attribute].eq(value)
+        end
+
+        relation
+      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
+      #   end
+      #
+      # It can also validate whether the value of the specified attributes are unique based on a scope parameter:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_uniqueness_of :user_name, :scope => :account_id
+      #   end 
+      #
+      # Or even 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. The best way to work around this problem is to add a unique
+      # index to the database table 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
+      #
+      # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
+      # constraint errors from other types of database errors by throwing an
+      # ActiveRecord::RecordNotUnique exception.
+      # For other adapters you will have to parse the (database-specific) exception
+      # message to detect such a case.
+      # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
+      # * ActiveRecord::ConnectionAdapters::MysqlAdapter
+      # * ActiveRecord::ConnectionAdapters::Mysql2Adapter
+      # * ActiveRecord::ConnectionAdapters::SQLiteAdapter
+      # * ActiveRecord::ConnectionAdapters::SQLite3Adapter
+      # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      #
+      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,10 @@
+module ActiveRecord
+  module VERSION #:nodoc:
+    MAJOR = 3
+    MINOR = 2
+    TINY  = 1
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/lib/rails/generators/active_record.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/named_base'
+require 'rails/generators/migration'
+require 'rails/generators/active_model'
+require 'rails/generators/active_record/migration'
+require 'active_record'
+
+module ActiveRecord
+  module Generators
+    class Base < Rails::Generators::NamedBase #:nodoc:
+      include Rails::Generators::Migration
+      extend ActiveRecord::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
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Generators
+    module Migration
+      # Implement the required interface for Rails::Generators::Migration.
+      def 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][:index] field[:type][:index]"
+
+      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,31 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+<%- if migration_action == 'add' -%>
+  def change
+<% attributes.each do |attribute| -%>
+    add_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %><%= attribute.inject_options %>
+    <%- if attribute.has_index? -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+    <%- end %>
+<%- end -%>
+  end
+<%- else -%>
+  def up
+<% attributes.each do |attribute| -%>
+  <%- if migration_action -%>
+    <%= migration_action %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type %><%= attribute.inject_options %><% end %>
+    <% if attribute.has_index? && migration_action == 'add' %>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+    <% end -%>
+  <%- end -%>
+<%- end -%>
+  end
+
+  def 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 %><%= attribute.inject_options %><% end %>
+  <%- end -%>
+<%- end -%>
+  end
+<%- end -%>
+end