prettier 1.0.0.pre.rc2 → 1.2.1

data/src/nodes/case.js

@@ -8,54 +8,58 @@ const {
   line
 } = require("../prettier");
 
-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) => {
-        if (index === 0) {
-          return [pred];
-        }
-
-        // Pull off the last element and make it concat with a comma so that
-        // we can maintain alternating lines and docs.
-        return accum
-          .slice(0, -1)
-          .concat([concat([accum[accum.length - 1], ","]), 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));
+function printCase(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"])
+  );
+}
+
+function printWhen(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) => {
+      if (index === 0) {
+        return [pred];
+      }
+
+      // Pull off the last element and make it concat with a comma so that
+      // we can maintain alternating lines and docs.
+      return accum
+        .slice(0, -1)
+        .concat([concat([accum[accum.length - 1], ","]), 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));
+}
+
+module.exports = {
+  case: printCase,
+  when: printWhen
 };

data/src/nodes/hashes.js

@@ -1,14 +1,11 @@
-const {
-  concat,
-  group,
-  hardline,
-  ifBreak,
-  indent,
-  join,
-  line
-} = require("../prettier");
+const { concat, group, ifBreak, indent, join, line } = require("../prettier");
 
-const { getTrailingComma, prefix, skipAssignIndent } = require("../utils");
+const {
+  getTrailingComma,
+  prefix,
+  printEmptyCollection,
+  skipAssignIndent
+} = require("../utils");
 
 // When attempting to convert a hash rocket into a hash label, you need to take
 // care because only certain patterns are allowed. Ruby source says that they
@@ -93,50 +90,7 @@ function printHashContents(path, opts, print) {
       ? printHashKeyLabel
       : printHashKeyRocket;
 
-  const contents = join(concat([",", line]), path.map(print, "body"));
-
-  // If we're inside a hash literal, then we want to add the braces at this
-  // level so that the grouping is correct. Otherwise you could end up with
-  // opening and closing braces being split up, but the contents not being split
-  // correctly.
-  if (path.getParentNode().type === "hash") {
-    return group(
-      concat([
-        "{",
-        indent(
-          concat([
-            line,
-            contents,
-            getTrailingComma(opts) ? ifBreak(",", "") : ""
-          ])
-        ),
-        line,
-        "}"
-      ])
-    );
-  }
-
-  // Otherwise, we're inside a bare_assoc_hash, so we don't want to print
-  // braces at all.
-  return group(contents);
-}
-
-function printEmptyHashWithComments(path, opts) {
-  const hashNode = path.getValue();
-
-  const printComment = (commentPath, index) => {
-    hashNode.comments[index].printed = true;
-    return opts.printer.printComment(commentPath);
-  };
-
-  return concat([
-    "{",
-    indent(
-      concat([hardline, join(hardline, path.map(printComment, "comments"))])
-    ),
-    line,
-    "}"
-  ]);
+  return join(concat([",", line]), path.map(print, "body"));
 }
 
 function printHash(path, opts, print) {
@@ -146,10 +100,23 @@ function printHash(path, opts, print) {
   // missing, then it means we're dealing with an empty hash, so we can just
   // exit here and print.
   if (hashNode.body[0] === null) {
-    return hashNode.comments ? printEmptyHashWithComments(path, opts) : "{}";
+    return printEmptyCollection(path, opts, "{", "}");
   }
 
-  return path.call(print, "body", 0);
+  return group(
+    concat([
+      "{",
+      indent(
+        concat([
+          line,
+          path.call(print, "body", 0),
+          getTrailingComma(opts) ? ifBreak(",", "") : ""
+        ])
+      ),
+      line,
+      "}"
+    ])
+  );
 }
 
 module.exports = {

data/src/nodes/loops.js

@@ -12,85 +12,85 @@ const {
 const { containsAssignment } = require("../utils");
 const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
-const printLoop = (keyword, modifier) => (path, { rubyModifier }, print) => {
-  const [_predicate, stmts] = path.getValue().body;
+function printLoop(keyword, modifier) {
+  return function printLoopWithOptions(path, { rubyModifier }, print) {
+    const [_predicate, stmts] = path.getValue().body;
 
-  // If the only statement inside this while loop is a void statement, then we
-  // can shorten to just displaying the predicate and then a semicolon.
-  if (
-    stmts.body.length === 1 &&
-    stmts.body[0].type === "void_stmt" &&
-    !stmts.body[0].comments
-  ) {
-    return group(
-      concat([
-        keyword,
-        " ",
-        path.call(print, "body", 0),
-        ifBreak(softline, "; "),
-        "end"
+    // If the only statement inside this while loop is a void statement, then we
+    // can shorten to just displaying the predicate and then a semicolon.
+    if (
+      stmts.body.length === 1 &&
+      stmts.body[0].type === "void_stmt" &&
+      !stmts.body[0].comments
+    ) {
+      return group(
+        concat([
+          keyword,
+          " ",
+          path.call(print, "body", 0),
+          ifBreak(softline, "; "),
+          "end"
+        ])
+      );
+    }
+
+    const inlineLoop = concat(
+      inlineEnsureParens(path, [
+        path.call(print, "body", 1),
+        ` ${keyword} `,
+        path.call(print, "body", 0)
       ])
     );
-  }
 
-  const inlineLoop = concat(
-    inlineEnsureParens(path, [
-      path.call(print, "body", 1),
-      ` ${keyword} `,
-      path.call(print, "body", 0)
-    ])
-  );
+    // If we're in the modifier form and we're modifying a `begin`, then this is
+    // a special case where we need to explicitly use the modifier form because
+    // otherwise the semantic meaning changes. This looks like:
+    //
+    //     begin
+    //       foo
+    //     end while bar
+    //
+    // The above is effectively a `do...while` loop (which we don't have in
+    // ruby).
+    if (modifier && path.getValue().body[1].type === "begin") {
+      return inlineLoop;
+    }
 
-  // If we're in the modifier form and we're modifying a `begin`, then this is a
-  // special case where we need to explicitly use the modifier form because
-  // otherwise the semantic meaning changes. This looks like:
-  //
-  //     begin
-  //       foo
-  //     end while bar
-  //
-  // The above is effectively a `do...while` loop (which we don't have in ruby).
-  if (modifier && path.getValue().body[1].type === "begin") {
-    return inlineLoop;
-  }
+    const blockLoop = concat([
+      concat([
+        `${keyword} `,
+        align(keyword.length + 1, path.call(print, "body", 0))
+      ]),
+      indent(concat([softline, path.call(print, "body", 1)])),
+      concat([softline, "end"])
+    ]);
 
-  const blockLoop = concat([
-    concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0))
-    ]),
-    indent(concat([softline, path.call(print, "body", 1)])),
-    concat([softline, "end"])
-  ]);
+    // If we're disallowing inline loops or if the predicate of the loop
+    // contains an assignment (in which case we can't know for certain that that
+    // assignment doesn't impact the statements inside the loop) then we can't
+    // use the modifier form and we must use the block form.
+    if (!rubyModifier || containsAssignment(path.getValue().body[0])) {
+      return concat([breakParent, blockLoop]);
+    }
 
-  // If we're disallowing inline loops or if the predicate of the loop contains
-  // an assignment (in which case we can't know for certain that that
-  // assignment doesn't impact the statements inside the loop) then we can't
-  // use the modifier form and we must use the block form.
-  if (!rubyModifier || containsAssignment(path.getValue().body[0])) {
-    return concat([breakParent, blockLoop]);
-  }
+    return group(ifBreak(blockLoop, inlineLoop));
+  };
+}
 
-  return group(ifBreak(blockLoop, inlineLoop));
-};
+function printFor(path, opts, print) {
+  const [variable, range, stmts] = path.map(print, "body");
 
-// Technically this is incorrect. A `for` loop actually introduces and modifies
-// a local variable that then remains in the outer scope. Additionally, if the
-// `each` method was somehow missing from the enumerable (it's possible...),
-// then this transformation would fail. However - I've never actually seen a
-// `for` loop used in production. If someone actually calls me on it, I'll fix
-// this, but for now I'm leaving it.
-const printFor = (path, opts, print) =>
-  group(
+  return group(
     concat([
-      path.call(print, "body", 1),
-      ".each do |",
-      path.call(print, "body", 0),
-      "|",
-      indent(concat([hardline, path.call(print, "body", 2)])),
+      "for ",
+      variable,
+      " in ",
+      range,
+      indent(concat([hardline, stmts])),
       concat([hardline, "end"])
     ])
   );
+}
 
 module.exports = {
   while: printLoop("while", false),

data/src/nodes/methods.js

@@ -1,4 +1,4 @@
-const { concat, group, hardline, indent } = require("../prettier");
+const { concat, group, hardline, indent, line } = require("../prettier");
 const { first } = require("../utils");
 
 function printMethod(offset) {
@@ -16,8 +16,7 @@ function printMethod(offset) {
     }
 
     // In case there are no parens but there are arguments
-    const parens =
-      params.type === "params" && params.body.some((paramType) => paramType);
+    const parens = params.type === "params" && params.body.some((type) => type);
 
     declaration.push(
       path.call(print, "body", offset),
@@ -48,8 +47,34 @@ function printMethod(offset) {
   };
 }
 
+function printSingleLineMethod(path, opts, print) {
+  let paramsNode = path.getValue().body[1];
+  let paramsDoc = "";
+
+  if (paramsNode) {
+    if (paramsNode.body[0].type === "params") {
+      paramsNode = paramsNode.body[0];
+    }
+
+    if (paramsNode.type === "params" && paramsNode.body.some((type) => type)) {
+      paramsDoc = path.call(print, "body", 1);
+    }
+  }
+
+  return group(
+    concat([
+      "def ",
+      path.call(print, "body", 0),
+      paramsDoc,
+      " =",
+      indent(group(concat([line, path.call(print, "body", 2)])))
+    ])
+  );
+}
+
 module.exports = {
   access_ctrl: first,
   def: printMethod(0),
-  defs: printMethod(2)
+  defs: printMethod(2),
+  defsl: printSingleLineMethod
 };

data/src/nodes/patterns.js

@@ -1,5 +1,7 @@
 const { concat, group, hardline, indent, join, line } = require("../prettier");
 
+const patterns = ["aryptn", "binary", "fndptn", "hshptn", "rassign"];
+
 function printPatternArg(path, opts, print) {
   // Pinning is a really special syntax in pattern matching that's not really
   // all that well supported in ripper. Here we're just going to the original
@@ -34,10 +36,7 @@ function printAryPtn(path, opts, print) {
 
   args = group(join(concat([",", line]), args));
 
-  if (
-    constant ||
-    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
-  ) {
+  if (constant || patterns.includes(path.getParentNode().type)) {
     args = concat(["[", args, "]"]);
   }
 
@@ -48,6 +47,22 @@ function printAryPtn(path, opts, print) {
   return args;
 }
 
+function printFndPtn(path, opts, print) {
+  const [constant] = path.getValue().body;
+
+  let args = [concat(["*", path.call(print, "body", 1)])]
+    .concat(path.map(print, "body", 2))
+    .concat(concat(["*", path.call(print, "body", 3)]));
+
+  args = concat(["[", group(join(concat([",", line]), args)), "]"]);
+
+  if (constant) {
+    return concat([path.call(print, "body", 0), args]);
+  }
+
+  return args;
+}
+
 function printHshPtn(path, opts, print) {
   const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
   let args = [];
@@ -80,10 +95,8 @@ function printHshPtn(path, opts, print) {
 
   if (constant) {
     args = concat(["[", args, "]"]);
-  } else if (
-    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
-  ) {
-    args = concat(["{", args, "}"]);
+  } else if (patterns.includes(path.getParentNode().type)) {
+    args = concat(["{ ", args, " }"]);
   }
 
   if (constant) {
@@ -111,8 +124,23 @@ function printIn(path, opts, print) {
   return group(concat(parts));
 }
 
+function printRAssign(path, opts, print) {
+  const { keyword } = path.getValue();
+  const [leftDoc, rightDoc] = path.map(print, "body");
+
+  return group(
+    concat([
+      leftDoc,
+      keyword ? " in" : " =>",
+      group(indent(concat([line, rightDoc])))
+    ])
+  );
+}
+
 module.exports = {
   aryptn: printAryPtn,
+  fndptn: printFndPtn,
   hshptn: printHshPtn,
-  in: printIn
+  in: printIn,
+  rassign: printRAssign
 };