prettier 0.12.2

data/src/nodes/hashes.js

@@ -0,0 +1,134 @@
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line,
+  literalline
+} = require("../builders");
+const { skipAssignIndent } = require("../utils");
+
+const nodeDive = (node, steps) => {
+  let current = node;
+
+  steps.forEach(step => {
+    current = current[step];
+  });
+
+  return current;
+};
+
+const makeLabel = (path, { preferHashLabels }, print, steps) => {
+  const labelNode = nodeDive(path.getValue(), steps);
+  const labelDoc = path.call.apply(path, [print].concat(steps));
+
+  switch (labelNode.type) {
+    case "@label":
+      if (preferHashLabels) {
+        return labelDoc;
+      }
+      return `:${labelDoc.slice(0, labelDoc.length - 1)} =>`;
+    case "symbol_literal": {
+      // You can have a symbol literal as a key in a hash that ends with an =
+      // character, which breaks when you use hash labels.
+      const endsInEquals = labelNode.body[0].body[0].body.endsWith("=");
+
+      if (preferHashLabels && labelNode.body.length === 1 && !endsInEquals) {
+        const symbolSteps = steps.concat("body", 0, "body", 0);
+
+        return concat([
+          path.call.apply(path, [print].concat(symbolSteps)),
+          ":"
+        ]);
+      }
+      return concat([labelDoc, " =>"]);
+    }
+    case "dyna_symbol":
+      if (preferHashLabels) {
+        return concat(labelDoc.parts.slice(1).concat(":"));
+      }
+      return concat([labelDoc, " =>"]);
+    default:
+      return concat([labelDoc, " =>"]);
+  }
+};
+
+module.exports = {
+  assoc_new: (path, opts, print) => {
+    const valueDoc = path.call(print, "body", 1);
+    const parts = [makeLabel(path, opts, print, ["body", 0])];
+
+    if (skipAssignIndent(path.getValue().body[1])) {
+      parts.push(" ", valueDoc);
+    } else {
+      parts.push(indent(concat([line, valueDoc])));
+    }
+
+    return group(concat(parts));
+  },
+  assoclist_from_args: (path, opts, print) => {
+    const { addTrailingCommas } = opts;
+
+    const assocNodes = path.getValue().body[0];
+    const assocDocs = [];
+
+    assocNodes.forEach((assocNode, index) => {
+      const isInner = index !== assocNodes.length - 1;
+      const valueNode = assocNode.body[1];
+
+      const isStraightHeredoc = valueNode.type === "heredoc";
+      const isSquigglyHeredoc =
+        valueNode.type === "string_literal" &&
+        valueNode.body[0].type === "heredoc";
+
+      if (isStraightHeredoc || isSquigglyHeredoc) {
+        const heredocSteps = isStraightHeredoc
+          ? ["body", 1]
+          : ["body", 1, "body", 0];
+        const { beging, ending } = nodeDive(assocNode, heredocSteps);
+
+        assocDocs.push(
+          makeLabel(path, opts, print, ["body", 0, index, "body", 0]),
+          " ",
+          beging,
+          isInner || addTrailingCommas ? "," : "",
+          literalline,
+          concat(
+            path.map.apply(
+              path,
+              [print, "body", 0, index].concat(heredocSteps).concat("body")
+            )
+          ),
+          ending,
+          isInner ? line : ""
+        );
+      } else {
+        assocDocs.push(path.call(print, "body", 0, index));
+
+        if (isInner) {
+          assocDocs.push(concat([",", line]));
+        } else if (addTrailingCommas) {
+          assocDocs.push(ifBreak(",", ""));
+        }
+      }
+    });
+
+    return group(concat(assocDocs));
+  },
+  bare_assoc_hash: (path, opts, print) =>
+    group(join(concat([",", line]), path.map(print, "body", 0))),
+  hash: (path, opts, print) => {
+    if (path.getValue().body[0] === null) {
+      return "{}";
+    }
+
+    return group(
+      concat([
+        "{",
+        indent(concat([line, concat(path.map(print, "body"))])),
+        concat([line, "}"])
+      ])
+    );
+  }
+};

data/src/nodes/hooks.js

@@ -0,0 +1,15 @@
+const { concat, group, indent, line } = require("../builders");
+
+const printHook = name => (path, opts, print) =>
+  group(
+    concat([
+      `${name} {`,
+      indent(concat([line, path.call(print, "body", 0)])),
+      concat([line, "}"])
+    ])
+  );
+
+module.exports = {
+  BEGIN: printHook("BEGIN"),
+  END: printHook("END")
+};

data/src/nodes/lambdas.js

@@ -0,0 +1,59 @@
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  line,
+  removeLines,
+  softline
+} = require("../builders");
+const { hasAncestor } = require("../utils");
+
+module.exports = {
+  lambda: (path, opts, print) => {
+    let params = path.getValue().body[0];
+    let paramsConcat = "";
+
+    if (params.type === "params") {
+      paramsConcat = path.call(print, "body", 0);
+    } else {
+      [params] = params.body;
+      paramsConcat = path.call(print, "body", 0, "body", 0);
+    }
+
+    const noParams = params.body.every(type => !type);
+    const inlineLambda = concat([
+      "->",
+      noParams ? "" : concat(["(", paramsConcat, ")"]),
+      " { ",
+      path.call(print, "body", 1),
+      " }"
+    ]);
+
+    if (hasAncestor(path, ["command", "command_call"])) {
+      return group(
+        ifBreak(
+          concat([
+            "lambda {",
+            noParams ? "" : concat([" |", removeLines(paramsConcat), "|"]),
+            indent(concat([line, path.call(print, "body", 1)])),
+            concat([line, "}"])
+          ]),
+          inlineLambda
+        )
+      );
+    }
+
+    return group(
+      ifBreak(
+        concat([
+          "lambda do",
+          noParams ? "" : concat([" |", removeLines(paramsConcat), "|"]),
+          indent(concat([softline, path.call(print, "body", 1)])),
+          concat([softline, "end"])
+        ]),
+        inlineLambda
+      )
+    );
+  }
+};

data/src/nodes/loops.js

@@ -0,0 +1,46 @@
+const {
+  breakParent,
+  concat,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  softline
+} = require("../builders");
+
+const printLoop = keyword => (path, { inlineLoops }, print) =>
+  group(
+    ifBreak(
+      concat([
+        concat([`${keyword} `, path.call(print, "body", 0)]),
+        indent(concat([softline, path.call(print, "body", 1)])),
+        concat([softline, "end"])
+      ]),
+      concat([
+        inlineLoops ? "" : breakParent,
+        path.call(print, "body", 1),
+        ` ${keyword} `,
+        path.call(print, "body", 0)
+      ])
+    )
+  );
+
+const printFor = (path, opts, print) =>
+  group(
+    concat([
+      path.call(print, "body", 1),
+      ".each do |",
+      path.call(print, "body", 0),
+      "|",
+      indent(concat([hardline, path.call(print, "body", 2)])),
+      concat([hardline, "end"])
+    ])
+  );
+
+module.exports = {
+  while: printLoop("while"),
+  while_mod: printLoop("while"),
+  until: printLoop("until"),
+  until_mod: printLoop("until"),
+  for: printFor
+};

data/src/nodes/methods.js

@@ -0,0 +1,42 @@
+const { concat, group, hardline, indent } = require("../builders");
+
+const printMethod = offset => (path, opts, print) => {
+  const [_name, params, body] = path.getValue().body.slice(offset);
+  const declaration = ["def "];
+
+  // In this case, we're printing a method that's defined as a singleton, so we
+  // need to include the target and the operator
+  if (offset > 0) {
+    declaration.push(path.call(print, "body", 0), path.call(print, "body", 1));
+  }
+
+  // In case there are no parens but there are arguments
+  const parens =
+    params.type === "params" && params.body.some(paramType => paramType);
+
+  declaration.push(
+    path.call(print, "body", offset),
+    parens ? "(" : "",
+    path.call(print, "body", offset + 1),
+    parens ? ")" : ""
+  );
+
+  // If the body is empty, we can replace with a ;
+  const stmts = body.body[0].body;
+  if (stmts.length === 1 && stmts[0].type === "void_stmt") {
+    return group(concat(declaration.concat(["; end"])));
+  }
+
+  return group(
+    concat([
+      group(concat(declaration)),
+      indent(concat([hardline, path.call(print, "body", offset + 2)])),
+      group(concat([hardline, "end"]))
+    ])
+  );
+};
+
+module.exports = {
+  def: printMethod(0),
+  defs: printMethod(2)
+};

data/src/nodes/params.js

@@ -0,0 +1,75 @@
+const { concat, group, join, line } = require("../builders");
+
+const printGenericRestParam = symbol => (path, opts, print) =>
+  path.getValue().body[0]
+    ? concat([symbol, path.call(print, "body", 0)])
+    : symbol;
+
+const printParams = (path, opts, print) => {
+  const [
+    reqs,
+    optls,
+    rest,
+    post,
+    kwargs,
+    kwargRest,
+    block
+  ] = path.getValue().body;
+  let parts = [];
+
+  if (reqs) {
+    parts = parts.concat(path.map(print, "body", 0));
+  }
+
+  if (optls) {
+    parts = parts.concat(
+      optls.map((_, index) =>
+        concat([
+          path.call(print, "body", 1, index, 0),
+          " = ",
+          path.call(print, "body", 1, index, 1)
+        ])
+      )
+    );
+  }
+
+  if (rest) {
+    parts.push(path.call(print, "body", 2));
+  }
+
+  if (post) {
+    parts = parts.concat(path.map(print, "body", 3));
+  }
+
+  if (kwargs) {
+    parts = parts.concat(
+      kwargs.map(([, value], index) => {
+        if (!value) {
+          return path.call(print, "body", 4, index, 0);
+        }
+        return group(join(" ", path.map(print, "body", 4, index)));
+      })
+    );
+  }
+
+  if (kwargRest) {
+    parts.push(path.call(print, "body", 5));
+  }
+
+  if (block) {
+    parts.push(path.call(print, "body", 6));
+  }
+
+  return group(join(concat([",", line]), parts));
+};
+
+const paramError = () => {
+  throw new Error("formal argument cannot be a global variable");
+};
+
+module.exports = {
+  kwrest_param: printGenericRestParam("**"),
+  rest_param: printGenericRestParam("*"),
+  params: printParams,
+  param_error: paramError
+};

data/src/nodes/regexp.js

@@ -0,0 +1,18 @@
+const { concat } = require("../builders");
+const { makeList } = require("../utils");
+
+module.exports = {
+  regexp: makeList,
+  regexp_literal: (path, opts, print) => {
+    const [contents, ending] = path.map(print, "body");
+
+    const useBraces = contents.some(
+      content => typeof content === "string" && content.includes("/")
+    );
+    const parts = [useBraces ? "%r{" : "/"]
+      .concat(contents)
+      .concat([useBraces ? "}" : "/", ending.slice(1)]);
+
+    return concat(parts);
+  }
+};

data/src/nodes/rescue.js

@@ -0,0 +1,77 @@
+const {
+  align,
+  concat,
+  group,
+  hardline,
+  indent,
+  join,
+  line
+} = require("../builders");
+const { literal } = require("../utils");
+
+module.exports = {
+  begin: (path, opts, print) =>
+    concat([
+      "begin",
+      indent(concat([hardline, concat(path.map(print, "body"))])),
+      hardline,
+      "end"
+    ]),
+  ensure: (path, opts, print) =>
+    concat([
+      "ensure",
+      indent(concat([hardline, concat(path.map(print, "body"))]))
+    ]),
+  redo: literal("redo"),
+  rescue: (path, opts, print) => {
+    const [exception, variable, _stmts, addition] = path.getValue().body;
+    const parts = ["rescue"];
+
+    if (exception || variable) {
+      if (exception) {
+        if (Array.isArray(exception)) {
+          // In this case, it's actually only the one exception (it's an array
+          // of length 1).
+          parts.push(" ", path.call(print, "body", 0, 0));
+        } else {
+          // Here we have multiple exceptions from which we're rescuing, so we
+          // need to align them and join them together.
+          const joiner = concat([",", line]);
+          const exceptions = group(join(joiner, path.call(print, "body", 0)));
+
+          parts.push(" ", align("rescue ".length, exceptions));
+        }
+      }
+
+      if (variable) {
+        parts.push(" => ", path.call(print, "body", 1));
+      }
+    } else {
+      // If you don't specify an error to rescue in a `begin/rescue` block, then
+      // implicitly you're rescuing from `StandardError`. In this case, we're
+      // just going to explicitly add it.
+      parts.push(" StandardError");
+    }
+
+    parts.push(indent(concat([hardline, path.call(print, "body", 2)])));
+
+    // This is the next clause on the `begin` statement, either another
+    // `rescue`, and `ensure`, or an `else` clause.
+    if (addition) {
+      parts.push(concat([hardline, path.call(print, "body", 3)]));
+    }
+
+    return group(concat(parts));
+  },
+  rescue_mod: (path, opts, print) =>
+    concat([
+      "begin",
+      indent(concat([hardline, path.call(print, "body", 0)])),
+      hardline,
+      "rescue StandardError",
+      indent(concat([hardline, path.call(print, "body", 1)])),
+      hardline,
+      "end"
+    ]),
+  retry: literal("retry")
+};