activerecord 3.0.0 → 4.0.0

data/lib/active_record/scoping/named.rb

@@ -0,0 +1,175 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/kernel/singleton_class'
+
+module ActiveRecord
+  # = Active Record \Named \Scopes
+  module Scoping
+    module Named
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Returns an <tt>ActiveRecord::Relation</tt> scope object.
+        #
+        #   posts = Post.all
+        #   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.all
+        #   fruits = fruits.where(color: 'red') if options[:red_only]
+        #   fruits = fruits.limit(10) if limited?
+        #
+        # You can define a scope that applies to all finders using
+        # <tt>ActiveRecord::Base.default_scope</tt>.
+        def all
+          if current_scope
+            current_scope.clone
+          else
+            scope = relation
+            scope.default_scoped = true
+            scope
+          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
+            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 +scope+ define class methods <tt>Shirt.red</tt> and
+        # <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, in effect,
+        # represents the query <tt>Shirt.where(color: 'red')</tt>.
+        #
+        # You should always pass a callable object to the scopes defined
+        # with +scope+. This ensures that the scope is re-evaluated each
+        # time it is called.
+        #
+        # 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
+        # <tt>Shirt.red</tt> is not an Array; it resembles the association object
+        # constructed by a +has_many+ 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
+        # <tt>Shirt.red</tt> 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 +has_many+ 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 have extensions, just as with +has_many+
+        # 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
+        #       pluck(:title)
+        #     end
+        #   end
+        #
+        # We are able to call the methods like this:
+        #
+        #   Article.published.featured.latest_article
+        #   Article.featured.titles
+        def scope(name, body, &block)
+          extension = Module.new(&block) if block
+
+          # Check body.is_a?(Relation) to prevent the relation actually being
+          # loaded by respond_to?
+          if body.is_a?(Relation) || !body.respond_to?(:call)
+            ActiveSupport::Deprecation.warn(
+              "Using #scope without passing a callable object is deprecated. For " \
+              "example `scope :red, where(color: 'red')` should be changed to " \
+              "`scope :red, -> { where(color: 'red') }`. There are numerous gotchas " \
+              "in the former usage and it makes the implementation more complicated " \
+              "and buggy. (If you prefer, you can just define a class method named " \
+              "`self.red`.)"
+            )
+          end
+
+          singleton_class.send(:define_method, name) do |*args|
+            if body.respond_to?(:call)
+              scope = all.scoping { body.call(*args) }
+              scope = scope.extending(extension) if extension
+            else
+              scope = body
+            end
+
+            scope || all
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/scoping.rb

@@ -0,0 +1,82 @@
+require 'active_support/per_thread_registry'
+
+module ActiveRecord
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      include Default
+      include Named
+    end
+
+    module ClassMethods
+      def current_scope #:nodoc:
+        ScopeRegistry.value_for(:current_scope, base_class.to_s)
+      end
+
+      def current_scope=(scope) #:nodoc:
+        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+      end
+    end
+
+    def populate_with_current_scope_attributes
+      return unless self.class.scope_attributes?
+
+      self.class.scope_attributes.each do |att,value|
+        send("#{att}=", value) if respond_to?("#{att}=")
+      end
+    end
+
+    # This class stores the +:current_scope+ and +:ignore_default_scope+ values
+    # for different classes. The registry is stored as a thread local, which is
+    # accessed through +ScopeRegistry.current+.
+    #
+    # This class allows you to store and get the scope values on different
+    # classes and different types of scopes. For example, if you are attempting
+    # to get the current_scope for the +Board+ model, then you would use the
+    # following code:
+    #
+    #   registry = ActiveRecord::Scoping::ScopeRegistry
+    #   registry.set_value_for(:current_scope, "Board", some_new_scope)
+    #
+    # Now when you run:
+    #
+    #   registry.value_for(:current_scope, "Board")
+    #
+    # You will obtain whatever was defined in +some_new_scope+. The +value_for+
+    # and +set_value_for+ methods are delegated to the current +ScopeRegistry+
+    # object, so the above example code can also be called as:
+    #
+    #   ActiveRecord::Scoping::ScopeRegistry.set_value_for(:current_scope,
+    #       "Board", some_new_scope)
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_name+ and +variable_name+.
+      def value_for(scope_type, variable_name)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +variable_name+.
+      def set_value_for(scope_type, variable_name, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name] = value
+      end
+
+      private
+
+      def raise_invalid_scope_type!(scope_type)
+        if !VALID_SCOPE_TYPES.include?(scope_type)
+          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        end
+      end
+    end
+  end
+end

data/lib/active_record/serialization.rb

@@ -4,56 +4,18 @@ module ActiveRecord #:nodoc:
     extend ActiveSupport::Concern
     include ActiveModel::Serializers::JSON
 
-    def serializable_hash(options = nil)
-      options ||= {}
-
-      options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
-      options[:except] |= Array.wrap(self.class.inheritance_column)
-
-      hash = super(options)
-
-      serializable_add_includes(options) do |association, records, opts|
-        hash[association] = records.is_a?(Enumerable) ?
-          records.map { |r| r.serializable_hash(opts) } :
-          records.serializable_hash(opts)
-      end
-
-      hash
+    included do
+      self.include_root_in_json = false
     end
 
-    private
-      # Add associations specified via the <tt>:includes</tt> option.
-      #
-      # Expects a block that takes as arguments:
-      #   +association+ - name of the association
-      #   +records+     - the association record(s) to be serialized
-      #   +opts+        - options for the association records
-      def serializable_add_includes(options = {})
-        return unless include_associations = options.delete(:include)
-
-        base_only_or_except = { :except => options[:except],
-                                :only => options[:only] }
-
-        include_has_options = include_associations.is_a?(Hash)
-        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
-
-        for association in associations
-          records = case self.class.reflect_on_association(association).macro
-          when :has_many, :has_and_belongs_to_many
-            send(association).to_a
-          when :has_one, :belongs_to
-            send(association)
-          end
+    def serializable_hash(options = nil)
+      options = options.try(:clone) || {}
 
-          unless records.nil?
-            association_options = include_has_options ? include_associations[association] : base_only_or_except
-            opts = options.merge(association_options)
-            yield(association, records, opts)
-          end
-        end
+      options[:except] = Array(options[:except]).map { |n| n.to_s }
+      options[:except] |= Array(self.class.inheritance_column)
 
-        options[:include] = include_associations
-      end
+      super(options)
+    end
   end
 end
 

data/lib/active_record/serializers/xml_serializer.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/hash/conversions'
 
 module ActiveRecord #:nodoc:
@@ -19,8 +18,8 @@ module ActiveRecord #:nodoc:
     #     <id type="integer">1</id>
     #     <approved type="boolean">false</approved>
     #     <replies-count type="integer">0</replies-count>
-    #     <bonus-time type="datetime">2000-01-01T08:28:00+12:00</bonus-time>
-    #     <written-on type="datetime">2003-07-16T09:28:00+1200</written-on>
+    #     <bonus-time type="dateTime">2000-01-01T08:28:00+12:00</bonus-time>
+    #     <written-on type="dateTime">2003-07-16T09:28:00+1200</written-on>
     #     <content>Have a nice day</content>
     #     <author-email-address>david@loudthinking.com</author-email-address>
     #     <parent-id></parent-id>
@@ -37,7 +36,7 @@ module ActiveRecord #:nodoc:
     #
     # For instance:
     #
-    #   topic.to_xml(:skip_instruct => true, :except => [ :id, :bonus_time, :written_on, :replies_count ])
+    #   topic.to_xml(skip_instruct: true, except: [ :id, :bonus_time, :written_on, :replies_count ])
     #
     #   <topic>
     #     <title>The First Topic</title>
@@ -51,7 +50,7 @@ module ActiveRecord #:nodoc:
     #
     # To include first level associations use <tt>:include</tt>:
     #
-    #   firm.to_xml :include => [ :account, :clients ]
+    #   firm.to_xml include: [ :account, :clients ]
     #
     #   <?xml version="1.0" encoding="UTF-8"?>
     #   <firm>
@@ -75,14 +74,14 @@ module ActiveRecord #:nodoc:
     #   </firm>
     #
     # Additionally, the record being serialized will be passed to a Proc's second
-    # parameter.  This allows for ad hoc additions to the resultant document that
+    # parameter. This allows for ad hoc additions to the resultant document that
     # incorporate the context of the record being serialized. And by leveraging the
     # closure created by a Proc, to_xml can be used to add elements that normally fall
     # outside of the scope of the model -- for example, generating and appending URLs
     # associated with models.
     #
     #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
-    #   firm.to_xml :procs => [ proc ]
+    #   firm.to_xml procs: [ proc ]
     #
     #   <firm>
     #     # ... normal attributes as shown above ...
@@ -91,7 +90,7 @@ module ActiveRecord #:nodoc:
     #
     # To include deeper levels of associations pass a hash like this:
     #
-    #   firm.to_xml :include => {:account => {}, :clients => {:include => :address}}
+    #   firm.to_xml include: {account: {}, clients: {include: :address}}
     #   <?xml version="1.0" encoding="UTF-8"?>
     #   <firm>
     #     <id type="integer">1</id>
@@ -121,7 +120,7 @@ module ActiveRecord #:nodoc:
     #
     # To include any methods on the model being called use <tt>:methods</tt>:
     #
-    #   firm.to_xml :methods => [ :calculated_earnings, :real_earnings ]
+    #   firm.to_xml methods: [ :calculated_earnings, :real_earnings ]
     #
     #   <firm>
     #     # ... normal attributes as shown above ...
@@ -133,7 +132,7 @@ module ActiveRecord #:nodoc:
     # modified version of the options hash that was given to +to_xml+:
     #
     #   proc = Proc.new { |options| options[:builder].tag!('abc', 'def') }
-    #   firm.to_xml :procs => [ proc ]
+    #   firm.to_xml procs: [ proc ]
     #
     #   <firm>
     #     # ... normal attributes as shown above ...
@@ -163,8 +162,9 @@ module ActiveRecord #:nodoc:
     #
     #   class IHaveMyOwnXML < ActiveRecord::Base
     #     def to_xml(options = {})
+    #       require 'builder'
     #       options[:indent] ||= 2
-    #       xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    #       xml = options[:builder] ||= ::Builder::XmlMarkup.new(indent: options[:indent])
     #       xml.instruct! unless options[:skip_instruct]
     #       xml.level_one do
     #         xml.tag!(:second_level, 'content')
@@ -177,66 +177,19 @@ module ActiveRecord #:nodoc:
   end
 
   class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
-    def initialize(*args)
-      super
-      options[:except] |= Array.wrap(@serializable.class.inheritance_column)
-    end
-
-    def add_extra_behavior
-      add_includes
-    end
-
-    def add_includes
-      procs = options.delete(:procs)
-      @serializable.send(:serializable_add_includes, options) do |association, records, opts|
-        add_associations(association, records, opts)
-      end
-      options[:procs] = procs
-    end
-
-    # TODO This can likely be cleaned up to simple use ActiveSupport::XmlMini.to_tag as well.
-    def add_associations(association, records, opts)
-      association_name = association.to_s.singularize
-      merged_options   = options.merge(opts).merge!(:root => association_name, :skip_instruct => true)
-
-      if records.is_a?(Enumerable)
-        tag  = ActiveSupport::XmlMini.rename_key(association.to_s, options)
-        type = options[:skip_types] ? { } : {:type => "array"}
-
-        if records.empty?
-          @builder.tag!(tag, type)
-        else
-          @builder.tag!(tag, type) do
-            records.each do |record|
-              if options[:skip_types]
-                record_type = {}
-              else
-                record_class = (record.class.to_s.underscore == association_name) ? nil : record.class.name
-                record_type = {:type => record_class}
-              end
-
-              record.to_xml merged_options.merge(record_type)
-            end
-          end
-        end
-      elsif record = @serializable.send(association)
-        record.to_xml(merged_options)
-      end
-    end
-
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
       def compute_type
-        type = @serializable.class.serialized_attributes.has_key?(name) ?
-          super : @serializable.class.columns_hash[name].type
+        klass = @serializable.class
+        type = if klass.serialized_attributes.key?(name)
+                 super
+               elsif klass.columns_hash.key?(name)
+                 klass.columns_hash[name].type
+               else
+                 NilClass
+               end
 
-        case type
-        when :text
-          :string
-        when :time
-          :datetime
-        else
-          type
-        end
+        { :text => :string,
+          :time => :datetime }[type] || type
       end
       protected :compute_type
     end

data/lib/active_record/statement_cache.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+
+  # Statement cache is used to cache a single statement in order to avoid creating the AST again.
+  # Initializing the cache is done by passing the statement in the initialization block:
+  #
+  #   cache = ActiveRecord::StatementCache.new do
+  #     Book.where(name: "my book").limit(100)
+  #   end
+  #
+  # The cached statement is executed by using the +execute+ method:
+  #
+  #   cache.execute
+  #
+  # The relation returned by the block is cached, and for each +execute+ call the cached relation gets duped.
+  # Database is queried when +to_a+ is called on the relation.
+  class StatementCache
+    def initialize
+      @relation = yield
+      raise ArgumentError.new("Statement cannot be nil") if @relation.nil?
+    end
+
+    def execute
+      @relation.dup.to_a
+    end
+  end
+end

data/lib/active_record/store.rb

@@ -0,0 +1,156 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActiveRecord
+  # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
+  # It's like a simple key/value store baked into your record when you don't care about being able to
+  # query that store outside the context of a single record.
+  #
+  # You can then declare accessors to this store that are then accessible just like any other attribute
+  # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
+  # already built around just accessing attributes on the model.
+  #
+  # Make sure that you declare the database column used for the serialized store as a text, so there's
+  # plenty of room.
+  #
+  # You can set custom coder to encode/decode your serialized attributes to/from different formats.
+  # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
+  #
+  # Examples:
+  #
+  #   class User < ActiveRecord::Base
+  #     store :settings, accessors: [ :color, :homepage ], coder: JSON
+  #   end
+  #
+  #   u = User.new(color: 'black', homepage: '37signals.com')
+  #   u.color                          # Accessor stored attribute
+  #   u.settings[:country] = 'Denmark' # Any attribute, even if not specified with an accessor
+  #
+  #   # There is no difference between strings and symbols for accessing custom attributes
+  #   u.settings[:country]  # => 'Denmark'
+  #   u.settings['country'] # => 'Denmark'
+  #
+  #   # Add additional accessors to an existing store through store_accessor
+  #   class SuperUser < User
+  #     store_accessor :settings, :privileges, :servants
+  #   end
+  #
+  # The stored attribute names can be retrieved using +stored_attributes+.
+  #
+  #   User.stored_attributes[:settings] # [:color, :homepage]
+  #
+  # == Overwriting default accessors
+  #
+  # All stored values are automatically available through accessors on the Active Record
+  # object, but sometimes you want to specialize this behavior. This can be done by overwriting
+  # the default accessors (using the same name as the attribute) and calling <tt>super</tt>
+  # to actually change things.
+  #
+  #   class Song < ActiveRecord::Base
+  #     # Uses a stored integer to hold the volume adjustment of the song
+  #     store :settings, accessors: [:volume_adjustment]
+  #
+  #     def volume_adjustment=(decibels)
+  #       super(decibels.to_i)
+  #     end
+  #
+  #     def volume_adjustment
+  #       super.to_i
+  #     end
+  #   end
+  module Store
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :stored_attributes, instance_accessor: false
+      self.stored_attributes = {}
+    end
+
+    module ClassMethods
+      def store(store_attribute, options = {})
+        serialize store_attribute, IndifferentCoder.new(options[:coder])
+        store_accessor(store_attribute, options[:accessors]) if options.has_key? :accessors
+      end
+
+      def store_accessor(store_attribute, *keys)
+        keys = keys.flatten
+
+        _store_accessors_module.module_eval do
+          keys.each do |key|
+            define_method("#{key}=") do |value|
+              write_store_attribute(store_attribute, key, value)
+            end
+
+            define_method(key) do
+              read_store_attribute(store_attribute, key)
+            end
+          end
+        end
+
+        self.stored_attributes[store_attribute] ||= []
+        self.stored_attributes[store_attribute] |= keys
+      end
+
+      def _store_accessors_module
+        @_store_accessors_module ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+    end
+
+    protected
+      def read_store_attribute(store_attribute, key)
+        attribute = initialize_store_attribute(store_attribute)
+        attribute[key]
+      end
+
+      def write_store_attribute(store_attribute, key, value)
+        attribute = initialize_store_attribute(store_attribute)
+        if value != attribute[key]
+          send :"#{store_attribute}_will_change!"
+          attribute[key] = value
+        end
+      end
+
+    private
+      def initialize_store_attribute(store_attribute)
+        attribute = send(store_attribute)
+        unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
+          attribute = IndifferentCoder.as_indifferent_hash(attribute)
+          send :"#{store_attribute}=", attribute
+        end
+        attribute
+      end
+
+    class IndifferentCoder # :nodoc:
+      def initialize(coder_or_class_name)
+        @coder =
+          if coder_or_class_name.respond_to?(:load) && coder_or_class_name.respond_to?(:dump)
+            coder_or_class_name
+          else
+            ActiveRecord::Coders::YAMLColumn.new(coder_or_class_name || Object)
+          end
+      end
+
+      def dump(obj)
+        @coder.dump self.class.as_indifferent_hash(obj)
+      end
+
+      def load(yaml)
+        self.class.as_indifferent_hash @coder.load(yaml)
+      end
+
+      def self.as_indifferent_hash(obj)
+        case obj
+        when ActiveSupport::HashWithIndifferentAccess
+          obj
+        when Hash
+          obj.with_indifferent_access
+        else
+          ActiveSupport::HashWithIndifferentAccess.new
+        end
+      end
+    end
+  end
+end