shipit-cli 0.19.7__tar.gz → 0.19.9__tar.gz

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.19.7
+Version: 0.19.9
 Summary: Shipit CLI is the best way to build, serve and deploy your projects anywhere.
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.19.7"
+version = "0.19.9"
 description = "Shipit CLI is the best way to build, serve and deploy your projects anywhere."
 readme = "README.md"
 requires-python = ">=3.10"

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/src/shipit/assets/wordpress/install.sh

@@ -7,11 +7,23 @@ export PAGER="cat"
 WP_ADMIN_EMAIL=${WP_ADMIN_EMAIL:-"admin@example.com"}
 WP_ADMIN_USERNAME=${WP_ADMIN_USERNAME:-"admin"}
 WP_ADMIN_PASSWORD=${WP_ADMIN_PASSWORD:-"admin"}
-WP_LOCALE=${WP_LOCALE:-"en_US"}
+WP_DEFAULT_LOCALE=${WP_DEFAULT_LOCALE:-"en_US"}
+WP_LOCALE=${WP_LOCALE:-"$WP_DEFAULT_LOCALE"}
 WP_SITEURL=${WP_SITEURL:-"http://localhost"}
 WP_SITE_TITLE=${WP_SITE_TITLE:-"WordPress"}
 
-if wp core is-installed; then
+echo "📁 Initializing wp-content..."
+mkdir -p wp-content/plugins
+mkdir -p wp-content/themes
+mkdir -p wp-content/upgrade
+
+if [ -n "${WPCONTENT_BASE_PATH:-}" ] && [ -d "${WPCONTENT_BASE_PATH}" ]; then
+  shopt -s dotglob nullglob
+  cp -R "${WPCONTENT_BASE_PATH}"/* /app/wp-content || true
+  shopt -u dotglob nullglob
+fi
+
+if wp core is-installed && [ "${WP_FORCE_SETUP:-false}" != "true" ]; then
   echo "🚀 Setting up WordPress from an existing installation"
   if [ "${WP_UPDATE_DB:-true}" = "true" ]; then
       echo "🛠️ Activating maintenance mode..."
@@ -23,20 +35,6 @@ if wp core is-installed; then
   fi
 else
   echo "🚀 Setting up WordPress from a fresh install"
-  echo "📁 Initializing wp-content..."
-
-  mkdir -p wp-content/plugins
-  mkdir -p wp-content/themes
-  mkdir -p wp-content/upgrade
-
-  if [ -n "${WPCONTENT_BASE_PATH:-}" ] && [ -d "${WPCONTENT_BASE_PATH}" ]; then
-    shopt -s dotglob nullglob
-    # Note: change this back to copy all, once using the WP Zip files
-    # cp -R "${WPCONTENT_BASE_PATH}"/* /app/wp-content
-    cp -R "${WPCONTENT_BASE_PATH}"/plugins/* /app/wp-content/plugins || true
-    cp -R "${WPCONTENT_BASE_PATH}"/themes/twentytwenty* /app/wp-content/themes || true
-    shopt -u dotglob nullglob
-  fi
 
   echo "⚙️ Installing WordPress core"
 
@@ -60,7 +58,7 @@ if [ -n "${WP_PLUGINS:-}" ]; then
   for PLUGIN_ENTRY in $WP_PLUGINS; do
     if [[ "$PLUGIN_ENTRY" =~ ^https?:// ]]; then
       echo "• Installing plugin from URL: $PLUGIN_ENTRY"
-      wp plugin install "$PLUGIN_ENTRY" --activate
+      wp plugin install "$PLUGIN_ENTRY" --force --activate
     else
       # Extract name and version using parameter expansion
       PLUGIN_NAME="${PLUGIN_ENTRY%%:*}"
@@ -68,15 +66,25 @@ if [ -n "${WP_PLUGINS:-}" ]; then
 
       if [[ "$PLUGIN_NAME" == "$PLUGIN_VERSION" ]]; then
         echo "• Installing plugin '${PLUGIN_NAME}' (latest version)..."
-        wp plugin install "$PLUGIN_NAME" --activate
+        wp plugin install "$PLUGIN_NAME" --force --activate
       else
         echo "• Installing plugin '${PLUGIN_NAME}' (version: ${PLUGIN_VERSION})..."
-        wp plugin install "$PLUGIN_NAME" --version="$PLUGIN_VERSION" --activate
+        wp plugin install "$PLUGIN_NAME" --force --version="$PLUGIN_VERSION" --activate
       fi
     fi
   done
 fi
 
+if [ -n "${WP_PLUGINS_ACTIVATE:-}" ]; then
+  echo "✨ Activating plugins: $WP_PLUGINS_ACTIVATE"
+  IFS=',' # Split by commas
+  
+  for PLUGIN_ENTRY in $WP_PLUGINS_ACTIVATE; do
+    echo "• Activating plugin: $PLUGIN_ENTRY"
+    wp plugin activate "$PLUGIN_ENTRY"
+  done
+fi
+
 # Install themes from WP_THEMES environment variable
 if [ -n "${WP_THEMES:-}" ]; then
   echo "🎨 Installing themes from WP_THEMES: $WP_THEMES"
@@ -85,17 +93,17 @@ if [ -n "${WP_THEMES:-}" ]; then
   for THEME_ENTRY in $WP_THEMES; do
     if [[ "$THEME_ENTRY" =~ ^https?:// ]]; then
       echo "• Installing theme from URL: $THEME_ENTRY"
-      wp theme install "$THEME_ENTRY"
+      wp theme install "$THEME_ENTRY" --force
     else
       THEME_NAME="${THEME_ENTRY%%:*}"
       THEME_VERSION="${THEME_ENTRY#*:}"
 
       if [[ "$THEME_NAME" == "$THEME_VERSION" ]]; then
         echo "• Installing theme '${THEME_NAME}' (latest version)..."
-        wp theme install "$THEME_NAME"
+        wp theme install "$THEME_NAME" --force
       else
         echo "• Installing theme '${THEME_NAME}' (version: ${THEME_VERSION})..."
-        wp theme install "$THEME_NAME" --version="$THEME_VERSION"
+        wp theme install "$THEME_NAME" --force --version="$THEME_VERSION"
       fi
     fi
   done
@@ -108,14 +116,14 @@ fi
 
 if [ -n "${WP_LOCALE:-}" ]; then
   echo "🌐 Setting locale: $WP_LOCALE"
-  wp language core install "$WP_LOCALE"
-  wp language theme install --all "$WP_LOCALE"
-  wp language plugin install --all "$WP_LOCALE"
+  # wp language core install "$WP_LOCALE"
+  # wp language theme install --all "$WP_LOCALE"
+  # wp language plugin install --all "$WP_LOCALE"
   wp site switch-language "$WP_LOCALE"
 fi
 
-# echo "✍️ Rewriting permalinks structure"
-# wp rewrite flush --hard || true
+echo "✍️ Rewriting permalinks structure"
+wp rewrite flush --hard || true
 
 # if [ ! -f "/app/wp-content/wp-config.php" ]; then
 #   cat > /app/wp-content/wp-config.php <<EOF

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/src/shipit/providers/php.py

@@ -184,13 +184,21 @@ class PhpProvider:
     def dependencies(self) -> list[DependencySpec]:
         deps = [
             DependencySpec(
-                "php" if not self.config.phpix else "phpix",
+                "php",
                 var_name="config.php_version",
                 architecture_var_name="config.php_architecture",
                 use_in_build=True,
-                use_in_serve=True,
+                use_in_serve=not self.config.phpix,
             ),
         ]
+        if self.config.phpix:
+            deps.append(DependencySpec(
+                "phpix",
+                var_name="config.php_version",
+                architecture_var_name="config.php_architecture",
+                use_in_build=False,
+                use_in_serve=True,
+            ))
         if self.config.use_composer:
             deps.append(DependencySpec("composer", use_in_build=True))
             deps.append(DependencySpec("bash", use_in_serve=True))

shipit_cli-0.19.9/src/shipit/providers/wordpress.py

@@ -0,0 +1,305 @@
+import json
+import re
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from typing import Dict, Literal, Optional
+
+from pydantic_settings import SettingsConfigDict
+
+from .base import (
+    Config,
+    DetectResult,
+    DependencySpec,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    _exists,
+)
+from .php import PhpConfig, PhpProvider
+
+
+@dataclass(frozen=True)
+class WordPressExtension:
+    kind: Literal["plugin", "theme"]
+    slug: str
+    activate_target: str
+    source_file: Optional[str] = None
+
+    @property
+    def content_dir(self) -> str:
+        return f"{self.kind}s"
+
+
+class WordPressConfig(PhpConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    wp_version: Optional[str] = None
+    wp_locale: Optional[str] = None
+    wp_cli_version: Optional[str] = None
+
+
+class WordPressProvider(PhpProvider):
+    HEADER_SCAN_BYTES = 8192
+    PLUGIN_HEADER_RE = re.compile(
+        r"^[ \t/*#@]*Plugin Name\s*:", re.I | re.M
+    )
+    THEME_HEADER_RE = re.compile(
+        r"^[ \t/*#@]*Theme Name\s*:", re.I | re.M
+    )
+
+    @classmethod
+    def name(cls) -> str:
+        return "wordpress"
+
+    @classmethod
+    def load_config(
+        cls, path: Path, config: Config
+    ) -> WordPressConfig:
+        php_config = super().load_config(path, config)
+        wp_config = WordPressConfig(**php_config.model_dump())
+        if cls.detect_extension(path) and not wp_config.wp_version:
+            wp_config.wp_version = "latest"
+        return wp_config
+
+    @classmethod
+    def detect(
+        cls, path: Path, config: Config
+    ) -> Optional[DetectResult]:
+        if (
+            _exists(path, "wp-content")
+            and _exists(path, "index.php")
+            and _exists(path, "wp-load.php")
+        ):
+            return DetectResult(cls.name(), 80)
+
+        wp_config = cls.load_config(path, config)
+        if wp_config.wp_version:
+            return DetectResult(cls.name(), 80)
+        if cls.detect_extension(path):
+            return DetectResult(cls.name(), 75)
+        return None
+
+    @classmethod
+    def detect_extension(cls, path: Path) -> Optional[WordPressExtension]:
+        theme = cls._detect_theme(path)
+        if theme:
+            return theme
+        return cls._detect_plugin(path)
+
+    @classmethod
+    def _detect_plugin(cls, path: Path) -> Optional[WordPressExtension]:
+        plugin_files = sorted(path.glob("*.php"))
+        for plugin_file in plugin_files:
+            if not cls._file_has_header(plugin_file, cls.PLUGIN_HEADER_RE):
+                continue
+            slug = cls._slugify(path.name)
+            return WordPressExtension(
+                kind="plugin",
+                slug=slug,
+                activate_target=f"{slug}/{plugin_file.name}",
+                source_file=plugin_file.name,
+            )
+        return None
+
+    @classmethod
+    def _detect_theme(cls, path: Path) -> Optional[WordPressExtension]:
+        style_css = path / "style.css"
+        if not cls._file_has_header(style_css, cls.THEME_HEADER_RE):
+            return None
+        if not (
+            (path / "index.php").is_file()
+            or (path / "templates" / "index.html").is_file()
+            or (path / "theme.json").is_file()
+        ):
+            return None
+        slug = cls._slugify(path.name)
+        return WordPressExtension(
+            kind="theme",
+            slug=slug,
+            activate_target=slug,
+            source_file="style.css",
+        )
+
+    @classmethod
+    def _file_has_header(cls, path: Path, pattern: re.Pattern[str]) -> bool:
+        if not path.is_file():
+            return False
+        try:
+            contents = path.read_text(errors="ignore")[: cls.HEADER_SCAN_BYTES]
+        except OSError:
+            return False
+        return bool(pattern.search(contents))
+
+    @staticmethod
+    def _slugify(value: str) -> str:
+        slug = re.sub(r"[^a-z0-9_-]+", "-", value.lower()).strip("-_")
+        return slug or "wordpress-extension"
+
+    @cached_property
+    def extension(self) -> Optional[WordPressExtension]:
+        return self.detect_extension(self.path)
+
+    def dependencies(self) -> list[DependencySpec]:
+        return [
+            *super().dependencies(),
+            DependencySpec("bash", use_in_build=False, use_in_serve=True),
+        ]
+
+    def declarations(self) -> Optional[str]:
+        return (super().declarations() or "") + (
+            "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 _wordpress_base_build_steps(self) -> list[str]:
+        steps = [
+            'copy(wp_cli_download_url, "{}/wp-cli.phar".format(assets.path))',
+            'copy("wordpress/install.sh", "{}/setup-wp.sh".format(assets.path), base="assets")',
+        ]
+        if self.config.wp_version:
+            version_args = [f"--version={self.config.wp_version}"]
+            if self.config.wp_locale:
+                version_args.append(f"--locale={self.config.wp_locale}")
+            version_flags = " ".join(version_args)
+            steps.append(
+                'run("php -d memory_limit=512M {}/wp-cli.phar core '
+                "download --allow-root --path={} "
+                f'{version_flags}".format(assets.path, app.path))'
+            )
+        if self.config.phpix:
+            # We create the start script that creates the .htaccess symlink
+            # since phpix now supports .htaccess files.
+            steps.append(
+                'copy("wordpress/start.php", "{}/start-wp.php".format(assets.path), base="assets")'
+            )
+        if self.extension or not _exists(self.path, "wp-config.php"):
+            steps.append(
+                'copy("wordpress/wp-config.php", "{}/wp-config.php".format(app.path), base="assets")'
+            )
+        if self.extension or not _exists(self.path, ".htaccess"):
+            steps.append(
+                'copy("wordpress/.htaccess", "{}/.htaccess".format(app.path), base="assets")'
+            )
+        return steps
+
+    def _wp_content_seed_steps(self) -> list[str]:
+        steps = []
+        if self.config.wp_version:
+            steps.append(
+                'run("cp -R {}/wp-content/* {}".format(app.path, wpcontent_base.path))'
+            )
+        if _exists(self.path, "wp-content"):
+            steps.append('copy("wp-content", "{}".format(wpcontent_base.path))')
+        return steps
+
+    def _php_asset_steps(self) -> list[str]:
+        steps = [
+            'workdir(app.path)',
+        ]
+        if _exists(self.path, "php.ini"):
+            steps.append('copy("php.ini", "{}/php.ini".format(assets.path))')
+        else:
+            steps.append(
+                'copy("php/php.ini", "{}/php.ini".format(assets.path), base="assets")'
+            )
+        return steps
+
+    def _extension_build_steps(self, extension: WordPressExtension) -> list[str]:
+        target = (
+            f'"{{}}/{extension.content_dir}/{extension.slug}".format('
+            "wpcontent_base.path)"
+        )
+        ignore = [".git", ".source"]
+        if self.config.use_composer:
+            ignore.append("vendor")
+
+        steps = [
+            *self._wordpress_base_build_steps(),
+            *self._php_asset_steps(),
+            *self._wp_content_seed_steps(),
+            f'copy(".", {target}, ignore={json.dumps(ignore)})',
+        ]
+
+        if self.config.use_composer:
+            steps.extend(
+                [
+                    f"workdir({target})",
+                    (
+                        'env(COMPOSER_HOME="/tmp", COMPOSER_FUND="0", '
+                        'COMPOSER_ALLOW_SUPERUSER="1")'
+                    ),
+                    (
+                        'run("composer install --optimize-autoloader '
+                        '--ignore-platform-reqs --no-scripts '
+                        '--no-interaction", group="install")'
+                    ),
+                ]
+            )
+            if self.config.composer_build_script:
+                steps.append(
+                    f'run("composer run-script {self.config.composer_build_script}", '
+                    'outputs=["."], group="build")'
+                )
+
+        return steps
+
+    def build_steps(self) -> list[str]:
+        if self.extension:
+            return self._extension_build_steps(self.extension)
+
+        return (
+            self._wordpress_base_build_steps()
+            + super().build_steps_with_options(
+                extra_ignore=["wp-content"],
+                after_install=None,
+                after_build=None,
+            )
+            + self._wp_content_seed_steps()
+        )
+
+    def prepare_steps(self) -> Optional[list[str]]:
+        return super().prepare_steps()
+
+    def commands(self) -> Dict[str, str]:
+        commands = super().commands()
+        if self.config.phpix:
+            if "start" in commands:
+                commands["start"] = (
+                    '"phpix --startup-script={}/start-wp.php -S localhost:{} '
+                    '-t {}".format(assets.serve_path, PORT, app.serve_path)'
+                )
+        return {
+            "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,
+        }
+
+    def mounts(self) -> list[MountSpec]:
+        return super().mounts() + [MountSpec("wpcontent_base")]
+
+    def volumes(self) -> list[VolumeSpec]:
+        return [
+            VolumeSpec(
+                name="wp-content",
+                serve_path='"{}/wp-content/".format(app.serve_path)',
+                var_name="wp_content",
+            )
+        ]
+
+    def env(self) -> Optional[Dict[str, str]]:
+        env = {
+            "PAGER": '"cat"',
+            "WPCONTENT_BASE_PATH": '"{}".format(wpcontent_base.serve_path)',
+            **(super().env() or {}),
+        }
+        if self.config.wp_locale:
+            env["WP_LOCALE"] = f'"{self.config.wp_locale}"'
+        if self.extension and self.extension.kind == "plugin":
+            env["WP_PLUGINS_ACTIVATE"] = f'"{self.extension.activate_target}"'
+        if self.extension and self.extension.kind == "theme":
+            env["WP_DEFAULT_THEME"] = f'"{self.extension.activate_target}"'
+        return env
+
+    def services(self) -> list[ServiceSpec]:
+        return [ServiceSpec(name="database", provider="mysql")]

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/src/shipit/runners/wasmer.py

@@ -149,28 +149,28 @@ class WasmerRunner:
         },
         "phpix": {
             "dependencies": {
-                "latest": "phpix/phpix-83-32bit@=0.2.0-rc.1",
-                "8.3": "phpix/phpix-83-32bit@=0.2.0-rc.1",
-                "8.3.29": "phpix/phpix-83-32bit@=0.2.0-rc.1",
-                "8.2": "phpix/phpix-82-32bit@=0.2.0-rc.1",
-                "8.1": "phpix/phpix-81-32bit@=0.2.0-rc.1",
+                "latest": "phpix/phpix-83-32bit@=0.2.0-rc.2",
+                "8.3": "phpix/phpix-83-32bit@=0.2.0-rc.2",
+                "8.3.29": "phpix/phpix-83-32bit@=0.2.0-rc.2",
+                "8.2": "phpix/phpix-82-32bit@=0.2.0-rc.2",
+                "8.1": "phpix/phpix-81-32bit@=0.2.0-rc.2",
                 "7.4": "php/php-32@=7.4.3301", # Note, we don't have PHPix + PHP 7.4 yet
             },
             "architecture_dependencies": {
                 "64-bit": {
-                    "latest": "phpix/phpix-83-64bit@=0.2.0-rc.1",
-                    "8.3": "phpix/phpix-83-64bit@=0.2.0-rc.1",
-                    "8.3.29": "phpix/phpix-83-64bit@=0.2.0-rc.1",
-                    "8.2": "phpix/phpix-82-64bit@=0.2.0-rc.1",
-                    "8.1": "phpix/phpix-81-64bit@=0.2.0-rc.1",
+                    "latest": "phpix/phpix-83-64bit@=0.2.0-rc.2",
+                    "8.3": "phpix/phpix-83-64bit@=0.2.0-rc.2",
+                    "8.3.29": "phpix/phpix-83-64bit@=0.2.0-rc.2",
+                    "8.2": "phpix/phpix-82-64bit@=0.2.0-rc.2",
+                    "8.1": "phpix/phpix-81-64bit@=0.2.0-rc.2",
                     "7.4": "php/php-64@=7.4.3301",
                 },
                 "32-bit": {
-                    "latest": "phpix/phpix-83-32bit@=0.2.0-rc.1",
-                    "8.3": "phpix/phpix-83-32bit@=0.2.0-rc.1",
-                    "8.3.29": "phpix/phpix-83-32bit@=0.2.0-rc.1",
-                    "8.2": "phpix/phpix-82-32bit@=0.2.0-rc.1",
-                    "8.1": "phpix/phpix-81-32bit@=0.2.0-rc.1",
+                    "latest": "phpix/phpix-83-32bit@=0.2.0-rc.2",
+                    "8.3": "phpix/phpix-83-32bit@=0.2.0-rc.2",
+                    "8.3.29": "phpix/phpix-83-32bit@=0.2.0-rc.2",
+                    "8.2": "phpix/phpix-82-32bit@=0.2.0-rc.2",
+                    "8.1": "phpix/phpix-81-32bit@=0.2.0-rc.2",
                     "7.4": "php/php-32@=7.4.3301",
                 },
             },

shipit_cli-0.19.9/src/shipit/version.py

@@ -0,0 +1,5 @@
+__all__ = ["version", "version_info"]
+
+
+version = "0.19.9"
+version_info = (0, 19, 9, "final", 0)

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/tests/test_e2e.py

@@ -168,6 +168,41 @@ class E2ECase:
             ],
             build_modes=(BuildMode.Wasmer,),
         ),
+        # Full WordPress release archive, built and run through Wasmer only.
+        E2ECase(
+            path="examples/php-wordpress-empty",
+            serve_pattern=(
+                r"listening addr"
+            ),
+            http=[
+                HTTPRequest(
+                    path="/",
+                    expected_status=200,
+                    body_match=r"WordPress",
+                )
+            ],
+            use_random_port=False,
+            env={
+                "DB_NAME": "test",
+                "DB_USERNAME": "root",
+                "DB_HOST": "127.0.0.1",
+                "DB_PORT": "3306",
+                "DB_PASSWORD": "",
+                "SHIPIT_PHPIX": "true",
+                "SHIPIT_WP_VERSION": "latest",
+                # "SHIPIT_WP_LOCALE": "en_US",
+            },
+            create_db=True,
+            create_wp_content_volume=True,
+            run_after_deploy=True,
+            commands=[
+                RunCommand(
+                    "wp eval 'echo json_encode([\"status\" => \"ok\"]);'",
+                    stdout_match=r'\{"status":"ok"\}',
+                )
+            ],
+            build_modes=(BuildMode.Wasmer,),
+        ),
         # WordPress skeleton in phpix mode (Wasmer only), validate memory cap.
         E2ECase(
             path="examples/php-wordpress",

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/tests/test_generate_shipit_examples.py

@@ -18,12 +18,19 @@ _EXAMPLE_DIRS = _example_dirs_with_shipit()
 @pytest.mark.parametrize(
     "example_dir", _EXAMPLE_DIRS, ids=[p.name for p in _EXAMPLE_DIRS]
 )
-def test_generate_shipit_matches_example(example_dir: Path) -> None:
+def test_generate_shipit_matches_example(
+    example_dir: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     """Ensure generated Shipit content matches the checked-in file.
 
     This validates provider detection and the Shipit generator formatting for
     each example that includes a `Shipit` file.
     """
+    if example_dir.name == "php-wordpress-empty":
+        monkeypatch.setenv("SHIPIT_WP_VERSION", "latest")
+        monkeypatch.setenv("SHIPIT_PHPIX", "true")
+
     base_config = Config()
     base_config.commands.enrich_from_path(example_dir)
 

{shipit_cli-0.19.7 → shipit_cli-0.19.9}/tests/test_wordpress_phpix.py

@@ -2,14 +2,45 @@ from pathlib import Path
 
 import yaml
 
-from shipit.generator import generate_shipit, load_provider_config
+from shipit.generator import generate_shipit, load_provider, load_provider_config
 from shipit.providers.base import Config
-from shipit.providers.wordpress import WordPressProvider
+from shipit.providers.wordpress import WordPressConfig, WordPressProvider
 from shipit.runners.wasmer import WasmerRunner
 from shipit.shipit_types import Mount, Package, Serve, Service
 from shipit.version import version as shipit_version
 
 
+def _write_plugin(project_dir: Path, filename: str = "my-plugin.php") -> None:
+    project_dir.mkdir()
+    (project_dir / filename).write_text(
+        """<?php
+/**
+ * Plugin Name: My Plugin
+ */
+"""
+    )
+
+
+def _write_theme(project_dir: Path) -> None:
+    project_dir.mkdir()
+    (project_dir / "style.css").write_text(
+        """/*
+Theme Name: My Theme
+*/
+"""
+    )
+    (project_dir / "index.php").write_text("<?php\n")
+
+
+def _generate_for_path(project_dir: Path) -> tuple[type, WordPressConfig, str]:
+    base_config = Config()
+    base_config.commands.enrich_from_path(project_dir)
+    provider_cls = load_provider(project_dir, base_config)
+    provider_config = load_provider_config(provider_cls, project_dir, base_config)
+    provider = provider_cls(project_dir, provider_config)
+    return provider_cls, provider_config, generate_shipit(project_dir, provider)
+
+
 class DummyBuildBackend:
     def __init__(self, root: Path) -> None:
         self.root = root
@@ -29,6 +60,57 @@ class DummyBuildBackend:
         return None
 
 
+def test_wordpress_provider_detects_plugin_and_generates_activation(
+    tmp_path: Path,
+) -> None:
+    project_dir = tmp_path / "my-plugin"
+    _write_plugin(project_dir)
+
+    provider_cls, provider_config, generated = _generate_for_path(project_dir)
+
+    assert provider_cls is WordPressProvider
+    assert provider_config.wp_version == "latest"
+    assert "--version=latest" in generated
+    assert (
+        'copy(".", "{}/plugins/my-plugin".format(wpcontent_base.path), '
+        'ignore=[".git", ".source"])'
+    ) in generated
+    assert '"WP_PLUGINS_ACTIVATE": "my-plugin/my-plugin.php"' in generated
+
+
+def test_wordpress_provider_detects_theme_and_generates_activation(
+    tmp_path: Path,
+) -> None:
+    project_dir = tmp_path / "my-theme"
+    _write_theme(project_dir)
+
+    provider_cls, provider_config, generated = _generate_for_path(project_dir)
+
+    assert provider_cls is WordPressProvider
+    assert provider_config.wp_version == "latest"
+    assert "--version=latest" in generated
+    assert (
+        'copy(".", "{}/themes/my-theme".format(wpcontent_base.path), '
+        'ignore=[".git", ".source"])'
+    ) in generated
+    assert '"WP_DEFAULT_THEME": "my-theme"' in generated
+
+
+def test_wordpress_extension_keeps_user_wp_version(tmp_path: Path) -> None:
+    project_dir = tmp_path / "my-plugin"
+    _write_plugin(project_dir)
+
+    base_config = Config()
+    provider_config = load_provider_config(
+        WordPressProvider,
+        project_dir,
+        base_config,
+        {"wp_version": "6.8.3"},
+    )
+
+    assert provider_config.wp_version == "6.8.3"
+
+
 def test_generate_shipit_wordpress_phpix_mode() -> None:
     repo_root = Path(__file__).resolve().parents[1]
     example_dir = repo_root / "examples" / "php-wordpress"

shipit_cli-0.19.7/src/shipit/providers/wordpress.py

@@ -1,122 +0,0 @@
-from pathlib import Path
-from typing import Dict, Optional
-
-from .base import (
-    DetectResult,
-    DependencySpec,
-    Provider,
-    _exists,
-    MountSpec,
-    ServiceSpec,
-    VolumeSpec,
-    Config,
-)
-from .php import PhpConfig, PhpProvider
-from pydantic_settings import SettingsConfigDict
-
-
-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, config: Config
-    ) -> Optional[DetectResult]:
-        if (
-            _exists(path, "wp-content")
-            and _exists(path, "index.php")
-            and _exists(path, "wp-load.php")
-        ):
-            return DetectResult(cls.name(), 80)
-        return None
-
-    def dependencies(self) -> list[DependencySpec]:
-        return [
-            *super().dependencies(),
-            DependencySpec("bash", use_in_build=False, use_in_serve=True),
-        ]
-
-    def declarations(self) -> Optional[str]:
-        return (super().declarations() or "") + (
-            "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.path))',
-            'copy("wordpress/install.sh", "{}/setup-wp.sh".format(assets.path), base="assets")',
-        ]
-        if self.config.phpix:
-            # We create the start script that creates the .htaccess symlink
-            # since phpix now supports .htaccess files.
-            steps.append(
-                'copy("wordpress/start.php", "{}/start-wp.php".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.path), base="assets")'
-            )
-        if not _exists(self.path, ".htaccess"):
-            steps.append(
-                'copy("wordpress/.htaccess", "{}/.htaccess".format(app.path), base="assets")'
-            )
-        return steps + super().build_steps_with_options(
-            extra_ignore=["wp-content"],
-            after_install=None,
-            after_build=None
-        ) + ['copy("wp-content", "{}".format(wpcontent_base.path))']
-
-    def prepare_steps(self) -> Optional[list[str]]:
-        return super().prepare_steps()
-
-    def commands(self) -> Dict[str, str]:
-        commands = super().commands()
-        if self.config.phpix:
-            if "start" in commands:
-                commands["start"] = (
-                    '"phpix --startup-script={}/start-wp.php -S localhost:{} '
-                    '-t {}".format(assets.serve_path, PORT, app.serve_path)'
-                )
-        return {
-            "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,
-        }
-
-    def mounts(self) -> list[MountSpec]:
-        return super().mounts() + [MountSpec("wpcontent_base")]
-
-    def volumes(self) -> list[VolumeSpec]:
-        return [
-            VolumeSpec(
-                name="wp-content",
-                serve_path='"{}/wp-content/".format(app.serve_path)',
-                var_name="wp_content",
-            )
-        ]
-
-    def env(self) -> Optional[Dict[str, str]]:
-        return {
-            "PAGER": '"cat"',
-            "WPCONTENT_BASE_PATH": '"{}".format(wpcontent_base.serve_path)',
-            **(super().env() or {}),
-        }
-
-    def services(self) -> list[ServiceSpec]:
-        return [ServiceSpec(name="database", provider="mysql")]

shipit_cli-0.19.7/src/shipit/version.py

@@ -1,5 +0,0 @@
-__all__ = ["version", "version_info"]
-
-
-version = "0.19.7"
-version_info = (0, 19, 7, "final", 0)