Arel: rubocop -a

1 files changed, 59 insertions, 58 deletions

diff --git a/activerecord/lib/arel/predications.rb b/activerecord/lib/arel/predications.rb
index 799c7c67b8..1e701586a4 100644
--- a/activerecord/lib/arel/predications.rb
+++ b/activerecord/lib/arel/predications.rb
@@ -1,31 +1,32 @@
 # frozen_string_literal: true
+
 module Arel
   module Predications
-    def not_eq other
+    def not_eq(other)
       Nodes::NotEqual.new self, quoted_node(other)
     end
 
-    def not_eq_any others
+    def not_eq_any(others)
       grouping_any :not_eq, others
     end
 
-    def not_eq_all others
+    def not_eq_all(others)
       grouping_all :not_eq, others
     end
 
-    def eq other
+    def eq(other)
       Nodes::Equality.new self, quoted_node(other)
     end
 
-    def eq_any others
+    def eq_any(others)
       grouping_any :eq, others
     end
 
-    def eq_all others
+    def eq_all(others)
       grouping_all :eq, quoted_array(others)
     end
 
-    def between other
+    def between(other)
       if equals_quoted?(other.begin, -Float::INFINITY)
         if equals_quoted?(other.end, Float::INFINITY)
           not_in([])
@@ -45,7 +46,7 @@ module Arel
       end
     end
 
-    def in other
+    def in(other)
       case other
       when Arel::SelectManager
         Arel::Nodes::In.new(self, other.ast)
@@ -63,15 +64,15 @@ Passing a range to `#in` is deprecated. Call `#between`, instead.
       end
     end
 
-    def in_any others
+    def in_any(others)
       grouping_any :in, others
     end
 
-    def in_all others
+    def in_all(others)
       grouping_all :in, others
     end
 
-    def not_between other
+    def not_between(other)
       if equals_quoted?(other.begin, -Float::INFINITY)
         if equals_quoted?(other.end, Float::INFINITY)
           self.in([])
@@ -93,7 +94,7 @@ Passing a range to `#in` is deprecated. Call `#between`, instead.
       end
     end
 
-    def not_in other
+    def not_in(other)
       case other
       when Arel::SelectManager
         Arel::Nodes::NotIn.new(self, other.ast)
@@ -111,130 +112,130 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       end
     end
 
-    def not_in_any others
+    def not_in_any(others)
       grouping_any :not_in, others
     end
 
-    def not_in_all others
+    def not_in_all(others)
       grouping_all :not_in, others
     end
 
-    def matches other, escape = nil, case_sensitive = false
+    def matches(other, escape = nil, case_sensitive = false)
       Nodes::Matches.new self, quoted_node(other), escape, case_sensitive
     end
 
-    def matches_regexp other, case_sensitive = true
+    def matches_regexp(other, case_sensitive = true)
       Nodes::Regexp.new self, quoted_node(other), case_sensitive
     end
 
-    def matches_any others, escape = nil, case_sensitive = false
+    def matches_any(others, escape = nil, case_sensitive = false)
       grouping_any :matches, others, escape, case_sensitive
     end
 
-    def matches_all others, escape = nil, case_sensitive = false
+    def matches_all(others, escape = nil, case_sensitive = false)
       grouping_all :matches, others, escape, case_sensitive
     end
 
-    def does_not_match other, escape = nil, case_sensitive = false
+    def does_not_match(other, escape = nil, case_sensitive = false)
       Nodes::DoesNotMatch.new self, quoted_node(other), escape, case_sensitive
     end
 
-    def does_not_match_regexp other, case_sensitive = true
+    def does_not_match_regexp(other, case_sensitive = true)
       Nodes::NotRegexp.new self, quoted_node(other), case_sensitive
     end
 
-    def does_not_match_any others, escape = nil
+    def does_not_match_any(others, escape = nil)
       grouping_any :does_not_match, others, escape
     end
 
-    def does_not_match_all others, escape = nil
+    def does_not_match_all(others, escape = nil)
       grouping_all :does_not_match, others, escape
     end
 
-    def gteq right
+    def gteq(right)
       Nodes::GreaterThanOrEqual.new self, quoted_node(right)
     end
 
-    def gteq_any others
+    def gteq_any(others)
       grouping_any :gteq, others
     end
 
-    def gteq_all others
+    def gteq_all(others)
       grouping_all :gteq, others
     end
 
-    def gt right
+    def gt(right)
       Nodes::GreaterThan.new self, quoted_node(right)
     end
 
-    def gt_any others
+    def gt_any(others)
       grouping_any :gt, others
     end
 
-    def gt_all others
+    def gt_all(others)
       grouping_all :gt, others
     end
 
-    def lt right
+    def lt(right)
       Nodes::LessThan.new self, quoted_node(right)
     end
 
-    def lt_any others
+    def lt_any(others)
       grouping_any :lt, others
     end
 
-    def lt_all others
+    def lt_all(others)
       grouping_all :lt, others
     end
 
-    def lteq right
+    def lteq(right)
       Nodes::LessThanOrEqual.new self, quoted_node(right)
     end
 
-    def lteq_any others
+    def lteq_any(others)
       grouping_any :lteq, others
     end
 
-    def lteq_all others
+    def lteq_all(others)
       grouping_all :lteq, others
     end
 
-    def when right
+    def when(right)
       Nodes::Case.new(self).when quoted_node(right)
     end
 
-    def concat other
+    def concat(other)
       Nodes::Concat.new self, other
     end
 
     private
 
-    def grouping_any method_id, others, *extras
-      nodes = others.map {|expr| send(method_id, expr, *extras)}
-      Nodes::Grouping.new nodes.inject { |memo,node|
-        Nodes::Or.new(memo, node)
-      }
-    end
+      def grouping_any(method_id, others, *extras)
+        nodes = others.map { |expr| send(method_id, expr, *extras) }
+        Nodes::Grouping.new nodes.inject { |memo, node|
+          Nodes::Or.new(memo, node)
+        }
+      end
 
-    def grouping_all method_id, others, *extras
-      nodes = others.map {|expr| send(method_id, expr, *extras)}
-      Nodes::Grouping.new Nodes::And.new(nodes)
-    end
+      def grouping_all(method_id, others, *extras)
+        nodes = others.map { |expr| send(method_id, expr, *extras) }
+        Nodes::Grouping.new Nodes::And.new(nodes)
+      end
 
-    def quoted_node(other)
-      Nodes.build_quoted(other, self)
-    end
+      def quoted_node(other)
+        Nodes.build_quoted(other, self)
+      end
 
-    def quoted_array(others)
-      others.map { |v| quoted_node(v) }
-    end
+      def quoted_array(others)
+        others.map { |v| quoted_node(v) }
+      end
 
-    def equals_quoted?(maybe_quoted, value)
-      if maybe_quoted.is_a?(Nodes::Quoted)
-        maybe_quoted.val == value
-      else
-        maybe_quoted == value
+      def equals_quoted?(maybe_quoted, value)
+        if maybe_quoted.is_a?(Nodes::Quoted)
+          maybe_quoted.val == value
+        else
+          maybe_quoted == value
+        end
       end
-    end
   end
 end