Use external software to compare metrics

The two software now used to compare metrics are written in Rust and
provide a considerable speed up on large repositories.

Author: Luni-4

check-submodule.py

@@ -17,26 +17,23 @@
 
 ./check-submodule.py compute-ci-metrics -p LOCAL_DIR -l TREE_SITTER_LANGUAGE
 
+To compare metrics and retrieve the structural JSON of differences
+in addition to the files containing the minimal tests:
 
-To compare metrics and retrieve minimal tests:
-
-1. Install deepdiff: pip install deepdiff
+1. Install json-diff from here: https://github.com/Luni-4/json-diff/releases
+2. Install json-minimal-tests from here: https://github.com/Luni-4/json-minimal-tests/releases
 
 ./check-submodule.py compare-metrics -l TREE_SITTER_LANGUAGE
+
+NOTE: Add the paths of the software above to the PATH environment variable!
 """
 
 import argparse
-import asyncio
-import json
-import math
 import pathlib
-import re
 import subprocess
 import sys
 import typing as T
 
-import deepdiff
-
 # The /tmp directory will be used as workdir
 WORKDIR = pathlib.Path("/tmp")
 # Suffix for the directory containing the old metrics
@@ -69,42 +66,6 @@
     "tree-sitter-python": ["*.py"],
 }
 
-
-class JsonDiff:
-    def __init__(
-        self,
-        old_metrics: T.List[pathlib.Path],
-        new_metrics: T.List[pathlib.Path],
-        compare_dir: pathlib.Path,
-        max_workers: int,
-    ):
-        self.compare_dir = compare_dir
-        self.max_workers = max_workers
-
-        # Max number of file paths in a sublist
-        n = math.ceil(len(old_metrics) / max_workers)
-
-        # Assign a certain number of filepaths to each worker
-        self.workers_filepaths = [
-            zip(old_metrics[i * n : (i + 1) * n], new_metrics[i * n : (i + 1) * n])
-            for i in range((len(old_metrics) + n - 1) // n)
-        ]
-
-    # Run asynchronous comparisons between json files.
-    async def diff(self):
-        # Save minimal tests in the chosen directory.
-        def _worker(worker_list: T.List[pathlib.Path]):
-            for old_filename, new_filename in worker_list:
-
-                # Compute minimal tests
-                compute_minimal_tests(old_filename, new_filename, self.compare_dir)
-
-        # Define the max number of coroutines used to compare json files
-        await asyncio.gather(
-            *(_worker(worker_filepaths) for worker_filepaths in self.workers_filepaths)
-        )
-
-
 # Run a subprocess.
 def run_subprocess(cmd: str, *args: T.Union[str, pathlib.Path]) -> None:
     subprocess.run([cmd, *args])
@@ -138,106 +99,6 @@ def run_rca(
     )
 
 
-# Find the difference between the two json metric files.
-def get_json_diff(
-    first_file: pathlib.Path, second_file: pathlib.Path
-) -> T.Tuple[T.Dict[str, T.Any], T.Dict[str, T.Any]]:
-    with open(first_file, "r") as input_file:
-        t1 = json.load(input_file)
-
-    with open(second_file, "r") as input_file:
-        t2 = json.load(input_file)
-
-    diff = deepdiff.DeepDiff(t1, t2, ignore_order=True)
-
-    return (t1, diff)
-
-
-# Save the filename and the list of code spans associated to the differences
-# in a dictionary.
-def get_metrics_diff_span(
-    first_json: T.Dict[str, T.Any], diff: T.Dict[str, T.Any]
-) -> T.Dict[str, T.List[T.Tuple[int, int]]]:
-    # Search for this pattern in the differences object
-    prog = re.compile(r"\['spaces'\]\[\d+\]")
-
-    output = {"name": first_json["name"], "spaces_spans": []}
-
-    for value in diff["values_changed"]:
-        val = "".join(prog.findall(value))
-        # Subtracting one because files starts from 0
-        start_line = eval(f'first_json{val}["start_line"]') - 1
-        end_line = eval(f'first_json{val}["end_line"]')
-        output["spaces_spans"].append((start_line, end_line))
-
-    # Print the path of the repository file containing the differences
-    print(first_json["name"])
-
-    return output
-
-
-# Dump minimal tests code in an output file.
-def dump_minimal_tests(
-    code_spans_object: T.Dict[str, T.List[T.Tuple[int, int]]],
-    new_filename: pathlib.Path,
-    compare_dir: pathlib.Path,
-) -> None:
-    # Remove duplicates from the list of spans
-    spans_list = dict.fromkeys(code_spans_object["spaces_spans"])
-
-    # Get filename
-    filename = code_spans_object["name"]
-
-    # Read code spans from the input source code
-    with open(filename, "r", encoding="utf-8", errors="ignore") as input_file:
-        # Decode only utf-8 source code files
-        lines = input_file.readlines()
-
-    # Write spans to output file
-    output_path = compare_dir / new_filename.stem
-    with open(output_path, "w") as output_file:
-        for span in spans_list:
-            output_file.write("Minimal test:\n")
-            output_file.write("".join(lines[span[0] : span[1]]) + "\n")
-
-
-# Compute minimal tests.
-def compute_minimal_tests(
-    old_filename: pathlib.Path, new_filename: pathlib.Path, compare_dir: pathlib.Path
-) -> None:
-    # Find the difference between the two json files with the aim of
-    # getting some minimal tests
-    first_json, diff = get_json_diff(old_filename, new_filename)
-
-    # If two json files are identical, return
-    if not diff:
-        return
-
-    # Retrieve the code spans associated to the differences
-    code_spans_object = get_metrics_diff_span(first_json, diff)
-
-    # Dump the minimal tests retrived from code spans on a file with the
-    # same extension of the analyzed source code
-    dump_minimal_tests(code_spans_object, new_filename, compare_dir)
-
-
-# Save json files of differences and minimal tests in the chosen directory
-# concurrently.
-def save_diff_files(
-    old_dir: pathlib.Path, new_dir: pathlib.Path, compare_dir: pathlib.Path
-) -> None:
-    # Get all metric files in old and new directories
-    old_paths = sorted(pathlib.Path(old_dir).glob("*.json"))
-    new_paths = sorted(pathlib.Path(new_dir).glob("*.json"))
-
-    # Create a new coroutines handler
-    json_diff = JsonDiff(old_paths, new_paths, compare_dir, 4)
-
-    # Find the differences between json files and save the results in a
-    # chosen directory asynchronously
-    asyncio.run(json_diff.diff())
-
-
 # Compute continuous integration metrics before and after a
 # tree-sitter-language update.
 def compute_ci_metrics(args: argparse.Namespace) -> None:
@@ -342,8 +203,13 @@ def compare_metrics(args: argparse.Namespace) -> None:
     # Create compare directory
     compare_dir.mkdir(parents=True, exist_ok=True)
 
-    # Save files of differences and minimal tests in the chosen directory
-    save_diff_files(old_dir, new_dir, compare_dir)
+    # Get JSON of differences
+    print("\nSave JSON of differences in", compare_dir)
+    run_subprocess("json-diff-cli", "--raw-json", "-o", compare_dir, old_dir, new_dir)
+
+    # Get minimal tests
+    print("\nSave minimal tests in", compare_dir)
+    run_subprocess("json-minimal-tests", "-o", compare_dir, old_dir, new_dir)
 
 
 def main() -> None: