Redundant Tenary Check Added

tests/fixtures/noqa/noqa.py

@@ -774,6 +774,9 @@ def many_raises_function(parameter):  # noqa: WPS238
         raise IndexError('3')
     raise TypeError('4')
 
+ternary_a = 1 
+ternary_b = 2
+ternary_result = ternary_a if ... else ternary_a # noqa: WPS475
 
 my_print("""
 text

tests/test_checker/test_noqa.py

@@ -267,6 +267,7 @@
     'WPS472': 1,
     'WPS473': 0,
     'WPS474': 1,
+    'WPS475': 1,
 
     'WPS500': 1,
     'WPS501': 1,

tests/test_visitors/test_ast/test_redundancy/test_redundant_ternary.py

@@ -0,0 +1,108 @@
+import pytest
+
+from wemake_python_styleguide.violations.best_practices import (
+    RedundantTernaryViolation,
+)
+from wemake_python_styleguide.visitors.ast.redundancy import (
+    RedundantTernaryVisitor,
+)
+
+# Correct:
+correct_ternary_elipses = """
+a if ... else c
+"""
+
+correct_not_equal = """
+a if a != b else c
+"""
+
+non_compare = """
+a if a | b else None
+"""
+
+two_operation_compare = """
+a == b != c
+"""
+
+correct_ternary_none = """
+a.split() if a is not None else None
+"""
+
+# Wrong:
+wrong_ternary_same_values = """
+a if ... else a
+"""
+
+wrong_ternary_useless_comparison_not_eq = """
+a if a != b else b
+"""
+wrong_ternary_useless_comparison_eq = """
+b if a == b else a
+"""
+
+wrong_ternarny_none = """
+a if a is not None else None
+"""
+
+
+@pytest.mark.parametrize('code', [
+    correct_ternary_elipses,
+    correct_not_equal,
+    correct_ternary_none,
+])
+def test_correct_ternary(
+    code,
+    assert_errors,
+    parse_ast_tree,
+    default_options,
+    mode,
+):
+    """Ensures that correct ternary expressions are fine."""
+    tree = parse_ast_tree(mode(code))
+
+    visitor = RedundantTernaryVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [])
+
+
+@pytest.mark.parametrize('code', [
+    wrong_ternary_same_values,
+    wrong_ternary_useless_comparison_not_eq,
+    wrong_ternary_useless_comparison_eq,
+    wrong_ternarny_none,
+])
+def test_wrong_ternary(
+    code,
+    assert_errors,
+    parse_ast_tree,
+    default_options,
+    mode,
+):
+    """Ensures that redundant ternary expressions are forbidden."""
+    tree = parse_ast_tree(mode(code))
+
+    visitor = RedundantTernaryVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [RedundantTernaryViolation])
+
+
+@pytest.mark.parametrize('code', [
+    non_compare,
+    two_operation_compare,
+])
+def safety_check_ternary(
+    code,
+    assert_errors,
+    parse_ast_tree,
+    default_options,
+    mode,
+):
+    """Ensures that conditions for checking are met."""
+    tree = parse_ast_tree(mode(code))
+
+    visitor = RedundantTernaryVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [])

wemake_python_styleguide/presets/types/tree.py

@@ -109,6 +109,7 @@
     decorators.WrongDecoratorVisitor,
 
     redundancy.RedundantEnumerateVisitor,
+    redundancy.RedundantTernaryVisitor,
 
     function_empty_lines.WrongEmptyLinesCountVisitor,
 

wemake_python_styleguide/violations/best_practices.py

@@ -91,6 +91,7 @@
    GettingElementByUnpackingViolation
    WrongEmptyLinesCountViolation
    ImportObjectCollisionViolation
+   RedundantTernaryViolation
 
 Best practices
 --------------
@@ -170,6 +171,7 @@
 .. autoclass:: GettingElementByUnpackingViolation
 .. autoclass:: WrongEmptyLinesCountViolation
 .. autoclass:: ImportObjectCollisionViolation
+.. autoclass:: RedundantTernaryViolation
 
 """
 
@@ -2849,3 +2851,34 @@ class ImportObjectCollisionViolation(ASTViolation):
 
     error_template = 'Found import object collision: {0}'
     code = 474
+
+
+@final
+class RedundantTernaryViolation(ASTViolation):
+    """
+    Forbid the redundant ternary expressions.
+
+    Reasoning:
+        If the ternary expression can be simplified,
+        it should be simplified.
+
+    Solution:
+        Instead of using a ternary operator, use the value directly.
+
+    Example::
+        Correct:
+        a if b is None else c
+        a if a != b else c
+
+        Wrong:
+        a if ... else a
+        a if a is not None else None
+        a if a != b else b
+        b if a == b else a
+
+    .. versionadded:: 0.19.0
+
+    """
+
+    error_template = 'Found redundant ternary operator'
+    code = 475

wemake_python_styleguide/visitors/ast/redundancy.py

@@ -6,6 +6,7 @@
 from wemake_python_styleguide.types import AnyComprehension, AnyFor
 from wemake_python_styleguide.violations.best_practices import (
     RedundantEnumerateViolation,
+    RedundantTernaryViolation,
 )
 from wemake_python_styleguide.visitors import decorators
 from wemake_python_styleguide.visitors.base import BaseNodeVisitor
@@ -53,3 +54,46 @@ def _check_for_redundant_enumerate(self, node: Union[AnyFor, ast.comprehension])
 
         if isinstance(index_receiver, ast.Name) and index_receiver.id == '_':
             self.add_violation(RedundantEnumerateViolation(index_receiver))
+
+
+@final
+class RedundantTernaryVisitor(BaseNodeVisitor):
+    """Finds useless ternary operators."""
+
+    def visit_IfExp(self, node: ast.IfExp) -> None:
+        """Finds useless ternary operators."""
+        body = ast.unparse(node.body)
+        orelse = ast.unparse(node.orelse)
+
+        # Check for specific patterns.
+        self.body_orelse_check(node, body, orelse)
+        self.check_computed_equal(node)
+
+        self.generic_visit(node)  # Visit all other node types.
+
+    def body_orelse_check(
+        self, node: ast.IfExp, body: str, orelse: str,
+    ) -> None:
+        """Check if body and orelse are the same."""
+        if body == orelse:
+            self.add_violation(RedundantTernaryViolation(node))
+
+    def check_computed_equal(self, node: ast.IfExp) -> None:
+        """Used to check if the computed branches are equal."""
+        if not isinstance(node.test, ast.Compare):
+            return
+
+        left = ast.unparse(node.test.left)
+        right = ast.unparse(node.test.comparators[0])
+
+        self.compare_operands(node, left, right)
+
+    def compare_operands(self, node: ast.IfExp, left: str, right: str) -> None:
+        """Compare each operand to see if will result in same values."""
+        body_str = ast.unparse(node.body)
+        orelse_str = ast.unparse(node.orelse)
+
+        if body_str == left and orelse_str == right:
+            self.add_violation(RedundantTernaryViolation(node))
+        elif body_str == right and orelse_str == left:
+            self.add_violation(RedundantTernaryViolation(node))