activerecord 3.2.6 → 6.0.0

data/lib/active_record.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2011 David Heinemeier Hansson
+# Copyright (c) 2004-2019 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,76 +23,93 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-require 'active_support'
-require 'active_support/i18n'
-require 'active_model'
-require 'arel'
+require "active_support"
+require "active_support/rails"
+require "active_model"
+require "arel"
+require "yaml"
 
-require 'active_record/version'
+require "active_record/version"
+require "active_model/attribute_set"
 
 module ActiveRecord
   extend ActiveSupport::Autoload
 
+  autoload :Base
+  autoload :Callbacks
+  autoload :Core
+  autoload :ConnectionHandling
+  autoload :CounterCache
+  autoload :DynamicMatchers
+  autoload :Enum
+  autoload :InternalMetadata
+  autoload :Explain
+  autoload :Inheritance
+  autoload :Integration
+  autoload :Migration
+  autoload :Migrator, "active_record/migration"
+  autoload :ModelSchema
+  autoload :NestedAttributes
+  autoload :NoTouching
+  autoload :TouchLater
+  autoload :Persistence
+  autoload :QueryCache
+  autoload :Querying
+  autoload :ReadonlyAttributes
+  autoload :RecordInvalid, "active_record/validations"
+  autoload :Reflection
+  autoload :RuntimeRegistry
+  autoload :Sanitization
+  autoload :Schema
+  autoload :SchemaDumper
+  autoload :SchemaMigration
+  autoload :Scoping
+  autoload :Serialization
+  autoload :StatementCache
+  autoload :Store
+  autoload :Suppressor
+  autoload :Timestamp
+  autoload :Transactions
+  autoload :Translation
+  autoload :Validations
+  autoload :SecureToken
+  autoload :DatabaseSelector, "active_record/middleware/database_selector"
+
   eager_autoload do
-    autoload :ActiveRecordError, 'active_record/errors'
-    autoload :ConnectionNotEstablished, 'active_record/errors'
-    autoload :ConnectionAdapters, 'active_record/connection_adapters/abstract_adapter'
+    autoload :ActiveRecordError, "active_record/errors"
+    autoload :ConnectionNotEstablished, "active_record/errors"
+    autoload :ConnectionAdapters, "active_record/connection_adapters/abstract_adapter"
 
     autoload :Aggregations
     autoload :Associations
-    autoload :AttributeMethods
     autoload :AttributeAssignment
+    autoload :AttributeMethods
     autoload :AutosaveAssociation
 
+    autoload :LegacyYamlAdapter
+
     autoload :Relation
+    autoload :AssociationRelation
+    autoload :NullRelation
 
-    autoload_under 'relation' do
+    autoload_under "relation" do
       autoload :QueryMethods
       autoload :FinderMethods
       autoload :Calculations
       autoload :PredicateBuilder
       autoload :SpawnMethods
       autoload :Batches
-      autoload :Explain
       autoload :Delegation
     end
 
-    autoload :Base
-    autoload :Callbacks
-    autoload :CounterCache
-    autoload :DynamicMatchers
-    autoload :DynamicFinderMatch
-    autoload :DynamicScopeMatch
-    autoload :Explain
-    autoload :IdentityMap
-    autoload :Inheritance
-    autoload :Integration
-    autoload :Migration
-    autoload :Migrator, 'active_record/migration'
-    autoload :ModelSchema
-    autoload :NestedAttributes
-    autoload :Observer
-    autoload :Persistence
-    autoload :QueryCache
-    autoload :Querying
-    autoload :ReadonlyAttributes
-    autoload :Reflection
     autoload :Result
-    autoload :Sanitization
-    autoload :Schema
-    autoload :SchemaDumper
-    autoload :Scoping
-    autoload :Serialization
-    autoload :SessionStore
-    autoload :Store
-    autoload :Timestamp
-    autoload :Transactions
-    autoload :Translation
-    autoload :Validations
+    autoload :TableMetadata
+    autoload :Type
   end
 
   module Coders
-    autoload :YAMLColumn, 'active_record/coders/yaml_column'
+    autoload :YAMLColumn, "active_record/coders/yaml_column"
+    autoload :JSON, "active_record/coders/json"
   end
 
   module AttributeMethods
@@ -105,7 +124,6 @@ module ActiveRecord
       autoload :TimeZoneConversion
       autoload :Write
       autoload :Serialization
-      autoload :DeprecatedUnderscoreRead
     end
   end
 
@@ -123,7 +141,6 @@ module ActiveRecord
 
     eager_autoload do
       autoload :AbstractAdapter
-      autoload :ConnectionManagement, "active_record/connection_adapters/abstract/connection_pool"
     end
   end
 
@@ -136,12 +153,43 @@ module ActiveRecord
     end
   end
 
-  autoload :TestCase
-  autoload :TestFixtures, 'active_record/fixtures'
+  module Middleware
+    extend ActiveSupport::Autoload
+
+    autoload :DatabaseSelector, "active_record/middleware/database_selector"
+  end
+
+  module Tasks
+    extend ActiveSupport::Autoload
+
+    autoload :DatabaseTasks
+    autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
+    autoload :MySQLDatabaseTasks,  "active_record/tasks/mysql_database_tasks"
+    autoload :PostgreSQLDatabaseTasks,
+      "active_record/tasks/postgresql_database_tasks"
+  end
+
+  autoload :TestDatabases, "active_record/test_databases"
+  autoload :TestFixtures, "active_record/fixtures"
+
+  def self.eager_load!
+    super
+    ActiveRecord::Locking.eager_load!
+    ActiveRecord::Scoping.eager_load!
+    ActiveRecord::Associations.eager_load!
+    ActiveRecord::AttributeMethods.eager_load!
+    ActiveRecord::ConnectionAdapters.eager_load!
+  end
 end
 
 ActiveSupport.on_load(:active_record) do
   Arel::Table.engine = self
 end
 
-I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.expand_path("active_record/locale/en.yml", __dir__)
+end
+
+YAML.load_tags["!ruby/object:ActiveRecord::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveRecord::Attribute::FromDatabase"] = "ActiveModel::Attribute::FromDatabase"
+YAML.load_tags["!ruby/object:ActiveRecord::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"

data/lib/arel/alias_predication.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module AliasPredication
+    def as(other)
+      Nodes::As.new self, Nodes::SqlLiteral.new(other)
+    end
+  end
+end

data/lib/arel/attributes/attribute.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Attributes
+    class Attribute < Struct.new :relation, :name
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+      include Arel::Math
+
+      ###
+      # Create a node for lowering this attribute
+      def lower
+        relation.lower self
+      end
+
+      def type_cast_for_database(value)
+        relation.type_cast_for_database(name, value)
+      end
+
+      def able_to_type_cast?
+        relation.able_to_type_cast?
+      end
+    end
+
+    class String    < Attribute; end
+    class Time      < Attribute; end
+    class Boolean   < Attribute; end
+    class Decimal   < Attribute; end
+    class Float     < Attribute; end
+    class Integer   < Attribute; end
+    class Undefined < Attribute; end
+  end
+
+  Attribute = Attributes::Attribute
+end

data/lib/arel/attributes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "arel/attributes/attribute"
+
+module Arel # :nodoc: all
+  module Attributes
+    ###
+    # Factory method to wrap a raw database +column+ to an Arel Attribute.
+    def self.for(column)
+      case column.type
+      when :string, :text, :binary             then String
+      when :integer                            then Integer
+      when :float                              then Float
+      when :decimal                            then Decimal
+      when :date, :datetime, :timestamp, :time then Time
+      when :boolean                            then Boolean
+      else
+        Undefined
+      end
+    end
+  end
+end

data/lib/arel/collectors/bind.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Bind
+      def initialize
+        @binds = []
+      end
+
+      def <<(str)
+        self
+      end
+
+      def add_bind(bind)
+        @binds << bind
+        self
+      end
+
+      def value
+        @binds
+      end
+    end
+  end
+end

data/lib/arel/collectors/composite.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Composite
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def <<(str)
+        left << str
+        right << str
+        self
+      end
+
+      def add_bind(bind, &block)
+        left.add_bind bind, &block
+        right.add_bind bind, &block
+        self
+      end
+
+      def value
+        [left.value, right.value]
+      end
+
+      private
+        attr_reader :left, :right
+    end
+  end
+end

data/lib/arel/collectors/plain_string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class PlainString
+      def initialize
+        @str = +""
+      end
+
+      def value
+        @str
+      end
+
+      def <<(str)
+        @str << str
+        self
+      end
+    end
+  end
+end

data/lib/arel/collectors/sql_string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "arel/collectors/plain_string"
+
+module Arel # :nodoc: all
+  module Collectors
+    class SQLString < PlainString
+      def initialize(*)
+        super
+        @bind_index = 1
+      end
+
+      def add_bind(bind)
+        self << yield(@bind_index)
+        @bind_index += 1
+        self
+      end
+    end
+  end
+end

data/lib/arel/collectors/substitute_binds.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class SubstituteBinds
+      def initialize(quoter, delegate_collector)
+        @quoter = quoter
+        @delegate = delegate_collector
+      end
+
+      def <<(str)
+        delegate << str
+        self
+      end
+
+      def add_bind(bind)
+        self << quoter.quote(bind)
+      end
+
+      def value
+        delegate.value
+      end
+
+      private
+        attr_reader :quoter, :delegate
+    end
+  end
+end

data/lib/arel/crud.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  ###
+  # FIXME hopefully we can remove this
+  module Crud
+    def compile_update(values, pk)
+      um = UpdateManager.new
+
+      if Nodes::SqlLiteral === values
+        relation = @ctx.from
+      else
+        relation = values.first.first.relation
+      end
+      um.key = pk
+      um.table relation
+      um.set values
+      um.take @ast.limit.expr if @ast.limit
+      um.order(*@ast.orders)
+      um.wheres = @ctx.wheres
+      um
+    end
+
+    def compile_insert(values)
+      im = create_insert
+      im.insert values
+      im
+    end
+
+    def create_insert
+      InsertManager.new
+    end
+
+    def compile_delete
+      dm = DeleteManager.new
+      dm.take @ast.limit.expr if @ast.limit
+      dm.wheres = @ctx.wheres
+      dm.from @ctx.froms
+      dm
+    end
+  end
+end

data/lib/arel/delete_manager.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class DeleteManager < Arel::TreeManager
+    include TreeManager::StatementMethods
+
+    def initialize
+      super
+      @ast = Nodes::DeleteStatement.new
+      @ctx = @ast
+    end
+
+    def from(relation)
+      @ast.relation = relation
+      self
+    end
+  end
+end

data/lib/arel/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class ArelError < StandardError
+  end
+
+  class EmptyJoinError < ArelError
+  end
+end

data/lib/arel/expressions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Expressions
+    def count(distinct = false)
+      Nodes::Count.new [self], distinct
+    end
+
+    def sum
+      Nodes::Sum.new [self]
+    end
+
+    def maximum
+      Nodes::Max.new [self]
+    end
+
+    def minimum
+      Nodes::Min.new [self]
+    end
+
+    def average
+      Nodes::Avg.new [self]
+    end
+
+    def extract(field)
+      Nodes::Extract.new [self], field
+    end
+  end
+end

data/lib/arel/factory_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  ###
+  # Methods for creating various nodes
+  module FactoryMethods
+    def create_true
+      Arel::Nodes::True.new
+    end
+
+    def create_false
+      Arel::Nodes::False.new
+    end
+
+    def create_table_alias(relation, name)
+      Nodes::TableAlias.new(relation, name)
+    end
+
+    def create_join(to, constraint = nil, klass = Nodes::InnerJoin)
+      klass.new(to, constraint)
+    end
+
+    def create_string_join(to)
+      create_join to, nil, Nodes::StringJoin
+    end
+
+    def create_and(clauses)
+      Nodes::And.new clauses
+    end
+
+    def create_on(expr)
+      Nodes::On.new expr
+    end
+
+    def grouping(expr)
+      Nodes::Grouping.new expr
+    end
+
+    ###
+    # Create a LOWER() function
+    def lower(column)
+      Nodes::NamedFunction.new "LOWER", [Nodes.build_quoted(column)]
+    end
+
+    def coalesce(*exprs)
+      Nodes::NamedFunction.new "COALESCE", exprs
+    end
+  end
+end

data/lib/arel/insert_manager.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class InsertManager < Arel::TreeManager
+    def initialize
+      super
+      @ast = Nodes::InsertStatement.new
+    end
+
+    def into(table)
+      @ast.relation = table
+      self
+    end
+
+    def columns; @ast.columns end
+    def values=(val); @ast.values = val; end
+
+    def select(select)
+      @ast.select = select
+    end
+
+    def insert(fields)
+      return if fields.empty?
+
+      if String === fields
+        @ast.values = Nodes::SqlLiteral.new(fields)
+      else
+        @ast.relation ||= fields.first.first.relation
+
+        values = []
+
+        fields.each do |column, value|
+          @ast.columns << column
+          values << value
+        end
+        @ast.values = create_values(values)
+      end
+      self
+    end
+
+    def create_values(values)
+      Nodes::ValuesList.new([values])
+    end
+
+    def create_values_list(rows)
+      Nodes::ValuesList.new(rows)
+    end
+  end
+end

data/lib/arel/math.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Math
+    def *(other)
+      Arel::Nodes::Multiplication.new(self, other)
+    end
+
+    def +(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new(self, other))
+    end
+
+    def -(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+    end
+
+    def /(other)
+      Arel::Nodes::Division.new(self, other)
+    end
+
+    def &(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseAnd.new(self, other))
+    end
+
+    def |(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseOr.new(self, other))
+    end
+
+    def ^(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseXor.new(self, other))
+    end
+
+    def <<(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftLeft.new(self, other))
+    end
+
+    def >>(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftRight.new(self, other))
+    end
+
+    def ~@
+      Arel::Nodes::BitwiseNot.new(self)
+    end
+  end
+end

data/lib/arel/nodes/and.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class And < Arel::Nodes::NodeExpression
+      attr_reader :children
+
+      def initialize(children)
+        super()
+        @children = children
+      end
+
+      def left
+        children.first
+      end
+
+      def right
+        children[1]
+      end
+
+      def hash
+        children.hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.children == other.children
+      end
+      alias :== :eql?
+    end
+  end
+end