arel_extensions 1.7.0 → 2.0.0.rc3

data/lib/arel_extensions/math_functions.rb

@@ -7,110 +7,105 @@ require 'arel_extensions/nodes/formatted_number'
 require 'arel_extensions/nodes/log10'
 require 'arel_extensions/nodes/power'
 require 'arel_extensions/nodes/std'
-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))
+        super(Arel::Nodes.build_quoted(other))
       else
-        super
+        super(other)
       end
     end
 
     # Arel does not handle Decimal literal properly
-    def /(other)
+    def / other
       case other
       when Float, BigDecimal
-        super(Arel.quoted(other))
+        super(Arel::Nodes.build_quoted(other))
       else
-        super
+        super(other)
       end
     end
 
     # 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
+     # 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]
+    def pow exposant = 0
+        ArelExtensions::Nodes::Power.new [self,exposant]
     end
 
     # function gives the power of a number
-    def power(exposant = 0)
-      ArelExtensions::Nodes::Power.new [self, exposant]
+    def power exposant = 0
+        ArelExtensions::Nodes::Power.new [self,exposant]
     end
 
     # Aggregate Functions
-    def std(opts = {unbiased: true})
-      ArelExtensions::Nodes::Std.new self, **opts
-    end
-
-    def variance(opts = {unbiased: true})
-      ArelExtensions::Nodes::Variance.new self, **opts
+    def std unbiased = true
+      ArelExtensions::Nodes::Std.new [self,unbiased]
     end
 
-    def sum(opts = {unbiased: true})
-      if AREL_VERSION >= V9_0
-        Arel::Nodes::Sum.new [self]
-      else
-        ArelExtensions::Nodes::Sum.new self, **opts
-      end
+    def variance unbiased = true
+      ArelExtensions::Nodes::Variance.new [self,unbiased]
     end
 
-    # function that can be invoked to produce random numbers between 0 and 1
-    #    def rand seed = nil
-    #        ArelExtensions::Nodes::Rand.new [seed]
-    #    end
-    alias random rand rescue nil
+    #function that can be invoked to produce random numbers between 0 and 1
+#    def rand seed = nil
+#        ArelExtensions::Nodes::Rand.new [seed]
+#    end
+    alias_method :random, :rand
 
-    # 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
+    #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
     end
 
     # function returning a number at a specific format
-    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')
+    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::Nodes.build_quoted('Wrong Format')
+      end
     end
+
   end
 end

data/lib/arel_extensions/nodes/abs.rb

@@ -2,6 +2,7 @@ module ArelExtensions
   module Nodes
     class Abs < Function
       RETURN_TYPE = :number
+
     end
   end
 end

data/lib/arel_extensions/nodes/blank.rb

@@ -4,22 +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
 end

data/lib/arel_extensions/nodes/case.rb

@@ -1,15 +1,10 @@
 module ArelExtensions
   module Nodes
-    if AREL_VERSION < V7_1
+    if Arel::VERSION < "7.1.0"
       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
@@ -20,37 +15,34 @@ module ArelExtensions
 
         class Else < Arel::Nodes::Unary # :nodoc:
         end
+
       end
     else
       class Case < Arel::Nodes::Case
         class When < Arel::Nodes::When # :nodoc:
         end
-
         class Else < Arel::Nodes::Else # :nodoc:
         end
       end
     end
 
-    class ArelExtensions::Nodes::Case
+    ArelExtensions::Nodes::Case.class_eval do
       include Arel::Expressions
-      include Arel::Math
-      include Arel::Predications
       include Arel::OrderPredications
-      include ArelExtensions::Aliases
-      include ArelExtensions::Comparators
-      include ArelExtensions::DateDuration
       include ArelExtensions::Math
-      include ArelExtensions::MathFunctions
-      include ArelExtensions::NullFunctions
+      include ArelExtensions::Comparators
       include ArelExtensions::Predications
+      include ArelExtensions::MathFunctions
       include ArelExtensions::StringFunctions
+      include ArelExtensions::NullFunctions
 
       def return_type
-        obj =
-          if @conditions.length > 0
+        obj = if @conditions.length > 0
             @conditions.last.right
           elsif @default
             @default.expr
+          else
+            nil
           end
         if obj.respond_to?(:return_type)
           obj.return_type
@@ -58,32 +50,36 @@ module ArelExtensions
           case obj
           when Integer, Float
             :number
-          when Date, DateTime, Time
+          when Date, DateTime,Time
             :datetime
           when Arel::Attributes::Attribute
-            Arel.column_of(obj.relation.table_name, obj.name.to_s)&.type || :string
+            begin
+              Arel::Table.engine.connection.schema_cache.columns_hash(obj.relation.table_name)[obj.name.to_s].type
+            rescue Exception
+              :string
+            end
           else
             :string
           end
         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 }
@@ -94,16 +90,16 @@ module ArelExtensions
         [@case, @conditions, @default].hash
       end
 
-      def eql?(other)
+      def eql? other
         self.class == other.class &&
-          self.case == other.case &&
-          conditions == other.conditions &&
-          default == other.default
+        self.case == other.case &&
+        self.conditions == other.conditions &&
+        self.default == other.default
       end
-      alias == eql?
+      alias :== :eql?
 
-      def as(other)
-        Arel::Nodes::As.new self, Arel.sql(other)
+      def as other
+        Arel::Nodes::As.new self, Arel::Nodes::SqlLiteral.new(other)
       end
     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'
@@ -14,16 +14,13 @@ module ArelExtensions
           @return_type = :decimal
         when :number
           @return_type = :number
-        when 'char', 'varchar', 'nchar', 'nvarchar'
+        when 'char', 'varchar', 'text', 'nchar', 'nvarchar', 'ntext'
           @return_type = :string
-        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,21 +29,24 @@ module ArelExtensions
           @as_attr = :string
         end
         tab = [convert_to_node(expr.first)]
-        super(tab)
+        return super(tab)
       end
 
       def +(other)
         case @return_type
         when :string
-          ArelExtensions::Nodes::Concat.new [self, other]
+          return ArelExtensions::Nodes::Concat.new [self, other]
         when :ruby_time
           ArelExtensions::Nodes::DateAdd.new [self, other]
         else
-          Arel.grouping(Arel::Nodes::Addition.new(self, other))
+          Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
         end
       end
 
-      attr_reader :return_type
+      def return_type
+        @return_type
+      end
+
     end
   end
 end

data/lib/arel_extensions/nodes/ceil.rb

@@ -1,7 +1,7 @@
 module ArelExtensions
   module Nodes
     class Ceil < Function
-      RETURN_TYPE = :number
+    	RETURN_TYPE = :number
     end
   end
 end

data/lib/arel_extensions/nodes/coalesce.rb

@@ -2,14 +2,14 @@ module ArelExtensions
   module Nodes
     class Coalesce < Function
       RETURN_TYPE = :string
-
+      
       attr_accessor :left_node_type
 
       def return_type
         @left_node_type || self.class.const_get(:RETURN_TYPE)
       end
 
-      def initialize(expr)
+      def initialize expr
         tab = expr.map { |arg|
           convert_to_node(arg)
         }
@@ -20,15 +20,16 @@ module ArelExtensions
           @left_node_type = :number
         when ArelExtensions::Nodes::Coalesce, ArelExtensions::Nodes::Function
           @left_node_type = expr.first.respond_to?(:left_node_type) ? expr.first.left_node_type : nil
-        when Arel::Nodes::Node, Arel::Attributes::Attribute
+        when Arel::Nodes::Node, Arel::Attributes::Attribute 
           @left_node_type = type_of_attribute(expr.first)
         when Date
           @left_node_type = :ruby_date
         when DateTime, Time
           @left_node_type = :ruby_time
         end
-        super(tab)
+        return super(tab)
       end
+
     end
   end
 end

data/lib/arel_extensions/nodes/collate.rb

@@ -1,17 +1,18 @@
 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

@@ -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)
@@ -11,12 +11,12 @@ module ArelExtensions::Nodes
         else
           node
         end
-      }.flatten.reduce([]) { |res, b|
+      }.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.quoted(res.last.expr.to_s + b.expr.to_s)
+          res[-1] = Arel::Nodes.build_quoted(res.last.expr + b.expr)
         else
           res << b
         end
@@ -25,8 +25,8 @@ module ArelExtensions::Nodes
       super(tab)
     end
 
-    def self.new(expr)
-      o = super
+    def self.new expr
+      o = super(expr)
       if o.expressions.length == 1
         o.expressions[0]
       else
@@ -35,18 +35,27 @@ module ArelExtensions::Nodes
     end
 
     def concat(other)
-      Concat.new(expressions + [other])
+      Concat.new(self.expressions + [other])
     end
+
   end
 
-  class GroupConcat < AggregateFunction
+  class GroupConcat < Function
     RETURN_TYPE = :string
 
-    attr_accessor :separator
-
-    def initialize(node, separator = ', ', **opts)
-      @separator = convert_to_node(separator)
-      super(node, **opts)
+    attr_accessor :orders
+    
+    def initialize expr
+      tab = expr.map { |arg|
+        if arg.is_a?(Array)
+          @orders = arg
+          nil
+        else
+          convert_to_node(arg)
+        end
+      }.compact
+      super(tab)
     end
+
   end
 end