arel_extensions 1.7.0 → 2.0.0.rc3

data/lib/arel_extensions/boolean_functions.rb

@@ -1,23 +1,27 @@
-# frozen_string_literal: true
-
 require 'arel_extensions/nodes/then'
 
 module ArelExtensions
   module BooleanFunctions
+
     def ⋀(other)
       self.and(other)
     end
 
-    def and(*others)
-      Arel::Nodes::And.new self, others
+    def and *others
+      Arel::Nodes::And.new([self]+ others.flatten)
     end
 
     def ⋁(other)
       self.or(other)
     end
 
-    def or(*others)
-      Arel::Nodes::Or.new self, others
+    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
     end
 
     def then(t, f = nil)
@@ -26,61 +30,16 @@ module ArelExtensions
   end
 end
 
-class Arel::Nodes::And
+Arel::Nodes::And.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
 
-# 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
+Arel::Nodes::Or.class_eval do
   include ArelExtensions::BooleanFunctions
+end
 
-  attr_reader :children
-
-  def self.new(*children)
-    children =
-      children.flatten.map { |c|
-        c.is_a?(self) ? c.children : c
-      }.flatten
-    super
-  end
-
-  def initialize(*children)
-    @children = children
-  end
-
-  def initialize_copy(other)
-    super
-    @children = other.children.copy if other.children
-  end
-
-  def left
-    children.first
-  end
-
-  def right
-    children[1]
-  end
+ArelExtensions::Nodes.const_set('Or',Class.new(Arel::Nodes::And)).class_eval do
+  include ArelExtensions::BooleanFunctions
+end
 
-  def hash
-    children.hash
-  end
 
-  def eql?(other)
-    self.class == other.class &&
-      children == other.children
-  end
-  alias == eql?
-end

data/lib/arel_extensions/common_sql_functions.rb

@@ -1,67 +1,66 @@
-# frozen_string_literal: true
-
 module ArelExtensions
   class CommonSqlFunctions
+
     def initialize(cnx)
       @cnx = cnx
       if cnx && cnx.adapter_name =~ /sqlite/i && !$load_extension_disabled
         begin
           db = cnx.raw_connection
           db.enable_load_extension(1)
-          db.load_extension('/usr/lib/sqlite3/pcre.so')
-          db.load_extension('/usr/lib/sqlite3/extension-functions.so')
+          db.load_extension("/usr/lib/sqlite3/pcre.so")
+          db.load_extension("/usr/lib/sqlite3/extension-functions.so")
           db.enable_load_extension(0)
-        rescue StandardError => e
+        rescue => e
           $load_extension_disabled = true
-          puts "cannot load extensions #{e.inspect}"
+          puts "can not load extensions #{e.inspect}"
         end
       end
     end
 
     def add_sqlite_functions
       db = @cnx.raw_connection
-      db.create_function('find_in_set', 1) do |func, val, list|
+      db.create_function("find_in_set", 1) do |func, val, list|
         case list
         when String
           i = list.split(',').index(val.to_s)
-          func.result = i ? (i + 1) : 0
+          func.result = i ? (i+1) : 0
         when NilClass
           func.result = nil
         else
           i = list.to_s.split(',').index(val.to_s)
-          func.result = i ? (i + 1) : 0
+          func.result = i ? (i+1) : 0
         end
       end
-      db.create_function('instr', 1) do |func, value1, value2|
+      db.create_function("instr", 1) do |func, value1, value2|
         i = value1.to_s.index(value2.to_s)
-        func.result = i ? (i + 1) : 0
-      end rescue 'function instr already here (>= 3.8.5)'
+        func.result = i ? (i+1) : 0
+      end rescue "function instr already here (>= 3.8.5)"
     end
 
     def add_sql_functions(env_db = nil)
       env_db ||= @cnx.adapter_name
-      env_db = 'mysql' if /mysql/i.match?(env_db)
-      if /sqlite/i.match?(env_db)
+      if env_db =~ /sqlite/i
         begin
           add_sqlite_functions
-        rescue StandardError => e
-          puts "cannot add sqlite functions #{e.inspect}"
+        rescue => e
+          puts "can not add sqlite functions #{e.inspect}"
         end
       end
       if File.exist?("init/#{env_db}.sql")
         sql = File.read("init/#{env_db}.sql")
         if env_db == 'mssql'
-          sql.split(/^GO\s*$/).each { |str|
+          sql.split(/^GO\s*$/).each {|str|
             @cnx.execute(str.strip) unless str.blank?
           }
-        elsif env_db == 'mysql'
-          sql.split('$$')[1..-2].each { |str|
-            @cnx.execute(str.strip) unless str.strip.blank?
-          }
+        elsif env_db == 'mysql' 
+			sql.split("$$")[1..-2].each { |str|
+				@cnx.execute(str.strip) unless str.strip.blank?
+			}
         else
           @cnx.execute(sql) unless sql.blank?
         end
       end
     end
+
   end
 end

data/lib/arel_extensions/comparators.rb

@@ -1,62 +1,59 @@
-# frozen_string_literal: true
-
 module ArelExtensions
   module Comparators
+
     def >(other)
-      Arel::Nodes::GreaterThan.new self, Arel.quoted(other, self)
+      Arel::Nodes::GreaterThan.new self, Arel::Nodes.build_quoted(other, self)
     end
 
     def >=(other)
-      Arel::Nodes::GreaterThanOrEqual.new self, Arel.quoted(other, self)
+      Arel::Nodes::GreaterThanOrEqual.new self, Arel::Nodes.build_quoted(other, self)
     end
 
     def <(other)
-      Arel::Nodes::LessThan.new self, Arel.quoted(other, self)
+      Arel::Nodes::LessThan.new self, Arel::Nodes.build_quoted(other, self)
     end
 
     def <=(other)
-      Arel::Nodes::LessThanOrEqual.new self, Arel.quoted(other, self)
+      Arel::Nodes::LessThanOrEqual.new self, Arel::Nodes.build_quoted(other, self)
     end
 
-    # REGEXP function
-    # Pattern matching using regular expressions
+
+    #REGEXP function
+    #Pattern matching using regular expressions
     def =~(other)
-      #      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
-      #      if arg == :string || arg == :text
-      Arel::Nodes::Regexp.new self, convert_regexp(other)
-      #      end
+#      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
+#      if arg == :string || arg == :text
+        Arel::Nodes::Regexp.new self, convert_regexp(other)
+#      end
     end
 
-    alias regex_matches =~
-
-    # NOT_REGEXP function
-    # Negation of Regexp
+    #NOT_REGEXP function
+    #Negation of Regexp
     def !~(other)
-      #      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
-      #      if arg == :string || arg == :text
-      Arel::Nodes::NotRegexp.new self, convert_regexp(other)
-      #      end
+#      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
+#      if arg == :string || arg == :text
+        Arel::Nodes::NotRegexp.new self, convert_regexp(other)
+#      end
     end
 
     private
-
-    # Function used for not_regexp.
+    #Function use for not_regexp
     def convert_regexp(other)
       case other
       when String
-        # Do nothing.
+        #Do nothing
       when Regexp
-        other = other.source.gsub('\A', '^')
-        other.gsub!('\z', '$')
-        other.gsub!('\Z', '$')
-        other.gsub!('\d', '[0-9]')
-        other.gsub!('\D', '[^0-9]')
-        other.gsub!('\w', '[0-9A-Za-z]')
-        other.gsub!('\W', '[^A-Za-z0-9_]')
+        other = other.source.gsub('\A','^')
+        other.gsub!('\Z','$')
+        other.gsub!('\d','[0-9]')
+        other.gsub!('\D','[^0-9]')
+        other.gsub!('\w','[0-9A-Za-z]')
+        other.gsub!('\W','[^A-Za-z0-9_]')
       else
         raise(ArgumentError)
       end
-      Arel.quoted(other, self)
+      Arel::Nodes.build_quoted(other, self)
     end
+
   end
 end

data/lib/arel_extensions/date_duration.rb

@@ -1,30 +1,27 @@
-# frozen_string_literal: true
-
 require 'arel_extensions/nodes/format'
-require 'arel_extensions/nodes/formatted_date'
 require 'arel_extensions/nodes/duration'
 require 'arel_extensions/nodes/wday'
 
 module ArelExtensions
   module DateDuration
-    # function returns the year (as a number) given a date value.
+    #function returns the year (as a number) given a date value.
     def year
-      ArelExtensions::Nodes::Duration.new 'y', self
+      ArelExtensions::Nodes::Duration.new "y", self
     end
 
-    # function returns the month (as a number) given a date value.
+  #function returns the month (as a number) given a date value.
     def month
-      ArelExtensions::Nodes::Duration.new 'm', self
+      ArelExtensions::Nodes::Duration.new "m", self
     end
 
-    # function returns the  week (as a number) given a date value.
+    #function returns the  week (as a number) given a date value.
     def week
-      ArelExtensions::Nodes::Duration.new 'w', self
+      ArelExtensions::Nodes::Duration.new "w", self
     end
 
-    # function returns the month (as a number) given a date value.
+    #function returns the month (as a number) given a date value.
     def day
-      ArelExtensions::Nodes::Duration.new 'd', self
+      ArelExtensions::Nodes::Duration.new "d", self
     end
 
     def wday
@@ -32,23 +29,20 @@ module ArelExtensions
     end
 
     def hour
-      ArelExtensions::Nodes::Duration.new 'h', self
+      ArelExtensions::Nodes::Duration.new "h", self
     end
 
     def minute
-      ArelExtensions::Nodes::Duration.new 'mn', self
+      ArelExtensions::Nodes::Duration.new "mn", self
     end
 
     def second
-      ArelExtensions::Nodes::Duration.new 's', self
+      ArelExtensions::Nodes::Duration.new "s", self
     end
 
-    def format(tpl, time_zone = nil)
-      ArelExtensions::Nodes::Format.new [self, tpl, time_zone]
+    def format(tpl)
+      ArelExtensions::Nodes::Format.new [self, tpl]
     end
 
-    def format_date(tpl, time_zone = nil)
-      ArelExtensions::Nodes::FormattedDate.new [self, tpl, time_zone]
-    end
   end
 end

data/lib/arel_extensions/insert_manager.rb

@@ -1,40 +1,33 @@
-# frozen_string_literal: true
-
 require 'arel'
 
 module ArelExtensions
   module InsertManager
-    def bulk_insert(cols, data)
-      raise ArgumentError, 'cols must be present' if cols.blank?
 
-      columns =
-        case cols.first
+    def bulk_insert(cols, data)
+      case cols.first
+        when String, Symbol
+          cols.each { |c|
+            @ast.columns << @ast.relation[c]
+          }
         when Array
-          case cols.first.first
-          when Arel::Attributes::Attribute
-            cols
-          when String, Symbol
-            cols.map { |c| [@ast.relation[c.first]] }
-          else
-            raise ArgumentError, "cols has an invalid type: #{cols.first.first.class}"
+          if String === cols.first.first
+            @ast.columns = cols.map {|c| [@ast.relation[c.first]] }
+          elsif Arel::Attributes::Attribute == cols.first.first
+            @ast.columns = cols
           end
-        when String, Symbol
-          cols.map { |c| @ast.relation[c] }
-        else
-          raise ArgumentError, "cols has an invalid type: #{cols.first.class}"
-        end
-      self.values = BulkValues.new(columns, data)
-      @ast.columns = columns
+        when NilClass
+          @ast.columns = @ast.relation.columns
+      end
+      self.values = BulkValues.new(@ast.columns, data)
     end
 
     class BulkValues < Arel::Nodes::Node
       attr_accessor :left, :cols
-
       def initialize(cols, values)
-        super()
         @left = values
         @cols = cols
       end
     end
+
   end
 end

data/lib/arel_extensions/math.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'arel_extensions/nodes'
 require 'arel_extensions/nodes/function'
 require 'arel_extensions/nodes/concat'
@@ -13,106 +11,111 @@ require 'arel_extensions/nodes/union_all'
 
 module ArelExtensions
   module Math
-    # function + between
-    # String and others (convert in string)  allows you to concatenate 2 or more strings together.
-    # Date and integer adds or subtracts a specified time interval from a date.
+    #function + between
+    #String and others (convert in string)  allows you to concatenate 2 or more strings together.
+    #Date and integer adds or subtracts a specified time interval from a date.
     def +(other)
       case self
-      when Arel::Nodes::Quoted
-        concat(other)
-      when Arel::Nodes::Grouping
-        if expr.left.is_a?(String) || expr.right.is_a?(String)
-          concat(other)
-        else
-          Arel.grouping(Arel::Nodes::Addition.new(self, other))
-        end
-      when ArelExtensions::Nodes::Function, ArelExtensions::Nodes::Case
-        case return_type
+        when Arel::Nodes::Quoted
+          return self.concat(other)
+        when Arel::Nodes::Grouping
+          if self.expr.left.is_a?(String) || self.expr.right.is_a?(String)
+            return self.concat(other)
+          else
+            return Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+          end
+        when  ArelExtensions::Nodes::Function,ArelExtensions::Nodes::Case
+          return case self.return_type
+        when :string, :text
+          self.concat(other)
         when :integer, :decimal, :float, :number, :int
-          Arel.grouping(Arel::Nodes::Addition.new(self, other))
+          Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
         when :date, :datetime
           ArelExtensions::Nodes::DateAdd.new [self, other]
         else
-          concat(other)
+          self.concat(other)
         end
-      when Arel::Nodes::Function
-        Arel.grouping(Arel::Nodes::Addition.new(self, other))
+      when  Arel::Nodes::Function
+        Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
       else
-        col =
-          if is_a?(Arel::Attribute) && respond_to?(:type_caster) && able_to_type_cast?
-            type_caster
-          elsif respond_to?(:relation)
-            Arel.column_of(relation.table_name, name.to_s)
-          end
-        if col
+        begin
+          col = Arel::Table.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s]
+        rescue Exception
+          col = nil
+        end
+        if (!col) #if the column doesn't exist in the database
+          Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new(self, other))
+        else
           arg = col.type
-          if arg == :integer || !arg
+          if arg == :integer || (!arg)
             other = other.to_i if other.is_a?(String)
-            Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
-          elsif %i[decimal float].include?(arg)
+            Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+          elsif arg == :decimal || arg == :float
             other = Arel.sql(other) if other.is_a?(String) # Arel should accept Float & BigDecimal!
-            Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
-          elsif %i[datetime date].include?(arg)
+            Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+          elsif arg == :datetime || arg == :date
             ArelExtensions::Nodes::DateAdd.new [self, other]
-          elsif %i[string text].include?(arg)
-            concat(other)
+          elsif arg == :string || arg == :text
+            self.concat(other)
           end
-        else
-          Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
         end
       end
     end
 
-    # function returns the time between two dates
-    # function returns the substraction between two ints
+    #function returns the time between two dates
+    #function returns the substraction between two ints
     def -(other)
       case self
       when Arel::Nodes::Grouping
-        if expr.left.is_a?(Date) || expr.left.is_a?(DateTime)
-          Arel.grouping(ArelExtensions::Nodes::DateSub.new([self, Arel.quoted(other)]))
+        if self.expr.left.is_a?(Date) || self.expr.left.is_a?(DateTime)
+          Arel::Nodes::Grouping.new(ArelExtensions::Nodes::DateSub.new [self, other])
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
+          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
         end
       when ArelExtensions::Nodes::Function, ArelExtensions::Nodes::Case
-        case return_type
+        case self.return_type
+        when :string, :text # ???
+          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other)) # ??
+        when :integer, :decimal, :float, :number
+          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
         when :date, :datetime
-          ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)]
+          ArelExtensions::Nodes::DateSub.new [self, other]
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
+          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
         end
       when Arel::Nodes::Function
-        Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
+        Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
       else
-        col =
-          if is_a?(Arel::Attribute) && respond_to?(:type_caster) && able_to_type_cast?
-            type_caster
-          elsif respond_to?(:relation)
-            Arel.column_of(relation.table_name, name.to_s)
-          end
-        if col
+        begin
+          col = Arel::Table.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s]
+        rescue Exception
+          col = nil
+        end
+        if (!col) #if the column doesn't exist in the database
+          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+        else
           arg = col.type
-          if %i[date datetime].include?(arg)
+          if (arg == :date || arg == :datetime)
             case other
             when Arel::Attributes::Attribute
-              col2 =
-                if other.is_a?(Arel::Attribute) && other.respond_to?(:type_caster) && other.able_to_type_cast?
-                  other.type_caster
-                elsif other.respond_to?(:relation)
-                  Arel.column_of(other.relation.table_name, other.name.to_s)
-                end
-              if col2
+              begin
+                col2 = Arel::Table.engine.connection.schema_cache.columns_hash(other.relation.table_name)[other.name.to_s]
+              rescue Exception
+                col2 = nil
+              end
+              if (!col2) #if the column doesn't exist in the database
+                ArelExtensions::Nodes::DateSub.new [self, other]
+              else
                 arg2 = col2.type
-                if %i[date datetime].include?(arg2)
+                if arg2 == :date || arg2 == :datetime
                   ArelExtensions::Nodes::DateDiff.new [self, other]
                 else
                   ArelExtensions::Nodes::DateSub.new [self, other]
                 end
-              else
-                ArelExtensions::Nodes::DateSub.new [self, other]
               end
             when Arel::Nodes::Node, DateTime, Time, String, Date
               ArelExtensions::Nodes::DateDiff.new [self, other]
-            when ArelExtensions::Nodes::Duration, Integer
+            when  ArelExtensions::Nodes::Duration, Integer
               ArelExtensions::Nodes::DateSub.new [self, other]
             else # ActiveSupport::Duration
               ArelExtensions::Nodes::DateAdd.new [self, -other]
@@ -120,17 +123,16 @@ module ArelExtensions
           else
             case other
             when Integer, Float, BigDecimal
-              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.sql(other.to_s)))
+              Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, Arel.sql(other.to_s)))
             when String
-              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.sql(other)))
+              Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, Arel.sql(other)))
             else
-              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
+              Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
             end
           end
-        else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         end
       end
     end
+
   end
 end