shipit-cli 0.19.6.dev1__tar.gz → 0.19.7__tar.gz

{shipit_cli-0.19.6.dev1 → shipit_cli-0.19.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.19.6.dev1
+Version: 0.19.7
 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.6.dev1 → shipit_cli-0.19.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.19.6.dev1"
+version = "0.19.7"
 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.6.dev1 → shipit_cli-0.19.7}/src/shipit/assets/wordpress/install.sh

@@ -11,10 +11,6 @@ WP_LOCALE=${WP_LOCALE:-"en_US"}
 WP_SITEURL=${WP_SITEURL:-"http://localhost"}
 WP_SITE_TITLE=${WP_SITE_TITLE:-"WordPress"}
 
-wp() {
-  php /opt/assets/wp-cli.phar --allow-root --path=/app "$@"
-}
-
 if wp core is-installed; then
   echo "🚀 Setting up WordPress from an existing installation"
   if [ "${WP_UPDATE_DB:-true}" = "true" ]; then
@@ -30,17 +26,17 @@ else
   echo "📁 Initializing wp-content..."
 
   mkdir -p wp-content/plugins
-  # mkdir -p wp-content/themes
+  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
+  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"
 
@@ -52,8 +48,8 @@ else
     --admin_email="$WP_ADMIN_EMAIL" \
     --locale="$WP_LOCALE"
 
-  # echo "🔄 Setting permalinks"
-  # wp rewrite structure '/%year%/%monthnum%/%day%/%postname%/'
+  echo "🔄 Setting permalinks"
+  wp rewrite structure '/%year%/%monthnum%/%day%/%postname%/'
 fi
 
 # Install plugins from WP_PLUGINS environment variable

{shipit_cli-0.19.6.dev1 → shipit_cli-0.19.7}/src/shipit/providers/node_static.py

@@ -1,24 +1,26 @@
-from shipit.providers.base import _exists
 import json
-import yaml
-from pathlib import Path
-from typing import Dict, Optional, Any, Set, List
+import re
+import shlex
 from enum import Enum
-from semantic_version import Version, NpmSpec
-from pydantic import Field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
 
+import yaml
+from pydantic import Field
+from pydantic_settings import SettingsConfigDict
+from semantic_version import NpmSpec, Version
 
 from .base import (
+    Config,
     DetectResult,
     DependencySpec,
-    Provider,
     MountSpec,
+    Provider,
     ServiceSpec,
     VolumeSpec,
-    Config,
+    _exists,
 )
 from .staticfile import StaticFileProvider, StaticFileConfig
-from pydantic_settings import SettingsConfigDict
 
 
 class PackageManager(Enum):
@@ -106,6 +108,13 @@ class StaticGenerator(Enum):
     VITE = "vite"
     NEXT = "next"
     GATSBY = "gatsby"
+    ELEVENTY = "eleventy"
+    VITEPRESS = "vitepress"
+    VUEPRESS = "vuepress"
+    HEXO = "hexo"
+    METALSMITH = "metalsmith"
+    ASSEMBLE = "assemble"
+    HARP = "harp"
     DOCUSAURUS_OLD = "docusaurus-old"
     DOCUSAURUS = "docusaurus"
     SVELTE = "svelte"
@@ -119,6 +128,8 @@ class StaticGenerator(Enum):
     def get_output_dir(self) -> str:
         if self == StaticGenerator.NEXT:
             return "out"
+        elif self == StaticGenerator.ELEVENTY:
+            return "_site"
         elif self == StaticGenerator.NUXT_V3:
             return ".output/public"
         elif self in [
@@ -129,6 +140,12 @@ class StaticGenerator(Enum):
             return "dist"
         elif self == StaticGenerator.GATSBY:
             return "public"
+        elif self == StaticGenerator.HEXO:
+            return "public"
+        elif self == StaticGenerator.VITEPRESS:
+            return "docs/.vitepress/dist"
+        elif self == StaticGenerator.VUEPRESS:
+            return "docs/.vuepress/dist"
         elif self in [
             StaticGenerator.REMIX_OLD,
             StaticGenerator.REMIX,
@@ -137,38 +154,68 @@ class StaticGenerator(Enum):
             return "build/client"
         elif self == StaticGenerator.REMIX_V2_CLASSIC:
             return "public"
+        elif self == StaticGenerator.ASSEMBLE:
+            return "dist"
+        elif self == StaticGenerator.HARP:
+            return "www"
         elif self in [
             StaticGenerator.DOCUSAURUS,
             StaticGenerator.DOCUSAURUS_OLD,
             StaticGenerator.SVELTE,
+            StaticGenerator.METALSMITH,
         ]:
             return "build"
         else:
             return "dist"
 
     @classmethod
-    def detect_generators_from_command(cls, build_command) -> List["StaticGenerator"]:
+    def detect_generators_from_command(
+        cls, build_command
+    ) -> List["StaticGenerator"]:
         commands = {
             "gatsby": [StaticGenerator.GATSBY],
             "astro": [StaticGenerator.ASTRO],
+            "@11ty/eleventy": [StaticGenerator.ELEVENTY],
+            "eleventy": [StaticGenerator.ELEVENTY],
             "remix-ssg": [StaticGenerator.REMIX_OLD],
             "remix": [StaticGenerator.REMIX_V2_CLASSIC, StaticGenerator.REMIX_V2],
             "vite": [StaticGenerator.VITE],
-            "docusaurus": [StaticGenerator.DOCUSAURUS, StaticGenerator.DOCUSAURUS_OLD],
+            "vitepress": [StaticGenerator.VITEPRESS],
+            "vuepress": [StaticGenerator.VUEPRESS],
+            "hexo": [StaticGenerator.HEXO],
+            "metalsmith": [StaticGenerator.METALSMITH],
+            "harp": [StaticGenerator.HARP],
+            "docusaurus": [
+                StaticGenerator.DOCUSAURUS,
+                StaticGenerator.DOCUSAURUS_OLD,
+            ],
             "next": [StaticGenerator.NEXT],
             "nuxi": [StaticGenerator.NUXT_V3],
             "nuxt": [StaticGenerator.NUXT_OLD],
             "svelte-kit": [StaticGenerator.SVELTE],
         }
-        build_command = build_command.split(" ")[0]
-        if build_command in commands:
-            return commands[build_command]
-        else:
-            return []
-    
+        try:
+            tokens = shlex.split(build_command)
+        except ValueError:
+            tokens = build_command.split()
+
+        for index, token in enumerate(tokens):
+            if token == "grunt" and "assemble" in tokens[index + 1 :]:
+                return [StaticGenerator.ASSEMBLE]
+            if token in commands:
+                return commands[token]
+        return []
+
     def build_command(self) -> str:
         return {
             StaticGenerator.GATSBY: "gatsby build",
+            StaticGenerator.ELEVENTY: "@11ty/eleventy",
+            StaticGenerator.VITEPRESS: "vitepress build docs",
+            StaticGenerator.VUEPRESS: "vuepress build docs",
+            StaticGenerator.HEXO: "hexo generate",
+            StaticGenerator.METALSMITH: "metalsmith build",
+            StaticGenerator.ASSEMBLE: "grunt assemble",
+            StaticGenerator.HARP: "harp compile . www",
             StaticGenerator.ASTRO: "astro build",
             StaticGenerator.REMIX_OLD: "remix-ssg build",
             StaticGenerator.REMIX_V2: "vite build",
@@ -200,6 +247,7 @@ class NodeStaticConfig(StaticFileConfig):
 
 class NodeStaticProvider(StaticFileProvider):
     only_build: bool = False
+    _ASSEMBLE_DEST_PATTERN = re.compile(r"\bdest\s*:\s*['\"]([^'\"]+)['\"]")
 
     def __init__(
         self, path: Path, config: NodeStaticConfig, only_build: bool = False
@@ -227,7 +275,25 @@ class NodeStaticProvider(StaticFileProvider):
         package_json = cls.parse_package_json(path)
 
         if not config.static_generator:
-            if cls.has_dependency(package_json, "gatsby"):
+            if cls.has_dependency(package_json, "@11ty/eleventy"):
+                config.static_generator = StaticGenerator.ELEVENTY
+            elif cls.has_dependency(package_json, "vitepress"):
+                config.static_generator = StaticGenerator.VITEPRESS
+            elif cls.has_dependency(package_json, "vuepress"):
+                config.static_generator = StaticGenerator.VUEPRESS
+            elif cls.has_dependency(package_json, "hexo") or cls.has_dependency(
+                package_json, "hexo-cli"
+            ):
+                config.static_generator = StaticGenerator.HEXO
+            elif cls.has_dependency(package_json, "metalsmith"):
+                config.static_generator = StaticGenerator.METALSMITH
+            elif cls.has_dependency(package_json, "assemble") or cls.has_dependency(
+                package_json, "grunt-assemble"
+            ):
+                config.static_generator = StaticGenerator.ASSEMBLE
+            elif cls.has_dependency(package_json, "harp"):
+                config.static_generator = StaticGenerator.HARP
+            elif cls.has_dependency(package_json, "gatsby"):
                 config.static_generator = StaticGenerator.GATSBY
             elif cls.has_dependency(package_json, "astro"):
                 config.static_generator = StaticGenerator.ASTRO
@@ -242,7 +308,17 @@ class NodeStaticProvider(StaticFileProvider):
             ) or cls.has_dependency(package_json, "@remix-run/dev", "0"):
                 config.static_generator = StaticGenerator.REMIX_OLD
             elif cls.has_dependency(package_json, "@remix-run/dev"):
-                has_vite = cls.has_dependency(package_json, "@remix-run/vite") or cls.has_dependency(package_json, "vite") or _exists(path, "vite.config.js", "vite.config.ts", "vite.config.mjs", "vite.config.cjs")
+                has_vite = (
+                    cls.has_dependency(package_json, "@remix-run/vite")
+                    or cls.has_dependency(package_json, "vite")
+                    or _exists(
+                        path,
+                        "vite.config.js",
+                        "vite.config.ts",
+                        "vite.config.mjs",
+                        "vite.config.cjs",
+                    )
+                )
                 if has_vite:
                     config.static_generator = StaticGenerator.REMIX_V2
                 else:
@@ -264,7 +340,12 @@ class NodeStaticProvider(StaticFileProvider):
             )
 
         if not config.static_dir:
-            config.static_dir = config.static_generator.get_output_dir()
+            if config.static_generator:
+                config.static_dir = cls.get_static_dir(
+                    path, package_json, config.static_generator
+                )
+            else:
+                config.static_dir = "dist"
 
         return config
 
@@ -282,6 +363,168 @@ class NodeStaticProvider(StaticFileProvider):
         except Exception:
             return None
 
+    @classmethod
+    def get_static_dir(
+        cls,
+        path: Path,
+        package_json: Optional[Dict[str, Any]],
+        static_generator: StaticGenerator,
+    ) -> str:
+        if static_generator == StaticGenerator.VITEPRESS:
+            root = cls._script_build_root(package_json, "vitepress")
+            root = root or cls._default_docs_root(path, ".vitepress")
+            return cls._rooted_output_dir(root, ".vitepress/dist")
+
+        if static_generator == StaticGenerator.VUEPRESS:
+            root = cls._script_build_root(package_json, "vuepress")
+            root = root or cls._default_docs_root(path, ".vuepress")
+            return cls._rooted_output_dir(root, ".vuepress/dist")
+
+        if static_generator == StaticGenerator.METALSMITH:
+            return cls._metalsmith_output_dir(path) or static_generator.get_output_dir()
+
+        if static_generator == StaticGenerator.ASSEMBLE:
+            return cls._assemble_output_dir(path) or static_generator.get_output_dir()
+
+        if static_generator == StaticGenerator.HARP:
+            return (
+                cls._harp_output_dir(package_json)
+                or static_generator.get_output_dir()
+            )
+
+        return static_generator.get_output_dir()
+
+    @classmethod
+    def _script_commands(
+        cls, package_json: Optional[Dict[str, Any]]
+    ) -> list[str]:
+        if not package_json:
+            return []
+        scripts = package_json.get("scripts", {})
+        if not isinstance(scripts, dict):
+            return []
+
+        preferred = ("generate", "build", "docs:build")
+        commands = [
+            scripts[name]
+            for name in preferred
+            if isinstance(scripts.get(name), str)
+        ]
+        commands.extend(
+            command
+            for name, command in scripts.items()
+            if name not in preferred and isinstance(command, str)
+        )
+        return commands
+
+    @classmethod
+    def _args_after_command(cls, command: str, executable: str) -> list[str]:
+        try:
+            tokens = shlex.split(command)
+        except ValueError:
+            tokens = command.split()
+
+        for index, token in enumerate(tokens):
+            if token == executable:
+                return tokens[index + 1 :]
+        return []
+
+    @classmethod
+    def _script_build_root(
+        cls, package_json: Optional[Dict[str, Any]], executable: str
+    ) -> Optional[str]:
+        for command in cls._script_commands(package_json):
+            args = cls._args_after_command(command, executable)
+            if not args or args[0] != "build":
+                continue
+            for arg in args[1:]:
+                if not arg.startswith("-"):
+                    return cls._clean_output_dir(arg)
+        return None
+
+    @classmethod
+    def _default_docs_root(cls, path: Path, config_dir: str) -> str:
+        docs_path = path / "docs"
+        if (docs_path / config_dir).exists() or docs_path.exists():
+            return "docs"
+        return "."
+
+    @classmethod
+    def _rooted_output_dir(cls, root: str, output_dir: str) -> str:
+        root = cls._clean_output_dir(root)
+        if root == ".":
+            return output_dir
+        return f"{root}/{output_dir}"
+
+    @classmethod
+    def _clean_output_dir(cls, output_dir: str) -> str:
+        output_dir = output_dir.strip().rstrip("/")
+        if output_dir.startswith("./"):
+            output_dir = output_dir[2:]
+        return output_dir or "."
+
+    @classmethod
+    def _metalsmith_output_dir(cls, path: Path) -> Optional[str]:
+        for config_name in ("metalsmith.json", ".metalsmith.json"):
+            config_path = path / config_name
+            if not config_path.is_file():
+                continue
+            try:
+                config = json.loads(config_path.read_text())
+            except Exception:
+                continue
+            if not isinstance(config, dict):
+                continue
+            for key in ("destination", "dest"):
+                output_dir = config.get(key)
+                if isinstance(output_dir, str) and output_dir:
+                    return cls._clean_output_dir(output_dir)
+        return None
+
+    @classmethod
+    def _assemble_output_dir(cls, path: Path) -> Optional[str]:
+        for config_name in ("Gruntfile.js", "Gruntfile.cjs"):
+            config_path = path / config_name
+            if not config_path.is_file():
+                continue
+            match = cls._ASSEMBLE_DEST_PATTERN.search(config_path.read_text())
+            if match:
+                return cls._clean_output_dir(match.group(1))
+        return None
+
+    @classmethod
+    def _harp_output_dir(
+        cls, package_json: Optional[Dict[str, Any]]
+    ) -> Optional[str]:
+        for command in cls._script_commands(package_json):
+            args = cls._args_after_command(command, "harp")
+            if not args:
+                continue
+            if args[0] == "compile":
+                args = args[1:]
+            positional_args = []
+            for index, arg in enumerate(args):
+                if arg in ("--output", "-o") and index + 1 < len(args):
+                    return cls._clean_output_dir(args[index + 1])
+                if not arg.startswith("-"):
+                    positional_args.append(arg)
+            if len(positional_args) >= 2:
+                return cls._clean_output_dir(positional_args[1])
+        return None
+
+    @classmethod
+    def _is_package_manager_build_command(cls, command: str) -> bool:
+        package_manager_prefixes = (
+            "npm run ",
+            "pnpm run ",
+            "pnpm ",
+            "yarn run ",
+            "yarn ",
+            "bun run ",
+            "bun ",
+        )
+        return command.startswith(package_manager_prefixes)
+
     @classmethod
     def has_dependency(
         cls,
@@ -314,26 +557,65 @@ class NodeStaticProvider(StaticFileProvider):
     ) -> Optional[DetectResult]:
         if config.commands.install:
             # Detect this provider from the install command
-            if config.commands.install in ["npm install", "npm ci", "npm i", "pnpm install", "pnpm ci", "pnpm i", "yarn install", "yarn ci", "yarn i", "bun install", "bun ci", "bun i"]:
+            install_commands = [
+                "npm install",
+                "npm ci",
+                "npm i",
+                "pnpm install",
+                "pnpm ci",
+                "pnpm i",
+                "yarn install",
+                "yarn ci",
+                "yarn i",
+                "bun install",
+                "bun ci",
+                "bun i",
+            ]
+            if config.commands.install in install_commands:
                 return DetectResult(cls.name(), 40)
 
+        has_package_manager_build_command = False
         if config.commands.build:
-            if config.commands.build.startswith("npm run "):
-                return DetectResult(cls.name(), 40)
-            elif config.commands.build.startswith("pnpm run "):
-                return DetectResult(cls.name(), 40)
-            elif config.commands.build.startswith("yarn run "):
-                return DetectResult(cls.name(), 40)
-            elif config.commands.build.startswith("bun run "):
-                return DetectResult(cls.name(), 40)
+            # Iterate over all generators and check if the build command matches
+            for static_generator in StaticGenerator:
+                if static_generator.build_command() in config.commands.build:
+                    return DetectResult(cls.name(), 60)
 
-            static_generators = StaticGenerator.detect_generators_from_command(config.commands.build)
+            static_generators = StaticGenerator.detect_generators_from_command(
+                config.commands.build
+            )
             if static_generators:
-                return DetectResult(cls.name(), 40)
+                return DetectResult(cls.name(), 60)
+
+            has_package_manager_build_command = (
+                cls._is_package_manager_build_command(config.commands.build)
+            )
 
         package_json = cls.parse_package_json(path)
         if not package_json:
+            if has_package_manager_build_command:
+                return DetectResult(cls.name(), 40)
             return None
+        for build_command in cls._script_commands(package_json):
+            for static_generator in StaticGenerator:
+                if static_generator.build_command() in build_command:
+                    return DetectResult(cls.name(), 60)
+            if StaticGenerator.detect_generators_from_command(build_command):
+                return DetectResult(cls.name(), 60)
+
+        pure_static_generators = [
+            "@11ty/eleventy",
+            "vitepress",
+            "vuepress",
+            "hexo",
+            "hexo-cli",
+            "metalsmith",
+            "assemble",
+            "grunt-assemble",
+            "harp",
+            "docusaurus",
+            "@docusaurus/core",
+        ]
         static_generators = [
             "astro",
             "vite",
@@ -341,12 +623,14 @@ class NodeStaticProvider(StaticFileProvider):
             "nuxt",
             "gatsby",
             "svelte",
-            "docusaurus",
-            "@docusaurus/core",
             "@remix-run/dev",
         ]
+        if any(cls.has_dependency(package_json, dep) for dep in pure_static_generators):
+            return DetectResult(cls.name(), 60)
         if any(cls.has_dependency(package_json, dep) for dep in static_generators):
             return DetectResult(cls.name(), 40)
+        if has_package_manager_build_command:
+            return DetectResult(cls.name(), 40)
         return None
 
     def dependencies(self) -> list[DependencySpec]:
@@ -367,16 +651,29 @@ class NodeStaticProvider(StaticFileProvider):
         cls,
         package_json: Optional[Dict[str, Any]],
         package_manager: PackageManager,
-        static_generator: StaticGenerator,
+        static_generator: Optional[StaticGenerator],
     ) -> Optional[str]:
         if package_json:
             scripts = package_json.get("scripts", {})
+            if not isinstance(scripts, dict):
+                scripts = {}
+            docs_build_command = scripts.get("docs:build")
+            if (
+                static_generator
+                in [StaticGenerator.VITEPRESS, StaticGenerator.VUEPRESS]
+                and docs_build_command
+            ):
+                return package_manager.run_command("docs:build")
             generate_command = scripts.get("generate")
             if generate_command:
                 return package_manager.run_command("generate")
             build_command = scripts.get("build")
             if build_command:
                 return package_manager.run_command("build")
+            if docs_build_command:
+                return package_manager.run_command("docs:build")
+        if not static_generator:
+            return None
         command = static_generator.build_command()
         return package_manager.run_execute_command(command)
 
@@ -393,20 +690,22 @@ class NodeStaticProvider(StaticFileProvider):
                 'env(CI="true", NODE_ENV="production", NPM_CONFIG_FUND="false")'
                 if self.config.package_manager == PackageManager.NPM
                 else None,
-                # 'run("npx corepack enable", inputs=["package.json"], group="install")',
                 f'run("{install_command}", inputs=["package.json"], group="install")',
             ],
         )
-    
+
     def build_steps_build(self) -> list[str]:
         return filter(
             None,
             [
-                f'run("{self.config.build_command}", outputs=[config.static_dir], group="build")'
-                if not self.only_build
+                (
+                    f'run("{self.config.build_command}", '
+                    'outputs=[config.static_dir], group="build")'
+                )
+                if self.config.build_command and not self.only_build
                 else None,
                 f'run("{self.config.build_command}", group="build")'
-                if self.only_build
+                if self.config.build_command and self.only_build
                 else None,
             ]
         )

{shipit_cli-0.19.6.dev1 → shipit_cli-0.19.7}/src/shipit/providers/wordpress.py

@@ -77,10 +77,10 @@ class WordPressProvider(PhpProvider):
                 'copy("wordpress/.htaccess", "{}/.htaccess".format(app.path), base="assets")'
             )
         return steps + super().build_steps_with_options(
-            extra_ignore=[],
+            extra_ignore=["wp-content"],
             after_install=None,
             after_build=None
-        ) # + ['copy("wp-content", "{}".format(wpcontent_base.path))']
+        ) + ['copy("wp-content", "{}".format(wpcontent_base.path))']
 
     def prepare_steps(self) -> Optional[list[str]]:
         return super().prepare_steps()
@@ -94,13 +94,13 @@ class WordPressProvider(PhpProvider):
                     '-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)',
+            "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")]
+        return super().mounts() + [MountSpec("wpcontent_base")]
 
     def volumes(self) -> list[VolumeSpec]:
         return [
@@ -114,7 +114,7 @@ class WordPressProvider(PhpProvider):
     def env(self) -> Optional[Dict[str, str]]:
         return {
             "PAGER": '"cat"',
-            # "WPCONTENT_BASE_PATH": '"{}".format(wpcontent_base.serve_path)',
+            "WPCONTENT_BASE_PATH": '"{}".format(wpcontent_base.serve_path)',
             **(super().env() or {}),
         }
 

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

@@ -149,29 +149,29 @@ class WasmerRunner:
         },
         "phpix": {
             "dependencies": {
-                "latest": "wasmer/phpix-32@=0.1.13803",
-                "8.3": "wasmer/phpix-32@=0.1.13803",
-                "8.3.29": "wasmer/phpix-32@=0.1.13803",
-                "8.2": "wasmer/phpix-32@=0.1.13803",
-                "8.1": "wasmer/phpix-32@=0.1.13803",
-                "7.4": "wasmer/phpix-32@=0.1.13803",
+                "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",
+                "7.4": "php/php-32@=7.4.3301", # Note, we don't have PHPix + PHP 7.4 yet
             },
             "architecture_dependencies": {
                 "64-bit": {
-                    "latest": "wasmer/phpix-64@=0.1.13803",
-                    "8.3": "wasmer/phpix-64@=0.1.13803",
-                    "8.3.29": "wasmer/phpix-64@=0.1.13803",
-                    "8.2": "wasmer/phpix-64@=0.1.13803",
-                    "8.1": "wasmer/phpix-64@=0.1.13803",
-                    "7.4": "wasmer/phpix-64@=0.1.13803",
+                    "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",
+                    "7.4": "php/php-64@=7.4.3301",
                 },
                 "32-bit": {
-                    "latest": "wasmer/phpix-32@=0.1.13803",
-                    "8.3": "wasmer/phpix-32@=0.1.13803",
-                    "8.3.29": "wasmer/phpix-32@=0.1.13803",
-                    "8.2": "wasmer/phpix-32@=0.1.13803",
-                    "8.1": "wasmer/phpix-32@=0.1.13803",
-                    "7.4": "wasmer/phpix-32@=0.1.13803",
+                    "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",
+                    "7.4": "php/php-32@=7.4.3301",
                 },
             },
             "scripts": {"php", "phpix"},
@@ -231,6 +231,8 @@ class WasmerRunner:
             )
             provider_config.cross_platform = "wasix_wasm32"
             provider_config.precompile_python = True
+        elif isinstance(provider_config, PhpConfig):
+            provider_config.phpix = True
         self.provider_config = provider_config
         return provider_config
 

shipit_cli-0.19.7/src/shipit/version.py

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

{shipit_cli-0.19.6.dev1 → shipit_cli-0.19.7}/tests/test_e2e.py

@@ -237,6 +237,55 @@ class E2ECase:
             serve_pattern=r"server is listening on",
             http=[HTTPRequest(path="/", body_match=r"Welcome to MkDocs with Plugins")],
         ),
+        # Eleventy / 11ty static site
+        E2ECase(
+            path="examples/eleventy",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Eleventy Example")],
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
+        ),
+        # VitePress static documentation site
+        E2ECase(
+            path="examples/vitepress",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"VitePress Example")],
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
+        ),
+        # VuePress static documentation site
+        E2ECase(
+            path="examples/vuepress",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"VuePress Example")],
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
+        ),
+        # Hexo static blog
+        E2ECase(
+            path="examples/hexo",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Hexo Example")],
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
+        ),
+        # Metalsmith static site
+        E2ECase(
+            path="examples/metalsmith",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Metalsmith Example")],
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
+        ),
+        # Assemble static site
+        E2ECase(
+            path="examples/assemble",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Assemble Example")],
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
+        ),
+        # Harp static site
+        E2ECase(
+            path="examples/harp",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Harp Example")],
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
+        ),
         # Python FastAPI app on Uvicorn
         E2ECase(
             path="examples/python-fastapi",

shipit_cli-0.19.6.dev1/src/shipit/version.py

@@ -1,5 +0,0 @@
-__all__ = ["version", "version_info"]
-
-
-version = "0.19.6.dev1"
-version_info = (0, 19, 6, "dev", 1)