git-tide 0.1.2__tar.gz → 0.1.3__tar.gz

{git_tide-0.1.2 → git_tide-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: git-tide
-Version: 0.1.2
+Version: 0.1.3
 Summary: CLI for automated gitflow-style branching
 Author: Chad Dombrova
 Classifier: Programming Language :: Python :: 2
@@ -100,6 +100,12 @@ In order for `tide` to work its magic, the Gitlab repo needs to be properly conf
     branches.rc = "staging"
     branches.stable = "master"
     ```
+- For each project within your repo that you want to manage tagged releases, add a `project` entry:
+    ```toml
+    [tool.tide]
+    project = "project_name"
+    ```
+  If there is only one, then combine be sure to put all of your options under a single `[tool.tide]` section.
 - Create a [Project Access Token](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html) with the appropriate scope for being able to push tags, changes and create cicd variables.
 - Run `tide init --access-token='YOUR_ACCESS_TOKEN'`
 - Copy and modify the `.gitlab-ci.yml` file ensuring the branch variables match the ones in the `pyproject.toml` (TODO: automated generation of `.gitlab-ci.yml` in `tide init`)

{git_tide-0.1.2 → git_tide-0.1.3}/README.md

@@ -76,6 +76,12 @@ In order for `tide` to work its magic, the Gitlab repo needs to be properly conf
     branches.rc = "staging"
     branches.stable = "master"
     ```
+- For each project within your repo that you want to manage tagged releases, add a `project` entry:
+    ```toml
+    [tool.tide]
+    project = "project_name"
+    ```
+  If there is only one, then combine be sure to put all of your options under a single `[tool.tide]` section.
 - Create a [Project Access Token](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html) with the appropriate scope for being able to push tags, changes and create cicd variables.
 - Run `tide init --access-token='YOUR_ACCESS_TOKEN'`
 - Copy and modify the `.gitlab-ci.yml` file ensuring the branch variables match the ones in the `pyproject.toml` (TODO: automated generation of `.gitlab-ci.yml` in `tide init`)

{git_tide-0.1.2 → git_tide-0.1.3}/pyproject.toml

@@ -6,7 +6,7 @@ name = "git-tide"
 packages = [
     { include = "tide", from = "src" },
 ]
-version = "0.1.2"
+version = "0.1.3"
 description = "CLI for automated gitflow-style branching"
 authors = ["Chad Dombrova", "Matt Collie"]
 readme = "README.md"
@@ -44,10 +44,3 @@ markers = [
 branches.beta = "develop"
 branches.rc = "staging"
 branches.stable = "master"
-
-[tool.commitizen]
-name = "cz_conventional_commits"
-tag_format = "$version"
-version_scheme = "pep440"
-version_provider = "scm"
-major_version_zero = false

{git_tide-0.1.2 → git_tide-0.1.3}/src/tide/cli.py

@@ -54,7 +54,6 @@ def get_runtime() -> Runtime:
     """
     Return a Runtime corresponding to where the current python process is *running*
     """
-    print(os.environ.get("GITLAB_CI"))
     if os.environ.get("GITLAB_CI", "false") == "true":
         return GitlabRuntime(CONFIG)
     # gitlab-ci-local and our unittests set this to false as an inidicator that
@@ -179,9 +178,11 @@ def autotag(annotation: str, base_rev: str | None) -> None:
 
     projects = get_modified_projects(base_rev, verbose=CONFIG.verbose)
     if projects:
-        for project_folder, _ in projects:
+        for project_folder, project_name in projects:
             # Auto-tag
-            tag = get_tag_for_branch(CONFIG, remote, branch, project_folder)
+            tag = get_tag_for_branch(
+                CONFIG, remote, branch, project_name, project_folder
+            )
 
             # NOTE: this delay is necessary to create stable sorting of tags
             # because git's time resolution is 1s (same as unix timestamp).
@@ -317,7 +318,16 @@ def get_tag(path: str, branch: str | None, remote: str, next: bool) -> None:
         if branch is None:
             runtime = get_runtime()
             branch = runtime.current_branch()
-        click.echo(get_tag_for_branch(CONFIG, remote, branch, Path(path)))
+        projects = dict(get_projects())
+        folder = Path(path)
+        try:
+            project_name = projects[folder]
+        except KeyError:
+            raise click.ClickException(
+                f"There is not a project at path={folder}. "
+                "Ensure there is a pyproject.toml file with a [tool.tide] section and a `project` entry"
+            )
+        click.echo(get_tag_for_branch(CONFIG, remote, branch, project_name, folder))
     else:
         click.echo(cz("version", "--project", folder=path))
 

{git_tide-0.1.2 → git_tide-0.1.3}/src/tide/core.py

@@ -1,7 +1,6 @@
 from __future__ import absolute_import, print_function, annotations
 
 import os
-import re
 import subprocess
 import json
 
@@ -23,6 +22,7 @@ from .gitutils import git, checkout, get_tags, branch_exists, join, current_rev,
 
 if TYPE_CHECKING:
     import gitlab.v4.objects
+    import commitizen.providers
 
 
 TOOL_NAME = "tide"
@@ -477,7 +477,13 @@ def cz(*args: str, folder: str | Path | None = None) -> str:
     return output.strip()
 
 
-def is_pending_bump(config: Config, remote: str, branch: str, folder: Path) -> bool:
+def is_pending_bump(
+    config: Config,
+    provider: commitizen.providers.ScmProvider,
+    remote: str,
+    branch: str,
+    folder: Path,
+) -> bool:
     """
     Return whether the given branch and folder combination are awaiting a minor bump.
 
@@ -489,9 +495,6 @@ def is_pending_bump(config: Config, remote: str, branch: str, folder: Path) -> b
     Returns:
         whether it is pending or not
     """
-    from commitizen.config import read_cfg
-    from commitizen.providers import ScmProvider
-
     if branch != config.most_experimental_branch():
         return False
 
@@ -505,9 +508,6 @@ def is_pending_bump(config: Config, remote: str, branch: str, folder: Path) -> b
     cwd = os.getcwd()
     os.chdir(folder)
     try:
-        # Use the matching logic from commitizen, which will read the commitizen
-        # config file for us (note: it supports more than just pyproject.toml).
-        provider = ScmProvider(read_cfg())
         matcher = provider._tag_format_matcher()
         if config.verbose:
             click.echo(f"Found promotion base rev: {promotion_rev}")
@@ -559,7 +559,9 @@ def set_promotion_marker(remote: str, branch: str) -> None:
     git("push", remote, "refs/notes/*")
 
 
-def get_tag_for_branch(config: Config, remote: str, branch: str, folder: Path) -> str:
+def get_tag_for_branch(
+    config: Config, remote: str, branch: str, project_name: str, folder: Path
+) -> str:
     """
     Determine the appropriate new tag for a given branch based on the latest changes.
 
@@ -577,6 +579,24 @@ def get_tag_for_branch(config: Config, remote: str, branch: str, folder: Path) -
     Raises:
         RuntimeError: If the command does not generate an output or fails to determine the tag.
     """
+    from commitizen.providers import ScmProvider
+    from commitizen.version_schemes import get_version_scheme, Increment
+    from commitizen.config.base_config import BaseConfig
+    from commitizen.defaults import Settings
+    from commitizen import bump
+
+    tag_format = f"{project_name}-$version"
+    cz_config = BaseConfig()
+    cz_config.update(
+        Settings(
+            name="cz_conventional_commits",
+            tag_format=tag_format,
+            version_scheme="pep440",
+            version_provider="scm",
+            major_version_zero=False,
+        )
+    )
+
     try:
         release_id = config.branch_to_release_id[branch]
     except KeyError:
@@ -585,35 +605,43 @@ def get_tag_for_branch(config: Config, remote: str, branch: str, folder: Path) -
             f"Must be one of {', '.join(config.branches)}"
         )
 
-    increment = "patch"
+    provider = ScmProvider(cz_config)
+    scheme = get_version_scheme(cz_config)
+    current_version = scheme(provider.get_version())
 
     # Only apply minor increment the most experimental branch
-    if is_pending_bump(config, remote, branch, folder):
-        increment = "minor"
+    if is_pending_bump(config, provider, remote, branch, folder):
+        increment: Increment = "MINOR"
+        exact_increment = True
+    else:
+        increment = "PATCH"
+        exact_increment = False
 
-    args = [f"--increment={increment}"]
     if release_id != ReleaseID.stable:
-        args += ["--prerelease", release_id.value]
-
-    if increment == "minor":
-        args += ["--increment-mode=exact"]
-
-    # run this in the project directory so that the pyproject.toml is accessible.
-    output = cz(*(["bump"] + list(args) + ["--dry-run", "--yes"]), folder=folder)
-    match = re.search("tag to create: (.*)", output)
-
-    if not match:
-        raise click.ClickException(output)
+        prerelease = release_id.value
+    else:
+        prerelease = None
+
+    new_version = current_version.bump(
+        increment,
+        prerelease=prerelease,
+        exact_increment=exact_increment,
+    )
 
-    tag = match.group(1).strip()
+    new_tag_version = bump.normalize_tag(
+        new_version,
+        tag_format=tag_format,
+        scheme=scheme,
+    )
 
-    return tag
+    return new_tag_version
 
 
-def get_projects() -> list[tuple[Path, str | None]]:
+def get_projects() -> list[tuple[Path, str]]:
     """Get the list of projects within the repo.
 
-    A project is a folder with a pyproject.toml file with a `tool.commitizen` section.
+    A project is a folder with a pyproject.toml file with a `tool.tide` section
+    and a `tool.tide.project`.
     """
     results = []
     repo = GitRepo(".")
@@ -621,24 +649,20 @@ def get_projects() -> list[tuple[Path, str | None]]:
         with open(path, "rb") as f:
             data = tomllib.load(f)
             try:
-                data["tool"]["commitizen"]
+                name = data["tool"][TOOL_NAME]["project"]
             except KeyError:
                 pass
             else:
-                try:
-                    name = data["project"]["name"]
-                except KeyError:
-                    name = None
                 results.append((Path(path).parent, name))
     return sorted(results)
 
 
 def get_modified_projects(
     base_rev: str, verbose: bool = False
-) -> list[tuple[Path, str | None]]:
+) -> list[tuple[Path, str]]:
     """Get the list of projects with changes files.
 
-    A project is defined as a folder with a pyproject.toml file with a `tool.commitizen` section.
+    A project is defined as a folder with a pyproject.toml file with a `tool.tide` section.
 
     Args:
         base_rev: The Git revision to compare against when identifying changed files