arel 6.0.4 → 7.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59ae3c77b74453a1663328ba61bfc418c079991c
-  data.tar.gz: 7b834bf894712eb6aacfc8ba7daee9e74267cc26
+  metadata.gz: d1986f950d2ecce6990d5a420c7963c874bcf22b
+  data.tar.gz: e21fbc532cdf9feceed6883a9ed1a151c0c1ebb3
 SHA512:
-  metadata.gz: 750cf5971ff972d2c4db50ba08d36bbedc180bc5ad468668259f1d56d66ca6af377a92f2991370654b97e92130e6ea3d9ff7e826930cab74da8a73e118e878b2
-  data.tar.gz: 803c188ee28bd29a6df184200d15dce08c6f7166b0f762cd698193692f8616873894f2be87b924848d5ec26cb0b57061346a8dfe98b71bab0072b8b9b5bd4612
+  metadata.gz: c0c67c17600ee4a7ce861bc688abf8d409d8b8c1c65969f26a9cfe8d7263eacd3c50f3e9548b80f1e071cd14e176e765addba6ec84de579c4797a123c960e2b1
+  data.tar.gz: a9f11f32f1868a9df3b27c88828513bf4106fcce946defc2d383488ab9fe9cb814408c51071ce6bbfe5aa8777d1a1fba7afd4fea89d4931282a2d7447343588e

data/History.txt

@@ -1,26 +1,45 @@
-=== 6.0.4 / 2016-12-27
+=== 7.1.4 / 2016-10-10
 
-* Enhancements
+* bug fixes
 
-  * Ruby 2.4 compatibility
+  * Remove deprecated usage inside arel.
 
-=== 6.0.3 / 2015-08-04
+=== 7.1.3 / 2016-10-07
 
-* Bug fixes
+* bug fixes
 
-  * Fix quoting LIMIT values on Oracle visitor.
+  * Remove union mapping as :binary node when performing DepthFirst enumeration
+  * Fix invalid BindParam output in Dot visitor
+  * Add Arel::Nodes::Casted to dot visitor
+  * Use Arel::Nodes::BindParam in Oracle visitor for queries using both LIMIT and OFFSET
 
-=== 6.0.2 / 2015-07-11
+=== 7.1.2 / 2016-09-13
 
-* Bug fixes
+* bug fixes
 
-  * Fix file permission problem on the gem package
+  * Don't store all aliases to a table
 
-=== 6.0.1 / 2015-07-10
+=== 7.1.1 / 2016-07-27
 
-* Bug fixes
+* 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
 
-  * Stop quoting LIMIT values.
+  * Remove deprecated method `Table#primary_key`
+  * Remove engine from the constructor arguments `Arel::Table`
+  * Deprecate automatic type casting within Arel
 
 === 6.0.0 / 2014-11-25
 

data/MIT-LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2007-2010 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
@@ -18,3 +18,4 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/{README.markdown → README.md}

@@ -1,4 +1,4 @@
-# Arel [![Build Status](https://secure.travis-ci.org/rails/arel.svg?branch=master)](http://travis-ci.org/rails/arel) [![Dependency Status](https://gemnasium.com/rails/arel.svg)](https://gemnasium.com/rails/arel)
+# Arel
 
 * http://github.com/rails/arel
 
@@ -8,8 +8,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 +17,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 +27,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 +56,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 +107,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 +128,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                                 \
@@ -119,23 +154,35 @@ The `AND` operator behaves similarly.
 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 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
 
@@ -179,12 +226,13 @@ 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:
+[Common Table Expressions (CTE)](https://en.wikipedia.org/wiki/Common_table_expressions#Common_table_expression) support via:
 
 Create a `CTE`
 
@@ -201,7 +249,9 @@ 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
 ```
 
 When your query is too complex for `Arel`, you can use `Arel::SqlLiteral`:
@@ -214,14 +264,21 @@ 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"
 ```
 
-### License
+## Contributing to Arel
+
+Arel is the work of many contributors. You're encouraged to submit pull requests, propose
+features and discuss issues.
+
+See [CONTRIBUTING](CONTRIBUTING.md).
 
-Arel is released under the [MIT License](http://opensource.org/licenses/MIT).
+## License
+Arel is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/arel.rb

@@ -21,7 +21,7 @@ require 'arel/delete_manager'
 require 'arel/nodes'
 
 module Arel
-  VERSION = '6.0.4'
+  VERSION = '7.1.4'
 
   def self.sql raw_sql
     Arel::Nodes::SqlLiteral.new raw_sql

data/lib/arel/attributes/attribute.rb

@@ -12,6 +12,14 @@ module Arel
       def lower
         relation.lower self
       end
+
+      def type_cast_for_database(value)
+        relation.type_cast_for_database(name, value)
+      end
+
+      def able_to_type_cast?
+        relation.able_to_type_cast?
+      end
     end
 
     class String    < Attribute; end

data/lib/arel/crud.rb

@@ -3,7 +3,7 @@ module Arel
   # FIXME hopefully we can remove this
   module Crud
     def compile_update values, pk
-      um = UpdateManager.new @engine
+      um = UpdateManager.new
 
       if Nodes::SqlLiteral === values
         relation = @ctx.from
@@ -26,11 +26,12 @@ module Arel
     end
 
     def create_insert
-      InsertManager.new @engine
+      InsertManager.new
     end
 
     def compile_delete
-      dm = DeleteManager.new @engine
+      dm = DeleteManager.new
+      dm.take @ast.limit.expr if @ast.limit
       dm.wheres = @ctx.wheres
       dm.from @ctx.froms
       dm

data/lib/arel/delete_manager.rb

@@ -1,6 +1,6 @@
 module Arel
   class DeleteManager < Arel::TreeManager
-    def initialize engine
+    def initialize
       super
       @ast = Nodes::DeleteStatement.new
       @ctx = @ast
@@ -11,6 +11,11 @@ module Arel
       self
     end
 
+    def take limit
+      @ast.limit = Nodes::Limit.new(Nodes.build_quoted(limit)) if limit
+      self
+    end
+
     def wheres= list
       @ast.wheres = list
     end

data/lib/arel/insert_manager.rb

@@ -1,6 +1,6 @@
 module Arel
   class InsertManager < Arel::TreeManager
-    def initialize engine
+    def initialize
       super
       @ast = Nodes::InsertStatement.new
     end

data/lib/arel/math.rb

@@ -15,5 +15,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.rb

@@ -28,8 +28,10 @@ require 'arel/nodes/join_source'
 require 'arel/nodes/delete_statement'
 require 'arel/nodes/table_alias'
 require 'arel/nodes/infix_operation'
+require 'arel/nodes/unary_operation'
 require 'arel/nodes/over'
 require 'arel/nodes/matches'
+require 'arel/nodes/regexp'
 
 # nary
 require 'arel/nodes/and'
@@ -46,6 +48,9 @@ require 'arel/nodes/named_function'
 # windows
 require 'arel/nodes/window'
 
+# conditional expressions
+require 'arel/nodes/case'
+
 # joins
 require 'arel/nodes/full_outer_join'
 require 'arel/nodes/inner_join'
@@ -55,41 +60,4 @@ require 'arel/nodes/string_join'
 
 require 'arel/nodes/sql_literal'
 
-module Arel
-  module Nodes
-    class Casted < Arel::Nodes::Node # :nodoc:
-      attr_reader :val, :attribute
-      def initialize val, attribute
-        @val       = val
-        @attribute = attribute
-        super()
-      end
-
-      def nil?; @val.nil?; end
-
-      def eql? other
-        self.class == other.class &&
-          self.val == other.val &&
-          self.attribute == other.attribute
-      end
-      alias :== :eql?
-    end
-
-    class Quoted < Arel::Nodes::Unary # :nodoc:
-    end
-
-    def self.build_quoted other, attribute = nil
-      case other
-      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::Nodes::BindParam, Arel::SelectManager
-        other
-      else
-        case attribute
-        when Arel::Attributes::Attribute
-          Casted.new other, attribute
-        else
-          Quoted.new other
-        end
-      end
-    end
-  end
-end
+require 'arel/nodes/casted'