arel_extensions 2.1.2 → 2.1.5

data/lib/arel_extensions/math.rb

@@ -1,5 +1,3 @@
-require 'arel_extensions/helpers'
-
 require 'arel_extensions/nodes'
 require 'arel_extensions/nodes/function'
 require 'arel_extensions/nodes/concat'
@@ -18,16 +16,16 @@ module ArelExtensions
     # Date and integer adds or subtracts a specified time interval from a date.
     def +(other)
       case self
-        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.grouping(Arel::Nodes::Addition.new self, other)
-          end
-        when ArelExtensions::Nodes::Function,ArelExtensions::Nodes::Case
-          return case self.return_type
+      when Arel::Nodes::Quoted
+        self.concat(other)
+      when Arel::Nodes::Grouping
+        if self.expr.left.is_a?(String) || self.expr.right.is_a?(String)
+          self.concat(other)
+        else
+          Arel.grouping(Arel::Nodes::Addition.new self, other)
+        end
+      when ArelExtensions::Nodes::Function, ArelExtensions::Nodes::Case
+        case self.return_type
         when :string, :text
           self.concat(other)
         when :integer, :decimal, :float, :number, :int
@@ -40,17 +38,22 @@ module ArelExtensions
       when Arel::Nodes::Function
         Arel.grouping(Arel::Nodes::Addition.new self, other)
       else
-        col = self.respond_to?(:relation)? ArelExtensions::column_of(self.relation.table_name, self.name.to_s) : nil
-        if (!col) # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Addition.new(self, Arel::Nodes.build_quoted(other)))
+        col =
+          if self.is_a?(Arel::Attribute) && self.respond_to?(:type_caster) && self.able_to_type_cast?
+            self.type_caster
+          else
+            Arel.column_of(self.relation.table_name, self.name.to_s) if self.respond_to?(:relation)
+          end
+        if !col # if the column doesn't exist in the database
+          Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(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::Nodes.build_quoted(other))
+            Arel.grouping(Arel::Nodes::Addition.new self, Arel.quoted(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::Nodes.build_quoted(other))
+            Arel.grouping(Arel::Nodes::Addition.new self, Arel.quoted(other))
           elsif arg == :datetime || arg == :date
             ArelExtensions::Nodes::DateAdd.new [self, other]
           elsif arg == :string || arg == :text
@@ -66,34 +69,44 @@ module ArelExtensions
       case self
       when Arel::Nodes::Grouping
         if self.expr.left.is_a?(Date) || self.expr.left.is_a?(DateTime)
-          Arel.grouping(ArelExtensions::Nodes::DateSub.new [self, Arel::Nodes.build_quoted(other)])
+          Arel.grouping(ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)])
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         end
       when ArelExtensions::Nodes::Function, ArelExtensions::Nodes::Case
         case self.return_type
         when :string, :text # ???
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other))) # ??
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other))) # ??
         when :integer, :decimal, :float, :number
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         when :date, :datetime
-          ArelExtensions::Nodes::DateSub.new [self, Arel::Nodes.build_quoted(other)]
+          ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)]
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         end
       when Arel::Nodes::Function
-        Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+        Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
       else
-        col = ArelExtensions::column_of(self.relation.table_name, self.name.to_s)
-        if (!col) # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+        col =
+          if self.is_a?(Arel::Attribute) && self.respond_to?(:type_caster) && self.able_to_type_cast?
+            self.type_caster
+          else
+            Arel.column_of(self.relation.table_name, self.name.to_s) if self.respond_to?(:relation)
+          end
+        if !col # if the column doesn't exist in the database
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         else
           arg = col.type
           if (arg == :date || arg == :datetime)
             case other
             when Arel::Attributes::Attribute
-              col2 = ArelExtensions::column_of(other.relation.table_name, other.name.to_s)
-              if (!col2) # if the column doesn't exist in the database
+              col2 =
+                if other.is_a?(Arel::Attribute) && other.respond_to?(:type_caster) && other.able_to_type_cast?
+                  other.type_caster
+                else
+                  Arel.column_of(other.relation.table_name, other.name.to_s) if other.respond_to?(:relation)
+                end
+              if !col2 # if the column doesn't exist in the database
                 ArelExtensions::Nodes::DateSub.new [self, other]
               else
                 arg2 = col2.type
@@ -117,7 +130,7 @@ module ArelExtensions
             when String
               Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.sql(other)))
             else
-              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
             end
           end
         end

data/lib/arel_extensions/math_functions.rb

@@ -15,7 +15,7 @@ module ArelExtensions
     def * other
       case other
       when Float, BigDecimal
-        super(Arel::Nodes.build_quoted(other))
+        super(Arel.quoted(other))
       else
         super(other)
       end
@@ -25,7 +25,7 @@ module ArelExtensions
     def / other
       case other
       when Float, BigDecimal
-        super(Arel::Nodes.build_quoted(other))
+        super(Arel.quoted(other))
       else
         super(other)
       end
@@ -33,32 +33,32 @@ module ArelExtensions
 
     # Abs function returns the absolute value of a number passed as argument #
     def abs
-        ArelExtensions::Nodes::Abs.new [self]
+      ArelExtensions::Nodes::Abs.new [self]
     end
 
     # will rounded up any positive or negative decimal value within the function upwards #
     def ceil
-        ArelExtensions::Nodes::Ceil.new [self]
+      ArelExtensions::Nodes::Ceil.new [self]
     end
 
     # function rounded up any positive or negative decimal value down to the next least integer
     def floor
-        ArelExtensions::Nodes::Floor.new [self]
+      ArelExtensions::Nodes::Floor.new [self]
     end
 
     # function gives the base 10 log
     def log10
-        ArelExtensions::Nodes::Log10.new [self]
+      ArelExtensions::Nodes::Log10.new [self]
     end
 
     # function gives the power of a number
     def pow exposant = 0
-        ArelExtensions::Nodes::Power.new [self,exposant]
+      ArelExtensions::Nodes::Power.new [self, exposant]
     end
 
     # function gives the power of a number
     def power exposant = 0
-        ArelExtensions::Nodes::Power.new [self,exposant]
+      ArelExtensions::Nodes::Power.new [self, exposant]
     end
 
     # Aggregate Functions
@@ -71,7 +71,7 @@ module ArelExtensions
     end
 
     def sum opts = {unbiased: true}
-      if Gem::Version.new(Arel::VERSION) >= Gem::Version.new("9.0.0")
+      if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('9.0.0')
         Arel::Nodes::Sum.new [self]
       else
         ArelExtensions::Nodes::Sum.new self, **opts
@@ -86,17 +86,17 @@ module ArelExtensions
 
     # function is used to round a numeric field to the number of decimals specified
     def round precision = nil
-        if precision
-            ArelExtensions::Nodes::Round.new [self, precision]
-        else
-            ArelExtensions::Nodes::Round.new [self]
-        end
+      if precision
+        ArelExtensions::Nodes::Round.new [self, precision]
+      else
+        ArelExtensions::Nodes::Round.new [self]
+      end
     end
 
     # function returning a number at a specific format
     def format_number format_string, locale = nil
       begin
-        sprintf(format_string,0) # this line is to get the right error message if the format_string is not correct
+        sprintf(format_string, 0) # this line is to get the right error message if the format_string is not correct
         m = /^(.*)%([ #+\-0]*)([1-9][0-9]+|[1-9]?)[.]?([0-9]*)([a-zA-Z])(.*)$/.match(format_string)
         opts = {
           prefix: m[1],
@@ -108,10 +108,10 @@ module ArelExtensions
           locale: locale,
           original_string: format_string
         }
-        # opts = {:locale => 'fr_FR', :type => "e"/"f"/"d", :prefix => "$ ", :suffix => " %", :flags => " +-#0", :width => 5, :precision => 6}
-        ArelExtensions::Nodes::FormattedNumber.new [self,opts]
+        # opts = {locale: 'fr_FR', type: "e"/"f"/"d", prefix: "$ ", suffix: " %", flags: " +-#0", width: 5, precision: 6}
+        ArelExtensions::Nodes::FormattedNumber.new [self, opts]
       rescue Exception
-        Arel::Nodes.build_quoted('Wrong Format')
+        Arel.quoted('Wrong Format')
       end
     end
   end

data/lib/arel_extensions/nodes/blank.rb

@@ -16,7 +16,7 @@ module ArelExtensions
       RETURN_TYPE = :boolean
 
       def initialize expr
-          super expr.first
+        super expr.first
       end
     end
   end

data/lib/arel_extensions/nodes/case.rb

@@ -1,8 +1,6 @@
-require 'arel_extensions/helpers'
-
 module ArelExtensions
   module Nodes
-    if Gem::Version.new(Arel::VERSION) < Gem::Version.new("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
@@ -46,7 +44,7 @@ module ArelExtensions
 
       def return_type
         obj = if @conditions.length > 0
-            @conditions.last.right
+                @conditions.last.right
           elsif @default
             @default.expr
           end
@@ -56,10 +54,10 @@ module ArelExtensions
           case obj
           when Integer, Float
             :number
-          when Date, DateTime,Time
+          when Date, DateTime, Time
             :datetime
           when Arel::Attributes::Attribute
-            ArelExtensions::column_of(obj.relation.table_name, obj.name.to_s)&.type || :string
+            Arel.column_of(obj.relation.table_name, obj.name.to_s)&.type || :string
           else
             :string
           end

data/lib/arel_extensions/nodes/cast.rb

@@ -19,11 +19,11 @@ module ArelExtensions
         when 'text', :text, 'ntext', :ntext
           @as_attr = expr[1].to_sym
           @return_type = :string
-        when :datetime, 'datetime','smalldatetime'
+        when :datetime, 'datetime', 'smalldatetime'
           @return_type = :datetime
-        when :time,'time'
+        when :time, 'time'
           @return_type = :time
-        when :date,'date'
+        when :date, 'date'
           @return_type = :date
         when :binary, 'binary', 'varbinary', 'image'
           @return_type = :binary
@@ -32,13 +32,13 @@ module ArelExtensions
           @as_attr = :string
         end
         tab = [convert_to_node(expr.first)]
-        return super(tab)
+        super(tab)
       end
 
       def +(other)
         case @return_type
         when :string
-          return ArelExtensions::Nodes::Concat.new [self, other]
+          ArelExtensions::Nodes::Concat.new [self, other]
         when :ruby_time
           ArelExtensions::Nodes::DateAdd.new [self, other]
         else

data/lib/arel_extensions/nodes/coalesce.rb

@@ -27,7 +27,7 @@ module ArelExtensions
         when DateTime, Time
           @left_node_type = :ruby_time
         end
-        return super(tab)
+        super(tab)
       end
     end
   end

data/lib/arel_extensions/nodes/collate.rb

@@ -1,17 +1,17 @@
 module ArelExtensions
   module Nodes
     class Collate < Function
-    RETURN_TYPE = :string
+      RETURN_TYPE = :string
 
-    attr_accessor :ai, :ci, :option
+      attr_accessor :ai, :ci, :option
 
-    def initialize left, option = nil, ai = false, ci = false
-      @ai = ai
-      @ci = ci
-      @option = option
-      tab = [convert_to_node(left)]
-      return super(tab)
-    end
+      def initialize left, option = nil, ai = false, ci = false
+        @ai = ai
+        @ci = ci
+        @option = option
+        tab = [convert_to_node(left)]
+        super(tab)
+      end
     end
   end
 end

data/lib/arel_extensions/nodes/concat.rb

@@ -13,10 +13,10 @@ module ArelExtensions::Nodes
         end
       }.flatten.reduce([]) { |res, b|
         # concatenate successive literal strings.
-        if b.is_a?(Arel::Nodes::Quoted) && b.expr == ""
+        if b.is_a?(Arel::Nodes::Quoted) && b.expr == ''
           res
         elsif res.last && res.last.is_a?(Arel::Nodes::Quoted) && b.is_a?(Arel::Nodes::Quoted)
-          res[-1] = Arel::Nodes.build_quoted(res.last.expr + b.expr)
+          res[-1] = Arel.quoted(res.last.expr + b.expr)
         else
           res << b
         end

data/lib/arel_extensions/nodes/date_diff.rb

@@ -19,7 +19,7 @@ module ArelExtensions
         when DateTime, Time
           @left_node_type = :ruby_time
         end
-        res << ([:date, :ruby_date].include?(@left_node_type) ? convert_to_date_node(col) : convert_to_datetime_node(col))
+        res << (%i[date ruby_date].include?(@left_node_type) ? convert_to_date_node(col) : convert_to_datetime_node(col))
         case expr[1]
         when Arel::Nodes::Node, Arel::Attributes::Attribute
           @right_node_type = type_of_attribute(expr[1])
@@ -28,7 +28,7 @@ module ArelExtensions
         when DateTime, Time
           @right_node_type = :ruby_time
         end
-        res << ([:date, :ruby_date].include?(@left_node_type) ? convert_to_date_node(expr[1]) : convert_to_datetime_node(expr[1]))
+        res << (%i[date ruby_date].include?(@left_node_type) ? convert_to_date_node(expr[1]) : convert_to_datetime_node(expr[1]))
         super res
       end
     end
@@ -43,19 +43,19 @@ module ArelExtensions
         tab = expr.map do |arg|
           convert(arg)
         end
-        return super(tab)
+        super(tab)
       end
 
       def sqlite_value
         v = self.expressions.last
         if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
           if @date_type == :date
-            return Arel::Nodes.build_quoted((v.value >= 0 ? '+' : '-') + v.inspect)
+            Arel.quoted((v.value >= 0 ? '+' : '-') + v.inspect)
           elsif @date_type == :datetime
-            return Arel::Nodes.build_quoted((v.value >= 0 ? '+' : '-') + v.inspect)
+            Arel.quoted((v.value >= 0 ? '+' : '-') + v.inspect)
           end
         else
-          return v
+          v
         end
       end
 
@@ -115,7 +115,7 @@ module ArelExtensions
         v ||= self.expressions.last
         if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
           if @date_type == :date
-            v.to_i / (24*3600)
+            v.to_i / (24 * 3600)
           elsif @date_type == :datetime
             if v.parts.size == 1
               #       first entry in the dict v.parts; one of [:years, :months, :weeks, :days, :hours, :minutes, :seconds]
@@ -155,9 +155,9 @@ module ArelExtensions
           if ArelExtensions::Nodes::Duration === v
             v.with_interval = true
             case v.left
-            when 'd','m','y'
+            when 'd', 'm', 'y'
               Arel.sql('day')
-            when 'h','mn','s'
+            when 'h', 'mn', 's'
               Arel.sql('second')
             when /i\z/
               Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left[0..-2]])
@@ -179,7 +179,7 @@ module ArelExtensions
         when DateTime, Time, Date
           raise(ArgumentError, "#{object.class} cannot be converted to Integer")
         when String
-          Arel::Nodes.build_quoted(object)
+          Arel.quoted(object)
         else
           raise(ArgumentError, "#{object.class} cannot be converted to Integer")
         end

data/lib/arel_extensions/nodes/formatted_number.rb

@@ -3,10 +3,10 @@ module ArelExtensions
     class FormattedNumber < Function
       RETURN_TYPE = :string
 
-      attr_accessor :locale, :prefix, :suffix, :flags, :scientific_notation, :width,:precision, :type, :original_string
+      attr_accessor :locale, :prefix, :suffix, :flags, :scientific_notation, :width, :precision, :type, :original_string
 
       def initialize expr
-        # expr[1] = {:locale => 'fr_FR', :type => "e"/"f"/"d", :prefix => "$ ", :suffix => " %", :flags => " +-#0", :width => 5, :precision => 6}
+        # expr[1] = {locale: 'fr_FR', type: "e"/"f"/"d", prefix: "$ ", suffix: " %", flags: " +-#0", width: 5, precision: 6}
         col = expr.first
         @locale = expr[1][:locale]
         @prefix = expr[1][:prefix]

data/lib/arel_extensions/nodes/function.rb

@@ -22,14 +22,14 @@ module ArelExtensions
 
       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")
+        if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('9.0.0')
           self.alias = Arel.sql(other)
         end
         res
       end
 
       def expr
-         @expressions.first
+        @expressions.first
       end
 
       def left
@@ -41,17 +41,17 @@ module ArelExtensions
       end
 
       def ==(other)
-        Arel::Nodes::Equality.new self, Arel::Nodes.build_quoted(other, self)
+        Arel::Nodes::Equality.new self, Arel.quoted(other, self)
       end
 
       def !=(other)
-        Arel::Nodes::NotEqual.new self, Arel::Nodes.build_quoted(other, self)
+        Arel::Nodes::NotEqual.new self, Arel.quoted(other, self)
       end
 
       def type_of_attribute(att)
         case att
         when Arel::Attributes::Attribute
-          ArelExtensions::column_of(att.relation.table_name, att.name.to_s)&.type || att
+          Arel.column_of(att.relation.table_name, att.name.to_s)&.type || att
         when ArelExtensions::Nodes::Function
           att.return_type
           #        else
@@ -64,13 +64,13 @@ module ArelExtensions
         when Arel::Attributes::Attribute, Arel::Nodes::Node, Integer
           object
         when DateTime
-          Arel::Nodes.build_quoted(object, self)
+          Arel.quoted(object, self)
         when Time
-          Arel::Nodes.build_quoted(object.strftime('%H:%M:%S'), self)
+          Arel.quoted(object.strftime('%H:%M:%S'), self)
         when MBSTRING, String, Symbol
-          Arel::Nodes.build_quoted(object.to_s)
+          Arel.quoted(object.to_s)
         when Date
-          Arel::Nodes.build_quoted(object.to_s, self)
+          Arel.quoted(object.to_s, self)
         when NilClass
           Arel.sql('NULL')
         when ActiveSupport::Duration
@@ -87,7 +87,7 @@ module ArelExtensions
         when Arel::Nodes::Node
           object
         when Integer
-          Arel::Nodes.build_quoted(object.to_s)
+          Arel.quoted(object.to_s)
         when Arel::Attributes::Attribute
           case self.type_of_attribute(object)
           when :date
@@ -98,17 +98,17 @@ module ArelExtensions
             object
           end
         when DateTime
-          Arel::Nodes.build_quoted(object, self)
+          Arel.quoted(object, self)
         when Time
-          Arel::Nodes.build_quoted(object.strftime('%H:%M:%S'), self)
+          Arel.quoted(object.strftime('%H:%M:%S'), self)
         when MBSTRING, String
-          Arel::Nodes.build_quoted(object.to_s)
+          Arel.quoted(object.to_s)
         when Date
-          Arel::Nodes.build_quoted(object, self)
+          Arel.quoted(object, self)
         when NilClass
           Arel.sql(nil)
         when ActiveSupport::Duration
-          Arel::Nodes.build_quoted(object.to_i.to_s)
+          Arel.quoted(object.to_i.to_s)
         else
           raise(ArgumentError, "#{object.class} cannot be converted to CONCAT arg")
         end
@@ -119,11 +119,11 @@ module ArelExtensions
         when Arel::Attributes::Attribute, Arel::Nodes::Node
           object
         when DateTime, Time
-          Arel::Nodes.build_quoted(Date.new(object.year, object.month, object.day), self)
+          Arel.quoted(Date.new(object.year, object.month, object.day), self)
         when MBSTRING, String
-          Arel::Nodes.build_quoted(Date.parse(object.to_s), self)
+          Arel.quoted(Date.parse(object.to_s), self)
         when Date
-          Arel::Nodes.build_quoted(object, self)
+          Arel.quoted(object, self)
         else
           raise(ArgumentError, "#{object.class} cannot be converted to Date")
         end
@@ -134,11 +134,11 @@ module ArelExtensions
         when Arel::Attributes::Attribute, Arel::Nodes::Node
           object
         when DateTime, Time
-          Arel::Nodes.build_quoted(object, self)
+          Arel.quoted(object, self)
         when MBSTRING, String
-          Arel::Nodes.build_quoted(Time.parse(object.to_s), self)
+          Arel.quoted(Time.parse(object.to_s), self)
         when Date
-          Arel::Nodes.build_quoted(Time.utc(object.year, object.month, object.day, 0, 0, 0), self)
+          Arel.quoted(Time.utc(object.year, object.month, object.day, 0, 0, 0), self)
         else
           raise(ArgumentError, "#{object.class} cannot be converted to Datetime")
         end

data/lib/arel_extensions/nodes/json.rb

@@ -11,15 +11,15 @@ module ArelExtensions
       end
 
       def get key
-        JsonGet.new(self,key)
+        JsonGet.new(self, key)
       end
 
       def set key, value
-        JsonSet.new(self,key,value)
+        JsonSet.new(self, key, value)
       end
 
       def group as_array = true, orders = nil
-        JsonGroup.new(self,as_array, orders)
+        JsonGroup.new(self, as_array, orders)
       end
 
       def hash
@@ -32,19 +32,19 @@ module ArelExtensions
           n.dict
         when Array
           n.map{|e|
-             (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_json_node(e)
+            (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_json_node(e)
           }
         when Hash
-          n.reduce({}){|acc,v|
+          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"))
+          convert_to_node(n.strftime('%Y-%m-%d'))
         when DateTime, Time
-          convert_to_node(n.strftime("%Y-%m-%dT%H:%M:%S.%L%:z"))
+          convert_to_node(n.strftime('%Y-%m-%dT%H:%M:%S.%L%:z'))
         when NilClass
           Arel.null
         when Arel::SelectManager

data/lib/arel_extensions/nodes/levenshtein_distance.rb

@@ -4,7 +4,7 @@ module ArelExtensions
       RETURN_TYPE = :number
 
       def initialize expr
-        super [convert_to_node(expr.first), Arel::Nodes.build_quoted(expr[1])]
+        super [convert_to_node(expr.first), Arel.quoted(expr[1])]
       end
     end
   end

data/lib/arel_extensions/nodes/locate.rb

@@ -7,7 +7,7 @@ module ArelExtensions
         tab = expr.map do |arg|
           convert_to_node(arg)
         end
-        return super(tab)
+        super(tab)
       end
     end
   end

data/lib/arel_extensions/nodes/matches.rb

@@ -4,7 +4,7 @@ module ArelExtensions
       attr_accessor :case_sensitive if Arel::VERSION.to_i < 7
 
       def initialize(left, right, escape = nil)
-        r = Arel::Nodes.build_quoted(right)
+        r = Arel.quoted(right)
         if Arel::VERSION.to_i < 7 # managed by default in version 7+ (rails 5), so useful for rails 3 & 4
           super(left, r, escape)
           @case_sensitive = false