mega_snake 0.1.0__py3-none-any.whl

mega_snake/__init__.py

@@ -0,0 +1 @@
+""" init file for setup configuration package """

mega_snake/__main__.py

@@ -0,0 +1,107 @@
+"""Sets the environment configuration"""
+
+import os
+from typing import Optional
+import sys
+import click
+from .diff_tree.module import main as diff_tree
+from .light_weight.module import main as create_release, add_wrapper as create_release_result_callback
+from .remote_branches.module import main as remote_branches, add_wrapper as remote_branches_result_callback
+from .config_environment.module import main as config_environment, add_wrapper as config_env_result_callback
+from .constants import LOGGING_OPT, SHELL_OPT, APP_NAME
+from .util.formatting import get_traceback
+from .util.props import init_app_properties
+from .util.formatting import WorkspaceError, ws_advice
+from .util.cli_group import CliGroup
+
+
+@click.group(
+    help="""A CLI tool focused on simplifying Java development with VSCode by automating workspace configuration.
+
+Main features:
+- Automated workspace setup for Java/Gradle projects
+- Java and Gradle version management
+- VSCode extensions and settings configuration
+- Debug configurations and launch settings
+- Local development environment setup
+- Git integration and workspace organization""",
+    epilog="""Examples:\n
+    # Set up a complete workspace environment\n
+    mgsnake working-env\n
+    \n
+    # Configure Java version\n
+    mgsnake set-java\n
+    \n
+    # Configure Gradle version\n
+    mgsnake set-gradle\n
+    \n
+    # Initialize local configurations\n
+    mgsnake init-local-config\n
+    \n
+    # Run with debug logging\n
+    mgsnake --log-level DEBUG <command>\n
+    \n
+For more details on specific commands, use: mgsnake <command> --help""",
+    context_settings={"help_option_names": ["-h", "--help"]},
+    cls=CliGroup,
+    no_args_is_help=True,
+)
+@click.option("--log-level", "-l", type=click.Choice(list(LOGGING_OPT), False), default="INFO", help="log level")
+@click.pass_context
+def cli(ctx: click.Context, log_level: str) -> None:
+    """cli entry point"""
+    ctx.ensure_object(dict)  # Ensures ctx.obj is a dictionary
+    try:
+        light_weight: bool = False
+        cmd_name = ctx.invoked_subcommand
+        if cmd_name:
+            cmd = cli.get_command(ctx, cmd_name)
+            if not cmd:
+                raise click.ClickException(f"Command '{cmd_name}' not found")
+            # check if the command has cli_metadata
+            metadata = getattr(cmd.callback, "flags", {})
+            flags: Optional[set[str]] = metadata.get("flags")
+            if flags and "no_init" in flags:
+                return
+            ws_advice(f"Invoking subcommand: {cmd_name}")
+            if flags and "skip" in flags:
+                ws_advice("'skip' flag detected. Running in light-weight mode if local working directory is not found.")
+                light_weight = True
+        shell = os.environ.get("MEGA_SNAKE_SHELL")
+        if not shell:
+            raise EnvironmentError("Environment variable 'MEGA_SNAKE_SHELL' is not set")
+        if shell not in SHELL_OPT:
+            raise ValueError(f"Unsupported shell: {shell}. Supported shells are: {', '.join(SHELL_OPT)}")
+        init_app_properties(log_level, shell, light_weight)
+    except Exception as e:
+        click.echo(f"Error during initialization: {e}", err=True)
+        click.echo(get_traceback(e), err=True)
+        raise SystemExit(e) from e
+
+
+@cli.result_callback()
+@click.pass_context
+def post_command(ctx, result, **kwargs) -> None:
+    """Post-command execution logic"""
+    if ctx.invoked_subcommand:
+        ws_advice(
+            f"Command '{ctx.invoked_subcommand}' completed successfully with result: {result} and kwargs: {kwargs}"
+        )
+    exit_code: int = ctx.obj.get("exit_code", 0)
+    if exit_code:
+        sys.exit(exit_code)
+
+
+cli.add_command_with_alias(diff_tree, ["dt", "tree"])
+for command in create_release.commands.values():
+    cli.add_command(create_release_result_callback(command))
+for command in config_environment.commands.values():
+    cli.add_command(config_env_result_callback(command))
+for command in remote_branches.commands.values():
+    cli.add_command(remote_branches_result_callback(command))
+
+if __name__ == "__main__":
+    try:
+        cli.main(prog_name=APP_NAME)
+    except Exception as e:
+        raise WorkspaceError("Error during cli execution", e) from e

mega_snake/config.properties

@@ -0,0 +1,11 @@
+python_module=mega_snake
+resources_path=resources
+working_path=workspace_temp
+log_file_name=python_snake
+local_config_file_name=local_config
+local_env_file_name=.mgsnake.env
+graphql_schema_file_name=schema
+python_virtual_bash=.venv/bin/activate
+python_virtual_ps1_osx=.venv/bin/Activate.ps1
+python_virtual_ps1_linux=.venv/bin/activate.ps1
+python_virtual_ps1_win=.venv/Scripts/Activate.ps1

mega_snake/config_environment/__init__.py

@@ -0,0 +1 @@
+""" init file for the config_environment module """

mega_snake/config_environment/create_working_env.py

@@ -0,0 +1,437 @@
+"""This module contains the functions for setting the workspace for the project."""
+
+import os
+from pathlib import Path
+import shutil
+import json
+import re
+from typing import Any
+import click
+import jq
+from mega_snake.constants import APP_NAME, WORKSPACE_EXTENSIONS
+from mega_snake.util.props import get_property
+from mega_snake.util.formatting import ws_success
+from mega_snake.config_environment.util import update_workspace
+from mega_snake.config_environment.models.github_queries import PrQueries, IssuesQueries
+from mega_snake.config_environment.models.log_viewer_watcher import LogWatcher
+from mega_snake.config_environment.models.vscode_task import VscodeTask, TASKS_INPUT_QUERY
+from mega_snake.config_environment.models.vscode_input import VscodeInput, InputType
+from mega_snake.config_environment.models.vscode_launch import (
+    VscodeLaunch,
+    LAUNCH_INPUT_QUERY,
+    SUBSTITUTE_SHELL_TAG,
+    SUBSTITUTE_PROJECT_TAG,
+    REMOTE_DEBUG_PORT_QUERY,
+)
+from mega_snake.config_environment.java_set import execute as set_java
+from mega_snake.config_environment.gradle_set import execute as set_gradle, set_gradle_version as gradle_command
+from mega_snake.config_environment.maven_set import execute as set_maven, set_maven_version as maven_command
+from mega_snake.config_environment.local_config import execute as initial_load
+from mega_snake.util.formatting import ws_advice, ws_info, ws_warning
+from mega_snake.util.util import (
+    get_command_return_code,
+    get_validated_input,
+    cli_metadata,
+    get_remote_url,
+    load_json_with_comments,
+    get_input_or_default,
+)
+
+
+@click.command(
+    name="working-env",
+    short_help="Configures the VS Code workspace environment",
+    help="Sets up the VS Code workspace with recommended extensions, default settings, tasks, launch configurations,"
+    " and git exclusions. Also configures Java and Gradle when applicable.",
+    epilog="""This command will:
+    - Create/update VSCode workspace file
+    - Configure git exclusions for workspace files
+    - Set up Java and Gradle configurations
+    - Add recommended extensions
+    - Configure default settings and file associations
+    - Set up tasks and launch configurations
+    - Configure log watchers and GitHub queries
+
+    usage: mgsnake working-env
+    """,
+)
+@cli_metadata(flags={"skip"})
+def create_working_env() -> None:  # previously untrackGradleProps
+    """
+    Sets the workspace for the project.
+
+    Returns:
+        None
+    """
+    git_repo: bool = True
+    if not shutil.which("git"):
+        git_repo = False
+        if (
+            get_validated_input(
+                "Git is not installed. Would you like to configure the workspace without git?", ["y", "n"]
+            ).lower()
+            == "n"
+        ):
+            ws_warning("Git is required to configure the workspace. Exiting...")
+            return
+    else:
+        if get_command_return_code("git rev-parse --is-inside-work-tree") != 0:
+            git_repo = False
+            if (
+                get_validated_input(
+                    "Not inside a git repository. Would you like to configure the workspace anyway?", ["y", "n"]
+                ).lower()
+                == "n"
+            ):
+                ws_warning("Not inside a git repository. Exiting...")
+                return
+    _execute(git_repo)
+
+
+def _execute(git_repo: bool) -> None:  # previously untrackGradleProps
+    """
+    Sets the workspace for the project.
+
+    Returns:
+        None
+    """
+    workspace_file: str = _get_workspace_file()
+    working_path: str = _get_working_path()
+    if git_repo:
+        _git_exclude(working_path)
+    initial_load(False)
+    set_java(False, workspace_file)
+    # verifying if build.gradle or build.gradle.kts exists
+    build_file: str = f"{os.getcwd()}/build.gradle"
+    build_kts_file: str = f"{os.getcwd()}/build.gradle.kts"
+    if not os.path.exists(build_file) and not os.path.exists(build_kts_file):
+        ws_warning(
+            f"build.gradle or build.gradle.kts file not found in the current directory. "
+            f"Please run '{APP_NAME} {gradle_command.name}' command if you want to set the Gradle version anyway."
+        )
+    else:
+        set_gradle(False, workspace_file)
+    # verifying if pom.xml exists
+    pom_file: str = f"{os.getcwd()}/pom.xml"
+    if not os.path.exists(pom_file):
+        ws_warning(
+            f"pom.xml file not found in the current directory. "
+            f"Please run '{APP_NAME} {maven_command.name}' command if you want to set the Maven version anyway."
+        )
+    else:
+        set_maven(None, workspace_file)
+    _add_default_settings(workspace_file, working_path)
+
+
+FOLDER = os.path.basename(os.getcwd())
+GIT_BLAME_QUERY = '.settings.["git-blame.gitWebUrl"]'
+EXTENSIONS_QUERY = ".extensions.recommendations"
+DEFAULT_PROPS: dict[str, Any] = {
+    REMOTE_DEBUG_PORT_QUERY: 5005,
+    "mgsnake.java.remoteDebug.profile": "dev",
+    "mgsnake.java.remoteDebug.jar": "build/libs/*.jar",
+    "terminal.integrated.scrollback": 9000,
+    "editor.largeFileOptimizations": False,
+    "editor.maxTokenizationLineLength": 2000000,
+    "logViewer.followTailMode": "auto",
+    "logViewer.chunkSizeKb": 81920,
+    "java.jdt.ls.vmargs": "-XX:+UseParallelGC -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90"
+    " -Dsun.zip.disableMemoryMapping=true -Xmx4G -Xms100m -Xlog:disable",
+}
+FILE_ASSOCIATIONS: dict[str, str] = {
+    "**/.github/workflows/*.yml": "github-actions-workflow",
+    "*.yml": "yaml",
+    "*.gradle": "gradle",
+}
+FILE_ASSOCIATION_QUERY = '.settings.["files.associations"]'
+NEW_WORKSPACE_CONTENTS: dict[str, Any] = {"folders": [{"name": "main", "path": "."}], "settings": {}}
+
+
+def _get_workspace_file() -> str:
+    """
+    Gets the workspace file for the project. If not found, creates a new one.
+
+    Returns:
+        str - The workspace file path
+    """
+    workspace_file: str = get_property("workspace_file")
+    if workspace_file:
+        ws_info(f"Vscode workspace file found: {workspace_file}")
+        # Check if the workspace file is in the current directory
+        if not os.path.exists(workspace_file):
+            raise FileNotFoundError(f"No workspace file found at {workspace_file}")
+        # Check if the workspace file is not empty
+        with open(workspace_file, "r", encoding="utf-8") as file:
+            if file.read().strip():
+                return workspace_file
+            ws_warning("Vscode workspace file is empty")
+    else:
+        ws_warning("Vscode workspace file not found in current directory")
+        if get_validated_input("Would you like to create a new default workspace file?", ["y", "n"]).lower() == "n":
+            raise RuntimeError("Vscode workspace file is required to configure the working environment. Exiting...")
+    workspace_file = f"{os.getcwd()}/{FOLDER}.code-workspace"
+    with open(workspace_file, "w", encoding="utf-8") as file:
+        json.dump(NEW_WORKSPACE_CONTENTS, file, indent=4)
+    ws_success(f"Vscode workspace file created at {workspace_file}")
+    return workspace_file
+
+
+def _get_working_path() -> str:
+    """
+    Gets the working path for the project. If not found, creates a new one.
+
+    Returns:
+        str - The working path
+    """
+    working_path: str = get_property("working_path")
+    assert working_path, (
+        "Working path is required to configure the working environment, but not found in the properties. This is a bug."
+    )
+    assert Path(working_path).resolve().is_relative_to(Path.cwd().resolve()), (
+        "Working path is not in the current directory. This is a bug."
+    )
+    if os.path.exists(working_path):
+        ws_info(f"Working path found: {working_path}")
+        return working_path
+    ws_warning("Working path not found in current directory")
+    if get_validated_input("Would you like to create a new default working path?", ["y", "n"]).lower() == "n":
+        raise RuntimeError("Working path is required to configure the working environment. Exiting...")
+    os.makedirs(working_path, exist_ok=True)
+    ws_success(f"Working path created at {working_path}")
+    return working_path
+
+
+def _git_exclude(working_path: str) -> None:
+    """
+    Excludes the .vscode folder and the working path from git.
+    """
+    working_path = os.path.basename(working_path)
+    ex_file: str = ".git/info/exclude"
+    # Reading git exclude file
+    with open(ex_file, "r", encoding="utf-8") as file:
+        exclude: str = file.read()
+    if not exclude.endswith("\n"):
+        exclude += "\n"
+    regex = re.compile(r"^\s*\.vscode/?\s*$", re.MULTILINE)
+    if regex.search(exclude):
+        ws_advice(f".vscode folder already excluded in {ex_file}")
+    else:
+        exclude += ".vscode/\n"
+        ws_success(f"Excluded .vscode folder in {ex_file}")
+    regex = re.compile(rf"^\s*{working_path}/?\s*$", re.MULTILINE)
+    if regex.search(exclude):
+        ws_advice(f"{working_path} folder already excluded in {ex_file}")
+    else:
+        exclude += f"{working_path}/\n"
+        ws_success(f"Excluded {working_path} folder in {ex_file}")
+    regex = re.compile(r"^\s*/\*\.code-workspace\s*$", re.MULTILINE)
+    if regex.search(exclude):
+        ws_advice(f"root code-workspace file already excluded in {ex_file}")
+    else:
+        exclude += "/*.code-workspace\n"
+        ws_success(f"Excluded root code-workspace file in {ex_file}")
+    # Writing git exclude file
+    with open(ex_file, "w", encoding="utf-8") as file:
+        file.write(exclude)
+
+
+def _add_default_settings(workspace_file: str, working_path: str) -> None:
+    """
+    Adds default settings to the workspace file.
+
+    Args:
+        workspace_file (str): The workspace file path
+        working_path (str): The working path
+    """
+    json_data: dict[str, Any] = load_json_with_comments(workspace_file)
+    update_file: bool = False
+
+    json_data, updated = _add_recommended_extensions(json_data)
+    update_file = update_file or updated
+
+    json_data, updated = _update_git_blame(json_data)
+    update_file = update_file or updated
+
+    json_data, updated = _update_github_queries(json_data)
+    update_file = update_file or updated
+
+    json_data, updated = _update_log_watchers(json_data, working_path)
+    update_file = update_file or updated
+
+    json_data, updated = _update_vscode_tasks(json_data, working_path)
+    update_file = update_file or updated
+
+    json_data, updated = _update_vscode_launch(json_data, working_path)
+    update_file = update_file or updated
+
+    json_data, updated = _update_input_props(json_data)
+    update_file = update_file or updated
+
+    json_data, updated = _update_file_associations(json_data)
+    update_file = update_file or updated
+
+    if update_file:
+        temp_file = f"{working_path}/blame.json"
+        update_workspace(json_data, temp_file, workspace_file)
+        ws_success("Workspace settings updated successfully")
+    else:
+        ws_advice("Workspace settings already up-to-date")
+
+
+def _add_recommended_extensions(json_data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+    """
+    Adds recommended extensions to the json contents.
+
+    Args:
+        json_data (dict): The workspace file contents
+    """
+    update_file: bool = False
+    result = jq.compile(EXTENSIONS_QUERY).input(json_data).all()
+    if not result or not result[0]:
+        jq_query = f"{EXTENSIONS_QUERY} = {json.dumps(WORKSPACE_EXTENSIONS)}"
+        json_data = jq.compile(jq_query).input(json_data).first()
+        update_file = True
+    else:
+        ext_list: list[str] = []
+        for ext in WORKSPACE_EXTENSIONS:
+            if ext not in result[0]:
+                ext_list.append(ext)
+        if ext_list:
+            jq_query = f"{EXTENSIONS_QUERY} += {json.dumps(ext_list)}"
+            json_data = jq.compile(jq_query).input(json_data).first()
+            update_file = True
+    return json_data, update_file
+
+
+def _update_git_blame(json_data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+    """Update git blame settings in workspace"""
+    result = jq.compile(GIT_BLAME_QUERY).input(json_data).first()
+    remote_url = get_remote_url()
+    if not result and remote_url:
+        remote_url = re.sub(r"^git@", "https://", remote_url)
+        match = re.match(r"https\://\w+\.\w+\:", remote_url)
+        if match:
+            repl = re.sub(r"\:$", "/", match.group())
+            remote_url = remote_url.replace(match.group(), repl)
+        jq_query = f'{GIT_BLAME_QUERY} = "{remote_url}/tree/$ID"'
+        json_data = jq.compile(jq_query).input(json_data).first()
+        return json_data, True
+    return json_data, False
+
+
+def _update_github_queries(json_data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+    """Update GitHub PR and Issues queries"""
+    updated = False
+    for pr_query in PrQueries:
+        res = pr_query.add_query(json_data)
+        if res:
+            updated = True
+            json_data = res
+
+    for issue_query in IssuesQueries:
+        res = issue_query.add_query(json_data)
+        if res:
+            updated = True
+            json_data = res
+
+    return json_data, updated
+
+
+def _update_log_watchers(json_data: dict[str, Any], working_path: str) -> tuple[dict[str, Any], bool]:
+    """Update log watchers configuration"""
+    updated = False
+    for watcher in LogWatcher:
+        res = watcher.add_watcher(json_data, working_path)
+        if res:
+            updated = True
+            json_data = res
+    return json_data, updated
+
+
+def _update_vscode_tasks(json_data: dict[str, Any], working_path: str) -> tuple[dict[str, Any], bool]:
+    """Update VSCode tasks configuration"""
+    updated = False
+
+    res = VscodeTask.add_tasks_version(json_data)
+    if res:
+        updated = True
+        json_data = res
+
+    for input_type in [a for a in VscodeInput if a.enum_type != InputType.LAUNCH]:
+        res = input_type.add_tasks_input(json_data, TASKS_INPUT_QUERY)
+        if res:
+            updated = True
+            json_data = res
+
+    for task in VscodeTask:
+        res = task.add_tasks_task(json_data, working_path)
+        if res:
+            updated = True
+            json_data = res
+
+    return json_data, updated
+
+
+def _update_vscode_launch(json_data: dict[str, Any], working_path: str) -> tuple[dict[str, Any], bool]:
+    """Update VSCode launch configuration"""
+    updated = False
+
+    res = VscodeLaunch.add_launch_version(json_data)
+    if res:
+        updated = True
+        json_data = res
+
+    for input_type in [a for a in VscodeInput if a.enum_type != InputType.TASK]:
+        res = input_type.add_tasks_input(json_data, LAUNCH_INPUT_QUERY)
+        if res:
+            updated = True
+            json_data = res
+
+    for launch in VscodeLaunch:
+        res = launch.add_launch_config(json_data, _launch_substituter, working_path)
+        if res:
+            updated = True
+            json_data = res
+
+    return json_data, updated
+
+
+def _update_input_props(json_data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+    """Update VSCode input properties"""
+    updated = False
+    for key, value in DEFAULT_PROPS.items():
+        snake_query: str = f'.settings.["{key}"]'
+        result = jq.compile(snake_query).input(json_data).first()
+        if result is None:
+            prompt: str = f"Enter the value a value for {key}"
+            value = get_input_or_default(prompt, value)
+            jq_query = f"{snake_query} = {json.dumps(value)}"
+            json_data = jq.compile(jq_query).input(json_data).first()
+            updated = True
+
+    return json_data, updated
+
+
+def _update_file_associations(json_data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+    """Update file associations in workspace"""
+    updated = False
+    for key, value in FILE_ASSOCIATIONS.items():
+        file_query: str = f'{FILE_ASSOCIATION_QUERY}.["{key}"]'
+        result = jq.compile(file_query).input(json_data).first()
+        if not result:
+            jq_query = f"{file_query} = {json.dumps(value)}"
+            json_data = jq.compile(jq_query).input(json_data).first()
+            updated = True
+    return json_data, updated
+
+
+def _launch_substituter(launch: str) -> str:
+    """
+    Substitutes launch tags with values
+    """
+    # verify if the launch contains the tags
+    if SUBSTITUTE_SHELL_TAG in launch:
+        launch = launch.replace(SUBSTITUTE_SHELL_TAG, get_property("shell"))
+    if SUBSTITUTE_PROJECT_TAG in launch:
+        launch = launch.replace(SUBSTITUTE_PROJECT_TAG, FOLDER)
+    return launch