complexipy 0.3.0__tar.gz → 0.3.2__tar.gz

{complexipy-0.3.0 → complexipy-0.3.2}/Cargo.lock

@@ -119,7 +119,7 @@ checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 
 [[package]]
 name = "complexipy"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "csv",
  "env_logger",

{complexipy-0.3.0 → complexipy-0.3.2}/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "complexipy"
-version = "0.3.0"
+version = "0.3.2"
 edition = "2021"
 authors = ["Robin Quintero <rohaquinlop301@gmail.com>"]
 license = "MIT"
-description = "An extremely fast Python library to calculate the cognitive complexity of python files, written in Rust."
+description = "An extremely fast Python library to calculate the cognitive complexity of Python files, written in Rust."
 readme = "README.md"
 homepage = "https://github.com/rohaquinlop/complexipy"
 documentation = "https://rohaquinlop.github.io/complexipy/"

{complexipy-0.3.0 → complexipy-0.3.2}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.3
 Name: complexipy
-Version: 0.3.0
+Version: 0.3.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: typer[all]
 License-File: LICENSE
-Summary: An extremely fast Python library to calculate the cognitive complexity of python files, written in Rust.
+Summary: An extremely fast Python library to calculate the cognitive complexity of Python files, written in Rust.
 Keywords: cognitive,complexity,cognitive complexity,rust,fast
 Home-Page: https://github.com/rohaquinlop/complexipy
 Author: Robin Quintero <rohaquinlop301@gmail.com>
 Author-email: Robin Quintero <rohaquinlop301@gmail.com>
 License: MIT
-Requires-Python: >=3.11
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Source Code, https://github.com/rohaquinlop/complexipy
 
@@ -65,7 +65,7 @@ Made with [contributors-img](https://contrib.rocks)
 
 ## Requirements
 
-- Python >= 3.11
+- Python >= 3.8
 - You also need to install `git` in your computer if you want to analyze a git repository.
 
 ## Installation
@@ -79,16 +79,17 @@ pip install complexipy
 To run **complexipy** you can use the following command:
 
 ```shell
-complexipy .                         # Use complexipy to analyze the current directory and any subdirectories
-complexipy path/to/directory         # Use complexipy to analyze a specific directory and any subdirectories
-complexipy git_repository_url        # Use complexipy to analyze a git repository
-complexipy path/to/file.py           # Use complexipy to analyze a specific file
-complexipy path/to/file.py -c 20     # Use the -c option to set the maximum congnitive complexity, default is 15
-complexipy path/to/directory -c 0    # Set the maximum cognitive complexity to 0 to disable the exit with error
-complexipy path/to/directory -o      # Use the -o option to output the results to a CSV file, default is False
-complexipy path/to/directory -d low  # Use the -d option to set detail level, default is "normal". If set to "low" will show only files with complexity greater than the maximum complexity
-complexipy path/to/directory -l file # Use the -l option to set the level of measurement, default is "function". If set to "file" will measure the complexity of the file and will validate the maximum complexity according to the file complexity.
-complexipy path/to/directory -q     # Use the -q option to disable the output to the console, default is False.
+complexipy .                            # Use complexipy to analyze the current directory and any subdirectories
+complexipy path/to/directory            # Use complexipy to analyze a specific directory and any subdirectories
+complexipy git_repository_url           # Use complexipy to analyze a git repository
+complexipy path/to/file.py              # Use complexipy to analyze a specific file
+complexipy path/to/file.py -c 20        # Use the -c option to set the maximum congnitive complexity, default is 15
+complexipy path/to/directory -c 0       # Set the maximum cognitive complexity to 0 to disable the exit with error
+complexipy path/to/directory -o         # Use the -o option to output the results to a CSV file, default is False
+complexipy path/to/directory -d low     # Use the -d option to set detail level, default is "normal". If set to "low" will show only files with complexity greater than the maximum complexity
+complexipy path/to/directory -l file    # Use the -l option to set the level of measurement, default is "function". If set to "file" will measure the complexity of the file and will validate the maximum complexity according to the file complexity.
+complexipy path/to/directory -q         # Use the -q option to disable the output to the console, default is False.
+complexipy path/to/directory -s desc    # Use the -s option to set the sort order, default is "asc". If set to "desc" will sort the results in descending order. If set to "asc" will sort the results in ascending order. If set to "name" will sort the results by name.
 ```
 
 ### Options
@@ -99,7 +100,7 @@ complexipy path/to/directory -q     # Use the -q option to disable the output to
   If set to 0, the exit with error will be disabled.
 - `-o` or `--output`: Output the results to a CSV file, default is False. The
   filename will be `complexipy.csv` and will be saved in the invocation directory.
-- `-d` or `--detail`: Set the detail level, default is "normal". If set to "low"
+- `-d` or `--details`: Set the detail level, default is "normal". If set to "low"
   will show only files or functions with complexity greater than the maximum
   complexity.
 - `-l` or `--level` Set the level of measurement, default is "function". If set
@@ -110,6 +111,10 @@ complexipy path/to/directory -q     # Use the -q option to disable the output to
   a maximum complexity according for each file or for each function in the file
   (or files).
 - `-q` or `--quiet`: Disable the output to the console, default is False.
+- `-s` or `--sort`: Set the sort order, default is "asc". If set to "desc" will
+  sort the results in descending order. If set to "asc" will sort the results in
+  ascending order. If set to "name" will sort the results by name. This option will
+  affect the output to the console and the output to the CSV file.
 
 If the cognitive complexity of a file or a function is greater than the maximum
 cognitive cognitive complexity, then the return code will be 1 and exit with
@@ -139,7 +144,7 @@ The cognitive complexity of the file is 1, and the output of the command
 `complexipy path/to/file.py` will be:
 
 ```txt
-───────────────────────────── 🐙 complexipy 0.3.0 ──────────────────────────────
+───────────────────────────── 🐙 complexipy 0.3.2 ──────────────────────────────
                                     Summary
       ┏━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
       ┃ Path              ┃ File              ┃ Function    ┃ Complexity ┃

{complexipy-0.3.0 → complexipy-0.3.2}/README.md

@@ -47,7 +47,7 @@ Made with [contributors-img](https://contrib.rocks)
 
 ## Requirements
 
-- Python >= 3.11
+- Python >= 3.8
 - You also need to install `git` in your computer if you want to analyze a git repository.
 
 ## Installation
@@ -61,16 +61,17 @@ pip install complexipy
 To run **complexipy** you can use the following command:
 
 ```shell
-complexipy .                         # Use complexipy to analyze the current directory and any subdirectories
-complexipy path/to/directory         # Use complexipy to analyze a specific directory and any subdirectories
-complexipy git_repository_url        # Use complexipy to analyze a git repository
-complexipy path/to/file.py           # Use complexipy to analyze a specific file
-complexipy path/to/file.py -c 20     # Use the -c option to set the maximum congnitive complexity, default is 15
-complexipy path/to/directory -c 0    # Set the maximum cognitive complexity to 0 to disable the exit with error
-complexipy path/to/directory -o      # Use the -o option to output the results to a CSV file, default is False
-complexipy path/to/directory -d low  # Use the -d option to set detail level, default is "normal". If set to "low" will show only files with complexity greater than the maximum complexity
-complexipy path/to/directory -l file # Use the -l option to set the level of measurement, default is "function". If set to "file" will measure the complexity of the file and will validate the maximum complexity according to the file complexity.
-complexipy path/to/directory -q     # Use the -q option to disable the output to the console, default is False.
+complexipy .                            # Use complexipy to analyze the current directory and any subdirectories
+complexipy path/to/directory            # Use complexipy to analyze a specific directory and any subdirectories
+complexipy git_repository_url           # Use complexipy to analyze a git repository
+complexipy path/to/file.py              # Use complexipy to analyze a specific file
+complexipy path/to/file.py -c 20        # Use the -c option to set the maximum congnitive complexity, default is 15
+complexipy path/to/directory -c 0       # Set the maximum cognitive complexity to 0 to disable the exit with error
+complexipy path/to/directory -o         # Use the -o option to output the results to a CSV file, default is False
+complexipy path/to/directory -d low     # Use the -d option to set detail level, default is "normal". If set to "low" will show only files with complexity greater than the maximum complexity
+complexipy path/to/directory -l file    # Use the -l option to set the level of measurement, default is "function". If set to "file" will measure the complexity of the file and will validate the maximum complexity according to the file complexity.
+complexipy path/to/directory -q         # Use the -q option to disable the output to the console, default is False.
+complexipy path/to/directory -s desc    # Use the -s option to set the sort order, default is "asc". If set to "desc" will sort the results in descending order. If set to "asc" will sort the results in ascending order. If set to "name" will sort the results by name.
 ```
 
 ### Options
@@ -81,7 +82,7 @@ complexipy path/to/directory -q     # Use the -q option to disable the output to
   If set to 0, the exit with error will be disabled.
 - `-o` or `--output`: Output the results to a CSV file, default is False. The
   filename will be `complexipy.csv` and will be saved in the invocation directory.
-- `-d` or `--detail`: Set the detail level, default is "normal". If set to "low"
+- `-d` or `--details`: Set the detail level, default is "normal". If set to "low"
   will show only files or functions with complexity greater than the maximum
   complexity.
 - `-l` or `--level` Set the level of measurement, default is "function". If set
@@ -92,6 +93,10 @@ complexipy path/to/directory -q     # Use the -q option to disable the output to
   a maximum complexity according for each file or for each function in the file
   (or files).
 - `-q` or `--quiet`: Disable the output to the console, default is False.
+- `-s` or `--sort`: Set the sort order, default is "asc". If set to "desc" will
+  sort the results in descending order. If set to "asc" will sort the results in
+  ascending order. If set to "name" will sort the results by name. This option will
+  affect the output to the console and the output to the CSV file.
 
 If the cognitive complexity of a file or a function is greater than the maximum
 cognitive cognitive complexity, then the return code will be 1 and exit with
@@ -121,7 +126,7 @@ The cognitive complexity of the file is 1, and the output of the command
 `complexipy path/to/file.py` will be:
 
 ```txt
-───────────────────────────── 🐙 complexipy 0.3.0 ──────────────────────────────
+───────────────────────────── 🐙 complexipy 0.3.2 ──────────────────────────────
                                     Summary
       ┏━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
       ┃ Path              ┃ File              ┃ Function    ┃ Complexity ┃

{complexipy-0.3.0 → complexipy-0.3.2}/complexipy/main.py

@@ -1,6 +1,7 @@
 from .types import (
     DetailTypes,
     Level,
+    Sort,
 )
 from .utils import (
     output_summary,
@@ -27,7 +28,7 @@ import typer
 root_dir = Path(__file__).resolve().parent.parent
 app = typer.Typer(name="complexipy")
 console = Console()
-version = "0.3.0"
+version = "0.3.2"
 
 
 @app.command()
@@ -59,6 +60,12 @@ def main(
     quiet: bool = typer.Option(
         False, "--quiet", "-q", help="Suppress the output to the console."
     ),
+    sort: Sort = typer.Option(
+        Sort.asc.value,
+        "--sort",
+        "-s",
+        help="Sort the output by complexity, it can be 'asc', 'desc' or 'name'. Default is 'asc'.",
+    ),
 ):
     is_dir = Path(path).is_dir()
     _url_pattern = (
@@ -77,22 +84,25 @@ def main(
     output_csv_path = f"{invocation_path}/complexipy.csv"
 
     if output and file_level:
-        rust.output_csv_file_level(output_csv_path, files)
+        rust.output_csv_file_level(output_csv_path, files, sort.value)
         console.print(f"Results saved in {output_csv_path}")
     if output and not file_level:
-        rust.output_csv_function_level(output_csv_path, files)
+        rust.output_csv_function_level(output_csv_path, files, sort.value)
         console.print(f"Results saved in {output_csv_path}")
 
     # Summary
     if not quiet:
         has_success = output_summary(
-            console, file_level, files, max_complexity, details, path, execution_time
+            console, file_level, files, max_complexity, details, path, sort
         )
     if quiet and not file_level:
         has_success = has_success_function_level(files, max_complexity)
     if quiet and file_level:
         has_success = has_success_file_level(files, max_complexity)
 
+    console.print(
+        f"{len(files)} file{'s' if len(files)> 1 else ''} analyzed in {execution_time:.4f} seconds"
+    )
     console.rule(":tada: Analysis completed! :tada:")
 
     if not has_success:

{complexipy-0.3.0 → complexipy-0.3.2}/complexipy/types.py

@@ -9,3 +9,9 @@ class DetailTypes(Enum):
 class Level(Enum):
     function = "function"
     file = "file"
+
+
+class Sort(Enum):
+    asc = "asc"
+    desc = "desc"
+    name = "name"

{complexipy-0.3.0 → complexipy-0.3.2}/complexipy/utils.py

@@ -1,8 +1,10 @@
 from .types import (
     DetailTypes,
+    Sort,
 )
 from complexipy.rust import (
     FileComplexity,
+    FunctionComplexity,
 )
 from rich.align import (
     Align,
@@ -20,27 +22,28 @@ def output_summary(
     max_complexity: int,
     details: DetailTypes,
     path: str,
-    execution_time: float,
+    sort: Sort,
 ) -> bool:
     if file_level:
         table, has_success, total_complexity = create_table_file_level(
-            files, max_complexity, details
+            files, max_complexity, details, sort
         )
     else:
         table, has_success, total_complexity = create_table_function_level(
-            files, max_complexity, details
+            files, max_complexity, details, sort
         )
-    console.print(Align.center(table))
+
+    if details == DetailTypes.low and table.row_count < 1:
+        console.print(f"No {'file' if file_level else 'function'}{'s' if len(files) > 1 else ''} were found with complexity greater than {max_complexity}.")
+    else:
+        console.print(Align.center(table))
     console.print(f":brain: Total Cognitive Complexity in {path}: {total_complexity}")
-    console.print(
-        f"{len(files)} file{'s' if len(files)> 1 else ''} analyzed in {execution_time:.4f} seconds"
-    )
 
     return has_success
 
 
 def create_table_file_level(
-    files: list[FileComplexity], max_complexity: int, details: DetailTypes
+    files: list[FileComplexity], max_complexity: int, details: DetailTypes, sort: Sort
 ) -> tuple[Table, bool, int]:
     has_success = True
 
@@ -51,6 +54,13 @@ def create_table_file_level(
     table.add_column("File")
     table.add_column("Complexity")
     total_complexity = 0
+
+    if sort != Sort.name:
+        files.sort(key=lambda x: x.complexity)
+
+        if sort == Sort.desc:
+            files.reverse()
+
     for file in files:
         total_complexity += file.complexity
         if file.complexity > max_complexity and max_complexity != 0:
@@ -70,9 +80,14 @@ def create_table_file_level(
 
 
 def create_table_function_level(
-    files: list[FileComplexity], complexity: int, details: DetailTypes
+    files: list[FileComplexity],
+    complexity: int,
+    details: DetailTypes,
+    sort: bool = False,
 ) -> tuple[Table, bool, int]:
     has_success = True
+    all_functions: list[tuple[str, str, FunctionComplexity]] = []
+    total_complexity = 0
 
     table = Table(
         title="Summary", show_header=True, header_style="bold magenta", show_lines=True
@@ -81,26 +96,35 @@ def create_table_function_level(
     table.add_column("File")
     table.add_column("Function")
     table.add_column("Complexity")
-    total_complexity = 0
+
     for file in files:
         total_complexity += file.complexity
         for function in file.functions:
             total_complexity += function.complexity
-            if function.complexity > complexity and complexity != 0:
-                table.add_row(
-                    f"{file.path}",
-                    f"[green]{file.file_name}[/green]",
-                    f"[green]{function.name}[/green]",
-                    f"[red]{function.complexity}[/red]",
-                )
-                has_success = False
-            elif details != DetailTypes.low or complexity == 0:
-                table.add_row(
-                    f"{file.path}",
-                    f"[green]{file.file_name}[/green]",
-                    f"[green]{function.name}[/green]",
-                    f"[blue]{function.complexity}[/blue]",
-                )
+            all_functions.append((file.path, file.file_name, function))
+
+    if sort != Sort.name:
+        all_functions.sort(key=lambda x: x[2].complexity)
+
+        if sort == Sort.desc:
+            all_functions.reverse()
+
+    for function in all_functions:
+        if function[2].complexity > complexity and complexity != 0:
+            table.add_row(
+                f"{function[0]}",
+                f"[green]{function[1]}[/green]",
+                f"[green]{function[2].name}[/green]",
+                f"[red]{function[2].complexity}[/red]",
+            )
+            has_success = False
+        elif details != DetailTypes.low or complexity == 0:
+            table.add_row(
+                f"{function[0]}",
+                f"[green]{function[1]}[/green]",
+                f"[green]{function[2].name}[/green]",
+                f"[blue]{function[2].complexity}[/blue]",
+            )
     return table, has_success, total_complexity
 
 

{complexipy-0.3.0 → complexipy-0.3.2}/docs/index.md

@@ -47,7 +47,7 @@ Made with [contributors-img](https://contrib.rocks)
 
 ## Requirements
 
-- Python >= 3.11
+- Python >= 3.8
 - You also need to install `git` in your computer if you want to analyze a git repository.
 
 ## Installation
@@ -61,16 +61,17 @@ pip install complexipy
 To run **complexipy** you can use the following command:
 
 ```shell
-complexipy .                         # Use complexipy to analyze the current directory and any subdirectories
-complexipy path/to/directory         # Use complexipy to analyze a specific directory and any subdirectories
-complexipy git_repository_url        # Use complexipy to analyze a git repository
-complexipy path/to/file.py           # Use complexipy to analyze a specific file
-complexipy path/to/file.py -c 20     # Use the -c option to set the maximum congnitive complexity, default is 15
-complexipy path/to/directory -c 0    # Set the maximum cognitive complexity to 0 to disable the exit with error
-complexipy path/to/directory -o      # Use the -o option to output the results to a CSV file, default is False
-complexipy path/to/directory -d low  # Use the -d option to set detail level, default is "normal". If set to "low" will show only files with complexity greater than the maximum complexity
-complexipy path/to/directory -l file # Use the -l option to set the level of measurement, default is "function". If set to "file" will measure the complexity of the file and will validate the maximum complexity according to the file complexity.
-complexipy path/to/directory -q     # Use the -q option to disable the output to the console, default is False.
+complexipy .                            # Use complexipy to analyze the current directory and any subdirectories
+complexipy path/to/directory            # Use complexipy to analyze a specific directory and any subdirectories
+complexipy git_repository_url           # Use complexipy to analyze a git repository
+complexipy path/to/file.py              # Use complexipy to analyze a specific file
+complexipy path/to/file.py -c 20        # Use the -c option to set the maximum congnitive complexity, default is 15
+complexipy path/to/directory -c 0       # Set the maximum cognitive complexity to 0 to disable the exit with error
+complexipy path/to/directory -o         # Use the -o option to output the results to a CSV file, default is False
+complexipy path/to/directory -d low     # Use the -d option to set detail level, default is "normal". If set to "low" will show only files with complexity greater than the maximum complexity
+complexipy path/to/directory -l file    # Use the -l option to set the level of measurement, default is "function". If set to "file" will measure the complexity of the file and will validate the maximum complexity according to the file complexity.
+complexipy path/to/directory -q         # Use the -q option to disable the output to the console, default is False.
+complexipy path/to/directory -s desc    # Use the -s option to set the sort order, default is "asc". If set to "desc" will sort the results in descending order. If set to "asc" will sort the results in ascending order. If set to "name" will sort the results by name.
 ```
 
 ### Options
@@ -81,7 +82,7 @@ complexipy path/to/directory -q     # Use the -q option to disable the output to
   If set to 0, the exit with error will be disabled.
 - `-o` or `--output`: Output the results to a CSV file, default is False. The
   filename will be `complexipy.csv` and will be saved in the invocation directory.
-- `-d` or `--detail`: Set the detail level, default is "normal". If set to "low"
+- `-d` or `--details`: Set the detail level, default is "normal". If set to "low"
   will show only files or functions with complexity greater than the maximum
   complexity.
 - `-l` or `--level` Set the level of measurement, default is "function". If set
@@ -92,6 +93,10 @@ complexipy path/to/directory -q     # Use the -q option to disable the output to
   a maximum complexity according for each file or for each function in the file
   (or files).
 - `-q` or `--quiet`: Disable the output to the console, default is False.
+- `-s` or `--sort`: Set the sort order, default is "asc". If set to "desc" will
+  sort the results in descending order. If set to "asc" will sort the results in
+  ascending order. If set to "name" will sort the results by name. This option will
+  affect the output to the console and the output to the CSV file.
 
 If the cognitive complexity of a file or a function is greater than the maximum
 cognitive cognitive complexity, then the return code will be 1 and exit with
@@ -121,7 +126,7 @@ The cognitive complexity of the file is 1, and the output of the command
 `complexipy path/to/file.py` will be:
 
 ```txt
-───────────────────────────── 🐙 complexipy 0.3.0 ──────────────────────────────
+───────────────────────────── 🐙 complexipy 0.3.2 ──────────────────────────────
                                     Summary
       ┏━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
       ┃ Path              ┃ File              ┃ Function    ┃ Complexity ┃

{complexipy-0.3.0 → complexipy-0.3.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "complexipy"
 keywords = ["cognitive", "complexity", "cognitive complexity", "rust", "fast"]
-requires-python = ">=3.11"
+requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",

{complexipy-0.3.0 → complexipy-0.3.2}/src/cognitive_complexity/mod.rs

@@ -271,7 +271,12 @@ fn statement_cognitive_complexity(statement: Stmt, nesting_level: u64) -> PyResu
             }
         }
         Stmt::Assign(a) => {
-            complexity += count_bool_ops(*a.value);
+            match *a.value {
+                ast::Expr::IfExp(..) => {
+                    complexity += count_bool_ops(*a.value);
+                }
+                _ => {}
+            }
 
             if complexity > 0 {
                 complexity += nesting_level;

{complexipy-0.3.0 → complexipy-0.3.2}/src/cognitive_complexity/utils.rs

@@ -1,44 +1,95 @@
-use crate::classes::FileComplexity;
+use crate::classes::{FileComplexity, FunctionComplexity};
 use csv::Writer;
 use pyo3::prelude::*;
 use rustpython_parser::ast::{self, Stmt};
 
 #[pyfunction]
-pub fn output_csv_file_level(invocation_path: &str, files_complexity: Vec<FileComplexity>) {
+pub fn output_csv_file_level(
+    invocation_path: &str,
+    files_complexity: Vec<FileComplexity>,
+    sort: &str,
+) {
     let mut writer = Writer::from_path(invocation_path).unwrap();
 
     writer
         .write_record(&["Path", "File Name", "Cognitive Complexity"])
         .unwrap();
 
-    for file in files_complexity {
-        writer
-            .write_record(&[&file.path, &file.file_name, &file.complexity.to_string()])
-            .unwrap();
+    if sort != "name" {
+        let mut files_complexity = files_complexity;
+
+        files_complexity.sort_by_key(|f| f.complexity);
+
+        if sort == "desc" {
+            files_complexity.reverse();
+        }
+
+        for file in files_complexity.into_iter() {
+            writer
+                .write_record(&[&file.path, &file.file_name, &file.complexity.to_string()])
+                .unwrap();
+        }
+    } else {
+        for file in &files_complexity {
+            writer
+                .write_record(&[&file.path, &file.file_name, &file.complexity.to_string()])
+                .unwrap();
+        }
     }
 
     writer.flush().unwrap();
 }
 
 #[pyfunction]
-pub fn output_csv_function_level(invocation_path: &str, functions_complexity: Vec<FileComplexity>) {
+pub fn output_csv_function_level(
+    invocation_path: &str,
+    functions_complexity: Vec<FileComplexity>,
+    sort: &str,
+) {
     let mut writer = Writer::from_path(invocation_path).unwrap();
 
     writer
         .write_record(&["Path", "File Name", "Function Name", "Cognitive Complexity"])
         .unwrap();
 
-    for file in functions_complexity {
-        for function in file.functions {
+    if sort != "name" {
+        let mut all_functions: Vec<(String, String, FunctionComplexity)> = vec![];
+
+        for file in functions_complexity {
+            for function in file.functions {
+                all_functions.push((file.path.clone(), file.file_name.clone(), function));
+            }
+        }
+
+        all_functions.sort_by_key(|f| f.2.complexity);
+
+        if sort == "desc" {
+            all_functions.reverse();
+        }
+
+        for (path, file_name, function) in all_functions.into_iter() {
             writer
                 .write_record(&[
-                    &file.path,
-                    &file.file_name,
+                    &path,
+                    &file_name,
                     &function.name,
                     &function.complexity.to_string(),
                 ])
                 .unwrap();
         }
+    } else {
+        for file in functions_complexity {
+            for function in file.functions {
+                writer
+                    .write_record(&[
+                        &file.path,
+                        &file.file_name,
+                        &function.name,
+                        &function.complexity.to_string(),
+                    ])
+                    .unwrap();
+            }
+        }
     }
 
     writer.flush().unwrap();
@@ -83,16 +134,13 @@ pub fn count_bool_ops(expr: ast::Expr) -> u64 {
     let mut complexity: u64 = 0;
 
     match expr {
-        ast::Expr::BoolOp(..) => {
-            complexity += 1;
-        }
-        ast::Expr::BinOp(b) => {
+        ast::Expr::BoolOp(b) => {
             complexity += 1;
-            complexity += count_bool_ops(*b.left);
-            complexity += count_bool_ops(*b.right);
+            for value in b.values.iter() {
+                complexity += count_bool_ops(value.clone());
+            }
         }
         ast::Expr::UnaryOp(u) => {
-            complexity += 1;
             complexity += count_bool_ops(*u.operand);
         }
         ast::Expr::Compare(c) => {