shipit-cli 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

shipit/providers/registry.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from .base import Provider
 from .hugo import HugoProvider
 from .laravel import LaravelProvider

shipit/providers/staticfile.py

@@ -1,9 +1,8 @@
-from __future__ import annotations
-
 from pathlib import Path
 from typing import Dict, Optional
 import json
 import yaml
+from pydantic_settings import SettingsConfigDict
 
 from .base import (
     DetectResult,
@@ -13,69 +12,89 @@ from .base import (
     MountSpec,
     ServiceSpec,
     VolumeSpec,
-    CustomCommands,
+    Config,
 )
 
 
+class StaticFileConfig(Config):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    sws_version: Optional[str] = "2.38.0"
+    static_dir: Optional[str] = None
+
+
 class StaticFileProvider:
     config: Optional[dict] = None
     path: Path
-    custom_commands: CustomCommands
 
-    def __init__(self, path: Path, custom_commands: CustomCommands):
+    def __init__(self, path: Path, config: StaticFileConfig):
         self.path = path
-        self.custom_commands = custom_commands
-        if (self.path / "Staticfile").exists():
+        self.config = config
+
+    @classmethod
+    def load_config(
+        cls, path: Path, base_config: Config
+    ) -> StaticFileConfig:
+        if (path / "Staticfile").exists():
+            config = None
             try:
-                self.config = yaml.safe_load((self.path / "Staticfile").read_text())
+                config = yaml.safe_load((path / "Staticfile").read_text())
             except yaml.YAMLError as e:
                 print(f"Error loading Staticfile: {e}")
                 pass
 
+            if config:
+                return StaticFileConfig(
+                    **base_config.model_dump(),
+                    static_dir=config.get("root"),
+                )
+        if _exists(path, "public/index.html") or _exists(path, "public/index.htm"):
+            return StaticFileConfig(static_dir="public", **base_config.model_dump())
+
+        return StaticFileConfig(**base_config.model_dump())
+
     @classmethod
     def name(cls) -> str:
         return "staticfile"
 
     @classmethod
     def detect(
-        cls, path: Path, custom_commands: CustomCommands
+        cls, path: Path, config: Config
     ) -> Optional[DetectResult]:
+        is_python_php_js_project = _exists(
+            path, "package.json", "pyproject.toml", "composer.json"
+        )
         if _exists(path, "Staticfile"):
             return DetectResult(cls.name(), 50)
-        if _exists(path, "index.html") and not _exists(
-            path, "package.json", "pyproject.toml", "composer.json"
-        ):
+        if not is_python_php_js_project:
+            if _exists(
+                path, "index.html", "index.htm", "public/index.htm", "public/index.html"
+            ):
+                return DetectResult(cls.name(), 10)
             return DetectResult(cls.name(), 10)
-        if custom_commands.start and custom_commands.start.startswith(
+        if config.commands.start and config.commands.start.startswith(
             "static-web-server "
         ):
             return DetectResult(cls.name(), 70)
         return None
 
-    def initialize(self) -> None:
-        pass
-
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return None
-
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "static-web-server",
-                env_var="SHIPIT_SWS_VERSION",
-                default_version="2.38.0",
+                var_name="config.sws_version",
                 use_in_serve=True,
             )
         ]
 
     def build_steps(self) -> list[str]:
         return [
-            'workdir(app["build"])',
+            'workdir(static_app.path)',
             'copy({}, ".", ignore=[".git"])'.format(
-                json.dumps(self.config and self.config.get("root") or ".")
+                json.dumps(self.config.static_dir or ".")
             ),
         ]
 
@@ -87,11 +106,11 @@ class StaticFileProvider:
 
     def commands(self) -> Dict[str, str]:
         return {
-            "start": '"static-web-server --root={} --log-level=info --port={}".format(app["serve"], PORT)'
+            "start": '"static-web-server --root={} --log-level=info --port={}".format(static_app.serve_path, PORT)'
         }
 
     def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app")]
+        return [MountSpec("static_app")]
 
     def volumes(self) -> list[VolumeSpec]:
         return []

shipit/providers/wordpress.py

@@ -1,6 +1,3 @@
-from __future__ import annotations
-from shipit.providers.php import PhpProvider
-
 from pathlib import Path
 from typing import Dict, Optional
 
@@ -12,22 +9,33 @@ from .base import (
     MountSpec,
     ServiceSpec,
     VolumeSpec,
-    CustomCommands,
+    Config,
 )
-from .php import PhpProvider
+from .php import PhpConfig, PhpProvider
+from pydantic_settings import SettingsConfigDict
 
 
-class WordPressProvider(PhpProvider):
-    def __init__(self, path: Path, custom_commands: CustomCommands):
-        super().__init__(path, custom_commands)
+class WordPressConfig(PhpConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    wp_cli_version: Optional[str] = None
 
+
+class WordPressProvider(PhpProvider):
     @classmethod
     def name(cls) -> str:
         return "wordpress"
 
+    @classmethod
+    def load_config(
+        cls, path: Path, config: Config
+    ) -> WordPressConfig:
+        php_config = super().load_config(path, config)
+        return WordPressConfig(**php_config.model_dump())
+
     @classmethod
     def detect(
-        cls, path: Path, custom_commands: CustomCommands
+        cls, path: Path, config: Config
     ) -> Optional[DetectResult]:
         if (
             _exists(path, "wp-content")
@@ -37,15 +45,9 @@ class WordPressProvider(PhpProvider):
             return DetectResult(cls.name(), 80)
         return None
 
-    def initialize(self) -> None:
-        pass
-
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return None
-
     def dependencies(self) -> list[DependencySpec]:
         return [
             *super().dependencies(),
@@ -54,21 +56,18 @@ class WordPressProvider(PhpProvider):
 
     def declarations(self) -> Optional[str]:
         return (super().declarations() or "") + (
-            'wp_cli_version = getenv("SHIPIT_WPCLI_VERSION")\n'
-            "if wp_cli_version:\n"
-            '    wp_cli_download_url = f"https://github.com/wp-cli/wp-cli/releases/download/v{wp_cli_version}/wp-cli-{wp_cli_version}.phar"\n'
-            "else:\n"
-            '    wp_cli_download_url = "https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar"\n'
+            "wp_cli_version = config.wp_cli_version\n"
+            'wp_cli_download_url = f"https://github.com/wp-cli/wp-cli/releases/download/v{wp_cli_version}/wp-cli-{wp_cli_version}.phar" if wp_cli_version else "https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar"\n'
         )
 
     def build_steps(self) -> list[str]:
         steps = [
-            'copy(wp_cli_download_url, "{}/wp-cli.phar".format(assets["build"]))',
-            'copy("wordpress/install.sh", "{}/setup-wp.sh".format(assets["build"]), base="assets")',
+            'copy(wp_cli_download_url, "{}/wp-cli.phar".format(assets.path))',
+            'copy("wordpress/install.sh", "{}/setup-wp.sh".format(assets.path), base="assets")',
         ]
         if not _exists(self.path, "wp-config.php"):
             steps.append(
-                'copy("wordpress/wp-config.php", "{}/wp-config.php".format(app["build"]), base="assets")'
+                'copy("wordpress/wp-config.php", "{}/wp-config.php".format(app.path), base="assets")'
             )
         return steps + super().build_steps()
 
@@ -78,8 +77,8 @@ class WordPressProvider(PhpProvider):
     def commands(self) -> Dict[str, str]:
         commands = super().commands()
         return {
-            # "wp": '"php {}/wp-cli.phar --allow-root --path={}".format(assets["serve"], app["serve"])',
-            "after_deploy": '"bash {}/setup-wp.sh".format(assets["serve"])',
+            # "wp": '"php {}/wp-cli.phar --allow-root --path={}".format(assets.serve_path, app.serve_path)',
+            "after_deploy": '"bash {}/setup-wp.sh".format(assets.serve_path)',
             **commands,
         }
 
@@ -90,7 +89,7 @@ class WordPressProvider(PhpProvider):
         return [
             VolumeSpec(
                 name="wp-content",
-                serve_path='"{}/wp-content/".format(app["serve"])',
+                serve_path='"{}/wp-content/".format(app.serve_path)',
                 var_name="wp_content",
             )
         ]

shipit/runners/__init__.py

@@ -0,0 +1,9 @@
+from .base import Runner
+from .local import LocalRunner
+from .wasmer import WasmerRunner
+
+__all__ = [
+    "Runner",
+    "LocalRunner",
+    "WasmerRunner",
+]

shipit/runners/base.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+from typing import Dict, List, Protocol, TYPE_CHECKING
+
+from shipit.builders.base import BuildBackend
+
+if TYPE_CHECKING:
+    from shipit.shipit_types import PrepareStep, Serve
+
+
+class Runner(Protocol):
+    build_backend: BuildBackend
+
+    def prepare_config(self, provider_config: object) -> object: ...
+    def build(self, serve: "Serve") -> None: ...
+    def prepare(self, env: Dict[str, str], prepare: List["PrepareStep"]) -> None: ...
+    def run_serve_command(self, command: str) -> None: ...
+    def get_serve_mount_path(self, name: str) -> Path: ...

shipit/runners/local.py

@@ -0,0 +1,105 @@
+import shutil
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import sh  # type: ignore[import-untyped]
+from rich import box
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from shipit.builders.base import BuildBackend
+from shipit.runners.base import Runner
+from shipit.shipit_types import PrepareStep, Serve
+from shipit.ui import console, write_stderr, write_stdout
+
+
+class LocalRunner:
+    def __init__(self, build_backend: BuildBackend, src_dir: Path) -> None:
+        self.build_backend = build_backend
+        self.src_dir = src_dir
+        self.runner_path = self.src_dir / ".shipit" / "runner" / "local"
+        self.serve_bin_path = self.runner_path / "serve" / "bin"
+        self.prepare_bash_script = self.runner_path / "prepare" / "prepare.sh"
+
+    def prepare_config(self, provider_config: object) -> object:
+        return provider_config
+
+    def get_serve_mount_path(self, name: str) -> Path:
+        return self.build_backend.get_artifact_mount_path(name)
+
+    def build(self, serve: Serve) -> None:
+        self.build_prepare(serve)
+        self.build_serve(serve)
+
+    def build_prepare(self, serve: Serve) -> None:
+        if not serve.prepare:
+            return
+        self.prepare_bash_script.parent.mkdir(parents=True, exist_ok=True)
+        commands: List[str] = []
+        if serve.cwd:
+            commands.append(f"cd {serve.cwd}")
+        if serve.prepare:
+            for step in serve.prepare:
+                commands.append(step.command)
+        content = "#!/bin/bash\n{body}".format(body="\n".join(commands))
+        console.print(
+            f"\n[bold]Created prepare.sh script to run before packaging ✅[/bold]"
+        )
+        manifest_panel = Panel(
+            Syntax(
+                content,
+                "bash",
+                theme="monokai",
+                background_color="default",
+                line_numbers=True,
+            ),
+            box=box.SQUARE,
+            border_style="bright_black",
+            expand=False,
+        )
+        console.print(manifest_panel, markup=False, highlight=True)
+        self.prepare_bash_script.write_text(content)
+        self.prepare_bash_script.chmod(0o755)
+
+    def build_serve(self, serve: Serve) -> None:
+        console.print("\n[bold]Building serve[/bold]")
+        shutil.rmtree(self.serve_bin_path.parent, ignore_errors=True)
+        self.serve_bin_path.mkdir(parents=True, exist_ok=True)
+        runtime_path = self.build_backend.get_runtime_path() or ""
+        path_prefix = f"PATH={runtime_path}:$PATH " if runtime_path else ""
+        console.print(f"[bold]Serve Commands:[/bold]")
+        for command in serve.commands:
+            console.print(f"* {command}")
+            command_path = self.serve_bin_path / command
+            env_vars = ""
+            if serve.env:
+                env_vars = " ".join([f"{k}={v}" for k, v in serve.env.items()])
+            lines = ["#!/bin/bash"]
+            if serve.cwd:
+                lines.append(f"cd {serve.cwd}")
+            cmd_body = f"{path_prefix}{env_vars} {serve.commands[command]}".strip()
+            lines.append(cmd_body)
+            content = "\n".join(lines) + "\n"
+            command_path.write_text(content)
+            manifest_panel = Panel(
+                Syntax(
+                    content.strip(),
+                    "bash",
+                    theme="monokai",
+                    background_color="default",
+                    line_numbers=True,
+                ),
+                box=box.SQUARE,
+                border_style="bright_black",
+                expand=False,
+            )
+            console.print(manifest_panel, markup=False, highlight=True)
+            command_path.chmod(0o755)
+
+    def prepare(self, env: Dict[str, str], prepare: List[PrepareStep]) -> None:
+        sh.Command(str(self.prepare_bash_script))(_out=write_stdout, _err=write_stderr)
+
+    def run_serve_command(self, command: str) -> None:
+        console.print(f"\n[bold]Running {command} command[/bold]")
+        command_path = self.serve_bin_path / command
+        sh.Command(str(command_path))(_out=write_stdout, _err=write_stderr)