Add new fixer for 'not A is B' -> 'A is not B' situation.

Closes #110.

Thanks to @rs2 for submitting the idea!

Author: lensvol

README.md

@@ -161,7 +161,6 @@ def f():
 
   if a or b or c:
       pass
-  
   ```
 
 * **B007: Convert f-strings without expressions into regular strings.**
@@ -214,7 +213,20 @@ def f():
   c = frozenset([(1, 2), ("a", "b")])
   ```
 
+* **B010: Replace 'not A is B' with 'A is not B'**
+
+  Usage of `A is not B` over `not A is B` is recommended both by Google and [PEP-8](https://www.python.org/dev/peps/pep-0008/#programming-recommendations). Both of those forms are compiled to the same bytecode, but second form has some potential of confusion for the reader.
+  (thanks to @rs2 for submitting this!).  
 
+  ```python
+  # BEFORE:
+  if not obj is Record:
+      sys.exit(-1)
+  
+  # AFTER:
+  if obj is not Record:
+      sys.exit(-1)
+  ```
 
 **NB:** Each of the fixers can be disabled on per-line basis using [flake8's "noqa" comments](http://flake8.pycqa.org/en/3.1.1/user/ignoring-errors.html#in-line-ignoring-errors).
 

pybetter/cli.py

@@ -17,6 +17,7 @@
     FixTrivialFmtStringCreation,
     FixTrivialNestedWiths,
     FixUnhashableList,
+    FixNotIsConditionOrder,
 )
 from pybetter.utils import resolve_paths, create_diff, prettify_time_interval
 
@@ -30,6 +31,7 @@
     FixTrivialFmtStringCreation,
     FixTrivialNestedWiths,
     FixUnhashableList,
+    FixNotIsConditionOrder,
 )
 
 

pybetter/improvements.py

@@ -12,6 +12,7 @@
 from pybetter.transformers.mutable_args import ArgEmptyInitTransformer
 from pybetter.transformers.nested_withs import NestedWithTransformer
 from pybetter.transformers.not_in import NotInConditionTransformer
+from pybetter.transformers.not_is import NotIsConditionTransformer
 from pybetter.transformers.parenthesized_return import RemoveParenthesesFromReturn
 from pybetter.transformers.unhashable_list import UnhashableListTransformer
 
@@ -95,6 +96,13 @@ class FixUnhashableList(BaseImprovement):
     TRANSFORMER = UnhashableListTransformer
 
 
+class FixNotIsConditionOrder(BaseImprovement):
+    NAME = "not_is"
+    DESCRIPTION = "Replace 'not A is B' with 'A is not B'"
+    CODE = "B010"
+    TRANSFORMER = NotIsConditionTransformer
+
+
 __all__ = [
     "BaseImprovement",
     "FixBooleanEqualityChecks",
@@ -106,4 +114,5 @@ class FixUnhashableList(BaseImprovement):
     "FixTrivialFmtStringCreation",
     "FixTrivialNestedWiths",
     "FixUnhashableList",
+    "FixNotIsConditionOrder",
 ]

pybetter/transformers/not_is.py

@@ -0,0 +1,33 @@
+import libcst as cst
+import libcst.matchers as m
+
+from pybetter.transformers.base import NoqaAwareTransformer
+
+
+class NotIsConditionTransformer(NoqaAwareTransformer):
+    @m.leave(
+        m.UnaryOperation(
+            operator=m.Not(),
+            expression=m.Comparison(comparisons=[m.ComparisonTarget(operator=m.Is())]),
+        )
+    )
+    def replace_not_in_condition(
+        self, _, updated_node: cst.UnaryOperation
+    ) -> cst.BaseExpression:
+        comparison_node: cst.Comparison = cst.ensure_type(
+            updated_node.expression, cst.Comparison
+        )
+
+        # TODO: Implement support for multiple consecutive 'not ... in B',
+        # even if it does not make any sense in practice.
+        return cst.Comparison(
+            left=comparison_node.left,
+            lpar=updated_node.lpar,
+            rpar=updated_node.rpar,
+            comparisons=[
+                comparison_node.comparisons[0].with_changes(operator=cst.IsNot())
+            ],
+        )
+
+
+__all__ = ["NotIsConditionTransformer"]

tests/test_not_in.py

@@ -46,6 +46,7 @@
     NO_CHANGES_MADE,
 )
 
+
 CONSECUTIVE_COMPARISONS_UNCHANGED = (
     """
     if not (a in b in c in d):

tests/test_not_is.py

@@ -0,0 +1,60 @@
+import pytest
+
+from pybetter.cli import process_file
+from pybetter.improvements import FixNotIsConditionOrder
+
+NO_CHANGES_MADE = None
+
+TRIVIAL_NOT_A_IS_B_CASE = (
+    """
+    if not a is B:
+        pass
+    """,
+    """
+    if a is not B:
+        pass
+    """,
+)
+
+
+MULTIPLE_NOT_A_IS_B_CASE = (
+    """
+    if foo is not None and not bar is None:
+        pass
+    """,
+    """
+    if foo is not None and bar is not None:
+        pass
+    """,
+)
+
+
+NESTED_NOT_A_IS_B_CASE = (
+    """
+    if not foo is (not A is B):
+        pass
+    """,
+    """
+    if foo is not (A is not B):
+        pass
+    """,
+)
+
+
+@pytest.mark.parametrize(
+    "original,expected",
+    [
+        TRIVIAL_NOT_A_IS_B_CASE,
+        MULTIPLE_NOT_A_IS_B_CASE,
+        NESTED_NOT_A_IS_B_CASE,
+    ],
+    ids=[
+        "trivial 'not A is B' case",
+        "multiple 'not A is B' in same expression",
+        "nested 'not A is B' case",
+    ],
+)
+def test_not_in_transformation(original, expected):
+    processed, _ = process_file(original.strip(), [FixNotIsConditionOrder])
+
+    assert processed.strip() == (expected or original).strip()