lib/rubocop/cop/style/and_or.rb in rubocop-0.34.2 vs lib/rubocop/cop/style/and_or.rb in rubocop-0.35.0

@@ -61,28 +61,57 @@
         def correction(node)
           expr1, expr2 = *node
           replacement = (node.type == :and ? '&&' : '||')
           lambda do |corrector|
             [expr1, expr2].each do |expr|
-              _receiver, _method_name, *args = *expr
-              next unless correctable?(expr)
-
-              sb = expr.loc.expression.source_buffer
-              begin_paren = expr.loc.selector.end_pos
-              end_paren = begin_paren + 1
-              range = Parser::Source::Range.new(sb, begin_paren, end_paren)
-              corrector.replace(range, '(')
-              corrector.insert_after(args.last.loc.expression, ')')
+              if expr.send_type?
+                correct_send(expr, corrector)
+              elsif expr.return_type?
+                correct_other(expr, corrector)
+              elsif expr.assignment?
+                correct_other(expr, corrector)
+              end
             end
             corrector.replace(node.loc.operator, replacement)
           end
         end
 
-        def correctable?(expr)
-          return false unless expr.type == :send
-          _receiver, method_name, *args = *expr
+        def correct_send(node, corrector)
+          receiver, method_name, *args = *node
+          if method_name == :!
+            # ! is a special case:
+            # 'x and !obj.method arg' can be auto-corrected if we
+            # recurse down a level and add parens to 'obj.method arg'
+            # however, 'not x' also parses as (send x :!)
+
+            if node.loc.selector.source == '!'
+              node = receiver
+              _receiver, _method_name, *args = *node
+            elsif node.loc.selector.source == 'not'
+              return correct_other(node, corrector)
+            else
+              fail 'unrecognized unary negation operator'
+            end
+          end
+          return unless correctable_send?(node)
+
+          sb = node.loc.expression.source_buffer
+          begin_paren = node.loc.selector.end_pos
+          range = Parser::Source::Range.new(sb, begin_paren, begin_paren + 1)
+          corrector.replace(range, '(')
+          corrector.insert_after(args.last.loc.expression, ')')
+        end
+
+        def correct_other(node, corrector)
+          return unless node.loc.expression.begin.source != '('
+          corrector.insert_before(node.loc.expression, '(')
+          corrector.insert_after(node.loc.expression, ')')
+        end
+
+        def correctable_send?(node)
+          _receiver, method_name, *args = *node
           # don't clobber if we already have a starting paren
-          return false unless !expr.loc.begin || expr.loc.begin.source != '('
+          return false unless !node.loc.begin || node.loc.begin.source != '('
           # don't touch anything unless we are sure it is a method call.
           return false unless args.last && method_name.to_s =~ /[a-z]/
 
           true
         end