arel_extensions 1.5.2 → 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' \
-  && Arel::VERSION.to_i < 10 \
-  && 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_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)
+  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_method(: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,5 +1,4 @@
 require 'arel'
-require 'base64'
 
 require 'arel_extensions/railtie' if defined?(Rails::Railtie)
 
@@ -8,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 Gem::Version.new(Arel::VERSION) < Gem::Version.new('10.0.0')
-    def hash
-      [self.class, self.val, self.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
-    self.hash.eql? other.hash
-  end
-end
-
-class Arel::Nodes::Function
+Arel::Nodes::Function.class_eval do
   include Arel::Math
   include Arel::Expressions
 end
 
-if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('7.1.0')
-  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'
@@ -79,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
     Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
   end
 
-  # The TRUE pseudo literal.
-  def self.true
-    Arel::Nodes::Equality.new(1, 1)
-  end
-
-  def self.tuple *v
-    tmp = Arel.grouping(nil)
-    Arel.grouping v.map{|e| tmp.convert_to_node(e)}
+  def self.json *expr
+    if expr.length == 1
+      ArelExtensions::Nodes::Json.new(expr.first)
+    else
+      ArelExtensions::Nodes::Json.new(expr)
+    end
   end
 
-  # For instance
-  #
-  # ```
-  # Arel.when(at[field].is_null).then(0).else(1)
-  # ```
   def self.when condition
     ArelExtensions::Nodes::Case.new.when(condition)
   end
+
+  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
@@ -198,150 +109,44 @@ class Arel::Nodes::Function
   include ArelExtensions::BooleanFunctions
   include ArelExtensions::NullFunctions
   include ArelExtensions::Predications
-
-  alias_method(:old_as, :as) rescue nil
-  def as other
-    res = Arel::Nodes::As.new(self.clone, Arel.sql(other))
-    if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('9.0.0')
-      self.alias = Arel.sql(other)
-    end
-    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_method(: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 !self.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 self.relation.respond_to?(met)
-      self.relation.send(met, args)
-    else
-      super(met, *args)
-    end
-  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 ActiveRecord.version >= Gem::Version.create('7.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

@@ -8,30 +8,22 @@ jdbc-sqlite:
   timeout: 500
 mysql:
   adapter: mysql2
-  database: arelx_test
-  username: root
-  host: 127.0.0.1
-  port: 3306
+  database: arext_test
+  username: travis
   encoding: utf8
 jdbc-mysql:
   adapter: jdbcmysql
-  database: arelx_test
-  username: root
+  database: arext_test
+  username: travis
   encoding: utf8
 postgresql:
   adapter: postgresql
-  database: arelx_test
+  database: arext_test
   username: postgres
-  password: secret
-  host: 127.0.0.1
-  port: 5432
 jdbc-postgresql:
   adapter: jdbcpostgresql
-  database: arelx_test
+  database: arext_test
   username: postgres
-  password: secret
-  host: 127.0.0.1
-  port: 5432
 oracle:
   adapter: oracle_enhanced
   database: xe
@@ -45,7 +37,7 @@ jdbc-oracle:
 ibm_db:
   adapter:  ibm_db
   username: travis
-  database: arelx_test
+  database: arext_test
 mssql:
   adapter: sqlserver
   host: localhost

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