prettier 0.12.2

data/src/nodes/alias.js

@@ -0,0 +1,32 @@
+const { concat, join } = require("../builders");
+
+const usingSymbols = path => {
+  const [left, right] = path.getValue().body.map(node => node.body[0].type);
+  return left === "symbol" && right === "symbol";
+};
+
+const identFromSymbol = (path, print, index) =>
+  path.call(print, "body", index, "body", 0, "body", 0);
+
+const aliasError = (_path, _opts, _print) => {
+  throw new Error("can't make alias for the number variables");
+};
+
+const aliasVars = (path, opts, print) => {
+  if (usingSymbols(path)) {
+    return join(" ", [
+      identFromSymbol(path, print, 0),
+      identFromSymbol(path, print, 1)
+    ]);
+  }
+  return join(" ", path.map(print, "body"));
+};
+
+const alias = (path, opts, print) =>
+  concat(["alias ", aliasVars(path, opts, print)]);
+
+module.exports = {
+  alias,
+  alias_error: aliasError,
+  var_alias: alias
+};

data/src/nodes/arrays.js

@@ -0,0 +1,162 @@
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line,
+  literalline,
+  softline
+} = require("../builders");
+
+const isStringArray = args =>
+  args.body.every(
+    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 makeArray = start => (path, opts, print) =>
+  [start].concat(path.map(print, "body"));
+
+const getSpecialArrayParts = (path, print, args) =>
+  args.body.map((_arg, index) =>
+    path.call(print, "body", 0, "body", index, "body", 0, "body", 0)
+  );
+
+const printAref = (path, opts, print) =>
+  group(
+    concat([
+      path.call(print, "body", 0),
+      "[",
+      indent(
+        concat([
+          softline,
+          join(concat([",", line]), path.call(print, "body", 1))
+        ])
+      ),
+      concat([softline, "]"])
+    ])
+  );
+
+const printSpecialArray = parts =>
+  group(
+    concat([
+      parts[0],
+      "[",
+      indent(concat([softline, join(line, parts.slice(1))])),
+      concat([softline, "]"])
+    ])
+  );
+
+// Extract out the actual elements, taking into account nesting with
+// `args_add_star` nodes. The only nodes that get passed into this function are
+// `args` or `args_add_star`.
+const getElements = (node, elementPath) => {
+  if (node.type === "args") {
+    return node.body.map((element, index) => ({
+      element,
+      elementPath: elementPath.concat(["body", index])
+    }));
+  }
+
+  return getElements(node.body[0], elementPath.concat(["body", 0])).concat(
+    node.body.slice(1).map((element, index) => ({
+      element,
+      elementPath: elementPath.concat(["body", index + 1])
+    }))
+  );
+};
+
+module.exports = {
+  aref: (path, opts, print) => {
+    if (!path.getValue().body[1]) {
+      return concat([path.call(print, "body", 0), "[]"]);
+    }
+
+    return printAref(path, opts, print);
+  },
+  aref_field: printAref,
+  array: (path, { addTrailingCommas }, print) => {
+    const args = path.getValue().body[0];
+
+    if (args === null) {
+      return "[]";
+    }
+
+    if (isStringArray(args)) {
+      return printSpecialArray(
+        ["%w"].concat(getSpecialArrayParts(path, print, args))
+      );
+    }
+
+    if (isSymbolArray(args)) {
+      return printSpecialArray(
+        ["%i"].concat(getSpecialArrayParts(path, print, args))
+      );
+    }
+
+    if (!["args", "args_add_star"].includes(args.type)) {
+      return printSpecialArray(path.call(print, "body", 0));
+    }
+
+    const normalDocs = [];
+
+    const elementDocs = path.call(print, "body", 0);
+    const elements = getElements(path.getValue().body[0], ["body", 0]);
+
+    // We need to manually loop through the elements in the array in order to
+    // take care of heredocs printing (their commas go after the opening, as
+    // opposed to at the end).
+    elements.forEach(({ element, elementPath }, index) => {
+      const isInner = index !== elements.length - 1;
+
+      const isStraightHeredoc = element.type === "heredoc";
+      const isSquigglyHeredoc =
+        element.type === "string_literal" && element.body[0].type === "heredoc";
+
+      if (isStraightHeredoc || isSquigglyHeredoc) {
+        const heredocNode = isStraightHeredoc ? element : element.body[0];
+        const heredocPath = [print].concat(elementPath);
+
+        if (isSquigglyHeredoc) {
+          heredocPath.push("body", 0);
+        }
+
+        normalDocs.push(
+          heredocNode.beging,
+          isInner || addTrailingCommas ? "," : "",
+          literalline,
+          concat(path.map.apply(path, heredocPath.concat("body"))),
+          heredocNode.ending,
+          isInner ? line : ""
+        );
+      } else {
+        normalDocs.push(elementDocs[index]);
+
+        if (isInner) {
+          normalDocs.push(concat([",", line]));
+        } else if (addTrailingCommas) {
+          normalDocs.push(ifBreak(",", ""));
+        }
+      }
+    });
+
+    return group(
+      concat([
+        "[",
+        indent(concat([softline].concat(normalDocs))),
+        concat([softline, "]"])
+      ])
+    );
+  },
+  qsymbols: makeArray("%i"),
+  qwords: makeArray("%w"),
+  symbols: makeArray("%I"),
+  words: makeArray("%W")
+};

data/src/nodes/blocks.js

@@ -0,0 +1,66 @@
+const {
+  breakParent,
+  concat,
+  group,
+  ifBreak,
+  indent,
+  softline
+} = require("../builders");
+const { hasAncestor } = require("../utils");
+
+const printBlock = (path, opts, print) => {
+  const [variables, statements] = path.getValue().body;
+  const stmts =
+    statements.type === "stmts" ? statements.body : statements.body[0].body;
+
+  let doBlockBody = "";
+  if (stmts.length !== 1 || stmts[0].type !== "void_stmt") {
+    doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
+  }
+
+  // If this block is nested underneath a command or command_call node, then we
+  // can't use `do...end` because that will get associated with the parent node
+  // 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 doBlock = concat([
+    useBraces ? " {" : " do",
+    variables ? concat([" ", path.call(print, "body", 0)]) : "",
+    doBlockBody,
+    concat([softline, useBraces ? "}" : "end"])
+  ]);
+
+  // We can hit this next pattern if within the block the only statement is a
+  // comment.
+  if (
+    stmts.length > 1 &&
+    stmts.filter(stmt => stmt.type !== "@comment").length === 1
+  ) {
+    return concat([breakParent, doBlock]);
+  }
+
+  // If the parent node is a command node, then there are no parentheses around
+  // the arguments to that command, so we need to break the block
+  if (["command", "command_call"].includes(path.getParentNode().body[0].type)) {
+    return concat([breakParent, doBlock]);
+  }
+
+  const hasBody = stmts.some(({ type }) => type !== "void_stmt");
+  const braceBlock = concat([
+    " {",
+    hasBody || variables ? " " : "",
+    variables ? path.call(print, "body", 0) : "",
+    path.call(print, "body", 1),
+    hasBody ? " " : "",
+    "}"
+  ]);
+
+  return group(ifBreak(doBlock, braceBlock));
+};
+
+module.exports = {
+  brace_block: printBlock,
+  do_block: printBlock
+};

data/src/nodes/calls.js

@@ -0,0 +1,28 @@
+const { concat, group, indent, softline } = require("../builders");
+const { makeCall } = require("../utils");
+
+const noIndent = ["array", "hash", "method_add_block", "xstring_literal"];
+
+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];
+
+    // 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);
+    }
+
+    // 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]);
+    }
+
+    return group(
+      concat([receiver, indent(concat([softline, operator, name]))])
+    );
+  }
+};

data/src/nodes/case.js

@@ -0,0 +1,57 @@
+const {
+  align,
+  concat,
+  fill,
+  group,
+  hardline,
+  indent,
+  line
+} = require("../builders");
+
+module.exports = {
+  case: (path, opts, print) => {
+    const statement = ["case"];
+
+    // You don't need to explicitly have something to test against in a case
+    // statement (without it it effectively becomes an if/elsif chain).
+    if (path.getValue().body[0]) {
+      statement.push(" ", path.call(print, "body", 0));
+    }
+
+    return concat(
+      statement.concat([hardline, path.call(print, "body", 1), hardline, "end"])
+    );
+  },
+  when: (path, opts, print) => {
+    const [_preds, _stmts, addition] = path.getValue().body;
+
+    // The `fill` builder command expects an array of docs alternating with
+    // line breaks. This is so it can loop through and determine where to break.
+    const preds = fill(
+      path
+        .call(print, "body", 0)
+        .reduce(
+          (accum, pred, index) =>
+            index === 0 ? [pred] : accum.concat([",", line, pred]),
+          null
+        )
+    );
+
+    const stmts = path.call(print, "body", 1);
+    const parts = [concat(["when ", align("when ".length, preds)])];
+
+    // 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)) {
+      parts.push(indent(concat([hardline, stmts])));
+    }
+
+    // This is the next clause on the case statement, either another `when` or
+    // an `else` clause.
+    if (addition) {
+      parts.push(hardline, path.call(print, "body", 2));
+    }
+
+    return group(concat(parts));
+  }
+};

data/src/nodes/commands.js

@@ -0,0 +1,70 @@
+const { align, concat, group, ifBreak, join, line } = require("../builders");
+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].type === "def";
+
+module.exports = {
+  command: (path, opts, print) => {
+    const command = path.call(print, "body", 0);
+    const { args, heredocs } = makeArgs(path, opts, print, 1);
+
+    if (heredocs.length > 1) {
+      return concat([command, " ", join(", ", args)].concat(heredocs));
+    }
+
+    const joinedArgs = join(concat([",", line]), args);
+    const breakArgs = hasDef(path.getValue())
+      ? joinedArgs
+      : align(command.length + 1, joinedArgs);
+
+    const commandDoc = group(
+      ifBreak(
+        concat([command, " ", breakArgs]),
+        concat([command, " ", joinedArgs])
+      )
+    );
+
+    if (heredocs.length === 1) {
+      return group(concat([commandDoc].concat(heredocs)));
+    }
+
+    return commandDoc;
+  },
+  command_call: (path, opts, print) => {
+    const parts = [
+      path.call(print, "body", 0),
+      makeCall(path, opts, print),
+      path.call(print, "body", 2)
+    ];
+
+    if (!path.getValue().body[3]) {
+      return concat(parts);
+    }
+
+    parts.push(" ");
+    const { args, heredocs } = makeArgs(path, opts, print, 3);
+
+    if (heredocs.length > 1) {
+      return concat(parts.concat([join(", ", args)]).concat(heredocs));
+    }
+
+    const joinedArgs = join(concat([",", line]), args);
+    const breakArgs =
+      path.getValue().body[2].body === "to"
+        ? joinedArgs
+        : align(docLength(concat(parts)), joinedArgs);
+
+    const commandDoc = group(
+      ifBreak(concat(parts.concat(breakArgs)), concat(parts.concat(joinedArgs)))
+    );
+
+    if (heredocs.length === 1) {
+      return group(concat([commandDoc].concat(heredocs)));
+    }
+
+    return commandDoc;
+  }
+};

data/src/nodes/conditionals.js

@@ -0,0 +1,154 @@
+const {
+  align,
+  breakParent,
+  concat,
+  hardline,
+  group,
+  ifBreak,
+  indent,
+  softline
+} = require("../builders");
+
+const noTernary = [
+  "@comment",
+  "alias",
+  "assign",
+  "break",
+  "command",
+  "command_call",
+  "if_mod",
+  "ifop",
+  "lambda",
+  "massign",
+  "next",
+  "opassign",
+  "rescue_mod",
+  "return",
+  "return0",
+  "super",
+  "undef",
+  "unless_mod",
+  "until_mod",
+  "var_alias",
+  "void_stmt",
+  "while_mod",
+  "yield",
+  "yield0",
+  "zsuper"
+];
+
+const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
+  concat([
+    `${keyword} `,
+    align(keyword.length - 1, path.call(print, "body", 0)),
+    indent(concat([softline, path.call(print, "body", 1)])),
+    concat([softline, path.call(print, "body", 2)]),
+    concat([softline, "end"]),
+    breaking ? breakParent : ""
+  ]);
+
+const printTernaryConditions = (keyword, truthyValue, falsyValue) => {
+  const parts = [truthyValue, " : ", falsyValue];
+  return keyword === "if" ? parts : parts.reverse();
+};
+
+const canTernary = stmts =>
+  stmts.body.length === 1 && !noTernary.includes(stmts.body[0].type);
+
+const printConditional = keyword => (path, { inlineConditionals }, print) => {
+  const [_predicate, stmts, addition] = path.getValue().body;
+
+  // 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);
+
+    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))
+        )
+      )
+    );
+  }
+
+  // If there is an else and only an else, attempt to shorten to a ternary
+  if (
+    addition &&
+    addition.type === "else" &&
+    canTernary(stmts) &&
+    canTernary(addition.body[0])
+  ) {
+    const ternary = printTernaryConditions(
+      keyword,
+      path.call(print, "body", 1),
+      path.call(print, "body", 2, "body", 0)
+    );
+
+    return group(
+      ifBreak(
+        printWithAddition(keyword, path, print),
+        concat([path.call(print, "body", 0), " ? "].concat(ternary))
+      )
+    );
+  }
+
+  // If there's an additional clause, we know we can't go for the inline option
+  if (addition) {
+    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)
+      ])
+    )
+  );
+};
+
+module.exports = {
+  elsif: (path, opts, print) => {
+    const [_predicate, _statements, addition] = path.getValue().body;
+    const parts = [
+      group(
+        concat([
+          "elsif ",
+          align("elsif".length - 1, path.call(print, "body", 0))
+        ])
+      ),
+      indent(concat([hardline, path.call(print, "body", 1)]))
+    ];
+
+    if (addition) {
+      parts.push(group(concat([hardline, path.call(print, "body", 2)])));
+    }
+
+    return group(concat(parts));
+  },
+  if: printConditional("if"),
+  ifop: printConditional("if"),
+  if_mod: printConditional("if"),
+  unless: printConditional("unless"),
+  unless_mod: printConditional("unless")
+};