arel 7.0.0 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7b8575f1877fe831a05c70632e7046c6ce384c9
-  data.tar.gz: ab4c6895e273c5ad2bd6456bdf2f0fd1b3f7e0a2
+  metadata.gz: dc3719172683caa3fb2bd15ce6ef3ed477a8b2ef
+  data.tar.gz: 74b4f1d7d44871db56c62907ed1c4ba51040bf6e
 SHA512:
-  metadata.gz: 71feebe60212b48f1bce1fe0acc756728aff663f7e84836bc5888ed237bc6315b22d95993d9b9fce655dbccbf35c75652e9fd62c185d141c0c246084e3d70e68
-  data.tar.gz: 563e00ae3191b5d4be40b8ead9168ead202242593a9761a2a5e938454b13c3094542d83b2e3ca5706c572ca2d1551772a9bce80631e55be9aa3379435bfecb75
+  metadata.gz: bedb8b1701ee99fca067c4a52f92d096648d25d67d4809408ede3eeb40298b3fc83a9fdccf1f4195c32f871ee430eba29f11dedd19b12032639a8b03bc7ec54c
+  data.tar.gz: 97a3b3155db8b0c57ca4616598d45d8aad7592c56a6882e0e7f5369eeac221802cae5cd60b4d72a92d755eb13be4b39aedc9ea967e1c6faac28953a3414d1f39

data/History.txt

@@ -1,3 +1,30 @@
+=== 9.0.0 / 2017-11-14
+
+* Enhancements
+  * `InsertManager#insert` is now chainable
+  * Support multiple inserts
+
+=== 8.0.0 / 2017-02-21
+
+* Enhancements
+
+  * Remove deprecated type casting support in Arel
+  * Frozen all string literals in Arel
+
+=== 7.1.1 / 2016-07-27
+
+* Bug Fixes
+
+  * Fix warning in `Casted#hash`
+
+=== 7.1.0 / 2016-07-19
+
+* Enhancements
+
+  * Support Ruby 2.4 unified Integer class
+  * Implement `CASE` conditional expression
+  * Support for Bitwise Operations as `InfixOperations`
+
 === 7.0.0 / 2015-12-17
 
 * Enhancements

data/MIT-LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2007-2015 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
+Copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.markdown → README.md}

@@ -1,6 +1,7 @@
 # Arel
 
 * http://github.com/rails/arel
+* [API Documentation](http://www.rubydoc.info/github/rails/arel)
 
 ## DESCRIPTION
 
@@ -8,8 +9,8 @@ Arel Really Exasperates Logicians
 
 Arel is a SQL AST manager for Ruby. It
 
-1. Simplifies the generation of complex SQL queries
-2. Adapts to various RDBMSes
+1. simplifies the generation of complex SQL queries, and
+2. adapts to various RDBMSes.
 
 It is intended to be a framework framework; that is, you can build your own ORM
 with it, focusing on innovative object and collection modeling as opposed to
@@ -17,7 +18,7 @@ database compatibility and query generation.
 
 ## Status
 
-For the moment, Arel uses Active Record's connection adapters to connect to the various engines, connection pooling, perform quoting, and do type conversion.
+For the moment, Arel uses Active Record's connection adapters to connect to the various engines and perform connection pooling, quoting, and type conversion.
 
 ## A Gentle Introduction
 
@@ -27,7 +28,7 @@ Generating a query with Arel is simple. For example, in order to produce
 SELECT * FROM users
 ```
 
-you construct a table relation and convert it to sql:
+you construct a table relation and convert it to SQL:
 
 ```ruby
 users = Arel::Table.new(:users)
@@ -56,13 +57,48 @@ users.project(users[:id])
 Comparison operators `=`, `!=`, `<`, `>`, `<=`, `>=`, `IN`:
 
 ```ruby
-users.where(users[:age].eq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" = 10
-users.where(users[:age].not_eq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" != 10
-users.where(users[:age].lt(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" < 10
-users.where(users[:age].gt(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" > 10
-users.where(users[:age].lteq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" <= 10
-users.where(users[:age].gteq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" >= 10
-users.where(users[:age].in([20, 16, 17])).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" IN (20, 16, 17)
+users.where(users[:age].eq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" = 10
+
+users.where(users[:age].not_eq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" != 10
+
+users.where(users[:age].lt(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" < 10
+
+users.where(users[:age].gt(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" > 10
+
+users.where(users[:age].lteq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" <= 10
+
+users.where(users[:age].gteq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" >= 10
+
+users.where(users[:age].in([20, 16, 17])).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" IN (20, 16, 17)
+```
+
+Bitwise operators `&`, `|`, `^`, `<<`, `>>`:
+
+```ruby
+users.where((users[:bitmap] & 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" & 16) > 0
+
+users.where((users[:bitmap] | 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" | 16) > 0
+
+users.where((users[:bitmap] ^ 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" ^ 16) > 0
+
+users.where((users[:bitmap] << 1).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" << 1) > 0
+
+users.where((users[:bitmap] >> 1).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" >> 1) > 0
+
+users.where((~ users[:bitmap]).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users" WHERE  ~ "users"."bitmap" > 0
 ```
 
 Joins resemble SQL strongly:
@@ -72,7 +108,7 @@ users.join(photos).on(users[:id].eq(photos[:user_id]))
 # => SELECT * FROM users INNER JOIN photos ON users.id = photos.user_id
 ```
 
-Left Joins
+Left joins:
 
 ```ruby
 users.join(photos, Arel::Nodes::OuterJoin).on(users[:id].eq(photos[:user_id]))
@@ -93,7 +129,7 @@ users.project(users[:name]).group(users[:name])
 # => SELECT users.name FROM users GROUP BY users.name
 ```
 
-The best property of arel is its "composability", or closure under all operations. For example, to restrict AND project, just "chain" the method invocations:
+The best property of Arel is its "composability," or closure under all operations. For example, to restrict AND project, just "chain" the method invocations:
 
 ```ruby
 users                                 \
@@ -114,28 +150,47 @@ The `OR` operator works like this:
 users.where(users[:name].eq('bob').or(users[:age].lt(25)))
 ```
 
-The `AND` operator behaves similarly.
+The `AND` operator behaves similarly. Here is an example of the `DISTINCT` operator:
+
+```ruby
+posts = Arel::Table.new(:posts)
+posts.project(posts[:title])
+posts.distinct
+posts.to_sql # => 'SELECT DISTINCT "posts"."title" FROM "posts"'
+```
 
 Aggregate functions `AVG`, `SUM`, `COUNT`, `MIN`, `MAX`, `HAVING`:
 
 ```ruby
-photos.group(photos[:user_id]).having(photos[:id].count.gt(5)) # => SELECT FROM photos GROUP BY photos.user_id HAVING COUNT(photos.id) > 5
-users.project(users[:age].sum) # => SELECT SUM(users.age) FROM users
-users.project(users[:age].average) # => SELECT AVG(users.age) FROM users
-users.project(users[:age].maximum) # => SELECT MAX(users.age) FROM users
-users.project(users[:age].minimum) # => SELECT MIN(users.age) FROM users
-users.project(users[:age].count) # => SELECT COUNT(users.age) FROM users
+photos.group(photos[:user_id]).having(photos[:id].count.gt(5))
+# => SELECT FROM photos GROUP BY photos.user_id HAVING COUNT(photos.id) > 5
+
+users.project(users[:age].sum)
+# => SELECT SUM(users.age) FROM users
+
+users.project(users[:age].average)
+# => SELECT AVG(users.age) FROM users
+
+users.project(users[:age].maximum)
+# => SELECT MAX(users.age) FROM users
+
+users.project(users[:age].minimum)
+# => SELECT MIN(users.age) FROM users
+
+users.project(users[:age].count)
+# => SELECT COUNT(users.age) FROM users
 ```
 
 Aliasing Aggregate Functions:
 
 ```ruby
-users.project(users[:age].average.as("mean_age")) # => SELECT AVG(users.age) AS mean_age FROM users
+users.project(users[:age].average.as("mean_age"))
+# => SELECT AVG(users.age) AS mean_age FROM users
 ```
 
-### The Crazy Features
+### The Advanced Features
 
-The examples above are fairly simple and other libraries match or come close to matching the expressiveness of Arel (e.g., `Sequel` in Ruby).
+The examples above are fairly simple and other libraries match or come close to matching the expressiveness of Arel (e.g. `Sequel` in Ruby).
 
 #### Inline math operations
 
@@ -160,6 +215,7 @@ products.
 
 #### Complex Joins
 
+##### Alias
 Where Arel really shines is in its ability to handle complex joins and aggregations. As a first example, let's consider an "adjacency list", a tree represented in a table. Suppose we have a table `comments`, representing a threaded discussion:
 
 ```ruby
@@ -179,12 +235,14 @@ Joining a table to itself requires aliasing in SQL. This aliasing can be handled
 replies = comments.alias
 comments_with_replies = \
   comments.join(replies).on(replies[:parent_id].eq(comments[:id])).where(comments[:id].eq(1))
-# => SELECT * FROM comments INNER JOIN comments AS comments_2 WHERE comments_2.parent_id = comments.id AND comments.id = 1
+# => SELECT * FROM comments INNER JOIN comments AS comments_2
+#    WHERE comments_2.parent_id = comments.id AND comments.id = 1
 ```
 
 This will return the reply for the first comment.
 
-[Common Table Expressions(CTE)](https://en.wikipedia.org/wiki/Common_table_expressions#Common_table_expression) support via:
+##### CTE
+[Common Table Expressions (CTE)](https://en.wikipedia.org/wiki/Common_table_expressions#Common_table_expression) support via:
 
 Create a `CTE`
 
@@ -201,9 +259,12 @@ users.
   project(users[:id], cte_table[:click].sum).
   with(composed_cte)
 
-# => WITH cte_table AS (SELECT FROM photos  WHERE photos.created_at > '2014-05-02') SELECT users.id, SUM(cte_table.click) FROM users INNER JOIN cte_table ON users.id = cte_table.user_id
+# => WITH cte_table AS (SELECT FROM photos  WHERE photos.created_at > '2014-05-02')
+#    SELECT users.id, SUM(cte_table.click)
+#    FROM users INNER JOIN cte_table ON users.id = cte_table.user_id
 ```
 
+#### Write SQL strings
 When your query is too complex for `Arel`, you can use `Arel::SqlLiteral`:
 
 ```ruby
@@ -214,17 +275,18 @@ photo_clicks = Arel::Nodes::SqlLiteral.new(<<-SQL
     ELSE default_calculation END
 SQL
 )
+
 photos.project(photo_clicks.as("photo_clicks"))
 # => SELECT CASE WHEN condition1 THEN calculation1
-    WHEN condition2 THEN calculation2
-    WHEN condition3 THEN calculation3
-    ELSE default_calculation END
- FROM "photos"
+#    WHEN condition2 THEN calculation2
+#    WHEN condition3 THEN calculation3
+#    ELSE default_calculation END
+#    FROM "photos"
 ```
 
 ## Contributing to Arel
 
-Arel is work of many contributors. You're encouraged to submit pull requests, propose
+Arel is the work of many contributors. You're encouraged to submit pull requests, propose
 features and discuss issues.
 
 See [CONTRIBUTING](CONTRIBUTING.md).

data/lib/arel/alias_predication.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module AliasPredication
     def as other

data/lib/arel/attributes/attribute.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Attributes
     class Attribute < Struct.new :relation, :name

data/lib/arel/attributes.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'arel/attributes/attribute'
 
 module Arel

data/lib/arel/collectors/bind.rb

@@ -1,35 +1,23 @@
+# frozen_string_literal: true
+
 module Arel
   module Collectors
     class Bind
       def initialize
-        @parts = []
+        @binds = []
       end
 
       def << str
-        @parts << str
         self
       end
 
       def add_bind bind
-        @parts << bind
+        @binds << bind
         self
       end
 
-      def value; @parts; end
-
-      def substitute_binds bvs
-        bvs = bvs.dup
-        @parts.map do |val|
-          if Arel::Nodes::BindParam === val
-            bvs.shift
-          else
-            val
-          end
-        end
-      end
-
-      def compile bvs
-        substitute_binds(bvs).join
+      def value
+        @binds
       end
     end
   end

data/lib/arel/collectors/composite.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arel
+  module Collectors
+    class Composite
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def << str
+        left << str
+        right << str
+        self
+      end
+
+      def add_bind bind, &block
+        left.add_bind bind, &block
+        right.add_bind bind, &block
+        self
+      end
+
+      def value
+        [left.value, right.value]
+      end
+
+      protected
+
+      attr_reader :left, :right
+    end
+  end
+end

data/lib/arel/collectors/plain_string.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 module Arel
   module Collectors
     class PlainString
       def initialize
-        @str = ''
+        @str = ''.dup
       end
 
       def value

data/lib/arel/collectors/sql_string.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'arel/collectors/plain_string'
 

data/lib/arel/collectors/substitute_binds.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Arel
+  module Collectors
+    class SubstituteBinds
+      def initialize(quoter, delegate_collector)
+        @quoter = quoter
+        @delegate = delegate_collector
+      end
+
+      def << str
+        delegate << str
+        self
+      end
+
+      def add_bind bind
+        self << quoter.quote(bind)
+      end
+
+      def value
+        delegate.value
+      end
+
+      protected
+
+      attr_reader :quoter, :delegate
+    end
+  end
+end

data/lib/arel/compatibility/wheres.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Compatibility # :nodoc:
     class Wheres # :nodoc:

data/lib/arel/crud.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   ###
   # FIXME hopefully we can remove this

data/lib/arel/delete_manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   class DeleteManager < Arel::TreeManager
     def initialize

data/lib/arel/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Arel
+  class ArelError < StandardError
+  end
+
+  class EmptyJoinError < ArelError
+  end
+end

data/lib/arel/expressions.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Expressions
     def count distinct = false

data/lib/arel/factory_methods.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   ###
   # Methods for creating various nodes

data/lib/arel/insert_manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   class InsertManager < Arel::TreeManager
     def initialize
@@ -33,10 +34,15 @@ module Arel
         end
         @ast.values = create_values values, @ast.columns
       end
+      self
     end
 
     def create_values values, columns
       Nodes::Values.new values, columns
     end
+
+    def create_values_list(rows)
+      Nodes::ValuesList.new(rows)
+    end
   end
 end

data/lib/arel/math.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Math
     def *(other)
@@ -15,5 +16,29 @@ module Arel
     def /(other)
       Arel::Nodes::Division.new(self, other)
     end
+
+    def &(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseAnd.new(self, other))
+    end
+
+    def |(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseOr.new(self, other))
+    end
+
+    def ^(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseXor.new(self, other))
+    end
+
+    def <<(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftLeft.new(self, other))
+    end
+
+    def >>(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftRight.new(self, other))
+    end
+
+    def ~@
+      Arel::Nodes::BitwiseNot.new(self)
+    end
   end
 end

data/lib/arel/nodes/and.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class And < Arel::Nodes::Node

data/lib/arel/nodes/ascending.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class Ascending < Ordering

data/lib/arel/nodes/binary.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class Binary < Arel::Nodes::Node

data/lib/arel/nodes/bind_param.rb

@@ -1,8 +1,26 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class BindParam < Node
-      def ==(other)
-        other.is_a?(BindParam)
+      attr_accessor :value
+
+      def initialize(value)
+        @value = value
+        super()
+      end
+
+      def hash
+        [self.class, self.value].hash
+      end
+
+      def eql?(other)
+        other.is_a?(BindParam) &&
+          value == other.value
+      end
+      alias :== :eql?
+
+      def nil?
+        value.nil?
       end
     end
   end

data/lib/arel/nodes/case.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module Arel
+  module Nodes
+    class Case < Arel::Nodes::Node
+      include Arel::OrderPredications
+      include Arel::Predications
+      include Arel::AliasPredication
+
+      attr_accessor :case, :conditions, :default
+
+      def initialize expression = nil, default = nil
+        @case = expression
+        @conditions = []
+        @default = default
+      end
+
+      def when condition, expression = nil
+        @conditions << When.new(Nodes.build_quoted(condition), expression)
+        self
+      end
+
+      def then expression
+        @conditions.last.right = Nodes.build_quoted(expression)
+        self
+      end
+
+      def else expression
+        @default = Else.new Nodes.build_quoted(expression)
+        self
+      end
+
+      def initialize_copy other
+        super
+        @case = @case.clone if @case
+        @conditions = @conditions.map { |x| x.clone }
+        @default = @default.clone if @default
+      end
+
+      def hash
+        [@case, @conditions, @default].hash
+      end
+
+      def eql? other
+        self.class == other.class &&
+          self.case == other.case &&
+          self.conditions == other.conditions &&
+          self.default == other.default
+      end
+      alias :== :eql?
+    end
+
+    class When < Binary # :nodoc:
+    end
+
+    class Else < Unary # :nodoc:
+    end
+  end
+end

data/lib/arel/nodes/casted.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class Casted < Arel::Nodes::Node # :nodoc:
@@ -10,6 +11,10 @@ module Arel
 
       def nil?; @val.nil?; end
 
+      def hash
+        [self.class, val, attribute].hash
+      end
+
       def eql? other
         self.class == other.class &&
             self.val == other.val &&
@@ -25,7 +30,7 @@ module Arel
 
     def self.build_quoted other, attribute = nil
       case other
-        when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::Nodes::BindParam, Arel::SelectManager, Arel::Nodes::Quoted
+        when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::Nodes::BindParam, Arel::SelectManager, Arel::Nodes::Quoted, Arel::Nodes::SqlLiteral
           other
         else
           case attribute

data/lib/arel/nodes/count.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class Count < Arel::Nodes::Function
+      include Math
+
       def initialize expr, distinct = false, aliaz = nil
         super(expr, aliaz)
         @distinct = distinct

data/lib/arel/nodes/delete_statement.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class DeleteStatement < Arel::Nodes::Binary

data/lib/arel/nodes/descending.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Nodes
     class Descending < Ordering