@prettier/plugin-php 0.23.0 → 0.25.0

package/README.md

@@ -176,17 +176,33 @@ await prettier.format(YOUR_CODE, {
 
 Prettier for PHP supports the following options. We recommend that all users set the `phpVersion` option.
 
-| Name               | Default    | Description                                                                                                                                                                                                                                                                            |
-| ------------------ | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `phpVersion`       | `"7.0"`    | Allows specifying the PHP version you're using. If you're using PHP 7.1 or later, setting this option will make use of modern language features in the printed output. If you're using PHP lower than 7.0, you'll have to set this option or Prettier will generate incompatible code. |
-| `printWidth`       | `80`       | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width))                                                                                                                                                                                        |
-| `tabWidth`         | `4`        | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)), The default is `4` based on the `PSR-2` coding standard.                                                                                                                                |
-| `useTabs`          | `false`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tabs))                                                                                                                                                                                               |
-| `singleQuote`      | `false`    | If set to `"true"`, strings that use double quotes but do not rely on the features they add, will be reformatted. Example: `"foo" -> 'foo'`, `"foo $bar" -> "foo $bar"`.                                                                                                               |
-| `trailingCommaPHP` | `true`     | If set to `true`, trailing commas will be added wherever possible. <br> If set to `false`, no trailing commas are printed.                                                                                                                                                             |
-| `braceStyle`       | `"per-cs"` | If set to `"per-cs"`, prettier will move open brace for code blocks (classes, functions and methods) onto new line. <br> If set to `"1tbs"`, prettier will move open brace for code blocks (classes, functions and methods) onto same line.                                            |
-| `requirePragma`    | `false`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma))                                                                                                                                                                                     |
-| `insertPragma`     | `false`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#insert-pragma))                                                                                                                                                                                      |
+| Name               | Default     | Description                                                                                                                                                                                                                                 |
+| ------------------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `phpVersion`       | `"auto"` \* | Allows specifying the PHP version you're using. (See Notes Below)                                                                                                                                                                           |
+| `printWidth`       | `80`        | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width))                                                                                                                                             |
+| `tabWidth`         | `4`         | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)), The default is `4` based on the `PSR-2` coding standard.                                                                                     |
+| `useTabs`          | `false`     | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tabs))                                                                                                                                                    |
+| `singleQuote`      | `false`     | If set to `"true"`, strings that use double quotes but do not rely on the features they add, will be reformatted. Example: `"foo" -> 'foo'`, `"foo $bar" -> "foo $bar"`.                                                                    |
+| `trailingCommaPHP` | `true`      | If set to `true`, trailing commas will be added wherever possible. <br> If set to `false`, no trailing commas are printed.                                                                                                                  |
+| `braceStyle`       | `"per-cs"`  | If set to `"per-cs"`, prettier will move open brace for code blocks (classes, functions and methods) onto new line. <br> If set to `"1tbs"`, prettier will move open brace for code blocks (classes, functions and methods) onto same line. |
+| `requirePragma`    | `false`     | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma))                                                                                                                                          |
+| `insertPragma`     | `false`     | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#insert-pragma))                                                                                                                                           |
+
+### \* `phpVersion` Configuration Notes :
+
+The default setting `auto`, attempts to auto-detect your supported php versions from a `composer.json` with in the
+current directory or any parent directory, the plugin will use a minimum supported php version from
+`{"require":{"php":"..."}}` to set the phpVersion. If not found or not able to be parsed, it will default to latest
+supported PHP version.
+
+You set the `phpVersion` to `composer` and this will only use the `composer.json` file to determine the php
+version, prettier will crash if the PHP cannot be determined.
+
+You can also set the `phpVersion` to a specific version, such as `7.4`, `8.0`, `8.1`, `8.2`, `8.3` or `8.4`.
+
+**Please Note:** If the phpVersion is not set correctly for your environment, this plugin will produce code that could
+be incompatible with your PHP runtime. For example, if you are using PHP 7.4, but the plugin is set to PHP 8.3, it will
+produce code that uses features not available in PHP 7.4.
 
 ## Ignoring code
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-php",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Prettier PHP Plugin",
   "repository": "prettier/prettier-php",
   "author": "Lucas Azzola <@azz>",
@@ -27,32 +27,32 @@
   ],
   "dependencies": {
     "linguist-languages": "^8.0.0",
-    "php-parser": "^3.2.5"
+    "php-parser": "^3.4.0"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.27.2",
     "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-babel": "^6.0.3",
-    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-babel": "^7.0.0",
+    "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-inject": "^5.0.5",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.1",
-    "@rollup/plugin-replace": "^5.0.5",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-terser": "^0.4.3",
     "c8": "^10.1.3",
     "cross-env": "^7.0.2",
     "eslint": "8.57.0",
     "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-import": "2.32.0",
     "eslint-plugin-jest": "27.6.3",
-    "eslint-plugin-prettier": "5.1.3",
+    "eslint-plugin-prettier": "5.5.5",
     "eslint-plugin-prettier-doc": "^1.1.0",
-    "jest": "30.0.3",
-    "jest-environment-jsdom": "30.0.2",
+    "jest": "30.3.0",
+    "jest-environment-jsdom": "30.3.0",
     "jest-light-runner": "^0.7.9",
     "jest-snapshot-serializer-raw": "^2.0.0",
     "prettier": "^3.6.1",
-    "rollup": "^3.28.1",
+    "rollup": "^4.60.0",
     "strip-ansi": "^7.1.0"
   },
   "peerDependencies": {

package/src/needs-parens.mjs

@@ -1,9 +1,4 @@
-import {
-  getPrecedence,
-  shouldFlatten,
-  isBitwiseOperator,
-  isMinVersion,
-} from "./util.mjs";
+import { getPrecedence, shouldFlatten, isBitwiseOperator } from "./util.mjs";
 
 function needsParens(path, options) {
   const { parent } = path;
@@ -135,7 +130,7 @@ function needsParens(path, options) {
     case "new": {
       const requiresParens =
         node.kind === "clone" ||
-        (node.kind === "new" && !isMinVersion(options.phpVersion, "8.4"));
+        (node.kind === "new" && options.phpVersion < 8.4);
       switch (parent.kind) {
         case "propertylookup":
         case "nullsafepropertylookup":
@@ -147,7 +142,8 @@ function needsParens(path, options) {
           return false;
       }
     }
-    case "yield": {
+    case "yield":
+    case "yieldfrom": {
       switch (parent.kind) {
         case "propertylookup":
         case "nullsafepropertylookup":
@@ -159,8 +155,11 @@ function needsParens(path, options) {
         case "retif":
           return key === "test";
 
+        case "assign":
+          return node.kind === "yield" && !!(node.key || node.value);
+
         default:
-          return !!(node.key || node.value);
+          return node.kind === "yieldfrom" || !!(node.key || node.value);
       }
     }
     case "assign": {
@@ -171,7 +170,7 @@ function needsParens(path, options) {
         return false;
       } else if (parent.kind === "assign") {
         return false;
-      } else if (parent.kind === "static") {
+      } else if (parent.kind === "staticvariable") {
         return false;
       } else if (
         ["if", "do", "while", "foreach", "switch"].includes(parent.kind)
@@ -220,7 +219,7 @@ function needsParens(path, options) {
         default:
           return false;
       }
-    case "silence":
+    case "silent":
     case "cast":
       // TODO: bug https://github.com/glayzzle/php-parser/issues/172
       return node.parenthesizedExpression;

package/src/options.mjs

@@ -1,30 +1,124 @@
+import fs from "fs";
+import path from "path";
+
 const CATEGORY_PHP = "PHP";
 
+// prettier-ignore
+const SUPPORTED_PHP_VERSIONS = [
+  5.0, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6,
+  7.0, 7.1, 7.2, 7.3, 7.4,
+  8.0, 8.1, 8.2, 8.3, 8.4, 8.5,
+];
+
+export const LATEST_SUPPORTED_PHP_VERSION = Math.max(...SUPPORTED_PHP_VERSIONS);
+
+let getComposerError = "";
+
+/**
+ * Detect the minimum PHP version from the composer.json file
+ * @return {number|null} The PHP version to use in the composer.json file, null when not found
+ */
+function getComposerPhpVersion() {
+  // Try to find composer.json
+  const currentDir = process.cwd();
+  let composerPath = null;
+
+  const directComposerPath = path.join(currentDir, "composer.json");
+  if (fs.existsSync(directComposerPath)) {
+    composerPath = directComposerPath;
+  }
+
+  if (!composerPath) {
+    let searchDir = path.dirname(currentDir);
+    while (searchDir !== path.parse(searchDir).root) {
+      const potentialComposerPath = path.join(searchDir, "composer.json");
+      if (fs.existsSync(potentialComposerPath)) {
+        composerPath = potentialComposerPath;
+        break;
+      }
+      searchDir = path.dirname(searchDir);
+    }
+  }
+
+  if (composerPath) {
+    try {
+      const fileContent = fs.readFileSync(composerPath, "utf8");
+      const composerJson = JSON.parse(fileContent);
+
+      if (composerJson.require && composerJson.require.php) {
+        // Check for a wildcard pattern like "7.*"
+        const wildcardMatch = composerJson.require.php.match(
+          /^(?:[^0-9]*)?([0-9]+)\.\*/
+        );
+        if (wildcardMatch) {
+          return parseFloat(`${wildcardMatch[1]}.0`);
+        }
+
+        // Extract version from composer semver format
+        const versionMatch = composerJson.require.php.match(
+          /^(?:[^0-9]*)?([0-9]+)\.([0-9]+)/
+        );
+
+        if (versionMatch) {
+          return parseFloat(`${versionMatch[1]}.${versionMatch[2]}`);
+        } else {
+          getComposerError = `Could not decode PHP version (${composerJson.require.php}})`;
+          return null;
+        }
+      }
+    } catch (e) {
+      getComposerError = `Error reading composer.json: ${e.message}`;
+    }
+  } else {
+    getComposerError = "Could not find composer.json";
+  }
+
+  return null;
+}
+
+export { getComposerPhpVersion };
+
+/**
+ * Resolve the PHP version to a number based on the provided options.
+ *
+ */
+export function resolvePhpVersion(options) {
+  if (!options) {
+    return;
+  }
+  if (options.phpVersion === "auto") {
+    options.phpVersion =
+      getComposerPhpVersion() ?? LATEST_SUPPORTED_PHP_VERSION;
+  } else if (options.phpVersion === "composer") {
+    const v = getComposerPhpVersion();
+    if (v === null) {
+      throw new Error(
+        `Could not determine PHP version from composer; ${getComposerError}`
+      );
+    }
+    options.phpVersion = v;
+  } else {
+    options.phpVersion = parseFloat(options.phpVersion);
+  }
+}
+
 export default {
   phpVersion: {
     since: "0.13.0",
     category: CATEGORY_PHP,
     type: "choice",
-    default: "7.0",
+    default: "auto",
     description: "Minimum target PHP version.",
     choices: [
-      { value: "5.0" },
-      { value: "5.1" },
-      { value: "5.2" },
-      { value: "5.3" },
-      { value: "5.4" },
-      { value: "5.5" },
-      { value: "5.6" },
-      { value: "7.0" },
-      { value: "7.1" },
-      { value: "7.2" },
-      { value: "7.3" },
-      { value: "7.4" },
-      { value: "8.0" },
-      { value: "8.1" },
-      { value: "8.2" },
-      { value: "8.3" },
-      { value: "8.4" },
+      ...SUPPORTED_PHP_VERSIONS.map((v) => ({ value: v.toFixed(1) })),
+      {
+        value: "composer",
+        description: "Use the PHP version defined in composer.json",
+      },
+      {
+        value: "auto",
+        description: `Try composer.json, else latest PHP Version (${LATEST_SUPPORTED_PHP_VERSION})`,
+      },
     ],
   },
   trailingCommaPHP: {

package/src/parser.mjs

@@ -1,5 +1,6 @@
 import engine from "php-parser";
-import options from "./options.mjs";
+import { LATEST_SUPPORTED_PHP_VERSION } from "./options.mjs";
+import { resolvePhpVersion } from "./options.mjs";
 
 function parse(text, opts) {
   const inMarkdown = opts && opts.parentParser === "markdown";
@@ -7,19 +8,16 @@ function parse(text, opts) {
   if (!text && inMarkdown) {
     return "";
   }
+  resolvePhpVersion(opts);
 
   // Todo https://github.com/glayzzle/php-parser/issues/170
   text = text.replace(/\?>\n<\?/g, "?>\n___PSEUDO_INLINE_PLACEHOLDER___<?");
 
-  const latestSupportedPhpVersion = Math.max(
-    ...options.phpVersion.choices.map((c) => parseFloat(c.value))
-  );
-
   // initialize a new parser instance
   const parser = new engine({
     parser: {
       extractDoc: true,
-      version: `${latestSupportedPhpVersion}`,
+      version: `${LATEST_SUPPORTED_PHP_VERSION}`,
     },
     ast: {
       withPositions: true,

package/src/printer.mjs

@@ -37,7 +37,6 @@ import {
   isReferenceLikeNode,
   normalizeMagicMethodName,
   isSimpleCallArgument,
-  isMinVersion,
 } from "./util.mjs";
 
 const {
@@ -51,6 +50,7 @@ const {
   dedent,
   ifBreak,
   hardline,
+  hardlineWithoutBreakParent,
   softline,
   literalline,
   align,
@@ -66,12 +66,19 @@ const {
   isPreviousLineEmpty,
 } = prettierUtil;
 
+/**
+ * Determine if we should print a trailing comma based on the config & php version
+ *
+ * @param options {object} Prettier Options
+ * @param requiredVersion {number}
+ * @returns {boolean}
+ */
 function shouldPrintComma(options, requiredVersion) {
   if (!options.trailingCommaPHP) {
     return false;
   }
 
-  return isMinVersion(options.phpVersion, requiredVersion);
+  return options.phpVersion >= requiredVersion;
 }
 
 function shouldPrintHardlineForOpenBrace(options) {
@@ -612,9 +619,9 @@ function printArgumentsList(path, options, print, argumentsKey = "arguments") {
   const lastArg = getLast(args);
 
   const maybeTrailingComma =
-    (shouldPrintComma(options, "7.3") &&
+    (shouldPrintComma(options, 7.3) &&
       ["call", "new", "unset", "isset"].includes(node.kind)) ||
-    (shouldPrintComma(options, "8.0") &&
+    (shouldPrintComma(options, 8.0) &&
       ["function", "closure", "method", "arrowfunc", "attribute"].includes(
         node.kind
       ))
@@ -735,6 +742,32 @@ function shouldInlineLogicalExpression(node) {
 // precedence level and the AST is structured based on precedence
 // level, things are naturally broken up correctly, i.e. `&&` is
 // broken before `+`.
+function printPipeChain(path, print, trailingSemicolon = false) {
+  const elements = [];
+
+  function collect() {
+    const { node } = path;
+    if (node.kind === "bin" && node.type === "|>") {
+      elements.push(path.call(print, "left"));
+      path.call(collect, "right");
+    } else {
+      elements.push(print());
+    }
+  }
+
+  collect();
+
+  const [first, ...rest] = elements;
+  const semicolon = trailingSemicolon
+    ? ifBreak([hardlineWithoutBreakParent, ";"], ";")
+    : "";
+  return group([
+    first,
+    indent(rest.flatMap((el) => [line, "|> ", el])),
+    semicolon,
+  ]);
+}
+
 function printBinaryExpression(
   path,
   print,
@@ -1186,7 +1219,7 @@ function printAttrs(path, options, print, { inline = false } = {}) {
     allAttrs.push(
       group([
         indent(attrGroup),
-        ifBreak(shouldPrintComma(options, "8.0") ? "," : ""),
+        ifBreak(shouldPrintComma(options, 8.0) ? "," : ""),
         softline,
         "]",
         inline ? ifBreak(softline, " ") : "",
@@ -1213,7 +1246,7 @@ function printClass(path, options, print) {
     declaration.push("abstract ");
   }
 
-  if (node.isReadonly) {
+  if (node.isReadonly && !isAnonymousClass) {
     declaration.push("readonly ");
   }
 
@@ -1518,6 +1551,7 @@ function printAssignmentRight(
 
   const canBreak =
     (pureRightNode.kind === "bin" &&
+      pureRightNode.type !== "|>" &&
       !shouldInlineLogicalExpression(pureRightNode)) ||
     (pureRightNode.kind === "retif" &&
       ((!pureRightNode.trueExpr &&
@@ -1658,11 +1692,7 @@ function printNode(path, options, print) {
           join([",", line], path.map(print, "items")),
         ]),
         node.name
-          ? [
-              ifBreak(shouldPrintComma(options, "7.2") ? "," : ""),
-              softline,
-              "}",
-            ]
+          ? [ifBreak(shouldPrintComma(options, 7.2) ? "," : ""), softline, "}"]
           : "",
       ]);
     case "useitem":
@@ -2092,7 +2122,7 @@ function printNode(path, options, print) {
             () => printAttrs(path, options, print, { inline: true }),
             "what"
           ),
-          "class",
+          node.what.isReadonly ? "readonly class" : "class",
           node.arguments.length > 0
             ? [" ", printArgumentsList(path, options, print)]
             : "",
@@ -2356,9 +2386,8 @@ function printNode(path, options, print) {
     case "list":
     case "array": {
       const useShortForm =
-        (node.kind === "array" && isMinVersion(options.phpVersion, "5.4")) ||
-        (node.kind === "list" &&
-          (node.shortForm || isMinVersion(options.phpVersion, "7.1")));
+        (node.kind === "array" && options.phpVersion >= 5.4) ||
+        (node.kind === "list" && (node.shortForm || options.phpVersion >= 7.1));
       const open = useShortForm ? "[" : [node.kind, "("];
       const close = useShortForm ? "]" : ")";
 
@@ -2408,7 +2437,7 @@ function printNode(path, options, print) {
           indent([softline, printArrayItems(path, options, print)]),
           needsForcedTrailingComma ? "," : "",
           ifBreak(
-            !needsForcedTrailingComma && shouldPrintComma(options, "5.0")
+            !needsForcedTrailingComma && shouldPrintComma(options, 5.0)
               ? [
                   lastElem && shouldPrintHardlineBeforeTrailingComma(lastElem)
                     ? hardline
@@ -2486,6 +2515,16 @@ function printNode(path, options, print) {
       );
     }
     case "bin": {
+      if (node.type === "|>") {
+        const { parent, grandparent } = path;
+        const isStatementLevel =
+          parent.kind === "expressionstatement" ||
+          (parent.kind === "assign" &&
+            grandparent &&
+            grandparent.kind === "expressionstatement");
+        return printPipeChain(path, print, isStatementLevel);
+      }
+
       const { parent, grandparent: parentParent } = path;
       const isInsideParenthesis =
         node !== parent.body &&
@@ -2675,7 +2714,7 @@ function printNode(path, options, print) {
       if (parent.kind === "encapsedpart") {
         const parentParent = path.grandparent;
         let closingTagIndentation = 0;
-        const flexible = isMinVersion(options.phpVersion, "7.3");
+        const flexible = options.phpVersion >= 7.3;
         let linebreak = literalline;
         if (parentParent.type === "heredoc") {
           linebreak = flexible ? hardline : literalline;
@@ -2744,7 +2783,7 @@ function printNode(path, options, print) {
         case "string":
         case "shell":
         case "heredoc": {
-          const flexible = isMinVersion(options.phpVersion, "7.3");
+          const flexible = options.phpVersion >= 7.3;
           const linebreak = flexible ? hardline : literalline;
           return [
             getEncapsedQuotes(node),
@@ -2769,7 +2808,7 @@ function printNode(path, options, print) {
     case "magic":
       return node.value;
     case "nowdoc": {
-      const flexible = isMinVersion(options.phpVersion, "7.3");
+      const flexible = options.phpVersion >= 7.3;
       const linebreak = flexible ? hardline : literalline;
       return [
         "<<<'",

package/src/util.mjs

@@ -41,6 +41,7 @@ const PRECEDENCE = new Map(
       "<<=",
       ">>=",
     ],
+    ["|>"],
     ["??"],
     ["||"],
     ["&&"],
@@ -70,7 +71,7 @@ const bitshiftOperators = [">>", "<<"];
 
 function isBitwiseOperator(operator) {
   return (
-    !!bitshiftOperators[operator] ||
+    bitshiftOperators.includes(operator) ||
     operator === "|" ||
     operator === "^" ||
     operator === "&"
@@ -359,6 +360,17 @@ function lineShouldEndWithSemicolon(path) {
       return true;
     }
   }
+  if (node.kind === "expressionstatement") {
+    const expr = node.expression;
+    const isPipeChain =
+      (expr.kind === "bin" && expr.type === "|>") ||
+      (expr.kind === "assign" &&
+        expr.right.kind === "bin" &&
+        expr.right.type === "|>");
+    if (isPipeChain) {
+      return false;
+    }
+  }
   return [
     "expressionstatement",
     "do",
@@ -678,7 +690,7 @@ function isSimpleCallArgument(node, depth = 2) {
 
   if (isCallLikeExpression(node)) {
     const parts = getChainParts(node);
-    parts.unshift();
+    parts.shift();
 
     return (
       parts.length <= depth &&
@@ -709,10 +721,6 @@ function memoize(fn) {
   };
 }
 
-function isMinVersion(actualVersion, requiredVersion) {
-  return parseFloat(actualVersion) >= parseFloat(requiredVersion);
-}
-
 export {
   printNumber,
   getPrecedence,
@@ -744,5 +752,4 @@ export {
   normalizeMagicMethodName,
   isSimpleCallArgument,
   memoize,
-  isMinVersion,
 };