refactor: rename issues to violations

deptry/core.py

@@ -80,30 +80,35 @@ def run(self) -> None:
         ]
         imported_modules = [mod for mod in imported_modules if not mod.standard_library]
 
-        issues = self._find_issues(imported_modules, dependencies_extract.dependencies)
-        TextReporter(issues).report()
+        violations = self._find_violations(imported_modules, dependencies_extract.dependencies)
+        TextReporter(violations).report()
 
         if self.json_output:
-            JSONReporter(issues, self.json_output).report()
+            JSONReporter(violations, self.json_output).report()
 
-        self._exit(issues)
+        self._exit(violations)
 
-    def _find_issues(
+    def _find_violations(
         self, imported_modules: list[Module], dependencies: list[Dependency]
     ) -> dict[str, list[Violation]]:
         result = {}
+
         if not self.skip_obsolete:
             result["obsolete"] = ObsoleteDependenciesFinder(imported_modules, dependencies, self.ignore_obsolete).find()
+
         if not self.skip_missing:
             result["missing"] = MissingDependenciesFinder(imported_modules, dependencies, self.ignore_missing).find()
+
         if not self.skip_transitive:
             result["transitive"] = TransitiveDependenciesFinder(
                 imported_modules, dependencies, self.ignore_transitive
             ).find()
+
         if not self.skip_misplaced_dev:
             result["misplaced_dev"] = MisplacedDevDependenciesFinder(
                 imported_modules, dependencies, self.ignore_misplaced_dev
             ).find()
+
         return result
 
     def _get_dependencies(self, dependency_management_format: DependencyManagementFormat) -> DependenciesExtract:
@@ -156,5 +161,5 @@ def _log_config(self) -> None:
         logging.debug("")
 
     @staticmethod
-    def _exit(issues: dict[str, list[Violation]]) -> None:
-        sys.exit(int(any(issues.values())))
+    def _exit(violations: dict[str, list[Violation]]) -> None:
+        sys.exit(int(any(violations.values())))

deptry/reporters/base.py

@@ -12,7 +12,7 @@
 class Reporter(ABC):
     """Base class for all violation reporters."""
 
-    issues: dict[str, list[Violation]]
+    violations: dict[str, list[Violation]]
 
     @abstractmethod
     def report(self) -> None:

deptry/reporters/json.py

@@ -15,14 +15,14 @@ class JSONReporter(Reporter):
     def report(self) -> None:
         output = {}
 
-        for issue_type, issues in self.issues.items():
+        for issue_type, violations in self.violations.items():
             output[issue_type] = [
                 (
-                    issue.issue.package
-                    if isinstance(issue.issue, Module) and issue.issue_type is TransitiveDependenciesFinder
-                    else issue.issue.name
+                    violation.issue.package
+                    if isinstance(violation.issue, Module) and violation.issue_type is TransitiveDependenciesFinder
+                    else violation.issue.name
                 )
-                for issue in issues
+                for violation in violations
             ]
 
         with open(self.json_output, "w", encoding="utf-8") as f:

deptry/reporters/text.py

@@ -17,21 +17,27 @@ def report(self) -> None:
         self._log_and_exit()
 
     def _log_and_exit(self) -> None:
-        total_issues_found = sum([len(v) for k, v in self.issues.items()])
-        self._log_total_number_of_issues_found(total_issues_found)
-        if "obsolete" in self.issues and self.issues["obsolete"]:
-            self._log_obsolete_dependencies(self.issues["obsolete"])
-        if "missing" in self.issues and self.issues["missing"]:
-            self._log_missing_dependencies(self.issues["missing"])
-        if "transitive" in self.issues and self.issues["transitive"]:
-            self._log_transitive_dependencies(self.issues["transitive"])
-        if "misplaced_dev" in self.issues and self.issues["misplaced_dev"]:
-            self._log_misplaced_develop_dependencies(self.issues["misplaced_dev"])
-        if total_issues_found > 0:
+        total_violations_found = sum([len(v) for k, v in self.violations.items()])
+
+        self._log_total_number_of_violations_found(total_violations_found)
+
+        if "obsolete" in self.violations and self.violations["obsolete"]:
+            self._log_obsolete_dependencies(self.violations["obsolete"])
+
+        if "missing" in self.violations and self.violations["missing"]:
+            self._log_missing_dependencies(self.violations["missing"])
+
+        if "transitive" in self.violations and self.violations["transitive"]:
+            self._log_transitive_dependencies(self.violations["transitive"])
+
+        if "misplaced_dev" in self.violations and self.violations["misplaced_dev"]:
+            self._log_misplaced_develop_dependencies(self.violations["misplaced_dev"])
+
+        if total_violations_found > 0:
             self._log_additional_info()
 
     @staticmethod
-    def _log_total_number_of_issues_found(number: int) -> None:
+    def _log_total_number_of_violations_found(number: int) -> None:
         if number == 0:
             logging.info("Success! No dependency issues found.")
         elif number == 1:

tests/unit/reporters/test_text_reporter.py

@@ -19,13 +19,13 @@
 
 def test_logging_number_multiple(caplog: LogCaptureFixture) -> None:
     with caplog.at_level(logging.INFO):
-        issues = {
+        violations = {
             "missing": [Violation(MissingDependenciesFinder, Module("foo", package="foo_package"))],
             "obsolete": [Violation(ObsoleteDependenciesFinder, Dependency("foo", Path("pyproject.toml")))],
             "transitive": [Violation(TransitiveDependenciesFinder, Module("foo", package="foo_package"))],
             "misplaced_dev": [Violation(MisplacedDevDependenciesFinder, Module("foo", package="foo_package"))],
         }
-        TextReporter(issues).report()
+        TextReporter(violations).report()
 
     assert "There were 4 dependency issues found" in caplog.text
     assert "The project contains obsolete dependencies" in caplog.text
@@ -37,16 +37,16 @@ def test_logging_number_multiple(caplog: LogCaptureFixture) -> None:
 
 def test_logging_number_single(caplog: LogCaptureFixture) -> None:
     with caplog.at_level(logging.INFO):
-        issues = {"missing": [Violation(MissingDependenciesFinder, Module("foo", package="foo_package"))]}
-        TextReporter(issues).report()
+        violations = {"missing": [Violation(MissingDependenciesFinder, Module("foo", package="foo_package"))]}
+        TextReporter(violations).report()
 
     assert "There was 1 dependency issue found" in caplog.text
 
 
 def test_logging_number_none(caplog: LogCaptureFixture) -> None:
     with caplog.at_level(logging.INFO):
-        issues: dict[str, list[Violation]] = {"missing": []}
-        TextReporter(issues).report()
+        violations: dict[str, list[Violation]] = {"missing": []}
+        TextReporter(violations).report()
 
     assert "No dependency issues found" in caplog.text
     assert "There were 4 dependency issues found" not in caplog.text

tests/unit/test_core.py

@@ -131,24 +131,24 @@ def test__get_stdlib_packages_unsupported(version_info: tuple[int | str, ...]) -
         Core._get_stdlib_modules()
 
 
-def test__exit_with_issues() -> None:
-    issues = {
+def test__exit_with_violations() -> None:
+    violations = {
         "missing": [Violation(MissingDependenciesFinder, Module("foo"))],
         "obsolete": [Violation(ObsoleteDependenciesFinder, Dependency("foo", Path("pyproject.toml")))],
         "transitive": [Violation(TransitiveDependenciesFinder, Module("foo"))],
         "misplaced_dev": [Violation(MisplacedDevDependenciesFinder, Module("foo"))],
     }
     with pytest.raises(SystemExit) as e:
-        Core._exit(issues)
+        Core._exit(violations)
 
     assert e.type == SystemExit
     assert e.value.code == 1
 
 
-def test__exit_without_issues() -> None:
-    issues: dict[str, list[Violation]] = {}
+def test__exit_without_violations() -> None:
+    violations: dict[str, list[Violation]] = {}
     with pytest.raises(SystemExit) as e:
-        Core._exit(issues)
+        Core._exit(violations)
 
     assert e.type == SystemExit
     assert e.value.code == 0