arel_extensions 1.3.4 → 2.0.0.rc3

data/lib/arel_extensions/visitors.rb

@@ -1,97 +1,81 @@
-require 'arel_extensions/visitors/convert_format'
 require 'arel_extensions/visitors/to_sql'
 require 'arel_extensions/visitors/mysql'
+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) || defined?(Arel::Visitors::MSSQL)
-  require 'arel_extensions/visitors/mssql'
-end
+Arel::Visitors::MSSQL.class_eval do
+  include ArelExtensions::Visitors::MSSQL
 
-if defined?(Arel::Visitors::SQLServer)
-  class Arel::Visitors::SQLServer
-    include ArelExtensions::Visitors::MSSQL
+  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_As, :visit_Arel_Nodes_As) rescue nil
-    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_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 = []
-      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
 
-  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
+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
 
-          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 = []
-            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
 
-          alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
-          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
+        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) rescue nil
-          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
+        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
     end
+  end
   rescue LoadError
-  rescue => e
+rescue => e
     e
-  end
 end

data/lib/arel_extensions.rb

@@ -7,53 +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/helpers'
 require 'arel_extensions/version'
-require 'arel_extensions/aliases'
 require 'arel_extensions/attributes'
 require 'arel_extensions/visitors'
 require 'arel_extensions/nodes'
@@ -78,55 +66,9 @@ require 'arel_extensions/nodes/soundex'
 require 'arel_extensions/nodes/cast'
 require 'arel_extensions/nodes/json'
 
-# 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
-
-  # 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
@@ -135,33 +77,30 @@ module Arel
     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
@@ -170,101 +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
-
-  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
-  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

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