prettier 0.18.0 → 0.18.1

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
@@ -22,17 +22,38 @@
     "prettier": ">=1.10"
   },
   "devDependencies": {
-    "all-contributors-cli": "^6.12.0",
+    "all-contributors-cli": "^6.14.1",
     "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"
+    "eslint-config-prettier": "^6.10.1",
+    "jest": "^25.2.7"
+  },
+  "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$"
+  },
+  "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/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 &&

data/src/nodes/arrays.js

@@ -9,19 +9,19 @@ const {
   softline
 } = require("../prettier");
 
-const isStringArray = args =>
+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(" ")
   );
 
-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 +44,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, hardline, 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,
+        hardline,
+        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,

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,7 +176,7 @@ 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 canTernary = (path) => {
   const [_pred, stmts, addition] = path.getValue().body;
 
   return (
@@ -186,7 +187,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} {`,