From c22abda79b7f0fbee5f0ef0e9648d52d7d483902 Mon Sep 17 00:00:00 2001
From: Shahbaz Javeed <sjaveed@gmail.com>
Date: Thu, 10 Dec 2015 16:50:28 -0500
Subject: * Support for bitwise operations as infix operators.  Tests included.

*** Individual commit messages included below ***
* Preliminary support for bitwise operations as infix operators.  Tests to follow.

* Added bitwise xor, shift left and shift right operators

* Fixed the BitwiseOr class so it uses the :| operator instead of :&
* All the methods for the bitwise operators in the Arel::Math module now wrap them up in Arel::Nodes::Grouping so the operation becomes isolated like addition and subtraction
* Preliminary set of tests for the new operators

* Updated README with examples of bitwise operations

* Added a new UnaryOperation class which is a riff on the InfixOperation class
* Added tests for UnaryOperation (inspired by InfixOperation tests)
* Added the bitwise not (~) operator as a UnaryOperation
* Added tests for the bitwise not operator

* Added documentation for the bitwise not operator

* Updated gemspec using `rake arel.gemspec`
---
 test/nodes/test_unary_operation.rb | 39 ++++++++++++++++++++++++++++++++++++++
 test/visitors/test_to_sql.rb       | 37 ++++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 test/nodes/test_unary_operation.rb

(limited to 'test')

diff --git a/test/nodes/test_unary_operation.rb b/test/nodes/test_unary_operation.rb
new file mode 100644
index 0000000000..d89c10b431
--- /dev/null
+++ b/test/nodes/test_unary_operation.rb
@@ -0,0 +1,39 @@
+require 'helper'
+
+module Arel
+  module Nodes
+    class TestUnaryOperation < Minitest::Test
+      def test_construct
+        operation = UnaryOperation.new :-, 1
+        assert_equal :-, operation.operator
+        assert_equal 1, operation.expr
+      end
+
+      def test_operation_alias
+        operation = UnaryOperation.new :-, 1
+        aliaz = operation.as('zomg')
+        assert_kind_of As, aliaz
+        assert_equal operation, aliaz.left
+        assert_equal 'zomg', aliaz.right
+      end
+
+      def test_operation_ordering
+        operation = UnaryOperation.new :-, 1
+        ordering = operation.desc
+        assert_kind_of Descending, ordering
+        assert_equal operation, ordering.expr
+        assert ordering.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [UnaryOperation.new(:-, 1), UnaryOperation.new(:-, 1)]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [UnaryOperation.new(:-, 1), UnaryOperation.new(:-, 2)]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/test/visitors/test_to_sql.rb b/test/visitors/test_to_sql.rb
index 4162d970b5..6da86c2dee 100644
--- a/test/visitors/test_to_sql.rb
+++ b/test/visitors/test_to_sql.rb
@@ -475,6 +475,31 @@ module Arel
           compile(node).must_equal %("users"."name" || "users"."name")
         end
 
+        it "should handle BitwiseAnd" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) & 16
+          compile(node).must_equal %(("products"."bitmap" & 16))
+        end
+
+        it "should handle BitwiseOr" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) | 16
+          compile(node).must_equal %(("products"."bitmap" | 16))
+        end
+
+        it "should handle BitwiseXor" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) ^ 16
+          compile(node).must_equal %(("products"."bitmap" ^ 16))
+        end
+
+        it "should handle BitwiseShiftLeft" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) << 4
+          compile(node).must_equal %(("products"."bitmap" << 4))
+        end
+
+        it "should handle BitwiseShiftRight" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) >> 4
+          compile(node).must_equal %(("products"."bitmap" >> 4))
+        end
+
         it "should handle arbitrary operators" do
           node = Arel::Nodes::InfixOperation.new(
             '&&',
@@ -485,6 +510,18 @@ module Arel
         end
       end
 
+      describe "Nodes::UnaryOperation" do
+        it "should handle BitwiseNot" do
+          node = ~ Arel::Attributes::Integer.new(Table.new(:products), :bitmap)
+          compile(node).must_equal %( ~ "products"."bitmap")
+        end
+
+        it "should handle arbitrary operators" do
+          node = Arel::Nodes::UnaryOperation.new('!', Arel::Attributes::String.new(Table.new(:products), :active))
+          compile(node).must_equal %( ! "products"."active")
+        end
+      end
+
       describe "Nodes::NotIn" do
         it "should know how to visit" do
           node = @attr.not_in [1, 2, 3]
-- 
cgit v1.2.3