arel_extensions 2.4.0 → 2.5.0

data/lib/arel_extensions/math_functions.rb

@@ -12,22 +12,22 @@ require 'arel_extensions/nodes/sum'
 module ArelExtensions
   module MathFunctions
     # Arel does not handle Decimal literal properly
-    def * other
+    def *(other)
       case other
       when Float, BigDecimal
         super(Arel.quoted(other))
       else
-        super(other)
+        super
       end
     end
 
     # Arel does not handle Decimal literal properly
-    def / other
+    def /(other)
       case other
       when Float, BigDecimal
         super(Arel.quoted(other))
       else
-        super(other)
+        super
       end
     end
 
@@ -52,25 +52,25 @@ module ArelExtensions
     end
 
     # function gives the power of a number
-    def pow exposant = 0
+    def pow(exposant = 0)
       ArelExtensions::Nodes::Power.new [self, exposant]
     end
 
     # function gives the power of a number
-    def power exposant = 0
+    def power(exposant = 0)
       ArelExtensions::Nodes::Power.new [self, exposant]
     end
 
     # Aggregate Functions
-    def std opts = {unbiased: true}
+    def std(opts = {unbiased: true})
       ArelExtensions::Nodes::Std.new self, **opts
     end
 
-    def variance opts = {unbiased: true}
+    def variance(opts = {unbiased: true})
       ArelExtensions::Nodes::Variance.new self, **opts
     end
 
-    def sum opts = {unbiased: true}
+    def sum(opts = {unbiased: true})
       if AREL_VERSION >= V9_0
         Arel::Nodes::Sum.new [self]
       else
@@ -82,10 +82,10 @@ module ArelExtensions
     #    def rand seed = nil
     #        ArelExtensions::Nodes::Rand.new [seed]
     #    end
-    alias_method(:random, :rand) rescue nil
+    alias random rand rescue nil
 
     # function is used to round a numeric field to the number of decimals specified
-    def round precision = nil
+    def round(precision = nil)
       if precision
         ArelExtensions::Nodes::Round.new [self, precision]
       else
@@ -94,25 +94,23 @@ module ArelExtensions
     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
-        m = /^(.*)%([ #+\-0]*)([1-9][0-9]+|[1-9]?)[.]?([0-9]*)([a-zA-Z])(.*)$/.match(format_string)
-        opts = {
-          prefix: m[1],
-          flags: m[2].split(//).uniq.join,
-          width: m[3].to_i,
-          precision: m[4] != '' ? m[4].to_i : 6,
-          type: m[5],
-          suffix: m[6],
-          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]
-      rescue Exception
-        Arel.quoted('Wrong Format')
-      end
+    def format_number(format_string, locale = nil)
+      format(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],
+        flags: m[2].split('').uniq.join,
+        width: m[3].to_i,
+        precision: m[4] == '' ? 6 : m[4].to_i,
+        type: m[5],
+        suffix: m[6],
+        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]
+    rescue Exception
+      Arel.quoted('Wrong Format')
     end
   end
 end

data/lib/arel_extensions/nodes/aggregate_function.rb

@@ -3,10 +3,10 @@ module ArelExtensions
     class AggregateFunction < Function
       attr_accessor :order, :group
 
-      def initialize node, **opts
-        @order = Array.wrap(opts[:order]).map{|e| convert_to_node(e)}
-        @group = Array.wrap(opts[:group]).map{|e| convert_to_node(e)}
-        super [node]
+      def initialize(node, **opts)
+        @order = Array.wrap(opts[:order]).map { |e| convert_to_node(e) }
+        @group = Array.wrap(opts[:group]).map { |e| convert_to_node(e) }
+        super([node])
       end
     end
   end

data/lib/arel_extensions/nodes/blank.rb

@@ -4,19 +4,21 @@ module ArelExtensions
   module Nodes
     class Blank < Arel::Nodes::Unary
       include ArelExtensions::BooleanFunctions
+
       RETURN_TYPE = :boolean
 
-      def initialize expr
-        super expr.first
+      def initialize(expr)
+        super(expr.first)
       end
     end
 
     class NotBlank < Arel::Nodes::Unary
       include ArelExtensions::BooleanFunctions
+
       RETURN_TYPE = :boolean
 
-      def initialize expr
-        super expr.first
+      def initialize(expr)
+        super(expr.first)
       end
     end
   end

data/lib/arel_extensions/nodes/case.rb

@@ -6,9 +6,10 @@ module ArelExtensions
         include Arel::Math
         include Arel::Predications
         include Arel::OrderPredications
+
         attr_accessor :case, :conditions, :default
 
-        def initialize expression = nil, default = nil
+        def initialize(expression = nil, default = nil)
           @case = expression
           @conditions = []
           @default = default
@@ -24,6 +25,7 @@ module ArelExtensions
       class Case < Arel::Nodes::Case
         class When < Arel::Nodes::When # :nodoc:
         end
+
         class Else < Arel::Nodes::Else # :nodoc:
         end
       end
@@ -44,8 +46,9 @@ module ArelExtensions
       include ArelExtensions::StringFunctions
 
       def return_type
-        obj = if @conditions.length > 0
-                @conditions.last.right
+        obj =
+          if @conditions.length > 0
+            @conditions.last.right
           elsif @default
             @default.expr
           end
@@ -65,22 +68,22 @@ module ArelExtensions
         end
       end
 
-      def when condition, expression = nil
+      def when(condition, expression = nil)
         @conditions << Case::When.new(condition, expression)
         self
       end
 
-      def then expression
+      def then(expression)
         @conditions.last.right = expression
         self
       end
 
-      def else expression
+      def else(expression)
         @default = Case::Else.new expression
         self
       end
 
-      def initialize_copy other
+      def initialize_copy(other)
         super
         @case = @case.clone if @case
         @conditions = @conditions.map { |x| x.clone }
@@ -91,15 +94,15 @@ module ArelExtensions
         [@case, @conditions, @default].hash
       end
 
-      def eql? other
+      def eql?(other)
         self.class == other.class &&
           self.case == other.case &&
-          self.conditions == other.conditions &&
-          self.default == other.default
+          conditions == other.conditions &&
+          default == other.default
       end
-      alias :== :eql?
+      alias == eql?
 
-      def as other
+      def as(other)
         Arel::Nodes::As.new self, Arel.sql(other)
       end
     end

data/lib/arel_extensions/nodes/cast.rb

@@ -5,7 +5,7 @@ module ArelExtensions
 
       attr_accessor :as_attr
 
-      def initialize expr
+      def initialize(expr)
         @as_attr = expr[1]
         case expr[1]
         when :int, 'bigint', 'int', 'smallint', 'tinyint', 'bit'
@@ -42,13 +42,11 @@ module ArelExtensions
         when :ruby_time
           ArelExtensions::Nodes::DateAdd.new [self, other]
         else
-          Arel.grouping(Arel::Nodes::Addition.new self, other)
+          Arel.grouping(Arel::Nodes::Addition.new(self, other))
         end
       end
 
-      def return_type
-        @return_type
-      end
+      attr_reader :return_type
     end
   end
 end

data/lib/arel_extensions/nodes/coalesce.rb

@@ -9,7 +9,7 @@ module ArelExtensions
         @left_node_type || self.class.const_get(:RETURN_TYPE)
       end
 
-      def initialize expr
+      def initialize(expr)
         tab = expr.map { |arg|
           convert_to_node(arg)
         }

data/lib/arel_extensions/nodes/collate.rb

@@ -5,7 +5,7 @@ module ArelExtensions
 
       attr_accessor :ai, :ci, :option
 
-      def initialize left, option = nil, ai = false, ci = false
+      def initialize(left, option = nil, ai = false, ci = false)
         @ai = ai
         @ci = ci
         @option = option

data/lib/arel_extensions/nodes/concat.rb

@@ -2,7 +2,7 @@ module ArelExtensions::Nodes
   class Concat < Function
     RETURN_TYPE = :string
 
-    def initialize expr
+    def initialize(expr)
       tab = expr.map { |arg|
         # flatten nested concats.
         node = convert_to_node(arg)
@@ -25,8 +25,8 @@ module ArelExtensions::Nodes
       super(tab)
     end
 
-    def self.new expr
-      o = super(expr)
+    def self.new(expr)
+      o = super
       if o.expressions.length == 1
         o.expressions[0]
       else
@@ -35,7 +35,7 @@ module ArelExtensions::Nodes
     end
 
     def concat(other)
-      Concat.new(self.expressions + [other])
+      Concat.new(expressions + [other])
     end
   end
 
@@ -44,9 +44,9 @@ module ArelExtensions::Nodes
 
     attr_accessor :separator
 
-    def initialize node, separator = ', ', **opts
+    def initialize(node, separator = ', ', **opts)
       @separator = convert_to_node(separator)
-      super node, **opts
+      super(node, **opts)
     end
   end
 end

data/lib/arel_extensions/nodes/date_diff.rb

@@ -3,8 +3,7 @@ require 'date'
 module ArelExtensions
   module Nodes
     class DateDiff < Function # difference entre colonne date et date string/date
-      attr_accessor :left_node_type
-      attr_accessor :right_node_type
+      attr_accessor :left_node_type, :right_node_type
 
       RETURN_TYPE = :integer # by default...
 
@@ -29,7 +28,7 @@ module ArelExtensions
           @right_node_type = :ruby_time
         end
         res << (%i[date ruby_date].include?(@left_node_type) ? convert_to_date_node(expr[1]) : convert_to_datetime_node(expr[1]))
-        super res
+        super(res)
       end
     end
 
@@ -37,7 +36,7 @@ module ArelExtensions
       RETURN_TYPE = :date
       attr_accessor :date_type
 
-      def initialize expr
+      def initialize(expr)
         col = expr.first
         @date_type = type_of_attribute(col)
         tab = expr.map do |arg|
@@ -47,8 +46,8 @@ module ArelExtensions
       end
 
       def sqlite_value
-        v = self.expressions.last
-        if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
+        v = expressions.last
+        if defined?(ActiveSupport::Duration) && v.is_a?(ActiveSupport::Duration)
           if @date_type == :date
             Arel.quoted((v.value >= 0 ? '+' : '-') + v.inspect)
           elsif @date_type == :datetime
@@ -60,60 +59,54 @@ module ArelExtensions
       end
 
       def mysql_value(v = nil)
-        v ||= self.expressions.last
-        if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
+        v ||= expressions.last
+        if defined?(ActiveSupport::Duration) && v.is_a?(ActiveSupport::Duration)
           if @date_type == :date || @date_type == :datetime
             Arel.sql('INTERVAL %s' % v.inspect.sub(/s\Z/, ''))
           end
+        elsif v.is_a?(ArelExtensions::Nodes::Duration)
+          v.with_interval = true
+          v
         else
-          if ArelExtensions::Nodes::Duration === v
-            v.with_interval = true
-            v
-          else
-            v
-          end
+          v
         end
       end
 
       def postgresql_value(v = nil)
-        v ||= self.expressions.last
-        if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
+        v ||= expressions.last
+        if defined?(ActiveSupport::Duration) && v.is_a?(ActiveSupport::Duration)
           if @date_type == :date
             Arel.sql("INTERVAL '%s'" % v.inspect.sub(/s\Z/, '').upcase)
           elsif @date_type == :datetime
             Arel.sql("INTERVAL '%s'" % v.inspect.sub(/s\Z/, '').upcase)
           end
+        elsif v.is_a?(ArelExtensions::Nodes::Duration)
+          v.with_interval = true
+          v
         else
-          if ArelExtensions::Nodes::Duration === v
-            v.with_interval = true
-            v
-          else
-            v
-          end
+          v
         end
       end
 
       def oracle_value(v = nil)
-        v ||= self.expressions.last
-        if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
+        v ||= expressions.last
+        if defined?(ActiveSupport::Duration) && v.is_a?(ActiveSupport::Duration)
           if @date_type == :ruby_date
             Arel.sql("(INTERVAL '1' DAY) * %s" % v.inspect.to_i)
           else
             Arel.sql("(INTERVAL '1' SECOND) * %s" % v.to_i)
           end
+        elsif v.is_a?(ArelExtensions::Nodes::Duration)
+          v.with_interval = true
+          v
         else
-          if ArelExtensions::Nodes::Duration === v
-            v.with_interval = true
-            v
-          else
-            v
-          end
+          v
         end
       end
 
       def mssql_value(v = nil)
-        v ||= self.expressions.last
-        if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
+        v ||= expressions.last
+        if defined?(ActiveSupport::Duration) && v.is_a?(ActiveSupport::Duration)
           if @date_type == :date
             v.to_i / (24 * 3600)
           elsif @date_type == :datetime
@@ -134,8 +127,8 @@ module ArelExtensions
       end
 
       def mssql_datepart(v = nil)
-        v ||= self.expressions.last
-        if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === v
+        v ||= expressions.last
+        if defined?(ActiveSupport::Duration) && v.is_a?(ActiveSupport::Duration)
           if @date_type == :date
             Arel.sql('day')
           elsif @date_type == :datetime
@@ -151,19 +144,17 @@ module ArelExtensions
                   end
             Arel.sql(res)
           end
-        else
-          if ArelExtensions::Nodes::Duration === v
-            v.with_interval = true
-            case v.left
-            when 'd', 'm', 'y'
-              Arel.sql('day')
-            when 'h', 'mn', 's'
-              Arel.sql('second')
-            when /i\z/
-              Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left[0..-2]])
-            else
-              Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left])
-            end
+        elsif v.is_a?(ArelExtensions::Nodes::Duration)
+          v.with_interval = true
+          case v.left
+          when 'd', 'm', 'y'
+            Arel.sql('day')
+          when 'h', 'mn', 's'
+            Arel.sql('second')
+          when /i\z/
+            Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left[0..-2]])
+          else
+            Arel.sql(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left])
           end
         end
       end
@@ -190,7 +181,7 @@ module ArelExtensions
       RETURN_TYPE = :integer
 
       def initialize(expr)
-        super [expr.first, convert_number(expr[1])]
+        super([expr.first, convert_number(expr[1])])
       end
 
       def convert_number(object)
@@ -200,7 +191,7 @@ module ArelExtensions
         when String
           object.to_i
         else
-          if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === object
+          if defined?(ActiveSupport::Duration) && object.is_a?(ActiveSupport::Duration)
             object.to_i
           else
             raise(ArgumentError, "#{object.class} cannot be converted to Number")

data/lib/arel_extensions/nodes/duration.rb

@@ -5,8 +5,8 @@ module ArelExtensions
 
       attr_accessor :with_interval
 
-      def initialize left, right, aliaz = nil
-        tab = Array.new
+      def initialize(left, right, aliaz = nil)
+        tab = []
         tab << left
         tab << right
         @with_interval = left.end_with?('i')

data/lib/arel_extensions/nodes/format.rb

@@ -7,12 +7,12 @@ module ArelExtensions
 
       attr_accessor :col_type, :iso_format, :time_zone
 
-      def initialize expr
+      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)]
+        super([col, convert_to_string_node(@iso_format)])
       end
 
       private

data/lib/arel_extensions/nodes/formatted_date.rb

@@ -7,12 +7,12 @@ module ArelExtensions
 
       attr_accessor :col_type, :iso_format, :time_zone
 
-      def initialize expr
+      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)]
+        super([col, convert_to_string_node(@iso_format)])
       end
 
       private

data/lib/arel_extensions/nodes/formatted_number.rb

@@ -5,7 +5,7 @@ module ArelExtensions
 
       attr_accessor :locale, :prefix, :suffix, :flags, :scientific_notation, :width, :precision, :type, :original_string
 
-      def initialize expr
+      def initialize(expr)
         # expr[1] = {locale: 'fr_FR', type: "e"/"f"/"d", prefix: "$ ", suffix: " %", flags: " +-#0", width: 5, precision: 6}
         col = expr.first
         @locale = expr[1][:locale]
@@ -17,7 +17,7 @@ module ArelExtensions
         @flags = expr[1][:flags]
         @scientific_notation = /[eE]/.match(expr[1][:type]) || false
         @original_string = expr[1][:original_string]
-        super [col]
+        super([col])
       end
     end
   end

data/lib/arel_extensions/nodes/function.rb

@@ -26,8 +26,8 @@ module ArelExtensions
         self.class.const_get(:RETURN_TYPE)
       end
 
-      def as other
-        res = Arel::Nodes::As.new(self.clone, Arel.sql(other))
+      def as(other)
+        res = Arel::Nodes::As.new(clone, Arel.sql(other))
         self.alias = Arel.sql(other)
         res
       end
@@ -73,6 +73,8 @@ module ArelExtensions
           Arel.quoted(object.strftime('%H:%M:%S'), self)
         when MBSTRING, String, Symbol
           Arel.quoted(object.to_s)
+        when TrueClass, FalseClass
+          Arel.quoted(object)
         when Date
           Arel.quoted(object.to_s, self)
         when NilClass
@@ -80,7 +82,7 @@ module ArelExtensions
         when ActiveSupport::Duration
           Arel.sql(object.to_i)
         when Array
-          Arel.grouping(object.map{|e| convert_to_node(e)})
+          Arel.grouping(object.map { |e| convert_to_node(e) })
         else
           raise(ArgumentError, "#{object.class} cannot be converted to CONCAT arg")
         end
@@ -93,7 +95,7 @@ module ArelExtensions
         when Integer
           Arel.quoted(object.to_s)
         when Arel::Attributes::Attribute
-          case self.type_of_attribute(object)
+          case type_of_attribute(object)
           when :date
             ArelExtensions::Nodes::Format.new [object, 'yyyy-mm-dd']
           when :time

data/lib/arel_extensions/nodes/is_null.rb

@@ -4,11 +4,13 @@ module ArelExtensions
   module Nodes
     class IsNull < Arel::Nodes::Unary
       include ArelExtensions::BooleanFunctions
+
       RETURN_TYPE = :boolean
     end
 
     class IsNotNull < Arel::Nodes::Unary
       include ArelExtensions::BooleanFunctions
+
       RETURN_TYPE = :boolean
     end
   end