arel_extensions 2.3.3 → 2.5.0

data/lib/arel_extensions/boolean_functions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'arel_extensions/nodes/then'
 
 module ArelExtensions
@@ -6,7 +8,7 @@ module ArelExtensions
       self.and(other)
     end
 
-    def and *others
+    def and(*others)
       Arel::Nodes::And.new self, others
     end
 
@@ -14,7 +16,7 @@ module ArelExtensions
       self.or(other)
     end
 
-    def or *others
+    def or(*others)
       Arel::Nodes::Or.new self, others
     end
 
@@ -27,7 +29,7 @@ end
 class Arel::Nodes::And
   include ArelExtensions::BooleanFunctions
 
-  def self.new *children
+  def self.new(*children)
     children =
       children.flatten.map { |c|
         c.is_a?(self) ? c.children : c
@@ -47,15 +49,15 @@ class Arel::Nodes::Or
 
   attr_reader :children
 
-  def self.new *children
+  def self.new(*children)
     children =
       children.flatten.map { |c|
         c.is_a?(self) ? c.children : c
       }.flatten
-    super(*children)
+    super
   end
 
-  def initialize *children
+  def initialize(*children)
     @children = children
   end
 
@@ -80,5 +82,5 @@ class Arel::Nodes::Or
     self.class == other.class &&
       children == other.children
   end
-  alias :== :eql?
+  alias == eql?
 end

data/lib/arel_extensions/common_sql_functions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArelExtensions
   class CommonSqlFunctions
     def initialize(cnx)
@@ -9,7 +11,7 @@ module ArelExtensions
           db.load_extension('/usr/lib/sqlite3/pcre.so')
           db.load_extension('/usr/lib/sqlite3/extension-functions.so')
           db.enable_load_extension(0)
-        rescue => e
+        rescue StandardError => e
           $load_extension_disabled = true
           puts "cannot load extensions #{e.inspect}"
         end
@@ -42,14 +44,14 @@ module ArelExtensions
       if /sqlite/i.match?(env_db)
         begin
           add_sqlite_functions
-        rescue => e
+        rescue StandardError => e
           puts "cannot add sqlite functions #{e.inspect}"
         end
       end
       if File.exist?("init/#{env_db}.sql")
         sql = File.read("init/#{env_db}.sql")
         if env_db == 'mssql'
-          sql.split(/^GO\s*$/).each {|str|
+          sql.split(/^GO\s*$/).each { |str|
             @cnx.execute(str.strip) unless str.blank?
           }
         elsif env_db == 'mysql'

data/lib/arel_extensions/comparators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArelExtensions
   module Comparators
     def >(other)
@@ -19,8 +21,8 @@ module ArelExtensions
     # REGEXP function
     # Pattern matching using regular expressions
     def =~(other)
-        #      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
-        #      if arg == :string || arg == :text
+      #      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
+      #      if arg == :string || arg == :text
       Arel::Nodes::Regexp.new self, convert_regexp(other)
       #      end
     end
@@ -30,8 +32,8 @@ module ArelExtensions
     # NOT_REGEXP function
     # Negation of Regexp
     def !~(other)
-        #      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
-        #      if arg == :string || arg == :text
+      #      arg = self.relation.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s].type
+      #      if arg == :string || arg == :text
       Arel::Nodes::NotRegexp.new self, convert_regexp(other)
       #      end
     end

data/lib/arel_extensions/constants.rb

@@ -0,0 +1,13 @@
+module ArelExtensions
+  ACTIVE_RECORD_VERSION = Gem::Version.new(ActiveRecord::VERSION::STRING).freeze
+  AREL_VERSION = Gem::Version.new(Arel::VERSION).freeze
+  V10 = Gem::Version.new('10.0').freeze
+  V5 = Gem::Version.new('5.0').freeze
+  V6 = Gem::Version.new('6.0').freeze
+  V7 = Gem::Version.new('7.0').freeze
+  V7_0 = Gem::Version.new('7.0').freeze
+  V7_1 = Gem::Version.new('7.1').freeze
+  V7_2 = Gem::Version.new('7.2').freeze
+  V8_1 = Gem::Version.new('8.1').freeze
+  V9_0 = Gem::Version.new('9.0').freeze
+end

data/lib/arel_extensions/date_duration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'arel_extensions/nodes/format'
 require 'arel_extensions/nodes/formatted_date'
 require 'arel_extensions/nodes/duration'

data/lib/arel_extensions/helpers.rb

@@ -1,5 +1,6 @@
-module ArelExtensions
+# frozen_string_literal: true
 
+module ArelExtensions
   #
   # column_of
   #
@@ -19,7 +20,7 @@ module ArelExtensions
     Arel::Table.engine.connection.schema_cache.columns_hash(table_name)[column_name]
   rescue NoMethodError
     nil
-  rescue => e
+  rescue StandardError => e
     warn("Warning: Unexpected exception caught while fetching column name for #{table_name}.#{column_name} in `column_of_via_arel_table`\n#{e.class}")
     warn(e.backtrace)
     nil
@@ -27,33 +28,31 @@ module ArelExtensions
 
   def self.column_of(table_name, column_name)
     pool = ActiveRecord::Base.connection.pool
-    use_arel_table = !ActiveRecord::Base.connected? || \
-      (pool.respond_to?(:schema_cache) && pool.schema_cache.nil?)
+    use_arel_table = !ActiveRecord::Base.connected? \
+      || (pool.respond_to?(:schema_cache) && pool.schema_cache.nil?)
 
     if use_arel_table
       column_of_via_arel_table(table_name, column_name)
-    else
-      if pool.respond_to?(:pool_config)
-        if pool.pool_config.respond_to?(:schema_reflection) # activerecord >= 7.1
-          if ActiveRecord.version >= Gem::Version.create('7.2')
-            pool.pool_config.schema_reflection.columns_hash(pool, table_name)[column_name]
-          else
-            pool.pool_config.schema_reflection.columns_hash(ActiveRecord::Base.connection, table_name)[column_name]
-          end
-        else # activerecord < 7.1
-          pool.pool_config.schema_cache.columns_hash(table_name)[column_name]
+    elsif pool.respond_to?(:pool_config)
+      if pool.pool_config.respond_to?(:schema_reflection) # activerecord >= 7.1
+        if ActiveRecord.version >= Gem::Version.create('7.2')
+          pool.pool_config.schema_reflection.columns_hash(pool, table_name)[column_name]
+        else
+          pool.pool_config.schema_reflection.columns_hash(ActiveRecord::Base.connection, table_name)[column_name]
         end
-      elsif pool.respond_to?(:schema_cache) # activerecord < 6.1
-        pool.schema_cache.columns_hash(table_name)[column_name]
-      else # activerecord < 5.0
-        column_of_via_arel_table(table_name, column_name)
+      else # activerecord < 7.1
+        pool.pool_config.schema_cache.columns_hash(table_name)[column_name]
       end
+    elsif pool.respond_to?(:schema_cache) # activerecord < 6.1
+      pool.schema_cache.columns_hash(table_name)[column_name]
+    else # activerecord < 5.0
+      column_of_via_arel_table(table_name, column_name)
     end
   rescue ActiveRecord::ConnectionNotEstablished
     column_of_via_arel_table(table_name, column_name)
   rescue ActiveRecord::StatementInvalid
     nil
-  rescue => e
+  rescue StandardError => e
     warn("Warning: Unexpected exception caught while fetching column name for #{table_name}.#{column_name} in `column_of`")
     warn(e)
     warn(e.backtrace)

data/lib/arel_extensions/insert_manager.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'arel'
 
 module ArelExtensions
   module InsertManager
     def bulk_insert(cols, data)
       raise ArgumentError, 'cols must be present' if cols.blank?
+
       columns =
         case cols.first
         when Array
@@ -11,7 +14,7 @@ module ArelExtensions
           when Arel::Attributes::Attribute
             cols
           when String, Symbol
-            cols.map {|c| [@ast.relation[c.first]] }
+            cols.map { |c| [@ast.relation[c.first]] }
           else
             raise ArgumentError, "cols has an invalid type: #{cols.first.first.class}"
           end
@@ -28,6 +31,7 @@ module ArelExtensions
       attr_accessor :left, :cols
 
       def initialize(cols, values)
+        super()
         @left = values
         @cols = cols
       end

data/lib/arel_extensions/math.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'arel_extensions/nodes'
 require 'arel_extensions/nodes/function'
 require 'arel_extensions/nodes/concat'
@@ -17,48 +19,46 @@ module ArelExtensions
     def +(other)
       case self
       when Arel::Nodes::Quoted
-        self.concat(other)
+        concat(other)
       when Arel::Nodes::Grouping
-        if self.expr.left.is_a?(String) || self.expr.right.is_a?(String)
-          self.concat(other)
+        if expr.left.is_a?(String) || expr.right.is_a?(String)
+          concat(other)
         else
-          Arel.grouping(Arel::Nodes::Addition.new self, other)
+          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)
+        case return_type
         when :integer, :decimal, :float, :number, :int
-          Arel.grouping(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)
+          concat(other)
         end
       when Arel::Nodes::Function
-        Arel.grouping(Arel::Nodes::Addition.new self, other)
+        Arel.grouping(Arel::Nodes::Addition.new(self, other))
       else
         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)
+          if is_a?(Arel::Attribute) && respond_to?(:type_caster) && able_to_type_cast?
+            type_caster
+          elsif respond_to?(:relation)
+            Arel.column_of(relation.table_name, name.to_s)
           end
-        if !col # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
-        else
+        if col
           arg = col.type
           if arg == :integer || !arg
             other = other.to_i if other.is_a?(String)
-            Arel.grouping(Arel::Nodes::Addition.new self, Arel.quoted(other))
-          elsif arg == :decimal || arg == :float
+            Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
+          elsif %i[decimal float].include?(arg)
             other = Arel.sql(other) if other.is_a?(String) # Arel should accept Float & BigDecimal!
-            Arel.grouping(Arel::Nodes::Addition.new self, Arel.quoted(other))
-          elsif arg == :datetime || arg == :date
+            Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
+          elsif %i[datetime date].include?(arg)
             ArelExtensions::Nodes::DateAdd.new [self, other]
-          elsif arg == :string || arg == :text
-            self.concat(other)
+          elsif %i[string text].include?(arg)
+            concat(other)
           end
+        else
+          Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
         end
       end
     end
@@ -68,17 +68,13 @@ module ArelExtensions
     def -(other)
       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.quoted(other)])
+        if expr.left.is_a?(Date) || expr.left.is_a?(DateTime)
+          Arel.grouping(ArelExtensions::Nodes::DateSub.new([self, Arel.quoted(other)]))
         else
           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.quoted(other))) # ??
-        when :integer, :decimal, :float, :number
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
+        case return_type
         when :date, :datetime
           ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)]
         else
@@ -88,33 +84,31 @@ module ArelExtensions
         Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
       else
         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)
+          if is_a?(Arel::Attribute) && respond_to?(:type_caster) && able_to_type_cast?
+            type_caster
+          elsif respond_to?(:relation)
+            Arel.column_of(relation.table_name, name.to_s)
           end
-        if !col # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
-        else
+        if col
           arg = col.type
-          if (arg == :date || arg == :datetime)
+          if %i[date datetime].include?(arg)
             case other
             when Arel::Attributes::Attribute
               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)
+                elsif other.respond_to?(:relation)
+                  Arel.column_of(other.relation.table_name, other.name.to_s)
                 end
-              if !col2 # if the column doesn't exist in the database
-                ArelExtensions::Nodes::DateSub.new [self, other]
-              else
+              if col2
                 arg2 = col2.type
-                if arg2 == :date || arg2 == :datetime
+                if %i[date datetime].include?(arg2)
                   ArelExtensions::Nodes::DateDiff.new [self, other]
                 else
                   ArelExtensions::Nodes::DateSub.new [self, other]
                 end
+              else
+                ArelExtensions::Nodes::DateSub.new [self, other]
               end
             when Arel::Nodes::Node, DateTime, Time, String, Date
               ArelExtensions::Nodes::DateDiff.new [self, other]
@@ -133,6 +127,8 @@ module ArelExtensions
               Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
             end
           end
+        else
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         end
       end
     end

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,26 +52,26 @@ 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}
-      if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('9.0.0')
+    def sum(opts = {unbiased: true})
+      if AREL_VERSION >= V9_0
         Arel::Nodes::Sum.new [self]
       else
         ArelExtensions::Nodes::Sum.new self, **opts
@@ -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/byte_size.rb

@@ -0,0 +1,11 @@
+module ArelExtensions
+  module Nodes
+    class ByteSize < Function
+      RETURN_TYPE = :integer
+
+      def initialize(node)
+        super([node])
+      end
+    end
+  end
+end

data/lib/arel_extensions/nodes/case.rb

@@ -1,14 +1,15 @@
 module ArelExtensions
   module Nodes
-    if Gem::Version.new(Arel::VERSION) < Gem::Version.new('7.1.0')
+    if AREL_VERSION < V7_1
       class Case < Arel::Nodes::Node
         include Arel::Expressions
         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