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

shipit/providers/laravel.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from pathlib import Path
 from typing import Dict, Optional
 
@@ -12,65 +10,76 @@ from .base import (
     ServiceSpec,
     VolumeSpec,
     CustomCommands,
+    Config,
 )
+from .php import PhpConfig, PhpProvider
+from .node_static import NodeStaticConfig, NodeStaticProvider
+from pydantic_settings import SettingsConfigDict
+
+
+class LaravelConfig(PhpConfig, NodeStaticConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
 
 
-class LaravelProvider:
-    def __init__(self, path: Path, custom_commands: CustomCommands):
+class LaravelProvider(PhpProvider):
+    def __init__(self, path: Path, config: LaravelConfig):
         self.path = path
-        self.custom_commands = custom_commands
+        self.node_provider = NodeStaticProvider(path, config, only_build=True)
+        self.config = config
+
+    @classmethod
+    def load_config(cls, path: Path, base_config: Config) -> LaravelConfig:
+        config = super().load_config(path, base_config)
+        node_config = NodeStaticProvider.load_config(path, base_config)
+        node_config.static_dir = None
+        node_config.static_generator = None
+        return LaravelConfig(
+            **(
+                config.model_dump()
+                | node_config.model_dump()
+                | base_config.model_dump()
+            )
+        )
 
     @classmethod
     def name(cls) -> str:
         return "laravel"
 
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
+    def detect(cls, path: Path, config: Config) -> Optional[DetectResult]:
         if _exists(path, "artisan") and _exists(path, "composer.json"):
             return DetectResult(cls.name(), 95)
         return None
 
-    def initialize(self) -> None:
-        pass
-
-    def serve_name(self) -> str:
-        return self.path.name
-
-    def platform(self) -> Optional[str]:
-        return "laravel"
+    def serve_name(self) -> Optional[str]:
+        return None
 
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "php",
-                env_var="SHIPIT_PHP_VERSION",
-                default_version="8.3",
+                var_name="config.php_version",
                 use_in_build=True,
                 use_in_serve=True,
             ),
             DependencySpec("composer", use_in_build=True),
-            DependencySpec("pie", use_in_build=True),
-            DependencySpec("pnpm", use_in_build=True),
+            # DependencySpec("pie", use_in_build=True),
+            *self.node_provider.dependencies(),
             DependencySpec("bash", use_in_serve=True),
         ]
 
-    def declarations(self) -> Optional[str]:
-        return "HOME = getenv(\"HOME\")"
-
     def build_steps(self) -> list[str]:
         return [
-            "env(HOME=HOME, COMPOSER_FUND=\"0\")",
-            "workdir(app[\"build\"])",
-            "run(\"pie install php/pdo_pgsql\")",
-            "run(\"composer install --optimize-autoloader --no-scripts --no-interaction\", inputs=[\"composer.json\", \"composer.lock\", \"artisan\"], outputs=[\".\"], group=\"install\")",
-            "run(\"pnpm install\", inputs=[\"package.json\", \"package-lock.json\"], outputs=[\".\"], group=\"install\")",
-            "copy(\".\", \".\", ignore=[\".git\"])",
-            "run(\"pnpm run build\", outputs=[\".\"], group=\"build\")",
+            'env(COMPOSER_HOME="/tmp", COMPOSER_FUND="0")',
+            'workdir(app.path)',
+            # "run(\"pie install php/pdo_pgsql\")",
+            'run("composer install --optimize-autoloader --no-scripts --no-interaction", inputs=["composer.json", "composer.lock", "artisan"], outputs=["."], group="install")',
+            *self.node_provider.build_steps(),
         ]
 
     def prepare_steps(self) -> Optional[list[str]]:
         return [
-            'workdir(app["serve"])',
+            'workdir(app.serve_path)',
             'run("mkdir -p storage/framework/{sessions,views,cache,testing} storage/logs bootstrap/cache")',
             'run("php artisan config:cache")',
             'run("php artisan event:cache")',
@@ -85,13 +94,13 @@ class LaravelProvider:
         }
 
     def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app")]
+        return [MountSpec("app"), *self.node_provider.mounts()]
 
     def volumes(self) -> list[VolumeSpec]:
         return []
 
     def env(self) -> Optional[Dict[str, str]]:
         return None
-    
+
     def services(self) -> list[ServiceSpec]:
         return []

shipit/providers/mkdocs.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from pathlib import Path
 from typing import Dict, Optional
 
@@ -12,35 +10,52 @@ from .base import (
     ServiceSpec,
     VolumeSpec,
     CustomCommands,
+    Config,
 )
-from .staticfile import StaticFileProvider
-from .python import PythonProvider
+from .staticfile import StaticFileProvider, StaticFileConfig
+from .python import PythonProvider, PythonConfig
+from pydantic_settings import SettingsConfigDict
+
+
+class MkdocsConfig(PythonConfig, StaticFileConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    mkdocs_version: Optional[str] = None
 
 
 class MkdocsProvider(StaticFileProvider):
-    def __init__(self, path: Path, custom_commands: CustomCommands):
+    def __init__(self, path: Path, config: MkdocsConfig):
         self.path = path
-        self.python_provider = PythonProvider(path, custom_commands, only_build=True, extra_dependencies={"mkdocs"})
+        self.python_provider = PythonProvider(path, config, only_build=True)
+
+    @classmethod
+    def load_config(cls, path: Path, base_config: Config) -> MkdocsConfig:
+        python_config = PythonProvider.load_config(
+            path, base_config, must_have_deps={"mkdocs"}
+        )
+        staticfile_config = StaticFileProvider.load_config(path, base_config)
+
+        return MkdocsConfig(
+            **(
+                python_config.model_dump()
+                | staticfile_config.model_dump()
+                | base_config.model_dump()
+            )
+        )
 
     @classmethod
     def name(cls) -> str:
         return "mkdocs"
 
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
+    def detect(cls, path: Path, config: Config) -> Optional[DetectResult]:
         if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
             return DetectResult(cls.name(), 85)
-        if custom_commands.build and custom_commands.build.startswith("mkdocs "):
+        if config.commands.build and config.commands.build.startswith("mkdocs "):
             return DetectResult(cls.name(), 85)
         return None
 
-    def initialize(self) -> None:
-        pass
-
-    def serve_name(self) -> str:
-        return self.path.name
-
-    def platform(self) -> Optional[str]:
+    def serve_name(self) -> Optional[str]:
         return None
 
     def dependencies(self) -> list[DependencySpec]:
@@ -50,25 +65,25 @@ class MkdocsProvider(StaticFileProvider):
         ]
 
     def declarations(self) -> Optional[str]:
-        return "mkdocs_version = getenv(\"SHIPIT_MKDOCS_VERSION\") or \"1.6.1\"\n" + (self.python_provider.declarations() or "")
+        return self.python_provider.declarations() or ""
 
     def build_steps(self) -> list[str]:
         return [
             *self.python_provider.build_steps(),
-            "run(\"uv run mkdocs build --site-dir={}\".format(app[\"build\"]), outputs=[\".\"], group=\"build\")",
+            'run("uv run mkdocs build --site-dir={}".format(static_app.path), outputs=["."], group="build")',
         ]
 
     def prepare_steps(self) -> Optional[list[str]]:
         return self.python_provider.prepare_steps()
 
     def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app"), *self.python_provider.mounts()]
+        return [*self.python_provider.mounts(), *super().mounts()]
 
     def volumes(self) -> list[VolumeSpec]:
         return []
 
     def env(self) -> Optional[Dict[str, str]]:
         return self.python_provider.env()
-    
+
     def services(self) -> list[ServiceSpec]:
         return []