arel_extensions 1.3.4 → 2.0.0.rc3

data/lib/arel_extensions/nodes/power.rb

@@ -1,11 +1,11 @@
 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/rand.rb

@@ -10,6 +10,7 @@ module ArelExtensions
           super []
         end
       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,8 +11,10 @@ module ArelExtensions
       end
 
       def +(other)
-        return ArelExtensions::Nodes::Concat.new(self.expressions + [other])
+        return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
       end
+
     end
+
   end
 end

data/lib/arel_extensions/nodes/replace.rb

@@ -2,26 +2,18 @@ module ArelExtensions
   module Nodes
     class Replace < Function
       RETURN_TYPE = :string
-      attr_accessor :left, :pattern, :substitute
 
-      def initialize left, pattern, substitute
-        @left = convert_to_node(left)
-        @pattern = convert_to_node(pattern)
-        @substitute = convert_to_node(substitute)
-        super([@left, @pattern, @substitute])
+      def initialize expr
+        tab = expr.map { |arg|
+          convert_to_node(arg)
+        }
+        return super(tab)
       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])
+      def +(other)
+        return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
       end
+
     end
   end
 end

data/lib/arel_extensions/nodes/round.rb

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

data/lib/arel_extensions/nodes/soundex.rb

@@ -1,18 +1,18 @@
 module ArelExtensions
-  module Nodes
-    class Soundex < Function
-      include Arel::Expressions
-      include ArelExtensions::Comparators
+	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
 
-      RETURN_TYPE = :string
-
-      def ==(other)
-        Arel::Nodes::Equality.new self, Arel.quoted(other, self)
-      end
-
-      def !=(other)
-        Arel::Nodes::NotEqual.new self, Arel.quoted(other, self)
-      end
-    end
-  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,23 +1,26 @@
 module ArelExtensions
   module Nodes
-    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 < AggregateFunction
-      RETURN_TYPE = :number
-      attr_accessor :unbiased_estimator
-
-      def initialize node, **opts
-        @unbiased_estimator = opts[:unbiased] ? true : false
-        super node, **opts
-      end
+    class Std < Function
+    	RETURN_TYPE = :number
+    	
+		attr_accessor :unbiased_estimator
+    	def initialize expr
+	        col = expr.first
+            @unbiased_estimator = expr[1]
+        	super [col]
+    	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    
+    
   end
 end

data/lib/arel_extensions/nodes/substring.rb

@@ -1,15 +1,23 @@
 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
 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,16 +11,18 @@ 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
       RETURN_TYPE = :string
     end
+
   end
 end

data/lib/arel_extensions/nodes/union.rb

@@ -1,21 +1,24 @@
 module ArelExtensions
   module Nodes
     class Union < Arel::Nodes::Union
-      def initialize left, right
-        return super(left, right)
+
+      def initialize left,right
+        return super(left,right)
       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
-        Arel::Nodes::TableAlias.new Arel.grouping(self), Arel::Nodes::SqlLiteral.new(other.to_s)
+        Arel::Nodes::TableAlias.new Arel::Nodes::Grouping.new(self), Arel::Nodes::SqlLiteral.new(other.to_s)
       end
     end
+
   end
 end
+

data/lib/arel_extensions/nodes/union_all.rb

@@ -1,17 +1,20 @@
 module ArelExtensions
   module Nodes
     class UnionAll < Arel::Nodes::UnionAll
-      def initialize left, right
-        return super(left, right)
+
+      def initialize left,right
+        return super(left,right)
       end
 
       def union_all(other)
-        return ArelExtensions::Nodes::UnionAll.new(self, other)
+        return ArelExtensions::Nodes::UnionAll.new(self,other)
       end
 
       def as other
-        Arel::Nodes::TableAlias.new Arel.grouping(self), Arel::Nodes::SqlLiteral.new(other.to_s)
+        Arel::Nodes::TableAlias.new Arel::Nodes::Grouping.new(self), Arel::Nodes::SqlLiteral.new(other.to_s)
       end
     end
+
   end
 end
+

data/lib/arel_extensions/nodes/wday.rb

@@ -1,15 +1,19 @@
 module ArelExtensions
   module Nodes
     class Wday < Function
+
+
       def initialize other, aliaz = nil
         tab = Array.new
         tab << other
         super(tab, aliaz)
       end
 
+
       def date
         @expressions.first
       end
+
     end
   end
 end

data/lib/arel_extensions/nodes.rb

@@ -1,2 +1,2 @@
 require 'arel_extensions/nodes/function'
-require 'arel_extensions/nodes/aggregate_function'
+

data/lib/arel_extensions/null_functions.rb

@@ -3,21 +3,23 @@ require 'arel_extensions/nodes/is_null'
 
 module ArelExtensions
   module NullFunctions
-    # ISNULL function lets you return an alternative value when an expression is NULL.
+
+    #ISNULL function lets you return an alternative value when an expression is NULL.
     def is_null
       ArelExtensions::Nodes::IsNull.new [self]
     end
-
-    # ISNOTNULL function lets you return an alternative value when an expression is NOT NULL.
+    
+    #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.
+    #If all occurrences of expr evaluate to null, then the function returns null.
     def coalesce *args
       args.unshift(self)
       ArelExtensions::Nodes::Coalesce.new args
     end
+
   end
 end

data/lib/arel_extensions/predications.rb

@@ -1,78 +1,76 @@
 module ArelExtensions
   module Predications
-    def when right, expression = nil
-      ArelExtensions::Nodes::Case.new(self).when(right, expression)
+    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.quoted(other), escape)
+        Arel::Nodes::Matches.new(self, Arel::Nodes.build_quoted(other), escape)
       else
-        Arel::Nodes::Matches.new(self, Arel.quoted(other), escape, case_sensitive)
+        Arel::Nodes::Matches.new(self, Arel::Nodes.build_quoted(other), escape, case_sensitive)
       end
     end
 
-    def imatches(other, escape = nil)
+    def imatches(other, escape=nil)
       ArelExtensions::Nodes::IMatches.new(self, other, escape)
     end
 
     def cast right
-      ArelExtensions::Nodes::Cast.new([self, right])
+      ArelExtensions::Nodes::Cast.new([self,right])
     end
 
-    def in(*other) # In should handle nil element in the Array
-      other = other.first if other.length <= 1
+    def in(other) #In should handle nil element in the Array
       case other
       when Range
         self.between(other)
-      when Arel::Nodes::Grouping, ArelExtensions::Nodes::Union, ArelExtensions::Nodes::UnionAll
-        Arel::Nodes::In.new(self, quoted_node(other))
       when Enumerable
-        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)
+        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
       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
-      other = other.first if other.length <= 1
+    def not_in(other) #In should handle nil element in the Array
       case other
       when Range
         Arel::Nodes::Not.new(self.between(other))
-      when Arel::Nodes::Grouping, ArelExtensions::Nodes::Union, ArelExtensions::Nodes::UnionAll
-        Arel::Nodes::NotIn.new(self, quoted_node(other))
       when Enumerable
-        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
+        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
       when nil
         self.is_not_null
       when Arel::SelectManager
         Arel::Nodes::NotIn.new(self, other.ast)
       else
-        Arel::Nodes::NotIn.new(self, quoted_node(other))
+        Arel::Nodes::NotIn.new(self,quoted_node(other))
       end
     end
 
@@ -81,20 +79,21 @@ module ArelExtensions
       when Arel::Attributes::Attribute, Arel::Nodes::Node, Integer
         object
       when DateTime
-        Arel.quoted(object, self)
+        Arel::Nodes.build_quoted(object, self)
       when Time
-        Arel.quoted(object.strftime('%H:%M:%S'), self)
+        Arel::Nodes.build_quoted(object.strftime('%H:%M:%S'), self)
       when String
-        Arel.quoted(object)
+        Arel::Nodes.build_quoted(object)
       when Date
-        Arel.quoted(object.to_s, self)
+        Arel::Nodes.build_quoted(object.to_s, self)
       when NilClass
         Arel.sql('NULL')
       when ActiveSupport::Duration
         object.to_i
       else
-        raise(ArgumentError, "#{object.class} cannot be converted to CONCAT arg")
+        raise(ArgumentError, "#{object.class} can not be converted to CONCAT arg")
       end
     end
+
   end
 end

data/lib/arel_extensions/railtie.rb

@@ -1,9 +1,9 @@
 require 'rails'
 
 module ArelExtensions
-  class Railtie < Rails::Railtie
-    rake_tasks do
-      load 'arel_extensions/tasks.rb'
-    end
-  end
+	class Railtie < Rails::Railtie
+		rake_tasks do
+    		load 'arel_extensions/tasks.rb'
+    	end
+	end
 end

data/lib/arel_extensions/set_functions.rb

@@ -3,28 +3,30 @@ require 'arel_extensions/nodes/union_all'
 
 module ArelExtensions
   module SetFunctions
+
     def +(other)
-      ArelExtensions::Nodes::Union.new(self, other)
+      ArelExtensions::Nodes::Union.new(self,other)
     end
 
     def union(other)
-      ArelExtensions::Nodes::Union.new(self, other)
+      ArelExtensions::Nodes::Union.new(self,other)
     end
 
     def union_all(other)
-      ArelExtensions::Nodes::UnionAll.new(self, other)
+      ArelExtensions::Nodes::UnionAll.new(self,other)
     end
 
     def uniq
       self
     end
+
   end
 end
 
-class Arel::Nodes::Union
+Arel::Nodes::Union.class_eval do
   include ArelExtensions::SetFunctions
 end
 
-class Arel::Nodes::UnionAll
+Arel::Nodes::UnionAll.class_eval do
   include ArelExtensions::SetFunctions
 end