@lando/drupal 0.12.0 → 1.0.0

package/node_modules/@lando/php/node_modules/semver/ranges/outside.js

@@ -0,0 +1,80 @@
+const SemVer = require('../classes/semver')
+const Comparator = require('../classes/comparator')
+const { ANY } = Comparator
+const Range = require('../classes/range')
+const satisfies = require('../functions/satisfies')
+const gt = require('../functions/gt')
+const lt = require('../functions/lt')
+const lte = require('../functions/lte')
+const gte = require('../functions/gte')
+
+const outside = (version, range, hilo, options) => {
+  version = new SemVer(version, options)
+  range = new Range(range, options)
+
+  let gtfn, ltefn, ltfn, comp, ecomp
+  switch (hilo) {
+    case '>':
+      gtfn = gt
+      ltefn = lte
+      ltfn = lt
+      comp = '>'
+      ecomp = '>='
+      break
+    case '<':
+      gtfn = lt
+      ltefn = gte
+      ltfn = gt
+      comp = '<'
+      ecomp = '<='
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
+
+  // If it satisfies the range it is not outside
+  if (satisfies(version, range, options)) {
+    return false
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let high = null
+    let low = null
+
+    comparators.forEach((comparator) => {
+      if (comparator.semver === ANY) {
+        comparator = new Comparator('>=0.0.0')
+      }
+      high = high || comparator
+      low = low || comparator
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator
+      }
+    })
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
+    }
+  }
+  return true
+}
+
+module.exports = outside

package/node_modules/@lando/php/node_modules/semver/ranges/simplify.js

@@ -0,0 +1,47 @@
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+module.exports = (versions, range, options) => {
+  const set = []
+  let first = null
+  let prev = null
+  const v = versions.sort((a, b) => compare(a, b, options))
+  for (const version of v) {
+    const included = satisfies(version, range, options)
+    if (included) {
+      prev = version
+      if (!first) {
+        first = version
+      }
+    } else {
+      if (prev) {
+        set.push([first, prev])
+      }
+      prev = null
+      first = null
+    }
+  }
+  if (first) {
+    set.push([first, null])
+  }
+
+  const ranges = []
+  for (const [min, max] of set) {
+    if (min === max) {
+      ranges.push(min)
+    } else if (!max && min === v[0]) {
+      ranges.push('*')
+    } else if (!max) {
+      ranges.push(`>=${min}`)
+    } else if (min === v[0]) {
+      ranges.push(`<=${max}`)
+    } else {
+      ranges.push(`${min} - ${max}`)
+    }
+  }
+  const simplified = ranges.join(' || ')
+  const original = typeof range.raw === 'string' ? range.raw : String(range)
+  return simplified.length < original.length ? simplified : range
+}

package/node_modules/@lando/php/node_modules/semver/ranges/subset.js

@@ -0,0 +1,247 @@
+const Range = require('../classes/range.js')
+const Comparator = require('../classes/comparator.js')
+const { ANY } = Comparator
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a null set, OR
+// - Every simple range `r1, r2, ...` which is not a null set is a subset of
+//   some `R1, R2, ...`
+//
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+//   - If C is only the ANY comparator, return true
+//   - Else if in prerelease mode, return false
+//   - else replace c with `[>=0.0.0]`
+// - If C is only the ANY comparator
+//   - if in prerelease mode, return true
+//   - else replace C with `[>=0.0.0]`
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If any C is a = range, and GT or LT are set, return false
+// - If EQ
+//   - If GT, and EQ does not satisfy GT, return true (null set)
+//   - If LT, and EQ does not satisfy LT, return true (null set)
+//   - If EQ satisfies every C, return true
+//   - Else return false
+// - If GT
+//   - If GT.semver is lower than any > or >= comp in C, return false
+//   - If GT is >=, and GT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the GT.semver tuple, return false
+// - If LT
+//   - If LT.semver is greater than any < or <= comp in C, return false
+//   - If LT is <=, and LT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the LT.semver tuple, return false
+// - Else return true
+
+const subset = (sub, dom, options = {}) => {
+  if (sub === dom) {
+    return true
+  }
+
+  sub = new Range(sub, options)
+  dom = new Range(dom, options)
+  let sawNonNull = false
+
+  OUTER: for (const simpleSub of sub.set) {
+    for (const simpleDom of dom.set) {
+      const isSub = simpleSubset(simpleSub, simpleDom, options)
+      sawNonNull = sawNonNull || isSub !== null
+      if (isSub) {
+        continue OUTER
+      }
+    }
+    // the null set is a subset of everything, but null simple ranges in
+    // a complex range should be ignored.  so if we saw a non-null range,
+    // then we know this isn't a subset, but if EVERY simple range was null,
+    // then it is a subset.
+    if (sawNonNull) {
+      return false
+    }
+  }
+  return true
+}
+
+const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]
+const minimumVersion = [new Comparator('>=0.0.0')]
+
+const simpleSubset = (sub, dom, options) => {
+  if (sub === dom) {
+    return true
+  }
+
+  if (sub.length === 1 && sub[0].semver === ANY) {
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      return true
+    } else if (options.includePrerelease) {
+      sub = minimumVersionWithPreRelease
+    } else {
+      sub = minimumVersion
+    }
+  }
+
+  if (dom.length === 1 && dom[0].semver === ANY) {
+    if (options.includePrerelease) {
+      return true
+    } else {
+      dom = minimumVersion
+    }
+  }
+
+  const eqSet = new Set()
+  let gt, lt
+  for (const c of sub) {
+    if (c.operator === '>' || c.operator === '>=') {
+      gt = higherGT(gt, c, options)
+    } else if (c.operator === '<' || c.operator === '<=') {
+      lt = lowerLT(lt, c, options)
+    } else {
+      eqSet.add(c.semver)
+    }
+  }
+
+  if (eqSet.size > 1) {
+    return null
+  }
+
+  let gtltComp
+  if (gt && lt) {
+    gtltComp = compare(gt.semver, lt.semver, options)
+    if (gtltComp > 0) {
+      return null
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
+      return null
+    }
+  }
+
+  // will iterate one or zero times
+  for (const eq of eqSet) {
+    if (gt && !satisfies(eq, String(gt), options)) {
+      return null
+    }
+
+    if (lt && !satisfies(eq, String(lt), options)) {
+      return null
+    }
+
+    for (const c of dom) {
+      if (!satisfies(eq, String(c), options)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  let higher, lower
+  let hasDomLT, hasDomGT
+  // if the subset has a prerelease, we need a comparator in the superset
+  // with the same tuple and a prerelease, or it's not a subset
+  let needDomLTPre = lt &&
+    !options.includePrerelease &&
+    lt.semver.prerelease.length ? lt.semver : false
+  let needDomGTPre = gt &&
+    !options.includePrerelease &&
+    gt.semver.prerelease.length ? gt.semver : false
+  // exception: <1.2.3-0 is the same as <1.2.3
+  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
+      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
+    needDomLTPre = false
+  }
+
+  for (const c of dom) {
+    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='
+    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='
+    if (gt) {
+      if (needDomGTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomGTPre.major &&
+            c.semver.minor === needDomGTPre.minor &&
+            c.semver.patch === needDomGTPre.patch) {
+          needDomGTPre = false
+        }
+      }
+      if (c.operator === '>' || c.operator === '>=') {
+        higher = higherGT(gt, c, options)
+        if (higher === c && higher !== gt) {
+          return false
+        }
+      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (lt) {
+      if (needDomLTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomLTPre.major &&
+            c.semver.minor === needDomLTPre.minor &&
+            c.semver.patch === needDomLTPre.patch) {
+          needDomLTPre = false
+        }
+      }
+      if (c.operator === '<' || c.operator === '<=') {
+        lower = lowerLT(lt, c, options)
+        if (lower === c && lower !== lt) {
+          return false
+        }
+      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
+      return false
+    }
+  }
+
+  // if there was a < or >, and nothing in the dom, then must be false
+  // UNLESS it was limited by another range in the other direction.
+  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
+    return false
+  }
+
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
+    return false
+  }
+
+  // we needed a prerelease range in a specific tuple, but didn't get one
+  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
+  // because it includes prereleases in the 1.2.3 tuple
+  if (needDomGTPre || needDomLTPre) {
+    return false
+  }
+
+  return true
+}
+
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp > 0 ? a
+    : comp < 0 ? b
+    : b.operator === '>' && a.operator === '>=' ? b
+    : a
+}
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp < 0 ? a
+    : comp > 0 ? b
+    : b.operator === '<' && a.operator === '<=' ? b
+    : a
+}
+
+module.exports = subset

package/node_modules/@lando/php/node_modules/semver/ranges/to-comparators.js

@@ -0,0 +1,8 @@
+const Range = require('../classes/range')
+
+// Mostly just for testing and legacy API reasons
+const toComparators = (range, options) =>
+  new Range(range, options).set
+    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))
+
+module.exports = toComparators

package/node_modules/@lando/php/node_modules/semver/ranges/valid.js

@@ -0,0 +1,11 @@
+const Range = require('../classes/range')
+const validRange = (range, options) => {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+}
+module.exports = validRange

package/node_modules/@lando/php/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@lando/php",
+  "description": "A Lando plugin that provides a tight integration with PHP.",
+  "version": "1.0.0",
+  "author": "Mike Pirog @pirog",
+  "license": "GPL-3.0",
+  "repository": "lando/php",
+  "bugs": "https://github.com/lando/php/issues/new/choose",
+  "homepage": "https://github.com/lando/php",
+  "keywords": [
+    "lando",
+    "lando-plugin",
+    "lando-service",
+    "php"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "lando": {},
+  "main": "index.js",
+  "nyc": {
+    "include": [
+      "lib/**/*.js",
+      "recipes/**/*.js",
+      "services/**/*.js",
+      "types/**/*.js"
+    ],
+    "exclude": [
+      "test/**"
+    ],
+    "cache": true,
+    "all": true
+  },
+  "scripts": {
+    "coverage": "nyc report --reporter=text-lcov | coveralls",
+    "docs:dev": "vuepress dev docs --clean-cache --clean-temp",
+    "docs:build": "vuepress build docs",
+    "docs:lint": "eslint -c docs/.eslintrc.json --quiet docs/.vuepress",
+    "lint": "eslint --quiet . && npm run docs:lint",
+    "test:unit": "nyc --reporter=html --reporter=text mocha --timeout 5000 test/**/*.spec.js",
+    "test:leia": "npm run leia \"examples/**/README.md\" -c 'Destroy tests' --stdin",
+    "test": "npm run lint && npm run test:unit"
+  },
+  "dependencies": {
+    "@lando/nginx": "0.11.0",
+    "lodash": "^4.17.21",
+    "semver": "^7.3.7"
+  },
+  "devDependencies": {
+    "@babel/eslint-parser": "^7.16.0",
+    "@lando/leia": "0.6.5",
+    "@lando/vuepress-theme-default-plus": "1.0.0-beta.49",
+    "chai": "^4.3.4",
+    "command-line-test": "^1.0.10",
+    "eslint": "^7.32.0",
+    "eslint-config-google": "^0.9.1",
+    "eslint-plugin-vue": "^8.0.3",
+    "mocha": "^9.1.2",
+    "nyc": "^15.1.0",
+    "vuepress": "2.0.0-beta.53"
+  },
+  "bundledDependencies": [
+    "@lando/nginx",
+    "lodash",
+    "semver"
+  ],
+  "dist": {
+    "integrity": "sha512-7SEQCVApKyU05ZUetBwh7jGL5Rg1mZpTuHe9zc1cDyYD8PLFj8hYVreQTckCp0A6U3gjj7gXJEBnDt0mGt9S6w==",
+    "shasum": "7a5c4b46424d67f08affec563e5257010d6ac085",
+    "filename": "lando-php-1.0.0.tgz",
+    "unpackedSize": 3232123
+  }
+}

package/node_modules/@lando/php/plugin.yml

@@ -0,0 +1,29 @@
+# We don't need this because its in the package.json
+# but we set it anyway just to make sure we know what is what
+name: "@lando/php"
+
+# Let lando autoscan this plugin for "legacy" plugin stuff needed for v3
+legacy: true
+
+# This is just metadata that something else can use to understand how the docs are organized
+docs:
+  # This is the tag we should use when connecting platform.sh content together eg showing guides on the main
+  # platform.sh recipe docs
+  tag: php
+
+  # This gets added to the lando/lando docs guides.json
+  guides:
+    title: PHP
+    collapsable: true
+    # Note that these are "source/destination" pairs the source is relative to the root of this
+    # repo and the desintation is relative to docs/guides in the main lando repo
+    # When this gets added to guides.json we map children so its just the destination
+    children:
+      "guides/adding-tooling": php/adding-tooling
+
+  # This gets added to the lando/lando docs config.js
+  # Below takes docs/usage.md from this repo and puts it into config/CHANGEME.md in lando/lando
+  # and then adds CHANGEME to the list of recipes in config.js
+  config:
+    recipes:
+      "php": ./docs/usage.md

package/node_modules/@lando/php/scripts/install-composer.sh

@@ -0,0 +1,36 @@
+#!/bin/sh
+
+set -e
+
+VERSION="$1"
+
+# NOTE: we should have better protections here
+php -r "copy('https://getcomposer.org/installer', '/tmp/composer-setup.php');"
+
+# Allow for a few convenience install methods
+if [ "$VERSION" = '1-latest' ]; then
+  php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer --1
+elif [ "$VERSION" = '1' ]; then
+  php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer --1
+elif [ "$VERSION" = '2-latest' ]; then
+  php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer --2
+elif [ "$VERSION" = '2' ]; then
+  php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer --2
+elif [ "$VERSION" = 'preview' ]; then
+  php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer --preview
+elif [ "$VERSION" = 'snapshot' ]; then
+  php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer --snapshot
+else
+  php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer --version="$VERSION"
+fi
+
+# Remove the setup script
+php -r "unlink('/tmp/composer-setup.php');"
+
+# Check if anything is installed globally
+if [ -f /var/www/.composer/composer.json ]; then
+  # If this is version 2 then let's make sure hirak/prestissimo is removed
+  if composer --version 2>/dev/null | grep -E "Composer (version )?2." > /dev/null; then
+    composer global remove hirak/prestissimo
+  fi
+fi

package/node_modules/@lando/php/utils/add-build-step.js

@@ -0,0 +1,14 @@
+'use strict';
+
+// Modules
+const _ = require('lodash');
+
+/*
+ * Helper to get global deps
+ * @TODO: this looks pretty testable? should services have libs?
+ */
+module.exports = (steps, app, name, step = 'build_internal', front = false) => {
+  const current = _.get(app, `config.services.${name}.${step}`, []);
+  const add = (front) ? _.flatten([steps, current]) : _.flatten([current, steps]);
+  _.set(app, `config.services.${name}.${step}`, _.uniq(add));
+};

package/node_modules/@lando/php/utils/clone-overrides.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Modules
+const _ = require('lodash');
+
+/*
+ * Helper to get global deps
+ * @TODO: this looks pretty testable? should services have libs?
+ */
+module.exports = (overrides = {}) => {
+  const newOverrides = _.cloneDeep(overrides);
+  if (_.has(newOverrides, 'image')) delete newOverrides.image;
+  if (_.has(newOverrides, 'build')) delete newOverrides.build;
+  return newOverrides;
+};

package/node_modules/@lando/php/utils/get-install-commands.js

@@ -0,0 +1,13 @@
+'use strict';
+
+// Modules
+const _ = require('lodash');
+
+/*
+ * Helper to get global deps
+ * @TODO: this looks pretty testable? should services have libs?
+ */
+module.exports = (deps, pkger, prefix = []) => _(deps)
+  .map((version, pkg) => _.flatten([prefix, pkger(pkg, version)]))
+  .map(command => command.join(' '))
+  .value();

package/node_modules/@lando/postgres/.editorconfig

@@ -0,0 +1,12 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+
+[*.js]
+indent_style = space
+indent_size = 2

package/node_modules/@lando/postgres/.eslintignore

@@ -0,0 +1,4 @@
+.temp
+.cache
+dist
+_site

package/node_modules/@lando/postgres/.eslintrc.json

@@ -0,0 +1,31 @@
+{
+  "env": {
+    "node": true,
+    "mocha": true
+  },
+  "parser": "@babel/eslint-parser",
+  "parserOptions": {
+    "sourceType": "module",
+    "ecmaVersion": 8,
+    "requireConfigFile": false
+  },
+  "extends": "google",
+  "rules": {
+    "arrow-parens": ["error",
+      "as-needed"
+    ],
+    "max-len": ["error", {
+      "code": 120,
+      "ignoreComments": true
+    }],
+    "require-jsdoc": ["error", {
+      "require": {
+        "FunctionDeclaration": true,
+        "MethodDefinition": false,
+        "ClassDeclaration": false,
+        "ArrowFunctionExpression": false,
+        "FunctionExpression": false
+      }
+    }]
+  }
+}

package/node_modules/@lando/postgres/.gitattributes

@@ -0,0 +1,11 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Declare files that will always have LF line endings on checkout.
+*.js text eol=lf
+*.sh text eol=lf
+*.conf text eol=lf
+*.cnf text eol=lf
+*.ini text eol=lf
+*.php text eol=lf
+*.vcl text eol=lf

package/node_modules/@lando/postgres/.lando.yml

@@ -0,0 +1,14 @@
+name: lando-postgres-plugin
+services:
+  node:
+    type: node:14
+    build:
+      - npm install
+    scanner: false
+    ssl: false
+    sslExpose: false
+tooling:
+  node:
+    service: node
+  npm:
+    service: node

package/node_modules/@lando/postgres/.node-version

@@ -0,0 +1 @@
+18

package/node_modules/@lando/postgres/.nyc_output/2687c51a-1087-45b1-b5dd-1c557d4a9030.json

@@ -0,0 +1 @@
+{}

package/node_modules/@lando/postgres/.nyc_output/8b1ac11a-c036-44b8-8ee5-b34875c4541c.json

@@ -0,0 +1 @@
+{}

package/node_modules/@lando/postgres/.nyc_output/processinfo/2687c51a-1087-45b1-b5dd-1c557d4a9030.json

@@ -0,0 +1 @@
+{"parent":null,"pid":1966,"argv":["/opt/hostedtoolcache/node/18.19.0/x64/bin/node","/home/runner/work/postgres/postgres/node_modules/.bin/mocha","--timeout","5000","test/**/*.spec.js"],"execArgv":[],"cwd":"/home/runner/work/postgres/postgres","time":1702582254499,"ppid":1955,"coverageFilename":"/home/runner/work/postgres/postgres/.nyc_output/2687c51a-1087-45b1-b5dd-1c557d4a9030.json","externalId":"","uuid":"2687c51a-1087-45b1-b5dd-1c557d4a9030","files":[]}

package/node_modules/@lando/postgres/.nyc_output/processinfo/8b1ac11a-c036-44b8-8ee5-b34875c4541c.json

@@ -0,0 +1 @@
+{"parent":null,"pid":1955,"argv":["/opt/hostedtoolcache/node/18.19.0/x64/bin/node","/home/runner/work/postgres/postgres/node_modules/.bin/nyc","--reporter=html","--reporter=text","mocha","--timeout","5000","test/**/*.spec.js"],"execArgv":[],"cwd":"/home/runner/work/postgres/postgres","time":1702582254328,"ppid":1954,"coverageFilename":"/home/runner/work/postgres/postgres/.nyc_output/8b1ac11a-c036-44b8-8ee5-b34875c4541c.json","externalId":"","uuid":"8b1ac11a-c036-44b8-8ee5-b34875c4541c","files":[]}