CLI jako narzędzie zarządzania projektem i automatyzacji zadań deweloperskich

# Define that the following targets are not files
.PHONY: help app-start app-exec app-run app-logs \
        code-format code-check code-test code-all \
		db-cli

# Define working directory
WORKING_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))

# Load environment variables from .env file (if there are variables set in the format VAR=value)
-include $(WORKING_DIR)/.env

# Abbreviation for docker compose
CMD_DC := docker compose

# Macro for running a command with arguments
#   - get arguments from MAKECMDGOALS except the current target ($@)
#   - if no arguments, set the default value passed as $(2)
#   - run command passed as $(1) and collected arguments
define RUN_WITH_ARGS
	@args="$(filter-out $@,$(MAKECMDGOALS))"; \
	if [ -z "$$args" ]; then \
	    args="$(2)"; \
	fi; \
	echo "Running: $(1) $$args"; \
	$(1) $$args
endef


help:
	@echo "Available targets:"
	@echo "  make app-start               - Start the project using the command 'docker compose up'."
	@echo "  make app-logs ARGS='<args>'  - Displays logs from Docker containers "
	@echo "                                 using the command 'docker compose logs -f <args>'."
	@echo "  make app-run ARGS='<args>'   - Starts the Docker container and executes a command in it "
	@echo "                                 using the command 'docker compose run --rm <args>'. "
	@echo "                                 Default args are 'fastapi sh'."
	@echo "  make app-exec ARGS='<args>'  - Execute a command in a running Docker container "
	@echo "                                 using the command 'docker compose exec -it <args>'. "
	@echo "                                 Default args are 'fastapi sh'."
	@echo ""
	@echo "  make code-format             - Formats code"
	@echo "  make code-check              - Lints code"
	@echo "  make code-test ARGS='<args>' - Runs unit tests using the command 'pytest <args>'."
	@echo "  make code-all                - Formats, lints, and tests code all in one go"
	@echo ""
	@echo "  make db-cli                  - Connect to the Postgres database using psql."
	@echo ""


# Targets for the "app" section
app-start:
	$(CMD_DC) up

app-logs:
	$(CMD_DC) logs -f $(ARGS)

app-run:
	$(CMD_DC) run --rm $(or $(ARGS),fastapi sh)

app-exec:
	$(call RUN_WITH_ARGS,$(CMD_DC) exec -it,fastapi sh)


# Targets for the "code" section
code-format:
	$(CMD_DC) run --rm fastapi ruff format

code-check:
	$(CMD_DC) run --rm fastapi ruff check --fix

code-test:
	$(CMD_DC) run --rm fastapi pytest $(ARGS)

code-all:
	$(CMD_DC) run --rm fastapi /bin/sh -c "ruff format && ruff check --fix && pytest"

# Targets for the "db" section
db-cli:
	$(CMD_DC) exec -it postgres psql -U $(POSTGRES_USER) $(POSTGRES_DB)


# Catch-all – will catch all undefined targets
%:
	@:

make app-start
# docker compose up

make code-all
# docker compose run --rm fastapi /bin/sh -c "ruff format && ruff check --fix && pytest"

make app-logs ARGS=fastapi
# docker compose logs -f fastapi

app-run:
	$(CMD_DC) run --rm $(or $(ARGS),fastapi sh)

make app-run
# docker compose run --rm fastapi sh

make app-run ARGS=db sh
# docker compose run db bash

# Macro for running a command with arguments
#   - get arguments from MAKECMDGOALS except the current target ($@)
#   - if no arguments, set the default value passed as $(2)
#   - run command passed as $(1) and collected arguments
define RUN_WITH_ARGS
	@args="$(filter-out $@,$(MAKECMDGOALS))"; \
	if [ -z "$$args" ]; then \
	    args="$(2)"; \
	fi; \
	echo "Running: $(1) $$args"; \
	$(1) $$args
endef

app-exec:
	$(call RUN_WITH_ARGS,$(CMD_DC) exec -it,fastapi sh)

# Catch-all – will catch all undefined targets
%:
	@:

app-exec:
	$(call RUN_WITH_ARGS,$(CMD_DC) exec -it,fastapi sh)

make app-exec fastapi ls -lah

%:
	@:

POSTGRES_USER=pg_user
POSTGRES_DB=pg_db

# Define working directory
WORKING_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))

# Load environment variables from .env file (if there are variables set in the format VAR=value)
-include $(WORKING_DIR)/.env

db-cli:
	$(CMD_DC) exec -it postgres psql -U $(POSTGRES_USER) $(POSTGRES_DB)

make db-cli
# docker compose exec -it postgres psql -U pg_user pg_db

#!/usr/bin/env bash  
  
#~ A script to manage the project  
#~  
#~ It contains shortcuts to run common commands used in the project.  
#~  
#~ Usage: ./cli [options]  
#~  
  
WORKING_DIR="$(dirname ${0})"  
  
  
load_env() { 
  local ENV_FILE="${1?Missing environment file}"  
  local ENVS_ARRAY VAR_DECLARATION  
  mapfile ENVS_ARRAY < <(  
    grep --invert-match '^#' "${ENV_FILE}" | grep --invert-match '^\s*$'  
  ) # Uses grep to remove commented and blank lines  
  for VAR_DECLARATION in "${ENVS_ARRAY[@]}"; do  
    { # try  
      export "${VAR_DECLARATION//[$'\r\n']}" # The substitution removes the line breaks  
    } || { # catch  
       echo "Cannot load '${VAR_DECLARATION}'"  
    }  
  done
}  
  
  
display_help() {  
    # Creating help text by reading comments from the source file.  
    # Displays all lines that start with #~, regardless of CRLF
	local src="$0"  
    sed -n 's/^\(\r*[[:space:]]*\)#~/\1/p' "$src"  
}  
  
cmd_dc () {  
    local cmd=(docker compose "$@")  
    echo "Running: ${cmd[*]}"  
    eval "${cmd[@]}"  
}  
  
load_env "${WORKING_DIR}/.env"  
  
case "$1" in  
    #~ Application:  
    app)  
        case $2 in  
            #~ app start - starts the project in detached mode and displays logs  
            start)  
                cmd_dc up 
                ;;  
            #~ app exec [<container> [<command>]] - executes a command in the running container  
            #~     - default container is fastapi and default command is sh
            exec)  
                cmd_dc exec -it "${3:-fastapi sh}" "${@:4}"  
                ;;  
            #~ app run [<container> [<command>]] - runs a command in the selected container  
            #~     - default container is fastapi and default command is sh
            run)  
                cmd_dc run --rm "${3:-fastapi sh}" "${@:4}"  
                ;;  
            #~ app logs - shows Docker Compose logs and follows them  
            logs)  
                cmd_dc logs -f "${@:3}"  
                ;;  
            #~  
            *)  
                display_help  
                ;;  
        esac
        ;;
    #~ Code quality:  
    code)  
        case $2 in  
            #~ code format - formats the code  
            format)  
                cmd_dc run --rm fastapi ruff format  
                ;;  
            #~ code check - lints the code  
            check)  
                cmd_dc run --rm fastapi ruff check --fix  
                ;;  
            #~ code test - runs unit tests  
            test)  
                cmd_dc run --rm fastapi pytest "${@:3}"  
                ;; 
            #~ code all - runs 'format', 'check', and 'test' commands together  
            all)  
                cmd_dc run --rm fastapi /bin/sh -c "\"ruff format && ruff check --fix && pytest\""  
                ;;  
            #~  
            *)  
                display_help  
                ;;  
        esac
		;;
	#~ Database:
    db)
        case $2 in
            #~ db cli - connects to PostgreSQL database using psql
            cli)
                cmd_dc exec -it postgres psql -U "${POSTGRES_USER}" "${POSTGRES_DB}"
                ;;
        esac
		;;
    #~ --help | -h Displays this help text.
	--help|-h)  
        display_help  
        ;;  
    #~  
    *)  
        display_help  
        ;;  
esac

./cli app start
# docker compose up

case "$1" in
    app)  
        case $2 in
            start)  
                cmd_dc up 
                ;;

./cli app run
# docker compose run --rm fastapi sh

./cli app run fastapi ls -lah
# docker compose run --rm fastapi ls -lah

./cli db cli
# docker compose exec -it postgres psql -U pg_user pg_db

./cli -h
# A script to manage the project
#
# It contains shortcuts to run common commands used in the project.
#
# Usage: ./cli [options]
#
#     Application:
#             app start - starts project in detached mode and display logs
#             app exec [<container> [<command>]] - execute command in running selected container
#                 - default container is fastapi and default command is sh
#             app run [<container> [<command>]] - run command in selected container
#                 - default container is fastapi and default command is sh
#             app logs - shows docker compose logs and follow
#            
#     Code quality:
#             code format - formats code
#             code check - lint code
#             code test - runs unit tests
#             code all - runs 'format', 'check', and 'test' commands together
#
#     Database:
#             db cli - connect to PostgreSQL database using psql
#            
#     Other:
#         cmd <command> - runs command in the fastapi container eg `cmd hash_pass mypass`
#    
#     --help | -h Displays this help text.

#!/usr/bin/env python3
import os
import sys
import subprocess
import logging
import inspect

# Custom log formatter that colors error messages in red.
class CustomFormatter(logging.Formatter):
    red = "\x1b[31;20m"
    reset = "\x1b[0m"

    def format(self, record):
        msg = super().format(record)
        if record.levelno == logging.ERROR:
            msg = f"{self.red}{msg}{self.reset}"
        return msg

# Logger configuration
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(logging.INFO)
formatter = CustomFormatter("[%(levelname)s] %(message)s")
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)

def _load_env_file(env_file):
    """
    Reads environment variables from the given .env file and returns them as a dictionary.
    Skips comments and empty lines.
    """
    env_vars = {}
    try:
        with open(env_file, "r") as f:
            for line in f:
                line = line.strip()
                if not line or line.startswith("#"):
                    continue
                try:
                    key, value = line.split("=", 1)
                    env_vars[key] = value
                except Exception as e:
                    logger.error(f"Cannot load '{line}': {e}")
                    raise
    except FileNotFoundError:
        logger.error(f"File {env_file} not found.")
        raise
    return env_vars

def _display_help():
    """
    Displays a help message with available commands and their descriptions.
    """
    # Get all available commands by inspecting functions
    command_groups = {}
    command_docs = {}
    
    # Get all functions from the module
    for name, func in inspect.getmembers(sys.modules[__name__], inspect.isfunction):
        # Skip functions that start with _ as they are helpers
        if name.startswith('_') or name == 'display_help' or name == 'main':
            continue
            
        parts = name.split('_', 1)
        if len(parts) == 2:
            group, cmd = parts
            if group not in command_groups:
                command_groups[group] = []
            command_groups[group].append(cmd)
            
            # Store function docstring (first line only) for help text
            doc = inspect.getdoc(func)
            if doc:
                # Get the first line of the docstring
                first_line = doc.split('\n')[0].strip()
                command_docs[name] = first_line
            else:
                command_docs[name] = "No description available"
    
    # Build help text
    help_text = "Usage: ./cli.py <group> <command> [args]\n"
    help_text += "Available groups and commands:\n"
    
    for group in sorted(command_groups.keys()):
        help_text += f"  {group}:\n"
        for cmd in sorted(command_groups[group]):
            func_name = f"{group}_{cmd}"
            description = command_docs.get(func_name, "No description available")
            help_text += f"    {cmd:<10} - {description}\n"
        help_text += "\n"
    
    logger.info(help_text)
    sys.exit(1)

def _cmd_dc(args):
    """
    Runs a Docker Compose command with the given arguments.
    """
    cmd = ["docker", "compose"] + args
    logger.info("Running: " + " ".join(cmd))
    try:
        subprocess.run(cmd, check=True)
    except subprocess.CalledProcessError as e:
        logger.error(f"Error executing command: {e}")
        raise

def _try_execute_command(func_name, args, env_vars):
    """
    Checks if a function exists and calls it if it does.
    Returns True if the function was found and executed, False otherwise.
    """
    func = globals().get(func_name)
    if func and callable(func) and not func_name.startswith('_'):
        func(args, env_vars=env_vars)
        return True
    return False


# --- Definitions for the "app" group ---
def app_start(args, **kwargs):
    """Starts the application in detached mode and displays logs."""
    _cmd_dc(["up"] + args)


def app_exec(args, **kwargs):
    """
    Executes a command in a running container.
    Default container is 'fastapi' and default command is 'sh'.
    """
    container = args[0] if args else "fastapi"
    cmd_args = args[1:] if len(args) > 1 else ["sh"]
    _cmd_dc(["exec", "-it", container] + cmd_args)

def app_run(args, **kwargs):
    """
    Runs a command in a new container.
    Default container is 'fastapi' and default command is 'sh'.
    """
    container = args[0] if args else "fastapi"
    cmd_args = args[1:] if len(args) > 1 else ["sh"]
    _cmd_dc(["run", "--rm", container] + cmd_args)

def app_logs(args, **kwargs):
    """Displays Docker Compose logs with optional arguments."""
    _cmd_dc(["logs", "-f"] + args)

# --- Definitions for the "code" group ---
def code_format(args, **kwargs):
    """Formats the code."""
    _cmd_dc(["run", "--rm", "fastapi", "ruff", "format"])

def code_check(args, **kwargs):
    """Checks the code with a linter and fixes issues."""
    _cmd_dc(["run", "--rm", "fastapi", "ruff", "check", "--fix"])

def code_test(args, **kwargs):
    """Runs unit tests."""
    _cmd_dc(["run", "--rm", "fastapi", "pytest"] + args)

def code_all(args, **kwargs):
    """Runs format, check, and test together."""
    _cmd_dc(["run", "--rm", "fastapi", "/bin/sh", "-c", "ruff format && ruff check --fix && pytest"])

# --- Definitions for the "db" group ---
def db_cli(args, **kwargs):
    """
    Connects to the PostgreSQL database using psql.
    Uses the POSTGRES_USER and POSTGRES_DB variables from the .env file.
    """
    # Get env_vars from kwargs
    env_vars = kwargs.get('env_vars')
    
    # Load env_vars if not provided
    if env_vars is None:
        working_dir = os.path.dirname(os.path.abspath(__file__))
        env_vars = _load_env_file(os.path.join(working_dir, ".env"))
        
    user = env_vars.get("POSTGRES_USER")
    db_name = env_vars.get("POSTGRES_DB")
    if not user or not db_name:
        logger.error("Required variables POSTGRES_USER or POSTGRES_DB are missing in the .env file")
        raise Exception("Invalid environment settings.")
    _cmd_dc(["exec", "-it", "postgres", "psql", "-U", user, db_name])


def main():
    try:
        working_dir = os.path.dirname(os.path.abspath(__file__))
        env_vars = _load_env_file(os.path.join(working_dir, ".env"))

        if len(sys.argv) < 2 or sys.argv[1] in ("--help", "-h"):
            _display_help()

        # Try to match the first two arguments to a function name
        if len(sys.argv) >= 3:
            func_name = f"{sys.argv[1]}_{sys.argv[2]}"
            if _try_execute_command(func_name, sys.argv[3:], env_vars):
                return
        
        # Try to match just the first argument
        if len(sys.argv) >= 2:
            func_name = sys.argv[1]
            if _try_execute_command(func_name, sys.argv[2:], env_vars):
                return
                
        # No matching function found
        _display_help()
        
    except Exception as e:
        logger.error(f"An error occurred: {e}", exc_info=True)
        sys.exit(1)

if __name__ == "__main__":
    main()