- Writing custom git flow scripts - a start

scripts/git/commands/bugfix.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from ..core import config, git_api, output
+
+
+def _bugfix_branch_name(name: str) -> str:
+    return f"{config.CONFIG.bugfix_prefix}{name}"
+
+
+def handle_bugfix_start(args) -> int:
+    name: str = args.name
+    cfg = config.CONFIG
+
+    try:
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.develop_branch, cfg.remote_name)
+
+        branch_name = _bugfix_branch_name(name)
+        output.info(f"Aanmaken van bugfix branch '{branch_name}' vanaf '{cfg.develop_branch}'")
+        git_api.create_branch(branch_name, cfg.develop_branch)
+        output.success(f"Bugfix branch '{branch_name}' is aangemaakt en gecheckt out.")
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+
+
+def handle_bugfix_finish(args) -> int:
+    cfg = config.CONFIG
+    name: str | None = args.name
+
+    try:
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+
+        if name is None:
+            current = git_api.get_current_branch()
+            if not current.startswith(cfg.bugfix_prefix):
+                raise git_api.GitError(
+                    "Je zit niet op een bugfix branch. Geef de bugfix-naam expliciet door (zonder prefix)."
+                )
+            bugfix_branch = current
+        else:
+            bugfix_branch = _bugfix_branch_name(name)
+
+        git_api.ensure_not_behind_remote(bugfix_branch, cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.develop_branch, cfg.remote_name)
+
+        output.info(f"Mergen van '{bugfix_branch}' naar '{cfg.develop_branch}'")
+        git_api.checkout_branch(cfg.develop_branch)
+
+        merge_args = ["merge"]
+        if cfg.use_no_ff_for_feature:
+            merge_args.append("--no-ff")
+        merge_args.append(bugfix_branch)
+
+        try:
+            git_api._run_git(merge_args)  # type: ignore[attr-defined]
+        except git_api.GitError as exc:
+            raise git_api.GitError(
+                "Merge is mislukt (mogelijk conflicten). Los de conflicten op en voltooi de merge handmatig."
+            ) from exc
+
+        output.success(f"Bugfix branch '{bugfix_branch}' is gemerged naar '{cfg.develop_branch}'.")
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+

scripts/git/commands/feature.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from ..core import config, git_api, output
+
+
+def _feature_branch_name(name: str) -> str:
+    return f"{config.CONFIG.feature_prefix}{name}"
+
+
+def handle_feature_start(args) -> int:
+    name: str = args.name
+    cfg = config.CONFIG
+
+    try:
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.develop_branch, cfg.remote_name)
+
+        branch_name = _feature_branch_name(name)
+        output.info(f"Aanmaken van feature branch '{branch_name}' vanaf '{cfg.develop_branch}'")
+        git_api.create_branch(branch_name, cfg.develop_branch)
+        output.success(f"Feature branch '{branch_name}' is aangemaakt en gecheckt out.")
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+
+
+def handle_feature_finish(args) -> int:
+    cfg = config.CONFIG
+    name: str | None = args.name
+
+    try:
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+
+        if name is None:
+            current = git_api.get_current_branch()
+            if not current.startswith(cfg.feature_prefix):
+                raise git_api.GitError(
+                    "Je zit niet op een feature branch. Geef de feature-naam expliciet door (zonder prefix)."
+                )
+            feature_branch = current
+        else:
+            feature_branch = _feature_branch_name(name)
+
+        # Zorg dat betrokken branches niet achterlopen op remote
+        git_api.ensure_not_behind_remote(feature_branch, cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.develop_branch, cfg.remote_name)
+
+        output.info(f"Mergen van '{feature_branch}' naar '{cfg.develop_branch}'")
+        git_api.checkout_branch(cfg.develop_branch)
+
+        merge_args = ["merge"]
+        if cfg.use_no_ff_for_feature:
+            merge_args.append("--no-ff")
+        merge_args.append(feature_branch)
+
+        try:
+            git_api._run_git(merge_args)  # type: ignore[attr-defined]
+        except git_api.GitError as exc:
+            raise git_api.GitError(
+                "Merge is mislukt (mogelijk conflicten). Los de conflicten op en voltooi de merge handmatig."
+            ) from exc
+
+        output.success(f"Feature branch '{feature_branch}' is gemerged naar '{cfg.develop_branch}'.")
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+

scripts/git/commands/hotfix.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from ..core import config, git_api, output
+
+
+def _hotfix_branch_name(name: str) -> str:
+    return f"{config.CONFIG.hotfix_prefix}{name}"
+
+
+def _ensure_version(name: str | None) -> str:
+    # Voor hotfix kunnen we dezelfde prompt gebruiken indien geen naam/versie is opgegeven
+    if name:
+        return name
+    output.info("Geen hotfix-naam/versie opgegeven. Gelieve een identificatie in te geven (bijv. 1.2.1 of short-name):")
+    entered = input("Hotfix: ").strip()
+    if not entered:
+        raise git_api.GitError("Geen hotfix-naam/versie opgegeven.")
+    return entered
+
+
+def handle_hotfix_start(args) -> int:
+    cfg = config.CONFIG
+    try:
+        raw_name: str = args.name
+        name = _ensure_version(raw_name)
+        branch_name = _hotfix_branch_name(name)
+
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.main_branch, cfg.remote_name)
+
+        output.info(f"Aanmaken van hotfix branch '{branch_name}' vanaf '{cfg.main_branch}'")
+        git_api.create_branch(branch_name, cfg.main_branch)
+        output.success(f"Hotfix branch '{branch_name}' is aangemaakt en gecheckt out.")
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+
+
+def handle_hotfix_finish(args) -> int:
+    cfg = config.CONFIG
+    try:
+        name_arg = getattr(args, "name", None)
+
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+
+        if name_arg:
+            name = name_arg
+            hotfix_branch = _hotfix_branch_name(name)
+        else:
+            current = git_api.get_current_branch()
+            prefix = cfg.hotfix_prefix
+            if current.startswith(prefix):
+                name = current[len(prefix) :]
+                hotfix_branch = current
+            else:
+                name = _ensure_version(None)
+                hotfix_branch = _hotfix_branch_name(name)
+
+        git_api.ensure_not_behind_remote(hotfix_branch, cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.main_branch, cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.develop_branch, cfg.remote_name)
+
+        # Voor nu vragen we ook hier de versie/naam en gebruiken die voor de tag.
+        # In een latere iteratie kunnen we hier automatische patch-bumping doen.
+        version_for_tag = name
+        tag_name = cfg.tag_format.format(version=version_for_tag)
+
+        # Merge naar main
+        output.info(f"Mergen van '{hotfix_branch}' naar '{cfg.main_branch}' en tag '{tag_name}' aanmaken")
+        git_api.checkout_branch(cfg.main_branch)
+        merge_args = ["merge"]
+        if cfg.use_no_ff_for_hotfix:
+            merge_args.append("--no-ff")
+        merge_args.append(hotfix_branch)
+        try:
+            git_api._run_git(merge_args)  # type: ignore[attr-defined]
+        except git_api.GitError as exc:
+            raise git_api.GitError(
+                "Merge van hotfix naar main is mislukt (mogelijk conflicten). Los de conflicten op en voltooi de merge handmatig."
+            ) from exc
+
+        git_api._run_git(["tag", tag_name])  # type: ignore[attr-defined]
+
+        # Merge naar develop
+        output.info(f"Mergen van '{hotfix_branch}' naar '{cfg.develop_branch}'")
+        git_api.checkout_branch(cfg.develop_branch)
+        merge_args = ["merge"]
+        if cfg.use_no_ff_for_hotfix:
+            merge_args.append("--no-ff")
+        merge_args.append(hotfix_branch)
+        try:
+            git_api._run_git(merge_args)  # type: ignore[attr-defined]
+        except git_api.GitError as exc:
+            raise git_api.GitError(
+                "Merge van hotfix naar develop is mislukt (mogelijk conflicten). Los de conflicten op en voltooi de merge handmatig."
+            ) from exc
+
+        output.success(
+            f"Hotfix '{name}' is voltooid: gemerged naar '{cfg.main_branch}' en '{cfg.develop_branch}' en getagd als '{tag_name}'."
+        )
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+

scripts/git/commands/release.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from ..core import config, git_api, output
+
+
+def _release_branch_name(version: str) -> str:
+    return f"{config.CONFIG.release_prefix}{version}"
+
+
+def _ensure_version(version: str | None) -> str:
+    if version:
+        return version
+    # Eenvoudige interactieve prompt; later kunnen we validatie uitbreiden
+    output.info("Geen versie opgegeven. Gelieve een versie in te geven (bijv. 1.2.0):")
+    entered = input("Versie: ").strip()
+    if not entered:
+        raise git_api.GitError("Geen versie opgegeven.")
+    return entered
+
+
+def handle_release_start(args) -> int:
+    cfg = config.CONFIG
+    try:
+        version = _ensure_version(getattr(args, "version", None))
+        branch_name = _release_branch_name(version)
+
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.develop_branch, cfg.remote_name)
+
+        output.info(f"Aanmaken van release branch '{branch_name}' vanaf '{cfg.develop_branch}'")
+        git_api.create_branch(branch_name, cfg.develop_branch)
+        output.success(f"Release branch '{branch_name}' is aangemaakt en gecheckt out.")
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+
+
+def handle_release_finish(args) -> int:
+    cfg = config.CONFIG
+    try:
+        version_arg = getattr(args, "version", None)
+        git_api.ensure_clean_working_tree()
+        git_api.fetch_remote(cfg.remote_name)
+
+        if version_arg:
+            version = version_arg
+            release_branch = _release_branch_name(version)
+        else:
+            # Probeer huidige branch te gebruiken
+            current = git_api.get_current_branch()
+            prefix = cfg.release_prefix
+            if current.startswith(prefix):
+                version = current[len(prefix) :]
+                release_branch = current
+            else:
+                # Geen logische branch, vraag versie interactief
+                version = _ensure_version(None)
+                release_branch = _release_branch_name(version)
+
+        # Zorg dat betrokken branches niet achterlopen
+        git_api.ensure_not_behind_remote(release_branch, cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.main_branch, cfg.remote_name)
+        git_api.ensure_not_behind_remote(cfg.develop_branch, cfg.remote_name)
+
+        tag_name = cfg.tag_format.format(version=version)
+
+        # Merge naar main
+        output.info(f"Mergen van '{release_branch}' naar '{cfg.main_branch}' en tag '{tag_name}' aanmaken")
+        git_api.checkout_branch(cfg.main_branch)
+        merge_args = ["merge"]
+        if cfg.use_no_ff_for_release:
+            merge_args.append("--no-ff")
+        merge_args.append(release_branch)
+        try:
+            git_api._run_git(merge_args)  # type: ignore[attr-defined]
+        except git_api.GitError as exc:
+            raise git_api.GitError(
+                "Merge naar main is mislukt (mogelijk conflicten). Los de conflicten op en voltooi de merge handmatig."
+            ) from exc
+
+        # Tag aanmaken op main
+        git_api._run_git(["tag", tag_name])  # type: ignore[attr-defined]
+
+        # Merge terug naar develop
+        output.info(f"Mergen van '{release_branch}' terug naar '{cfg.develop_branch}'")
+        git_api.checkout_branch(cfg.develop_branch)
+        merge_args = ["merge"]
+        if cfg.use_no_ff_for_release:
+            merge_args.append("--no-ff")
+        merge_args.append(release_branch)
+        try:
+            git_api._run_git(merge_args)  # type: ignore[attr-defined]
+        except git_api.GitError as exc:
+            raise git_api.GitError(
+                "Merge naar develop is mislukt (mogelijk conflicten). Los de conflicten op en voltooi de merge handmatig."
+            ) from exc
+
+        output.success(
+            f"Release '{version}' is voltooid: gemerged naar '{cfg.main_branch}' en '{cfg.develop_branch}' en getagd als '{tag_name}'."
+        )
+        return 0
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+

scripts/git/commands/status.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from ..core import config, git_api, output
+
+
+def handle_status(args) -> int:  # noqa: ARG001 - argparse API
+    """Toon huidige branch en eenvoudige status-info."""
+
+    try:
+        branch = git_api.get_current_branch()
+    except git_api.GitError as exc:
+        output.error(str(exc))
+        return 1
+
+    clean = git_api.is_clean_working_tree()
+
+    output.heading("Repo status")
+    output.plain(f"Huidige branch : {branch}")
+    output.plain(f"Working tree   : {'clean' if clean else 'NIET clean'}")
+
+    # Optionele remote-checks
+    cfg = config.CONFIG
+    for important_branch in {cfg.main_branch, cfg.develop_branch, branch}:
+        try:
+            git_api.ensure_not_behind_remote(important_branch, cfg.remote_name)
+        except git_api.GitError as exc:
+            output.warning(str(exc))
+
+    return 0
+