envoy.code.check/

Author: phlax

envoy.code.check/envoy/code/check/abstract/changelog.py

@@ -26,39 +26,20 @@ class ChangelogFile:
 
     def __init__(
             self,
-            project: base_interface.IProject,
+            check: "AChangelogCheck",
             changelog: base_interface.IChangelog) -> None:
-        self.project = project
+        self.check = check
+        self.project = check.project
         self.changelog = changelog
 
-    @cached_property
-    def invalid_reflink_re(self) -> Pattern[str]:
-        return re.compile(INVALID_REFLINK)
-
-    @cached_property
-    def link_ticks_re(self) -> Pattern[str]:
-        return re.compile(LINK_TICKS_REGEX)
-
-    @cached_property
-    def punctuation_re(self) -> Pattern[str]:
-        return re.compile(REF_WITH_PUNCTUATION_REGEX)
-
-    @cached_property
-    def ref_ticks_re(self) -> Pattern[str]:
-        return re.compile(REF_TICKS_REGEX)
-
-    @cached_property
-    def single_tick_re(self) -> Pattern[str]:
-        return re.compile(SINGLE_TICK_REGEX)
-
     def check_punctuation(self, section, entry) -> List[str]:
         change = entry["change"]
         if change.strip().endswith("."):
             return []
         # Ends with punctuated link
         ends_with_punctuated_link = (
             change.strip().endswith('`')
-            and self.punctuation_re.match(change.strip()))
+            and self.check.punctuation_re.match(change.strip()))
         if ends_with_punctuated_link:
             return []
         # Ends with a list
@@ -74,58 +55,86 @@ def check_reflinks(self, section, entry) -> List[str]:
             [f"{self.changelog.version}: Found text "
              f"\" ref:\" ({section}/{entry['area']}) "
              f"This should probably be \" :ref:\"\n{entry['change']}"]
-            if self.invalid_reflink_re.findall(entry["change"])
+            if self.check.invalid_reflink_re.findall(entry["change"])
             else [])
 
-    def check_change(self, section, entry) -> List[str]:
-        return [
+    def check_change(self, section, entry) -> Tuple[str, ...]:
+        return tuple(
             *self.check_reflinks(section, entry),
             *self.check_ticks(section, entry),
-            *self.check_punctuation(section, entry)]
+            *self.check_punctuation(section, entry))
 
     def check_ticks(self, section, entry) -> List[str]:
         _change = entry["change"]
-        for reflink in self.ref_ticks_re.findall(_change):
+        for reflink in self.check.ref_ticks_re.findall(_change):
             _change = _change.replace(reflink, "")
-        for extlink in self.link_ticks_re.findall(_change):
+        for extlink in self.check.link_ticks_re.findall(_change):
             _change = _change.replace(extlink, "")
-        single_ticks = self.single_tick_re.findall(_change)
+        single_ticks = self.check.single_tick_re.findall(_change)
         return (
             [f"{self.changelog.version}: Single backticks found "
              f"({section}/{entry['area']}) "
              f"{', '.join(single_ticks)}\n{_change}"]
             if single_ticks
             else [])
 
-    def run_checks(self) -> List[str]:
+    @property
+    def is_current(self):
+        return self.project.is_current(self.changelog.version)
+
+    def run_checks(self) -> Tuple[str, ...]:
         errors = []
-        for section, entries in self.changelog.data.items():
+        duplicate_current = (
+            self.is_current
+            and (self.project.changelogs.current_path
+                 != self.changelog.path))
+        if duplicate_current:
+            errors.append(
+                f"Duplicate current version file: {self.changelog.path}")
+
+        for section, data in self.changelog.data.items():
             if section == "date":
+                missing_pending = (
+                    self.is_current
+                    and self.project.is_dev
+                    and data != "Pending")
+                if missing_pending:
+                    errors.append(
+                        f"{self.changelog_version} "
+                        f"should be set to `Pending`")
+                incorrect_pending = (
+                    (not self.is_current
+                     or not self.project.is_dev)
+                    and data == "Pending")
+                if incorrect_pending:
+                    errors.append(
+                        f"{self.changelog_version} "
+                        f"should be not set to `Pending`")
+                # TODO: add date format check
                 continue
             if section not in self.project.changelogs.sections:
                 errors.append(
                     f"{self.changelog.version} Unrecognized changelog "
                     f"section: {section}")
             if section == "changes":
                 no_changes_version = (
-                    version.Version(self.changelog.version)
+                    self.changelog.version
                     > version.Version("1.16"))
                 if no_changes_version:
                     errors.append(
                         "Removed `changes` section found: "
                         f"{self.changelog.version}")
-            if not entries:
+            if not data:
                 continue
-            for entry in entries:
+            for entry in data:
                 errors.extend(self.check_change(section, entry))
-        return errors
+        return tuple(errors)
 
 
-class AChangelogCheck(
+class AProjectCheck(
         abstract.ACodeCheck,
         metaclass=abstracts.Abstraction):
     """Extensions check."""
-    changelog_file_class = ChangelogFile
 
     def __init__(
             self,
@@ -135,10 +144,18 @@ def __init__(
         self.project = project
         super().__init__(*args, **kwargs)
 
+
+class AChangelogCheck(
+        AProjectCheck,
+        metaclass=abstracts.Abstraction):
+    """Extensions check."""
+    changelog_file_class = ChangelogFile
+
     @property
-    def current_changelog_path(self) -> pathlib.Path:
-        return self.project.changelogs.current_path.relative_to(
-            self.project.path)
+    def dev_not_pending(self) -> bool:
+        return (
+            self.project.is_dev
+            and not self.project.changelogs.is_pending)
 
     @property
     def extra_pending(self) -> List[str]:
@@ -147,17 +164,13 @@ def extra_pending(self) -> List[str]:
             in self.pending_changelogs
             if x != self.project.version.base_version]
 
-    @property
-    def pending_not_dev(self) -> bool:
-        return (
-            not self.project.is_dev
-            and self.project.changelogs.is_pending)
+    @cached_property
+    def invalid_reflink_re(self) -> Pattern[str]:
+        return re.compile(INVALID_REFLINK)
 
-    @property
-    def dev_not_pending(self) -> bool:
-        return (
-            self.project.is_dev
-            and not self.project.changelogs.is_pending)
+    @cached_property
+    def link_ticks_re(self) -> Pattern[str]:
+        return re.compile(LINK_TICKS_REGEX)
 
     @cached_property
     def pending_changelogs(self) -> List[str]:
@@ -166,13 +179,33 @@ def pending_changelogs(self) -> List[str]:
             for k, v in self.project.changelogs.items()
             if v.release_date == "Pending"]
 
+    @property
+    def pending_not_dev(self) -> bool:
+        return (
+            not self.project.is_dev
+            and self.project.changelogs.is_pending)
+
+    @cached_property
+    def punctuation_re(self) -> Pattern[str]:
+        return re.compile(REF_WITH_PUNCTUATION_REGEX)
+
+    @cached_property
+    def ref_ticks_re(self) -> Pattern[str]:
+        return re.compile(REF_TICKS_REGEX)
+
+    @cached_property
+    def single_tick_re(self) -> Pattern[str]:
+        return re.compile(SINGLE_TICK_REGEX)
+
     def check_changelog(
             self,
-            changelog: base_interface.IChangelog) -> List[str]:
-        return self.changelog_file_class(
-            self.project, changelog).run_checks()
+            changelog: base_interface.IChangelog) -> Tuple[str, ...]:
+        return self.changelog_file_class(self, changelog).run_checks()
 
     def check_changes(
-            self) -> Iterator[Tuple[base_interface.IChangelog, List]]:
+            self) -> Iterator[
+                Tuple[
+                    base_interface.IChangelog,
+                    Tuple[str, ...]]]:
         for changelog in self.project.changelogs.values():
             yield changelog, self.check_changelog(changelog)

envoy.code.check/envoy/code/check/abstract/checker.py

@@ -243,46 +243,6 @@ async def check_changelog_changes(self):
                     [f"{changelog.version}"])
 
     async def check_changelog_version(self) -> None:
-        version_path = self.project.version_path.relative_to(self.project.path)
-        if self.changelog.dev_not_pending:
-            self.error(
-                "changelog_version",
-                [f"`{version_path}` is set to `-dev` "
-                 f"but `{self.changelog.current_changelog_path}` "
-                 "is not `Pending`"])
-        elif self.changelog.pending_not_dev:
-            self.error(
-                "changelog_version",
-                [f"`{version_path}` is not set to `-dev` "
-                 f"but `{self.changelog.current_changelog_path}` "
-                 "is `Pending`"])
-        elif self.project.is_dev:
-            self.succeed(
-                "changelog_version",
-                [f"`{version_path}` is set to `-dev` and "
-                 f"`{self.changelog.current_changelog_path}` is `Pending`"])
-        else:
-            self.succeed(
-                "changelog_version",
-                [f"`{version_path}` is not set to `-dev` and "
-                 f"`{self.changelog.current_changelog_path}` "
-                 "is not `Pending`"])
-
-        if not self.changelog.extra_pending:
-            self.succeed(
-                "changelog_version",
-                ["No extraneous pending versions found"])
-        elif self.project.is_dev:
-            self.error(
-                "changelog_version",
-                [f"Only current version should be pending, "
-                 f"found: {self.changelog.extra_pending}"])
-        else:
-            self.error(
-                "changelog_version",
-                [f"Nothing should be pending, "
-                 f"found: {self.changelog.extra_pending}"])
-
         current_is_duplicated = (
             pathlib.Path(
                 f"changelogs/{self.project.version.base_version}.yaml")