@prettier/plugin-php 0.22.1 → 0.22.3

package/README.md

@@ -37,6 +37,10 @@ Prettier is an opinionated code formatter. It enforces a consistent style by par
 
 This plugin adds support for the PHP language to Prettier.
 
+> [!NOTE]
+>
+> This plugin uses PSR / PER as guidance when making formatting decisions, but does not aim to be fully PSR / PER compliant. The idea is to stay reasonably close to how Prettier for JS works.
+
 ### Can this be used in production?
 
 We're considering the plugin to be stable when pure PHP files are formatted. Formatting of files that contain mixed PHP and HTML is still considered unstable - please see [open issues with the tag "inline"](https://github.com/prettier/plugin-php/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Ainline) for details.
@@ -85,7 +89,7 @@ yarn:
 
 ```bash
 yarn add --dev prettier @prettier/plugin-php
-# or globally
+# or globally (pending https://github.com/prettier/prettier/issues/15141)
 yarn global add prettier @prettier/plugin-php
 ```
 
@@ -93,7 +97,7 @@ npm:
 
 ```bash
 npm install --save-dev prettier @prettier/plugin-php
-# or globally
+# or globally (pending https://github.com/prettier/prettier/issues/15141)
 npm install --global prettier @prettier/plugin-php
 ```
 
@@ -270,7 +274,7 @@ Sublime Text support is available through Package Control and the [JsPrettier](h
 
 ### Vim
 
-Regarding plugin support in the official plugin vim-prettier see [this issue](https://github.com/prettier/vim-prettier/issues/119).
+The official [prettier plugin for vim](https://github.com/prettier/vim-prettier) has built-in support for plugin-php since 1.0.
 
 #### ALE
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-php",
-  "version": "0.22.1",
+  "version": "0.22.3",
   "description": "Prettier PHP Plugin",
   "repository": "prettier/prettier-php",
   "author": "Lucas Azzola <@azz>",
@@ -21,7 +21,6 @@
   ],
   "dependencies": {
     "linguist-languages": "^7.27.0",
-    "mem": "^9.0.2",
     "php-parser": "^3.1.5"
   },
   "devDependencies": {
@@ -34,13 +33,13 @@
     "@rollup/plugin-node-resolve": "^15.2.1",
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-terser": "^0.4.3",
-    "c8": "^8.0.1",
+    "c8": "^9.1.0",
     "cross-env": "^7.0.2",
-    "eslint": "8.56.0",
+    "eslint": "8.57.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-jest": "27.6.0",
-    "eslint-plugin-prettier": "5.0.1",
+    "eslint-plugin-jest": "27.6.3",
+    "eslint-plugin-prettier": "5.1.3",
     "eslint-plugin-prettier-doc": "^1.1.0",
     "jest": "29.7.0",
     "jest-environment-jsdom": "29.7.0",

package/src/options.mjs

@@ -45,4 +45,11 @@ export default {
       { value: "1tbs", description: "Use 1tbs brace style." },
     ],
   },
+  singleQuote: {
+    since: "0.0.0",
+    category: CATEGORY_PHP,
+    type: "boolean",
+    default: false,
+    description: "Use single quotes instead of double quotes.",
+  },
 };

package/src/pragma.mjs

@@ -1,4 +1,4 @@
-import memoize from "mem";
+import { memoize } from "./util.mjs";
 import parse from "./parser.mjs";
 
 const reHasPragma = /@prettier|@format/;

package/src/printer.mjs

@@ -36,6 +36,7 @@ import {
   getAncestorNode,
   isReferenceLikeNode,
   normalizeMagicMethodName,
+  isSimpleCallArgument,
 } from "./util.mjs";
 
 const {
@@ -508,9 +509,9 @@ function printMemberChain(path, options, print) {
     printIndentedGroup(groups.slice(shouldMerge ? 2 : 1)),
   ];
 
-  const callExpressionCount = printedNodes.filter(
+  const callExpressions = printedNodes.filter(
     (tuple) => tuple.node.kind === "call"
-  ).length;
+  );
 
   // We don't want to print in one line if there's:
   //  * A comment.
@@ -519,7 +520,10 @@ function printMemberChain(path, options, print) {
   // If the last group is a function it's okay to inline if it fits.
   if (
     hasComment ||
-    callExpressionCount >= 3 ||
+    (callExpressions.length > 2 &&
+      callExpressions.some(
+        (exp) => !exp.node.arguments.every((arg) => isSimpleCallArgument(arg))
+      )) ||
     printedGroups.slice(0, -1).some(willBreak)
   ) {
     return group(expanded);
@@ -1014,8 +1018,8 @@ function printLines(path, options, print, childrenAttribute = "children") {
               "?>",
             ]
           : isProgramLikeNode(node) && isFirstNode && node.kind !== "namespace"
-          ? ""
-          : [beforeCloseTagInlineNode, "?>"];
+            ? ""
+            : [beforeCloseTagInlineNode, "?>"];
 
       //FIXME getNode is used to get ancestors, but it seems this means to get next sibling?
       const nextV = path.getNode(index + 1);
@@ -1030,8 +1034,8 @@ function printLines(path, options, print, childrenAttribute = "children") {
               hardline,
             ]
           : isProgramLikeNode(node) && isLastNode
-          ? ""
-          : [openTag, " "];
+            ? ""
+            : [openTag, " "];
 
       printed = [beforeInline, printed, afterInline];
     }
@@ -1087,8 +1091,8 @@ function printLines(path, options, print, childrenAttribute = "children") {
               : "",
           ]
         : node.comments
-        ? hardline
-        : "";
+          ? hardline
+          : "";
 
       parts.push(lineSuffix([beforeCloseTag, "?>"]));
     }
@@ -1293,17 +1297,18 @@ function printClass(path, options, print) {
     }
   }
 
+  const hasEmptyClassBody =
+    node.body && node.body.length === 0 && !hasDanglingComments(node);
+
   const printedDeclaration = group([
     group(declaration),
-    shouldPrintHardlineForOpenBrace(options)
+    shouldPrintHardlineForOpenBrace(options) && !hasEmptyClassBody
       ? isAnonymousClass
         ? line
         : hardline
       : " ",
   ]);
 
-  const hasEmptyClassBody =
-    node.body && node.body.length === 0 && !hasDanglingComments(node);
   const printedBody = [
     "{",
     indent([
@@ -1311,7 +1316,7 @@ function printClass(path, options, print) {
       printStatements(path, options, print, "body"),
     ]),
     printDanglingComments(path, options, true),
-    isAnonymousClass && hasEmptyClassBody ? softline : hardline,
+    hasEmptyClassBody ? "" : hardline,
     "}",
   ];
 
@@ -1379,14 +1384,14 @@ function printFunction(path, options, print) {
     return [...declAttrs, printedDeclaration];
   }
 
-  const isClosure = node.kind === "closure";
   const printedBody = [
     "{",
     indent([hasEmptyBody(path) ? "" : hardline, print("body")]),
-    isClosure && hasEmptyBody(path) ? "" : hardline,
+    hasEmptyBody(path) ? "" : hardline,
     "}",
   ];
 
+  const isClosure = node.kind === "closure";
   if (isClosure) {
     return [...declAttrs, printedDeclaration, " ", printedBody];
   }
@@ -1395,7 +1400,9 @@ function printFunction(path, options, print) {
     return [
       ...declAttrs,
       printedDeclaration,
-      shouldPrintHardlineForOpenBrace(options) ? hardline : " ",
+      shouldPrintHardlineForOpenBrace(options) && !hasEmptyBody(path)
+        ? hardline
+        : " ",
       printedBody,
     ];
   }
@@ -1411,7 +1418,9 @@ function printFunction(path, options, print) {
     conditionalGroup([
       [
         printedDeclaration,
-        shouldPrintHardlineForOpenBrace(options) ? hardline : " ",
+        shouldPrintHardlineForOpenBrace(options) && !hasEmptyBody(path)
+          ? hardline
+          : " ",
         printedBody,
       ],
       [printedDeclaration, " ", printedBody],
@@ -1707,8 +1716,8 @@ function printNode(path, options, print) {
                     hardline,
                   ]
                 : hasDanglingComments(node)
-                ? [line, printDanglingComments(path, options, true), line]
-                : "",
+                  ? [line, printDanglingComments(path, options, true), line]
+                  : "",
               "}",
             ]
           : "",

package/src/util.mjs

@@ -612,6 +612,103 @@ function normalizeMagicMethodName(name) {
   return name;
 }
 
+/**
+ * @param {string[]} kindsArray
+ * @returns {(node: Node | Comment) => Boolean}
+ */
+function createTypeCheckFunction(kindsArray) {
+  const kinds = new Set(kindsArray);
+  return (node) => kinds.has(node?.kind);
+}
+
+const isSingleWordType = createTypeCheckFunction([
+  "variadicplaceholder",
+  "namedargument",
+  "nullkeyword",
+  "identifier",
+  "parameter",
+  "variable",
+  "variadic",
+  "boolean",
+  "literal",
+  "number",
+  "string",
+  "clone",
+  "cast",
+]);
+
+const isArrayExpression = createTypeCheckFunction(["array"]);
+const isCallLikeExpression = createTypeCheckFunction([
+  "nullsafepropertylookup",
+  "propertylookup",
+  "staticlookup",
+  "offsetlookup",
+  "call",
+  "new",
+]);
+const isArrowFuncExpression = createTypeCheckFunction(["arrowfunc"]);
+
+function getChainParts(node, prev = []) {
+  const parts = prev;
+  if (isCallLikeExpression(node)) {
+    parts.push(node);
+  }
+
+  if (!node.what) {
+    return parts;
+  }
+
+  return getChainParts(node.what, parts);
+}
+
+function isSimpleCallArgument(node, depth = 2) {
+  if (depth <= 0) {
+    return false;
+  }
+
+  const isChildSimple = (child) => isSimpleCallArgument(child, depth - 1);
+
+  if (isSingleWordType(node)) {
+    return true;
+  }
+
+  if (isArrayExpression(node)) {
+    return node.items.every((x) => x === null || isChildSimple(x));
+  }
+
+  if (isCallLikeExpression(node)) {
+    const parts = getChainParts(node);
+    parts.unshift();
+
+    return (
+      parts.length <= depth &&
+      parts.every((node) =>
+        isLookupNode(node)
+          ? isChildSimple(node.offset)
+          : node.arguments.every(isChildSimple)
+      )
+    );
+  }
+
+  if (isArrowFuncExpression(node)) {
+    return (
+      node.arguments.length <= depth && node.arguments.every(isChildSimple)
+    );
+  }
+
+  return false;
+}
+
+function memoize(fn) {
+  const cache = new Map();
+  return (key) => {
+    if (!cache.has(key)) {
+      cache.set(key, fn(key));
+    }
+    return cache.get(key);
+  };
+}
+
 export {
   printNumber,
   getPrecedence,
@@ -641,4 +738,6 @@ export {
   isDocNode,
   getAncestorNode,
   normalizeMagicMethodName,
+  isSimpleCallArgument,
+  memoize,
 };