prettier 0.18.0 → 0.20.0

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "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.12.0",
-    "eslint": "^6.8.0",
-    "eslint-config-airbnb-base": "^14.0.0",
-    "eslint-config-prettier": "^6.9.0",
-    "eslint-plugin-import": "^2.20.0",
-    "jest": "^25.1.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/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/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/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));
   });
 
@@ -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,7 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'json'
-
 require 'bundler/setup' if ENV['CI']
 require 'haml'
 
@@ -48,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

@@ -62,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 &&
@@ -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,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

@@ -10,7 +10,7 @@ const {
 } = require("../prettier");
 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,7 +74,7 @@ module.exports = {
     parts.push("| ");
     return concat(parts);
   },
-  brace_block: printBlock,
-  do_block: printBlock,
+  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, group(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(