activerecord 6.0.1

data/lib/active_record/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActiveRecord
+  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
+  def self.version
+    gem_version
+  end
+end

data/lib/arel.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "arel/errors"
+
+require "arel/crud"
+require "arel/factory_methods"
+
+require "arel/expressions"
+require "arel/predications"
+require "arel/window_predications"
+require "arel/math"
+require "arel/alias_predication"
+require "arel/order_predications"
+require "arel/table"
+require "arel/attributes"
+
+require "arel/visitors"
+require "arel/collectors/sql_string"
+
+require "arel/tree_manager"
+require "arel/insert_manager"
+require "arel/select_manager"
+require "arel/update_manager"
+require "arel/delete_manager"
+require "arel/nodes"
+
+module Arel
+  VERSION = "10.0.0"
+
+  # Wrap a known-safe SQL string for passing to query methods, e.g.
+  #
+  #   Post.order(Arel.sql("length(title)")).last
+  #
+  # Great caution should be taken to avoid SQL injection vulnerabilities.
+  # This method should not be used with unsafe values such as request
+  # parameters or model attributes.
+  def self.sql(raw_sql)
+    Arel::Nodes::SqlLiteral.new raw_sql
+  end
+
+  def self.star # :nodoc:
+    sql "*"
+  end
+
+  def self.arel_node?(value) # :nodoc:
+    value.is_a?(Arel::Node) || value.is_a?(Arel::Attribute) || value.is_a?(Arel::Nodes::SqlLiteral)
+  end
+
+  def self.fetch_attribute(value) # :nodoc:
+    case value
+    when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
+      yield value.left.is_a?(Arel::Attributes::Attribute) ? value.left : value.right
+    end
+  end
+
+  ## Convenience Alias
+  Node = Arel::Nodes::Node # :nodoc:
+end

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.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/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/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