Fix RSpec/ChangeByZero with compound operators

Previously, it didn't recognize compound expressions using `&` or `|`.
This led it to correct part of the expressions as regular code, but the
generated code was malformed.

Now it recognizes compound expressions using the operators.

Also, its correction was wrong if `change` `by(0)` was used with
`to_not` or `not_to` already. It no longer makes that correction.

Author: BrianHawley

CHANGELOG.md

@@ -5,6 +5,8 @@
 * Fix `RSpec/FilePath` cop missing mismatched expanded namespace. ([@sl4vr][])
 * Add new `AllowConsecutiveOneLiners` (default true) option for `Rspec/EmptyLineAfterHook` cop. ([@ngouy][])
 * Add autocorrect support for `RSpec/EmptyExampleGroup`. ([@r7kamura][])
+* Fix `RSpec/ChangeByZero` with compound expressions using `&` or `|` operators. ([@BrianHawley][])
+* Fix `RSpec/ChangeByZero` bad correction when already `not_to` or `to_not`. ([@BrianHawley][])
 
 ## 2.12.1 (2022-07-03)
 
@@ -718,3 +720,4 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 [@edgibbs]: https://github.com/edgibbs
 [@Drowze]: https://github.com/Drowze
 [@akiomik]: https://github.com/akiomik
+[@BrianHawley]: https://github.com/BrianHawley

lib/rubocop/cop/rspec/change_by_zero.rb

@@ -73,13 +73,15 @@ def check_offense(node)
             add_offense(expression, message: MSG_COMPOUND)
           else
             add_offense(expression) do |corrector|
+              next unless node.parent.method?(:to)
+
               autocorrect(corrector, node)
             end
           end
         end
 
         def compound_expectations?(node)
-          %i[and or].include?(node.parent.method_name)
+          %i[and or & |].include?(node.parent.method_name)
         end
 
         def autocorrect(corrector, node)

spec/rubocop/cop/rspec/change_by_zero_spec.rb

@@ -25,6 +25,24 @@
     RUBY
   end
 
+  it 'registers an offense when the argument to `by` is zero, ' \
+    'but does not correct if it is `not_to` `change` already' do
+    expect_offense(<<-RUBY)
+      it do
+        expect { foo }.not_to change(Foo, :bar).by(0)
+                              ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+        expect { foo }.not_to change(::Foo, :bar).by(0)
+                              ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+        expect { foo }.not_to change { Foo.bar }.by(0)
+                              ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+        expect { foo }.not_to change(Foo, :bar).by 0
+                              ^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
   it 'registers an offense when the argument to `by` is zero ' \
     'with compound expectations' do
     expect_offense(<<-RUBY)
@@ -39,6 +57,16 @@
               ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
           .and change { Foo.baz }.by(0)
                ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        expect { foo }
+          .to change(Foo, :bar).by(0) &
+              ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              change(Foo, :baz).by(0)
+              ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        expect { foo }
+          .to change { Foo.bar }.by(0) &
+              ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              change { Foo.baz }.by(0)
+              ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
         expect { foo }
           .to change(Foo, :bar).by(0)
               ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
@@ -49,8 +77,20 @@
               ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
           .or change { Foo.baz }.by(0)
               ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        expect { foo }
+          .to change(Foo, :bar).by(0) |
+              ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              change(Foo, :baz).by(0)
+              ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        expect { foo }
+          .to change { Foo.bar }.by(0) |
+              ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              change { Foo.baz }.by(0)
+              ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
       end
     RUBY
+
+    expect_no_corrections
   end
 
   it 'does not register an offense when the argument to `by` is not zero' do