prettier 0.12.2 → 0.12.3

data/src/nodes/alias.js

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

data/src/nodes/args.js

@@ -0,0 +1,88 @@
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line,
+  softline
+} = require("../prettier");
+
+const toProc = require("../toProc");
+const { makeArgs } = require("../utils");
+
+module.exports = {
+  arg_paren: (path, opts, print) => {
+    if (path.getValue().body[0] === null) {
+      return "";
+    }
+
+    const { addTrailingCommas } = opts;
+    const { args, heredocs } = makeArgs(path, opts, print, 0);
+
+    const argsNode = path.getValue().body[0];
+    const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
+
+    if (heredocs.length > 1) {
+      return concat(["(", join(", ", args), ")"].concat(heredocs));
+    }
+
+    const parenDoc = group(
+      concat([
+        "(",
+        indent(
+          concat([
+            softline,
+            join(concat([",", line]), args),
+            addTrailingCommas && !hasBlock ? ifBreak(",", "") : ""
+          ])
+        ),
+        concat([softline, ")"])
+      ])
+    );
+
+    if (heredocs.length === 1) {
+      return group(concat([parenDoc].concat(heredocs)));
+    }
+
+    return parenDoc;
+  },
+  args: (path, opts, print) => {
+    const args = path.map(print, "body");
+    let blockNode = null;
+
+    [1, 2, 3].find(parent => {
+      const parentNode = path.getParentNode(parent);
+      blockNode =
+        parentNode &&
+        parentNode.type === "method_add_block" &&
+        parentNode.body[1];
+      return blockNode;
+    });
+
+    const proc = blockNode && toProc(blockNode);
+    if (proc) {
+      args.push(proc);
+    }
+
+    return args;
+  },
+  args_add_block: (path, opts, print) => {
+    const parts = path.call(print, "body", 0);
+
+    if (path.getValue().body[1]) {
+      parts.push(concat(["&", path.call(print, "body", 1)]));
+    }
+
+    return parts;
+  },
+  args_add_star: (path, opts, print) => {
+    const printed = path.map(print, "body");
+    const parts = printed[0]
+      .concat([concat(["*", printed[1]])])
+      .concat(printed.slice(2));
+
+    return parts;
+  },
+  blockarg: (path, opts, print) => concat(["&", path.call(print, "body", 0)])
+};

data/src/nodes/arrays.js

@@ -7,7 +7,7 @@ const {
   line,
   literalline,
   softline
-} = require("../builders");
+} = require("../prettier");
 
 const isStringArray = args =>
   args.body.every(

data/src/nodes/assign.js

@@ -0,0 +1,39 @@
+const { concat, group, indent, join, line } = require("../prettier");
+const { concatBody, first, skipAssignIndent } = require("../utils");
+
+module.exports = {
+  assign: (path, opts, print) => {
+    const [printedTarget, printedValue] = path.map(print, "body");
+    let adjustedValue = printedValue;
+
+    if (
+      ["mrhs_add_star", "mrhs_new_from_args"].includes(
+        path.getValue().body[1].type
+      )
+    ) {
+      adjustedValue = group(join(concat([",", line]), printedValue));
+    }
+
+    if (skipAssignIndent(path.getValue().body[1])) {
+      return group(concat([printedTarget, " = ", adjustedValue]));
+    }
+
+    return group(
+      concat([printedTarget, " =", indent(concat([line, adjustedValue]))])
+    );
+  },
+  assign_error: (_path, _opts, _print) => {
+    throw new Error("Can't set variable");
+  },
+  opassign: (path, opts, print) =>
+    group(
+      concat([
+        path.call(print, "body", 0),
+        " ",
+        path.call(print, "body", 1),
+        indent(concat([line, path.call(print, "body", 2)]))
+      ])
+    ),
+  var_field: concatBody,
+  var_ref: first
+};

data/src/nodes/blocks.js

@@ -4,9 +4,11 @@ const {
   group,
   ifBreak,
   indent,
+  join,
+  removeLines,
   softline
-} = require("../builders");
-const { hasAncestor } = require("../utils");
+} = require("../prettier");
+const { empty, first, hasAncestor } = require("../utils");
 
 const printBlock = (path, opts, print) => {
   const [variables, statements] = path.getValue().body;
@@ -61,6 +63,19 @@ const printBlock = (path, opts, print) => {
 };
 
 module.exports = {
+  block_var: (path, opts, print) => {
+    const parts = ["|", removeLines(path.call(print, "body", 0))];
+
+    // The second part of this node is a list of optional block-local variables
+    if (path.getValue().body[1]) {
+      parts.push("; ", join(", ", path.map(print, "body", 1)));
+    }
+
+    parts.push("| ");
+    return concat(parts);
+  },
   brace_block: printBlock,
-  do_block: printBlock
+  do_block: printBlock,
+  excessed_comma: empty,
+  number_arg: first
 };

data/src/nodes/calls.js

@@ -1,5 +1,6 @@
-const { concat, group, indent, softline } = require("../builders");
-const { makeCall } = require("../utils");
+const { concat, group, indent, softline } = require("../prettier");
+const toProc = require("../toProc");
+const { concatBody, first, makeCall } = require("../utils");
 
 const noIndent = ["array", "hash", "method_add_block", "xstring_literal"];
 
@@ -24,5 +25,38 @@ module.exports = {
     return group(
       concat([receiver, indent(concat([softline, operator, name]))])
     );
-  }
+  },
+  fcall: concatBody,
+  method_add_arg: (path, opts, print) => {
+    const [method, args] = path.map(print, "body");
+    const argNode = path.getValue().body[1];
+
+    // This case will ONLY be hit if we can successfully turn the block into a
+    // to_proc call. In that case, we just explicitly add the parens around it.
+    if (argNode.type === "args" && args.length > 0) {
+      return concat([method, "("].concat(args).concat(")"));
+    }
+
+    return concat([method, args]);
+  },
+  method_add_block: (path, opts, print) => {
+    const [method, block] = path.getValue().body;
+    const proc = toProc(block);
+
+    if (proc && method.type === "call") {
+      return group(
+        concat([
+          path.call(print, "body", 0),
+          "(",
+          indent(concat([softline, proc])),
+          concat([softline, ")"])
+        ])
+      );
+    }
+    if (proc) {
+      return path.call(print, "body", 0);
+    }
+    return concat(path.map(print, "body"));
+  },
+  vcall: first
 };

data/src/nodes/case.js

@@ -6,7 +6,7 @@ const {
   hardline,
   indent,
   line
-} = require("../builders");
+} = require("../prettier");
 
 module.exports = {
   case: (path, opts, print) => {

data/src/nodes/commands.js

@@ -1,9 +1,10 @@
-const { align, concat, group, ifBreak, join, line } = require("../builders");
+const { align, concat, group, ifBreak, join, line } = require("../prettier");
 const { docLength, makeArgs, makeCall } = require("../utils");
 
 const hasDef = node =>
   node.body[1].type === "args_add_block" &&
   node.body[1].body[0].type === "args" &&
+  node.body[1].body[0].body[0] &&
   node.body[1].body[0].body[0].type === "def";
 
 module.exports = {

data/src/nodes/conditionals.js

@@ -7,7 +7,7 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../builders");
+} = require("../prettier");
 
 const noTernary = [
   "@comment",
@@ -47,49 +47,114 @@ const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
     breaking ? breakParent : ""
   ]);
 
-const printTernaryConditions = (keyword, truthyValue, falsyValue) => {
-  const parts = [truthyValue, " : ", falsyValue];
+// 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 => {
+  if (clause.type === "concat") {
+    const [part] = clause.parts;
+
+    if (part.type === "concat" && part.parts[0] === "not") {
+      // We are inside of a statements list and the statement is a unary `not`.
+      return concat(["not(", part.parts[2], ")"]);
+    }
+
+    if (clause.parts[0] === "not") {
+      // We are inside a ternary condition and the clause is a unary `not`.
+      return concat(["not(", clause.parts[2], ")"]);
+    }
+  }
+
+  return clause;
+};
+
+// The conditions for a ternary look like `foo : bar` where `foo` represents
+// the truthy clause and `bar` represents the falsy clause. In the case that the
+// parent node is an `unless`, these have to flip in order.
+const printTernaryClauses = (keyword, truthyClause, falsyClause) => {
+  const parts = [
+    printTernaryClause(truthyClause),
+    " : ",
+    printTernaryClause(falsyClause)
+  ];
+
   return keyword === "if" ? parts : parts.reverse();
 };
 
-const canTernary = stmts =>
-  stmts.body.length === 1 && !noTernary.includes(stmts.body[0].type);
+// Handles ternary nodes. If it does not fit on one line, then we break out into
+// an if/else statement. Otherwise we remain as a ternary.
+const printTernary = (path, _opts, print) => {
+  const [predicate, truthyClause, falsyClause] = path.map(print, "body");
+  const ternaryClauses = printTernaryClauses("if", truthyClause, falsyClause);
 
-const printConditional = keyword => (path, { inlineConditionals }, print) => {
-  const [_predicate, stmts, addition] = path.getValue().body;
+  return group(
+    ifBreak(
+      concat([
+        "if ",
+        predicate,
+        indent(concat([softline, truthyClause])),
+        concat([softline, "else"]),
+        indent(concat([softline, falsyClause])),
+        concat([softline, "end"])
+      ]),
+      concat([predicate, " ? "].concat(ternaryClauses))
+    )
+  );
+};
 
-  // If the addition is not an elsif or an else, then it's the second half of a
-  // ternary expression
-  if (addition && addition.type !== "elsif" && addition.type !== "else") {
-    const parts = [path.call(print, "body", 0), " ? "];
-    const truthyValue = path.call(print, "body", 1);
-    const falsyValue = path.call(print, "body", 2);
+// 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 multiline = concat([
+    `${keyword} `,
+    align(keyword.length - 1, path.call(print, "body", 0)),
+    indent(concat([softline, path.call(print, "body", 1)])),
+    concat([softline, "end"])
+  ]);
 
-    return group(
-      ifBreak(
-        concat([
-          `${keyword} `,
-          path.call(print, "body", 0),
-          indent(concat([softline, path.call(print, "body", 1)])),
-          concat([softline, "else"]),
-          indent(concat([softline, path.call(print, "body", 2)])),
-          concat([softline, "end"])
-        ]),
-        concat(
-          parts.concat(printTernaryConditions(keyword, truthyValue, falsyValue))
-        )
-      )
-    );
+  const stmts = path.getValue().body[1];
+  const hasComments =
+    stmts.type === "stmts" && stmts.body.some(stmt => stmt.type === "@comment");
+
+  if (!inlineConditionals || hasComments) {
+    return multiline;
   }
 
-  // If there is an else and only an else, attempt to shorten to a ternary
-  if (
+  const inline = concat([
+    path.call(print, "body", 1),
+    ` ${keyword} `,
+    path.call(print, "body", 0)
+  ]);
+
+  return group(ifBreak(multiline, inline));
+};
+
+// 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 =>
+  stmts.body.length === 1 && !noTernary.includes(stmts.body[0].type);
+
+// In order for an `if` or `unless` expression to be shortened to a ternary,
+// there has to be one and only one "addition" (another clause attached) which
+// 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;
+
+  return (
     addition &&
     addition.type === "else" &&
-    canTernary(stmts) &&
-    canTernary(addition.body[0])
-  ) {
-    const ternary = printTernaryConditions(
+    [stmts, addition.body[0]].every(canTernaryStmts)
+  );
+};
+
+// A normalized print function for both `if` and `unless` nodes.
+const printConditional = keyword => (path, { inlineConditionals }, print) => {
+  if (canTernary(path)) {
+    const ternaryConditions = printTernaryClauses(
       keyword,
       path.call(print, "body", 1),
       path.call(print, "body", 2, "body", 0)
@@ -98,36 +163,32 @@ const printConditional = keyword => (path, { inlineConditionals }, print) => {
     return group(
       ifBreak(
         printWithAddition(keyword, path, print),
-        concat([path.call(print, "body", 0), " ? "].concat(ternary))
+        concat([path.call(print, "body", 0), " ? "].concat(ternaryConditions))
       )
     );
   }
 
-  // If there's an additional clause, we know we can't go for the inline option
-  if (addition) {
+  // If there's an additional clause that wasn't matched earlier, we know we
+  // can't go for the inline option.
+  if (path.getValue().body[2]) {
     return group(printWithAddition(keyword, path, print, { breaking: true }));
   }
 
-  // If it's short enough, favor the inline conditional
-  return group(
-    ifBreak(
-      concat([
-        `${keyword} `,
-        align(keyword.length - 1, path.call(print, "body", 0)),
-        indent(concat([softline, path.call(print, "body", 1)])),
-        concat([softline, "end"])
-      ]),
-      concat([
-        inlineConditionals ? "" : breakParent,
-        path.call(print, "body", 1),
-        ` ${keyword} `,
-        path.call(print, "body", 0)
-      ])
-    )
-  );
+  return printSingle(keyword)(path, { inlineConditionals }, print);
 };
 
 module.exports = {
+  else: (path, opts, print) => {
+    const stmts = path.getValue().body[0];
+
+    return concat([
+      stmts.body.length === 1 && stmts.body[0].type === "command"
+        ? breakParent
+        : "",
+      "else",
+      indent(concat([softline, path.call(print, "body", 0)]))
+    ]);
+  },
   elsif: (path, opts, print) => {
     const [_predicate, _statements, addition] = path.getValue().body;
     const parts = [
@@ -147,8 +208,8 @@ module.exports = {
     return group(concat(parts));
   },
   if: printConditional("if"),
-  ifop: printConditional("if"),
-  if_mod: printConditional("if"),
+  ifop: printTernary,
+  if_mod: printSingle("if"),
   unless: printConditional("unless"),
-  unless_mod: printConditional("unless")
+  unless_mod: printSingle("unless")
 };