cookieplone 0.1.0__tar.gz

cookieplone-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: cookieplone
+Version: 0.1.0
+Summary: Create Plone projects, addons, documentation with ease!
+Home-page: https://github.com/plone/cookieplone
+Author: Plone Community
+Author-email: dev@plone.org
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Dist: cookiecutter (>=2.6.0,<3.0.0)
+Requires-Dist: semver (>=3.0.2,<4.0.0)
+Requires-Dist: typer[all] (>=0.12.3,<0.13.0)
+Project-URL: Documentation, https://plone.github.io/cookieplone/
+Project-URL: Repository, https://github.com/plone/cookieplone
+Description-Content-Type: text/markdown
+
+<p align="center">
+    <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-logo.png">
+</p>
+
+<h1 align="center">
+  cookieplone
+</h1>
+
+
+<div align="center">
+
+[![PyPI](https://img.shields.io/pypi/v/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - Wheel](https://img.shields.io/pypi/wheel/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - License](https://img.shields.io/pypi/l/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - Status](https://img.shields.io/pypi/status/cookieplone)](https://pypi.org/project/cookieplone/)
+
+
+[![PyPI - Plone Versions](https://img.shields.io/pypi/frameworkversions/plone/cookieplone)](https://pypi.org/project/cookieplone/)
+
+[![Tests](https://github.com/plone/cookieplone/actions/workflows/main.yml/badge.svg)](https://github.com/plone/cookieplone/actions/workflows/main.yml)
+
+[![GitHub contributors](https://img.shields.io/github/contributors/plone/cookieplone)](https://github.com/plone/cookieplone)
+[![GitHub Repo stars](https://img.shields.io/github/stars/plone/cookieplone?style=social)](https://github.com/plone/cookieplone)
+
+</div>
+

cookieplone-0.1.0/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+    <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-logo.png">
+</p>
+
+<h1 align="center">
+  cookieplone
+</h1>
+
+
+<div align="center">
+
+[![PyPI](https://img.shields.io/pypi/v/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - Wheel](https://img.shields.io/pypi/wheel/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - License](https://img.shields.io/pypi/l/cookieplone)](https://pypi.org/project/cookieplone/)
+[![PyPI - Status](https://img.shields.io/pypi/status/cookieplone)](https://pypi.org/project/cookieplone/)
+
+
+[![PyPI - Plone Versions](https://img.shields.io/pypi/frameworkversions/plone/cookieplone)](https://pypi.org/project/cookieplone/)
+
+[![Tests](https://github.com/plone/cookieplone/actions/workflows/main.yml/badge.svg)](https://github.com/plone/cookieplone/actions/workflows/main.yml)
+
+[![GitHub contributors](https://img.shields.io/github/contributors/plone/cookieplone)](https://github.com/plone/cookieplone)
+[![GitHub Repo stars](https://img.shields.io/github/stars/plone/cookieplone?style=social)](https://github.com/plone/cookieplone)
+
+</div>

cookieplone-0.1.0/cookieplone/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cookieplone-0.1.0/cookieplone/__main__.py

@@ -0,0 +1,6 @@
+"""Allow cookieplone to be executable through `python -m cookieplone`."""
+
+from cookieplone.cli import main
+
+if __name__ == "__main__":  # pragma: no cover
+    main(prog_name="cookiecutter")

cookieplone-0.1.0/cookieplone/cli.py

@@ -0,0 +1,172 @@
+"""Main `cookieplone` CLI."""
+
+import os
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cookiecutter import __version__ as __cookiecutter_version__
+from cookiecutter.log import configure_logger
+from rich import print
+from rich.prompt import Prompt
+
+from cookieplone import __version__, data
+from cookieplone.exceptions import GeneratorException
+from cookieplone.generator import generate
+from cookieplone.repository import get_base_repository, get_template_options
+from cookieplone.utils import console
+
+
+def validate_extra_context(value: list[str] | None = None):
+    """Validate extra content follows the correct pattern."""
+    if not value:
+        return {}
+    for string in value:
+        if "=" not in string:
+            raise typer.BadParameter(
+                f"EXTRA_CONTEXT should contain items of the form key=value; "
+                f"'{string}' doesn't match that form"
+            )
+    # Convert list -- e.g.: ['program_name=foobar', 'startsecs=66']
+    # to dict -- e.g.: {'program_name': 'foobar', 'startsecs': '66'}
+    return dict([s.split("=", 1) for s in value])
+
+
+def prompt_for_template(base_path: Path) -> str:
+    """Parse cookiecutter.json in base_path and prompt user to choose."""
+    templates = get_template_options(base_path)
+    choices = {i[0]: i[1] for i in templates}
+    console.welcome_screen(templates)
+    answer = Prompt.ask("Select a template", choices=list(choices.keys()), default=1)
+    return choices[answer]
+
+
+def version_info() -> str:
+    """Return the Cookieplone version, location and Python powering it."""
+    python_version = sys.version
+    location = Path(__file__).parent
+    return (
+        f"Cookieplone {__version__} from {location} "
+        f"(Cookiecutter {__cookiecutter_version__}, "
+        f"Python {python_version})"
+    )
+
+
+def cli(
+    template: Annotated[str, typer.Argument(help="Template to be used.")] = "",
+    extra_context: Annotated[
+        data.OptionalListStr,
+        typer.Argument(callback=validate_extra_context, help="Extra context."),
+    ] = None,
+    output_dir: Annotated[
+        data.OptionalPath,
+        typer.Option("--output-dir", "-o", help="Where to generate the code."),
+    ] = None,
+    tag: Annotated[str, typer.Option(help="Tag.")] = "",
+    version: Annotated[
+        bool, typer.Option("--version", help="Display the version of cookieplone.")
+    ] = False,
+    no_input: Annotated[
+        bool,
+        typer.Option(
+            "--no_input",
+            help=(
+                "Do not prompt for parameters and only use cookiecutter.json "
+                "file content. Defaults to deleting any cached resources and "
+                "redownloading them. Cannot be combined with the --replay flag."
+            ),
+        ),
+    ] = False,
+    replay: Annotated[bool, typer.Option("--replay", "-r")] = False,
+    replay_file: Annotated[data.OptionalPath, typer.Option("--replay-file")] = None,
+    skip_if_file_exists: Annotated[
+        bool,
+        typer.Option(
+            "--skip-if-file-exists",
+            "-s",
+            help=(
+                "Skip the files in the corresponding directories "
+                "if they already exist"
+            ),
+        ),
+    ] = False,
+    overwrite_if_exists: Annotated[
+        bool, typer.Option("--overwrite-if-exists", "-f")
+    ] = False,
+    config_file: Annotated[
+        data.OptionalPath, typer.Option("--config-file", help="User configuration file")
+    ] = None,
+    default_config: Annotated[
+        bool,
+        typer.Option(
+            "--default-config",
+            help="Do not load a config file. Use the defaults instead",
+        ),
+    ] = False,
+    keep_project_on_failure: Annotated[
+        bool,
+        typer.Option(
+            "--keep-project-on-failure", help="Do not delete project folder on failure"
+        ),
+    ] = False,
+    debug_file: Annotated[
+        data.OptionalPath,
+        typer.Option(
+            "--debug-file", help="File to be used as a stream for DEBUG logging"
+        ),
+    ] = None,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+):
+    """Generate a new Plone codebase."""
+    if version:
+        info = version_info
+        print(info)
+        raise typer.Exit()
+    repository = os.environ.get("COOKIEPLONE_REPOSITORY")
+    if not repository:
+        repository = "gh:plone/cookiecutter-plone"
+
+    if not template:
+        # Display template options
+        repo_path = get_base_repository(repository)
+        template = prompt_for_template(Path(repo_path))
+    else:
+        console.welcome_screen()
+
+    if replay_file:
+        replay = replay_file
+    passwd = os.environ.get(
+        "COOKIECUTTER_REPO_PASSWORD", os.environ.get("COOKIEPLONE_REPO_PASSWORD")
+    )
+    if not output_dir:
+        output_dir = Path().cwd()
+    configure_logger(stream_level="DEBUG" if verbose else "INFO", debug_file=debug_file)
+    # Run generator
+    try:
+        generate(
+            repository,
+            tag,
+            no_input,
+            extra_context,
+            replay,
+            overwrite_if_exists,
+            output_dir,
+            config_file,
+            default_config,
+            passwd,
+            template,
+            skip_if_file_exists,
+            keep_project_on_failure,
+        )
+    except GeneratorException:
+        # TODO: Handle error
+        raise typer.Exit(1)  # noQA:B904
+    except Exception:
+        # TODO: Handle error
+        raise typer.Exit(1)  # noQA:B904
+
+
+def main():
+    """Run the cli."""
+    typer.run(cli)

cookieplone-0.1.0/cookieplone/data.py

@@ -0,0 +1,62 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal, Optional, TypeAlias
+
+OptionalPath: TypeAlias = Optional[Path]  # noQA:UP007
+OptionalListStr: TypeAlias = Optional[list[str]]  # noQA:UP007
+
+
+@dataclass
+class SanityCheck:
+    """Definition of a sanity check."""
+
+    name: str
+    func: Callable
+    args: list[Any]
+    level: Literal["info", "warning", "error"]
+
+
+@dataclass
+class SanityCheckResult:
+    """Result of a sanity check."""
+
+    name: str
+    status: bool
+    message: str = ""
+
+
+@dataclass
+class SanityCheckResults:
+    """Results of all sanity checks."""
+
+    status: bool
+    checks: list[SanityCheckResult]
+    message: str = ""
+
+
+@dataclass
+class ItemValidator:
+    """Validate an answer provided by the user."""
+
+    key: str
+    func: Callable
+    level: Literal["info", "warning", "error"] = "error"
+
+
+@dataclass
+class ItemValidatorResult:
+    """Result of an item validation."""
+
+    key: str
+    status: bool
+    message: str = ""
+
+
+@dataclass
+class ContextValidatorResult:
+    """Results of all validations checks."""
+
+    status: bool
+    validations: list[ItemValidatorResult]
+    message: str = ""

cookieplone-0.1.0/cookieplone/exceptions.py

@@ -0,0 +1,18 @@
+class CookieploneException(Exception):
+    """Cookieplone base exception."""
+
+    message: str
+
+    def __init__(self, message: str):
+        self.message = message
+
+
+class GeneratorException(CookieploneException):
+    """Cookieplone generator exception."""
+
+    message: str
+    original: Exception | None = None
+
+    def __init__(self, message: str, original: Exception | None = None):
+        self.message = message
+        self.original = original

cookieplone-0.1.0/cookieplone/filters/__init__.py

@@ -0,0 +1,84 @@
+import os
+
+from cookiecutter.utils import simple_filter
+
+from cookieplone.utils import containers, versions
+
+
+@simple_filter
+def package_name(v) -> str:
+    """Return the Python package name (without namespace)."""
+    return v.split(".")[1]
+
+
+@simple_filter
+def package_namespace(v) -> str:
+    """Return the Python package namespace."""
+    return v.split(".")[0]
+
+
+@simple_filter
+def pascal_case(package_name: str) -> str:
+    """Return the package name as a string in the PascalCase format ."""
+    parts = [name.title() for name in package_name.split("_")]
+    return "".join(parts)
+
+
+@simple_filter
+def extract_host(hostname: str) -> str:
+    """Get the host part of a hostname."""
+    parts = hostname.split(".")
+    return parts[0]
+
+
+@simple_filter
+def use_prerelease_versions(_: str) -> str:
+    """Should we use prerelease versions of packages."""
+    use_prerelease_versions = "USE_PRERELEASE" in os.environ
+    return "Yes" if use_prerelease_versions else "No"
+
+
+@simple_filter
+def latest_volto(use_prerelease_versions: str) -> str:
+    """Return the latest released version of Volto."""
+    allow_prerelease = use_prerelease_versions == "Yes"
+    return versions.latest_volto(allow_prerelease=allow_prerelease)
+
+
+@simple_filter
+def latest_plone(use_prerelease_versions: str) -> str:
+    """Return the latest released version of Plone."""
+    allow_prerelease = use_prerelease_versions == "Yes"
+    return versions.latest_plone(allow_prerelease=allow_prerelease)
+
+
+@simple_filter
+def node_version_for_volto(volto_version: str) -> int:
+    """Return the Node Version to be used."""
+    return versions.node_version_for_volto(volto_version)
+
+
+@simple_filter
+def gs_language_code(code: str) -> str:
+    """Return the language code as expected by Generic Setup."""
+    gs_code = code.lower()
+    if "-" in code:
+        base_language, country = code.split("-")
+        gs_code = f"{base_language}-{country.lower()}"
+    return gs_code
+
+
+@simple_filter
+def locales_language_code(code: str) -> str:
+    """Return the language code as expected by gettext."""
+    gs_code = code.lower()
+    if "-" in code:
+        base_language, country = code.split("-")
+        gs_code = f"{base_language}_{country.upper()}"
+    return gs_code
+
+
+@simple_filter
+def image_prefix(registry: str) -> str:
+    """Return the a prefix to be used with all Docker images."""
+    return containers.image_prefix(registry)

cookieplone-0.1.0/cookieplone/generator.py

@@ -0,0 +1,118 @@
+import json
+from collections import OrderedDict
+from pathlib import Path
+
+import typer
+from cookiecutter import exceptions as exc
+from cookiecutter.main import cookiecutter
+
+from cookieplone.exceptions import GeneratorException
+from cookieplone.utils import console, files
+
+
+def _remove_internal_keys(context: OrderedDict) -> dict:
+    """Remove internal and computed keys."""
+    new_context = {
+        key: value for key, value in context.items() if not key.startswith("_")
+    }
+    return new_context
+
+
+def generate(
+    repository,
+    tag,
+    no_input,
+    extra_context,
+    replay,
+    overwrite_if_exists,
+    output_dir,
+    config_file,
+    default_config,
+    passwd,
+    template,
+    skip_if_file_exists,
+    keep_project_on_failure,
+) -> Path:
+    try:
+        result = cookiecutter(
+            repository,
+            tag,
+            no_input,
+            extra_context=extra_context,
+            replay=replay,
+            overwrite_if_exists=overwrite_if_exists,
+            output_dir=output_dir,
+            config_file=config_file,
+            default_config=default_config,
+            password=passwd,
+            directory=template,
+            skip_if_file_exists=skip_if_file_exists,
+            accept_hooks=True,
+            keep_project_on_failure=keep_project_on_failure,
+        )
+    except (
+        exc.ContextDecodingException,
+        exc.OutputDirExistsException,
+        exc.InvalidModeException,
+        exc.FailedHookException,
+        exc.UnknownExtension,
+        exc.InvalidZipRepository,
+        exc.RepositoryNotFound,
+        exc.RepositoryCloneFailed,
+    ) as e:
+        raise GeneratorException(message=str(e), original=e)  # noQA:B904
+    except exc.UndefinedVariableInTemplate as undefined_err:
+        context_str = json.dumps(undefined_err.context, indent=2, sort_keys=True)
+        msg = f"""{undefined_err.message}
+        Error message: {undefined_err.error.message}
+        Context: {context_str}
+        """
+        raise GeneratorException(message=msg, original=undefined_err)  # noQA:B904
+    else:
+        return Path(result)
+
+
+def generate_subtemplate(
+    template: str, output_dir: Path, folder_name: str, context: OrderedDict
+) -> Path:
+    # Extract path to repository
+    repository = context.get("_checkout") or context.get("_template")
+
+    if not repository or not (Path(repository) / template).exists():
+        # TODO: Error message
+        raise typer.Exit(code=1)
+    # Cleanup context
+    extra_context = _remove_internal_keys(context)
+    ## Add folder name again
+    extra_context["__folder_name"] = folder_name
+    ## Disable GHA for subcomponent
+    extra_context["__gha_enable"] = False
+    # Enable quiet mode
+    console.enable_quiet_mode()
+    # Call generate
+    try:
+        result = generate(
+            repository,
+            None,  # We should have the tag already locally
+            True,  # No input
+            extra_context,
+            False,  # Not running a replay
+            True,  # overwrite_if_exists
+            output_dir,
+            None,  # config_file
+            None,  # default_config,
+            None,  # password
+            template,
+            False,  # skip_if_file_exists,
+            False,  # keep_project_on_failure
+        )
+    except GeneratorException as exc:
+        console.disable_quiet_mode()
+        raise exc
+    else:
+        console.disable_quiet_mode()
+        path = Path(result)
+        # Remove GHA folder
+        files.remove_gha(path)
+        # Return path
+        return path

cookieplone-0.1.0/cookieplone/repository.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+
+from cookiecutter.config import get_user_config
+from cookiecutter.repository import determine_repo_dir
+
+from cookieplone import data
+
+
+def get_base_repository(
+    repository: str,
+    tag: str | None = None,
+    password: str = "",
+    config_file: data.OptionalPath = None,
+    default_config: bool = False,
+):
+    config_dict = get_user_config(
+        config_file=config_file,
+        default_config=default_config,
+    )
+    base_repo_dir, _ = determine_repo_dir(
+        template=repository,
+        abbreviations=config_dict["abbreviations"],
+        clone_to_dir=config_dict["cookiecutters_dir"],
+        checkout=tag,
+        no_input=True,  # Force download
+        password=password,
+        directory="",
+    )
+    return base_repo_dir
+
+
+def get_template_options(base_path: Path) -> list[list[str]]:
+    """Parse cookiecutter.json and return a list of template options."""
+    config = json.loads((base_path / "cookiecutter.json").read_text())
+    available_templates = config.get("templates", {})
+    templates = []
+    for idx, name in enumerate(available_templates, start=1):
+        idx = str(idx)
+        value = available_templates[name]
+        title = value["title"]
+        description = value["description"]
+        templates.append((idx, name, title, description))
+    return templates

cookieplone-0.1.0/cookieplone/settings.py

@@ -0,0 +1,31 @@
+PLONE_MIN_VERSION = "6"
+
+SUPPORTED_PYTHON_VERSIONS = [
+    "3.8",
+    "3.9",
+    "3.10",
+    "3.11",
+    "3.12",
+]
+
+DEFAULT_NODE = 18
+SUPPORTED_NODE_VERSIONS = [
+    "16",
+    "17",
+    "18",
+    "19",
+    "20",
+]
+
+
+VOLTO_MIN_VERSION = "16"
+VOLTO_NODE = {
+    16: 16,
+    17: DEFAULT_NODE,
+    18: 20,
+}
+MIN_DOCKER_VERSION = "20.10"
+
+
+## Config
+QUIET_MODE_VAR = "COOKIEPLONE_QUIET_MODE_SWITCH"

cookieplone-0.1.0/cookieplone/utils/__init__.py

@@ -0,0 +1,3 @@
+from cookiecutter.utils import rmtree
+
+__all__ = ["rmtree"]

cookieplone-0.1.0/cookieplone/utils/commands/__init__.py

@@ -0,0 +1,85 @@
+import re
+import subprocess
+import sys
+
+from cookieplone import settings
+
+
+def _get_command_version(cmd: str) -> str:
+    """Get the reported version of a command line utility."""
+    try:
+        raw_version = (
+            subprocess.run([cmd, "--version"], capture_output=True)  # noQA: S603
+            .stdout.decode()
+            .strip()
+        )
+    except FileNotFoundError:
+        raw_version = ""
+    return raw_version
+
+
+def _parse_node_major_version(value: str) -> str:
+    """Parse value and return the major version of Node."""
+    match = re.match(r"v(\d{1,3})\.\d{1,3}.\d{1,3}", value)
+    return match.groups()[0] if match else ""
+
+
+def _parse_docker_version(value: str) -> str:
+    """Parse value and return the docker version."""
+    value = value.strip()
+    match = re.match(r"Docker version (\d{2}).(\d{1,2}).(\d{1,2})", value)
+    if match:
+        groups = match.groups()
+        return f"{groups[0]}.{groups[1]}"
+    return ""
+
+
+def check_python_version(supported_versions: list[str] | None = None) -> str:
+    """Check if Python version is supported."""
+    supported = (
+        supported_versions if supported_versions else settings.SUPPORTED_PYTHON_VERSIONS
+    )
+    version = f"{sys.version_info.major}.{sys.version_info.minor}"
+    return (
+        ""
+        if version in supported
+        else f"Python version is not supported: Got {sys.version}"
+    )
+
+
+def check_node_version(supported_versions: list[str] | None = None) -> str:
+    """Check if node version is supported."""
+    supported = (
+        supported_versions if supported_versions else settings.SUPPORTED_NODE_VERSIONS
+    )
+    raw_version = _get_command_version("node")
+    if not raw_version:
+        return "NodeJS not found."
+    else:
+        version = _parse_node_major_version(raw_version)
+        return (
+            ""
+            if version in supported
+            else f"Node version is not supported: Got {raw_version}"
+        )
+
+
+def check_docker_version(min_version: str) -> str:
+    """Check if docker version is supported."""
+    min_version = min_version if min_version else settings.MIN_DOCKER_VERSION
+    raw_version = _get_command_version("docker")
+    if not raw_version:
+        return "Docker not found."
+    else:
+        version = _parse_docker_version(raw_version)
+        return (
+            ""
+            if version >= settings.MIN_DOCKER_VERSION
+            else f"Docker version is not supported: Got {raw_version}"
+        )
+
+
+def check_command_is_available(command: str) -> str:
+    """Check if a command line utility is available."""
+    raw_version = _get_command_version(command)
+    return "" if raw_version else f"Command {command} is not available."

cookieplone-0.1.0/cookieplone/utils/console.py

@@ -0,0 +1,134 @@
+import os
+from textwrap import dedent
+
+from rich import print as base_print
+from rich.markup import escape
+from rich.panel import Panel
+from rich.table import Table
+
+from cookieplone.settings import QUIET_MODE_VAR
+
+BANNER = """
+                 .xxxxxxxxxxxxxx.
+             ;xxxxxxxxxxxxxxxxxxxxxx;
+          ;xxxxxxxxxxxxxxxxxxxxxxxxxxxx;
+        xxxxxxxxxx              xxxxxxxxxx
+      xxxxxxxx.                    .xxxxxxxx
+     xxxxxxx      xxxxxxx:            xxxxxxx
+   :xxxxxx       xxxxxxxxxx             xxxxxx:
+  :xxxxx+       xxxxxxxxxxx              +xxxxx:
+ .xxxxx.        :xxxxxxxxxx               .xxxxx.
+ xxxxx+          ;xxxxxxxx                 +xxxxx
+ xxxxx              +xx.                    xxxxx.
+xxxxx:                      .xxxxxxxx       :xxxxx
+xxxxx                      .xxxxxxxxxx       xxxxx
+xxxxx                      xxxxxxxxxxx       xxxxx
+xxxxx                      .xxxxxxxxxx       xxxxx
+xxxxx:                      .xxxxxxxx       :xxxxx
+.xxxxx              ;xx.       ...          xxxxx.
+ xxxxx+          :xxxxxxxx                 +xxxxx
+ .xxxxx.        :xxxxxxxxxx               .xxxxx.
+  :xxxxx+       xxxxxxxxxxx              ;xxxxx:
+   :xxxxxx       xxxxxxxxxx             xxxxxx:
+     xxxxxxx      xxxxxxx;            xxxxxxx
+      xxxxxxxx.                    .xxxxxxxx
+        xxxxxxxxxx              xxxxxxxxxx
+          ;xxxxxxxxxxxxxxxxxxxxxxxxxxxx+
+             ;xxxxxxxxxxxxxxxxxxxxxx;
+                 .xxxxxxxxxxxxxx.
+"""
+
+
+def _print(msg: str):
+    """Wrapper around rich.print."""
+    if not os.environ.get(QUIET_MODE_VAR):
+        base_print(msg)
+
+
+def print(msg: str, style: str = "", color: str = ""):  # noQA:A001
+    """Print to console, using style and color.
+
+    style: https://rich.readthedocs.io/en/latest/reference/style.html#rich.style.Style
+    """
+    tag_open = ""
+    tag_close = ""
+    markup = " ".join([item.strip() for item in (style, color) if item.strip()])
+    if markup:
+        tag_open = f"[{markup}]"
+        tag_close = f"[/{markup}]"
+    _print(f"{tag_open}{escape(msg)}{tag_close}")
+
+
+def print_plone_banner():
+    """Print Plone banner."""
+    style: str = "bold"
+    color: str = "blue"
+    print(BANNER, style, color)
+
+
+def info(msg: str):
+    style: str = "bold"
+    color: str = "white"
+    print(msg, style, color)
+
+
+def success(msg: str):
+    style: str = "bold"
+    color: str = "green"
+    print(msg, style, color)
+
+
+def error(msg: str):
+    style: str = "bold"
+    color: str = "red"
+    print(msg, style, color)
+
+
+def warning(msg: str):
+    style: str = "bold"
+    color: str = "yellow"
+    print(msg, style, color)
+
+
+def panel(title: str, msg: str = "", subtitle: str = "", url: str = ""):
+    msg = dedent(msg)
+    if url:
+        msg = f"{msg}\n[link]{url}[/link]"
+    _print(
+        Panel(
+            msg,
+            title=title,
+            subtitle=subtitle,
+        )
+    )
+
+
+def table_available_templates(title: str, rows: list[list[str]]):
+    """Display a table of options."""
+    table = Table(title=title, expand=True)
+
+    table.add_column("#", justify="center", style="cyan", no_wrap=True)
+    table.add_column("Title", style="blue")
+    table.add_column("Description", justify="left", style="blue")
+
+    for idx, _, title, description in rows:
+        table.add_row(idx, title, description)
+
+    return table
+
+
+def welcome_screen(templates: list[list[str]] | None = None):
+    print_plone_banner()
+    if templates:
+        table = table_available_templates("Templates", templates)
+        _print(table)
+
+
+def enable_quiet_mode():
+    """Enable quiet mode."""
+    os.environ[QUIET_MODE_VAR] = "1"
+
+
+def disable_quiet_mode():
+    """Disable quiet mode."""
+    os.environ.pop(QUIET_MODE_VAR, "")

cookieplone-0.1.0/cookieplone/utils/containers.py

@@ -0,0 +1,6 @@
+REGISTRIES = {"docker_hub": "", "github": "ghcr.io/", "gitlab": "registry.gitlab.com/"}
+
+
+def image_prefix(registry: str) -> str:
+    """Return the image prefix to be used based on the registry used."""
+    return REGISTRIES.get(registry, "")

cookieplone-0.1.0/cookieplone/utils/files.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+from cookiecutter.utils import rmtree
+
+
+def remove_files(base_path: Path, paths: list[str]):
+    """Remove files."""
+    for filepath in paths:
+        path = base_path / filepath
+        exists = path.exists()
+        if exists and path.is_dir():
+            rmtree(path)
+        elif exists and path.is_file():
+            path.unlink()
+
+
+def remove_gha(base_path: Path):
+    """Remove GHA folder."""
+    remove_files(base_path=base_path, paths=[".github"])

cookieplone-0.1.0/cookieplone/utils/sanity.py

@@ -0,0 +1,28 @@
+from cookieplone import data
+
+
+def run_sanity_checks(checks: list[data.SanityCheck]) -> data.SanityCheckResults:
+    """Run sanity checks."""
+    global_status = True
+    results = []
+    for check in checks:
+        name = check.name
+        func = check.func
+        args = check.args
+        level = check.level
+        message = func(*args)
+        if not message:
+            status = True
+            message = "✓"
+        elif level == "warning":
+            status = True
+        elif level == "error":
+            status = False
+        global_status = global_status and status
+        results.append(data.SanityCheckResult(name, status, message))
+    global_message = (
+        f"Ran {len(checks)} checks and they {'passed' if global_status else 'failed'}."
+    )
+    return data.SanityCheckResults(
+        status=global_status, message=global_message, checks=results
+    )

cookieplone-0.1.0/cookieplone/utils/validators.py

@@ -0,0 +1,134 @@
+import re
+from typing import Any
+from urllib.parse import urlparse
+
+from packaging.version import InvalidVersion, Version
+
+from cookieplone import data, settings
+
+
+def _version_from_str(value: str) -> Version | None:
+    """Parse a value and return a Version"""
+    try:
+        version = Version(value)
+    except InvalidVersion:
+        version = None
+    return version
+
+
+def validate_not_empty(value: Any, key: str = "") -> str:
+    """Value should not be empty."""
+    status = True
+    if isinstance(value, str):
+        status = bool(value.strip())
+    elif isinstance(value, int | float):
+        # We accept 0 as valid
+        status = True
+    else:
+        status = bool(value)
+
+    return "" if status else f"{key} should be provided"
+
+
+def validate_component_version(component: str, version: str, min_version: str) -> str:
+    """Validate if a component version is bigger than the min_version."""
+    version_ = _version_from_str(version)
+    min_version = _version_from_str(min_version)
+    check = version_ and min_version and (version_ >= min_version)
+    return "" if check else f"{version} is not a valid {component} version."
+
+
+def validate_language_code(value: str) -> str:
+    """Language code should be valid."""
+    pattern = r"^([a-z]{2}|[a-z]{2}-[a-z]{2})$"
+    return (
+        "" if re.match(pattern, value) else f"'{value}' is not a valid language code."
+    )
+
+
+def validate_python_package_name(value: str) -> str:
+    """Validate python_package_name is an identifier."""
+    status = False
+    if "." in value:
+        namespace, package = value.split(".")
+        status = namespace.isidentifier() and package.isidentifier()
+    else:
+        status = value.isidentifier()
+    return "" if status else f"'{value}' is not a valid Python identifier."
+
+
+def validate_hostname(value: str) -> str:
+    """Check if hostname is valid."""
+    valid = False
+    if value and value.strip():
+        value_with_protocol = f"https://{value}"
+        result = urlparse(value_with_protocol)
+        valid = str(result.hostname) == value
+    return "" if valid else f"'{value}' is not a valid hostname."
+
+
+def validate_volto_addon_name(value: str) -> str:
+    """Validate the volto addon name is valid."""
+    pattern = "^[a-z0-9-~][a-z0-9-._~]*$"
+    return "" if re.match(pattern, value) else f"'{value}' is not a valid name."
+
+
+def validate_npm_package_name(value: str) -> str:
+    """Validate the npm package name is valid."""
+    pattern = r"^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$"
+    return "" if re.match(pattern, value) else f"'{value}' is not a valid package name."
+
+
+def validate_plone_version(value: str) -> str:
+    """Validate Plone Version."""
+    status = False
+    version = _version_from_str(value)
+    if version:
+        status = version >= _version_from_str(settings.PLONE_MIN_VERSION)
+    return "" if status else f"{value} is not a valid Plone version."
+
+
+def validate_volto_version(value: str) -> str:
+    """Validate Volto Version."""
+    status = False
+    version = _version_from_str(value)
+    if version:
+        status = version >= _version_from_str(settings.VOLTO_MIN_VERSION)
+    return "" if status else f"{value} is not a valid Volto version."
+
+
+def run_context_validations(
+    context: dict, validations: list[data.ItemValidator], allow_empty: bool = False
+) -> data.ContextValidatorResult:
+    """Run validations for context."""
+    global_status = True
+    results = []
+    if not allow_empty:
+        func = validate_not_empty
+        for key in context:
+            if key.startswith("_"):
+                # Ignore computed values
+                continue
+            validations.append(data.ItemValidator(key, func, "error"))
+    for validation in validations:
+        key = validation.key
+        func = validation.func
+        value = context.get(key, "")
+        level = validation.level
+        message = func(value, key) if func == validate_not_empty else func(value)
+        if not message:
+            status = True
+            message = "✓"
+        elif level == "warning":
+            status = True
+        elif level == "error":
+            status = False
+        global_status = global_status and status
+        results.append(data.ItemValidatorResult(key, status, message))
+    global_message = (
+        f"Ran {len(results)} validations and "
+        f"they {'passed' if global_status else 'failed'}."
+    )
+    return data.ContextValidatorResult(
+        status=global_status, message=global_message, validations=results
+    )

cookieplone-0.1.0/cookieplone/utils/versions.py

@@ -0,0 +1,92 @@
+import requests
+from packaging.version import Version
+
+from cookieplone import settings
+
+
+def get_npm_package_versions(package: str) -> list[str]:
+    """Get versions for a NPM package."""
+    url: str = f"https://registry.npmjs.org/{package}"
+    resp = requests.get(url, headers={"Accept": "application/vnd.npm.install-v1+json"})  # noQA: S113
+    data = resp.json()
+    return list(data["dist-tags"].values())
+
+
+def get_pypi_package_versions(package: str) -> list[str]:
+    """Get versions for a PyPi package."""
+    url: str = f"https://pypi.org/pypi/{package}/json"
+    resp = requests.get(url)  # noQA: S113
+    data = resp.json()
+    return list(data.get("releases").keys())
+
+
+def is_valid_version(
+    version: Version,
+    min_version: Version | None = None,
+    max_version: Version | None = None,
+    allow_prerelease: bool = False,
+) -> bool:
+    """Check if version is valid."""
+    status = True
+    if version.is_prerelease:
+        status = allow_prerelease
+    if status and min_version:
+        status = version >= min_version
+    if status and max_version:
+        status = version < max_version
+    return status
+
+
+def latest_version(
+    versions: list[str],
+    min_version: str | None = None,
+    max_version: str | None = None,
+    allow_prerelease: bool = False,
+) -> str | None:
+    min_version = Version(min_version) if min_version else None
+    max_version = Version(max_version) if max_version else None
+    versions_ = sorted(
+        [(Version(v.replace("v", "")), v) for v in versions], reverse=True
+    )
+    valid = [
+        (version, raw_version)
+        for version, raw_version in versions_
+        if is_valid_version(version, min_version, max_version, allow_prerelease)
+    ]
+    return valid[0][1] if valid else None
+
+
+def latest_volto(
+    min_version: str | None = None,
+    max_version: str | None = None,
+    allow_prerelease: bool = False,
+) -> str | None:
+    """Return the latest volto version."""
+    versions = get_npm_package_versions("@plone/volto")
+    return latest_version(
+        versions,
+        min_version=min_version,
+        max_version=max_version,
+        allow_prerelease=allow_prerelease,
+    )
+
+
+def latest_plone(
+    min_version: str | None = None,
+    max_version: str | None = None,
+    allow_prerelease: bool = False,
+) -> str | None:
+    """Return the latest Plone version."""
+    versions = get_pypi_package_versions("Plone")
+    return latest_version(
+        versions,
+        min_version=min_version,
+        max_version=max_version,
+        allow_prerelease=allow_prerelease,
+    )
+
+
+def node_version_for_volto(volto_version: str) -> int:
+    """Return the Node Version to be used with Volto."""
+    major = Version(volto_version).major
+    return settings.VOLTO_NODE.get(major, settings.DEFAULT_NODE)

cookieplone-0.1.0/pyproject.toml

@@ -0,0 +1,105 @@
+[tool.poetry]
+name = "cookieplone"
+version = "0"
+description = "Create Plone projects, addons, documentation with ease!"
+authors = ["Plone Community <dev@plone.org>"]
+repository = "https://github.com/plone/cookieplone"
+documentation = "https://plone.github.io/cookieplone/"
+readme = "README.md"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Natural Language :: English",
+  "License :: OSI Approved :: BSD License",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python",
+  "Topic :: Software Development",
+  "Topic :: Software Development :: Code Generators"
+]
+packages = [
+  {include = "cookieplone"}
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+cookiecutter = "^2.6.0"
+semver = "^3.0.2"
+typer = {extras = ["all"], version = "^0.12.3"}
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.1.1"
+pytest-cov = "^5.0.0"
+pre-commit = "^3.7.0"
+tox = "^4.14.2"
+
+[tool.poetry.scripts]
+cookieplone = 'cookieplone.__main__:main'
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+fix = true
+lint.select = [
+    # flake8-2020
+    "YTT",
+    # flake8-bandit
+    "S",
+    # flake8-bugbear
+    "B",
+    # flake8-builtins
+    "A",
+    # flake8-comprehensions
+    "C4",
+    # flake8-debugger
+    "T10",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+    # mccabe
+    "C90",
+    # pycodestyle
+    "E", "W",
+    # pyflakes
+    "F",
+    # pygrep-hooks
+    "PGH",
+    # pyupgrade
+    "UP",
+    # ruff
+    "RUF",
+]
+lint.ignore = [
+    # DoNotAssignLambda
+    "E731",
+]
+
+[tool.ruff.format]
+preview = true
+
+[tool.coverage.report]
+skip_empty = true
+
+[tool.coverage.run]
+branch = true
+source = ["cookieplone"]
+
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]
+
+[tool.poetry-version-plugin]
+source = "init"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

cookieplone-0.1.0/setup.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['cookieplone',
+ 'cookieplone.filters',
+ 'cookieplone.utils',
+ 'cookieplone.utils.commands']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['cookiecutter>=2.6.0,<3.0.0',
+ 'semver>=3.0.2,<4.0.0',
+ 'typer[all]>=0.12.3,<0.13.0']
+
+entry_points = \
+{'console_scripts': ['cookieplone = cookieplone.__main__:main']}
+
+setup_kwargs = {
+    'name': 'cookieplone',
+    'version': '0.1.0',
+    'description': 'Create Plone projects, addons, documentation with ease!',
+    'long_description': '<p align="center">\n    <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-logo.png">\n</p>\n\n<h1 align="center">\n  cookieplone\n</h1>\n\n\n<div align="center">\n\n[![PyPI](https://img.shields.io/pypi/v/cookieplone)](https://pypi.org/project/cookieplone/)\n[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cookieplone)](https://pypi.org/project/cookieplone/)\n[![PyPI - Wheel](https://img.shields.io/pypi/wheel/cookieplone)](https://pypi.org/project/cookieplone/)\n[![PyPI - License](https://img.shields.io/pypi/l/cookieplone)](https://pypi.org/project/cookieplone/)\n[![PyPI - Status](https://img.shields.io/pypi/status/cookieplone)](https://pypi.org/project/cookieplone/)\n\n\n[![PyPI - Plone Versions](https://img.shields.io/pypi/frameworkversions/plone/cookieplone)](https://pypi.org/project/cookieplone/)\n\n[![Tests](https://github.com/plone/cookieplone/actions/workflows/main.yml/badge.svg)](https://github.com/plone/cookieplone/actions/workflows/main.yml)\n\n[![GitHub contributors](https://img.shields.io/github/contributors/plone/cookieplone)](https://github.com/plone/cookieplone)\n[![GitHub Repo stars](https://img.shields.io/github/stars/plone/cookieplone?style=social)](https://github.com/plone/cookieplone)\n\n</div>\n',
+    'author': 'Plone Community',
+    'author_email': 'dev@plone.org',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'https://github.com/plone/cookieplone',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'entry_points': entry_points,
+    'python_requires': '>=3.10,<4.0',
+}
+
+
+setup(**setup_kwargs)