activerecord 2.3.18 → 3.2.22

data/lib/active_record/identity_map.rb

@@ -0,0 +1,162 @@
+module ActiveRecord
+  # = Active Record Identity Map
+  #
+  # Ensures that each object gets loaded only once by keeping every loaded
+  # object in a map. Looks up objects using the map when referring to them.
+  #
+  # More information on Identity Map pattern:
+  #   http://www.martinfowler.com/eaaCatalog/identityMap.html
+  #
+  # == Configuration
+  #
+  # In order to enable IdentityMap, set <tt>config.active_record.identity_map = true</tt>
+  # in your <tt>config/application.rb</tt> file.
+  #
+  # IdentityMap is disabled by default and still in development (i.e. use it with care).
+  #
+  # == Associations
+  #
+  # Active Record Identity Map does not track associations yet. For example:
+  #
+  #   comment = @post.comments.first
+  #   comment.post = nil
+  #   @post.comments.include?(comment) #=> true
+  #
+  # Ideally, the example above would return false, removing the comment object from the
+  # post association when the association is nullified. This may cause side effects, as
+  # in the situation below, if Identity Map is enabled:
+  #
+  #   Post.has_many :comments, :dependent => :destroy
+  #
+  #   comment = @post.comments.first
+  #   comment.post = nil
+  #   comment.save
+  #   Post.destroy(@post.id)
+  #
+  # Without using Identity Map, the code above will destroy the @post object leaving
+  # the comment object intact. However, once we enable Identity Map, the post loaded
+  # by Post.destroy is exactly the same object as the object @post. As the object @post
+  # still has the comment object in @post.comments, once Identity Map is enabled, the
+  # comment object will be accidently removed.
+  #
+  # This inconsistency is meant to be fixed in future Rails releases.
+  #
+  module IdentityMap
+
+    class << self
+      def enabled=(flag)
+        Thread.current[:identity_map_enabled] = flag
+      end
+
+      def enabled
+        Thread.current[:identity_map_enabled]
+      end
+      alias enabled? enabled
+
+      def repository
+        Thread.current[:identity_map] ||= Hash.new { |h,k| h[k] = {} }
+      end
+
+      def use
+        old, self.enabled = enabled, true
+
+        yield if block_given?
+      ensure
+        self.enabled = old
+        clear
+      end
+
+      def without
+        old, self.enabled = enabled, false
+
+        yield if block_given?
+      ensure
+        self.enabled = old
+      end
+
+      def get(klass, primary_key)
+        record = repository[klass.symbolized_sti_name][primary_key]
+
+        if record.is_a?(klass)
+          ActiveSupport::Notifications.instrument("identity.active_record",
+            :line => "From Identity Map (id: #{primary_key})",
+            :name => "#{klass} Loaded",
+            :connection_id => object_id)
+
+          record
+        else
+          nil
+        end
+      end
+
+      def add(record)
+        repository[record.class.symbolized_sti_name][record.id] = record if contain_all_columns?(record)
+      end
+
+      def remove(record)
+        repository[record.class.symbolized_sti_name].delete(record.id)
+      end
+
+      def remove_by_id(symbolized_sti_name, id)
+        repository[symbolized_sti_name].delete(id)
+      end
+
+      def clear
+        repository.clear
+      end
+
+      private
+
+        def contain_all_columns?(record)
+          (record.class.column_names - record.attribute_names).empty?
+        end
+    end
+
+    # Reinitialize an Identity Map model object from +coder+.
+    # +coder+ must contain the attributes necessary for initializing an empty
+    # model object.
+    def reinit_with(coder)
+      @attributes_cache = {}
+      dirty      = @changed_attributes.keys
+      attributes = self.class.initialize_attributes(coder['attributes'].except(*dirty))
+      @attributes.update(attributes)
+      @changed_attributes.update(coder['attributes'].slice(*dirty))
+      @changed_attributes.delete_if{|k,v| v.eql? @attributes[k]}
+
+      run_callbacks :find
+
+      self
+    end
+
+    class Middleware
+      class Body #:nodoc:
+        def initialize(target, original)
+          @target   = target
+          @original = original
+        end
+
+        def each(&block)
+          @target.each(&block)
+        end
+
+        def close
+          @target.close if @target.respond_to?(:close)
+        ensure
+          IdentityMap.enabled = @original
+          IdentityMap.clear
+        end
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        enabled = IdentityMap.enabled
+        IdentityMap.enabled = true
+        status, headers, body = @app.call(env)
+        [status, headers, Body.new(body, enabled)]
+      end
+    end
+  end
+end

data/lib/active_record/inheritance.rb

@@ -0,0 +1,174 @@
+require 'active_support/concern'
+
+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
+      self.store_full_sti_class = true
+    end
+
+    module ClassMethods
+      # True if this isn't a concrete subclass needing a STI type condition.
+      def descends_from_active_record?
+        if 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 base AR subclass that this class descends from. 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
+        class_of_active_record_descendant(self)
+      end
+
+      # Set this to true if this is an abstract class (see <tt>abstract_class?</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
+
+      # Finder methods must instantiate through this method to work with the
+      # single-table inheritance model that makes it possible to create
+      # objects of different types from the same table.
+      def instantiate(record)
+        sti_class = find_sti_class(record[inheritance_column])
+        record_id = sti_class.primary_key && record[sti_class.primary_key]
+
+        if ActiveRecord::IdentityMap.enabled? && record_id
+          instance = use_identity_map(sti_class, record_id, record)
+        else
+          instance = sti_class.allocate.init_with('attributes' => record)
+        end
+
+        instance
+      end
+
+      protected
+
+      # Returns the class descending directly from ActiveRecord::Base or an
+      # abstract class, if any, in the inheritance hierarchy.
+      def class_of_active_record_descendant(klass)
+        if klass == Base || klass.superclass == Base || klass.superclass.abstract_class?
+          klass
+        elsif klass.superclass.nil?
+          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+        else
+          class_of_active_record_descendant(klass.superclass)
+        end
+      end
+
+      # 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
+
+      def use_identity_map(sti_class, record_id, record)
+        if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
+          record_id = record_id.to_i
+        end
+
+        if instance = IdentityMap.get(sti_class, record_id)
+          instance.reinit_with('attributes' => record)
+        else
+          instance = sti_class.allocate.init_with('attributes' => record)
+          IdentityMap.add(instance)
+        end
+
+        instance
+      end
+
+      def find_sti_class(type_name)
+        if type_name.blank? || !columns_hash.include?(inheritance_column)
+          self
+        else
+          begin
+            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
+        end
+      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
+    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 format in the cache key.
+      # This is +:number+, by default.
+      class_attribute :cache_timestamp_format, :instance_writer => false
+      self.cache_timestamp_format = :number
+    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.
+    #
+    # ==== Examples
+    #
+    #   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 = self[:updated_at]
+        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

@@ -1,34 +1,17 @@
 en:
+  # Attributes names common to most models
+  #attributes:
+    #created_at: "Created at"
+    #updated_at: "Updated at"
+
+  # Active Record models configuration
   activerecord:
     errors:
-      # The values :model, :attribute and :value are always available for interpolation
-      # The value :count is available when applicable. Can be used for pluralization.
       messages:
-        inclusion: "is not included in the list"
-        exclusion: "is reserved"
-        invalid: "is invalid"
-        confirmation: "doesn't match confirmation"
-        accepted: "must be accepted"
-        empty: "can't be empty"
-        blank: "can't be blank"
-        too_long: "is too long (maximum is %{count} characters)"
-        too_short: "is too short (minimum is %{count} characters)"
-        wrong_length: "is the wrong length (should be %{count} characters)"
         taken: "has already been taken"
-        not_a_number: "is not a number"
-        greater_than: "must be greater than %{count}"
-        greater_than_or_equal_to: "must be greater than or equal to %{count}"
-        equal_to: "must be equal to %{count}"
-        less_than: "must be less than %{count}"
-        less_than_or_equal_to: "must be less than or equal to %{count}"
-        odd: "must be odd"
-        even: "must be even"
         record_invalid: "Validation failed: %{errors}"
         # Append your own errors here or at the model/attributes scope.
 
-      full_messages:
-        format: "%{attribute} %{message}"
-
       # You can define own errors for models or model attributes.
       # The values :model, :attribute and :value are always available for interpolation.
       #
@@ -39,20 +22,19 @@ en:
       #       attributes:
       #         login:
       #           blank: "This is a custom blank message for User login"
-      # Will define custom blank validation message for User model and 
+      # 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"
-