arel_extensions 1.7.0 → 2.0.0.rc3

data/lib/arel_extensions/visitors.rb

@@ -1,102 +1,81 @@
-# MSSQL visitors for java and rails ≥ 7 are painful to work with:
-# requiring the exact path to the visitor is needed even if the
-# AR adapter was loaded. It's also needed exactly here because:
-# 1. putting it inside the visitor or anywhere else will not
-#    guarantee its actual loading.
-# 2. it needs to load before arel_extensions/visitors.
-if RUBY_PLATFORM == 'java' \
-  && RUBY_ENGINE == 'jruby' \
-  && (version = JRUBY_VERSION.split('.').map(&:to_i)) && version[0] == 9 && version[1] >= 4 \
-  && Gem::Specification.find { |g| g.name == 'jdbc-mssql' }
-  begin
-    require 'arel/visitors/sqlserver'
-  rescue LoadError
-    warn 'arel/visitors/sqlserver not found: MSSQL might not work correctly.'
-  end
-elsif RUBY_PLATFORM != 'java' \
-  && ArelExtensions::AREL_VERSION < ArelExtensions::V10 \
-  && Gem::Specification.find { |g| g.name == 'activerecord-sqlserver-adapter' }
-  begin
-    require 'arel_sqlserver'
-  rescue LoadError
-    warn 'arel_sqlserver not found: SQLServer Visitor might not work correctly.'
-  end
-end
-
-require 'arel_extensions/visitors/convert_format'
 require 'arel_extensions/visitors/to_sql'
 require 'arel_extensions/visitors/mysql'
-require 'arel_extensions/visitors/mssql'
+require 'arel_extensions/visitors/oracle'
+require 'arel_extensions/visitors/oracle12'
 require 'arel_extensions/visitors/postgresql'
 require 'arel_extensions/visitors/sqlite'
+require 'arel_extensions/visitors/mssql'
 
-if defined?(Arel::Visitors::Oracle)
-  require 'arel_extensions/visitors/oracle'
-  require 'arel_extensions/visitors/oracle12'
-end
-
-if defined?(Arel::Visitors::SQLServer)
-  class Arel::Visitors::SQLServer
-    include ArelExtensions::Visitors::MSSQL
-  end
-end
+Arel::Visitors::MSSQL.class_eval do
+  include ArelExtensions::Visitors::MSSQL
 
-if defined?(Arel::Visitors::DepthFirst)
-  class Arel::Visitors::DepthFirst
-    def visit_Arel_SelectManager(o)
-      visit o.ast
+  alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
+  def visit_Arel_Nodes_As o, collector
+    if o.left.is_a?(Arel::Nodes::Binary)
+      collector << '('
+      collector = visit o.left, collector
+      collector << ')'
+    else
+      collector = visit o.left, collector
     end
+    collector << " AS ["
+    collector = visit o.right, collector
+    collector << "]"
+    collector
   end
-end
 
-if defined?(Arel::Visitors::MSSQL)
-  class Arel::Visitors::MSSQL
-    include ArelExtensions::Visitors::MSSQL
-
-    alias old_visit_Arel_Nodes_SelectStatement visit_Arel_Nodes_SelectStatement
-    def visit_Arel_Nodes_SelectStatement(o, collector)
-      if !collector.value.blank? && o.limit.blank? && o.offset.blank?
-        o = o.dup
-        o.orders = []
-      end
-      old_visit_Arel_Nodes_SelectStatement(o, collector)
+  alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+  def visit_Arel_Nodes_SelectStatement o, collector
+    if !collector.value.blank? && o.limit.blank? && o.offset.blank?
+      o = o.dup
+      o.orders = []
     end
+    old_visit_Arel_Nodes_SelectStatement(o,collector)
   end
 end
 
-if defined?(Arel::Visitors::SQLServer)
-  class Arel::Visitors::SQLServer
-    include ArelExtensions::Visitors::MSSQL
+begin
+  require 'arel_sqlserver'
+  if Arel::VERSION.to_i == 6
+    if Arel::Visitors::VISITORS['sqlserver'] && Arel::Visitors::VISITORS['sqlserver'] != Arel::Visitors::MSSQL
+      Arel::Visitors::VISITORS['sqlserver'].class_eval do
+        include ArelExtensions::Visitors::MSSQL
 
-    # There's a bug when working with jruby 9.4 that prevents us from
-    # refactoring this and putting it in the main module, or even in a separate
-    # module then including it.
-    #
-    # Reason: the line in this file that does:
-    #
-    #   require 'arel_extensions/visitors/mssql'
-    #
-    # The error could be seen by:
-    #
-    #   1. placing the visit_ inside the visitor, or placing it in a module
-    #      then including it here.
-    #   2. replacing the `rescue nil` from aliasing trick, and printing the
-    #      error.
-    #
-    # It complains that the visit_ does not exist in the module, as if it's
-    # evaluating the module eagerly, instead of lazily like in other versions
-    # of ruby.
-    #
-    # It might be something different, but this is the first thing we should
-    # investigate.
+        alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+        def visit_Arel_Nodes_SelectStatement o, collector
+          if !collector.value.blank? && o.limit.blank? && o.offset.blank?
+            o = o.dup
+            o.orders = []
+          end
+          old_visit_Arel_Nodes_SelectStatement(o,collector)
+        end
 
-    alias old_visit_Arel_Nodes_SelectStatement visit_Arel_Nodes_SelectStatement rescue nil
-    def visit_Arel_Nodes_SelectStatement(o, collector)
-      if !collector.value.blank? && o.limit.blank? && o.offset.blank?
-        o = o.dup
-        o.orders = []
+        alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
+        def visit_Arel_Nodes_As o, collector
+          if o.left.is_a?(Arel::Nodes::Binary)
+            collector << '('
+            collector = visit o.left, collector
+            collector << ')'
+          else
+            collector = visit o.left, collector
+          end
+          collector << " AS ["
+          collector = visit o.right, collector
+          collector << "]"
+          collector
+        end
+
+        alias_method :old_primary_Key_From_Table, :primary_Key_From_Table
+        def primary_Key_From_Table t
+          return unless t
+          column_name = @connection.schema_cache.primary_keys(t.name) ||
+            @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+          column_name ? t[column_name] : nil
+        end
       end
-      old_visit_Arel_Nodes_SelectStatement(o, collector)
     end
   end
+  rescue LoadError
+rescue => e
+    e
 end

data/lib/arel_extensions.rb

@@ -1,8 +1,4 @@
-# frozen_string_literal: true
-
 require 'arel'
-require 'arel_extensions/constants'
-require 'base64'
 
 require 'arel_extensions/railtie' if defined?(Rails::Railtie)
 
@@ -11,54 +7,41 @@ require 'arel_extensions/railtie' if defined?(Rails::Railtie)
 # Count|NamedFunction < Function < Arel::Nodes::Node
 
 # pure Arel internals improvements
-class Arel::Nodes::Binary
+Arel::Nodes::Binary.class_eval do
   include Arel::AliasPredication
   include Arel::Expressions
 end
 
-class Arel::Nodes::Casted
+Arel::Nodes::Casted.class_eval do
   include Arel::AliasPredication
-
-  # They forget to define hash.
-  if ArelExtensions::AREL_VERSION < ArelExtensions::V10
-    def hash
-      [self.class, val, attribute].hash
-    end
-  end
 end
 
-class Arel::Nodes::Unary
+Arel::Nodes::Unary.class_eval do
   include Arel::Math
   include Arel::AliasPredication
   include Arel::Expressions
 end
 
-class Arel::Nodes::Grouping
+Arel::Nodes::Grouping.class_eval do
+  include Arel::Math
+  include Arel::AliasPredication
   include Arel::OrderPredications
+  include Arel::Expressions
 end
 
-class Arel::Nodes::Ordering
-  def eql?(other)
-    hash.eql? other.hash
-  end
-end
-
-class Arel::Nodes::Function
+Arel::Nodes::Function.class_eval do
   include Arel::Math
   include Arel::Expressions
 end
 
-if ArelExtensions::AREL_VERSION >= ArelExtensions::V7_1
-  class Arel::Nodes::Case
+if Arel::VERSION >= "7.1.0"
+  Arel::Nodes::Case.class_eval do
     include Arel::Math
     include Arel::Expressions
   end
 end
 
-require 'arel_extensions/warning'
-require 'arel_extensions/helpers'
 require 'arel_extensions/version'
-require 'arel_extensions/aliases'
 require 'arel_extensions/attributes'
 require 'arel_extensions/visitors'
 require 'arel_extensions/nodes'
@@ -82,117 +65,42 @@ require 'arel_extensions/nodes/case'
 require 'arel_extensions/nodes/soundex'
 require 'arel_extensions/nodes/cast'
 require 'arel_extensions/nodes/json'
-require 'arel_extensions/nodes/rollup'
-require 'arel_extensions/nodes/select'
 
-# It seems like the code in lib/arel_extensions/visitors.rb that is supposed
-# to inject ArelExtension is not enough. Different versions of the sqlserver
-# adapter behave differently. It doesn't always proc, so we added this for
-# coverage.
-if defined?(Arel::Visitors::SQLServer)
-  Arel::Visitors.const_set(:MSSQL, Arel::Visitors::SQLServer)
-  require 'arel_extensions/visitors/mssql'
-  class Arel::Visitors::SQLServer
-    include ArelExtensions::Visitors::MSSQL
-  end
-end
 
-module Arel
-  def self.column_of(table_name, column_name)
-    ArelExtensions.column_of(table_name, column_name)
-  end
-
-  def self.duration(s, expr)
-    ArelExtensions::Nodes::Duration.new("#{s}i", expr)
-  end
-
-  # The FALSE pseudo literal.
-  def self.false
-    Arel::Nodes::Equality.new(1, 0)
-  end
-
-  def self.grouping(*v)
-    Arel::Nodes::Grouping.new(*v)
-  end
-
-  def self.json(*expr)
-    ArelExtensions::Nodes::Json.new(
-      if expr.length == 1
-        expr.first
-      else
-        expr
-      end
-    )
-  end
-
-  def self.json_true
-    res = Arel.grouping(Arel.quoted('true'))
-    res.instance_eval {
-      def return_type
-        :boolean
-      end
-    }
-    res
-  end
-
-  def self.json_false
-    res = Arel.grouping(Arel.quoted('false'))
-    res.instance_eval {
-      def return_type
-        :boolean
-      end
-    }
-    res
-  end
-
-  # The NULL literal.
-  def self.null
-    Arel.quoted(nil)
-  end
-
-  def self.quoted(*args)
-    Arel::Nodes.build_quoted(*args)
-  end
 
+module Arel
   def self.rand
     ArelExtensions::Nodes::Rand.new
   end
 
-  def self.rollup(*args)
-    Arel::Nodes::RollUp.new(args)
-  end
-
-  def self.shorten(s)
+  def self.shorten s
     Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
   end
 
-  # The TRUE pseudo literal.
-  def self.true
-    Arel::Nodes::Equality.new(1, 1)
+  def self.json *expr
+    if expr.length == 1
+      ArelExtensions::Nodes::Json.new(expr.first)
+    else
+      ArelExtensions::Nodes::Json.new(expr)
+    end
   end
 
-  def self.tuple(*v)
-    tmp = Arel.grouping(nil)
-    Arel.grouping(v.map { |e| tmp.convert_to_node(e) })
+  def self.when condition
+    ArelExtensions::Nodes::Case.new.when(condition)
   end
 
-  # For instance
-  #
-  # ```
-  # Arel.when(at[field].is_null).then(0).else(1)
-  # ```
-  def self.when(condition)
-    ArelExtensions::Nodes::Case.new.when(condition)
+  def self.duration s, expr
+    ArelExtensions::Nodes::Duration.new(s.to_s+'i',expr)
   end
+
 end
 
-class Arel::Attributes::Attribute
+Arel::Attributes::Attribute.class_eval do
   include Arel::Math
   include ArelExtensions::Attributes
 end
 
-class Arel::Nodes::Function
-  include ArelExtensions::Aliases
+Arel::Nodes::Function.class_eval do
   include ArelExtensions::Math
   include ArelExtensions::Comparators
   include ArelExtensions::DateDuration
@@ -201,163 +109,44 @@ class Arel::Nodes::Function
   include ArelExtensions::BooleanFunctions
   include ArelExtensions::NullFunctions
   include ArelExtensions::Predications
-
-  if ArelExtensions::ACTIVE_RECORD_VERSION >= ArelExtensions::V8_1
-    attr_accessor :alias
-    alias old_initialize initialize
-
-    def initialize(expr, aliaz = nil)
-      old_initialize(expr)
-      self.alias = aliaz
-    end
-  end
-
-  alias old_as as rescue nil
-  def as(other)
-    res = Arel::Nodes::As.new(clone, Arel.sql(other))
-    self.alias = Arel.sql(other)
-    res
-  end
-end
-
-class Arel::Nodes::Grouping
-  include ArelExtensions::Math
-  include ArelExtensions::Comparators
-  include ArelExtensions::DateDuration
-  include ArelExtensions::MathFunctions
-  include ArelExtensions::NullFunctions
-  include ArelExtensions::StringFunctions
-  include ArelExtensions::Predications
 end
 
-class Arel::Nodes::Unary
+Arel::Nodes::Unary.class_eval do
   include ArelExtensions::Math
   include ArelExtensions::Attributes
   include ArelExtensions::MathFunctions
   include ArelExtensions::Comparators
   include ArelExtensions::Predications
-
-  def eql?(other)
-    hash == other.hash
-  end
 end
 
-class Arel::Nodes::Binary
+Arel::Nodes::Binary.class_eval do
   include ArelExtensions::Math
   include ArelExtensions::Attributes
   include ArelExtensions::MathFunctions
   include ArelExtensions::Comparators
   include ArelExtensions::BooleanFunctions
   include ArelExtensions::Predications
-
-  def eql?(other)
-    hash == other.hash
-  end
 end
 
-class Arel::Nodes::Equality
+Arel::Nodes::Equality.class_eval do
   include ArelExtensions::Comparators
   include ArelExtensions::DateDuration
   include ArelExtensions::MathFunctions
   include ArelExtensions::StringFunctions
 end
 
-class Arel::InsertManager
+
+Arel::InsertManager.class_eval do
   include ArelExtensions::InsertManager
 end
 
-class Arel::SelectManager
+Arel::SelectManager.class_eval do
   include ArelExtensions::SetFunctions
   include ArelExtensions::Nodes
-
-  remove_method(:as) if method_defined?(:as)
-  def as(table_name)
-    Arel::Nodes::TableAlias.new(self, table_name)
-  end
-
-  # Install an alias, if present.
-  def xas(table_name)
-    if table_name.present?
-      as table_name
-    else
-      self
-    end
-  end
 end
 
-class Arel::Nodes::As
+Arel::Nodes::As.class_eval do
   include ArelExtensions::Nodes
 end
 
-class Arel::Table
-  alias old_alias alias rescue nil
-
-  # activerecord 7.1 removed the alias. We might need to remove our dependency
-  # on the alias if it proves problematic.
-  if !respond_to?(:table_name)
-    alias table_name name
-  end
 
-  def alias(name = "#{self.name}_2")
-    if name.present?
-      Arel::Nodes::TableAlias.new(self, name)
-    else
-      self
-    end
-  end
-end
-
-class Arel::Nodes::TableAlias
-  def method_missing(*args)
-    met = args.shift.to_sym
-    if relation.respond_to?(met)
-      relation.send(met, args)
-    else
-      super(met, *args)
-    end
-  end
-
-  def respond_to_missing?(method_name, include_private = false)
-    relation.respond_to?(method_name) || super
-  end
-end
-
-class Arel::Attributes::Attribute
-  def to_sql(engine = Arel::Table.engine)
-    collector = Arel::Collectors::SQLString.new
-    collector = engine.connection.visitor.accept self, collector
-    collector.value
-  end
-
-  def rollup
-    Arel::Nodes::RollUp.new([self])
-  end
-end
-
-class Arel::Nodes::Node
-  def rollup
-    Arel::Nodes::RollUp.new([self])
-  end
-end
-
-require 'active_record'
-if ArelExtensions::ACTIVE_RECORD_VERSION >= ArelExtensions::V7_2
-  class ActiveRecord::Relation::WhereClause
-    def except_predicates(columns)
-      attrs = columns.extract! { |node| node.is_a?(Arel::Attribute) }
-      non_attrs = columns.extract! { |node| node.is_a?(Arel::Predications) }
-
-      predicates.reject do |node|
-        if !non_attrs.empty? && node.equality? && node.left.is_a?(Arel::Predications)
-          non_attrs.include?(node.left)
-        end || Arel.fetch_attribute(node) do |attr|
-          attrs.find { |v| v.eql? attr } || columns.include?(attr.name.to_s) # 👈 replces
-          # attrs.include?(attr) || columns.include?(attr.name.to_s)         # 👈 this
-          #
-          # And that's because our attributes override `==`, so `attrs.include?(attr)` always
-          # passes because it returns an equality node.
-        end
-      end
-    end
-  end
-end

data/test/database.yml

@@ -1,4 +1,3 @@
-# Updated to use ENV vars mapped in compose.yml
 sqlite:
   adapter: sqlite3
   database: ":memory:"
@@ -9,31 +8,22 @@ jdbc-sqlite:
   timeout: 500
 mysql:
   adapter: mysql2
-  database: arelx_test
-  username: root
-  host: <%= ENV.fetch('MYSQL_HOST', '127.0.0.1') %>
-  port: 3306
-  encoding: utf8mb4
+  database: arext_test
+  username: travis
+  encoding: utf8
 jdbc-mysql:
   adapter: jdbcmysql
-  database: arelx_test
-  username: root
-  encoding: utf8mb4
-  host: <%= ENV.fetch('MYSQL_HOST', '127.0.0.1') %>
+  database: arext_test
+  username: travis
+  encoding: utf8
 postgresql:
   adapter: postgresql
-  database: arelx_test
+  database: arext_test
   username: postgres
-  password: secret
-  host: <%= ENV.fetch('POSTGRES_HOST', '127.0.0.1') %>
-  port: 5432
 jdbc-postgresql:
   adapter: jdbcpostgresql
-  database: arelx_test
+  database: arext_test
   username: postgres
-  password: secret
-  host: <%= ENV.fetch('POSTGRES_HOST', '127.0.0.1') %>
-  port: 5432
 oracle:
   adapter: oracle_enhanced
   database: xe
@@ -47,10 +37,10 @@ jdbc-oracle:
 ibm_db:
   adapter:  ibm_db
   username: travis
-  database: arelx_test
+  database: arext_test
 mssql:
   adapter: sqlserver
-  host: <%= ENV.fetch('MSSQL_HOST', 'localhost') %>
+  host: localhost
   database: master
   username: sa
   password: Password12!

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'fileutils'
+require 'arel'
+require 'active_record'
+
+require 'arel_extensions'
+
+require 'support/fake_record'
+Arel::Table.engine = FakeRecord::Base.new
+
+$arel_silence_type_casting_deprecation = true
+
+class Object
+  def must_be_like other
+    gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
+  end
+end