arel_extensions 2.3.3 → 2.5.0

data/lib/arel_extensions/nodes/substring.rb

@@ -3,13 +3,63 @@ module ArelExtensions
     class Substring < Function
       RETURN_TYPE = :string
 
-      def initialize expr
-        tab = [convert_to_node(expr[0]), convert_to_node(expr[1])]
+      def initialize(expr)
+        start = expr[1]
+        if start.is_a?(Range) && expr[2]
+          raise ArgumentError, 'cannot pass a length together with a Range start; the Range already determines the extracted length'
+        end
+
+        tab = [convert_to_node(expr[0]), start.is_a?(Range) ? start : convert_to_node(start)]
         if expr[2]
           tab << convert_to_node(expr[2])
         end
         super(tab)
       end
+
+      def range?
+        expressions[1].is_a?(Range)
+      end
+
+      # Builds the vendor-agnostic Arel node tree reproducing Ruby's
+      # `String#[Range]` semantics: endless/beginless ranges, negative
+      # "from the end" indices, `exclude_end?`, and Ruby's `nil`-vs-`""`
+      # distinction (out of range vs valid-but-empty).
+      #
+      # Only meaningful when `#range?` is true; visitors need to check
+      # that first, then `visit` the node this returns.
+      def range_substring_node
+        col = expressions[0]
+        range = expressions[1]
+        b = range.begin
+        e = range.end
+        n = col.char_length
+
+        b_idx =
+          if b.nil?
+            0
+          elsif b.negative?
+            n + b
+          else
+            b
+          end
+
+        e_idx =
+          if e.nil?
+            n
+          else
+            raw = e.negative? ? n + e : e
+            range.exclude_end? ? raw : raw + 1
+          end
+
+        e_idx_clamped = Arel.when(n < e_idx).then(n).else(e_idx)
+
+        cases = Arel.when(col.is_null).then(Arel.quoted(nil))
+        cases = cases.when(n < b_idx).then(Arel.quoted(nil))
+        cases = cases.when(b_idx < 0).then(Arel.quoted(nil)) if b.is_a?(Integer) && b.negative?
+        cases
+          .when(e_idx_clamped <= b_idx).then(Arel.quoted(''))
+          .else(Substring.new([col, b_idx + 1, e_idx_clamped - b_idx]))
+      end
     end
   end
 end

data/lib/arel_extensions/nodes/then.rb

@@ -1,7 +1,7 @@
 module ArelExtensions
   module Nodes
     class Then < Function
-      def initialize expr
+      def initialize(expr)
         tab = expr.map { |arg|
           convert_to_node(arg)
         }

data/lib/arel_extensions/nodes/trim.rb

@@ -3,7 +3,7 @@ module ArelExtensions
     class Trim < Function
       RETURN_TYPE = :string
 
-      def initialize expr
+      def initialize(expr)
         tab = expr.map { |arg|
           convert_to_node(arg)
         }
@@ -11,7 +11,7 @@ module ArelExtensions
       end
 
       def +(other)
-        ArelExtensions::Nodes::Concat.new(self.expressions + [other])
+        ArelExtensions::Nodes::Concat.new(expressions + [other])
       end
     end
 

data/lib/arel_extensions/nodes/union.rb

@@ -1,8 +1,8 @@
 module ArelExtensions
   module Nodes
     class Union < Arel::Nodes::Union
-      def initialize left, right
-        super(left, right)
+      def initialize(left, right)
+        super
       end
 
       def +(other)
@@ -13,7 +13,7 @@ module ArelExtensions
         ArelExtensions::Nodes::UnionAll.new(self, other)
       end
 
-      def as other
+      def as(other)
         Arel::Nodes::TableAlias.new Arel.grouping(self), Arel::Nodes::SqlLiteral.new(other.to_s)
       end
     end

data/lib/arel_extensions/nodes/union_all.rb

@@ -1,15 +1,15 @@
 module ArelExtensions
   module Nodes
     class UnionAll < Arel::Nodes::UnionAll
-      def initialize left, right
-        super(left, right)
+      def initialize(left, right)
+        super
       end
 
       def union_all(other)
         ArelExtensions::Nodes::UnionAll.new(self, other)
       end
 
-      def as other
+      def as(other)
         Arel::Nodes::TableAlias.new Arel.grouping(self), Arel::Nodes::SqlLiteral.new(other.to_s)
       end
     end

data/lib/arel_extensions/nodes/wday.rb

@@ -1,8 +1,8 @@
 module ArelExtensions
   module Nodes
     class Wday < Function
-      def initialize other, aliaz = nil
-        tab = Array.new
+      def initialize(other, aliaz = nil)
+        tab = []
         tab << other
         super(tab, aliaz)
       end

data/lib/arel_extensions/null_functions.rb

@@ -3,10 +3,9 @@ require 'arel_extensions/nodes/is_null'
 
 module ArelExtensions
   module NullFunctions
-
     # if_present returns nil if the the value is nil or blank
     def if_present
-      Arel.when(self.cast(:string).present).then(self)
+      Arel.when(cast(:string).present).then(self)
     end
 
     # ISNULL function lets you return an alternative value when an expression is NULL.
@@ -21,19 +20,18 @@ module ArelExtensions
 
     # returns the first non-null expr in the expression list. You must specify at least two expressions.
     # If all occurrences of expr evaluate to null, then the function returns null.
-    def coalesce *args
+    def coalesce(*args)
       args.unshift(self)
       ArelExtensions::Nodes::Coalesce.new args
     end
 
-    def coalesce_blank *args
-      res = Arel.when(self.cast(:string).present).then(self)
+    def coalesce_blank(*args)
+      res = Arel.when(cast(:string).present).then(self)
       args[0...-1].each do |a|
         val = a.is_a?(Arel::Nodes::Node) ? a : Arel.quoted(a)
         res = res.when(val.present).then(a)
       end
-      res = res.else(args[-1])
-      res
+      res.else(args[-1])
     end
   end
 end

data/lib/arel_extensions/predications.rb

@@ -1,11 +1,11 @@
 module ArelExtensions
   module Predications
-    def when right, expression = nil
+    def when(right, expression = nil)
       ArelExtensions::Nodes::Case.new(self).when(right, expression)
     end
 
     def matches(other, escape = nil, case_sensitive = nil)
-      if Arel::VERSION.to_i < 7
+      if AREL_VERSION < V7
         Arel::Nodes::Matches.new(self, Arel.quoted(other), escape)
       else
         Arel::Nodes::Matches.new(self, Arel.quoted(other), escape, case_sensitive)
@@ -16,7 +16,7 @@ module ArelExtensions
       ArelExtensions::Nodes::IMatches.new(self, other, escape)
     end
 
-    def cast right
+    def cast(right)
       ArelExtensions::Nodes::Cast.new([self, right])
     end
 
@@ -24,23 +24,24 @@ module ArelExtensions
       other = other.first if other.length <= 1
       case other
       when Range
-        self.between(other)
+        between(other)
       when Arel::Nodes::Grouping, ArelExtensions::Nodes::Union, ArelExtensions::Nodes::UnionAll
         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)}
+        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 [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) \
+             when 0 then []
+             when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? self.in(values[0]) : eq(values[0])]
+             else [Arel::Nodes::In.new(self, quoted_array(values))]
+             end) \
           + ranges.uniq.map { |r| self.in(r) }
         clauses.empty? ? Arel.false : clauses.reduce(&:or)
       when nil
-        self.is_null
+        is_null
       when Arel::SelectManager
         Arel::Nodes::In.new(self, other.ast)
       else
@@ -52,23 +53,24 @@ module ArelExtensions
       other = other.first if other.length <= 1
       case other
       when Range
-        Arel::Nodes::Not.new(self.between(other))
+        Arel::Nodes::Not.new(between(other))
       when Arel::Nodes::Grouping, ArelExtensions::Nodes::Union, ArelExtensions::Nodes::UnionAll
         Arel::Nodes::NotIn.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)}
+        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) } \
+          nils.uniq.map { |r| 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) }
+             when 0 then []
+             when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? not_in(values[0]) : not_eq(values[0])]
+             else [Arel::Nodes::NotIn.new(self, quoted_array(values))]
+             end) \
+          + ranges.uniq.map { |r| not_in(r) }
         Arel::Nodes::And.new clauses
       when nil
-        self.is_not_null
+        is_not_null
       when Arel::SelectManager
         Arel::Nodes::NotIn.new(self, other.ast)
       else
@@ -86,6 +88,8 @@ module ArelExtensions
         Arel.quoted(object.strftime('%H:%M:%S'), self)
       when String
         Arel.quoted(object)
+      when TrueClass, FalseClass
+        Arel.quoted(object)
       when Date
         Arel.quoted(object.to_s, self)
       when NilClass

data/lib/arel_extensions/string_functions.rb

@@ -1,3 +1,5 @@
+require 'arel_extensions/nodes/byte_size'
+require 'arel_extensions/nodes/char_length'
 require 'arel_extensions/nodes/concat' # if Arel::VERSION.to_i < 7
 require 'arel_extensions/nodes/length'
 require 'arel_extensions/nodes/locate'
@@ -16,37 +18,44 @@ require 'arel_extensions/nodes/collate'
 require 'arel_extensions/nodes/levenshtein_distance'
 require 'arel_extensions/nodes/md5'
 
-
 module ArelExtensions
   module StringFunctions
+    include ArelExtensions::Warning
+
     # *FindInSet function .......
     def &(other)
       ArelExtensions::Nodes::FindInSet.new [
         Arel.quoted(other.is_a?(Integer) ? other.to_s : other),
-        self,
+        self
       ]
     end
 
     # LENGTH function returns the length (bytewise) of the value in a text field.
     def length
+      deprecated "Use `byte_size` or `char_length` instead. `length` relies on the vendor's `LEN/LENGTH` implementation and it's not portable"
       ArelExtensions::Nodes::Length.new self, true
     end
 
     def byte_length
+      deprecated "Use `byte_size` instead. `byte_length` relies on the vendor's `LEN/LENGTH` implementation and it's not portable"
       ArelExtensions::Nodes::Length.new self, true
     end
 
+    def byte_size
+      ArelExtensions::Nodes::ByteSize.new self
+    end
+
     def char_length
-      ArelExtensions::Nodes::Length.new self, false
+      ArelExtensions::Nodes::CharLength.new self
     end
 
     # LOCATE function returns the first starting position of a string in another string.
     # If string1 or string2 is NULL then it returns NULL. If string1 not found in string2 then it returns 0.
-    def locate val
+    def locate(val)
       ArelExtensions::Nodes::Locate.new [self, val]
     end
 
-    def substring start, len = nil
+    def substring(start, len = nil)
       ArelExtensions::Nodes::Substring.new [self, start, len]
     end
 
@@ -61,9 +70,9 @@ module ArelExtensions
     #   It's ignored in all other cases.
     def [](start, end_ = nil)
       if start.is_a?(String) || start.is_a?(Symbol)
-        self.send(start)
+        send(start)
       elsif start.is_a?(Range)
-        ArelExtensions::Nodes::Substring.new [self, start.begin + 1, start.end - start.begin + 1]
+        ArelExtensions::Nodes::Substring.new [self, start]
       elsif start.is_a?(Integer) && !end_
         ArelExtensions::Nodes::Substring.new [self, start + 1, 1]
       elsif start.is_a?(Integer)
@@ -79,11 +88,11 @@ module ArelExtensions
       ArelExtensions::Nodes::Soundex.new [self]
     end
 
-    def imatches others, escape = nil
+    def imatches(others, escape = nil)
       ArelExtensions::Nodes::IMatches.new self, others, escape
     end
 
-    def imatches_any others, escape = nil
+    def imatches_any(others, escape = nil)
       grouping_any :imatches, others, escape
     end
 
@@ -100,31 +109,31 @@ module ArelExtensions
     #      res
     #    end
 
-    def imatches_all others, escape = nil
+    def imatches_all(others, escape = nil)
       grouping_all :imatches, others, escape, escape
     end
 
-    def idoes_not_match others, escape = nil
+    def idoes_not_match(others, escape = nil)
       ArelExtensions::Nodes::IDoesNotMatch.new self, others, escape
     end
 
-    def idoes_not_match_any others, escape = nil
+    def idoes_not_match_any(others, escape = nil)
       grouping_any :idoes_not_match, others, escape
     end
 
-    def idoes_not_match_all others, escape = nil
+    def idoes_not_match_all(others, escape = nil)
       grouping_all :idoes_not_match, others, escape
     end
 
-    def ai_matches other # accent insensitive & case sensitive
+    def ai_matches(other) # accent insensitive & case sensitive
       ArelExtensions::Nodes::AiMatches.new(self, other)
     end
 
-    def ai_imatches other # accent insensitive & case insensitive
+    def ai_imatches(other) # accent insensitive & case insensitive
       ArelExtensions::Nodes::AiIMatches.new(self, other)
     end
 
-    def smatches other # accent sensitive & case sensitive
+    def smatches(other) # accent sensitive & case sensitive
       ArelExtensions::Nodes::SMatches.new(self, other)
     end
 
@@ -136,12 +145,12 @@ module ArelExtensions
       ArelExtensions::Nodes::Collate.new(self, nil, false, true)
     end
 
-    def collate ai = false, ci = false, option = nil
+    def collate(ai = false, ci = false, option = nil)
       ArelExtensions::Nodes::Collate.new(self, option, ai, ci)
     end
 
     # REPLACE function replaces a sequence of characters in a string with another set of characters, not case-sensitive.
-    def replace pattern, substitute
+    def replace(pattern, substitute)
       if pattern.is_a? Regexp
         ArelExtensions::Nodes::RegexpReplace.new self, pattern, substitute
       else
@@ -149,11 +158,11 @@ module ArelExtensions
       end
     end
 
-    def regexp_replace pattern, substitute
+    def regexp_replace(pattern, substitute)
       ArelExtensions::Nodes::RegexpReplace.new self, pattern, substitute
     end
 
-    def concat other
+    def concat(other)
       ArelExtensions::Nodes::Concat.new [self, other]
     end
 
@@ -162,26 +171,26 @@ module ArelExtensions
       if orders.present?
         deprecated 'Use the kwarg `order` instead.', what: 'orders'
       end
-      order_tabs = [orders].flatten.map{ |o|
+      order_tabs = [orders].flatten.map { |o|
         if o.is_a?(Arel::Nodes::Ascending) || o.is_a?(Arel::Nodes::Descending)
           o
         elsif o.respond_to?(:asc)
           o.asc
         end
       }.compact
-      ArelExtensions::Nodes::GroupConcat.new(self, sep, group: group, order: (order || order_tabs))
+      ArelExtensions::Nodes::GroupConcat.new(self, sep, group: group, order: order || order_tabs)
     end
 
     # Function returns a string after removing left, right or the both prefixes or suffixes int argument
-    def trim other = ' '
+    def trim(other = ' ')
       ArelExtensions::Nodes::Trim.new [self, other]
     end
 
-    def ltrim other = ' '
+    def ltrim(other = ' ')
       ArelExtensions::Nodes::Ltrim.new [self, other]
     end
 
-    def rtrim other = ' '
+    def rtrim(other = ' ')
       ArelExtensions::Nodes::Rtrim.new [self, other]
     end
 
@@ -202,15 +211,15 @@ module ArelExtensions
     end
     alias present not_blank
 
-    def repeat other = 1
+    def repeat(other = 1)
       ArelExtensions::Nodes::Repeat.new [self, other]
     end
 
-    def levenshtein_distance other
+    def levenshtein_distance(other)
       ArelExtensions::Nodes::LevenshteinDistance.new [self, other]
     end
 
-    def edit_distance other
+    def edit_distance(other)
       ArelExtensions::Nodes::LevenshteinDistance.new [self, other]
     end
 

data/lib/arel_extensions/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArelExtensions
-  VERSION = '2.3.3'.freeze
+  VERSION = '2.5.0'
 end

data/lib/arel_extensions/visitors/convert_format.rb

@@ -2,13 +2,13 @@ module ArelExtensions
   module Visitors
     # Convert date format in strftime syntax to whatever the RDBMs
     # wants, based on the table of conversion +mapping+.
-    def self.strftime_to_format format, mapping
+    def self.strftime_to_format(format, mapping)
       @mapping_regexps ||= {}
       @mapping_regexps[mapping] ||=
         Regexp.new(
           mapping
             .keys
-            .map{|k| Regexp.escape(k)}
+            .map { |k| Regexp.escape(k) }
             .join('|')
         )
 

data/lib/arel_extensions/visitors/ibm_db.rb

@@ -1,14 +1,14 @@
 module ArelExtensions
   module Visitors
     class Arel::Visitors::IBM_DB
-      def visit_ArelExtensions_Nodes_Ceil o, collector
+      def visit_ArelExtensions_Nodes_Ceil(o, collector)
         collector << 'CEILING('
         collector = visit o.expr, collector
         collector << ')'
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Trim o, collector
+      def visit_ArelExtensions_Nodes_Trim(o, collector)
         collector << 'LTRIM(RTRIM('
         o.expressions.each_with_index { |arg, i|
           collector << COMMA if i != 0
@@ -18,7 +18,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_DateDiff o, collector
+      def visit_ArelExtensions_Nodes_DateDiff(o, collector)
         collector << 'DAY('
         collector = visit o.left, collector
         collector << ','
@@ -31,7 +31,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Duration o, collector
+      def visit_ArelExtensions_Nodes_Duration(o, collector)
         # visit left for period
         if o.left == 'd'
           collector << 'DAY('
@@ -52,7 +52,7 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_IsNull o, collector
+      def visit_ArelExtensions_Nodes_IsNull(o, collector)
         collector << 'COALESCE('
         collector = visit o.left, collector
         collector << ','