prettier 0.17.0 → 0.19.1

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.17.0",
+  "version": "0.19.1",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
@@ -22,17 +22,45 @@
     "prettier": ">=1.10"
   },
   "devDependencies": {
-    "all-contributors-cli": "^6.1.2",
-    "eslint": "^6.0.1",
-    "eslint-config-airbnb-base": "^14.0.0",
-    "eslint-config-prettier": "^6.0.0",
-    "eslint-plugin-import": "^2.16.0",
-    "jest": "^24.0.0"
+    "all-contributors-cli": "^6.14.1",
+    "eslint": "^7.1.0",
+    "eslint-config-prettier": "^6.10.1",
+    "husky": "^4.2.5",
+    "jest": "^26.0.0",
+    "pretty-quick": "^3.0.0"
+  },
+  "eslintConfig": {
+    "extends": [
+      "eslint:recommended",
+      "prettier"
+    ],
+    "env": {
+      "es6": true,
+      "jest": true,
+      "node": true
+    },
+    "rules": {
+      "no-unused-vars": [
+        "error",
+        {
+          "argsIgnorePattern": "^_",
+          "varsIgnorePattern": "^_"
+        }
+      ]
+    }
   },
   "jest": {
     "setupFilesAfterEnv": [
       "./test/js/setupTests.js"
     ],
     "testRegex": ".test.js$"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "pretty-quick --staged"
+    }
+  },
+  "prettier": {
+    "trailingComma": "none"
   }
 }

data/src/haml.js

@@ -3,13 +3,13 @@ const parse = require("./haml/parse");
 const print = require("./haml/print");
 
 const pragmaPattern = /^\s*-#\s*@(prettier|format)/;
-const hasPragma = text => pragmaPattern.test(text);
+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;
+const locStart = (_node) => 0;
+const locEnd = (_node) => 0;
 
 module.exports = {
   embed,

data/src/haml/embed.js

@@ -17,8 +17,8 @@ const parsers = {
   scss: "scss"
 };
 
-const replaceNewlines = doc =>
-  mapDoc(doc, currentDoc =>
+const replaceNewlines = (doc) =>
+  mapDoc(doc, (currentDoc) =>
     typeof currentDoc === "string" && currentDoc.includes("\n")
       ? concat(
           currentDoc

data/src/haml/nodes/silentScript.js

@@ -1,5 +1,21 @@
 const { concat, group, hardline, indent, join } = require("../../prettier");
 
+const findKeywordIndices = (children, keywords) => {
+  const indices = [];
+
+  children.forEach((child, index) => {
+    if (child.type !== "silent_script") {
+      return;
+    }
+
+    if (keywords.includes(child.value.keyword)) {
+      indices.push(index);
+    }
+  });
+
+  return indices;
+};
+
 // http://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
 const silentScript = (path, opts, print) => {
   const { children, value } = path.getValue();
@@ -9,13 +25,26 @@ const silentScript = (path, opts, print) => {
     const scripts = path.map(print, "children");
 
     if (value.keyword === "case") {
+      const keywordIndices = findKeywordIndices(children, ["when", "else"]);
+
+      parts.push(
+        concat(
+          scripts.map((script, index) => {
+            const concated = concat([hardline, script]);
+
+            return keywordIndices.includes(index) ? concated : indent(concated);
+          })
+        )
+      );
+    } else if (["if", "unless"].includes(value.keyword)) {
+      const keywordIndices = findKeywordIndices(children, ["elsif", "else"]);
+
       parts.push(
-        join(
-          "",
+        concat(
           scripts.map((script, index) => {
             const concated = concat([hardline, script]);
 
-            return index % 2 === 0 ? concated : indent(concated);
+            return keywordIndices.includes(index) ? concated : indent(concated);
           })
         )
       );

data/src/haml/nodes/tag.js

@@ -4,6 +4,7 @@ const {
   fill,
   group,
   hardline,
+  ifBreak,
   indent,
   join,
   line,
@@ -14,10 +15,10 @@ const getDynamicAttributes = (header, attributes) => {
   const pairs = attributes
     .slice(1, -2)
     .split(",")
-    .map(pair => pair.slice(1).split('" => '));
+    .map((pair) => pair.slice(1).split('" => '));
   const parts = [concat([pairs[0][0], "=", pairs[0][1]])];
 
-  pairs.slice(1).forEach(pair => {
+  pairs.slice(1).forEach((pair) => {
     parts.push(line, concat([pair[0], "=", pair[1]]));
   });
 
@@ -49,13 +50,13 @@ const getHashLabel = (key, value, opts) => {
 
 const getStaticAttributes = (header, attributes, opts) => {
   const keys = Object.keys(attributes).filter(
-    name => !["class", "id"].includes(name)
+    (name) => !["class", "id"].includes(name)
   );
 
   const getKeyValuePair = opts.preferHashLabels ? getHashLabel : getHashRocket;
   const parts = [getKeyValuePair(keys[0], attributes[keys[0]], opts)];
 
-  keys.slice(1).forEach(key => {
+  keys.slice(1).forEach((key) => {
     parts.push(",", line, getKeyValuePair(key, attributes[key], opts));
   });
 
@@ -71,7 +72,7 @@ const getHeader = (value, opts) => {
   }
 
   if (attributes.class) {
-    parts.push(`.${attributes.class.replace(" ", ".")}`);
+    parts.push(`.${attributes.class.replace(/ /g, ".")}`);
   }
 
   if (attributes.id) {
@@ -84,11 +85,16 @@ const getHeader = (value, opts) => {
     );
   }
 
-  if (Object.keys(attributes).some(name => name !== "class" && name !== "id")) {
+  if (
+    Object.keys(attributes).some((name) => name !== "class" && name !== "id")
+  ) {
     parts.push(getStaticAttributes(parts.join("").length, attributes, opts));
   }
 
   if (value.dynamic_attributes.old) {
+    if (parts.length === 0) {
+      parts.push("%div");
+    }
     parts.push(value.dynamic_attributes.old);
   }
 
@@ -112,12 +118,12 @@ const getHeader = (value, opts) => {
   }
 
   if (value.value) {
-    const prefix = value.parse ? "=" : "";
+    const prefix = value.parse ? "= " : ifBreak("", " ");
 
     return group(
       concat([
         group(concat(parts)),
-        indent(concat([softline, `${prefix} ${value.value}`]))
+        indent(concat([softline, prefix, value.value]))
       ])
     );
   }

data/src/haml/parse.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'json'
+require 'bundler/setup' if ENV['CI']
 require 'haml'
 
 class Haml::Parser::ParseNode
@@ -46,18 +46,17 @@ class Haml::Parser::ParseNode
       raise ArgumentError, "Unsupported type: #{type}"
     end
   end
-
-  def self.to_json(template)
-    parser = Haml::Parser.new({})
-    JSON.fast_generate(parser.call(template).as_json)
-  end
 end
 
 # If this is the main file we're executing, then most likely this is being
 # executed from the haml.js spawn. In that case, read the ruby source from
 # stdin and report back the AST over stdout.
-
 if $0 == __FILE__
+  # Don't explicitly require JSON if there is already as JSON loaded, as this
+  # can lead to all kinds of trouble where one version of it was already
+  # "activated" by rubygems.
+  require 'json' unless defined?(JSON)
+
   parser = Haml::Parser.new({})
   template = $stdin.read
 

data/src/nodes/alias.js

@@ -1,7 +1,7 @@
 const { concat, join } = require("../prettier");
 
-const usingSymbols = path => {
-  const [left, right] = path.getValue().body.map(node => node.body[0].type);
+const usingSymbols = (path) => {
+  const [left, right] = path.getValue().body.map((node) => node.body[0].type);
   return left === "symbol" && right === "symbol";
 };
 

data/src/nodes/args.js

@@ -17,6 +17,13 @@ module.exports = {
       return "";
     }
 
+    // Here we can skip the entire rest of the method by just checking if it's
+    // an args_forward node, as we're guaranteed that there are no other arg
+    // nodes.
+    if (path.getValue().body[0].type === "args_forward") {
+      return "(...)";
+    }
+
     const { addTrailingCommas } = opts;
     const { args, heredocs } = makeArgs(path, opts, print, 0);
 
@@ -55,7 +62,7 @@ module.exports = {
     // method_add_block node, and if they are that that node has a block
     // associated with it. If it does, we're going to attempt to transform it
     // into the to_proc shorthand and add it to the list of arguments.
-    [1, 2, 3].find(parent => {
+    [1, 2, 3].find((parent) => {
       const parentNode = path.getParentNode(parent);
       blockNode =
         parentNode &&
@@ -65,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,19 +9,23 @@ const {
   softline
 } = require("../prettier");
 
-const isStringArray = args =>
+const preserveArraySubstrings = [" ", "\\"];
+
+const isStringArray = (args) =>
   args.body.every(
-    arg =>
+    (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 =>
-  args.body.every(arg => arg.type === "symbol_literal");
+const isSymbolArray = (args) =>
+  args.body.every((arg) => arg.type === "symbol_literal");
 
-const makeArray = start => (path, opts, print) =>
+const makeArray = (start) => (path, opts, print) =>
   [start].concat(path.map(print, "body"));
 
 const getSpecialArrayParts = (path, print, args) =>
@@ -44,7 +48,7 @@ const printAref = (path, opts, print) =>
     ])
   );
 
-const printSpecialArray = parts =>
+const printSpecialArray = (parts) =>
   group(
     concat([
       parts[0],

data/src/nodes/blocks.js

@@ -8,9 +8,9 @@ const {
   removeLines,
   softline
 } = require("../prettier");
-const { empty, first, hasAncestor } = require("../utils");
+const { empty, hasAncestor } = require("../utils");
 
-const printBlock = (path, opts, print) => {
+const printBlock = (braces) => (path, opts, print) => {
   const [variables, statements] = path.getValue().body;
   const stmts =
     statements.type === "stmts" ? statements.body : statements.body[0].body;
@@ -25,7 +25,7 @@ const printBlock = (path, opts, print) => {
   // as opposed to the current node (because of the difference in operator
   // precedence). Instead, we still use a multi-line format but switch to using
   // braces instead.
-  const useBraces = hasAncestor(path, ["command", "command_call"]);
+  const useBraces = braces && hasAncestor(path, ["command", "command_call"]);
 
   const doBlock = concat([
     useBraces ? " {" : " do",
@@ -38,7 +38,7 @@ const printBlock = (path, opts, print) => {
   // comment.
   if (
     stmts.length > 1 &&
-    stmts.filter(stmt => stmt.type !== "@comment").length === 1
+    stmts.filter((stmt) => stmt.type !== "@comment").length === 1
   ) {
     return concat([breakParent, doBlock]);
   }
@@ -74,8 +74,7 @@ module.exports = {
     parts.push("| ");
     return concat(parts);
   },
-  brace_block: printBlock,
-  do_block: printBlock,
-  excessed_comma: empty,
-  number_arg: first
+  brace_block: printBlock(true),
+  do_block: printBlock(false),
+  excessed_comma: empty
 };

data/src/nodes/calls.js

@@ -1,29 +1,64 @@
-const { concat, group, indent, softline } = require("../prettier");
+const { concat, group, indent, literalline, softline } = require("../prettier");
 const toProc = require("../toProc");
 const { concatBody, first, makeCall } = require("../utils");
 
 const noIndent = ["array", "hash", "if", "method_add_block", "xstring_literal"];
 
+const getHeredoc = (path, print, node) => {
+  if (node.type === "heredoc") {
+    const { beging, ending } = node;
+    return { beging, ending, content: ["body", 0, "body"] };
+  }
+
+  if (node.type === "string_literal" && node.body[0].type === "heredoc") {
+    const { beging, ending } = node.body[0];
+    return { beging, ending, content: ["body", 0, "body", 0, "body"] };
+  }
+
+  return null;
+};
+
 module.exports = {
   call: (path, opts, print) => {
-    const receiver = path.call(print, "body", 0);
-    const operator = makeCall(path, opts, print);
-    let name = path.getValue().body[2];
+    const [receiverNode, _operatorNode, messageNode] = path.getValue().body;
+
+    const printedReceiver = path.call(print, "body", 0);
+    const printedOperator = makeCall(path, opts, print);
 
     // You can call lambdas with a special syntax that looks like func.(*args).
     // In this case, "call" is returned for the 3rd child node.
-    if (name !== "call") {
-      name = path.call(print, "body", 2);
+    const printedMessage =
+      messageNode === "call" ? messageNode : path.call(print, "body", 2);
+
+    // If we have a heredoc as a receiver, then we need to move the operator and
+    // the message up to start of the heredoc declaration, as in:
+    //
+    //     <<~TEXT.strip
+    //       content
+    //     TEXT
+    const heredoc = getHeredoc(path, print, receiverNode);
+    if (heredoc) {
+      return concat([
+        heredoc.beging,
+        printedOperator,
+        printedMessage,
+        literalline,
+        concat(path.map.apply(path, [print].concat(heredoc.content))),
+        heredoc.ending
+      ]);
     }
 
     // For certain left sides of the call nodes, we want to attach directly to
     // the } or end.
-    if (noIndent.includes(path.getValue().body[0].type)) {
-      return concat([receiver, operator, name]);
+    if (noIndent.includes(receiverNode.type)) {
+      return concat([printedReceiver, printedOperator, printedMessage]);
     }
 
     return group(
-      concat([receiver, indent(concat([softline, operator, name]))])
+      concat([
+        printedReceiver,
+        group(indent(concat([softline, printedOperator, printedMessage])))
+      ])
     );
   },
   fcall: concatBody,
@@ -41,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(