activerecord 1.0.0 → 4.0.0

data/lib/active_record/inheritance.rb

@@ -0,0 +1,200 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActiveRecord
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    included do
+      # Determine 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 can not be instantiated."
+        end
+        if (attrs = args.first).is_a?(Hash)
+          if subclass = subclass_from_attrs(attrs)
+            return subclass.new(*args, &block)
+          end
+        end
+        # Delegate to the original .new
+        super
+      end
+
+      # True if this isn't a concrete subclass needing a STI type condition.
+      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
+        @symbolized_base_class ||= base_class.to_s.to_sym
+      end
+
+      def symbolized_sti_name
+        @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|
+            begin
+              constant = ActiveSupport::Dependencies.constantize(candidate)
+              return constant if candidate == constant.to_s
+            rescue NameError => e
+              # We don't want to swallow NoMethodError < NameError errors
+              raise e unless e.instance_of?(NameError)
+            end
+          end
+
+          raise NameError, "uninitialized constant #{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.to_sym]
+        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_attrs(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
+
+    private
+
+    # 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,60 @@
+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)
+    def cache_key
+      case
+      when new_record?
+        "#{self.class.model_name.cache_key}/new"
+      when timestamp = max_updated_column_timestamp
+        timestamp = timestamp.utc.to_s(cache_timestamp_format)
+        "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
+      else
+        "#{self.class.model_name.cache_key}/#{id}"
+      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,181 @@
+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 = @attributes.keys) #: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))
+              )
+            ).arel.compile_update(arel_attributes_with_values_for_update(attribute_names))
+
+            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.bind_values.length)
+
+            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)
+          @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
+
+        # Quote the column name used for optimistic locking.
+        def quoted_locking_column
+          connection.quote_column_name(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
+
+        def column_defaults
+          @column_defaults ||= begin
+            defaults = super
+
+            if defaults.key?(locking_column) && lock_optimistically
+              defaults[locking_column] ||= 0
+            end
+
+            defaults
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/locking/pessimistic.rb

@@ -0,0 +1,77 @@
+module ActiveRecord
+  module Locking
+    # Locking::Pessimistic provides support for row-level locking using
+    # SELECT ... FOR UPDATE and other lock types.
+    #
+    # Pass <tt>lock: true</tt> to <tt>ActiveRecord::Base.find</tt> to obtain an exclusive
+    # lock on the selected rows:
+    #   # select * from accounts where id=1 for update
+    #   Account.find(1, lock: true)
+    #
+    # Pass <tt>lock: 'some locking clause'</tt> to give a database-specific locking clause
+    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
+    #
+    #   Account.transaction do
+    #     # select * from accounts where name = 'shugo' limit 1 for update
+    #     shugo = Account.where("name = 'shugo'").lock(true).first
+    #     yuko = Account.where("name = 'yuko'").lock(true).first
+    #     shugo.balance -= 100
+    #     shugo.save!
+    #     yuko.balance += 100
+    #     yuko.save!
+    #   end
+    #
+    # You can also use <tt>ActiveRecord::Base#lock!</tt> method to lock one record by id.
+    # This may be better if you don't need to lock every row. Example:
+    #
+    #   Account.transaction do
+    #     # select * from accounts where ...
+    #     accounts = Account.where(...)
+    #     account1 = accounts.detect { |account| ... }
+    #     account2 = accounts.detect { |account| ... }
+    #     # select * from accounts where id=? for update
+    #     account1.lock!
+    #     account2.lock!
+    #     account1.balance -= 100
+    #     account1.save!
+    #     account2.balance += 100
+    #     account2.save!
+    #   end
+    #
+    # You can start a transaction and acquire the lock in one go by calling
+    # <tt>with_lock</tt> with a block. The block is called from within
+    # a transaction, the object is already locked. Example:
+    #
+    #   account = Account.first
+    #   account.with_lock do
+    #     # This block is called within a transaction,
+    #     # account is already locked.
+    #     account.balance -= 100
+    #     account.save!
+    #   end
+    #
+    # Database-specific information on row locking:
+    #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
+    #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    module Pessimistic
+      # Obtain a row lock on this record. Reloads the record to obtain the requested
+      # lock. Pass an SQL locking clause to append the end of the SELECT statement
+      # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
+      # the locked record.
+      def lock!(lock = true)
+        reload(:lock => lock) if persisted?
+        self
+      end
+
+      # Wraps the passed block in a transaction, locking the object
+      # before yielding. You pass can the SQL locking clause
+      # as argument (see <tt>lock!</tt>).
+      def with_lock(lock = true)
+        transaction do
+          lock!(lock)
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/active_record/log_subscriber.rb

@@ -0,0 +1,82 @@
+module ActiveRecord
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
+    def self.runtime=(value)
+      ActiveRecord::RuntimeRegistry.sql_runtime = value
+    end
+
+    def self.runtime
+      ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def render_bind(column, value)
+      if column
+        if column.binary?
+          value = "<#{value.bytesize} bytes of binary data>"
+        end
+
+        [column.name, value]
+      else
+        [nil, value]
+      end
+    end
+
+    def sql(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+
+      return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
+
+      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      sql   = payload[:sql].squeeze(' ')
+      binds = nil
+
+      unless (payload[:binds] || []).empty?
+        binds = "  " + payload[:binds].map { |col,v|
+          render_bind(col, v)
+        }.inspect
+      end
+
+      if odd?
+        name = color(name, CYAN, true)
+        sql  = color(sql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{sql}#{binds}"
+    end
+
+    def identity(event)
+      return unless logger.debug?
+
+      name = color(event.payload[:name], odd? ? CYAN : MAGENTA, true)
+      line = odd? ? color(event.payload[:line], nil, true) : event.payload[:line]
+
+      debug "  #{name}  #{line}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+
+    def logger
+      ActiveRecord::Base.logger
+    end
+  end
+end
+
+ActiveRecord::LogSubscriber.attach_to :active_record