lib/rubocop/cop/style/and_or.rb in rubocop-0.42.0 vs lib/rubocop/cop/style/and_or.rb in rubocop-0.43.0

@@ -58,11 +58,11 @@
           add_offense(node, :operator, format(MSG, OPS[op], op))
         end
 
         def autocorrect(node)
           expr1, expr2 = *node
-          replacement = (node.type == :and ? '&&' : '||')
+          replacement = (node.and_type? ? '&&' : '||')
           lambda do |corrector|
             [expr1, expr2].each do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
               elsif expr.return_type?
@@ -76,16 +76,23 @@
         end
 
         def correct_send(node, corrector)
           receiver, method_name, *args = *node
           return correct_not(node, receiver, corrector) if method_name == :!
+          return correct_setter(node, corrector) if setter_method?(method_name)
           return unless correctable_send?(node)
 
           corrector.replace(whitespace_before_arg(node), '('.freeze)
           corrector.insert_after(args.last.source_range, ')'.freeze)
         end
 
+        def correct_setter(node, corrector)
+          receiver, _method_name, *args = *node
+          corrector.insert_before(receiver.source_range, '('.freeze)
+          corrector.insert_after(args.last.source_range, ')'.freeze)
+        end
+
         # ! 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 :!)
         def correct_not(node, receiver, corrector)
@@ -104,10 +111,14 @@
           return unless node.source_range.begin.source != '('
           corrector.insert_before(node.source_range, '(')
           corrector.insert_after(node.source_range, ')')
         end
 
+        def setter_method?(method_name)
+          method_name.to_s.end_with?('=')
+        end
+
         def correctable_send?(node)
           _receiver, method_name, *args = *node
           # don't clobber if we already have a starting paren
           return false unless !node.loc.begin || node.loc.begin.source != '('
           # don't touch anything unless we are sure it is a method call.
@@ -115,16 +126,15 @@
 
           true
         end
 
         def whitespace_before_arg(node)
-          sb = node.source_range.source_buffer
           begin_paren = node.loc.selector.end_pos
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).
           end_paren += 1 unless node.source =~ /\?[!\S]/
-          Parser::Source::Range.new(sb, begin_paren, end_paren)
+          range_between(begin_paren, end_paren)
         end
       end
     end
   end
 end