arel_extensions 1.0.8 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 609562660b01b52ccd184d516350279bd561e0a6
-  data.tar.gz: 8d27e16f757f07669329be3c7cf517fd97c3d29b
+  metadata.gz: b42393f60593054c04105afad4f4500dc826cd93
+  data.tar.gz: 383b4bc32619fe292c7f7ba31f867f1f49c8da80
 SHA512:
-  metadata.gz: 321e17886db0f209b2d0fe76d9d46c5999285a1f751738457c4ce10a63c3a040dc069d02166f8d6355cba2113832a9545b5a0384c9d62a55194a5307e3d3ce9f
-  data.tar.gz: e856b02e9d6ba606ad727780fc8d50cdc6af8fb33655647379ab9595d1f2997ef52aff6c5cd5c3c567f51015ea6753cfca2818344938532bb4ca8275947ec64f
+  metadata.gz: 7a724f2bd5c6d6ecedf567d44cc5d9be29f4270043b9d816b0090e19fce6380af13af3e5d4930f5252add2b4542d58ff7f6a21c202e1a5001665c7aa10b9aee3
+  data.tar.gz: 29f68d3d37bee531b23098ccace43491c42d781f719c451d1a7bbbaa4c0067b54abbf356940be7f955ad72984a07132e59e1bc4b8cea0f061e0abeb7099c416b

data/.travis.yml

@@ -12,7 +12,7 @@ before_install:
   - sudo apt-get install -y sqlite3-pcre curl
   - .travis/sqlite3/extension-functions.sh
   - .travis/oracle/download.sh
-  - .travis/oracle/install.sh
+  - sh -ex .travis/oracle/install.sh
   - .travis/setup_accounts.sh
 install:
   - gem install bundler

data/README.md

@@ -72,6 +72,11 @@ With Arel Extensions:
 ```
 
 Other functions : ABS, RAND, ROUND, FLOOR, CEIL, FORMAT
+Exemples :
+```ruby 
+t[:price].format_number("%07.2f €","fr_FR")
+# equivalent to 'sprintf("%07.2f €",price)' plus locale management 
+```
 
 ## String operations
 

data/lib/arel_extensions.rb

@@ -12,6 +12,10 @@ Arel::Nodes::Binary.class_eval do
   include Arel::Expressions
 end
 
+Arel::Nodes::Casted.class_eval do
+  include Arel::AliasPredication
+end
+
 Arel::Nodes::Unary.class_eval do
   include Arel::Math
   include Arel::AliasPredication
@@ -21,6 +25,7 @@ end
 Arel::Nodes::Grouping.class_eval do
   include Arel::Math
   include Arel::AliasPredication
+  include Arel::OrderPredications
   include Arel::Expressions
 end
 
@@ -67,6 +72,10 @@ module Arel
   def self.rand
     ArelExtensions::Nodes::Rand.new
   end
+  
+  def self.shorten s
+	Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
+  end  
 end
 
 Arel::Attributes::Attribute.class_eval do

data/lib/arel_extensions/math.rb

@@ -15,51 +15,59 @@ module ArelExtensions
     #String and others (convert in string)  allows you to concatenate 2 or more strings together.
     #Date and integer adds or subtracts a specified time interval from a date.
     def +(other)
-	  return ArelExtensions::Nodes::Concat.new [self, other] if self.is_a?(Arel::Nodes::Quoted)	  
-	  if self.is_a?(Arel::Nodes::Grouping)
+	  case self
+	  when Arel::Nodes::Quoted
+		return self.concat(other)  
+	  when Arel::Nodes::Grouping
 		if self.expr.left.is_a?(String) || self.expr.right.is_a?(String) 
-		  return ArelExtensions::Nodes::Concat.new [self, other]
+		  return self.concat(other)
 		else		
 		  return Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
 		end
-	  end	  
-	  if self.is_a?(ArelExtensions::Nodes::Function)		  
+	  when ArelExtensions::Nodes::Function
 		  return case self.return_type
 		  when :string, :text			
-			ArelExtensions::Nodes::Concat.new [self, other]
+			self.concat(other)
 		  when :integer, :decimal, :float, :number, :int
 			Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
 		  when :date, :datetime
 			ArelExtensions::Nodes::DateAdd.new [self, other]
 		  else
-			ArelExtensions::Nodes::Concat.new [self, other]
+			self.concat(other)
 		  end 
-	  end
-	  if self.is_a?(Arel::Nodes::Function)
+	  when Arel::Nodes::Function
 		return Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
-	  end
-	  col = Arel::Table.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s]
-	  if (!col) #if the column doesn't exist in the database
-		Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new(self, other))
 	  else
-		arg = col.type
-		if arg == :integer || (!arg)
-		  other = other.to_i if other.is_a?(String)
-		  Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
-		elsif arg == :decimal || arg == :float
-		  other = Arel.sql(other) if other.is_a?(String) # Arel should accept Float & BigDecimal!
-		  Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
-		elsif arg == :datetime || arg == :date
-		  ArelExtensions::Nodes::DateAdd.new [self, other]
-		elsif arg == :string || arg == :text
-		  ArelExtensions::Nodes::Concat.new [self, other]
-		end        
+		  col = Arel::Table.engine.connection.schema_cache.columns_hash(self.relation.table_name)[self.name.to_s]
+		  if (!col) #if the column doesn't exist in the database
+			Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new(self, other))
+		  else
+			arg = col.type
+			if arg == :integer || (!arg)
+			  other = other.to_i if other.is_a?(String)
+			  Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+			elsif arg == :decimal || arg == :float
+			  other = Arel.sql(other) if other.is_a?(String) # Arel should accept Float & BigDecimal!
+			  Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new self, other)
+			elsif arg == :datetime || arg == :date
+			  ArelExtensions::Nodes::DateAdd.new [self, other]
+			elsif arg == :string || arg == :text
+			  self.concat(other)
+			end  
+		  end
 	  end
     end
 
     #function returns the time between two dates
     #function returns the substraction between two ints
     def -(other)
+	  if self.is_a?(Arel::Nodes::Grouping)
+		if self.expr.left.is_a?(Date) || self.expr.left.is_a?(DateTime) 
+		  return Arel::Nodes::Grouping.new(ArelExtensions::Nodes::DateSub.new [self, other])
+		else		
+		  return Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+		end
+	  end
 	  return case self.return_type
 	  when :string, :text # ???
 		Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other)) # ??

data/lib/arel_extensions/math_functions.rb

@@ -59,7 +59,7 @@ module ArelExtensions
     # function returning a number at a specific 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
+			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],
@@ -73,7 +73,7 @@ module ArelExtensions
 			}
 			# opts = {:locale => 'fr_FR', :type => "e"/"f"/"d", :prefix => "$ ", :suffix => " %", :flags => " +-#0", :width => 5, :precision => 6}
 			ArelExtensions::Nodes::FormattedNumber.new [self,opts]
-		rescue
+		rescue Exception => e
 			Arel::Nodes.build_quoted('Wrong Format')
 		end
 	end	

data/lib/arel_extensions/nodes/case.rb

@@ -3,6 +3,7 @@ module ArelExtensions
 		if Arel::VERSION.to_i < 7 
 			class Case < Arel::Nodes::Node
 				include Arel::Expressions
+				include Arel::OrderPredications
 				include ArelExtensions::Comparators
 				include ArelExtensions::Predications
 

data/lib/arel_extensions/nodes/concat.rb

@@ -1,40 +1,53 @@
-module ArelExtensions
-  module Nodes
-    class Concat < Function
-      RETURN_TYPE = :string
-      
-      def initialize expr
-        tab = expr.map { |arg|
-          convert_to_node(arg)
-        }
-        return super(tab)
-      end
-
-      #def +(other)
-      #  return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
-      #end
-      
-      def concat(other)
-        return ArelExtensions::Nodes::Concat.new(self.expressions + [other]) 
-      end
+module ArelExtensions::Nodes
+  class Concat < Function
+    RETURN_TYPE = :string
 
+    def initialize expr
+      tab = expr.map { |arg|
+        # flatten nested concats.
+        node = convert_to_node(arg)
+        if node.is_a?(Concat)
+          node.expressions
+        else
+          node
+        end
+      }.flatten.reduce([]) { | res, b |
+        # concatenate successive literal strings.
+        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::Nodes.build_quoted(res.last.expr + b.expr)
+        else
+          res << b
+        end
+        res
+      }
+      super(tab)
     end
 
-    class GroupConcat < Function
-      RETURN_TYPE = :string
+    #def +(other)
+    #  Concat.new(self.expressions + [other])
+    #end
 
-      def initialize expr
-        tab = expr.map { |arg|
-          convert_to_node(arg)
-        }
-        return super(tab)
-      end
+    def concat(other)
+      Concat.new(self.expressions + [other])
+    end
+
+  end
 
-      #def +(other)
-      #  return ArelExtensions::Nodes::Concat.new([self, other]) 
-      #end
+  class GroupConcat < Function
+    RETURN_TYPE = :string
 
+    def initialize expr
+      tab = expr.map { |arg|
+        convert_to_node(arg)
+      }
+      super(tab)
     end
 
+    #def +(other)
+    #  return Concat.new([self, other])
+    #end
+
   end
 end

data/lib/arel_extensions/nodes/function.rb

@@ -4,7 +4,8 @@ module ArelExtensions
   module Nodes
     class Function < Arel::Nodes::Function    
       include Arel::Math
-      include Arel::Expressions
+      include Arel::Expressions      
+      include Arel::OrderPredications
 	  include ArelExtensions::Predications	
 	  
 	  RETURN_TYPE = :string # by default...

data/lib/arel_extensions/string_functions.rb

@@ -108,7 +108,12 @@ module ArelExtensions
     end
     
     def concat other
-      ArelExtensions::Nodes::Concat.new [self, other]
+      res = ArelExtensions::Nodes::Concat.new [self, other]
+      if res.expressions.length == 1
+		res.expressions.first
+	  else
+		res
+      end
     end
 
     def group_concat sep = nil

data/lib/arel_extensions/version.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = "1.0.8".freeze
+  VERSION = "1.1.0".freeze
 end

data/lib/arel_extensions/visitors/mssql.rb

@@ -65,29 +65,6 @@ module ArelExtensions
         collector
 	  end
 
-      # Deprecated
-      def visit_ArelExtensions_Nodes_ConcatOld o, collector
-        arg = o.left.relation.engine.columns.find{|c| c.name == o.left.name.to_s}.type
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.left, collector
-          collector << ' + '
-          collector = visit o.right, collector
-          collector
-        elsif ( arg == :date || arg == :datetime)
-          collector << "DATEADD(day"
-          collector << Arel::Visitors::MSSQL::COMMA
-          collector = visit o.right, collector
-          collector << Arel::Visitors::MSSQL::COMMA
-          collector = visit o.left, collector
-          collector
-        else
-          collector = visit o.left, collector
-          collector << " + '"
-          collector = visit o.right, collector
-          collector
-        end
-      end
-
       def visit_ArelExtensions_Nodes_Concat o, collector
         collector << "CONCAT("
         o.expressions.each_with_index { |arg, i|

data/lib/arel_extensions/visitors/oracle.rb

@@ -394,21 +394,10 @@ module ArelExtensions
       # add primary_key if not present, avoid zip
     if Arel::VERSION.to_i < 7
       def visit_ArelExtensions_InsertManager_BulkValues o, collector
-        raise ArgumentError, "missing columns" if o.cols.empty?
-        table = collector.value.sub(/\AINSERT INTO/, '')
-        into = " INTO#{table}"
-        collector = Arel::Collectors::SQLString.new
-        collector << "INSERT ALL\n"
-        pk_name = @connection.primary_key(o.cols.first.relation.name)
-        if pk_name
-          pk_missing = !o.cols.detect{|c| c.name == pk_name }
-          into.sub!(/\(/, %Q[("#{pk_name.upcase}", ]) if pk_missing
-        else
-          pk_missing = false
-        end
+		collector << "("
         o.left.each_with_index do |row, idx| # values
-          collector << "#{into} VALUES ("
-          collector << "NULL, " if pk_missing # expects to have a trigger to set the value before insert
+		  collector << " UNION ALL " if idx != 0
+          collector << "(SELECT "
           v = Arel::Nodes::Values.new(row, o.cols)
           len = v.expressions.length - 1
           v.expressions.each_with_index { |value, i|
@@ -421,19 +410,17 @@ module ArelExtensions
               end
               collector << Arel::Visitors::Oracle::COMMA unless i == len
           }
-          collector << ')'
+          collector << ' FROM DUAL)'
         end
-        collector << ' SELECT 1 FROM dual'
+        collector << ")"
         collector
       end
     else
       def visit_ArelExtensions_InsertManager_BulkValues o, collector
-        table = collector.value.sub(/\AINSERT INTO/, '')
-        into = " INTO#{table}"
-        collector = Arel::Collectors::SQLString.new
-        collector << "INSERT ALL\n"
+		collector << "("
         o.left.each_with_index do |row, idx|
-          collector << "#{into} VALUES ("
+		  collector << " UNION ALL " if idx != 0
+          collector << "(SELECT "
           v = Arel::Nodes::Values.new(row, o.cols)
           len = v.expressions.length - 1
           v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
@@ -445,9 +432,9 @@ module ArelExtensions
               end
               collector << Arel::Visitors::Oracle::COMMA unless i == len
           }
-          collector << ')'
+          collector << ' FROM DUAL)'
         end
-        collector << ' SELECT 1 FROM dual'
+        collector << ")"
         collector
       end
     end
@@ -455,18 +442,17 @@ module ArelExtensions
 
 	def get_time_converted element
 		if element.is_a?(Time)
-			res = ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
+			ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
 		elsif element.is_a?(Arel::Attributes::Attribute)
 			col = Arel::Table.engine.connection.schema_cache.columns_hash(element.relation.table_name)[element.name.to_s]
 			if col && (col.type == :time)
-				res = ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
+				ArelExtensions::Nodes::Format.new [element, '%H:%M:%S']
 			else
-				res = element
+				element
 			end
 		else
-			res = element
+			element
 		end
-		return res
 	end
 	
 	
@@ -511,10 +497,30 @@ module ArelExtensions
 		end
 		old_visit_Arel_Nodes_SelectStatement(o,collector)
 	end	
+	
+	alias_method :old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias  
+	def visit_Arel_Nodes_TableAlias o, collector
+		if o.name.length > 30
+			o = Arel::Table.new(o.table_name).alias(Base64.urlsafe_encode64(Digest::MD5.new.digest(o.name)).tr('=', '').tr('-', '_'))
+		end
+		old_visit_Arel_Nodes_TableAlias(o,collector)		
+	end
+	
+	
+	alias_method :old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute  
+	def visit_Arel_Attributes_Attribute o, collector			
+		join_name = o.relation.table_alias || o.relation.name
+		if join_name.length > 30
+			join_name = Arel.shorten(join_name)
+		end
+		collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
+	end
+	
 
 	def visit_ArelExtensions_Nodes_FormattedNumber o, collector		
 		col = o.left
-		comma = Arel::Visitors::Oracle::NUMBER_COMMA_MAPPING[o.locale] || '.,'	
+		comma = Arel::Visitors::Oracle::NUMBER_COMMA_MAPPING[o.locale] || '.,'
+		comma_in_format = o.precision == 0 ? '' : 'D'
 		options = Arel::Nodes.build_quoted("NLS_NUMERIC_CHARACTERS = '"+comma+"'")		
 		nines_after = (1..o.precision).map{'9'}.join('')
 		nines_before = (1..16).map{'9'}.join('')
@@ -528,7 +534,7 @@ module ArelExtensions
 		if o.scientific_notation 
 			number = Arel::Nodes::NamedFunction.new('TO_CHAR',[
 						Arel::Nodes.build_quoted(col.abs),
-						Arel::Nodes.build_quoted('FM'+nines_before+'D'+nines_after+'EEEE'),
+						Arel::Nodes.build_quoted('FM'+nines_before+comma_in_format+nines_after+'EEEE'),
 						options								
 					])	
 			if o.type == 'e'
@@ -537,7 +543,7 @@ module ArelExtensions
 		else			
 			number = Arel::Nodes::NamedFunction.new('TO_CHAR',[
 						Arel::Nodes.build_quoted(col.abs),
-						Arel::Nodes.build_quoted('FM'+nines_before+'D'+nines_after),
+						Arel::Nodes.build_quoted('FM'+nines_before+comma_in_format+nines_after),
 						options
 					])				
 		end
@@ -566,6 +572,8 @@ module ArelExtensions
 	end
 
 
+
+
     end
   end
 end

data/lib/arel_extensions/visitors/postgresql.rb

@@ -279,9 +279,9 @@ module ArelExtensions
         collector
 	  end
 
-	  def visit_ArelExtensions_Nodes_FormattedNumber o, collector		
+	  def visit_ArelExtensions_Nodes_FormattedNumber o, collector	
 			col = o.left
-			comma = Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale] || '.'			
+			comma = o.precision == 0 ? '' : (Arel::Visitors::PostgreSQL::NUMBER_COMMA_MAPPING[o.locale] || '.')			
 			nines_after = (1..o.precision).map{'9'}.join('')
 			nines_before = (1..16).map{'9'}.join('')
 			sign = ArelExtensions::Nodes::Case.new.when(col<0).
@@ -327,8 +327,8 @@ module ArelExtensions
 					after
 				])
 			)				
-			collector = visit ArelExtensions::Nodes::Concat.new([Arel::Nodes.build_quoted(o.prefix),full_number,Arel::Nodes.build_quoted(o.suffix)]), collector		
-			collector		
+			collector = visit ArelExtensions::Nodes::Concat.new([Arel::Nodes.build_quoted(o.prefix),full_number,Arel::Nodes.build_quoted(o.suffix)]), collector
+			collector
 	  end
 
 
@@ -341,6 +341,24 @@ module ArelExtensions
 			old_visit_Arel_Nodes_SelectStatement(o,collector)
 		end	
 
+		alias_method :old_visit_Arel_Nodes_TableAlias, :visit_Arel_Nodes_TableAlias  
+		def visit_Arel_Nodes_TableAlias o, collector
+			if o.name.length > 63
+				o = Arel::Table.new(o.table_name).alias(Arel.shorten(o.name))
+			end
+			old_visit_Arel_Nodes_TableAlias(o,collector)		
+		end
+
+		alias_method :old_visit_Arel_Attributes_Attribute, :visit_Arel_Attributes_Attribute  
+		def visit_Arel_Attributes_Attribute o, collector			
+			join_name = o.relation.table_alias || o.relation.name
+			if join_name.length > 63
+				join_name = Arel.shorten(join_name)
+			end
+			collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
+		end
+
+
     end
   end
 end

data/test/visitors/test_bulk_insert_oracle.rb

@@ -7,10 +7,10 @@ module ArelExtensions
         @conn = FakeRecord::Base.new
         @visitor = Arel::Visitors::Oracle.new @conn.connection
         @table = Arel::Table.new(:users)
-        @cols = ['id', 'name', 'comments', 'created_at']
+        @cols = ['name', 'comments', 'created_at']
         @data = [
-        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
-        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+        	['nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	['nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
 
@@ -26,9 +26,9 @@ module ArelExtensions
         insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
       	insert_manager.bulk_insert(@cols, @data)
       	sql = compile(insert_manager.ast)
-      	sql.must_be_like %Q[INSERT ALL INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01') INTO "users" ("id", "name", "comments", "created_at") VALUES (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01') SELECT 1 FROM dual]
+      	sql.must_be_like %Q[INSERT INTO "users" ("name", "comments", "created_at") ((SELECT 'nom1', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL) UNION ALL (SELECT 'nom2', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL))]
       end
 
 	  end
   end
-end
+end

data/test/visitors/test_to_sql.rb

@@ -63,7 +63,6 @@ module ArelExtensions
       it "should accept functions on strings" do
         c = @table[:name]
         compile(c + 'test').must_be_like %{CONCAT(\"users\".\"name\", 'test')}
-        compile(c + 'test' + ' chain').must_be_like %{CONCAT(CONCAT(\"users\".\"name\", 'test'), ' chain')}
         compile(c.length).must_be_like %{LENGTH("users"."name")}
         #puts (c.length.round + 42).inspect
         compile(c.length.round + 42).must_be_like %{(ROUND(LENGTH("users"."name")) + 42)}
@@ -82,6 +81,13 @@ module ArelExtensions
         compile(c + '0').must_be_like %{CONCAT("users"."name", '0')}
         compile(c.substring(1) + '0').must_be_like %{CONCAT(SUBSTRING("users"."name", 1), '0')}
         compile(c.substring(1) + c.substring(2)).must_be_like %{CONCAT(SUBSTRING("users"."name", 1), SUBSTRING("users"."name", 2))}
+        compile(c.concat(c).concat(c)).must_be_like %{CONCAT("users"."name", "users"."name", "users"."name")}
+        compile(c + c + c).must_be_like %{CONCAT("users"."name", "users"."name", "users"."name")}
+        
+        # some optimization on concat
+        compile(c + 'test' + ' chain').must_be_like %{CONCAT(\"users\".\"name\", 'test chain')}
+        compile(Arel::Nodes.build_quoted('test') + ' chain').must_be_like %{'test chain'}        
+        compile(c + '' + c).must_be_like %{CONCAT(\"users\".\"name\", \"users\".\"name\")}
       end
 
       # Comparators
@@ -302,7 +308,7 @@ module ArelExtensions
 			.must_be_like %{(CAST("users"."id" AS int) + 2)}
 	  end
 	  	  
-	  it "should be possible to to have nil element in the function NIL" do	 
+	  it "should be possible to have nil element in the function NIL" do	 
 		compile(@table[:id].in(nil))
 			.must_be_like %{ISNULL("users"."id")}			
 		compile(@table[:id].in([nil]))
@@ -319,6 +325,30 @@ module ArelExtensions
 			.must_be_like %{"users"."id" IN (1, 2)}
 	  
 	  end
+	  
+	  it "should be possible to add and substract as much as we want" do
+		c = @table[:name]
+		compile(c.locate('test')+1)
+			.must_be_like %{(LOCATE('test', "users"."name") + 1)}
+		compile(c.locate('test')-1)
+			.must_be_like %{(LOCATE('test', "users"."name") - 1)}
+		compile(c.locate('test')+c.locate('test'))
+			.must_be_like %{(LOCATE('test', "users"."name") + LOCATE('test', "users"."name"))}
+		compile(c.locate('test')+1+c.locate('test')-1 + 1)
+			.must_be_like %{((((LOCATE('test', "users"."name") + 1) + LOCATE('test', "users"."name")) - 1) + 1)}
+	  end
+	  
+	  it "should be possible to desc and asc on functions" do
+		c = @table[:name]
+		compile(c.asc)
+			.must_be_like %{"users"."name" ASC}
+		compile(c.substring(2).asc)
+			.must_be_like %{SUBSTRING("users"."name", 2) ASC}			
+		compile(c.substring(2).desc)
+			.must_be_like %{SUBSTRING("users"."name", 2) DESC}
+		compile((c.locate('test')+1).asc)
+			.must_be_like %{(LOCATE('test', "users"."name") + 1) ASC}
+	  end
 	 	  
 	  puts "AREL VERSION : " + Arel::VERSION.to_s
     end

data/test/with_ar/all_agnostic_test.rb

@@ -507,9 +507,12 @@ module ArelExtensions
 	  def test_format_numbers 
 		#score of Arthur = 65.62
 		skip " Works with SQLite if the version used knows printf" if @env_db = $sqlite
+			
+		assert_equal "Wrong Format" , t(@arthur, @score.format_number("$ %...234.6F €","fr_FR"))
 		assert_equal "AZERTY65,62" , t(@arthur, @score.format_number("AZERTY%.2f","fr_FR"))
 		assert_equal "65,62AZERTY" , t(@arthur, @score.format_number("%.2fAZERTY","fr_FR"))
 		assert_equal "$ 65.62 €" , t(@arthur, @score.format_number("$ %.2f €","en_US"))
+		assert_equal "$ 66 €" , t(@arthur, @score.format_number("$ %.0f €","en_US"))
 		assert_equal "$ 0065,62 €" , t(@arthur, @score.format_number("$ %07.2f €","fr_FR"))
 		assert_equal "$ 65,62   €" , t(@arthur, @score.format_number("$ %-07.2f €","fr_FR"))
 		assert_equal "$ 65,62   €" , t(@arthur, @score.format_number("$ %-7.2f €","fr_FR"))
@@ -519,8 +522,7 @@ module ArelExtensions
 		assert_equal "$ +065,62 €" , t(@arthur, @score.format_number("$ %0+7.2f €","fr_FR"))
 		assert_includes ["$ 6,56e1 €","$ 6,56e+01 €"], t(@arthur, @score.format_number("$ %.2e €","fr_FR"))			
 		assert_includes ["$ 6,56E1 €","$ 6,56E+01 €"], t(@arthur, @score.format_number("$ %.2E €","fr_FR"))			
-		assert_includes ["$ 6,562E1 €","$ 6,562E+01 €"], t(@arthur, @score.format_number("$ %.3E €","fr_FR"))	
-		assert_equal "Wrong Format" , t(@arthur, @score.format_number("$ %...234.6F €","fr_FR"))
+		assert_includes ["$ 6,562E1 €","$ 6,562E+01 €"], t(@arthur, @score.format_number("$ %.3E €","fr_FR"))
 	  end
 	  
 	  def test_accent_insensitive
@@ -563,6 +565,7 @@ module ArelExtensions
 		assert_equal "0", t(@arthur,ArelExtensions::Nodes::Case.new.when(@comments.smatches("arretez")).then("1").else("0"))		  
 		assert_equal "0", t(@arthur,ArelExtensions::Nodes::Case.new.when(@comments.smatches("Arrete")).then("1").else("0"))
 		assert_equal "0", t(@arthur,ArelExtensions::Nodes::Case.new.when(@comments.smatches("Arrêté")).then("1").else("0"))  
+		 	
 	  end
 	  
 	  def test_subquery_with_order	  
@@ -633,6 +636,17 @@ module ArelExtensions
 		#assert_equal true  , @test.where(@age.not_in([nil,1,2])).blank?
 	  end
 	 
+	  def test_alias_shortened
+		if ['postgresql','oracle'].include?(@env_db)
+			new_alias = Arel.shorten('azerty' * 15)
+			at = User.arel_table.alias('azerty' * 15)
+			assert_equal "\"user_tests\" \"#{new_alias}\"".downcase, User.arel_table.alias('azerty' * 15).to_sql.downcase
+			assert_equal '"user_tests" "u"'.downcase, User.arel_table.alias('u').to_sql.downcase
+			assert_equal  %Q[SELECT "#{new_alias}"."id" FROM "user_tests" "#{new_alias}"].downcase,
+						User.select(at[:id]).from(at).to_sql.downcase
+		end
+	  end
+	 
     end
   end
 end

data/test/with_ar/insert_agnostic_test.rb

@@ -81,4 +81,4 @@ END;])
 
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arel_extensions
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.1.0
 platform: ruby
 authors:
 - Yann Azoury
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-21 00:00:00.000000000 Z
+date: 2018-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arel
@@ -208,26 +208,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Extending Arel
-test_files:
-- test/database.yml
-- test/helper.rb
-- test/real_db_test.rb
-- test/support/alter_system_user_password.sql
-- test/support/create_oracle_enhanced_users.sql
-- test/support/fake_record.rb
-- test/test_comparators.rb
-- test/visitors/test_bulk_insert_oracle.rb
-- test/visitors/test_bulk_insert_sqlite.rb
-- test/visitors/test_bulk_insert_to_sql.rb
-- test/visitors/test_oracle.rb
-- test/visitors/test_to_sql.rb
-- test/with_ar/all_agnostic_test.rb
-- test/with_ar/insert_agnostic_test.rb
-- test/with_ar/test_bulk_sqlite.rb
-- test/with_ar/test_math_sqlite.rb
-- test/with_ar/test_string_mysql.rb
-- test/with_ar/test_string_sqlite.rb
+test_files: []