feat: add compile commands parsing

Author: cuinixam

src/py_app_dev/core/compile_commands.py

@@ -0,0 +1,126 @@
+import io
+import json
+import traceback
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import ClassVar, List, Optional
+
+from mashumaro import DataClassDictMixin
+from mashumaro.config import TO_DICT_ADD_OMIT_NONE_FLAG, BaseConfig
+from mashumaro.mixins.json import DataClassJSONMixin
+from mashumaro.types import SerializableType
+
+from .exceptions import UserNotificationException
+
+
+class PathField(SerializableType):
+    def _serialize(self) -> str:
+        return str(self)
+
+    @classmethod
+    def _deserialize(cls, value: str) -> Path:
+        return Path(value)
+
+
+@dataclass
+class CompileCommand(DataClassDictMixin):
+    directory: Path
+    file: Path
+    arguments: List[str] = field(default_factory=list)
+    command: Optional[str] = None
+    output: Optional[Path] = None
+
+    def get_compile_options(self) -> List[str]:
+        options = []
+        if self.arguments:
+            options = self.arguments
+        if self.command:
+            options = self.command.split()
+        return self.clean_up_arguments(options)
+
+    def get_file_path(self) -> Path:
+        return self.file if self.file.is_absolute() else self.directory / self.file
+
+    def clean_up_arguments(self, arguments: List[str]) -> List[str]:
+        """
+        Clean up the command line to only get the compilation options.
+
+        Ignore the first argument which is the compiler.
+        Remove the options for the output and input files.
+        Any arguments containing the input or output file names or paths are removed.
+        For example: -DStuff -ISome/Path -o output.o input.c -> -DStuff -ISome/Path
+        """
+        cleaned_args = []
+        skip_next = False
+        input_filename = self.file.name
+        output_filename = self.output.name if self.output else None
+
+        for arg in arguments[1:]:  # Skip the first argument (compiler)
+            if skip_next:
+                skip_next = False
+                continue
+
+            # Skip -o and its value
+            if arg == "-o":
+                skip_next = True
+                continue
+
+            # Skip -c option
+            if arg == "-c":
+                continue
+
+            # Skip arguments containing input or output file names or paths
+            if input_filename in arg or (output_filename and output_filename in arg):
+                continue
+
+            # Keep all other arguments
+            cleaned_args.append(arg)
+
+        return cleaned_args
+
+
+@dataclass
+class CompilationDatabase(DataClassJSONMixin):
+    commands: List[CompileCommand]
+
+    def getCompileCommands(self, file: Path) -> List[CompileCommand]:
+        return [command for command in self.commands if command.get_file_path() == file]
+
+    class Config(BaseConfig):
+        """Custom configuration for the dataclass serialization to ignore None values."""
+
+        code_generation_options: ClassVar[List[str]] = [TO_DICT_ADD_OMIT_NONE_FLAG]
+
+    @classmethod
+    def from_json_file(cls, file_path: Path) -> "CompilationDatabase":
+        try:
+            result = cls.from_dict({"commands": json.loads(file_path.read_text())})
+        except Exception as e:
+            output = io.StringIO()
+            traceback.print_exc(file=output)
+            raise UserNotificationException(output.getvalue()) from e
+        return result
+
+    def to_json_string(self) -> str:
+        return json.dumps(self.to_dict(omit_none=True), indent=2)
+
+    def to_json_file(self, file_path: Path) -> None:
+        file_path.write_text(self.to_json_string())
+
+
+class CompilationOptionsManager:
+    def __init__(self, compilation_database: Optional[Path] = None, no_default: bool = False):
+        self.compilation_database: Optional[CompilationDatabase] = CompilationDatabase.from_json_file(compilation_database) if compilation_database else None
+        self.no_default = no_default
+        self.default_options = ["-std=c11"]
+
+    def get_compile_options(self, file: Path) -> List[str]:
+        if self.compilation_database:
+            commands: List[CompileCommand] = self.compilation_database.getCompileCommands(file)
+            # TODO: how to handle multiple commands for the same file?
+            if commands:
+                return commands[0].get_compile_options()
+        return [] if self.no_default else self.default_options
+
+    def set_default_options(self, options: List[str]) -> None:
+        self.default_options = options

tests/test_compile_commands.py

@@ -0,0 +1,155 @@
+import json
+from pathlib import Path
+from typing import Generator
+
+import pytest
+
+from py_app_dev.core.compile_commands import CompilationDatabase, CompilationOptionsManager, CompileCommand
+
+
+@pytest.fixture
+def temp_compilation_database(tmp_path: Path) -> Generator[Path, None, None]:
+    db_content = [
+        {"directory": tmp_path.as_posix(), "file": "test1.c", "arguments": ["gcc", "-I/usr/include", "-DDEBUG", "test1.c"]},
+        {"directory": tmp_path.as_posix(), "file": "test2.c", "command": "gcc -c -O2 test2.c"},
+    ]
+    db_file = tmp_path / "compile_commands.json"
+    db_file.write_text(json.dumps(db_content))
+    yield db_file
+
+
+def test_compilation_options_manager_without_database() -> None:
+    manager = CompilationOptionsManager()
+    assert manager.get_compile_options(Path("any_file.c")) == ["-std=c11"]
+
+
+def test_compilation_options_manager_with_database(temp_compilation_database: Path) -> None:
+    manager = CompilationOptionsManager(temp_compilation_database)
+
+    # Test for file in the database
+    test1_path = Path(temp_compilation_database.parent) / "test1.c"
+    options = manager.get_compile_options(test1_path)
+    assert options == ["-I/usr/include", "-DDEBUG"]
+
+    # Test for file in the database with command string
+    test2_path = Path(temp_compilation_database.parent) / "test2.c"
+    options = manager.get_compile_options(test2_path)
+    assert options == ["-O2"]
+
+    # Test for file not in the database
+    not_in_db_path = Path(temp_compilation_database.parent) / "not_in_db.c"
+    options = manager.get_compile_options(not_in_db_path)
+    assert options == ["-std=c11"]
+
+
+def test_compilation_options_manager_no_default() -> None:
+    manager = CompilationOptionsManager(no_default=True)
+    options = manager.get_compile_options(Path("any_file.c"))
+    assert options == []
+
+
+def test_set_default_options() -> None:
+    manager = CompilationOptionsManager()
+    new_defaults = ["-std=c99", "-Wall"]
+    manager.set_default_options(new_defaults)
+    assert manager.get_compile_options(Path("any_file.c")) == new_defaults
+
+
+def test_compilation_database_from_json() -> None:
+    json_data = """
+    [
+        {
+            "directory": "/home/user/project",
+            "file": "main.c",
+            "arguments": ["gcc", "-c", "-I/usr/include", "main.c"]
+        }
+    ]
+    """
+    tmp_file = Path("temp_compile_commands.json")
+    tmp_file.write_text(json_data)
+
+    try:
+        db = CompilationDatabase.from_json_file(tmp_file)
+        assert len(db.commands) == 1
+        assert db.commands[0].directory == Path("/home/user/project")
+        assert db.commands[0].file == Path("main.c")
+        assert db.commands[0].arguments == ["gcc", "-c", "-I/usr/include", "main.c"]
+    finally:
+        tmp_file.unlink()
+
+
+def test_get_compile_commands() -> None:
+    json_data = """
+    [
+        {
+            "directory": "/home/user/project",
+            "file": "main.c",
+            "arguments": ["gcc", "-c", "-I/usr/include", "main.c"]
+        },
+        {
+            "directory": "/home/user/project",
+            "file": "helper.c",
+            "command": "gcc -c -O2 helper.c"
+        }
+    ]
+    """
+    tmp_file = Path("temp_compile_commands.json")
+    tmp_file.write_text(json_data)
+
+    try:
+        db = CompilationDatabase.from_json_file(tmp_file)
+        commands = db.getCompileCommands(Path("/home/user/project/main.c"))
+        assert len(commands) == 1
+        assert commands[0].file == Path("main.c")
+        assert commands[0].arguments == ["gcc", "-c", "-I/usr/include", "main.c"]
+
+        commands = db.getCompileCommands(Path("/home/user/project/helper.c"))
+        assert len(commands) == 1
+        assert commands[0].file == Path("helper.c")
+        assert commands[0].command == "gcc -c -O2 helper.c"
+
+        commands = db.getCompileCommands(Path("/home/user/project/nonexistent.c"))
+        assert len(commands) == 0
+    finally:
+        tmp_file.unlink()
+
+
+@pytest.fixture
+def compile_command():
+    return CompileCommand(directory=Path("/home/user/project"), file=Path("/home/user/project/input.c"), output=Path("/home/user/project/output.o"))
+
+
+def test_clean_up_arguments_basic(compile_command):
+    arguments = ["gcc", "-DStuff", "-ISome/Path", "-o", "/home/user/project/output.o", "/home/user/project/input.c"]
+    expected = ["-DStuff", "-ISome/Path"]
+    assert compile_command.clean_up_arguments(arguments) == expected
+
+
+def test_clean_up_arguments_with_c_option(compile_command):
+    arguments = ["gcc", "-DStuff", "-ISome/Path", "-c", "-o", "/home/user/project/output.o", "/home/user/project/input.c"]
+    expected = ["-DStuff", "-ISome/Path"]
+    assert compile_command.clean_up_arguments(arguments) == expected
+
+
+def test_clean_up_arguments_with_combined_options(compile_command):
+    arguments = ["gcc", "-DStuff", "-ISome/Path", "-c", "-o/home/user/project/output.o", "/home/user/project/input.c"]
+    expected = ["-DStuff", "-ISome/Path"]
+    assert compile_command.clean_up_arguments(arguments) == expected
+
+
+def test_clean_up_arguments_with_multiple_input_files(compile_command):
+    arguments = ["gcc", "-DStuff", "-ISome/Path", "-c", "/home/user/project/input.c", "/home/user/project/helper.c", "-o", "/home/user/project/output.o"]
+    expected = ["-DStuff", "-ISome/Path", "/home/user/project/helper.c"]
+    assert compile_command.clean_up_arguments(arguments) == expected
+
+
+def test_clean_up_arguments_with_complex_options(compile_command):
+    arguments = ["gcc", "-DStuff", "-ISome/Path", "-Werror", "-Wall", "-std=c11", '-DVERSION="1.0"', "-c", "/home/user/project/input.c", "-o", "/home/user/project/output.o"]
+    expected = ["-DStuff", "-ISome/Path", "-Werror", "-Wall", "-std=c11", '-DVERSION="1.0"']
+    assert compile_command.clean_up_arguments(arguments) == expected
+
+
+def test_clean_up_arguments_with_partial_paths(compile_command):
+    arguments = ["gcc", "-DStuff", "-I/home/user/project", "-Werror", "-Wall", "-c", "project/input.c", "-o", "project/output.o"]
+    expected = ["-DStuff", "-I/home/user/project", "-Werror", "-Wall"]
+    assert compile_command.clean_up_arguments(arguments) == expected