Move manifest path & text location into Manifest class

Author: spoorcc

dfetch/commands/check.py

@@ -29,6 +29,7 @@
 import dfetch.project
 from dfetch.commands.common import check_child_manifests
 from dfetch.log import get_logger
+from dfetch.manifest.manifest import Manifest
 from dfetch.reporting.check.code_climate_reporter import CodeClimateReporter
 from dfetch.reporting.check.jenkins_reporter import JenkinsReporter
 from dfetch.reporting.check.reporter import CheckReporter
@@ -83,18 +84,18 @@ def create_menu(subparsers: dfetch.commands.command.SubparserActionType) -> None
 
     def __call__(self, args: argparse.Namespace) -> None:
         """Perform the check."""
-        manifest, path = dfetch.manifest.manifest.get_manifest()
-        reporters = self._get_reporters(args, path)
+        manifest = dfetch.manifest.manifest.get_manifest()
+        reporters = self._get_reporters(args, manifest)
 
-        with in_directory(os.path.dirname(path)):
+        with in_directory(os.path.dirname(manifest.path)):
             exceptions: List[str] = []
             for project in manifest.selected_projects(args.projects):
                 with catch_runtime_exceptions(exceptions) as exceptions:
                     dfetch.project.make(project).check_for_update(reporters)
 
                 if not args.no_recommendations and os.path.isdir(project.destination):
                     with in_directory(project.destination):
-                        check_child_manifests(manifest, project, path)
+                        check_child_manifests(manifest, project)
 
             for reporter in reporters:
                 reporter.dump_to_file()
@@ -103,21 +104,23 @@ def __call__(self, args: argparse.Namespace) -> None:
             raise RuntimeError("\n".join(exceptions))
 
     @staticmethod
-    def _get_reporters(args: argparse.Namespace, path: str) -> List[CheckReporter]:
+    def _get_reporters(
+        args: argparse.Namespace, manifest: Manifest
+    ) -> List[CheckReporter]:
         """Get all reporters.
 
         Args:
             args (argparse.Namespace): Arguments given to the command line
-            path (str): Path to the manifest
+            manifest (Manifest): The manifest
 
         Returns:
             List[CheckReporter]: List of reporters that each provide a unique report
         """
-        reporters: List[CheckReporter] = [CheckStdoutReporter(path)]
+        reporters: List[CheckReporter] = [CheckStdoutReporter(manifest)]
         if args.jenkins_json:
-            reporters += [JenkinsReporter(path, args.jenkins_json)]
+            reporters += [JenkinsReporter(manifest, args.jenkins_json)]
         if args.sarif:
-            reporters += [SarifReporter(path, args.sarif)]
+            reporters += [SarifReporter(manifest, args.sarif)]
         if args.code_climate:
-            reporters += [CodeClimateReporter(path, args.code_climate)]
+            reporters += [CodeClimateReporter(manifest, args.code_climate)]
         return reporters

dfetch/commands/common.py

@@ -12,18 +12,14 @@
 logger = get_logger(__name__)
 
 
-def check_child_manifests(manifest: Manifest, project: ProjectEntry, path: str) -> None:
+def check_child_manifests(manifest: Manifest, project: ProjectEntry) -> None:
     """Check for child manifests within a project.
 
     Args:
         manifest (dfetch.manifest.manifest.Manifest): The parent manifest with projects.
         project (ProjectEntry): The parent project.
-        path (str): The path of the parent manifest.
     """
-    for (
-        childmanifest,
-        childmanifest_path,
-    ) in get_childmanifests(skip=[path]):
+    for childmanifest in get_childmanifests(skip=[manifest.path]):
         recommendations: List[ProjectEntry] = []
         for childproject in childmanifest.projects:
             if childproject.remote_url not in [
@@ -32,10 +28,10 @@ def check_child_manifests(manifest: Manifest, project: ProjectEntry, path: str)
                 recommendations.append(childproject.as_recommendation())
 
         if recommendations:
-            childmanifest_path = os.path.relpath(
-                childmanifest_path, start=os.path.dirname(path)
+            childmanifest_relpath = os.path.relpath(
+                childmanifest.path, start=os.path.dirname(manifest.path)
             ).replace("\\", "/")
-            _make_recommendation(project, recommendations, childmanifest_path)
+            _make_recommendation(project, recommendations, childmanifest_relpath)
 
 
 def _make_recommendation(

dfetch/commands/diff.py

@@ -100,10 +100,10 @@ def create_menu(subparsers: dfetch.commands.command.SubparserActionType) -> None
 
     def __call__(self, args: argparse.Namespace) -> None:
         """Perform the diff."""
-        manifest, path = dfetch.manifest.manifest.get_manifest()
+        manifest = dfetch.manifest.manifest.get_manifest()
         revs = [r for r in args.revs.strip(":").split(":", maxsplit=1) if r]
 
-        with in_directory(os.path.dirname(path)):
+        with in_directory(os.path.dirname(manifest.path)):
             exceptions: List[str] = []
             projects = manifest.selected_projects(args.projects)
             if not projects:
@@ -113,10 +113,10 @@ def __call__(self, args: argparse.Namespace) -> None:
             for project in projects:
                 patch_name = f"{project.name}.patch"
                 with catch_runtime_exceptions(exceptions) as exceptions:
-                    repo = _get_repo(path, project)
+                    repo = _get_repo(manifest.path, project)
                     patch = _diff_from_repo(repo, project, revs)
 
-                    _dump_patch(path, revs, project, patch_name, patch)
+                    _dump_patch(manifest.path, revs, project, patch_name, patch)
 
         if exceptions:
             raise RuntimeError("\n".join(exceptions))

dfetch/commands/freeze.py

@@ -70,12 +70,12 @@ def __call__(self, args: argparse.Namespace) -> None:
         """Perform the freeze."""
         del args  # unused
 
-        manifest, path = get_manifest()
+        manifest = get_manifest()
 
         exceptions: List[str] = []
         projects: List[ProjectEntry] = []
 
-        with in_directory(os.path.dirname(path)):
+        with in_directory(os.path.dirname(manifest.path)):
             for project in manifest.projects:
                 with catch_runtime_exceptions(exceptions) as exceptions:
                     on_disk_version = dfetch.project.make(project).on_disk_version()

dfetch/commands/report.py

@@ -63,10 +63,10 @@ def create_menu(subparsers: dfetch.commands.command.SubparserActionType) -> None
 
     def __call__(self, args: argparse.Namespace) -> None:
         """Generate the report."""
-        manifest, path = dfetch.manifest.manifest.get_manifest()
+        manifest = dfetch.manifest.manifest.get_manifest()
 
-        with dfetch.util.util.in_directory(os.path.dirname(path)):
-            reporter = REPORTERS[args.type](path)
+        with dfetch.util.util.in_directory(os.path.dirname(manifest.path)):
+            reporter = REPORTERS[args.type](manifest)
 
             for project in manifest.selected_projects(args.projects):
                 determined_licenses = self._determine_licenses(project)

dfetch/commands/update.py

@@ -69,13 +69,13 @@ def create_menu(subparsers: dfetch.commands.command.SubparserActionType) -> None
 
     def __call__(self, args: argparse.Namespace) -> None:
         """Perform the update."""
-        manifest, path = dfetch.manifest.manifest.get_manifest()
+        manifest = dfetch.manifest.manifest.get_manifest()
 
         exceptions: List[str] = []
         destinations: List[str] = [
             os.path.realpath(project.destination) for project in manifest.projects
         ]
-        with in_directory(os.path.dirname(path)):
+        with in_directory(os.path.dirname(manifest.path)):
             for project in manifest.selected_projects(args.projects):
                 with catch_runtime_exceptions(exceptions) as exceptions:
                     self._check_destination(project, destinations)
@@ -85,7 +85,7 @@ def __call__(self, args: argparse.Namespace) -> None:
                         project.destination
                     ):
                         with in_directory(project.destination):
-                            check_child_manifests(manifest, project, path)
+                            check_child_manifests(manifest, project)
 
         if exceptions:
             raise RuntimeError("\n".join(exceptions))

dfetch/manifest/manifest.py

@@ -22,6 +22,7 @@
 import io
 import os
 import pathlib
+import re
 from typing import IO, Any, Dict, List, Optional, Sequence, Tuple, Union
 
 import yaml
@@ -102,9 +103,16 @@ class Manifest:
 
     CURRENT_VERSION = "0.0"
 
-    def __init__(self, manifest: ManifestDict) -> None:
+    def __init__(
+        self,
+        manifest: ManifestDict,
+        text: Optional[str] = None,
+        path: Optional[Union[str, os.PathLike[str]]] = None,
+    ) -> None:
         """Create the manifest."""
         self.__version: str = str(manifest.get("version", self.CURRENT_VERSION))
+        self.__text: str = str(text)
+        self.__path: str = str(path)
 
         self._remotes, default_remotes = self._determine_remotes(
             manifest.get("remotes", [])
@@ -180,7 +188,10 @@ def _determine_remotes(
         return (remotes, default_remotes)
 
     @staticmethod
-    def from_yaml(text: Union[io.TextIOWrapper, str, IO[str]]) -> "Manifest":
+    def from_yaml(
+        text: Union[io.TextIOWrapper, str, IO[str]],
+        path: Optional[Union[str, os.PathLike[str]]] = None,
+    ) -> "Manifest":
         """Create a manifest from a file like object."""
         loaded_yaml = Manifest._load_yaml(text)
 
@@ -192,7 +203,11 @@ def from_yaml(text: Union[io.TextIOWrapper, str, IO[str]]) -> "Manifest":
         if not manifest:
             raise RuntimeError("Missing manifest root element!")
 
-        return Manifest(manifest)
+        if isinstance(text, (io.TextIOWrapper, IO)):
+            text.seek(0)
+            text = text.read()
+
+        return Manifest(manifest, text=text, path=path)
 
     @staticmethod
     def _load_yaml(text: Union[io.TextIOWrapper, str, IO[str]]) -> Any:
@@ -217,7 +232,12 @@ def from_file(path: str) -> "Manifest":
             FileNotFoundError: Given path was not a file.
         """
         with open(path, "r", encoding="utf-8") as opened_file:
-            return Manifest.from_yaml(opened_file)
+            return Manifest.from_yaml(opened_file, path)
+
+    @property
+    def path(self) -> str:
+        """Path to the manifest file."""
+        return self.__path
 
     @property
     def version(self) -> str:
@@ -293,6 +313,25 @@ def dump(self, path: str) -> None:
                 self._as_dict(), manifest_file, Dumper=ManifestDumper, sort_keys=False
             )
 
+    def find_name_in_manifest(self, name: str) -> Tuple[int, int, int]:
+        """Find the location of a project name in the manifest."""
+        if not self.__text:
+            raise FileNotFoundError("No manifest text available")
+
+        for line_nr, line in enumerate(self.__text.splitlines(), start=1):
+            match = re.search(rf"^\s+-\s*name:\s*(?P<name>{name})\s*$", line)
+
+            if match:
+                return (
+                    line_nr,
+                    int(match.start("name")) + 1,
+                    int(match.end("name")),
+                )
+        raise RuntimeError(
+            "An entry from the manifest was provided,"
+            " that doesn't exist in the manifest!"
+        )
+
 
 def find_manifest() -> str:
     """Find a manifest."""
@@ -308,25 +347,22 @@ def find_manifest() -> str:
     return os.path.realpath(paths[0])
 
 
-def get_manifest() -> Tuple[Manifest, str]:
+def get_manifest() -> Manifest:
     """Get manifest and its path."""
     logger.debug("Looking for manifest")
     manifest_path = find_manifest()
     validate(manifest_path)
 
     logger.debug(f"Using manifest {manifest_path}")
-    return (
-        Manifest.from_file(manifest_path),
-        manifest_path,
-    )
+    return Manifest.from_file(manifest_path)
 
 
-def get_childmanifests(skip: Optional[List[str]] = None) -> List[Tuple[Manifest, str]]:
+def get_childmanifests(skip: Optional[List[str]] = None) -> List[Manifest]:
     """Get manifest and its path."""
     skip = skip or []
     logger.debug("Looking for sub-manifests")
 
-    childmanifests: List[Tuple[Manifest, str]] = []
+    childmanifests: List[Manifest] = []
     for path in find_file(DEFAULT_MANIFEST_NAME, "."):
         path = os.path.realpath(path)
         if path not in skip:
@@ -335,8 +371,7 @@ def get_childmanifests(skip: Optional[List[str]] = None) -> List[Tuple[Manifest,
                 pathlib.Path(path).relative_to(os.path.dirname(os.getcwd())).as_posix()
             ):
                 validate(path)
-            childmanifest = Manifest.from_file(path)
-            childmanifests += [(childmanifest, path)]
+            childmanifests += [Manifest.from_file(path)]
 
     return childmanifests
 

dfetch/reporting/check/code_climate_reporter.py

@@ -61,6 +61,7 @@
 from typing import Any, Dict, List
 
 from dfetch.log import get_logger
+from dfetch.manifest.manifest import Manifest
 from dfetch.manifest.project import ProjectEntry
 from dfetch.reporting.check.reporter import CheckReporter, Issue, IssueSeverity
 
@@ -82,14 +83,14 @@ class CodeClimateReporter(CheckReporter):
 
     name = "code-climate"
 
-    def __init__(self, manifest_path: str, report_path: str) -> None:
+    def __init__(self, manifest: Manifest, report_path: str) -> None:
         """Create the code climate reporter.
 
         Args:
-            manifest_path (str): Path to the manifest.
+            manifest (Manifest): The manifest.
             report_path (str): Output path of the report.
         """
-        super().__init__(manifest_path)
+        super().__init__(manifest)
 
         self._report_path = report_path
 
@@ -111,7 +112,7 @@ def add_issue(self, project: ProjectEntry, issue: Issue) -> None:
             project (ProjectEntry): Project with the issue
             issue (Issue): The issue to add to the report
         """
-        line, col_start, col_end = self.find_name_in_manifest(project.name)
+        line, col_start, col_end = self._manifest.find_name_in_manifest(project.name)
 
         self._report += [
             {
@@ -123,7 +124,7 @@ def add_issue(self, project: ProjectEntry, issue: Issue) -> None:
                 ).hexdigest(),
                 "severity": self._determine_severity(issue.severity).value,
                 "location": {
-                    "path": os.path.relpath(self._manifest_path),
+                    "path": os.path.relpath(self._manifest.path),
                     "positions": {
                         "begin": {"line": line, "column": col_start},
                         "end": {"line": line, "column": col_end},

dfetch/reporting/check/jenkins_reporter.py

@@ -55,6 +55,7 @@
 from typing import Any, Dict
 
 from dfetch.log import get_logger
+from dfetch.manifest.manifest import Manifest
 from dfetch.manifest.project import ProjectEntry
 from dfetch.reporting.check.reporter import CheckReporter, Issue
 
@@ -66,14 +67,14 @@ class JenkinsReporter(CheckReporter):
 
     name = "jenkins"
 
-    def __init__(self, manifest_path: str, report_path: str) -> None:
+    def __init__(self, manifest: Manifest, report_path: str) -> None:
         """Create the jenkins reporter.
 
         Args:
-            manifest_path (str): Path to the manifest.
+            manifest (Manifest): The manifest.
             report_path (str): Output path of the report.
         """
-        super().__init__(manifest_path)
+        super().__init__(manifest)
 
         self._report_path = report_path
 
@@ -89,10 +90,10 @@ def add_issue(self, project: ProjectEntry, issue: Issue) -> None:
             project (ProjectEntry): Project with the issue
             issue (Issue): The issue to add to the report
         """
-        line, col_start, col_end = self.find_name_in_manifest(project.name)
+        line, col_start, col_end = self._manifest.find_name_in_manifest(project.name)
         self._report["issues"] += [
             {
-                "fileName": os.path.relpath(self._manifest_path),
+                "fileName": os.path.relpath(self._manifest.path),
                 "severity": str(issue.severity.value),
                 "message": f"{project.name} : {issue.message}",
                 "description": issue.description,