suite-py 1.47.1__tar.gz → 1.48.0__tar.gz

{suite_py-1.47.1 → suite_py-1.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: suite-py
-Version: 1.47.1
+Version: 1.48.0
 Summary: 
 Author: larrywax, EugenioLaghi, michelangelomo
 Author-email: devops@prima.it

{suite_py-1.47.1 → suite_py-1.48.0}/pyproject.toml

@@ -2,7 +2,7 @@
 authors = ["larrywax, EugenioLaghi, michelangelomo <devops@prima.it>"]
 description = ""
 name = "suite-py"
-version = "1.47.1"
+version = "1.48.0"
 
 [tool.poetry.dependencies]
 Click = ">=7.0"

{suite_py-1.47.1 → suite_py-1.48.0}/suite_py/__version__.py

@@ -1,2 +1,2 @@
 # -*- encoding: utf-8 -*-
-__version__ = "1.47.1"
+__version__ = "1.48.0"

{suite_py-1.47.1 → suite_py-1.48.0}/suite_py/cli.py

@@ -326,12 +326,34 @@ def release():
 @release.command(
     "create", help="Create a github release (and deploy it if GHA are used)"
 )
+@click.argument(
+    "commit",
+    required=False,
+    type=str,
+    metavar="[COMMIT]",
+)
+@click.option(
+    "--interactive",
+    "-i",
+    is_flag=True,
+    help="Interactively choose which unreleased commit to release (ignored if COMMIT is provided)",
+)
 @click.pass_obj
 @catch_exceptions
-def cli_release_create(obj):
+def cli_release_create(obj, commit, interactive):  # type: ignore[override]
+    """Create a release.
+
+    Optionally pass a COMMIT (full or short SHA) to create the release at that
+    specific commit instead of the latest commit (HEAD). Example:
+
+        suite-py release create 644a699
+
+    If you don't provide a COMMIT you can pass --interactive / -i to select
+    one among the unreleased commits (those after the last tag).
+    """
     from suite_py.commands.release import Release
 
-    obj.call(Release, action="create").run()
+    obj.call(Release, action="create", commit=commit, interactive=interactive).run()
 
 
 @main.command("status", help="Current status of a project")

{suite_py-1.47.1 → suite_py-1.48.0}/suite_py/commands/release.py

@@ -16,11 +16,24 @@ from suite_py.lib.handler.youtrack_handler import YoutrackHandler
 class Release:
     # pylint: disable=too-many-instance-attributes
     # pylint: disable=too-many-positional-arguments
-    def __init__(self, action, project, captainhook, config, tokens):
+    def __init__(
+        self,
+        action,
+        project,
+        captainhook,
+        config,
+        tokens,
+        commit=None,
+        interactive=False,
+    ):
         self._action = action
         self._project = project
         self._config = config
         self._tokens = tokens
+        # Optional commit (sha or short sha) to release instead of HEAD
+        self._commit = commit
+        # Whether to prompt the user to choose commit among unreleased ones
+        self._interactive = interactive
         self._changelog_handler = ChangelogHandler()
         self._youtrack = YoutrackHandler(config, tokens)
         self._captainhook = captainhook
@@ -52,62 +65,138 @@ class Release:
 
     def _create(self):
         latest = self._version.get_latest_version()
+        commits, new_version, message = self._gather_commits_and_version(latest)
+        message = self._augment_message_with_changelog(new_version, message)
+        message = common.ask_for_release_description(message)
+        sha = self._resolve_target_sha(commits)
+        self._create_release(new_version, message, sha)
 
-        commits = []
-        if latest != "":
-            logger.info(f"The current release is {latest}")
-            commits = self._github.get_commits_since_release(self._repo, latest)
-
-            _check_migrations_deploy(commits)
-
-            message = "\n".join(
-                [
-                    "* "
-                    + c.commit.message.splitlines()[0]
-                    + " by "
-                    + c.commit.author.name
-                    for c in commits
-                ]
-            )
+    # ---- helpers (extracted to reduce complexity of _create) ----
+    def _gather_commits_and_version(self, latest):
+        """Return (commits, new_version, base_message)."""
+        if latest == "":
+            return self._first_release_flow()
 
-            logger.info(f"\nCommits list:\n{message}\n")
+        logger.info(f"The current release is {latest}")
+        commits = self._github.get_commits_since_release(self._repo, latest)
+        # If user did not pass a target commit, ask interactively which commit to release.
+        # Only perform interactive selection if user explicitly requested it
+        if self._interactive:
+            self._select_commit_if_needed(commits)
+        commits = self._maybe_trim_commits(commits)
+        _check_migrations_deploy(commits)
+        message = self._build_commits_message(commits)
+        logger.info(f"\nCommits list:\n{message}\n")
+        if not prompt_utils.ask_confirm("Do you want to continue?"):
+            sys.exit()  # Preserve previous early return semantics
+        new_version = self._version.select_new_version(latest, allow_prerelease=True)
+        return commits, new_version, message
 
-            if not prompt_utils.ask_confirm("Do you want to continue?"):
-                return
+    def _first_release_flow(self):
+        logger.warning(f"No tags found, I'm about to push the tag {DEFAULT_VERSION}")
+        if not prompt_utils.ask_confirm(
+            "Are you sure you want to continue?", default=False
+        ):
+            sys.exit()
+        return [], DEFAULT_VERSION, f"First release with tag {DEFAULT_VERSION}"
 
-            new_version = self._version.select_new_version(
-                latest, allow_prerelease=True
+    def _maybe_trim_commits(self, commits):
+        if not self._commit:
+            return commits
+        try:
+            resolved_commit = self._repo.get_commit(self._commit)
+            target_sha = resolved_commit.sha
+        except Exception:  # pragma: no cover
+            logger.error(
+                f"The provided commit '{self._commit}' was not found in the repository."
             )
-
-        else:
-            # Se non viene trovata la release e non ci sono tag, viene saltato il check delle migrations e l'update delle card su youtrack
-            logger.warning(
-                f"No tags found, I'm about to push the tag {DEFAULT_VERSION}"
+            sys.exit(-1)
+        target_index = None
+        for idx, c in enumerate(commits):
+            if (
+                c.sha == target_sha
+                or getattr(c, "commit", None)
+                and c.commit.sha == target_sha
+            ):
+                target_index = idx
+                break
+        if target_index is None:
+            logger.error(
+                "The specified commit is not part of the unreleased commits (i.e., not after the latest release)."
             )
+            sys.exit(-1)
+        return commits[target_index:]
+
+    def _select_commit_if_needed(self, commits):
+        """Interactively ask the user which commit to release if none was provided.
+
+        Presents the unreleased commits (newest first) allowing the user to pick a
+        target commit. The chosen commit's SHA (full) is stored in `self._commit` so
+        that downstream logic (_maybe_trim_commits / _resolve_target_sha) works
+        unchanged.
+        """
+        if self._commit or not commits:
+            return
+        if len(commits) == 1:
+            # Only one unreleased commit; implicitly choose it.
+            self._commit = commits[0].sha
+            return
+        choices = [
+            {
+                "name": f"{c.sha[:8]} | {c.commit.message.splitlines()[0]}",
+                "value": c.sha,
+            }
+            for c in commits
+        ]
+        selected = prompt_utils.ask_choices(
+            "Select commit to release (newest first):", choices
+        )
+        self._commit = selected
+
+    @staticmethod
+    def _build_commits_message(commits):
+        return "\n".join(
+            [
+                "* " + c.commit.message.splitlines()[0] + " by " + c.commit.author.name
+                for c in commits
+            ]
+        )
+
+    def _augment_message_with_changelog(self, new_version, message):
+        if not self._changelog_handler.changelog_exists():
+            return message
+        latest_tag, latest_entry = self._changelog_handler.get_latest_entry_with_tag()
+        if latest_tag != new_version:
             if not prompt_utils.ask_confirm(
-                "Are you sure you want to continue?", default=False
+                "You didn't update your changelog, are you sure you want to proceed?"
             ):
                 sys.exit()
-            new_version = DEFAULT_VERSION
-            message = f"First release with tag {new_version}"
-
-        if self._changelog_handler.changelog_exists():
-            (
-                latest_tag,
-                latest_entry,
-            ) = self._changelog_handler.get_latest_entry_with_tag()
-
-            if latest_tag != new_version:
-                if not prompt_utils.ask_confirm(
-                    "You didn't update your changelog, are you sure you want to proceed?"
-                ):
-                    sys.exit()
-            else:
-                message = f"{latest_entry}\n\n# Commits\n\n{message}"
+            return message
+        return f"{latest_entry}\n\n# Commits\n\n{message}"
 
-        message = common.ask_for_release_description(message)
-        sha = commits[0].commit.sha if len(commits) > 0 else ""
-        self._create_release(new_version, message, sha)
+    def _resolve_target_sha(self, commits):
+        if not self._commit:
+            return commits[0].commit.sha if commits else ""
+        try:
+            sha = self._repo.get_commit(self._commit).sha
+        except Exception:  # pragma: no cover
+            logger.error(
+                f"Unable to resolve commit '{self._commit}' during release creation."
+            )
+            sys.exit(-1)
+        self._validate_target_commit_not_tagged(sha)
+        return sha
+
+    def _validate_target_commit_not_tagged(self, sha):
+        try:
+            for t in self._repo.get_tags():  # network call
+                if t.commit.sha == sha:
+                    logger.error(
+                        f"The commit {sha[:7]} is already tagged with {t.name}. Aborting."
+                    )
+                    sys.exit(-1)
+        except Exception:  # pragma: no cover
+            logger.warning("Could not verify if commit already tagged; continuing.")
 
     def _create_release(self, new_version, message, commit):
         new_release = self._repo.create_git_release(

{suite_py-1.47.1 → suite_py-1.48.0}/suite_py/lib/handler/pre_commit_handler.py

@@ -16,18 +16,20 @@ class PreCommit:
         self._git = GitHandler(project, config)
 
     def check_and_warn(self):
-        if self.is_enabled() and not self.is_pre_commit_hooks_installed():
-            self.warn_missing_pre_commit_hook()
+        if self._is_enabled() and not self._is_pre_commit_hooks_installed():
+            self._warn_missing_pre_commit_hook()
 
-    def is_pre_commit_hooks_installed(self):
+    def _is_enabled(self):
+        return self._git.get_git_config("suite-py.disable-pre-commit-warning") != "true"
+
+    def _is_pre_commit_hooks_installed(self):
         """
-        Apply some heuteristics to check whether the gitleaks pre-commit hook is installed.
+        Apply some heuristics to check whether the gitleaks pre-commit hook is installed.
         This is extremely imperfect, and only supports direct calls in shell scripts.
-        More hooks, like husky should be added later
         """
-        return self.is_vanilla_hook_setup() or self.is_pre_commit_py_hook_setup()
+        return self._is_shell_script_hook_setup() or self._is_pre_commit_py_hook_setup()
 
-    def warn_missing_pre_commit_hook(self):
+    def _warn_missing_pre_commit_hook(self):
         logger.warning(
             """
 Looks like the current repo is missing the gitleaks pre-commit hook!
@@ -42,28 +44,32 @@ to disable it globally
         """
         )
 
-    def is_vanilla_hook_setup(self):
+    def _is_shell_script_hook_setup(self):
         """
-        Check whether the gitleaks hook is setup as a regular bash script
-        """
-        pre_commit_file = self.read_pre_commit_hook()
-
-        # Assume everything is a shell script.
-        # Technically you could use a binary, or even python code,
-        # But those are out of scope for us, and the user should just disable the warning themselves
-        lines = pre_commit_file.splitlines()
+        Check whether the gitleaks hook is setup as a regular bash script:
 
-        # Filter out lines that start with '#' since those are probably just comments.
-        without_comments = filter(lambda l: not l.strip().startswith("#"), lines)
+        * is there a `.git/hooks/pre-commit` shell script that contains keyword "gitleaks"
+        * is there a `.husky/pre-commit` shell script that contains keyword "security-hooks" (primait/security-hooks repo)
+        """
+        checks = [
+            (os.path.join(self._git.hooks_path(), "pre-commit"), "gitleaks"),
+            (
+                os.path.join(self._git.get_path(), ".husky", "pre-commit"),
+                "security-hooks",
+            ),
+        ]
 
-        return any("gitleaks" in line for line in without_comments)
+        return any(
+            self._script_contains_keyword(path, keyword) for path, keyword in checks
+        )
 
-    def is_pre_commit_py_hook_setup(self):
+    def _is_pre_commit_py_hook_setup(self):
         """
         Check whether the gitleaks hook is setup with the pre-commit python framework
         """
-        # If the framework is not setup skip
-        if "pre-commit" not in self.read_pre_commit_hook():
+        # is there a `.git/hooks/pre-commit` shell script that contains keyword "pre-commit"
+        pre_commit_file_path = os.path.join(self._git.hooks_path(), "pre-commit")
+        if not self._script_contains_keyword(pre_commit_file_path, "pre-commit"):
             logger.debug("pre-commit.com not installed, skipping config check")
             return False
 
@@ -83,14 +89,21 @@ to disable it globally
             for repo in config.get("repos", [])
         )
 
-    def read_pre_commit_hook(self):
-        pre_commit_file_path = os.path.join(self._git.hooks_path(), "pre-commit")
-        logger.debug("Reading pre-commit script from %s", pre_commit_file_path)
+    def _script_contains_keyword(self, file_path, keyword):
+        """
+        Check if a keyword appears in a shell script, ignoring comment lines
+        (binaries and python code are out of scope for us).
+        """
         try:
-            with open(pre_commit_file_path, encoding="utf-8") as f:
-                return f.read()
+            logger.debug("checking pre-commit script(%s)", file_path)
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
         except FileNotFoundError:
-            return ""
+            logger.debug("pre-commit script(%s) not found", file_path)
+            return False
 
-    def is_enabled(self):
-        return self._git.get_git_config("suite-py.disable-pre-commit-warning") != "true"
+        # Filter out comments (lines starting with '#').
+        lines_without_comments = (
+            line for line in content.splitlines() if not line.strip().startswith("#")
+        )
+        return any(keyword in line for line in lines_without_comments)