activerecord 4.2.0

data/lib/active_record/gem_version.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  # Returns the version of the currently loaded Active Record as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 4
+    MINOR = 2
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_record/inheritance.rb

@@ -0,0 +1,247 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActiveRecord
+  # == Single table inheritance
+  #
+  # Active Record allows inheritance by storing the name of the class in a column that by
+  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
+  # This means that an inheritance looking like this:
+  #
+  #   class Company < ActiveRecord::Base; end
+  #   class Firm < Company; end
+  #   class Client < Company; end
+  #   class PriorityClient < Client; end
+  #
+  # When you do <tt>Firm.create(name: "37signals")</tt>, this record will be saved in
+  # the companies table with type = "Firm". You can then fetch this row again using
+  # <tt>Company.where(name: '37signals').first</tt> and it will return a Firm object.
+  #
+  # Be aware that because the type column is an attribute on the record every new
+  # subclass will instantly be marked as dirty and the type column will be included
+  # in the list of changed attributes on the record. This is different from non
+  # STI classes:
+  #
+  #   Company.new.changed? # => false
+  #   Firm.new.changed?    # => true
+  #   Firm.new.changes     # => {"type"=>["","Firm"]}
+  #
+  # If you don't have a type column defined in your table, single-table inheritance won't
+  # be triggered. In that case, it'll work just like normal subclasses with no special magic
+  # for differentiating between them or reloading the right type with find.
+  #
+  # Note, all the attributes for all the cases are kept in the same table. Read more:
+  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  #
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    included do
+      # Determines whether to store the full constant name including namespace when using STI.
+      class_attribute :store_full_sti_class, instance_writer: false
+      self.store_full_sti_class = true
+    end
+
+    module ClassMethods
+      # Determines if one of the attributes passed in is the inheritance column,
+      # and if the inheritance column is attr accessible, it initializes an
+      # instance of the given subclass instead of the base class.
+      def new(*args, &block)
+        if abstract_class? || self == Base
+          raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
+        end
+
+        attrs = args.first
+        if subclass_from_attributes?(attrs)
+          subclass = subclass_from_attributes(attrs)
+        end
+
+        if subclass
+          subclass.new(*args, &block)
+        else
+          super
+        end
+      end
+
+      # Returns +true+ if this does not need STI type condition. Returns
+      # +false+ if STI type condition needs to be applied.
+      def descends_from_active_record?
+        if self == Base
+          false
+        elsif superclass.abstract_class?
+          superclass.descends_from_active_record?
+        else
+          superclass == Base || !columns_hash.include?(inheritance_column)
+        end
+      end
+
+      def finder_needs_type_condition? #:nodoc:
+        # This is like this because benchmarking justifies the strange :false stuff
+        :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
+      end
+
+      def symbolized_base_class
+        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_base_class` is deprecated and will be removed without replacement.')
+        @symbolized_base_class ||= base_class.to_s.to_sym
+      end
+
+      def symbolized_sti_name
+        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_sti_name` is deprecated and will be removed without replacement.')
+        @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
+      end
+
+      # Returns the class descending directly from ActiveRecord::Base, or
+      # an abstract class, if any, in the inheritance hierarchy.
+      #
+      # If A extends AR::Base, A.base_class will return A. If B descends from A
+      # through some arbitrarily deep hierarchy, B.base_class will return A.
+      #
+      # If B < A and C < B and if A is an abstract_class then both B.base_class
+      # and C.base_class would return B as the answer since A is an abstract_class.
+      def base_class
+        unless self < Base
+          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+        end
+
+        if superclass == Base || superclass.abstract_class?
+          self
+        else
+          superclass.base_class
+        end
+      end
+
+      # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
+      # If you are using inheritance with ActiveRecord and don't want child classes
+      # to utilize the implied STI table name of the parent class, this will need to be true.
+      # For example, given the following:
+      #
+      #   class SuperClass < ActiveRecord::Base
+      #     self.abstract_class = true
+      #   end
+      #   class Child < SuperClass
+      #     self.table_name = 'the_table_i_really_want'
+      #   end
+      #
+      #
+      # <tt>self.abstract_class = true</tt> is required to make <tt>Child<.find,.create, or any Arel method></tt> use <tt>the_table_i_really_want</tt> instead of a table called <tt>super_classes</tt>
+      #
+      attr_accessor :abstract_class
+
+      # Returns whether this class is an abstract class or not.
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def sti_name
+        store_full_sti_class ? name : name.demodulize
+      end
+
+      protected
+
+      # Returns the class type of the record using the current module as a prefix. So descendants of
+      # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
+      def compute_type(type_name)
+        if type_name.match(/^::/)
+          # If the type is prefixed with a scope operator then we assume that
+          # the type_name is an absolute reference.
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          # Build a list of candidates to search for
+          candidates = []
+          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+          candidates << type_name
+
+          candidates.each do |candidate|
+            constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+            return constant if candidate == constant.to_s
+          end
+
+          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+        end
+      end
+
+      private
+
+      # Called by +instantiate+ to decide which class to use for a new
+      # record instance. For single-table inheritance, we check the record
+      # for a +type+ column and return the corresponding class.
+      def discriminate_class_for_record(record)
+        if using_single_table_inheritance?(record)
+          find_sti_class(record[inheritance_column])
+        else
+          super
+        end
+      end
+
+      def using_single_table_inheritance?(record)
+        record[inheritance_column].present? && columns_hash.include?(inheritance_column)
+      end
+
+      def find_sti_class(type_name)
+        if store_full_sti_class
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          compute_type(type_name)
+        end
+      rescue NameError
+        raise SubclassNotFound,
+          "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
+          "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
+          "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+          "or overwrite #{name}.inheritance_column to use another column for that information."
+      end
+
+      def type_condition(table = arel_table)
+        sti_column = table[inheritance_column]
+        sti_names  = ([self] + descendants).map { |model| model.sti_name }
+
+        sti_column.in(sti_names)
+      end
+
+      # Detect the subclass from the inheritance column of attrs. If the inheritance column value
+      # is not self or a valid subclass, raises ActiveRecord::SubclassNotFound
+      # If this is a StrongParameters hash, and access to inheritance_column is not permitted,
+      # this will ignore the inheritance column and return nil
+      def subclass_from_attributes?(attrs)
+        columns_hash.include?(inheritance_column) && attrs.is_a?(Hash)
+      end
+
+      def subclass_from_attributes(attrs)
+        subclass_name = attrs.with_indifferent_access[inheritance_column]
+
+        if subclass_name.present? && subclass_name != self.name
+          subclass = subclass_name.safe_constantize
+
+          unless descendants.include?(subclass)
+            raise ActiveRecord::SubclassNotFound.new("Invalid single-table inheritance type: #{subclass_name} is not a subclass of #{name}")
+          end
+
+          subclass
+        end
+      end
+    end
+
+    def initialize_dup(other)
+      super
+      ensure_proper_type
+    end
+
+    private
+
+    def initialize_internals_callback
+      super
+      ensure_proper_type
+    end
+
+    # Sets the attribute used for single table inheritance to this class name if this is not the
+    # ActiveRecord::Base descendant.
+    # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to
+    # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
+    # No such attribute would be set for objects of the Message class in that example.
+    def ensure_proper_type
+      klass = self.class
+      if klass.finder_needs_type_condition?
+        write_attribute(klass.inheritance_column, klass.sti_name)
+      end
+    end
+  end
+end

data/lib/active_record/integration.rb

@@ -0,0 +1,113 @@
+require 'active_support/core_ext/string/filters'
+
+module ActiveRecord
+  module Integration
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # :singleton-method:
+      # Indicates the format used to generate the timestamp in the cache key.
+      # Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      #
+      # This is +:nsec+, by default.
+      class_attribute :cache_timestamp_format, :instance_writer => false
+      self.cache_timestamp_format = :nsec
+    end
+
+    # Returns a String, which Action Pack uses for constructing an URL to this
+    # object. The default implementation returns this record's id as a String,
+    # or nil if this record's unsaved.
+    #
+    # For example, suppose that you have a User model, and that you have a
+    # <tt>resources :users</tt> route. Normally, +user_path+ will
+    # construct a path with the user object's 'id' in it:
+    #
+    #   user = User.find_by(name: 'Phusion')
+    #   user_path(user)  # => "/users/1"
+    #
+    # You can override +to_param+ in your model to make +user_path+ construct
+    # a path using the user's name instead of the user's id:
+    #
+    #   class User < ActiveRecord::Base
+    #     def to_param  # overridden
+    #       name
+    #     end
+    #   end
+    #
+    #   user = User.find_by(name: 'Phusion')
+    #   user_path(user)  # => "/users/Phusion"
+    def to_param
+      # We can't use alias_method here, because method 'id' optimizes itself on the fly.
+      id && id.to_s # Be sure to stringify the id for routes
+    end
+
+    # Returns a cache key that can be used to identify this record.
+    #
+    #   Product.new.cache_key     # => "products/new"
+    #   Product.find(5).cache_key # => "products/5" (updated_at not available)
+    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
+    #
+    # You can also pass a list of named timestamps, and the newest in the list will be
+    # used to generate the key:
+    #
+    #   Person.find(5).cache_key(:updated_at, :last_reviewed_at)
+    def cache_key(*timestamp_names)
+      case
+      when new_record?
+        "#{model_name.cache_key}/new"
+      when timestamp_names.any?
+        timestamp = max_updated_column_timestamp(timestamp_names)
+        timestamp = timestamp.utc.to_s(cache_timestamp_format)
+        "#{model_name.cache_key}/#{id}-#{timestamp}"
+      when timestamp = max_updated_column_timestamp
+        timestamp = timestamp.utc.to_s(cache_timestamp_format)
+        "#{model_name.cache_key}/#{id}-#{timestamp}"
+      else
+        "#{model_name.cache_key}/#{id}"
+      end
+    end
+
+    module ClassMethods
+      # Defines your model's +to_param+ method to generate "pretty" URLs
+      # using +method_name+, which can be any attribute or method that
+      # responds to +to_s+.
+      #
+      #   class User < ActiveRecord::Base
+      #     to_param :name
+      #   end
+      #
+      #   user = User.find_by(name: 'Fancy Pants')
+      #   user.id         # => 123
+      #   user_path(user) # => "/users/123-fancy-pants"
+      #
+      # Values longer than 20 characters will be truncated. The value
+      # is truncated word by word.
+      #
+      #   user = User.find_by(name: 'David HeinemeierHansson')
+      #   user.id         # => 125
+      #   user_path(user) # => "/users/125-david"
+      #
+      # Because the generated param begins with the record's +id+, it is
+      # suitable for passing to +find+. In a controller, for example:
+      #
+      #   params[:id]               # => "123-fancy-pants"
+      #   User.find(params[:id]).id # => 123
+      def to_param(method_name = nil)
+        if method_name.nil?
+          super()
+        else
+          define_method :to_param do
+            if (default = super()) &&
+                 (result = send(method_name).to_s).present? &&
+                   (param = result.squish.truncate(20, separator: /\s/, omission: nil).parameterize).present?
+              "#{default}-#{param}"
+            else
+              default
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/locale/en.yml

@@ -0,0 +1,47 @@
+en:
+  # Attributes names common to most models
+  #attributes:
+    #created_at: "Created at"
+    #updated_at: "Updated at"
+
+  # Default error messages
+  errors:
+    messages:
+      taken: "has already been taken"
+
+  # Active Record models configuration
+  activerecord:
+    errors:
+      messages:
+        record_invalid: "Validation failed: %{errors}"
+        restrict_dependent_destroy:
+          one: "Cannot delete record because a dependent %{record} exists"
+          many: "Cannot delete record because dependent %{record} exist"
+        # Append your own errors here or at the model/attributes scope.
+
+      # You can define own errors for models or model attributes.
+      # The values :model, :attribute and :value are always available for interpolation.
+      #
+      # For example,
+      #   models:
+      #     user:
+      #       blank: "This is a custom blank message for %{model}: %{attribute}"
+      #       attributes:
+      #         login:
+      #           blank: "This is a custom blank message for User login"
+      # Will define custom blank validation message for User model and
+      # custom blank validation message for login attribute of User model.
+      #models:
+
+    # Translate model names. Used in Model.human_name().
+    #models:
+      # For example,
+      #   user: "Dude"
+      # will translate User model name to "Dude"
+
+    # Translate model attribute names. Used in Model.human_attribute_name(attribute).
+    #attributes:
+      # For example,
+      #   user:
+      #     login: "Handle"
+      # will translate User attribute "login" as "Handle"

data/lib/active_record/locking/optimistic.rb

@@ -0,0 +1,204 @@
+module ActiveRecord
+  module Locking
+    # == What is Optimistic Locking
+    #
+    # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
+    # conflicts with the data. It does this by checking whether another process has made changes to a record since
+    # it was opened, an <tt>ActiveRecord::StaleObjectError</tt> exception is thrown if that has occurred
+    # and the update is ignored.
+    #
+    # Check out <tt>ActiveRecord::Locking::Pessimistic</tt> for an alternative.
+    #
+    # == Usage
+    #
+    # Active Records support optimistic locking if the field +lock_version+ is present. Each update to the
+    # record increments the +lock_version+ column and the locking facilities ensure that records instantiated twice
+    # will let the last one saved raise a +StaleObjectError+ if the first was also updated. Example:
+    #
+    #   p1 = Person.find(1)
+    #   p2 = Person.find(1)
+    #
+    #   p1.first_name = "Michael"
+    #   p1.save
+    #
+    #   p2.first_name = "should fail"
+    #   p2.save # Raises a ActiveRecord::StaleObjectError
+    #
+    # Optimistic locking will also check for stale data when objects are destroyed. Example:
+    #
+    #   p1 = Person.find(1)
+    #   p2 = Person.find(1)
+    #
+    #   p1.first_name = "Michael"
+    #   p1.save
+    #
+    #   p2.destroy # Raises a ActiveRecord::StaleObjectError
+    #
+    # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
+    # or otherwise apply the business logic needed to resolve the conflict.
+    #
+    # This locking mechanism will function inside a single Ruby process. To make it work across all
+    # web requests, the recommended approach is to add +lock_version+ as a hidden field to your form.
+    #
+    # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
+    # To override the name of the +lock_version+ column, set the <tt>locking_column</tt> class attribute:
+    #
+    #   class Person < ActiveRecord::Base
+    #     self.locking_column = :lock_person
+    #   end
+    #
+    module Optimistic
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :lock_optimistically, instance_writer: false
+        self.lock_optimistically = true
+      end
+
+      def locking_enabled? #:nodoc:
+        self.class.locking_enabled?
+      end
+
+      private
+        def increment_lock
+          lock_col = self.class.locking_column
+          previous_lock_value = send(lock_col).to_i
+          send(lock_col + '=', previous_lock_value + 1)
+        end
+
+        def _update_record(attribute_names = self.attribute_names) #:nodoc:
+          return super unless locking_enabled?
+          return 0 if attribute_names.empty?
+
+          lock_col = self.class.locking_column
+          previous_lock_value = send(lock_col).to_i
+          increment_lock
+
+          attribute_names += [lock_col]
+          attribute_names.uniq!
+
+          begin
+            relation = self.class.unscoped
+
+            stmt = relation.where(
+              relation.table[self.class.primary_key].eq(id).and(
+                relation.table[lock_col].eq(self.class.quote_value(previous_lock_value, column_for_attribute(lock_col)))
+              )
+            ).arel.compile_update(
+              arel_attributes_with_values_for_update(attribute_names),
+              self.class.primary_key
+            )
+
+            affected_rows = self.class.connection.update stmt
+
+            unless affected_rows == 1
+              raise ActiveRecord::StaleObjectError.new(self, "update")
+            end
+
+            affected_rows
+
+          # If something went wrong, revert the version.
+          rescue Exception
+            send(lock_col + '=', previous_lock_value)
+            raise
+          end
+        end
+
+        def destroy_row
+          affected_rows = super
+
+          if locking_enabled? && affected_rows != 1
+            raise ActiveRecord::StaleObjectError.new(self, "destroy")
+          end
+
+          affected_rows
+        end
+
+        def relation_for_destroy
+          relation = super
+
+          if locking_enabled?
+            column_name = self.class.locking_column
+            column      = self.class.columns_hash[column_name]
+            substitute  = self.class.connection.substitute_at(column)
+
+            relation = relation.where(self.class.arel_table[column_name].eq(substitute))
+            relation.bind_values << [column, self[column_name].to_i]
+          end
+
+          relation
+        end
+
+      module ClassMethods
+        DEFAULT_LOCKING_COLUMN = 'lock_version'
+
+        # Returns true if the +lock_optimistically+ flag is set to true
+        # (which it is, by default) and the table includes the
+        # +locking_column+ column (defaults to +lock_version+).
+        def locking_enabled?
+          lock_optimistically && columns_hash[locking_column]
+        end
+
+        # Set the column to use for optimistic locking. Defaults to +lock_version+.
+        def locking_column=(value)
+          clear_caches_calculated_from_columns
+          @locking_column = value.to_s
+        end
+
+        # The version column used for optimistic locking. Defaults to +lock_version+.
+        def locking_column
+          reset_locking_column unless defined?(@locking_column)
+          @locking_column
+        end
+
+        # Reset the column used for optimistic locking back to the +lock_version+ default.
+        def reset_locking_column
+          self.locking_column = DEFAULT_LOCKING_COLUMN
+        end
+
+        # Make sure the lock version column gets updated when counters are
+        # updated.
+        def update_counters(id, counters)
+          counters = counters.merge(locking_column => 1) if locking_enabled?
+          super
+        end
+
+        private
+
+        # We need to apply this decorator here, rather than on module inclusion. The closure
+        # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
+        # sub class being decorated. As such, changes to `lock_optimistically`, or
+        # `locking_column` would not be picked up.
+        def inherited(subclass)
+          subclass.class_eval do
+            is_lock_column = ->(name, _) { lock_optimistically && name == locking_column }
+            decorate_matching_attribute_types(is_lock_column, :_optimistic_locking) do |type|
+              LockingType.new(type)
+            end
+          end
+          super
+        end
+      end
+    end
+
+    class LockingType < SimpleDelegator # :nodoc:
+      def type_cast_from_database(value)
+        # `nil` *should* be changed to 0
+        super.to_i
+      end
+
+      def changed?(old_value, *)
+        # Ensure we save if the default was `nil`
+        super || old_value == 0
+      end
+
+      def init_with(coder)
+        __setobj__(coder['subtype'])
+      end
+
+      def encode_with(coder)
+        coder['subtype'] = __getobj__
+      end
+    end
+  end
+end