git-flow-envs 1.14.0__py3-none-any.whl

git_flow/__init__.py

@@ -0,0 +1,63 @@
+GitFlowError = ValueError
+
+BRANCH_TYPES = [
+    "feature",
+    "refactor",
+    "bugfix",
+    "hotfix",
+    "chore",
+    "docs",
+]
+
+COMMIT_TYPES = [
+    "feature",
+    "bugfix",
+    "hotfix",
+    "refactor",
+    "perf",
+    "docs",
+    "style",
+    "test",
+    "wip",
+]
+
+WIP_BRANCH_PREFIX = "wip/"
+TRASH_BRANCH_PREFIX = "trash/"
+
+# Commits con estos valores incrementan el componente correspondiente
+SEMVER_MAJOR = 3
+SEMVER_MINOR = 2
+SEMVER_PATCH = 1
+
+# Commits con estos tipos no alteran la versión
+SEMVER_SKIP = 0
+
+COMMIT_TYPE_INCREMENT = {
+    "feature": SEMVER_MINOR,
+    "bugfix": SEMVER_PATCH,
+    "hotfix": SEMVER_PATCH,
+    "refactor": SEMVER_SKIP,
+    "perf": SEMVER_SKIP,
+    "docs": SEMVER_SKIP,
+    "style": SEMVER_SKIP,
+    "test": SEMVER_SKIP,
+}
+
+SUPPORTED_REMOTE_APIS = [
+    "bitbucket.org",
+    "github.com",
+]
+
+REPOSITORY_TOKEN_FILENAME = ".repository-token"
+
+COLOR_BLACK = "\033[30m"
+COLOR_RED = "\033[31m"
+COLOR_GREEN = "\033[32m"
+COLOR_YELLOW = "\033[33m"
+COLOR_BLUE = "\033[34m"
+COLOR_5 = "\033[35m"
+COLOR_6 = "\033[36m"
+COLOR_7 = "\033[37m"
+COLOR_BLACK_BOLD = "\033[1;30m"
+COLOR_WHITE_BOLD = "\033[1;37m"
+COLOR_RESET = "\033[0m"

git_flow/changelog.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+from os.path import isfile
+
+from git_flow.git import Git
+
+
+class Changelog:
+    FILENAME = "CHANGELOG.md"
+    COMMIT_MESSAGE = "chore: bump version and update CHANGELOG.md [skip ci]"
+
+    def update(self, title: str, base: str, branch: str):
+        self._prepend(self.generate_entry(title, base, branch))
+
+    def generate_header(self, title):
+        now = datetime.now()
+
+        return f"""## {title} - {now.strftime("%F")}
+
+"""
+
+    def generate_content(self, base: str, branch: str):
+        commits = Git(
+            "log", base + ".." + branch, first_parent=True, format="%h", merges=False
+        ).lines()
+        content = ""
+
+        for commit in commits:
+            message = Git("show", commit, patch=False, format="%s").firstline()
+            email = Git("show", commit, patch=False, format="%ae").firstline()
+            username = email[: email.index("@")]
+            index = message.index(":")
+            commit_type = message[:index]
+            commit_message = message[index + 1 :]
+
+            content += f"- **{commit_type}**: {commit_message} [[{username}](mailto:{email})] ({commit})\n"
+
+        return content
+
+    def generate_footer(self):
+        return """
+---
+
+
+"""
+
+    def generate_entry(self, title: str, base: str, branch: str):
+        return (
+            self.generate_header(title)
+            + self.generate_content(base, branch)
+            + self.generate_footer()
+        )
+
+    def _prepend(self, content: str):
+        if isfile(self.FILENAME):
+            with open(self.FILENAME, "r") as f:
+                content += f.read()
+
+        with open(self.FILENAME, "w") as f:
+            f.write(content)

git_flow/command/base.py

@@ -0,0 +1,236 @@
+from argparse import Namespace, ArgumentParser
+from abc import ABC, abstractmethod
+from os.path import isfile
+
+from git_flow import (
+    BRANCH_TYPES,
+    COLOR_BLUE,
+    COLOR_GREEN,
+    COLOR_RED,
+    COLOR_RESET,
+    COLOR_YELLOW,
+    REPOSITORY_TOKEN_FILENAME,
+    GitFlowError,
+)
+from git_flow.git import FLOWCONFIG_FILE, Git
+from git_flow.remote.base import RemoteAPI
+from git_flow.remote.bitbucket import BitbucketRemoteAPI
+from git_flow.remote.github import GithubRemoteAPI
+
+TYPE_SUCCESS = 0
+TYPE_WARNING = 1
+TYPE_ERROR = 2
+TYPE_INFO = 3
+
+
+class Command(ABC):
+    flowconfig: dict[str, str]
+
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abstractmethod
+    def description(self) -> str:
+        pass
+
+    @abstractmethod
+    def run(self, args: Namespace = Namespace()):
+        pass
+
+    def init(self):
+        self.flowconfig = (
+            Git.get_config(FLOWCONFIG_FILE) if isfile(FLOWCONFIG_FILE) else {}
+        )
+
+    def success(self, msg: str):
+        self._print(TYPE_SUCCESS, msg)
+
+    def warning(self, msg: str):
+        self._print(TYPE_WARNING, msg)
+
+    def error(self, msg: str):
+        self._print(TYPE_ERROR, msg)
+
+    def info(self, msg: str):
+        self._print(TYPE_INFO, msg)
+
+    def prompt(
+        self,
+        prompt: str,
+        default: str | None = None,
+        persistent: bool = False,
+        strip: bool = True,
+    ) -> str:
+        onetime = not persistent
+
+        while onetime or persistent:
+            if default:
+                prompt += f" [{default}]"
+
+            prompt += ": "
+            result = input(prompt)
+            result = result.strip() if strip else result
+
+            if result:
+                return result
+            elif default is not None:
+                return default
+            elif persistent:
+                self.error("Debe ingresar un valor no vacío.")
+            else:
+                return result
+
+    def confirm(self, question: str, default: bool = True):
+        suffix = " [Y/n]: " if default else " [y/N]: "
+        answer = input(question + suffix)
+
+        return default if len(answer) == 0 else answer.startswith("y")
+
+    def choice(self, prompt: str, options: list[str]):
+        print(prompt)
+
+        for i, option in enumerate(options):
+            print(f"\t{i+1}. {option}")
+
+        selection = None
+
+        while selection is None:
+            answer = input(f"Seleccione una opción [1-{len(options)}] o escribala: ")
+
+            if answer.isdigit():
+                answer = int(answer)
+
+                if 1 <= answer and answer <= len(options):
+                    selection = options[answer - 1]
+
+                    if not self.confirm(
+                        f"Seleccionó la opción {answer} ({selection}), ¿es correcto?"
+                    ):
+                        selection = None
+                else:
+                    self.error(f"La opción {answer} está fuera del rango permitido.")
+            elif answer in options:
+                selection = answer
+            else:
+                self.error(f"La opción '{answer}' es inválida.")
+
+        return selection
+
+    def setup_parser(self, parser: ArgumentParser) -> ArgumentParser:
+        return parser
+
+    def ensure_initialized(self):
+        initialized = self.flowconfig["flow.initialized"] if self.flowconfig else None
+
+        if not initialized:
+            raise GitFlowError(
+                "El repositorio no fue inicializado, debe ejecutar el comando `init`."
+            )
+        elif initialized != "true":
+            raise GitFlowError(
+                f"El valor de `flow.initialized` ({initialized}) es inválido."
+            )
+
+    def ensure_right_branch(self):
+        branch = Git.get_current_branch()
+
+        if branch == "HEAD":
+            raise GitFlowError("No se encuentra parado sobre una rama.")
+        elif self.confirm(f"Se encuentra sobre la rama '{branch}'. ¿Es correcto?"):
+            return branch
+        else:
+            raise GitFlowError("Ejecución cancelada.")
+
+    def ensure_repository_token(self):
+        if not isfile(REPOSITORY_TOKEN_FILENAME):
+            raise GitFlowError(
+                "No existe un token para el repositorio en " + REPOSITORY_TOKEN_FILENAME
+            )
+
+        with open(REPOSITORY_TOKEN_FILENAME) as f:
+            return f.readline().strip()
+
+    def ensure_clean_worktree(self, has_remote: bool):
+        status = Git.status()
+
+        if not status:
+            return
+
+        not_empty = any(map(lambda s: s.index != " " or s.worktree != " ", status))
+
+        if not_empty:
+            if not has_remote:
+                self.warning("Existen cambios en tu entorno de trabajo sin commitear.")
+            else:
+                raise GitFlowError("No se puede continuar con cambios pendientes.")
+
+            if not self.confirm("¿Desea continuar?", False):
+                raise GitFlowError("Ejecución abortada")
+
+    def get_branch_env_and_type(self, branch: str) -> tuple[str, str]:
+        components = branch.split("/")
+        target_branches = self.flowconfig["flow.branches"].split(",")
+
+        if len(components) == 2:
+            if components[0] not in BRANCH_TYPES:
+                raise GitFlowError(
+                    f"Branch inválida, el tipo '{components[0]}' no es válido."
+                )
+
+            return (target_branches[0], components[0])
+        elif len(components) == 4:
+            target_branches = target_branches[1:]
+
+            if (
+                components[0] != "release"
+                or components[1] not in target_branches
+                or components[2] not in BRANCH_TYPES
+            ):
+                raise GitFlowError(
+                    "Branch release inválido, debe tener el siguiente formato: "
+                    "release/<env>/<type>/<name>, pero es: " + branch
+                )
+
+            return (components[1], components[2])
+        else:
+            raise GitFlowError("Branch inválido: " + branch)
+
+    def get_remote_api(self, token: str) -> RemoteAPI:
+        if "flow.remote" not in self.flowconfig:
+            raise GitFlowError("El repositorio no tiene configurado un remoto.")
+
+        [host, repository] = RemoteAPI.parse(self.flowconfig["flow.remote"])
+
+        if host == "bitbucket.org":
+            return BitbucketRemoteAPI(repository, token)
+        elif host == "github.com":
+            return GithubRemoteAPI(repository, token)
+        else:
+            raise GitFlowError("El host del repositorio remoto es inválido")
+
+    def _print(self, type: int, msg: str):
+        print(self._get_color(type) + self._get_tag(type) + " " + msg + COLOR_RESET)
+
+    def _get_color(self, type: int) -> str:
+        if type == TYPE_SUCCESS:
+            return COLOR_GREEN
+        elif type == TYPE_WARNING:
+            return COLOR_YELLOW
+        elif type == TYPE_ERROR:
+            return COLOR_RED
+        elif type == TYPE_INFO:
+            return COLOR_BLUE
+        return ""
+
+    def _get_tag(self, type: int) -> str:
+        if type == TYPE_SUCCESS:
+            return "[success]"
+        elif type == TYPE_WARNING:
+            return "[warning]"
+        elif type == TYPE_ERROR:
+            return "[error]"
+        elif type == TYPE_INFO:
+            return "[info]"
+
+        return ""

git_flow/command/branch.py

@@ -0,0 +1,117 @@
+from argparse import ArgumentParser, Namespace
+from git_flow import COLOR_WHITE_BOLD,  COLOR_GREEN, COLOR_RED, COLOR_RESET, TRASH_BRANCH_PREFIX, WIP_BRANCH_PREFIX, GitFlowError
+from git_flow.command.base import Command
+from git_flow.git import Git
+
+
+BRANCH_FORMAT = "%(refname:short)"
+
+
+class BranchCommand(Command):
+    def name(self) -> str:
+        return "branch"
+
+    def description(self) -> str:
+        return """Lista ramas del repositorio, agrupandolas por entorno objetivo"""
+
+    def setup_parser(self, parser: ArgumentParser) -> ArgumentParser:
+        parser.add_argument(
+            "environment",
+            nargs="?",
+            help="Entorno de las ramas a listar. Por defecto, es el entorno actual.",
+        )
+
+        parser.add_argument(
+            "--trash",
+            action="store_true",
+            help=f"Listar ramas en la 'papelera de reciclaje' (ramas que empiezan con '{TRASH_BRANCH_PREFIX}')"
+        )
+
+        parser.add_argument(
+            "--wip",
+            action="store_true",
+            help=f"Listar ramas 'en progreso' (ramas que empiezan con '{WIP_BRANCH_PREFIX}')"
+        )
+
+        parser.add_argument(
+            "--all",
+            action="store_true",
+            help=f"Listar ramas de todos los entornos"
+        )
+
+        return parser
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+
+        self.current_branch = Git.get_current_branch()
+        self.environments = self.flowconfig["flow.branches"].split(",")
+
+        if self.current_branch in self.environments:
+            current_environment = self.current_branch
+        else:
+            (current_environment, _) = self.get_branch_env_and_type(self.current_branch)
+
+        if args.trash:
+            self.show_branches(TRASH_BRANCH_PREFIX)
+        elif args.wip:
+            self.show_branches(WIP_BRANCH_PREFIX)
+        elif args.all:
+            self.show_envs()
+            self.show_all_branches()
+        elif args.environment is None:
+            self.show_envs()
+            self.show_env_branches(current_environment)
+        elif args.environment in self.environments:
+            self.show_envs()
+            self.show_env_branches(args.environment)
+        else:
+            raise GitFlowError(f"'{args.environment}' no es un entorno válido.")
+
+    def show_branches(self, prefix: str):
+        branches = self.get_branches(prefix)
+
+        if not branches:
+            print("No hay ramas a mostrar.")
+            return
+
+        for branch in branches:
+            prefix = (COLOR_RED + "*") if branch == self.current_branch else " "
+            print(prefix + " " + branch + COLOR_RESET)
+
+    def get_branches(self, prefix: str):
+        return Git("for-each-ref", "refs/heads/" + prefix, format=BRANCH_FORMAT).lines()
+
+    def show_all_branches(self):
+        for environment in self.environments:
+            self.show_env_branches(environment, len(self.environments) > 1)
+
+        trash = len(self.get_branches(TRASH_BRANCH_PREFIX))
+
+        if trash:
+            print()
+            print(COLOR_WHITE_BOLD + "Papelera: " + COLOR_RESET + str(trash) + " rama" + ("" if trash == 1 else "s"))
+
+    def show_envs(self):
+        print(COLOR_WHITE_BOLD + "Entornos" + COLOR_RESET)
+        for environment in self.environments:
+            prefix = (COLOR_GREEN + "*") if environment == self.current_branch else " "
+            print(prefix + " " + environment + COLOR_RESET)
+        print()
+
+    def show_env_branches(self, environment: str, show_env: bool = False):
+        is_first_env = environment == self.environments[0]
+        pattern = "refs/heads/" if is_first_env else "refs/heads/release/" + environment + "/"
+        pattern += "*/*"
+        exclude = ["refs/heads/" + TRASH_BRANCH_PREFIX, "refs/heads/release/"] if is_first_env else []
+        branches = Git("for-each-ref", pattern, exclude=exclude, format=BRANCH_FORMAT).lines()
+
+        print(COLOR_WHITE_BOLD + (environment if show_env else "Ramas") + COLOR_RESET)
+
+        if not branches:
+            print("No hay ramas a mostrar.")
+            return
+
+        for branch in branches:
+            prefix = (COLOR_GREEN + "*") if branch == self.current_branch else " "
+            print(prefix + " " + branch + COLOR_RESET)

git_flow/command/commit.py

@@ -0,0 +1,62 @@
+from argparse import Namespace
+from datetime import datetime
+from git_flow import COMMIT_TYPES, TRASH_BRANCH_PREFIX, WIP_BRANCH_PREFIX, GitFlowError
+from git_flow.command.base import Command
+from git_flow.git import Git
+
+
+class CommitCommand(Command):
+    def name(self) -> str:
+        return "commit"
+
+    def description(self) -> str:
+        return """Crea un commit siguiendo el formato de Conventional Commits"""
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+        branch = self.ensure_right_branch()
+
+        if not self._has_files_staged():
+            self.warning("No hay cambios en el indice para commitear.")
+            if self.confirm("¿Desea agregar la carpeta actual?"):
+                Git("add", ".").exec(print="Agregando cambios")
+            else:
+                raise GitFlowError(
+                    "Debe agregar algún cambio al indice para continuar."
+                )
+
+        commit_type = self.choice("Tipo de commit", COMMIT_TYPES)
+        commit_message = self.prompt(
+            "Mensaje (máximo recomendado: 100 caracteres)", persistent=True
+        )
+        message = commit_type + ": " + commit_message
+
+        if branch.startswith(WIP_BRANCH_PREFIX):
+            original_branch = branch.removeprefix(WIP_BRANCH_PREFIX)
+            Git("commit", m=message).exec(print="Creando commit en rama WIP")
+
+            if commit_type != "wip":
+                suffix = datetime.now().strftime("%Y%m%dT%H%M")
+                Git("switch", original_branch).exec(print="Volviendo a rama original")
+                Git("merge", branch, squash=True).exec(print="Squasheando commits WIP en uno solo")
+                Git("commit", m=message).exec(print="Creando commit final de rama WIP")
+                Git("branch", branch, TRASH_BRANCH_PREFIX + branch + "/" + suffix, move=True).exec(print="Backup de rama WIP")
+        else:
+            if commit_type == "wip":
+                Git("switch", WIP_BRANCH_PREFIX + branch, create=True).exec(print="Creando nueva rama WIP")
+
+            Git("commit", m=message).exec(print="Creando commit")
+
+    def _has_files_staged(self):
+        status = Git.status()
+
+        if not status:
+            raise GitFlowError("No hay cambios para commitear.")
+
+        files_in_index = []
+
+        for s in status:
+            if s.worktree != "?" and s.worktree != " ":
+                files_in_index.append(s.file)
+
+        return len(files_in_index) > 0

git_flow/command/init.py

@@ -0,0 +1,115 @@
+from argparse import Namespace
+from git_flow import GitFlowError
+from git_flow.command.base import Command
+from git_flow.git import FLOWCONFIG_FILE, Git
+
+
+class InitCommand(Command):
+    def name(self) -> str:
+        return "init"
+
+    def description(self) -> str:
+        return """Inicializa el repositorio para utilizar git-flow"""
+
+    def run(self, args: Namespace = Namespace()):
+        self._ensure_is_repository()
+        self._ensure_not_already_initialized()
+
+        branches = self._setup_flow_branches()
+        remote = self._setup_flow_remote()
+
+        flowconfig = {
+            "flow.initialized": "true",
+            "flow.branches": ",".join(branches),
+        }
+
+        if remote:
+            flowconfig["flow.remote"] = remote
+
+        Git.set_config(flowconfig, FLOWCONFIG_FILE)
+        Git("add", FLOWCONFIG_FILE).exec()
+        Git("commit", message="feature: initialize git-flow").exec()
+
+        self._ensure_all_flow_branches_exist(branches, remote)
+
+    def _ensure_is_repository(self):
+        if not Git.is_repository():
+            self.warning("El directorio actual no es un repositorio.")
+
+            if not self.confirm("¿Desea inicializarlo?"):
+                raise GitFlowError(
+                    "No se puede continuar sin inicializar el repositorio"
+                )
+
+            Git("init").exec()
+
+    def _ensure_not_already_initialized(self):
+        if not self.flowconfig:
+            return
+        elif self.flowconfig.get("flow.initialized") == "true":
+            raise GitFlowError("El repositorio ya fue inicializado para usar git-flow")
+        else:
+            raise GitFlowError("Valor de 'flow.initialized' es inválido")
+
+    def _setup_flow_branches(self):
+        self.info(
+            """Ingrese las ramas que representan los entornos de deploy del proyecto en
+            orden creciente de cercanía al entorno productivo, y separados por coma.
+            Por ejemplo: "dev,test,prod"."""
+        )
+
+        branches = list(
+            map(lambda b: b.strip(), self.prompt("Ramas", "main").split(","))
+        )
+
+        if not all(branches):
+            raise GitFlowError("No puede ingresar una rama vacia")
+
+        return branches
+
+    def _setup_flow_remote(self):
+        self.info(
+            """Puede elegir o crear un repositorio remoto para generar automáticamente PRs"""
+        )
+
+        remote = None
+
+        if self.confirm("¿Configurar repositorio remoto?"):
+            remotes = Git("remote").lines(print="Listando remotos disponibles")
+
+            if not remotes:
+                self.info("No tiene ningún repositorio remoto, se creará uno.")
+
+                url = self.prompt(
+                    "Ingrese la URL del repositorio (e.g. https://github.com/user/repo.git)",
+                    persistent=True,
+                )
+                remote = "origin"
+                Git("remote", "add", remote, url).exec(print="Agregando remoto")
+            elif len(remotes) == 1:
+                remote = remotes[0]
+            else:
+                self.info("Tiene más de un remoto, seleccione el que va a utilizar.")
+                remote = self.choice("Remoto", remotes)
+
+        return remote
+
+    def _ensure_all_flow_branches_exist(self, branches: list[str], remote: str | None):
+        existing_branches = Git.get_branches()
+
+        if not all(map(lambda b: b in existing_branches, branches)):
+            self.warning("Algunas de las ramas de entornos expecificadas no existen.")
+            self.info("Debe indicar sobre que rama se crearán las ramas de entorno.")
+
+            target_branch = self.choice("Rama", existing_branches)
+
+            for branch in branches:
+                if branch not in existing_branches:
+                    Git("branch", branch, target_branch).exec(
+                        print="Creando rama inexistente"
+                    )
+
+                    if remote:
+                        Git("push", remote, branch, set_upstream=True).exec(
+                            print="Creando rama en remoto"
+                        )