@webship.co/workspace 1.0.0-beta1 → 1.0.0-beta2

package/core/scripts/functions/fun-build-website.sh

@@ -0,0 +1,199 @@
+#!/usr/bin/env bash
+
+# Build the Website stack (Drupal 11.4, PHP 8.4):
+#
+#   build_website_project        drupal/website, installed by the Webship installer
+#                                (`drush site:install webship`) with the chosen site template.
+#   build_website_site_template  one site-template recipe on drupal/recommended-project 11.4.x,
+#                                installed with `drush site:install <recipe directory>`.
+#
+# The calling cmd-*.sh sets distribution_* and site_version, and for a recipe build
+# site_template_name, site_template_title and site_template_package.
+
+website_php_version="8.4";
+website_core_version="11.4.x-dev";
+
+# A clean DDEV project for PROJECT_NAME in this workspace, with the codebase of
+# `$1` (a composer project template with its version) in it.
+function website_create_project() {
+  base_url="https://${PROJECT_NAME}.ddev.site";
+
+  cd ${WORKSPACE_ROOT}/${doc_name};
+  drop_database;
+  if [ -d "${PROJECT_NAME}" ]; then
+    rm -rf ${PROJECT_NAME}
+  fi
+  mkdir -p ${PROJECT_NAME} ;
+  cd ${WORKSPACE_ROOT}/${doc_name}/${PROJECT_NAME} ;
+
+  ddev config --project-type=drupal --docroot=${distribution_webroot} --php-version=${PHP_VERSION:-${website_php_version}} --nodejs-version=$(ddev_nodejs_version) --project-name=${PROJECT_NAME} --auto ;
+  ddev start -y ;
+
+  if ! ddev composer create-project "$1" . --no-interaction ; then
+    echo "composer create-project failed for $1 — aborting, nothing was installed." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  # The web* packages and the site templates only have dev releases for now.
+  ddev composer config minimum-stability dev ;
+  ddev composer config prefer-stable true ;
+
+  # Keep the site templates as recipes, like drupal/website does: unpacking them
+  # into the root composer.json fails on aliased dev branches (the pending fixes).
+  ddev composer config --json --merge extra.drupal-recipe-unpack.ignore '["drupal/website_starter", "drupal/webship_starter", "drupal/webship_portal"]' ;
+}
+
+# -----------------------------------------------------------------------------
+# @todo Remove this block (and --with-pending-fixes) once these are merged into
+#   12.0.x — the builds work without the flag from then on:
+#   - webblog MR !4:     https://git.drupalcode.org/project/webblog/-/merge_requests/4
+#   - webreleases MR !5: https://git.drupalcode.org/project/webreleases/-/merge_requests/5
+#
+# Pins the issue-fork branches with --with-pending-fixes. `composer config
+# repositories.<name>` adds a repository ahead of packages.drupal.org, so the
+# fork wins. Arguments: the pins to add — webblog, webreleases.
+function website_add_pending_fixes() {
+  if [ ! "${WITH_PENDING_FIXES}" == 'yes' ] ; then
+    return 0 ;
+  fi
+
+  local pins=() ;
+  for fix in "$@" ; do
+    case "${fix}" in
+      webship)
+        # drupal/webship has no 12.0.x-dev on packages.drupal.org yet
+        # ("Package drupal/webship not found"): take the installer from its 12.0.x branch.
+        # The repository's default branch (11.0.x) names the package webship/webship,
+        # and a vcs repository takes its package name from the default branch.
+        echo "Pending fix: webship/webship (the Webship installer) from its 12.0.x branch." ;
+        ddev composer config repositories.webship-12 vcs https://git.drupalcode.org/project/webship.git ;
+        pins+=("webship/webship:12.0.x-dev") ;
+        ;;
+      webblog)
+        echo "Pending fix: webblog from issue/webblog-3591554 (3591554-display-builder)." ;
+        ddev composer config repositories.webblog-3591554 vcs https://git.drupalcode.org/issue/webblog-3591554.git ;
+        pins+=("drupal/webblog:dev-3591554-display-builder as 12.0.x-dev") ;
+        ;;
+      webreleases)
+        echo "Pending fix: webreleases from issue/webreleases-3591672 (3591672-display-builder)." ;
+        ddev composer config repositories.webreleases-3591672 vcs https://git.drupalcode.org/issue/webreleases-3591672.git ;
+        pins+=("drupal/webreleases:dev-3591672-display-builder as 12.0.x-dev") ;
+        ;;
+    esac
+  done
+
+  if [ ${#pins[@]} -gt 0 ] ; then
+    ddev composer require --no-update "${pins[@]}" ;
+  fi
+}
+# -----------------------------------------------------------------------------
+
+# The pending fixes a site template needs: webship_starter and webship_portal
+# bring webreleases on top of the Website Starter's webblog.
+function website_pending_fixes_for() {
+  case "$1" in
+    webship_starter|webship_portal) echo "webblog webreleases" ;;
+    *) echo "webblog" ;;
+  esac
+}
+
+# Install the site, then the shared after-install steps.
+function website_after_install() {
+  drush_set_debug_on;
+  drush_cr;
+
+  if [ "${ADD_USERS}" == 'yes' ] ; then
+    add_users ;
+  fi
+
+  echo "";
+  echo "*---------------------------------------------------------------------*";
+  echo "  ${PROJECT_NAME} is ready: ${base_url}";
+  echo "*---------------------------------------------------------------------*";
+
+  cd ${WORKSPACE_ROOT}/${doc_name};
+}
+
+# drupal/website installed by the Webship installer with --template.
+function build_website_project() {
+  local template="${TEMPLATE:-website_starter}" ;
+
+  website_create_project "${distribution_project_template}:${site_version}" || return 1 ;
+
+  # The Website project requires the Webship installer and the three site
+  # templates. Add whatever the published template does not require yet.
+  local require_block missing=() ;
+  require_block=$(sed -n '/"require": {/,/}/p' composer.json) ;
+  for package in "drupal/webship:12.0.x-dev" "drupal/website_starter:1.0.x-dev" "drupal/webship_starter:1.0.x-dev" "drupal/webship_portal:1.0.x-dev" ; do
+    # The installer is drupal/webship or webship/webship; the pending fixes pin the latter.
+    if [ "${package%%:*}" == "drupal/webship" ] && { [ "${WITH_PENDING_FIXES}" == 'yes' ] || echo "${require_block}" | grep -q '"webship/webship"' ; } ; then
+      continue ;
+    fi
+    if ! echo "${require_block}" | grep -q "\"${package%%:*}\"" ; then
+      echo "${distribution_project_template} does not require ${package%%:*} yet — adding it." ;
+      missing+=("${package}") ;
+    fi
+  done
+
+  # The codebase carries all three site templates, so it needs every pending fix.
+  website_add_pending_fixes webship $(website_pending_fixes_for webship_portal) ;
+
+  # Stage everything, then one full update, so no pin is held back by the lock file.
+  local composer_ok=1 ;
+  if [ ${#missing[@]} -gt 0 ] ; then
+    ddev composer require --no-update --no-interaction "${missing[@]}" || composer_ok=0 ;
+  fi
+  if [ ${composer_ok} -eq 1 ] && { [ ${#missing[@]} -gt 0 ] || [ "${WITH_PENDING_FIXES}" == 'yes' ] ; } ; then
+    ddev composer update -W --no-interaction || composer_ok=0 ;
+  fi
+  if [ ${composer_ok} -eq 0 ] ; then
+    echo "composer failed — aborting before the install." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  set_default_settings ;
+
+  echo "Install ${distribution_title} with the Webship installer and the ${template} site template.";
+  if ! ddev drush site:install webship --yes \
+    installer_site_template_form.add_ons=${template} \
+    --site-name="${distribution_title}" \
+    --account-name="${account_name}" --account-pass="${account_pass}" --account-mail="${account_mail}" \
+    --locale="en" ; then
+    echo "" ;
+    echo "The ${template} install failed — read the error above. The codebase is kept: ${base_url}/core/install.php" ;
+    cd ${WORKSPACE_ROOT}/${doc_name} ;
+    return 1 ;
+  fi
+
+  website_after_install ;
+}
+
+# One site-template recipe on a plain Drupal 11.4.x recommended project.
+function build_website_site_template() {
+  website_create_project "drupal/recommended-project:${website_core_version}" || return 1 ;
+
+  website_add_pending_fixes $(website_pending_fixes_for ${site_template_name}) ;
+
+  if ! ddev composer require -W --no-interaction "drush/drush:^13" "${site_template_package}:${site_version}" ; then
+    echo "composer require ${site_template_package}:${site_version} failed — aborting before the install." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  set_default_settings ;
+
+  echo "Install Drupal ${website_core_version} with the ${site_template_title} recipe.";
+  if ! ddev drush site:install /var/www/html/recipes/${site_template_name} --yes \
+    --site-name="${site_template_title}" \
+    --account-name="${account_name}" --account-pass="${account_pass}" --account-mail="${account_mail}" \
+    --locale="en" ; then
+    echo "" ;
+    echo "The ${site_template_title} install failed — read the error above." ;
+    cd ${WORKSPACE_ROOT}/${doc_name} ;
+    return 1 ;
+  fi
+
+  website_after_install ;
+}

package/core/scripts/functions/fun-checks.sh

@@ -0,0 +1,243 @@
+#!/usr/bin/env bash
+
+# Run the code-quality checks a package ALREADY declares.
+#
+# Nearly every package in this workspace carries its own quality scripts — `lint:js`, `lint:css`,
+# `lint:yaml`, `spellcheck`, `phpcs`, `test:chromium` — and until now nothing ran them from one
+# place. This verb reads a package's package.json, maps the names it happens to use onto a fixed set
+# of canonical checks, and runs them. It never invents a command: every check is a script the
+# package declared for itself.
+#
+# The map, the safety rule, the package manager and the dependency test all live in ONE place —
+# core/scripts/libs/checks_plan.js — which the dashboard also requires for the caption under its
+# Checks button. This file does not re-implement any of it; it asks for a plan and executes the rows
+# the resolver marked `ready`. That is what stops the button and the command disagreeing.
+#
+# Everything runs inside DDEV. A site runs its scripts in its own web container. A PACKAGE has no
+# DDEV project of its own, so it runs in the dashboard's container, which bind-mounts the whole
+# workspace tree at the same absolute path — /home/…/workspace/products/webship_core means the same
+# directory inside it and out. There is no host node, no host composer and no raw docker exec.
+
+readonly CHECKS_PLAN_JS="${WORKSPACE_SCRIPTS}/libs/checks_plan.js";
+readonly CHECKS_STATE_DIR="${WORKSPACE_PATH}/state/checks";
+
+# Where a project's checks run, and how a command is wrapped to get there.
+#
+#   site       the project has its own .ddev/config.yaml   -> its own web container
+#   here       we are already inside a DDEV web container  -> run in place, do not nest ddev exec
+#   dashboard  a package, invoked from the host            -> the dashboard's container
+function checks_where() {
+  local project_path="$1";
+  if [ -f "${project_path}/.ddev/config.yaml" ] ; then printf 'site' ; return 0 ; fi
+  if [ -n "${IS_DDEV_PROJECT:-}" ] ; then printf 'here' ; return 0 ; fi
+  printf 'dashboard';
+}
+
+# One check, run where it belongs. Output streams through unmodified — nothing is swallowed, so the
+# dashboard toast shows what a terminal would.
+#
+# `< /dev/null` on every one of them, and it is not decoration: the caller is a `while read` loop fed
+# by a process substitution, and `ddev exec` reads stdin. Without it the first check swallows the
+# rest of the plan and the run silently stops after one row — which is exactly what it did. It is the
+# same reason every job the dashboard starts closes stdin.
+function checks_run_one() {
+  local where="$1" project_path="$2" runner="$3" script="$4";
+  case "${where}" in
+    site)
+      ( cd "${project_path}" && ddev exec "${runner} run ${script}" ) < /dev/null ;;
+    here)
+      ( cd "${project_path}" && bash -lc "${runner} run ${script}" ) < /dev/null ;;
+    dashboard)
+      ( cd "${WORKSPACE_PATH}/workspace-app" && ddev exec -d "${project_path}" "${runner} run ${script}" ) < /dev/null ;;
+  esac
+}
+
+# The add-on's own commands, which are already whole checks — used only where the project carries
+# github.com/Webship/ddev-dev-tools.
+function checks_run_addon() {
+  local project_path="$1" command="$2";
+  ( cd "${project_path}" && ${command} ) < /dev/null ;
+}
+
+# Is the container this project needs actually up? A package with a stopped dashboard container has
+# nowhere to run, and saying so beats a docker error.
+function checks_require_container() {
+  local where="$1" project_path="$2";
+  case "${where}" in
+    site)
+      if ! ( cd "${project_path}" && ddev describe -j 2>/dev/null | grep -q '"status":"running"' ) ; then
+        echo "Starting ${doc_name}/${PROJECT_NAME}…";
+        ( cd "${project_path}" && ddev start -y ) || return 1 ;
+      fi
+      ;;
+    dashboard)
+      if ! docker ps --format '{{.Names}}' 2>/dev/null | grep -q '^ddev-workspace-web$' ; then
+        echo "The workspace dashboard container is not running, and a package has no DDEV project of its own.";
+        echo "  Start it:  cd ${WORKSPACE_PATH}/workspace-app && ddev start -y";
+        return 1 ;
+      fi
+      ;;
+  esac
+  return 0 ;
+}
+
+function checks_command() {
+  local project_path="${WORKSPACE_ROOT}/${doc_name}/${PROJECT_NAME}";
+  local where runner runner_reason deps_installed deps_evidence postinstall_count has_package is_site;
+  local started status=0 ran=0 passed=0 failed=0 refused=0 skipped=0 declared=0;
+  local failed_ids="";
+
+  if [ ! -d "${project_path}" ] ; then
+    echo "No ${PROJECT_NAME} in ${WORKSPACE_ROOT}/${doc_name}.";
+    return 2 ;
+  fi
+
+  # The plan, from the one resolver. `--format=meta` answers the questions about the package as a
+  # whole; the default TSV answers them per check.
+  local plan_args="";
+  [ ! "${ONLY}" == '_none_' ] && plan_args="${plan_args} --only=${ONLY}";
+  [ ! "${SKIP}" == '_none_' ] && plan_args="${plan_args} --skip=${SKIP}";
+  [ ! "${RUNNER}" == '_none_' ] && plan_args="${plan_args} --runner=${RUNNER}";
+  [ "${E2E}" == 'yes' ] && plan_args="${plan_args} --e2e";
+  plan_args="${plan_args} --browser=${BROWSER}";
+
+  IFS=$'\t' read -r runner runner_reason deps_installed deps_evidence postinstall_count has_package is_site \
+    < <(node "${CHECKS_PLAN_JS}" "${project_path}" --format=meta ${plan_args} | head -1);
+
+  where="$(checks_where "${project_path}")";
+
+  echo "";
+  echo "── Checks · ${doc_name}/${PROJECT_NAME} ─────────────────────────────";
+  if [ "${has_package}" == 'yes' ] ; then
+    echo "   ${runner:-(no runner)} (${runner_reason}) · dependencies $([ "${deps_installed}" == 'yes' ] && echo 'installed' || echo 'NOT installed') (${deps_evidence})";
+  else
+    echo "   no package.json — only the checks a DDEV add-on provides can apply here";
+  fi
+  echo "   running in: ${where}";
+  echo "";
+
+  # --list is pure filesystem work: it starts nothing and needs no dependencies.
+  if [ "${LIST}" == 'yes' ] ; then
+    node "${CHECKS_PLAN_JS}" "${project_path}" ${plan_args} \
+      | awk -F'\t' '{ printf "   %-9s %-14s %-14s %s\n", $1, $3, $4, ($5 != "" ? $5 : $6) }';
+    if [ "${postinstall_count}" != '0' ] ; then
+      echo "";
+      echo "   Installing this package would also run:";
+      node "${CHECKS_PLAN_JS}" "${project_path}" --format=meta | tail -n +2 | awk -F'\t' '{ printf "     %s\n", $2 }';
+    fi
+    echo "";
+    return 0 ;
+  fi
+
+  # Dependencies are never installed behind your back: a package's own postinstall can write into a
+  # docroot or run a webpack build, so --install is the arming step and it says what it will run.
+  if [ "${has_package}" == 'yes' ] && [ "${deps_installed}" == 'no' ] ; then
+    if [ "${INSTALL}" == 'yes' ] ; then
+      checks_require_container "${where}" "${project_path}" || return 2 ;
+      echo "Installing with ${runner} (${runner_reason}).";
+      if [ "${postinstall_count}" != '0' ] ; then
+        echo "This package runs ${postinstall_count} script(s) on install, which write into the tree:";
+        node "${CHECKS_PLAN_JS}" "${project_path}" --format=meta | tail -n +2 | awk -F'\t' '{ printf "  %s\n", $2 }';
+      fi
+      case "${where}" in
+        site)      ( cd "${project_path}" && ddev ${runner} install ) || return 2 ;;
+        here)      ( cd "${project_path}" && bash -lc "${runner} install" ) || return 2 ;;
+        dashboard) ( cd "${WORKSPACE_PATH}/workspace-app" && ddev exec -d "${project_path}" "${runner} install" ) || return 2 ;;
+      esac
+      plan_args="${plan_args} --assume-installed";
+    else
+      echo "Nothing ran: the dependencies of ${doc_name}/${PROJECT_NAME} are not installed.";
+      echo "  Install them and check:  bash cmd-tools-checks.sh ${PROJECT_NAME} --install";
+      echo "  See the plan first:      bash cmd-tools-checks.sh ${PROJECT_NAME} --list";
+      return 2 ;
+    fi
+  fi
+
+  started="$(date +%s)";
+  local summary="";
+
+  while IFS=$'\t' read -r id label row_status script command reason ; do
+    case "${row_status}" in
+      ready)
+        declared=$(( declared + 1 ));
+        checks_require_container "${where}" "${project_path}" || return 2 ;
+        echo "── ${id} ───────────────────────────────────────────────";
+        local one_started one_status;
+        one_started="$(date +%s)";
+        if [[ "${script}" == ddev\ * ]] ; then
+          checks_run_addon "${project_path}" "${command}";
+        elif [ "${id}" == 'e2e' ] && [ -f "${WORKSPACE_ROOT}/${doc_name}/cmd-tools-testing.sh" ] ; then
+          # The browser suite already has a command of its own, with the shared browser cache and the
+          # report handling in it. Hand over rather than reimplement half of it here.
+          bash "${WORKSPACE_ROOT}/${doc_name}/cmd-tools-testing.sh" "${PROJECT_NAME}" --run --browser "${BROWSER}" < /dev/null ;
+        else
+          checks_run_one "${where}" "${project_path}" "${runner}" "${script}";
+        fi
+        one_status=$? ;
+        ran=$(( ran + 1 ));
+        if [ ${one_status} -eq 0 ] ; then
+          passed=$(( passed + 1 ));
+          summary="${summary} ✅ $(printf '%-9s' "${id}") $(printf '%4ss' "$(( $(date +%s) - one_started ))")  ${script}\n";
+        else
+          failed=$(( failed + 1 ));
+          failed_ids="${failed_ids} ${id}";
+          status=1 ;
+          summary="${summary} ❌ $(printf '%-9s' "${id}") $(printf '%4ss' "$(( $(date +%s) - one_started ))")  ${script}\n";
+          if [ "${FAIL_FAST}" == 'yes' ] ; then
+            echo "";
+            echo "Stopping at the first failure, as asked (--fail-fast).";
+            break ;
+          fi
+        fi
+        echo "";
+        ;;
+      masked)
+        # A masked script cannot be trusted and cannot be ignored: it FAILS the run. The visible
+        # escape is --skip <id>, which is printed in the summary rather than hidden in a config.
+        declared=$(( declared + 1 ));
+        failed=$(( failed + 1 ));
+        failed_ids="${failed_ids} ${id}";
+        status=1 ;
+        summary="${summary} ⛔ $(printf '%-9s' "${id}")    —  ${script} — ${reason}\n";
+        ;;
+      refused)
+        declared=$(( declared + 1 ));
+        refused=$(( refused + 1 ));
+        summary="${summary} 🚫 $(printf '%-9s' "${id}")    —  ${script} — ${reason}\n";
+        ;;
+      skipped|deps-missing|unresolved-runner)
+        declared=$(( declared + 1 ));
+        skipped=$(( skipped + 1 ));
+        summary="${summary} ⏭  $(printf '%-9s' "${id}")    —  ${script:-—} — ${reason}\n";
+        ;;
+      *)
+        summary="${summary} ➖ $(printf '%-9s' "${id}")    —  ${reason}\n";
+        ;;
+    esac
+  done < <(node "${CHECKS_PLAN_JS}" "${project_path}" ${plan_args});
+
+  echo "";
+  echo "── Summary · ${doc_name}/${PROJECT_NAME} ────────────────────────────";
+  printf "%b" "${summary}";
+  echo "";
+  echo "   ${ran} ran · ${passed} passed · ${failed} failed · ${refused} refused · ${skipped} skipped   ($(( $(date +%s) - started ))s)";
+  if [ -n "${failed_ids}" ] ; then
+    echo "   Failed:${failed_ids}";
+    echo "   Re-run just those:  bash cmd-tools-checks.sh ${PROJECT_NAME} --only $(echo "${failed_ids}" | tr -s ' ' | sed 's/^ //;s/ /,/g')";
+  fi
+  if [ ${ran} -eq 0 ] && [ ${failed} -eq 0 ] ; then
+    echo "   Nothing ran. ${PROJECT_NAME} declares no check this verb can run — see --list.";
+  fi
+  echo "";
+
+  # The marker the dashboard reads for its caption. Written outside the package, like a graph, so a
+  # shipped repository never carries a file this tooling made.
+  if [ ${ran} -gt 0 ] ; then
+    mkdir -p "${CHECKS_STATE_DIR}/${doc_name}";
+    printf '{"at":%s,"workspace":"%s","project":"%s","ran":%s,"passed":%s,"failed":%s,"refused":%s,"skipped":%s,"seconds":%s}\n' \
+      "$(date +%s)" "${doc_name}" "${PROJECT_NAME}" "${ran}" "${passed}" "${failed}" "${refused}" "${skipped}" "$(( $(date +%s) - started ))" \
+      > "${CHECKS_STATE_DIR}/${doc_name}/${PROJECT_NAME}.json";
+  fi
+
+  return ${status} ;
+}