feat: add support for match pattern (#227)

* Added support of match pattern

* Corrected missing +

* Added match statement description into Cyclomatic Complexity doc section.

* Added match statement description into Cyclomatic Complexity doc section.

Author: DolajoCZ

docs/intro.rst

@@ -22,6 +22,8 @@ Complexity. Statements have the following effects on Cyclomatic Complexity:
  if                 +1             An `if` statement is a single decision.
  elif               +1             The `elif` statement adds another decision.
  else               +0             The `else` statement does not cause a new decision. The decision is at the `if`.
+ case pattern       +1             The `case pattern` statement is a single decision.
+ case _             +0             The `case _` statement does not cause a new decision. The decision is at the `case pattern`.
  for                +1             There is a decision at the start of the loop.
  while              +1             There is a decision at the `while` statement.
  except             +1             Each `except` branch adds a new conditional path of execution.

radon/tests/test_complexity_visitor.py

@@ -81,6 +81,42 @@
         4,
         {},
     ),
+    (
+        '''
+     match a:
+         case 1: pass
+     ''',
+        2,
+        {},
+    ),
+    (
+        '''
+     match a:
+         case 1: pass
+         case _: pass
+     ''',
+        2,
+        {},
+    ),
+    (
+        '''
+     match a:
+         case 1: pass
+         case 2: pass
+     ''',
+        3,
+        {},
+    ),
+    (
+        '''
+     match a:
+         case 1: pass
+         case 2: pass
+         case _: pass
+     ''',
+        3,
+        {},
+    ),
     (
         '''
      for x in range(10): print(x)

radon/visitors.py

@@ -236,6 +236,13 @@ def generic_visit(self, node):
         # Note: Lambda functions are not counted anymore, see #68
         elif name in ('If', 'IfExp'):
             self.complexity += 1
+        elif name == 'Match':
+            # check if _ (else) used
+            contain_underscore = any(
+                (case for case in node.cases if
+                 getattr(case.pattern, "pattern", False) is None))
+            # Max used for case when match contain only _ (else)
+            self.complexity += max(0, len(node.cases) - contain_underscore)
         # The For and While blocks count as 1 plus the `else` block.
         elif name in ('For', 'While', 'AsyncFor'):
             self.complexity += bool(node.orelse) + 1