prettier 0.18.1 → 0.20.1

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.18.1",
+  "version": "0.20.1",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
@@ -23,9 +23,11 @@
   },
   "devDependencies": {
     "all-contributors-cli": "^6.14.1",
-    "eslint": "^6.8.0",
+    "eslint": "^7.8.1",
     "eslint-config-prettier": "^6.10.1",
-    "jest": "^25.2.7"
+    "husky": "^4.2.5",
+    "jest": "^26.0.0",
+    "pretty-quick": "^3.0.0"
   },
   "eslintConfig": {
     "extends": [
@@ -53,6 +55,11 @@
     ],
     "testRegex": ".test.js$"
   },
+  "husky": {
+    "hooks": {
+      "pre-commit": "pretty-quick --staged"
+    }
+  },
   "prettier": {
     "trailingComma": "none"
   }

data/src/embed.js

@@ -0,0 +1,71 @@
+const {
+  concat,
+  indent,
+  literalline,
+  mapDoc,
+  markAsRoot,
+  stripTrailingHardline
+} = require("./prettier");
+
+const parsers = {
+  css: "css",
+  javascript: "babel",
+  js: "babel",
+  less: "less",
+  markdown: "markdown",
+  ruby: "ruby",
+  scss: "scss"
+};
+
+const replaceNewlines = (doc) =>
+  mapDoc(doc, (currentDoc) =>
+    typeof currentDoc === "string" && currentDoc.includes("\n")
+      ? concat(
+          currentDoc
+            .split(/(\n)/g)
+            .map((v, i) => (i % 2 === 0 ? v : literalline))
+        )
+      : currentDoc
+  );
+
+const embed = (path, _print, textToDoc, _opts) => {
+  const node = path.getValue();
+
+  // Currently we only support embedded formatting on heredoc nodes
+  if (node.type !== "heredoc") {
+    return null;
+  }
+
+  // First, ensure that we don't have any interpolation
+  const { beging, body, ending } = node;
+  if (body.some((part) => part.type !== "@tstring_content")) {
+    return null;
+  }
+
+  // Next, find the parser associated with this heredoc (if there is one). For
+  // example, if you use <<~CSS, we'd hook it up to the css parser.
+  const parser = parsers[beging.slice(3).toLowerCase()];
+  if (!parser) {
+    return null;
+  }
+
+  // Get the content as if it were a source string, and then pass that content
+  // into the embedded parser. Get back the doc node.
+  const content = body.map((part) => part.body).join("");
+  const formatted = concat([
+    literalline,
+    replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
+  ]);
+
+  // If we're using a squiggly heredoc, then we can properly handle indentation
+  // ourselves.
+  if (beging[2] === "~") {
+    return concat([beging, indent(markAsRoot(formatted)), literalline, ending]);
+  }
+
+  // Otherwise, we need to just assume it's formatted correctly and return the
+  // content as it is.
+  return markAsRoot(concat([beging, formatted, literalline, ending]));
+};
+
+module.exports = embed;

data/src/nodes/args.js

@@ -72,7 +72,7 @@ module.exports = {
       return blockNode;
     });
 
-    const proc = blockNode && toProc(blockNode);
+    const proc = blockNode && toProc(path, opts, blockNode);
 
     // If we have a successful to_proc transformation, but we're part of an aref
     // node, that means it's something to the effect of

data/src/nodes/arrays.js

@@ -9,13 +9,17 @@ const {
   softline
 } = require("../prettier");
 
+const preserveArraySubstrings = [" ", "\\"];
+
 const isStringArray = (args) =>
   args.body.every(
     (arg) =>
       arg.type === "string_literal" &&
       arg.body[0].body.length === 1 &&
       arg.body[0].body[0].type === "@tstring_content" &&
-      !arg.body[0].body[0].body.includes(" ")
+      !preserveArraySubstrings.some((str) =>
+        arg.body[0].body[0].body.includes(str)
+      )
   );
 
 const isSymbolArray = (args) =>

data/src/nodes/calls.js

@@ -1,4 +1,4 @@
-const { concat, group, indent, hardline, softline } = require("../prettier");
+const { concat, group, indent, literalline, softline } = require("../prettier");
 const toProc = require("../toProc");
 const { concatBody, first, makeCall } = require("../utils");
 
@@ -42,7 +42,7 @@ module.exports = {
         heredoc.beging,
         printedOperator,
         printedMessage,
-        hardline,
+        literalline,
         concat(path.map.apply(path, [print].concat(heredoc.content))),
         heredoc.ending
       ]);
@@ -76,7 +76,7 @@ module.exports = {
   },
   method_add_block: (path, opts, print) => {
     const [method, block] = path.getValue().body;
-    const proc = toProc(block);
+    const proc = toProc(path, opts, block);
 
     if (proc && method.type === "call") {
       return group(

data/src/nodes/conditionals.js

@@ -177,9 +177,10 @@ const canTernaryStmts = (stmts) => {
 // additional node must have only one statement, and that statement list must
 // pass the `canTernaryStmts` check.
 const canTernary = (path) => {
-  const [_pred, stmts, addition] = path.getValue().body;
+  const [predicate, stmts, addition] = path.getValue().body;
 
   return (
+    !["assign", "opassign"].includes(predicate.type) &&
     addition &&
     addition.type === "else" &&
     [stmts, addition.body[0]].every(canTernaryStmts)

data/src/nodes/rescue.js

@@ -53,7 +53,11 @@ module.exports = {
       parts.push(" StandardError");
     }
 
-    parts.push(indent(concat([hardline, path.call(print, "body", 2)])));
+    const rescueBody = path.call(print, "body", 2);
+
+    if (rescueBody.parts.length > 0) {
+      parts.push(indent(concat([hardline, rescueBody])));
+    }
 
     // This is the next clause on the `begin` statement, either another
     // `rescue`, and `ensure`, or an `else` clause.

data/src/parse.js

@@ -1,11 +1,27 @@
 const { spawnSync } = require("child_process");
 const path = require("path");
 
+// In order to properly parse ruby code, we need to tell the ruby process to
+// parse using UTF-8. Unfortunately, the way that you accomplish this looks
+// differently depending on your platform. This object below represents all of
+// the possible values of process.platform per:
+//   https://nodejs.org/api/process.html#process_process_platform
+const LANG = {
+  aix: "C.UTF-8",
+  darwin: "en_US.UTF-8",
+  freebsd: "C.UTF-8",
+  linux: "C.UTF-8",
+  openbsd: "C.UTF-8",
+  sunos: "C.UTF-8",
+  win32: ".UTF-8"
+}[process.platform];
+
 module.exports = (text, _parsers, _opts) => {
   const child = spawnSync(
     "ruby",
     ["--disable-gems", path.join(__dirname, "./ripper.rb")],
     {
+      env: Object.assign({}, process.env, { LANG }),
       input: text,
       maxBuffer: 10 * 1024 * 1024 // 10MB
     }

data/src/ripper.rb

@@ -3,10 +3,11 @@
 # We implement our own version checking here instead of using Gem::Version so
 # that we can use the --disable-gems flag.
 major, minor, * = RUBY_VERSION.split('.').map(&:to_i)
+
 if (major < 2) || ((major == 2) && (minor < 5))
   warn(
-    "Ruby version #{current_version} not supported. " \
-      "Please upgrade to #{required_version} or above."
+    "Ruby version #{RUBY_VERSION} not supported. " \
+      'Please upgrade to 2.5.0 or above.'
   )
 
   exit 1

data/src/ruby.js

@@ -1,8 +1,7 @@
+const embed = require("./embed");
 const parse = require("./parse");
 const print = require("./print");
 
-const haml = require("./haml");
-
 const pragmaPattern = /#\s*@(prettier|format)/;
 const hasPragma = (text) => pragmaPattern.test(text);
 
@@ -49,6 +48,7 @@ module.exports = {
       filenames: [
         ".irbrc",
         ".pryrc",
+        ".simplecov",
         "Appraisals",
         "Berksfile",
         "Brewfile",
@@ -74,11 +74,6 @@ module.exports = {
       interpreters: ["jruby", "macruby", "rake", "rbx", "ruby"],
       linguistLanguageId: 326,
       vscodeLanguageIds: ["ruby"]
-    },
-    {
-      name: "HAML",
-      parsers: ["haml"],
-      extensions: [".haml"]
     }
   ],
   parsers: {
@@ -88,22 +83,12 @@ module.exports = {
       hasPragma,
       locStart,
       locEnd
-    },
-    haml: {
-      parse: haml.parse,
-      astFormat: "haml",
-      hasPragma: haml.hasPragma,
-      locStart: haml.locStart,
-      locEnd: haml.locEnd
     }
   },
   printers: {
     ruby: {
+      embed,
       print
-    },
-    haml: {
-      embed: haml.embed,
-      print: haml.print
     }
   },
   options: {
@@ -141,6 +126,13 @@ module.exports = {
       default: true,
       description:
         "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals."
+    },
+    toProcTransform: {
+      type: "boolean",
+      category: "Global",
+      default: true,
+      description:
+        "When possible, convert blocks to the more concise Symbol#to_proc syntax."
     }
   },
   defaultOptions: {

data/src/toProc.js

@@ -11,8 +11,8 @@ const isCall = (node) => ["::", "."].includes(node) || node.type === "@period";
 //     [1, 2, 3].map(&:to_s)
 //
 // This works with `do` blocks as well.
-const toProc = (node) => {
-  if (!node) {
+const toProc = (path, opts, node) => {
+  if (!node || !opts.toProcTransform) {
     return null;
   }
 
@@ -76,6 +76,33 @@ const toProc = (node) => {
     return null;
   }
 
+  // Ensure that we're not inside of a hash that is being passed to a key that
+  // corresponds to `:if` or `:unless` to avoid problems with callbacks with
+  // Rails. For more context, see:
+  // https://github.com/prettier/plugin-ruby/issues/449
+  let assocNode = null;
+
+  if (path.getValue().type === "method_add_block") {
+    assocNode = path.getParentNode();
+  } else if (path.getValue().type === "args") {
+    assocNode = path.getParentNode(2);
+  }
+
+  if (assocNode && assocNode.type === "assoc_new") {
+    const [key] = assocNode.body;
+
+    if (key.type === "@label" && ["if:", "unless:"].includes(key.body)) {
+      return null;
+    }
+
+    if (
+      key.type === "symbol_literal" &&
+      ["if", "unless"].includes(key.body[0].body[0].body)
+    ) {
+      return null;
+    }
+  }
+
   return `&:${method.body}`;
 };
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.20.1
 platform: ruby
 authors:
 - Kevin Deisz
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-04-05 00:00:00.000000000 Z
+date: 2020-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,8 +52,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: 
-email: 
+description:
+email:
 executables:
 - rbprettier
 extensions: []
@@ -72,18 +72,7 @@ files:
 - node_modules/prettier/index.js
 - node_modules/prettier/third-party.js
 - package.json
-- src/haml.js
-- src/haml/embed.js
-- src/haml/nodes/comment.js
-- src/haml/nodes/doctype.js
-- src/haml/nodes/filter.js
-- src/haml/nodes/hamlComment.js
-- src/haml/nodes/script.js
-- src/haml/nodes/silentScript.js
-- src/haml/nodes/tag.js
-- src/haml/parse.js
-- src/haml/parse.rb
-- src/haml/print.js
+- src/embed.js
 - src/nodes.js
 - src/nodes/alias.js
 - src/nodes/args.js
@@ -123,7 +112,7 @@ homepage: https://github.com/prettier/plugin-ruby#readme
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -138,8 +127,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language
 test_files: []

data/src/haml.js

@@ -1,21 +0,0 @@
-const embed = require("./haml/embed");
-const parse = require("./haml/parse");
-const print = require("./haml/print");
-
-const pragmaPattern = /^\s*-#\s*@(prettier|format)/;
-const hasPragma = (text) => pragmaPattern.test(text);
-
-// These functions are just placeholders until we can actually perform this
-// properly. The functions are necessary otherwise the format with cursor
-// functions break.
-const locStart = (_node) => 0;
-const locEnd = (_node) => 0;
-
-module.exports = {
-  embed,
-  hasPragma,
-  locStart,
-  locEnd,
-  parse,
-  print
-};

data/src/haml/embed.js

@@ -1,58 +0,0 @@
-const {
-  concat,
-  hardline,
-  indent,
-  literalline,
-  mapDoc,
-  markAsRoot,
-  stripTrailingHardline
-} = require("../prettier");
-
-const parsers = {
-  css: "css",
-  javascript: "babel",
-  less: "less",
-  markdown: "markdown",
-  ruby: "ruby",
-  scss: "scss"
-};
-
-const replaceNewlines = (doc) =>
-  mapDoc(doc, (currentDoc) =>
-    typeof currentDoc === "string" && currentDoc.includes("\n")
-      ? concat(
-          currentDoc
-            .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : literalline))
-        )
-      : currentDoc
-  );
-
-const embed = (path, print, textToDoc, _opts) => {
-  const node = path.getValue();
-  if (node.type !== "filter") {
-    return null;
-  }
-
-  const parser = parsers[node.value.name];
-  if (!parser) {
-    return null;
-  }
-
-  return markAsRoot(
-    concat([
-      ":",
-      node.value.name,
-      indent(
-        concat([
-          hardline,
-          replaceNewlines(
-            stripTrailingHardline(textToDoc(node.value.text, { parser }))
-          )
-        ])
-      )
-    ])
-  );
-};
-
-module.exports = embed;