arel_extensions 2.0.21 → 2.2.2

data/lib/arel_extensions/math.rb

@@ -16,43 +16,44 @@ 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::Nodes::Grouping.new(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
-          Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+          Arel.grouping(Arel::Nodes::Addition.new self, other)
         when :date, :datetime
           ArelExtensions::Nodes::DateAdd.new [self, other]
         else
           self.concat(other)
         end
       when Arel::Nodes::Function
-        Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+        Arel.grouping(Arel::Nodes::Addition.new self, other)
       else
-        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))
+        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::Nodes::Grouping.new(Arel::Nodes::Addition.new self, 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::Nodes::Grouping.new(Arel::Nodes::Addition.new self, 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
@@ -68,42 +69,44 @@ module ArelExtensions
       case self
       when Arel::Nodes::Grouping
         if self.expr.left.is_a?(Date) || self.expr.left.is_a?(DateTime)
-          Arel::Nodes::Grouping.new(ArelExtensions::Nodes::DateSub.new [self, other])
+          Arel.grouping(ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)])
         else
-          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, 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::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other)) # ??
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other))) # ??
         when :integer, :decimal, :float, :number
-          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         when :date, :datetime
-          ArelExtensions::Nodes::DateSub.new [self, other]
+          ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)]
         else
-          Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         end
       when Arel::Nodes::Function
-        Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+        Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
       else
-        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))
+        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
-              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
+              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
@@ -123,11 +126,11 @@ module ArelExtensions
           else
             case other
             when Integer, Float, BigDecimal
-              Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, Arel.sql(other.to_s)))
+              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.sql(other.to_s)))
             when String
-              Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, Arel.sql(other)))
+              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.sql(other)))
             else
-              Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, 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,6 +1,6 @@
 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
@@ -34,16 +34,18 @@ module ArelExtensions
       include Arel::Math
       include Arel::Predications
       include Arel::OrderPredications
-      include ArelExtensions::Math
+      include ArelExtensions::Aliases
       include ArelExtensions::Comparators
-      include ArelExtensions::Predications
+      include ArelExtensions::DateDuration
+      include ArelExtensions::Math
       include ArelExtensions::MathFunctions
-      include ArelExtensions::StringFunctions
       include ArelExtensions::NullFunctions
+      include ArelExtensions::Predications
+      include ArelExtensions::StringFunctions
 
       def return_type
         obj = if @conditions.length > 0
-            @conditions.last.right
+                @conditions.last.right
           elsif @default
             @default.expr
           end
@@ -53,14 +55,10 @@ module ArelExtensions
           case obj
           when Integer, Float
             :number
-          when Date, DateTime,Time
+          when Date, DateTime, Time
             :datetime
           when Arel::Attributes::Attribute
-            begin
-              Arel::Table.engine.connection.schema_cache.columns_hash(obj.relation.table_name)[obj.name.to_s].type
-            rescue Exception
-              :string
-            end
+            Arel.column_of(obj.relation.table_name, obj.name.to_s)&.type || :string
           else
             :string
           end
@@ -102,7 +100,7 @@ module ArelExtensions
       alias :== :eql?
 
       def as other
-        Arel::Nodes::As.new self, Arel::Nodes::SqlLiteral.new(other)
+        Arel::Nodes::As.new self, Arel.sql(other)
       end
     end
   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,17 +32,17 @@ 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
-          Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+          Arel.grouping(Arel::Nodes::Addition.new self, other)
         end
       end
 

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.to_s + b.expr.to_s)
         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,9 +115,18 @@ 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
-            v.to_i
+            if v.parts.size == 1
+              #       first entry in the dict v.parts; one of [:years, :months, :weeks, :days, :hours, :minutes, :seconds]
+              #       |     the value
+              #       |     |
+              #       |     |
+              #       v     v
+              v.parts.first.second
+            else
+              v.to_i
+            end
           end
         else
           v
@@ -130,20 +139,30 @@ module ArelExtensions
           if @date_type == :date
             Arel.sql('day')
           elsif @date_type == :datetime
-            Arel.sql('second')
+            res = if v.parts.size == 1
+                    #       first entry in the dict v.parts; one of [:years, :months, :weeks, :days, :hours, :minutes, :seconds]
+                    #       |     the key
+                    #       |     |     convert symbol to string
+                    #       |     |     |   remove the plural suffix `s`
+                    #       v     v     v   v
+                    v.parts.first.first.to_s[0..-2]
+                  else
+                    'second'
+                  end
+            Arel.sql(res)
           end
         else
           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(Arel::Visitors::MSSQL::DATE_MAPPING[v.left[0..-2]])
+              Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left[0..-2]])
             else
-              Arel.sql(Arel::Visitors::MSSQL::DATE_MAPPING[v.left])
+              Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left])
             end
           end
         end
@@ -160,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/format.rb

@@ -5,11 +5,12 @@ module ArelExtensions
     class Format < Function
       RETURN_TYPE = :string
 
-      attr_accessor :col_type, :iso_format
+      attr_accessor :col_type, :iso_format, :time_zone
 
       def initialize expr
-        col = expr.first
+        col = expr[0]
         @iso_format = convert_format(expr[1])
+        @time_zone  = expr[2]
         @col_type = type_of_attribute(col)
         super [col, convert_to_string_node(@iso_format)]
       end

data/lib/arel_extensions/nodes/formatted_date.rb

@@ -0,0 +1,42 @@
+require 'strscan'
+
+module ArelExtensions
+  module Nodes
+    class FormattedDate < Function
+      RETURN_TYPE = :string
+
+      attr_accessor :col_type, :iso_format, :time_zone
+
+      def initialize expr
+        col = expr[0]
+        @iso_format = convert_format(expr[1])
+        @time_zone  = expr[2]
+        @col_type = type_of_attribute(col)
+        super [col, convert_to_string_node(@iso_format)]
+      end
+
+      private
+
+      # Address portability issues with some of the formats.
+      def convert_format(fmt)
+        s = StringScanner.new fmt
+        res = StringIO.new
+        while !s.eos?
+          res <<
+            case
+            when s.scan(/%D/)    then '%m/%d/%y'
+            when s.scan(/%F/)    then '%Y-%m-%d'
+            when s.scan(/%R/)    then '%H:%M'
+            when s.scan(/%r/)    then '%I:%M:%S %p'
+            when s.scan(/%T/)    then '%H:%M:%S'
+            when s.scan(/%v/)    then '%e-%b-%Y'
+
+            when s.scan(/[^%]+/) then s.matched
+            when s.scan(/./)     then s.matched
+            end
+        end
+        res.string
+      end
+    end
+  end
+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]