arel_extensions 2.0.1 → 2.0.11

data/lib/arel_extensions/nodes/function.rb

@@ -71,6 +71,8 @@ module ArelExtensions
           Arel.sql('NULL')
         when ActiveSupport::Duration
           Arel.sql(object.to_i)
+        when Array
+          Arel::Nodes::Grouping.new(object.map{|r| convert_to_node(e)})
         else
           raise(ArgumentError, "#{object.class} can not be converted to CONCAT arg")
         end

data/lib/arel_extensions/nodes/json.rb

@@ -18,7 +18,7 @@ module ArelExtensions
         JsonSet.new(self,key,value)
       end
 
-      def group as_array = true, orders= nil
+      def group as_array = true, orders = nil
         JsonGroup.new(self,as_array, orders)
       end
 
@@ -31,34 +31,51 @@ module ArelExtensions
     class Json < JsonNode
 
       def initialize *expr
-        if expr.length == 1
-          case expr.first
-          when JsonNode
-            @dict = expr.first.dict
-          when Array
-            @dict = expr.first.map{|e|
-              (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_node(e)
-            }
-          when Hash
-            @dict = expr.first.inject({}){|acc,v|
-              acc[convert_to_node(v[0])] =  (v[1].is_a?(Array) || v[1].is_a?(Hash)) ? Json.new(v[1]) :  convert_to_node(v[1])
-              acc
-            }
-          when String, Numeric, TrueClass, FalseClass
-            @dict = convert_to_node(expr.first)
-          when NilClass
-            @dict = Arel.sql('null')
+        @dict =
+          if expr.length == 1
+            convert_to_json_node(expr.first)
           else
-            if expr.first.is_a?(String) || (expr.first.is_a?(Arel::Attributes::Attribute) && type_of_attribute(expr.first) == :string) || (expr.first.return_type == :string)
-              @dict = convert_to_node(expr.first)
-            else
-              @dict = [convert_to_node(expr.first)]
-            end
+            expr.map{|e| convert_to_json_node(e) }
           end
+        super
+      end
+
+      def convert_to_json_node(n)
+        case n
+        when JsonNode
+          n.dict
+        when Array
+          n.map{|e|
+             (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_json_node(e)
+          }
+        when Hash
+          n.reduce({}){|acc,v|
+            acc[convert_to_json_node(v[0])] = (v[1].is_a?(Array) || v[1].is_a?(Hash)) ? Json.new(v[1]) : convert_to_json_node(v[1])
+            acc
+          }
+        when String, Numeric, TrueClass, FalseClass
+          convert_to_node(n)
+        when Date
+          convert_to_node(n.strftime("%Y-%m-%d"))
+        when DateTime, Time
+          convert_to_node(n.strftime("%Y-%m-%dT%H:%M:%S.%L%:z"))
+        when NilClass
+          Arel.sql('null')
         else
-          @dict = expr.map{|e| (e.is_a?(Array) || e.is_a?(Hash)) ? Json.new(e) : convert_to_node(e) }
+          convert_to_node(n)
+        end
+      end
+
+      def type_of_node(v)
+        if v.is_a?(Arel::Attributes::Attribute)
+          self.type_of_attribute(v)
+        elsif v.respond_to?(:return_type)
+          v.return_type
+        elsif v.nil?
+          :nil
+        else
+          :string
         end
-        super
       end
 
     end
@@ -73,11 +90,7 @@ module ArelExtensions
         @dict = as_array ? json : json.dict
         @as_array = as_array
         if orders
-          if orders.is_a?(Array)
-            @orders = orders
-          else
-            @orders = [orders]
-          end
+          @orders = Array(orders)
         end
       end
     end

data/lib/arel_extensions/nodes/matches.rb

@@ -3,7 +3,7 @@ module ArelExtensions
     class IMatches < Arel::Nodes::Matches
 
       attr_accessor :case_sensitive if Arel::VERSION.to_i < 7
-      
+
       def initialize(left, right, escape = nil)
         r = Arel::Nodes.build_quoted(right)
         if Arel::VERSION.to_i < 7 # managed by default in version 7+ (rails 5), so useful for rails 3 & 4
@@ -17,13 +17,13 @@ module ArelExtensions
 
     class IDoesNotMatch < IMatches
     end
-    
+
     class AiMatches < IMatches
     end
-    
+
     class AiIMatches < IMatches
     end
-    
+
     class SMatches < IMatches
     end
 

data/lib/arel_extensions/nodes/power.rb

@@ -1,11 +1,12 @@
 module ArelExtensions
   module Nodes
     class Power < Function
-    	RETURN_TYPE = :number
-		
-		def initialize expr
-		  super [convert_to_node(expr.first), convert_to_number(expr[1])]		  
-		end
+      RETURN_TYPE = :number
+
+      def initialize expr
+        super [convert_to_node(expr.first), convert_to_number(expr[1])]
+      end
+
     end
   end
 end

data/lib/arel_extensions/nodes/repeat.rb

@@ -2,7 +2,7 @@ module ArelExtensions
   module Nodes
     class Repeat < Function
       RETURN_TYPE = :string
-      
+
       def initialize expr
         tab = expr.map { |arg|
           convert_to_node(arg)
@@ -11,7 +11,7 @@ module ArelExtensions
       end
 
       def +(other)
-        return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
+        return ArelExtensions::Nodes::Concat.new(self.expressions + [other])
       end
 
     end

data/lib/arel_extensions/nodes/replace.rb

@@ -2,18 +2,36 @@ module ArelExtensions
   module Nodes
     class Replace < Function
       RETURN_TYPE = :string
+      attr_accessor :left, :pattern, :substitute
 
-      def initialize expr
-        tab = expr.map { |arg|
-          convert_to_node(arg)
-        }
-        return super(tab)
+      def initialize left, pattern, substitute
+        @left = convert_to_node(left)
+        @pattern = convert_to_node(pattern)
+        @substitute = convert_to_node(substitute)
+        super([@left,@pattern,@substitute])
       end
 
       def +(other)
-        return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
+        return ArelExtensions::Nodes::Concat.new(self.expressions + [other])
       end
 
     end
+
+    class RegexpReplace < Function
+      RETURN_TYPE = :string
+      attr_accessor :left, :pattern, :substitute
+
+      def initialize left, pattern, substitute
+        @left = convert_to_node(left)
+        @pattern = (pattern.is_a?(Regexp) ? pattern : %r[#{pattern}])
+        @substitute = convert_to_node(substitute)
+        super([@left,@pattern,@substitute])
+      end
+
+      def +(other)
+        return ArelExtensions::Nodes::Concat.new(self.expressions + [other])
+      end
+    end
+
   end
 end

data/lib/arel_extensions/nodes/round.rb

@@ -4,11 +4,11 @@ module ArelExtensions
       RETURN_TYPE = :number
 
       def initialize expr
-      	if expr && expr.length == 1
-      		super [convert_to_node(expr.first)]
-      	else
-      		super [convert_to_node(expr.first), convert_to_number(expr[1])]
-      	end
+        if expr && expr.length == 1
+          super [convert_to_node(expr.first)]
+        else
+          super [convert_to_node(expr.first), convert_to_number(expr[1])]
+        end
       end
 
     end

data/lib/arel_extensions/nodes/soundex.rb

@@ -1,18 +1,19 @@
 module ArelExtensions
-	module Nodes
-		class Soundex < Function	
-			include Arel::Expressions
-			include ArelExtensions::Comparators			
-							
-			RETURN_TYPE = :string
-				
-			def ==(other)
-				Arel::Nodes::Equality.new self, Arel::Nodes.build_quoted(other, self)
-			end
+  module Nodes
+    class Soundex < Function
+      include Arel::Expressions
+      include ArelExtensions::Comparators
 
-			def !=(other)
-				Arel::Nodes::NotEqual.new self, Arel::Nodes.build_quoted(other, self)
-			end
-		end
-	end
+      RETURN_TYPE = :string
+
+      def ==(other)
+        Arel::Nodes::Equality.new self, Arel::Nodes.build_quoted(other, self)
+      end
+
+      def !=(other)
+        Arel::Nodes::NotEqual.new self, Arel::Nodes.build_quoted(other, self)
+      end
+
+    end
+  end
 end

data/lib/arel_extensions/nodes/std.rb

@@ -1,26 +1,24 @@
 module ArelExtensions
   module Nodes
-    class Std < Function
-    	RETURN_TYPE = :number
-    	
-		attr_accessor :unbiased_estimator
-    	def initialize expr
-	        col = expr.first
-            @unbiased_estimator = expr[1]
-        	super [col]
-    	end    	
+    class Std < AggregateFunction
+      RETURN_TYPE = :number
+      attr_accessor :unbiased_estimator
+
+      def initialize node, opts = {}
+        @unbiased_estimator = opts[:unbiased] ? true : false
+        super node, opts
+      end
     end
-    
-    class Variance < Function
-    	RETURN_TYPE = :number
-    	
-		attr_accessor :unbiased_estimator
-    	def initialize expr
-	        col = expr.first
-            @unbiased_estimator = expr[1]
-        	super [col]
-    	end    	
-    end    
-    
+
+    class Variance < AggregateFunction
+      RETURN_TYPE = :number
+      attr_accessor :unbiased_estimator
+
+      def initialize node, opts = {}
+        @unbiased_estimator = opts[:unbiased] ? true : false
+        super node, opts
+      end
+    end
+
   end
 end

data/lib/arel_extensions/nodes/substring.rb

@@ -1,22 +1,15 @@
 module ArelExtensions
   module Nodes
     class Substring < Function
-    	RETURN_TYPE = :string
+      RETURN_TYPE = :string
 
-		def initialize expr
-			tab = [convert_to_node(expr[0]), convert_to_node(expr[1])]
-			if expr[2]
-				tab << convert_to_node(expr[2])
-#			else
-#				tab << expr[0].length
-			end
-			return super(tab)
-		end
-
-#		def +(other)
-#			puts "[Substring] : #{other.inspect} (#{self.expressions.inspect})"
-#	        return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
-#		end
+      def initialize expr
+        tab = [convert_to_node(expr[0]), convert_to_node(expr[1])]
+        if expr[2]
+          tab << convert_to_node(expr[2])
+        end
+        return super(tab)
+      end
 
     end
   end

data/lib/arel_extensions/nodes/sum.rb

@@ -0,0 +1,7 @@
+module ArelExtensions
+  module Nodes
+    class Sum < AggregateFunction
+      RETURN_TYPE = :number
+    end
+  end
+end

data/lib/arel_extensions/nodes/trim.rb

@@ -2,7 +2,7 @@ module ArelExtensions
   module Nodes
     class Trim < Function
       RETURN_TYPE = :string
-      
+
       def initialize expr
         tab = expr.map { |arg|
           convert_to_node(arg)
@@ -11,13 +11,13 @@ module ArelExtensions
       end
 
       def +(other)
-        return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
+        return ArelExtensions::Nodes::Concat.new(self.expressions + [other])
       end
 
     end
 
     class Ltrim < Trim
-	  RETURN_TYPE = :string
+      RETURN_TYPE = :string
     end
 
     class Rtrim < Trim

data/lib/arel_extensions/nodes/union.rb

@@ -7,11 +7,11 @@ module ArelExtensions
       end
 
       def +(other)
-        return ArelExtensions::Nodes::Union.new(self,other) 
+        return ArelExtensions::Nodes::Union.new(self,other)
       end
 
       def union(other)
-        return ArelExtensions::Nodes::UnionAll.new(self,other) 
+        return ArelExtensions::Nodes::UnionAll.new(self,other)
       end
 
       def as other
@@ -21,4 +21,3 @@ module ArelExtensions
 
   end
 end
-

data/lib/arel_extensions/nodes/union_all.rb

@@ -17,4 +17,3 @@ module ArelExtensions
 
   end
 end
-

data/lib/arel_extensions/null_functions.rb

@@ -8,12 +8,12 @@ module ArelExtensions
     def is_null
       ArelExtensions::Nodes::IsNull.new [self]
     end
-    
+
     #ISNOTNULL function lets you return an alternative value when an expression is NOT NULL.
     def is_not_null
       ArelExtensions::Nodes::IsNotNull.new [self]
     end
-    
+
     # returns the first non-null expr in the expression list. You must specify at least two expressions.
     #If all occurrences of expr evaluate to null, then the function returns null.
     def coalesce *args

data/lib/arel_extensions/predications.rb

@@ -1,10 +1,11 @@
 module ArelExtensions
   module Predications
-    def when right, expression=nil
+
+    def when right, expression = nil
       ArelExtensions::Nodes::Case.new(self).when(right,expression)
     end
 
-    def matches(other, escape=nil,case_sensitive= nil)
+    def matches(other, escape = nil,case_sensitive = nil)
       if Arel::VERSION.to_i < 7
         Arel::Nodes::Matches.new(self, Arel::Nodes.build_quoted(other), escape)
       else
@@ -12,7 +13,7 @@ module ArelExtensions
       end
     end
 
-    def imatches(other, escape=nil)
+    def imatches(other, escape = nil)
       ArelExtensions::Nodes::IMatches.new(self, other, escape)
     end
 
@@ -20,51 +21,53 @@ module ArelExtensions
       ArelExtensions::Nodes::Cast.new([self,right])
     end
 
-    def in(other) #In should handle nil element in the Array
+    def in(*other) #In should handle nil element in the Array
+      other = other.first if other.length <= 1
       case other
       when Range
         self.between(other)
+      when Arel::Nodes::Grouping
+        Arel::Nodes::In.new(self, quoted_node(other))
       when Enumerable
-        if other.include?(nil)
-          other.delete(nil)
-          case other.length
-          when 0
-            self.is_null
-          when 1
-            self.is_null.or(self==other[0])
-          else
-            self.is_null.or(Arel::Nodes::In.new(self,quoted_array(other)))
-          end
-        else
-          Arel::Nodes::In.new(self,quoted_array(other))
-        end
+        nils, values   = other.partition{ |v| v.nil? }
+        ranges, values = values.partition{ |v| v.is_a?(Range) || v.is_a?(Arel::SelectManager)}
+        # In order of (imagined) decreasing efficiency: nil, values, and then more complex.
+        clauses =
+          nils.uniq.map { |r| self.in(r) } \
+          + (case values.uniq.size
+              when 0 then []
+              when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? self.in(values[0]) : self.eq(values[0])]
+              else [Arel::Nodes::In.new(self, quoted_array(values))] end) \
+          + ranges.uniq.map { |r| self.in(r) }
+        clauses.empty? ? Arel.false : clauses.reduce(&:or)
       when nil
         self.is_null
       when Arel::SelectManager
         Arel::Nodes::In.new(self, other.ast)
       else
-        Arel::Nodes::In.new(self,quoted_node(other))
+        Arel::Nodes::In.new(self, quoted_node(other))
       end
     end
 
-    def not_in(other) #In should handle nil element in the Array
+    def not_in(*other) #In should handle nil element in the Array
+      other = other.first if other.length <= 1
       case other
       when Range
         Arel::Nodes::Not.new(self.between(other))
+      when Arel::Nodes::Grouping
+        Arel::Nodes::NotIn.new(self, quoted_node(other))
       when Enumerable
-        if other.include?(nil)
-          other.delete(nil)
-          case other.length
-          when 0
-            self.is_not_null
-          when 1
-            self.is_not_null.and(self!=other[0])
-          else
-            self.is_not_null.and(Arel::Nodes::NotIn.new(self,quoted_array(other)))
-          end
-        else
-          Arel::Nodes::NotIn.new(self,quoted_array(other))
-        end
+        nils, values   = other.partition{ |v| v.nil? }
+        ranges, values = values.partition{ |v| v.is_a?(Range) || v.is_a?(Arel::SelectManager)}
+        # In order of (imagined) decreasing efficiency: nil, values, and then more complex.
+        clauses =
+          nils.uniq.map { |r| self.not_in(r) } \
+          + (case values.uniq.size
+              when 0 then []
+              when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? self.not_in(values[0]) : self.not_eq(values[0])]
+              else [Arel::Nodes::NotIn.new(self, quoted_array(values))] end) \
+          + ranges.uniq.map { |r| self.not_in(r) }
+        Arel::Nodes::And.new clauses
       when nil
         self.is_not_null
       when Arel::SelectManager
@@ -94,6 +97,5 @@ module ArelExtensions
         raise(ArgumentError, "#{object.class} can not be converted to CONCAT arg")
       end
     end
-
   end
 end