activerecord 3.1.10 → 4.2.11

data/lib/active_record/identity_map.rb

@@ -1,163 +0,0 @@
-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.update(coder['attributes'].except(*dirty))
-      @changed_attributes.update(coder['attributes'].slice(*dirty))
-      @changed_attributes.delete_if{|k,v| v.eql? @attributes[k]}
-
-      set_serialized_attributes
-
-      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/named_scope.rb

@@ -1,200 +0,0 @@
-require 'active_support/core_ext/array'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/class/attribute'
-
-module ActiveRecord
-  # = Active Record Named \Scopes
-  module NamedScope
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # Returns an anonymous \scope.
-      #
-      #   posts = Post.scoped
-      #   posts.size # Fires "select count(*) from  posts" and returns the count
-      #   posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
-      #
-      #   fruits = Fruit.scoped
-      #   fruits = fruits.where(:colour => 'red') if options[:red_only]
-      #   fruits = fruits.limit(10) if limited?
-      #
-      # Anonymous \scopes tend to be useful when procedurally generating complex
-      # queries, where passing intermediate values (\scopes) around as first-class
-      # objects is convenient.
-      #
-      # You can define a \scope that applies to all finders using
-      # ActiveRecord::Base.default_scope.
-      def scoped(options = nil)
-        if options
-          scoped.apply_finder_options(options)
-        else
-          if current_scope
-            current_scope.clone
-          else
-            scope = relation.clone
-            scope.default_scoped = true
-            scope
-          end
-        end
-      end
-
-      ##
-      # Collects attributes from scopes that should be applied when creating
-      # an AR instance for the particular class this is called on.
-      def scope_attributes # :nodoc:
-        if current_scope
-          current_scope.scope_for_create
-        else
-          scope = relation.clone
-          scope.default_scoped = true
-          scope.scope_for_create
-        end
-      end
-
-      ##
-      # Are there default attributes associated with this scope?
-      def scope_attributes? # :nodoc:
-        current_scope || default_scopes.any?
-      end
-
-      # Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a database query,
-      # such as <tt>where(:color => :red).select('shirts.*').includes(:washing_instructions)</tt>.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     scope :red, where(:color => 'red')
-      #     scope :dry_clean_only, joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true)
-      #   end
-      #
-      # The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
-      # in effect, represents the query <tt>Shirt.where(:color => 'red')</tt>.
-      #
-      # Note that this is simply 'syntactic sugar' for defining an actual class method:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     def self.red
-      #       where(:color => 'red')
-      #     end
-      #   end
-      #
-      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it
-      # resembles the association object constructed by a <tt>has_many</tt> declaration. For instance,
-      # you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>, <tt>Shirt.red.where(:size => 'small')</tt>.
-      # Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable;
-      # <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt>
-      # all behave as if Shirt.red really was an Array.
-      #
-      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce
-      # all shirts that are both red and dry clean only.
-      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
-      # returns the number of garments for which these criteria obtain. Similarly with
-      # <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
-      #
-      # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which
-      # the \scopes were defined. But they are also available to <tt>has_many</tt> associations. If,
-      #
-      #   class Person < ActiveRecord::Base
-      #     has_many :shirts
-      #   end
-      #
-      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
-      # only shirts.
-      #
-      # Named \scopes can also be procedural:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     scope :colored, lambda { |color| where(:color => color) }
-      #   end
-      #
-      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
-      #
-      # On Ruby 1.9 you can use the 'stabby lambda' syntax:
-      #
-      #   scope :colored, ->(color) { where(:color => color) }
-      #
-      # Note that scopes defined with \scope will be evaluated when they are defined, rather than
-      # when they are used. For example, the following would be incorrect:
-      #
-      #   class Post < ActiveRecord::Base
-      #     scope :recent, where('published_at >= ?', Time.now - 1.week)
-      #   end
-      #
-      # The example above would be 'frozen' to the <tt>Time.now</tt> value when the <tt>Post</tt>
-      # class was defined, and so the resultant SQL query would always be the same. The correct
-      # way to do this would be via a lambda, which will re-evaluate the scope each time
-      # it is called:
-      #
-      #   class Post < ActiveRecord::Base
-      #     scope :recent, lambda { where('published_at >= ?', Time.now - 1.week) }
-      #   end
-      #
-      # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     scope :red, where(:color => 'red') do
-      #       def dom_id
-      #         'red_shirts'
-      #       end
-      #     end
-      #   end
-      #
-      # Scopes can also be used while creating/building a record.
-      #
-      #   class Article < ActiveRecord::Base
-      #     scope :published, where(:published => true)
-      #   end
-      #
-      #   Article.published.new.published    # => true
-      #   Article.published.create.published # => true
-      #
-      # Class methods on your model are automatically available
-      # on scopes. Assuming the following setup:
-      #
-      #   class Article < ActiveRecord::Base
-      #     scope :published, where(:published => true)
-      #     scope :featured, where(:featured => true)
-      #
-      #     def self.latest_article
-      #       order('published_at desc').first
-      #     end
-      #
-      #     def self.titles
-      #       map(&:title)
-      #     end
-      #
-      #   end
-      #
-      # We are able to call the methods like this:
-      #
-      #   Article.published.featured.latest_article
-      #   Article.featured.titles
-
-      def scope(name, scope_options = {})
-        name = name.to_sym
-        valid_scope_name?(name)
-        extension = Module.new(&Proc.new) if block_given?
-
-        scope_proc = lambda do |*args|
-          options = scope_options.respond_to?(:call) ? unscoped { scope_options.call(*args) } : scope_options
-          options = scoped.apply_finder_options(options) if options.is_a?(Hash)
-
-          relation = scoped.merge(options)
-
-          extension ? relation.extending(extension) : relation
-        end
-
-        singleton_class.send(:redefine_method, name, &scope_proc)
-      end
-
-    protected
-
-      def valid_scope_name?(name)
-        if respond_to?(name, true)
-          logger.warn "Creating scope :#{name}. " \
-                      "Overwriting existing method #{self.name}.#{name}."
-        end
-      end
-    end
-  end
-end

data/lib/active_record/observer.rb

@@ -1,121 +0,0 @@
-require 'active_support/core_ext/class/attribute'
-
-module ActiveRecord
-  # = Active Record Observer
-  #
-  # Observer classes respond to life cycle callbacks to implement trigger-like
-  # behavior outside the original class. This is a great way to reduce the
-  # clutter that normally comes when the model class is burdened with
-  # functionality that doesn't pertain to the core responsibility of the
-  # class. Example:
-  #
-  #   class CommentObserver < ActiveRecord::Observer
-  #     def after_save(comment)
-  #       Notifications.comment("admin@do.com", "New comment was posted", comment).deliver
-  #     end
-  #   end
-  #
-  # This Observer sends an email when a Comment#save is finished.
-  #
-  #   class ContactObserver < ActiveRecord::Observer
-  #     def after_create(contact)
-  #       contact.logger.info('New contact added!')
-  #     end
-  #
-  #     def after_destroy(contact)
-  #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
-  #     end
-  #   end
-  #
-  # This Observer uses logger to log when specific callbacks are triggered.
-  #
-  # == Observing a class that can't be inferred
-  #
-  # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
-  # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
-  # differently than the class you're interested in observing, you can use the Observer.observe class method which takes
-  # either the concrete class (Product) or a symbol for that class (:product):
-  #
-  #   class AuditObserver < ActiveRecord::Observer
-  #     observe :account
-  #
-  #     def after_update(account)
-  #       AuditTrail.new(account, "UPDATED")
-  #     end
-  #   end
-  #
-  # If the audit observer needs to watch more than one kind of object, this can be specified with multiple arguments:
-  #
-  #   class AuditObserver < ActiveRecord::Observer
-  #     observe :account, :balance
-  #
-  #     def after_update(record)
-  #       AuditTrail.new(record, "UPDATED")
-  #     end
-  #   end
-  #
-  # The AuditObserver will now act on both updates to Account and Balance by treating them both as records.
-  #
-  # == Available callback methods
-  #
-  # The observer can implement callback methods for each of the methods described in the Callbacks module.
-  #
-  # == Storing Observers in Rails
-  #
-  # If you're using Active Record within Rails, observer classes are usually stored in app/models with the
-  # naming convention of app/models/audit_observer.rb.
-  #
-  # == Configuration
-  #
-  # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration
-  # setting in your <tt>config/application.rb</tt> file.
-  #
-  #   config.active_record.observers = :comment_observer, :signup_observer
-  #
-  # Observers will not be invoked unless you define these in your application configuration.
-  #
-  # == Loading
-  #
-  # Observers register themselves in the model class they observe, since it is the class that
-  # notifies them of events when they occur. As a side-effect, when an observer is loaded its
-  # corresponding model class is loaded.
-  #
-  # Up to (and including) Rails 2.0.2 observers were instantiated between plugins and
-  # application initializers. Now observers are loaded after application initializers,
-  # so observed models can make use of extensions.
-  #
-  # If by any chance you are using observed models in the initialization you can still
-  # load their observers by calling <tt>ModelObserver.instance</tt> before. Observers are
-  # singletons and that call instantiates and registers them.
-  #
-  class Observer < ActiveModel::Observer
-
-    protected
-
-      def observed_classes
-        klasses = super
-        klasses + klasses.map { |klass| klass.descendants }.flatten
-      end
-
-      def add_observer!(klass)
-        super
-        define_callbacks klass
-      end
-
-      def define_callbacks(klass)
-        observer = self
-        observer_name = observer.class.name.underscore.gsub('/', '__')
-
-        ActiveRecord::Callbacks::CALLBACKS.each do |callback|
-          next unless respond_to?(callback)
-          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
-          unless klass.respond_to?(callback_meth)
-            klass.send(:define_method, callback_meth) do |&block|
-              observer.update(callback, self, &block)
-            end
-            klass.send(callback, callback_meth)
-          end
-        end
-      end
-  end
-end