arel_extensions 1.3.9 → 2.0.0.rc3

data/lib/arel_extensions/nodes/trim.rb

@@ -2,25 +2,27 @@ module ArelExtensions
   module Nodes
     class Trim < Function
       RETURN_TYPE = :string
-
+      
       def initialize expr
         tab = expr.map { |arg|
           convert_to_node(arg)
         }
-        super(tab)
+        return super(tab)
       end
 
       def +(other)
-        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
-        super(left, right)
+
+      def initialize left,right
+        return super(left,right)
       end
 
       def +(other)
-        ArelExtensions::Nodes::Union.new(self, other)
+        return ArelExtensions::Nodes::Union.new(self,other) 
       end
 
       def union(other)
-        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
-        super(left, right)
+
+      def initialize left,right
+        return super(left,right)
       end
 
       def union_all(other)
-        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

@@ -4,36 +4,22 @@ require 'arel_extensions/nodes/is_null'
 module ArelExtensions
   module NullFunctions
 
-    # if_present returns nil if the the value is nil or blank
-    def if_present
-      Arel.when(self.cast(:string).present).then(self)
-    end
-
-    # 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
 
-    def coalesce_blank *args
-      res = Arel.when(self.cast(:string).present).then(self)
-      args[0...-1].each do |a|
-        val = a.is_a?(Arel::Nodes::Node) ? a : Arel.quoted(a)
-        res = res.when(val.present).then(a)
-      end
-      res = res.else(args[-1])
-      res
-    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

data/lib/arel_extensions/string_functions.rb

@@ -1,4 +1,4 @@
-require 'arel_extensions/nodes/concat' # if Arel::VERSION.to_i < 7
+require 'arel_extensions/nodes/concat' #if Arel::VERSION.to_i < 7
 require 'arel_extensions/nodes/length'
 require 'arel_extensions/nodes/locate'
 require 'arel_extensions/nodes/substring'
@@ -19,26 +19,19 @@ require 'arel_extensions/nodes/md5'
 
 module ArelExtensions
   module StringFunctions
-    # *FindInSet function .......
+
+    #*FindInSet function .......
     def &(other)
       ArelExtensions::Nodes::FindInSet.new [other, self]
     end
 
-    # LENGTH function returns the length (bytewise) of the value in a text field.
+    #LENGTH function returns the length of the value in a text field.
     def length
-      ArelExtensions::Nodes::Length.new self, true
-    end
-
-    def byte_length
-      ArelExtensions::Nodes::Length.new self, true
+      ArelExtensions::Nodes::Length.new [self]
     end
 
-    def char_length
-      ArelExtensions::Nodes::Length.new self, false
-    end
-
-    # LOCATE function returns the first starting position of a string in another string.
-    # If string1 or string2 is NULL then it returns NULL. If string1 not found in string2 then it returns 0.
+    #LOCATE function returns the first starting position of a string in another string.
+    #If string1 or string2 is NULL then it returns NULL. If string1 not found in string2 then it returns 0.
     def locate val
       ArelExtensions::Nodes::Locate.new [self, val]
     end
@@ -58,7 +51,7 @@ module ArelExtensions
       end
     end
 
-    # SOUNDEX function returns a character string containing the phonetic representation of char.
+    #SOUNDEX function returns a character string containing the phonetic representation of char.
     def soundex
       ArelExtensions::Nodes::Soundex.new [self]
     end
@@ -71,19 +64,6 @@ module ArelExtensions
       grouping_any :imatches, others, escape
     end
 
-    #    def grouping_any method, others, *extra
-    #      puts "*******************"
-    #      puts method
-    #      puts others.inspect
-    #      puts extra.inspect
-    #      puts "-------------------"
-    #      res = super(method,others,*extra)
-    #      puts res.to_sql
-    #      puts res.inspect
-    #      puts "*******************"
-    #      res
-    #    end
-
     def imatches_all others, escape = nil
       grouping_all :imatches, others, escape, escape
     end
@@ -101,62 +81,53 @@ module ArelExtensions
     end
 
     def ai_matches other # accent insensitive & case sensitive
-      ArelExtensions::Nodes::AiMatches.new(self, other)
+      ArelExtensions::Nodes::AiMatches.new(self,other)
     end
 
     def ai_imatches other # accent insensitive & case insensitive
-      ArelExtensions::Nodes::AiIMatches.new(self, other)
+      ArelExtensions::Nodes::AiIMatches.new(self,other)
     end
 
     def smatches other # accent sensitive & case sensitive
-      ArelExtensions::Nodes::SMatches.new(self, other)
+      ArelExtensions::Nodes::SMatches.new(self,other)
     end
 
-    def ai_collate
-      ArelExtensions::Nodes::Collate.new(self, nil, true, false)
+    def ai_collate 
+      ArelExtensions::Nodes::Collate.new(self,nil,true,false)
     end
 
     def ci_collate
-      ArelExtensions::Nodes::Collate.new(self, nil, false, true)
-    end
-
-    def collate ai = false, ci = false, option = nil
-      ArelExtensions::Nodes::Collate.new(self, option, ai, ci)
+      ArelExtensions::Nodes::Collate.new(self,nil,false,true)
     end
 
-    # REPLACE function replaces a sequence of characters in a string with another set of characters, not case-sensitive.
-    def replace pattern, substitute
-      if pattern.is_a? Regexp
-        ArelExtensions::Nodes::RegexpReplace.new self, pattern, substitute
-      else
-        ArelExtensions::Nodes::Replace.new self, pattern, substitute
-      end
+    def collate ai=false,ci=false, option=nil
+      ArelExtensions::Nodes::Collate.new(self,option,ai,ci)
     end
 
-    def regexp_replace pattern, substitute
-      ArelExtensions::Nodes::RegexpReplace.new self, pattern, substitute
+    #REPLACE function replaces a sequence of characters in a string with another set of characters, not case-sensitive.
+    def replace left, right
+      ArelExtensions::Nodes::Replace.new [self, left, right]
     end
-
+    
     def concat other
       ArelExtensions::Nodes::Concat.new [self, other]
     end
 
-    # concat elements of a group, separated by sep and ordered by a list of Ascending or Descending
-    def group_concat(sep = nil, *orders, group: nil, order: nil)
-      if orders.present?
-        warn("Warning: ArelExtensions: group_concat: you should now use the kwarg 'order' to specify an order in the group_concat.")
-      end
+    #concat elements of a group, separated by sep and ordered by a list of Ascending or Descending
+    def group_concat sep = nil, *orders 
       order_tabs = [orders].flatten.map{ |o|
         if o.is_a?(Arel::Nodes::Ascending) || o.is_a?(Arel::Nodes::Descending)
           o
         elsif o.respond_to?(:asc)
           o.asc
+        else
+          nil
         end
       }.compact
-      ArelExtensions::Nodes::GroupConcat.new(self, sep, group: group, order: (order || order_tabs))
+      ArelExtensions::Nodes::GroupConcat.new [self, sep, order_tabs]
     end
 
-    # Function returns a string after removing left, right or the both prefixes or suffixes int argument
+    #Function returns a string after removing left, right or the both prefixes or suffixes int argument
     def trim other = ' '
       ArelExtensions::Nodes::Trim.new [self, other]
     end
@@ -184,12 +155,11 @@ module ArelExtensions
     def not_blank
       ArelExtensions::Nodes::NotBlank.new [self]
     end
-    alias present not_blank
-
-    def repeat other = 1
+    
+    def repeat other = 1 
       ArelExtensions::Nodes::Repeat.new [self, other]
     end
-
+    
     def levenshtein_distance other
       ArelExtensions::Nodes::LevenshteinDistance.new [self, other]
     end

data/lib/arel_extensions/tasks.rb

@@ -1,12 +1,12 @@
 namespace :arel_extensions do
-  desc 'Install DB functions into current DB'
-  task install_functions: :environment do
-    @env_db = if ENV['DB'] == 'oracle' && ((defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx') || (RUBY_PLATFORM == 'java')) # not supported
-                (RUBY_PLATFORM == 'java' ? 'jdbc-sqlite' : 'sqlite')
+	desc 'Install DB functions into current DB'
+	task :install_functions => :environment do
+		@env_db = if ENV['DB'] == 'oracle' && ((defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx") || (RUBY_PLATFORM == 'java')) # not supported
+                (RUBY_PLATFORM == 'java' ? "jdbc-sqlite" : 'sqlite')
               else
                 ENV['DB'] || ActiveRecord::Base.connection.adapter_name
               end
-    ActiveRecord::Base.establish_connection(Rails.env.to_sym)
+    ActiveRecord::Base.establish_connection(Rails.env)
     CommonSqlFunctions.new(ActiveRecord::Base.connection).add_sql_functions(@env_db)
-  end
+	end
 end

data/lib/arel_extensions/version.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = '1.3.9'.freeze
+  VERSION = "2.0.0.rc3".freeze
 end

data/lib/arel_extensions/visitors/ibm_db.rb

@@ -1,69 +1,76 @@
 module ArelExtensions
   module Visitors
-    class Arel::Visitors::IBM_DB
+    Arel::Visitors::IBM_DB.class_eval do
+
       def visit_ArelExtensions_Nodes_Ceil o, collector
-        collector << 'CEILING('
+        collector << "CEILING("
         collector = visit o.expr, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
       def visit_ArelExtensions_Nodes_Trim o, collector
-        collector << 'LTRIM(RTRIM('
+        collector << "LTRIM(RTRIM("
         o.expressions.each_with_index { |arg, i|
-          collector << COMMA if i != 0
+          collector << Arel::Visitors::IBM_DB::COMMA unless i == 0
           collector = visit arg, collector
         }
-        collector << '))'
+        collector << "))"
         collector
       end
 
+
       def visit_ArelExtensions_Nodes_DateDiff o, collector
-        collector << 'DAY('
+        collector << "DAY("
         collector = visit o.left, collector
-        collector << ','
+        collector << ","
         if o.right.is_a?(Arel::Attributes::Attribute)
           collector = visit o.right, collector
         else
           collector << "'#{o.right}'"
         end
-        collector << ')'
+        collector << ")"
         collector
       end
 
+
       def visit_ArelExtensions_Nodes_Duration o, collector
-        # visit left for period
-        if o.left == 'd'
-          collector << 'DAY('
-        elsif o.left == 'm'
-          collector << 'MONTH('
-        elsif o.left == 'w'
-          collector << 'WEEK'
-        elsif o.left == 'y'
-          collector << 'YEAR('
+        #visit left for period
+        if o.left == "d"
+          collector << "DAY("
+        elsif o.left == "m"
+          collector << "MONTH("
+        elsif o.left == "w"
+          collector << "WEEK"
+        elsif o.left == "y"
+          collector << "YEAR("
         end
-        # visit right
+        #visit right
         if o.right.is_a?(Arel::Attributes::Attribute)
           collector = visit o.right, collector
         else
           collector << "'#{o.right}'"
         end
-        collector << ')'
+        collector << ")"
         collector
       end
 
+
       def visit_ArelExtensions_Nodes_IsNull o, collector
-        collector << 'COALESCE('
+        collector << "COALESCE("
         collector = visit o.left, collector
-        collector << ','
-        if o.right.is_a?(Arel::Attributes::Attribute)
+        collector << ","
+        if(o.right.is_a?(Arel::Attributes::Attribute))
           collector = visit o.right, collector
         else
           collector << "'#{o.right}'"
         end
-        collector << ')'
+        collector << ")"
         collector
       end
+
+
+
     end
   end
 end