Simplify Implementation + Minor Document

.vscode/settings.json

@@ -5,8 +5,19 @@
     "python.testing.pytestArgs": [
         "tests"
     ],
+    "python.formatting.provider": "black",
+    "python.formatting.blackPath": "${workspaceRoot}/__pypackages__/3.10/Scripts/black",
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
-    "python.autoComplete.extraPaths": ["__pypackages__/<major.minor>/lib"],
-    "python.analysis.extraPaths": ["__pypackages__/<major.minor>/lib"]
+    "python.autoComplete.extraPaths": [
+        "__pypackages__/3.10/lib"
+    ],
+    "python.analysis.extraPaths": [
+        "__pypackages__/3.10/lib"
+    ],
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+        "source.organizeImports": true
+    },
+    "python.analysis.typeCheckingMode": "basic"
 }

cppython/exceptions.py

@@ -4,11 +4,21 @@
 
 
 class ConfigError(Exception):
-    def __init__(self, error: Exception) -> None:
+    """
+    Raised when there is a configuration error
+    """
+
+    def __init__(self, error: str) -> None:
         self._error = error
 
-        super().__init__(str(error))
+        super().__init__(error)
 
     @property
-    def error(self) -> Exception:
+    def error(self) -> str:
+        """
+        Returns the underlying error
+
+        Returns:
+            str -- The underlying error
+        """
         return self._error

cppython/plugins/generator/cmake.py

@@ -1,44 +1,45 @@
-from cppython.schema import Generator, Metadata
+"""
+The default generator implementation for CPPython
+"""
+from typing import Type
 
+from cppython.schema import Generator, GeneratorData, PyProject
 
-class CMakeGenerator(Generator):
+
+class CMakeData(GeneratorData):
     """
-    A CPPython generator implementing a CMake backend
+    The data schema required for the CMake tooling
     """
 
-    def __init__(self) -> None:
-        pass
 
+class CMakeGenerator(Generator):
     """
-    Plugin Contract
+    A CPPython generator implementing a CMake backend
     """
 
+    def __init__(self, pyproject: PyProject, cmake_data: CMakeData) -> None:
+        super().__init__(pyproject, cmake_data)
+
     @staticmethod
     def name() -> str:
         """
         The name of the generator
         """
         return "cmake"
 
-    """
-    Generator Contract
-    """
-
-    def populate_metadata(self, data: dict):
+    @staticmethod
+    def data_type() -> Type[GeneratorData]:
         """
-        data - The CPPoetry data taken from pyproject.toml
+        Returns the pydantic type to cast the generator configuration data to
         """
-        pass
+        return CMakeData
 
-    def populate_plugin(self, data: dict):
+    def install_generator(self) -> bool:
         """
-        data - The data taken from pyproject.toml that belongs to this generator
+        Installs the external tooling required by the generator if necessary
+        Returns whether anything was installed or not
         """
-        pass
-
-    """
-    API Contract
-    """
+        return False
 
     def install(self) -> None:
         raise NotImplementedError()

cppython/plugins/interface/console.py

@@ -1,119 +1,112 @@
-from cppython.project import Project
-from cppython.schema import Interface, PEP621
+"""
+A click CLI for CPPython interfacing
+"""
+
 from pathlib import Path
+from typing import Type
 
 import click
 import tomlkit
 
+from cppython.project import Project
+from cppython.schema import GeneratorData, GeneratorDataType, Interface, PyProject
+
+
+def _create_pyproject():
 
-def _read_data():
+    # Search for a path upward
     path = Path.cwd()
 
     while not path.glob("pyproject.toml"):
         if path.is_absolute():
             assert (
-                "This is not a valid project. No pyproject.toml found in the current directory or any of its parents."
-            )
+                False
+            ), "This is not a valid project. No pyproject.toml found in the current directory or any of its parents."
 
-    return tomlkit.loads(Path(path / "pyproject.toml").read_text(encoding="utf-8"))
+    path = Path(path / "pyproject.toml")
 
+    # Load file
+    data = tomlkit.loads(path.read_text(encoding="utf-8"))
 
-class Config(object):
+    # Interpret and validate data
+    return PyProject(**data)
+
+
+class Config:
     """
     The data object that will be expanded alongside 'pass_obj'
     """
 
     def __init__(self):
-
-        data = _read_data()
+        pyproject = _create_pyproject()
 
         # Initialize the object hook into CPPython
-        interface = ConsoleInterface(data)
+        interface = ConsoleInterface(pyproject)
 
         # Initialize the CPPython context
         self.project = Project(interface)
 
-    def load(self):
-        self.project.load()
-
 
 pass_config = click.make_pass_decorator(Config)
 
 
 @click.group()
 @click.pass_context
 def cli(context):
+    """
+    entry_point group for the CLI commands
+    """
     context.ensure_object(Config)
 
-    # Initialize cppython
-    context.obj.load()
-
 
 @cli.command()
 @pass_config
 def install(config):
+    """
+    Fulfills the 'install' API requirement
+    """
     config.project.install()
 
 
 @cli.command()
 @pass_config
 def update(config):
+    """
+    Fulfills the 'update' API requirement
+    """
     config.project.update()
 
 
-@cli.result_callback()
+@cli.command()
 @pass_config
-def cleanup(config, result):
-    pass
-
-
-class ConsoleInterface(Interface):
+def build(config):
     """
-    TODO: Description
+    Fulfills the 'build' API requirement
     """
+    config.project.build()
 
-    def __init__(self, data: dict) -> None:
-        self._data = data
 
+@cli.result_callback()
+@pass_config
+def cleanup(config, result):
     """
-    Plugin Contract
+    Post-command cleanup
     """
 
-    @staticmethod
-    def name() -> str:
-        """
-        The name of the generator
-        """
-        return "console"
 
+class ConsoleInterface(Interface):
     """
-    Interface Contract
+    Interface implementation to pass to the project
     """
 
-    @staticmethod
-    def external_config() -> bool:
-        """
-        True if the plugin can read its own configuration.
-        False otherwise
-        """
-
-        return False
-
-    @staticmethod
-    def parse_pep_621(data: dict) -> PEP621:
+    def read_generator_data(self, generator_data_type: Type[GeneratorDataType]) -> GeneratorDataType:
         """
-        Requests the plugin to read the available PEP 621 information. Only requested if the plugin is not the entrypoint
+        Requests generator information
         """
-        raise NotImplementedError()
+        return generator_data_type()
 
-    def pep_621(self) -> PEP621:
+    def write_pyproject(self) -> None:
         """
-        Requests PEP 621 information from the pyproject
+        Write output
         """
-        return self.parse_pep_621(self._data)
-
-    def write_pyproject(self) -> None:
-        raise NotImplementedError()
-
-    def read_pyproject(self) -> dict:
-        return self._data
+        pass

cppython/plugins/test/data.py

@@ -0,0 +1,15 @@
+"""
+Defaulted data to help testing
+"""
+
+from pathlib import Path
+
+from cppython.schema import PEP621, CPPythonData, PyProject, TargetEnum
+
+default_pep621 = PEP621(name="test_name", version="1.0")
+
+# CMake is a default plugin
+# TODO: Provide dynamic default
+default_cppython_data = CPPythonData(generator="cmake", target=TargetEnum.EXE, install_path=Path())
+
+default_pyproject = PyProject(pep_621=default_pep621, cppython_data=default_cppython_data)