arel_extensions 2.4.0 → 2.5.0

data/lib/arel_extensions/nodes/json.rb

@@ -5,20 +5,20 @@ module ArelExtensions
 
       attr_accessor :dict
 
-      def merge *expr
-        args = [self] + expr.map{|e| Json.new(e)}
+      def merge(*expr)
+        args = [self] + expr.map { |e| Json.new(e) }
         JsonMerge.new(args)
       end
 
-      def get key
+      def get(key)
         JsonGet.new(self, key)
       end
 
-      def set key, value
+      def set(key, value)
         JsonSet.new(self, key, value)
       end
 
-      def group as_array = true, orders = nil, distinct: false
+      def group(as_array = true, orders = nil, distinct: false)
         if distinct
           JsonGroup.new(Arel::Nodes::NamedFunction.new('DISTINCT', [self]), as_array, orders)
         else
@@ -35,12 +35,12 @@ module ArelExtensions
         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)
+          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])
+          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
@@ -58,9 +58,21 @@ module ArelExtensions
         end
       end
 
+      # A boolean literal, either bare (TrueClass/FalseClass) or wrapped in a Quoted node
+      # (which is how `convert_to_node` represents one after construction).
+      def boolean_literal?(v)
+        v.is_a?(TrueClass) \
+          || v.is_a?(FalseClass) \
+          || (v.is_a?(Arel::Nodes::Quoted) && [true, false].include?(v.expr))
+      end
+
       def type_of_node(v)
         if v.is_a?(Arel::Attributes::Attribute)
-          self.type_of_attribute(v)
+          type_of_attribute(v)
+        elsif v.is_a?(Numeric)
+          :numeric
+        elsif boolean_literal?(v)
+          :boolean
         elsif v.respond_to?(:return_type)
           v.return_type
         elsif v.nil?
@@ -72,12 +84,12 @@ module ArelExtensions
     end
 
     class Json < JsonNode
-      def initialize *expr
+      def initialize(*expr)
         @dict =
           if expr.length == 1
             convert_to_json_node(expr.first)
           else
-            expr.map{|e| convert_to_json_node(e) }
+            expr.map { |e| convert_to_json_node(e) }
           end
         super
       end
@@ -89,7 +101,7 @@ module ArelExtensions
     class JsonGroup < JsonNode
       attr_accessor :as_array, :orders
 
-      def initialize json, as_array = true, orders = nil
+      def initialize(json, as_array = true, orders = nil)
         @dict = as_array ? json : json.dict
         @as_array = as_array
         if orders
@@ -101,7 +113,7 @@ module ArelExtensions
     class JsonGet < JsonNode
       attr_accessor :key
 
-      def initialize json, key
+      def initialize(json, key)
         @dict = json
         @key = convert_to_node(key)
       end
@@ -110,7 +122,7 @@ module ArelExtensions
     class JsonSet < JsonNode
       attr_accessor :key, :value
 
-      def initialize json, key, value
+      def initialize(json, key, value)
         @dict = json
         @key = convert_to_node(key)
         @value = Json.new(value)

data/lib/arel_extensions/nodes/levenshtein_distance.rb

@@ -3,8 +3,8 @@ module ArelExtensions
     class LevenshteinDistance < Function
       RETURN_TYPE = :number
 
-      def initialize expr
-        super [convert_to_node(expr.first), Arel.quoted(expr[1])]
+      def initialize(expr)
+        super([convert_to_node(expr.first), Arel.quoted(expr[1])])
       end
     end
   end

data/lib/arel_extensions/nodes/locate.rb

@@ -3,7 +3,7 @@ module ArelExtensions
     class Locate < Function
       RETURN_TYPE = :integer
 
-      def initialize expr
+      def initialize(expr)
         tab = expr.map do |arg|
           convert_to_node(arg)
         end

data/lib/arel_extensions/nodes/power.rb

@@ -3,8 +3,8 @@ module ArelExtensions
     class Power < Function
       RETURN_TYPE = :number
 
-      def initialize expr
-        super [convert_to_node(expr.first), convert_to_number(expr[1])]
+      def initialize(expr)
+        super([convert_to_node(expr.first), convert_to_number(expr[1])])
       end
     end
   end

data/lib/arel_extensions/nodes/rand.rb

@@ -5,9 +5,9 @@ module ArelExtensions
 
       def initialize(seed = nil)
         if seed && seed.length == 1
-          super seed
+          super
         else
-          super []
+          super([])
         end
       end
     end

data/lib/arel_extensions/nodes/repeat.rb

@@ -3,7 +3,7 @@ module ArelExtensions
     class Repeat < 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
   end

data/lib/arel_extensions/nodes/replace.rb

@@ -4,7 +4,7 @@ module ArelExtensions
       RETURN_TYPE = :string
       attr_accessor :left, :pattern, :substitute
 
-      def initialize left, pattern, substitute
+      def initialize(left, pattern, substitute)
         @left = convert_to_node(left)
         @pattern = convert_to_node(pattern)
         @substitute = convert_to_node(substitute)
@@ -16,9 +16,9 @@ module ArelExtensions
       RETURN_TYPE = :string
       attr_accessor :left, :pattern, :substitute
 
-      def initialize left, pattern, substitute
+      def initialize(left, pattern, substitute)
         @left = convert_to_node(left)
-        @pattern = (pattern.is_a?(Regexp) ? pattern : %r[#{pattern}])
+        @pattern = (pattern.is_a?(Regexp) ? pattern : /#{pattern}/)
         @substitute = convert_to_node(substitute)
         super([@left, @pattern, @substitute])
       end

data/lib/arel_extensions/nodes/rollup.rb

@@ -3,7 +3,7 @@
 
 begin
   Arel::Nodes.const_get('RollUp')
-rescue NameError => _
+rescue NameError => _e
   module Arel
     module Nodes
       class RollUp < Arel::Nodes::Unary
@@ -18,16 +18,16 @@ rescue NameError => _
         # handle grouping aggregation semantics
         def grouping_array_or_grouping_element(o, collector)
           if o.expr.is_a? Array
-            collector << "( "
+            collector << '( '
             visit o.expr, collector
-            collector << " )"
+            collector << ' )'
           else
             visit o.expr, collector
           end
         end
 
         def visit_Arel_Nodes_RollUp(o, collector)
-          collector << "ROLLUP"
+          collector << 'ROLLUP'
           grouping_array_or_grouping_element o, collector
         end
       end

data/lib/arel_extensions/nodes/round.rb

@@ -3,11 +3,11 @@ module ArelExtensions
     class Round < Function
       RETURN_TYPE = :number
 
-      def initialize expr
+      def initialize(expr)
         if expr && expr.length == 1
-          super [convert_to_node(expr.first)]
+          super([convert_to_node(expr.first)])
         else
-          super [convert_to_node(expr.first), convert_to_number(expr[1])]
+          super([convert_to_node(expr.first), convert_to_number(expr[1])])
         end
       end
     end

data/lib/arel_extensions/nodes/select.rb

@@ -3,7 +3,7 @@ module Arel
     class SelectCore
       # havings did not exist in rails < 5.2
       if !method_defined?(:havings)
-        alias :havings :having
+        alias havings having
       end
     end
   end

data/lib/arel_extensions/nodes/std.rb

@@ -4,9 +4,9 @@ module ArelExtensions
       RETURN_TYPE = :number
       attr_accessor :unbiased_estimator
 
-      def initialize node, **opts
+      def initialize(node, **opts)
         @unbiased_estimator = opts[:unbiased] ? true : false
-        super node, **opts
+        super
       end
     end
 
@@ -14,9 +14,9 @@ module ArelExtensions
       RETURN_TYPE = :number
       attr_accessor :unbiased_estimator
 
-      def initialize node, **opts
+      def initialize(node, **opts)
         @unbiased_estimator = opts[:unbiased] ? true : false
-        super node, **opts
+        super
       end
     end
   end

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,6 +1,6 @@
 module ArelExtensions
   module Predications
-    def when right, expression = nil
+    def when(right, expression = nil)
       ArelExtensions::Nodes::Case.new(self).when(right, expression)
     end
 
@@ -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