arel_extensions 2.1.3 → 2.1.4

data/lib/arel_extensions/attributes.rb

@@ -19,11 +19,11 @@ module ArelExtensions
     include ArelExtensions::Predications
 
     def ==(other)
-      Arel::Nodes::Equality.new self, Arel::Nodes.build_quoted(other, self)
+      Arel::Nodes::Equality.new self, Arel.quoted(other, self)
     end
 
     def !=(other)
-      Arel::Nodes::NotEqual.new self, Arel::Nodes.build_quoted(other, self)
+      Arel::Nodes::NotEqual.new self, Arel.quoted(other, self)
     end
   end
 end

data/lib/arel_extensions/boolean_functions.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'arel_extensions/nodes/then'
 
 module ArelExtensions
@@ -32,7 +30,7 @@ class Arel::Nodes::And
   def self.new *children
     children =
       children.flatten.map { |c|
-      c.is_a?(self) ? c.children : c
+        c.is_a?(self) ? c.children : c
       }.flatten
     super(children)
   end
@@ -52,7 +50,7 @@ class Arel::Nodes::Or
   def self.new *children
     children =
       children.flatten.map { |c|
-      c.is_a?(self) ? c.children : c
+        c.is_a?(self) ? c.children : c
       }.flatten
     super(*children)
   end

data/lib/arel_extensions/common_sql_functions.rb

@@ -6,8 +6,8 @@ module ArelExtensions
         begin
           db = cnx.raw_connection
           db.enable_load_extension(1)
-          db.load_extension("/usr/lib/sqlite3/pcre.so")
-          db.load_extension("/usr/lib/sqlite3/extension-functions.so")
+          db.load_extension('/usr/lib/sqlite3/pcre.so')
+          db.load_extension('/usr/lib/sqlite3/extension-functions.so')
           db.enable_load_extension(0)
         rescue => e
           $load_extension_disabled = true
@@ -18,22 +18,22 @@ module ArelExtensions
 
     def add_sqlite_functions
       db = @cnx.raw_connection
-      db.create_function("find_in_set", 1) do |func, val, list|
+      db.create_function('find_in_set', 1) do |func, val, list|
         case list
         when String
           i = list.split(',').index(val.to_s)
-          func.result = i ? (i+1) : 0
+          func.result = i ? (i + 1) : 0
         when NilClass
           func.result = nil
         else
           i = list.to_s.split(',').index(val.to_s)
-          func.result = i ? (i+1) : 0
+          func.result = i ? (i + 1) : 0
         end
       end
-      db.create_function("instr", 1) do |func, value1, value2|
+      db.create_function('instr', 1) do |func, value1, value2|
         i = value1.to_s.index(value2.to_s)
-        func.result = i ? (i+1) : 0
-      end rescue "function instr already here (>= 3.8.5)"
+        func.result = i ? (i + 1) : 0
+      end rescue 'function instr already here (>= 3.8.5)'
     end
 
     def add_sql_functions(env_db = nil)
@@ -52,8 +52,8 @@ module ArelExtensions
           sql.split(/^GO\s*$/).each {|str|
             @cnx.execute(str.strip) unless str.blank?
           }
-        elsif env_db =='mysql'
-          sql.split("$$")[1..-2].each { |str|
+        elsif env_db == 'mysql'
+          sql.split('$$')[1..-2].each { |str|
             @cnx.execute(str.strip) unless str.strip.blank?
           }
         else

data/lib/arel_extensions/comparators.rb

@@ -1,19 +1,19 @@
 module ArelExtensions
   module Comparators
     def >(other)
-      Arel::Nodes::GreaterThan.new self, Arel::Nodes.build_quoted(other, self)
+      Arel::Nodes::GreaterThan.new self, Arel.quoted(other, self)
     end
 
     def >=(other)
-      Arel::Nodes::GreaterThanOrEqual.new self, Arel::Nodes.build_quoted(other, self)
+      Arel::Nodes::GreaterThanOrEqual.new self, Arel.quoted(other, self)
     end
 
     def <(other)
-      Arel::Nodes::LessThan.new self, Arel::Nodes.build_quoted(other, self)
+      Arel::Nodes::LessThan.new self, Arel.quoted(other, self)
     end
 
     def <=(other)
-      Arel::Nodes::LessThanOrEqual.new self, Arel::Nodes.build_quoted(other, self)
+      Arel::Nodes::LessThanOrEqual.new self, Arel.quoted(other, self)
     end
 
     # REGEXP function
@@ -21,7 +21,7 @@ module ArelExtensions
     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
-        Arel::Nodes::Regexp.new self, convert_regexp(other)
+      Arel::Nodes::Regexp.new self, convert_regexp(other)
       #      end
     end
 
@@ -30,7 +30,7 @@ module ArelExtensions
     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
-        Arel::Nodes::NotRegexp.new self, convert_regexp(other)
+      Arel::Nodes::NotRegexp.new self, convert_regexp(other)
       #      end
     end
 
@@ -42,17 +42,17 @@ module ArelExtensions
       when String
         # Do nothing.
       when Regexp
-        other = other.source.gsub('\A','^')
-        other.gsub!('\z','$')
-        other.gsub!('\Z','$')
-        other.gsub!('\d','[0-9]')
-        other.gsub!('\D','[^0-9]')
-        other.gsub!('\w','[0-9A-Za-z]')
-        other.gsub!('\W','[^A-Za-z0-9_]')
+        other = other.source.gsub('\A', '^')
+        other.gsub!('\z', '$')
+        other.gsub!('\Z', '$')
+        other.gsub!('\d', '[0-9]')
+        other.gsub!('\D', '[^0-9]')
+        other.gsub!('\w', '[0-9A-Za-z]')
+        other.gsub!('\W', '[^A-Za-z0-9_]')
       else
         raise(ArgumentError)
       end
-      Arel::Nodes.build_quoted(other, self)
+      Arel.quoted(other, self)
     end
   end
 end

data/lib/arel_extensions/date_duration.rb

@@ -6,22 +6,22 @@ module ArelExtensions
   module DateDuration
     # function returns the year (as a number) given a date value.
     def year
-      ArelExtensions::Nodes::Duration.new "y", self
+      ArelExtensions::Nodes::Duration.new 'y', self
     end
 
     # function returns the month (as a number) given a date value.
     def month
-      ArelExtensions::Nodes::Duration.new "m", self
+      ArelExtensions::Nodes::Duration.new 'm', self
     end
 
     # function returns the  week (as a number) given a date value.
     def week
-      ArelExtensions::Nodes::Duration.new "w", self
+      ArelExtensions::Nodes::Duration.new 'w', self
     end
 
     # function returns the month (as a number) given a date value.
     def day
-      ArelExtensions::Nodes::Duration.new "d", self
+      ArelExtensions::Nodes::Duration.new 'd', self
     end
 
     def wday
@@ -29,15 +29,15 @@ module ArelExtensions
     end
 
     def hour
-      ArelExtensions::Nodes::Duration.new "h", self
+      ArelExtensions::Nodes::Duration.new 'h', self
     end
 
     def minute
-      ArelExtensions::Nodes::Duration.new "mn", self
+      ArelExtensions::Nodes::Duration.new 'mn', self
     end
 
     def second
-      ArelExtensions::Nodes::Duration.new "s", self
+      ArelExtensions::Nodes::Duration.new 's', self
     end
 
     def format(tpl, time_zone = nil)

data/lib/arel_extensions/helpers.rb

@@ -16,33 +16,36 @@ module ArelExtensions
   # coveing all these cases.
 
   def self.column_of_via_arel_table(table_name, column_name)
-    begin
-      Arel::Table.engine.connection.schema_cache.columns_hash(table_name)[column_name]
+    Arel::Table.engine.connection.schema_cache.columns_hash(table_name)[column_name]
     rescue NoMethodError
       nil
-    rescue Exception => e
-      puts "Failed to fetch column info for #{table_name}.#{column_name} ."
-      puts "This should never be reached."
-      puts "#{e.class}: #{e}"
+    rescue => e
+      warn("Warning: Unexpected exception caught while fetching column name for #{table_name}.#{column_name} in `column_of_via_arel_table`\n#{e.class}: #{e}")
       nil
-    end
   end
 
   def self.column_of(table_name, column_name)
+    pool = ActiveRecord::Base.connection.pool
     use_arel_table = !ActiveRecord::Base.connected? || \
-      (ActiveRecord::Base.connection.pool.respond_to?(:schema_cache) && ActiveRecord::Base.connection.pool.schema_cache.nil?)
+      (pool.respond_to?(:schema_cache) && pool.schema_cache.nil?)
 
     if use_arel_table
       column_of_via_arel_table(table_name, column_name)
     else
-      if ActiveRecord::Base.connection.pool.respond_to?(:pool_config)
-        ActiveRecord::Base.connection.pool.pool_config.schema_cache.columns_hash(table_name)[column_name]
-      elsif ActiveRecord::Base.connection.pool.respond_to?(:schema_cache)
-        ActiveRecord::Base.connection.pool.schema_cache.columns_hash(table_name)[column_name]
+      if pool.respond_to?(:pool_config)
+        pool.pool_config.schema_cache.columns_hash(table_name)[column_name]
+      elsif pool.respond_to?(:schema_cache)
+        pool.schema_cache.columns_hash(table_name)[column_name]
       else
-        puts ">>> We really shouldn't be here #{table_name}.#{column_name}"
         column_of_via_arel_table(table_name, column_name)
       end
     end
+    rescue ActiveRecord::ConnectionNotEstablished
+      column_of_via_arel_table(table_name, column_name)
+    rescue ActiveRecord::StatementInvalid
+      nil
+    rescue => e
+      warn("Warning: Unexpected exception caught while fetching column name for #{table_name}.#{column_name} in `column_of`\n#{e.class}: #{e}")
+      nil
   end
 end

data/lib/arel_extensions/insert_manager.rb

@@ -3,7 +3,7 @@ require 'arel'
 module ArelExtensions
   module InsertManager
     def bulk_insert(cols, data)
-      raise ArgumentError, "cols must be present" if cols.blank?
+      raise ArgumentError, 'cols must be present' if cols.blank?
       columns =
         case cols.first
         when Array

data/lib/arel_extensions/math.rb

@@ -1,5 +1,3 @@
-require 'arel_extensions/helpers'
-
 require 'arel_extensions/nodes'
 require 'arel_extensions/nodes/function'
 require 'arel_extensions/nodes/concat'
@@ -26,7 +24,7 @@ module ArelExtensions
           else
             return Arel.grouping(Arel::Nodes::Addition.new self, other)
           end
-        when ArelExtensions::Nodes::Function,ArelExtensions::Nodes::Case
+        when ArelExtensions::Nodes::Function, ArelExtensions::Nodes::Case
           return case self.return_type
         when :string, :text
           self.concat(other)
@@ -40,17 +38,17 @@ module ArelExtensions
       when Arel::Nodes::Function
         Arel.grouping(Arel::Nodes::Addition.new self, other)
       else
-        col = self.respond_to?(:relation)? ArelExtensions::column_of(self.relation.table_name, self.name.to_s) : nil
+        col = Arel.column_of(self.relation.table_name, self.name.to_s) if self.respond_to?(:relation)
         if (!col) # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Addition.new(self, Arel::Nodes.build_quoted(other)))
+          Arel.grouping(Arel::Nodes::Addition.new(self, Arel.quoted(other)))
         else
           arg = col.type
           if arg == :integer || (!arg)
             other = other.to_i if other.is_a?(String)
-            Arel.grouping(Arel::Nodes::Addition.new self, Arel::Nodes.build_quoted(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.grouping(Arel::Nodes::Addition.new self, Arel::Nodes.build_quoted(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
@@ -66,33 +64,33 @@ module ArelExtensions
       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::Nodes.build_quoted(other)])
+          Arel.grouping(ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)])
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(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.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other))) # ??
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other))) # ??
         when :integer, :decimal, :float, :number
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         when :date, :datetime
-          ArelExtensions::Nodes::DateSub.new [self, Arel::Nodes.build_quoted(other)]
+          ArelExtensions::Nodes::DateSub.new [self, Arel.quoted(other)]
         else
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
         end
       when Arel::Nodes::Function
-        Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+        Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.quoted(other)))
       else
-        col = ArelExtensions::column_of(self.relation.table_name, self.name.to_s)
+        col = Arel.column_of(self.relation.table_name, self.name.to_s)
         if (!col) # if the column doesn't exist in the database
-          Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(other)))
+          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
-              col2 = ArelExtensions::column_of(other.relation.table_name, other.name.to_s)
+              col2 = Arel.column_of(other.relation.table_name, other.name.to_s)
               if (!col2) # if the column doesn't exist in the database
                 ArelExtensions::Nodes::DateSub.new [self, other]
               else
@@ -117,7 +115,7 @@ module ArelExtensions
             when String
               Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel.sql(other)))
             else
-              Arel.grouping(Arel::Nodes::Subtraction.new(self, Arel::Nodes.build_quoted(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,8 +1,6 @@
-require 'arel_extensions/helpers'
-
 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
@@ -46,7 +44,7 @@ module ArelExtensions
 
       def return_type
         obj = if @conditions.length > 0
-            @conditions.last.right
+                @conditions.last.right
           elsif @default
             @default.expr
           end
@@ -56,10 +54,10 @@ module ArelExtensions
           case obj
           when Integer, Float
             :number
-          when Date, DateTime,Time
+          when Date, DateTime, Time
             :datetime
           when Arel::Attributes::Attribute
-            ArelExtensions::column_of(obj.relation.table_name, obj.name.to_s)&.type || :string
+            Arel.column_of(obj.relation.table_name, obj.name.to_s)&.type || :string
           else
             :string
           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

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)]
+        return 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 + b.expr)
         else
           res << b
         end

data/lib/arel_extensions/nodes/date_diff.rb

@@ -50,9 +50,9 @@ module ArelExtensions
         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)
+            return Arel.quoted((v.value >= 0 ? '+' : '-') + v.inspect)
           elsif @date_type == :datetime
-            return Arel::Nodes.build_quoted((v.value >= 0 ? '+' : '-') + v.inspect)
+            return Arel.quoted((v.value >= 0 ? '+' : '-') + v.inspect)
           end
         else
           return v
@@ -115,7 +115,7 @@ 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
             if v.parts.size == 1
               #       first entry in the dict v.parts; one of [:years, :months, :weeks, :days, :hours, :minutes, :seconds]
@@ -155,9 +155,9 @@ module ArelExtensions
           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(ArelExtensions::Visitors::MSSQL::LOADED_VISITOR::DATE_MAPPING[v.left[0..-2]])
@@ -179,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/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]