arel_extensions 1.7.0 → 2.0.0.rc3

data/lib/arel_extensions/null_functions.rb

@@ -3,35 +3,23 @@ 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(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.
-    def coalesce(*args)
+    #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(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.else(args[-1])
-    end
   end
 end

data/lib/arel_extensions/predications.rb

@@ -1,80 +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)
-      if AREL_VERSION < V7
-        Arel::Nodes::Matches.new(self, Arel.quoted(other), escape)
+    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
-        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])
+    def cast 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
-        between(other)
-      when Arel::Nodes::Grouping, ArelExtensions::Nodes::Union, ArelExtensions::Nodes::UnionAll
-        Arel::Nodes::In.new(self, quoted_node(other))
+        self.between(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]) : 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
-        is_null
+        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(between(other))
-      when Arel::Nodes::Grouping, ArelExtensions::Nodes::Union, ArelExtensions::Nodes::UnionAll
-        Arel::Nodes::NotIn.new(self, quoted_node(other))
+        Arel::Nodes::Not.new(self.between(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| not_in(r) } \
-          + (case values.uniq.size
-             when 0 then []
-             when 1 then [values[0].is_a?(Arel::Nodes::Grouping) ? not_in(values[0]) : not_eq(values[0])]
-             else [Arel::Nodes::NotIn.new(self, quoted_array(values))]
-             end) \
-          + ranges.uniq.map { |r| 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
-        is_not_null
+        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
 
@@ -83,22 +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)
-      when TrueClass, FalseClass
-        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,6 +1,4 @@
-require 'arel_extensions/nodes/byte_size'
-require 'arel_extensions/nodes/char_length'
-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'
@@ -18,179 +16,127 @@ require 'arel_extensions/nodes/collate'
 require 'arel_extensions/nodes/levenshtein_distance'
 require 'arel_extensions/nodes/md5'
 
+
 module ArelExtensions
   module StringFunctions
-    include ArelExtensions::Warning
 
-    # *FindInSet function .......
+    #*FindInSet function .......
     def &(other)
-      ArelExtensions::Nodes::FindInSet.new [
-        Arel.quoted(other.is_a?(Integer) ? other.to_s : other),
-        self
-      ]
+      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
-      deprecated "Use `byte_size` or `char_length` instead. `length` relies on the vendor's `LEN/LENGTH` implementation and it's not portable"
-      ArelExtensions::Nodes::Length.new self, true
-    end
-
-    def byte_length
-      deprecated "Use `byte_size` instead. `byte_length` relies on the vendor's `LEN/LENGTH` implementation and it's not portable"
-      ArelExtensions::Nodes::Length.new self, true
-    end
-
-    def byte_size
-      ArelExtensions::Nodes::ByteSize.new self
-    end
-
-    def char_length
-      ArelExtensions::Nodes::CharLength.new self
+      ArelExtensions::Nodes::Length.new [self]
     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.
-    def locate(val)
+    #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
 
-    def substring(start, len = nil)
+    def substring start, len = nil
       ArelExtensions::Nodes::Substring.new [self, start, len]
     end
 
-    # Return a [ArelExtensions::Nodes::Substring] if `start` is a [Range] or an
-    # [Integer].
-    #
-    # Return the result to `self.send(start)` if it's a [String|Symbol]. The
-    # assumption is that you're trying to reach an [Arel::Table]'s
-    # [Arel::Attribute].
-    #
-    # @note `ind` should be an [Integer|NilClass] if `start` is an [Integer].
-    #   It's ignored in all other cases.
-    def [](start, end_ = nil)
-      if start.is_a?(String) || start.is_a?(Symbol)
-        send(start)
-      elsif start.is_a?(Range)
-        ArelExtensions::Nodes::Substring.new [self, start]
-      elsif start.is_a?(Integer) && !end_
-        ArelExtensions::Nodes::Substring.new [self, start + 1, 1]
-      elsif start.is_a?(Integer)
-        start += 1
-        ArelExtensions::Nodes::Substring.new [self, start, end_ - start + 1]
+    def [](start, ind = nil)
+      start += 1 if start.is_a?(Integer)
+      if start.is_a?(Range)
+        ArelExtensions::Nodes::Substring.new [self, start.begin + 1, start.end - start.begin + 1]
+      elsif start.is_a?(Integer) && !ind
+        ArelExtensions::Nodes::Substring.new [self, start, 1]
       else
-        raise ArgumentError, 'unrecognized argument types; can accept integers, ranges, or strings.'
+        ArelExtensions::Nodes::Substring.new [self, start, ind - start + 1]
       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
 
-    def imatches(others, escape = nil)
+    def imatches others, escape = nil
       ArelExtensions::Nodes::IMatches.new self, others, escape
     end
 
-    def imatches_any(others, escape = nil)
+    def imatches_any others, escape = nil
       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)
+    def imatches_all others, escape = nil
       grouping_all :imatches, others, escape, escape
     end
 
-    def idoes_not_match(others, escape = nil)
+    def idoes_not_match others, escape = nil
       ArelExtensions::Nodes::IDoesNotMatch.new self, others, escape
     end
 
-    def idoes_not_match_any(others, escape = nil)
+    def idoes_not_match_any others, escape = nil
       grouping_any :idoes_not_match, others, escape
     end
 
-    def idoes_not_match_all(others, escape = nil)
+    def idoes_not_match_all others, escape = nil
       grouping_all :idoes_not_match, others, escape
     end
 
-    def ai_matches(other) # accent insensitive & case sensitive
-      ArelExtensions::Nodes::AiMatches.new(self, other)
+    def ai_matches other # accent insensitive & case sensitive
+      ArelExtensions::Nodes::AiMatches.new(self,other)
     end
 
-    def ai_imatches(other) # accent insensitive & case insensitive
-      ArelExtensions::Nodes::AiIMatches.new(self, other)
+    def ai_imatches other # accent insensitive & case insensitive
+      ArelExtensions::Nodes::AiIMatches.new(self,other)
     end
 
-    def smatches(other) # accent sensitive & case sensitive
-      ArelExtensions::Nodes::SMatches.new(self, other)
+    def smatches other # accent sensitive & case sensitive
+      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)
+      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)
+    def collate ai=false,ci=false, option=nil
+      ArelExtensions::Nodes::Collate.new(self,option,ai,ci)
     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
-    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)
+    
+    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?
-        deprecated 'Use the kwarg `order` instead.', what: 'orders'
-      end
-      order_tabs = [orders].flatten.map { |o|
+    #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
-    def trim(other = ' ')
+    #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
 
-    def ltrim(other = ' ')
+    def ltrim other = ' '
       ArelExtensions::Nodes::Ltrim.new [self, other]
     end
 
-    def rtrim(other = ' ')
+    def rtrim other = ' '
       ArelExtensions::Nodes::Rtrim.new [self, other]
     end
 
@@ -209,17 +155,16 @@ 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)
+    
+    def levenshtein_distance other
       ArelExtensions::Nodes::LevenshteinDistance.new [self, other]
     end
 
-    def edit_distance(other)
+    def edit_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,5 +1,3 @@
-# frozen_string_literal: true
-
 module ArelExtensions
-  VERSION = '1.7.0'
+  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
-      def visit_ArelExtensions_Nodes_Ceil(o, collector)
-        collector << 'CEILING('
+    Arel::Visitors::IBM_DB.class_eval do
+
+      def visit_ArelExtensions_Nodes_Ceil o, collector
+        collector << "CEILING("
         collector = visit o.expr, collector
-        collector << ')'
+        collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Trim(o, collector)
-        collector << 'LTRIM(RTRIM('
+      def visit_ArelExtensions_Nodes_Trim o, collector
+        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('
+
+      def visit_ArelExtensions_Nodes_DateDiff o, collector
+        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('
+
+      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("
         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('
+
+      def visit_ArelExtensions_Nodes_IsNull o, collector
+        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