prettier 0.18.0 → 0.20.0

data/src/nodes/case.js

@@ -42,7 +42,7 @@ module.exports = {
 
     // It's possible in a when to just have empty void statements, in which case
     // we would skip adding the body.
-    if (!stmts.parts.every(part => !part)) {
+    if (!stmts.parts.every((part) => !part)) {
       parts.push(indent(concat([hardline, stmts])));
     }
 

data/src/nodes/commands.js

@@ -1,7 +1,7 @@
 const { align, concat, group, ifBreak, join, line } = require("../prettier");
 const { docLength, makeArgs, makeCall } = require("../utils");
 
-const hasDef = node =>
+const hasDef = (node) =>
   node.body[1].type === "args_add_block" &&
   node.body[1].body[0].type === "args" &&
   node.body[1].body[0].body[0] &&
@@ -20,7 +20,7 @@ const hasDef = node =>
 //
 // In this case the arguments are aligned to the left side as opposed to being
 // aligned with the `receive` call.
-const skipArgsAlign = path =>
+const skipArgsAlign = (path) =>
   ["to", "not_to"].includes(path.getValue().body[2].body);
 
 module.exports = {

data/src/nodes/conditionals.js

@@ -23,7 +23,7 @@ const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
 // For the unary `not` operator, we need to explicitly add parentheses to it in
 // order for it to be valid from within a ternary. Otherwise if the clause of
 // the ternary isn't a unary `not`, we can just pass it along.
-const printTernaryClause = clause => {
+const printTernaryClause = (clause) => {
   if (clause.type === "concat") {
     const [part] = clause.parts;
 
@@ -78,7 +78,7 @@ const printTernary = (path, _opts, print) => {
 // Prints an `if_mod` or `unless_mod` node. Because it was previously in the
 // modifier form, we're guaranteed to not have an additional node, so we can
 // just work with the predicate and the body.
-const printSingle = keyword => (path, { inlineConditionals }, print) => {
+const printSingle = (keyword) => (path, { inlineConditionals }, print) => {
   const multiline = concat([
     `${keyword} `,
     align(keyword.length + 1, path.call(print, "body", 0)),
@@ -88,7 +88,8 @@ const printSingle = keyword => (path, { inlineConditionals }, print) => {
 
   const [_predicate, stmts] = path.getValue().body;
   const hasComments =
-    stmts.type === "stmts" && stmts.body.some(stmt => stmt.type === "@comment");
+    stmts.type === "stmts" &&
+    stmts.body.some((stmt) => stmt.type === "@comment");
 
   if (!inlineConditionals || hasComments) {
     return multiline;
@@ -152,7 +153,7 @@ const noTernary = [
 // Certain expressions cannot be reduced to a ternary without adding parens
 // around them. In this case we say they cannot be ternaried and default instead
 // to breaking them into multiple lines.
-const canTernaryStmts = stmts => {
+const canTernaryStmts = (stmts) => {
   if (stmts.body.length !== 1) {
     return false;
   }
@@ -175,10 +176,11 @@ const canTernaryStmts = stmts => {
 // is of the "else" type. Both the body of the main node and the body of the
 // 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 canTernary = (path) => {
+  const [predicate, stmts, addition] = path.getValue().body;
 
   return (
+    !["assign", "opassign"].includes(predicate.type) &&
     addition &&
     addition.type === "else" &&
     [stmts, addition.body[0]].every(canTernaryStmts)
@@ -186,7 +188,7 @@ const canTernary = path => {
 };
 
 // A normalized print function for both `if` and `unless` nodes.
-const printConditional = keyword => (path, { inlineConditionals }, print) => {
+const printConditional = (keyword) => (path, { inlineConditionals }, print) => {
   if (canTernary(path)) {
     let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
       printTernaryClauses(

data/src/nodes/hashes.js

@@ -12,7 +12,7 @@ const { prefix, skipAssignIndent } = require("../utils");
 const nodeDive = (node, steps) => {
   let current = node;
 
-  steps.forEach(step => {
+  steps.forEach((step) => {
     current = current[step];
   });
 
@@ -29,7 +29,7 @@ const nodeDive = (node, steps) => {
 //
 // This function represents that check, as it determines if it can convert the
 // symbol node into a hash label.
-const isValidHashLabel = symbolLiteral => {
+const isValidHashLabel = (symbolLiteral) => {
   const label = symbolLiteral.body[0].body[0].body;
   return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
 };

data/src/nodes/hooks.js

@@ -1,6 +1,6 @@
 const { concat, group, indent, line } = require("../prettier");
 
-const printHook = name => (path, opts, print) =>
+const printHook = (name) => (path, opts, print) =>
   group(
     concat([
       `${name} {`,

data/src/nodes/lambdas.js

@@ -21,7 +21,7 @@ module.exports = {
       paramsConcat = path.call(print, "body", 0, "body", 0);
     }
 
-    const noParams = params.body.every(type => !type);
+    const noParams = params.body.every((type) => !type);
     const inlineLambda = concat([
       "->",
       noParams ? "" : concat(["(", paramsConcat, ")"]),

data/src/nodes/methods.js

@@ -9,7 +9,7 @@ const {
 } = require("../prettier");
 const { first, literal } = require("../utils");
 
-const printMethod = offset => (path, opts, print) => {
+const printMethod = (offset) => (path, opts, print) => {
   const [_name, params, body] = path.getValue().body.slice(offset);
   const declaration = ["def "];
 
@@ -21,7 +21,7 @@ const printMethod = offset => (path, opts, print) => {
 
   // In case there are no parens but there are arguments
   const parens =
-    params.type === "params" && params.body.some(paramType => paramType);
+    params.type === "params" && params.body.some((paramType) => paramType);
 
   declaration.push(
     path.call(print, "body", offset),

data/src/nodes/operators.js

@@ -7,10 +7,18 @@ module.exports = {
 
     return group(
       concat([
-        concat([path.call(print, "body", 0), useNoSpace ? "" : " "]),
-        operator,
+        group(path.call(print, "body", 0)),
         indent(
-          concat([useNoSpace ? softline : line, path.call(print, "body", 2)])
+          concat([
+            useNoSpace ? "" : " ",
+            group(
+              concat([
+                operator,
+                useNoSpace ? softline : line,
+                path.call(print, "body", 2)
+              ])
+            )
+          ])
         )
       ])
     );

data/src/nodes/params.js

@@ -1,7 +1,7 @@
 const { concat, group, join, line } = require("../prettier");
 const { literal } = require("../utils");
 
-const printGenericRestParam = symbol => (path, opts, print) =>
+const printGenericRestParam = (symbol) => (path, opts, print) =>
   path.getValue().body[0]
     ? concat([symbol, path.call(print, "body", 0)])
     : symbol;

data/src/nodes/regexp.js

@@ -7,7 +7,7 @@ module.exports = {
     const [contents, ending] = path.map(print, "body");
 
     const useBraces = contents.some(
-      content => typeof content === "string" && content.includes("/")
+      (content) => typeof content === "string" && content.includes("/")
     );
     const parts = [useBraces ? "%r{" : "/"]
       .concat(contents)

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/nodes/return.js

@@ -9,6 +9,16 @@ const {
 } = require("../prettier");
 const { literal } = require("../utils");
 
+// You can't skip the parentheses if you have the `and` or `or` operator,
+// because they have low enough operator precedence that you need to explicitly
+// keep them in there.
+const canSkipParens = (args) => {
+  const statement = args.body[0].body[0].body[0];
+  return (
+    statement.type !== "binary" || !["and", "or"].includes(statement.body[1])
+  );
+};
+
 const printReturn = (path, opts, print) => {
   let args = path.getValue().body[0].body[0];
   let steps = ["body", 0, "body", 0];
@@ -20,7 +30,7 @@ const printReturn = (path, opts, print) => {
   // If the body of the return contains parens, then just skip directly to the
   // content of the parens so that we can skip printing parens if we don't
   // want them.
-  if (args.body[0] && args.body[0].type === "paren") {
+  if (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
     args = args.body[0].body[0];
     steps = steps.concat("body", 0, "body", 0);
   }

data/src/nodes/strings.js

@@ -15,18 +15,18 @@ const { concatBody, empty, makeList, prefix, surround } = require("../utils");
 // quote the user chose. (If they chose single quotes, then double quoting
 // would activate the escape sequence, and if they chose double quotes, then
 // single quotes would deactivate it.)
-const isQuoteLocked = string =>
+const isQuoteLocked = (string) =>
   string.body.some(
-    part =>
+    (part) =>
       part.type === "@tstring_content" &&
       (part.body.includes("#{") || part.body.includes("\\"))
   );
 
 // A string is considered to be able to use single quotes if it contains only
 // plain string content and that content does not contain a single quote.
-const isSingleQuotable = string =>
+const isSingleQuotable = (string) =>
   string.body.every(
-    part => part.type === "@tstring_content" && !part.body.includes("'")
+    (part) => part.type === "@tstring_content" && !part.body.includes("'")
   );
 
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
@@ -61,7 +61,7 @@ const quotePairs = {
   "<": ">"
 };
 
-const getClosingQuote = quote => {
+const getClosingQuote = (quote) => {
   if (!quote.startsWith("%")) {
     return quote;
   }

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/prettier.js

@@ -3,7 +3,6 @@
 // directly, as it's been shipped with the gem.
 const source = process.env.RBPRETTIER ? "../node_modules/prettier" : "prettier";
 
-// eslint-disable-next-line import/no-dynamic-require
 const prettier = require(source);
 
 // Just combine all the things into one big object so that we can import

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,13 +1,14 @@
+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);
+const hasPragma = (text) => pragmaPattern.test(text);
 
-const locStart = node => node.char_start;
-const locEnd = node => node.char_end;
+const locStart = (node) => node.char_start;
+const locEnd = (node) => node.char_end;
 
 /*
  * metadata mostly pulled from linguist and rubocop:
@@ -49,6 +50,7 @@ module.exports = {
       filenames: [
         ".irbrc",
         ".pryrc",
+        ".simplecov",
         "Appraisals",
         "Berksfile",
         "Brewfile",
@@ -78,7 +80,8 @@ module.exports = {
     {
       name: "HAML",
       parsers: ["haml"],
-      extensions: [".haml"]
+      extensions: [".haml"],
+      vscodeLanguageIds: ["haml"]
     }
   ],
   parsers: {
@@ -99,6 +102,7 @@ module.exports = {
   },
   printers: {
     ruby: {
+      embed,
       print
     },
     haml: {
@@ -141,6 +145,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

@@ -1,4 +1,4 @@
-const isCall = node => ["::", "."].includes(node) || node.type === "@period";
+const isCall = (node) => ["::", "."].includes(node) || node.type === "@period";
 
 // If you have a simple block that only calls a method on the single required
 // parameter that is passed to it, then you can replace that block with the
@@ -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}`;
 };
 

data/src/utils.js

@@ -10,11 +10,11 @@ const concatBody = (path, opts, print) => concat(path.map(print, "body"));
 
 // If the node is a type of assignment or if the node is a paren and nested
 // inside that paren is a node that is a type of assignment.
-const containsAssignment = node =>
+const containsAssignment = (node) =>
   ["assign", "massign"].includes(node.type) ||
   (node.type === "paren" && node.body[0].body.some(containsAssignment));
 
-const docLength = doc => {
+const docLength = (doc) => {
   if (doc.length) {
     return doc.length;
   }
@@ -50,7 +50,7 @@ const hasAncestor = (path, types) => {
   return false;
 };
 
-const literal = value => () => value;
+const literal = (value) => () => value;
 
 const makeArgs = (path, opts, print, argsIndex) => {
   let argNodes = path.getValue().body[argsIndex];
@@ -103,13 +103,13 @@ const makeCall = (path, opts, print) => {
 
 const makeList = (path, opts, print) => path.map(print, "body");
 
-const prefix = value => (path, opts, print) =>
+const prefix = (value) => (path, opts, print) =>
   concat([value, path.call(print, "body", 0)]);
 
 const printComments = (printed, start, comments) => {
   let node = printed;
 
-  comments.forEach(comment => {
+  comments.forEach((comment) => {
     if (comment.start < start) {
       node = concat([
         comment.break ? breakParent : "",
@@ -129,7 +129,7 @@ const printComments = (printed, start, comments) => {
   return node;
 };
 
-const skipAssignIndent = node =>
+const skipAssignIndent = (node) =>
   ["array", "hash", "heredoc", "lambda", "regexp_literal"].includes(
     node.type
   ) ||