arel_extensions 1.2.8 → 1.2.16

data/lib/arel_extensions/attributes.rb

@@ -23,6 +23,5 @@ module ArelExtensions
     def !=(other)
       Arel::Nodes::NotEqual.new self, Arel::Nodes.build_quoted(other, self)
     end
-
   end
 end

data/lib/arel_extensions/boolean_functions.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'arel_extensions/nodes/then'
 
 module ArelExtensions
@@ -8,7 +9,7 @@ module ArelExtensions
     end
 
     def and *others
-      Arel::Nodes::And.new([self]+ others.flatten)
+      Arel::Nodes::And.new self, others
     end
 
     def ⋁(other)
@@ -16,28 +17,54 @@ module ArelExtensions
     end
 
     def or *others
-      args = others.flatten
-      if args.length == 1
-        Arel::Nodes::Or.new(self, args.first)
-      else
-        ArelExtensions::Nodes::Or.new([self]+ args)
-      end
+      Arel::Nodes::Or.new self, others
     end
 
     def then(t, f = nil)
       ArelExtensions::Nodes::Then.new [self, t, f]
     end
+
   end
 end
 
-Arel::Nodes::And.class_eval do
+class Arel::Nodes::And
   include ArelExtensions::BooleanFunctions
-end
 
-Arel::Nodes::Or.class_eval do
-  include ArelExtensions::BooleanFunctions
+  def self.new *children
+    children =
+      children.flatten.map { |c|
+      c.is_a?(self) ? c.children : c
+    }.flatten
+    super(children)
+  end
+
 end
 
-ArelExtensions::Nodes.const_set('Or',Class.new(Arel::Nodes::And)).class_eval do
+# For some reason, Arel's And is properly defined as variadic (it
+# stores @children, and hashes it all).  However Arel's Or is defined
+# as binary, with only @left and @right, and hashing only @left and @right.
+#
+# So reimplement its ctor and accessors.
+
+class Arel::Nodes::Or
   include ArelExtensions::BooleanFunctions
+
+  attr_reader :children
+
+  def self.new *children
+    children =
+      children.flatten.map { |c|
+      c.is_a?(self) ? c.children : c
+    }.flatten
+    super(*children)
+  end
+
+  def initialize *children
+    @children = children
+  end
+
+  def hash
+    children.hash
+  end
+
 end

data/lib/arel_extensions/insert_manager.rb

@@ -4,21 +4,23 @@ module ArelExtensions
   module InsertManager
 
     def bulk_insert(cols, data)
+    res_columns = []
       case cols.first
       when String, Symbol
         cols.each { |c|
-          @ast.columns << @ast.relation[c]
+          res_columns << @ast.relation[c]
         }
       when Array
         if String === cols.first.first
-          @ast.columns = cols.map {|c| [@ast.relation[c.first]] }
+          res_columns = cols.map {|c| [@ast.relation[c.first]] }
         elsif Arel::Attributes::Attribute == cols.first.first
-          @ast.columns = cols
+          res_columns = cols
         end
       when NilClass
-        @ast.columns = @ast.relation.columns
+        res_columns = @ast.relation.columns
       end
-      self.values = BulkValues.new(@ast.columns, data)
+      self.values = BulkValues.new(res_columns, data)
+      @ast.columns = res_columns
     end
 
     class BulkValues < Arel::Nodes::Node

data/lib/arel_extensions/nodes/case.rb

@@ -1,7 +1,11 @@
 module ArelExtensions
   module Nodes
-    if Arel::VERSION < "7.1.0"
+    if Gem::Version.new(Arel::VERSION) < Gem::Version.new("7.1.0")
       class Case < Arel::Nodes::Node
+        include Arel::Expressions
+        include Arel::Math
+        include Arel::Predications
+        include Arel::OrderPredications
         attr_accessor :case, :conditions, :default
 
         def initialize expression = nil, default = nil
@@ -26,8 +30,10 @@ module ArelExtensions
       end
     end
 
-    ArelExtensions::Nodes::Case.class_eval do
+    class ArelExtensions::Nodes::Case
       include Arel::Expressions
+      include Arel::Math
+      include Arel::Predications
       include Arel::OrderPredications
       include ArelExtensions::Math
       include ArelExtensions::Comparators

data/lib/arel_extensions/nodes/json.rb

@@ -26,6 +26,44 @@ module ArelExtensions
         [@dict].hash
       end
 
+      def convert_to_json_node(n)
+        case n
+        when JsonNode
+          n.dict
+        when Array
+          n.map{|e|
+             (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_json_node(e)
+          }
+        when Hash
+          n.reduce({}){|acc,v|
+            acc[convert_to_json_node(v[0])] = (v[1].is_a?(Array) || v[1].is_a?(Hash)) ? Json.new(v[1]) : convert_to_json_node(v[1])
+            acc
+          }
+        when String, Numeric, TrueClass, FalseClass
+          convert_to_node(n)
+        when Date
+          convert_to_node(n.strftime("%Y-%m-%d"))
+        when DateTime, Time
+          convert_to_node(n.strftime("%Y-%m-%dT%H:%M:%S.%L%:z"))
+        when NilClass
+          Arel.sql('null')
+        else
+          convert_to_node(n)
+        end
+      end
+
+      def type_of_node(v)
+        if v.is_a?(Arel::Attributes::Attribute)
+          self.type_of_attribute(v)
+        elsif v.respond_to?(:return_type)
+          v.return_type
+        elsif v.nil?
+          :nil
+        else
+          :string
+        end
+      end
+
     end
 
     class Json < JsonNode
@@ -33,32 +71,9 @@ module ArelExtensions
       def initialize *expr
         @dict =
           if expr.length == 1
-            case exp = expr.first
-            when JsonNode
-              exp.dict
-            when Array
-              exp.map{|e|
-                (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_node(e)
-              }
-            when Hash
-              exp.reduce({}){|acc,v|
-                acc[convert_to_node(v[0])] = (v[1].is_a?(Array) || v[1].is_a?(Hash)) ? Json.new(v[1]) : convert_to_node(v[1])
-                acc
-              }
-            when String, Numeric, TrueClass, FalseClass
-              convert_to_node(exp)
-            when NilClass
-              Arel.sql('null')
-            else
-              if (exp.is_a?(Arel::Attributes::Attribute) && type_of_attribute(exp) == :string) \
-                 || (exp.return_type == :string)
-                convert_to_node(exp)
-              else
-                [convert_to_node(exp)]
-              end
-            end
+            convert_to_json_node(expr.first)
           else
-            expr.map{|e| (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_node(e) }
+            expr.map{|e| convert_to_json_node(e) }
           end
         super
       end

data/lib/arel_extensions/predications.rb

@@ -1,5 +1,6 @@
 module ArelExtensions
   module Predications
+
     def when right, expression = nil
       ArelExtensions::Nodes::Case.new(self).when(right,expression)
     end
@@ -20,23 +21,25 @@ module ArelExtensions
       ArelExtensions::Nodes::Cast.new([self,right])
     end
 
-    def in(other) #In should handle nil element in the Array
+    def in(*other) #In should handle nil element in the Array
+      other = other.first if other.length <= 1
       case other
       when Range
         self.between(other)
+      when Arel::Nodes::Grouping
+        Arel::Nodes::In.new(self, quoted_node(other))
       when Enumerable
         nils, values   = other.partition{ |v| v.nil? }
         ranges, values = values.partition{ |v| v.is_a?(Range) || v.is_a?(Arel::SelectManager)}
-
         # In order of (imagined) decreasing efficiency: nil, values, and then more complex.
         clauses =
           nils.uniq.map { |r| self.in(r) } \
           + (case values.uniq.size
               when 0 then []
-              when 1 then [self == values[0]]
+              when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? self.in(values[0]) : self.eq(values[0])]
               else [Arel::Nodes::In.new(self, quoted_array(values))] end) \
           + ranges.uniq.map { |r| self.in(r) }
-        clauses.empty? ? self.is_null : clauses.reduce(&:or)
+        clauses.empty? ? Arel.false : clauses.reduce(&:or)
       when nil
         self.is_null
       when Arel::SelectManager
@@ -46,24 +49,25 @@ module ArelExtensions
       end
     end
 
-    def not_in(other) #In should handle nil element in the Array
+    def not_in(*other) #In should handle nil element in the Array
+      other = other.first if other.length <= 1
       case other
       when Range
         Arel::Nodes::Not.new(self.between(other))
+      when Arel::Nodes::Grouping
+        Arel::Nodes::NotIn.new(self, quoted_node(other))
       when Enumerable
-        if other.include?(nil)
-          other.delete(nil)
-          case other.length
-          when 0
-            self.is_not_null
-          when 1
-            self.is_not_null.and(self!=other[0])
-          else
-            self.is_not_null.and(Arel::Nodes::NotIn.new(self,quoted_array(other)))
-          end
-        else
-          Arel::Nodes::NotIn.new(self,quoted_array(other))
-        end
+        nils, values   = other.partition{ |v| v.nil? }
+        ranges, values = values.partition{ |v| v.is_a?(Range) || v.is_a?(Arel::SelectManager)}
+        # In order of (imagined) decreasing efficiency: nil, values, and then more complex.
+        clauses =
+          nils.uniq.map { |r| self.not_in(r) } \
+          + (case values.uniq.size
+              when 0 then []
+              when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? self.not_in(values[0]) : self.not_eq(values[0])]
+              else [Arel::Nodes::NotIn.new(self, quoted_array(values))] end) \
+          + ranges.uniq.map { |r| self.not_in(r) }
+        Arel::Nodes::And.new clauses
       when nil
         self.is_not_null
       when Arel::SelectManager
@@ -93,6 +97,5 @@ module ArelExtensions
         raise(ArgumentError, "#{object.class} can not be converted to CONCAT arg")
       end
     end
-
   end
 end

data/lib/arel_extensions/set_functions.rb

@@ -23,10 +23,10 @@ module ArelExtensions
   end
 end
 
-Arel::Nodes::Union.class_eval do
+class Arel::Nodes::Union
   include ArelExtensions::SetFunctions
 end
 
-Arel::Nodes::UnionAll.class_eval do
+class Arel::Nodes::UnionAll
   include ArelExtensions::SetFunctions
 end

data/lib/arel_extensions/string_functions.rb

@@ -64,6 +64,19 @@ module ArelExtensions
       grouping_any :imatches, others, escape
     end
 
+#    def grouping_any method, others, *extra
+#      puts "*******************"
+#      puts method
+#      puts others.inspect
+#      puts extra.inspect
+#      puts "-------------------"
+#      res = super(method,others,*extra)
+#      puts res.to_sql
+#      puts res.inspect
+#      puts "*******************"
+#      res
+#    end
+
     def imatches_all others, escape = nil
       grouping_all :imatches, others, escape, escape
     end

data/lib/arel_extensions/version.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = "1.2.8".freeze
+  VERSION = "1.2.16".freeze
 end

data/lib/arel_extensions/visitors.rb

@@ -6,7 +6,7 @@ require 'arel_extensions/visitors/postgresql'
 require 'arel_extensions/visitors/sqlite'
 require 'arel_extensions/visitors/mssql'
 
-Arel::Visitors::MSSQL.class_eval do
+class Arel::Visitors::MSSQL
   include ArelExtensions::Visitors::MSSQL
 
   alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As

data/lib/arel_extensions/visitors/ibm_db.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::IBM_DB.class_eval do
+    class Arel::Visitors::IBM_DB
 
       def visit_ArelExtensions_Nodes_Ceil o, collector
         collector << "CEILING("

data/lib/arel_extensions/visitors/mysql.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-    Arel::Visitors::MySQL.class_eval do
+    class Arel::Visitors::MySQL
       Arel::Visitors::MySQL::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'WEEKDAY', 'h' => 'HOUR', 'mn' => 'MINUTE', 's' => 'SECOND'}
       Arel::Visitors::MySQL::DATE_FORMAT_DIRECTIVES = { # ISO C / POSIX
         '%Y' => '%Y', '%C' =>   '', '%y' => '%y', '%m' => '%m', '%B' => '%M', '%b' => '%b', '%^b' => '%b',  # year, month
@@ -193,6 +193,13 @@ module ArelExtensions
         collector
       end
 
+      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
+        if !regexp_replace_supported?
+          warn("Warning : ArelExtensions: REGEXP_REPLACE does not seem to be available in the current version of the DBMS, it might crash")
+        end
+        super(o,collector)
+      end
+
       def visit_ArelExtensions_Nodes_Format o, collector
         case o.col_type
         when :date, :datetime
@@ -403,7 +410,7 @@ module ArelExtensions
 
       def visit_Aggregate_For_AggregateFunction o, collector
         if !window_supported?
-            warn("Warning : ArelExtensions: Window Functions are not available in the current version on the DBMS.")
+            warn("Warning : ArelExtensions: Window Functions are not available in the current version of the DBMS.")
             return collector
         end
 
@@ -449,14 +456,22 @@ module ArelExtensions
         version_supported?('10.2.3', '8.0')
       end
 
-      def version_supported?(mysql_v = '10.2.3',mariadb_v = '5.7.0')
+      def regexp_replace_supported?
+        version_supported?('10.0.5', '8.0')
+      end
+
+      def version_supported?(mariadb_v = '10.2.3', mysql_v = '5.7.0')
         conn = Arel::Table.engine.connection
-        conn.send(:mariadb?) &&
-          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mysql_v ||
-          conn.respond_to?(:version) && conn.send(:version) >= mysql_v) ||
-          !Arel::Table.engine.connection.send(:mariadb?) &&
-          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mariadb_v ||
-          conn.respond_to?(:version) && conn.send(:version) >= mariadb_v)
+        conn.send(:mariadb?) && \
+          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mariadb_v || \
+          conn.respond_to?(:version) && conn.send(:version) >= mariadb_v || \
+          conn.instance_variable_get(:"@version") && conn.instance_variable_get(:"@version") >= mariadb_v) || \
+          !conn.send(:mariadb?) && \
+          (conn.respond_to?(:get_database_version) && conn.send(:get_database_version) >= mysql_v || \
+          conn.respond_to?(:version) && conn.send(:version) >= mysql_v || \
+          conn.instance_variable_get(:"@version") && conn.instance_variable_get(:"@version") >= mysql_v)
+        # ideally we should parse the instance_variable @full_version because @version contains only the supposedly
+        # corresponding mysql version of the current mariadb version (which is not very helpful most of the time)
       end
 
       def visit_ArelExtensions_Nodes_Json o,collector