activerecord 3.2.19 → 5.0.0

data/lib/active_record/statement_cache.rb

@@ -0,0 +1,113 @@
+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 create block:
+  #
+  #   cache = StatementCache.create(Book.connection) do |params|
+  #     Book.where(name: "my book").where("author_id > 3")
+  #   end
+  #
+  # The cached statement is executed by using the
+  # [connection.execute]{rdoc-ref:ConnectionAdapters::DatabaseStatements#execute} method:
+  #
+  #   cache.execute([], Book, Book.connection)
+  #
+  # The relation returned by the block is cached, and for each
+  # [execute]{rdoc-ref:ConnectionAdapters::DatabaseStatements#execute}
+  # call the cached relation gets duped. Database is queried when +to_a+ is called on the relation.
+  #
+  # If you want to cache the statement without the values you can use the +bind+ method of the
+  # block parameter.
+  #
+  #   cache = StatementCache.create(Book.connection) do |params|
+  #     Book.where(name: params.bind)
+  #   end
+  #
+  # And pass the bind values as the first argument of +execute+ call.
+  #
+  #   cache.execute(["my book"], Book, Book.connection)
+  class StatementCache # :nodoc:
+    class Substitute; end # :nodoc:
+
+    class Query # :nodoc:
+      def initialize(sql)
+        @sql = sql
+      end
+
+      def sql_for(binds, connection)
+        @sql
+      end
+    end
+
+    class PartialQuery < Query # :nodoc:
+      def initialize values
+        @values = values
+        @indexes = values.each_with_index.find_all { |thing,i|
+          Arel::Nodes::BindParam === thing
+        }.map(&:last)
+      end
+
+      def sql_for(binds, connection)
+        val = @values.dup
+        binds = connection.prepare_binds_for_database(binds)
+        @indexes.each { |i| val[i] = connection.quote(binds.shift) }
+        val.join
+      end
+    end
+
+    def self.query(visitor, ast)
+      Query.new visitor.accept(ast, Arel::Collectors::SQLString.new).value
+    end
+
+    def self.partial_query(visitor, ast, collector)
+      collected = visitor.accept(ast, collector).value
+      PartialQuery.new collected
+    end
+
+    class Params # :nodoc:
+      def bind; Substitute.new; end
+    end
+
+    class BindMap # :nodoc:
+      def initialize(bound_attributes)
+        @indexes   = []
+        @bound_attributes = bound_attributes
+
+        bound_attributes.each_with_index do |attr, i|
+          if Substitute === attr.value
+            @indexes << i
+          end
+        end
+      end
+
+      def bind(values)
+        bas = @bound_attributes.dup
+        @indexes.each_with_index { |offset,i| bas[offset] = bas[offset].with_cast_value(values[i]) }
+        bas
+      end
+    end
+
+    attr_reader :bind_map, :query_builder
+
+    def self.create(connection, block = Proc.new)
+      relation      = block.call Params.new
+      bind_map      = BindMap.new relation.bound_attributes
+      query_builder = connection.cacheable_query relation.arel
+      new query_builder, bind_map
+    end
+
+    def initialize(query_builder, bind_map)
+      @query_builder = query_builder
+      @bind_map      = bind_map
+    end
+
+    def execute(params, klass, connection)
+      bind_values = bind_map.bind params
+
+      sql = query_builder.sql_for bind_values, connection
+
+      klass.find_by_sql(sql, bind_values, preparable: true)
+    end
+    alias :call :execute
+  end
+end

data/lib/active_record/store.rb

@@ -1,6 +1,8 @@
+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 backed into your record when you don't care about being able to
+  # 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
@@ -10,43 +12,199 @@ module ActiveRecord
   # 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+.
+  #
+  # NOTE: If you are using PostgreSQL specific columns like +hstore+ or +json+ there is no need for
+  # the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
+  # Simply use {.store_accessor}[rdoc-ref:ClassMethods#store_accessor] instead to generate
+  # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
+  # using a symbol.
+  #
+  # NOTE: The default validations with the exception of +uniqueness+ will work.
+  # For example, if you want to check for +uniqueness+ with +hstore+ you will
+  # need to use a custom validation to handle it.
+  #
   # Examples:
   #
   #   class User < ActiveRecord::Base
-  #     store :settings, accessors: [ :color, :homepage ]
+  #     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}[rdoc-ref:rdoc-ref:ClassMethods#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 << self
+        attr_accessor :local_stored_attributes
+      end
+    end
+
     module ClassMethods
       def store(store_attribute, options = {})
-        serialize store_attribute, Hash
+        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)
-        Array(keys).flatten.each do |key|
-          define_method("#{key}=") do |value|
-            send("#{store_attribute}=", {}) unless send(store_attribute).is_a?(Hash)
-            send("#{store_attribute}_will_change!")
-            send(store_attribute)[key] = value
+        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
+
+        # assign new store attribute and create new hash to ensure that each class in the hierarchy
+        # has its own hash of stored attributes.
+        self.local_stored_attributes ||= {}
+        self.local_stored_attributes[store_attribute] ||= []
+        self.local_stored_attributes[store_attribute] |= keys
+      end
+
+      def _store_accessors_module # :nodoc:
+        @_store_accessors_module ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+
+      def stored_attributes
+        parent = superclass.respond_to?(:stored_attributes) ? superclass.stored_attributes : {}
+        if self.local_stored_attributes
+          parent.merge!(self.local_stored_attributes) { |k, a, b| a | b }
+        end
+        parent
+      end
+    end
+
+    protected
+      def read_store_attribute(store_attribute, key)
+        accessor = store_accessor_for(store_attribute)
+        accessor.read(self, store_attribute, key)
+      end
+
+      def write_store_attribute(store_attribute, key, value)
+        accessor = store_accessor_for(store_attribute)
+        accessor.write(self, store_attribute, key, value)
+      end
+
+    private
+      def store_accessor_for(store_attribute)
+        type_for_attribute(store_attribute.to_s).accessor
+      end
+
+      class HashAccessor # :nodoc:
+        def self.read(object, attribute, key)
+          prepare(object, attribute)
+          object.public_send(attribute)[key]
+        end
+
+        def self.write(object, attribute, key, value)
+          prepare(object, attribute)
+          if value != read(object, attribute, key)
+            object.public_send :"#{attribute}_will_change!"
+            object.public_send(attribute)[key] = value
+          end
+        end
+
+        def self.prepare(object, attribute)
+          object.public_send :"#{attribute}=", {} unless object.send(attribute)
+        end
+      end
+
+      class StringKeyedHashAccessor < HashAccessor # :nodoc:
+        def self.read(object, attribute, key)
+          super object, attribute, key.to_s
+        end
+
+        def self.write(object, attribute, key, value)
+          super object, attribute, key.to_s, value
+        end
+      end
+
+      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
+        def self.prepare(object, store_attribute)
+          attribute = object.send(store_attribute)
+          unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            attribute = IndifferentCoder.as_indifferent_hash(attribute)
+            object.send :"#{store_attribute}=", attribute
           end
-    
-          define_method(key) do
-            send("#{store_attribute}=", {}) unless send(store_attribute).is_a?(Hash)
-            send(store_attribute)[key]
+          attribute
+        end
+      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
+end

data/lib/active_record/suppressor.rb

@@ -0,0 +1,58 @@
+module ActiveRecord
+  # ActiveRecord::Suppressor prevents the receiver from being saved during
+  # a given block.
+  #
+  # For example, here's a pattern of creating notifications when new comments
+  # are posted. (The notification may in turn trigger an email, a push
+  # notification, or just appear in the UI somewhere):
+  #
+  #   class Comment < ActiveRecord::Base
+  #     belongs_to :commentable, polymorphic: true
+  #     after_create -> { Notification.create! comment: self,
+  #       recipients: commentable.recipients }
+  #   end
+  #
+  # That's what you want the bulk of the time. New comment creates a new
+  # Notification. But there may well be off cases, like copying a commentable
+  # and its comments, where you don't want that. So you'd have a concern
+  # something like this:
+  #
+  #   module Copyable
+  #     def copy_to(destination)
+  #       Notification.suppress do
+  #         # Copy logic that creates new comments that we do not want
+  #         # triggering notifications.
+  #       end
+  #     end
+  #   end
+  module Suppressor
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def suppress(&block)
+        SuppressorRegistry.suppressed[name] = true
+        yield
+      ensure
+        SuppressorRegistry.suppressed[name] = false
+      end
+    end
+
+    def save(*) # :nodoc:
+      SuppressorRegistry.suppressed[self.class.name] ? true : super
+    end
+
+    def save!(*) # :nodoc:
+      SuppressorRegistry.suppressed[self.class.name] ? true : super
+    end
+  end
+
+  class SuppressorRegistry # :nodoc:
+    extend ActiveSupport::PerThreadRegistry
+
+    attr_reader :suppressed
+
+    def initialize
+      @suppressed = {}
+    end
+  end
+end

data/lib/active_record/table_metadata.rb

@@ -0,0 +1,68 @@
+module ActiveRecord
+  class TableMetadata # :nodoc:
+    delegate :foreign_type, :foreign_key, to: :association, prefix: true
+    delegate :association_primary_key, to: :association
+
+    def initialize(klass, arel_table, association = nil)
+      @klass = klass
+      @arel_table = arel_table
+      @association = association
+    end
+
+    def resolve_column_aliases(hash)
+      # This method is a hot spot, so for now, use Hash[] to dup the hash.
+      #   https://bugs.ruby-lang.org/issues/7166
+      new_hash = Hash[hash]
+      hash.each do |key, _|
+        if (key.is_a?(Symbol)) && klass.attribute_alias?(key)
+          new_hash[klass.attribute_alias(key)] = new_hash.delete(key)
+        end
+      end
+      new_hash
+    end
+
+    def arel_attribute(column_name)
+      if klass
+        klass.arel_attribute(column_name, arel_table)
+      else
+        arel_table[column_name]
+      end
+    end
+
+    def type(column_name)
+      if klass
+        klass.type_for_attribute(column_name.to_s)
+      else
+        Type::Value.new
+      end
+    end
+
+    def associated_with?(association_name)
+      klass && klass._reflect_on_association(association_name)
+    end
+
+    def associated_table(table_name)
+      return self if table_name == arel_table.name
+
+      association = klass._reflect_on_association(table_name)
+      if association && !association.polymorphic?
+        association_klass = association.klass
+        arel_table = association_klass.arel_table.alias(table_name)
+      else
+        type_caster = TypeCaster::Connection.new(klass, table_name)
+        association_klass = nil
+        arel_table = Arel::Table.new(table_name, type_caster: type_caster)
+      end
+
+      TableMetadata.new(association_klass, arel_table, association)
+    end
+
+    def polymorphic_association?
+      association && association.polymorphic?
+    end
+
+    protected
+
+    attr_reader :klass, :arel_table, :association
+  end
+end