prettier 0.12.2 → 0.12.3

data/src/nodes/constants.js

@@ -0,0 +1,25 @@
+const { concat, group, indent, join, softline } = require("../prettier");
+const { first, makeCall, prefix } = require("../utils");
+
+module.exports = {
+  const_path_field: (path, opts, print) => join("::", path.map(print, "body")),
+  const_path_ref: (path, opts, print) => join("::", path.map(print, "body")),
+  const_ref: first,
+  defined: (path, opts, print) =>
+    group(
+      concat([
+        "defined?(",
+        indent(concat([softline, path.call(print, "body", 0)])),
+        concat([softline, ")"])
+      ])
+    ),
+  field: (path, opts, print) =>
+    group(
+      concat([
+        path.call(print, "body", 0),
+        concat([makeCall(path, opts, print), path.call(print, "body", 2)])
+      ])
+    ),
+  top_const_field: prefix("::"),
+  top_const_ref: prefix("::")
+};

data/src/nodes/flow.js

@@ -0,0 +1,64 @@
+const { concat, join } = require("../prettier");
+const { literal } = require("../utils");
+
+module.exports = {
+  break: (path, opts, print) => {
+    const content = path.getValue().body[0];
+
+    if (content.body.length === 0) {
+      return "break";
+    }
+
+    if (content.body[0].body[0].type === "paren") {
+      return concat([
+        "break ",
+        path.call(print, "body", 0, "body", 0, "body", 0, "body", 0)
+      ]);
+    }
+
+    return concat(["break ", join(", ", path.call(print, "body", 0))]);
+  },
+  next: (path, opts, print) => {
+    const args = path.getValue().body[0].body[0];
+
+    if (!args) {
+      return "next";
+    }
+
+    if (args.body[0].type === "paren") {
+      // Ignoring the parens node and just going straight to the content
+      return concat([
+        "next ",
+        path.call(print, "body", 0, "body", 0, "body", 0, "body", 0)
+      ]);
+    }
+
+    return concat(["next ", join(", ", path.call(print, "body", 0))]);
+  },
+  return: (path, opts, print) => {
+    const args = path.getValue().body[0].body[0];
+
+    if (!args) {
+      return "return";
+    }
+
+    if (args.body[0] && args.body[0].type === "paren") {
+      // Ignoring the parens node and just going straight to the content
+      return concat([
+        "return ",
+        path.call(print, "body", 0, "body", 0, "body", 0, "body", 0)
+      ]);
+    }
+
+    return concat(["return ", join(", ", path.call(print, "body", 0))]);
+  },
+  return0: literal("return"),
+  yield: (path, opts, print) => {
+    if (path.getValue().body[0].type === "paren") {
+      return concat(["yield", path.call(print, "body", 0)]);
+    }
+
+    return concat(["yield ", join(", ", path.call(print, "body", 0))]);
+  },
+  yield0: literal("yield")
+};

data/src/nodes/hashes.js

@@ -6,8 +6,8 @@ const {
   join,
   line,
   literalline
-} = require("../builders");
-const { skipAssignIndent } = require("../utils");
+} = require("../prettier");
+const { prefix, skipAssignIndent } = require("../utils");
 
 const nodeDive = (node, steps) => {
   let current = node;
@@ -67,6 +67,7 @@ module.exports = {
 
     return group(concat(parts));
   },
+  assoc_splat: prefix("**"),
   assoclist_from_args: (path, opts, print) => {
     const { addTrailingCommas } = opts;
 

data/src/nodes/hooks.js

@@ -1,4 +1,4 @@
-const { concat, group, indent, line } = require("../builders");
+const { concat, group, indent, line } = require("../prettier");
 
 const printHook = name => (path, opts, print) =>
   group(

data/src/nodes/ints.js

@@ -0,0 +1,24 @@
+module.exports = {
+  "@int": (path, _opts, _print) => {
+    const { body } = path.getValue();
+
+    // If the number is octal and does not contain the optional "o" character
+    // after the leading 0, add it in.
+    if (/^0[0-9]/.test(body)) {
+      return `0o${body.slice(1)}`;
+    }
+
+    // If the number is a base 10 number, is sufficiently large, and is not
+    // already formatted with underscores, then add them in in between the
+    // numbers every three characters starting from the right.
+    if (!body.startsWith("0") && body.length >= 4 && !body.includes("_")) {
+      return `  ${body}`
+        .slice((body.length + 2) % 3)
+        .match(/.{3}/g)
+        .join("_")
+        .trim();
+    }
+
+    return body;
+  }
+};

data/src/nodes/lambdas.js

@@ -6,7 +6,7 @@ const {
   line,
   removeLines,
   softline
-} = require("../builders");
+} = require("../prettier");
 const { hasAncestor } = require("../utils");
 
 module.exports = {

data/src/nodes/loops.js

@@ -6,7 +6,7 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../builders");
+} = require("../prettier");
 
 const printLoop = keyword => (path, { inlineLoops }, print) =>
   group(

data/src/nodes/massign.js

@@ -0,0 +1,70 @@
+const { concat, group, indent, join, line, softline } = require("../prettier");
+const { makeList } = require("../utils");
+
+module.exports = {
+  massign: (path, opts, print) => {
+    let right = path.call(print, "body", 1);
+
+    if (
+      ["mrhs_add_star", "mrhs_new_from_args"].includes(
+        path.getValue().body[1].type
+      )
+    ) {
+      right = group(join(concat([",", line]), right));
+    }
+
+    return group(
+      concat([
+        group(join(concat([",", line]), path.call(print, "body", 0))),
+        " =",
+        indent(concat([line, right]))
+      ])
+    );
+  },
+  mlhs: makeList,
+  mlhs_add_post: (path, opts, print) =>
+    path.call(print, "body", 0).concat(path.call(print, "body", 1)),
+  mlhs_add_star: (path, opts, print) =>
+    path
+      .call(print, "body", 0)
+      .concat([
+        path.getValue().body[1]
+          ? concat(["*", path.call(print, "body", 1)])
+          : "*"
+      ]),
+  mlhs_paren: (path, opts, print) => {
+    if (["massign", "mlhs_paren"].includes(path.getParentNode().type)) {
+      // If we're nested in brackets as part of the left hand side of an
+      // assignment, i.e., (a, b, c) = 1, 2, 3
+      // ignore the current node and just go straight to the content
+      return path.call(print, "body", 0);
+    }
+
+    return group(
+      concat([
+        "(",
+        indent(
+          concat([
+            softline,
+            join(concat([",", line]), path.call(print, "body", 0))
+          ])
+        ),
+        concat([softline, ")"])
+      ])
+    );
+  },
+  mrhs: makeList,
+  mrhs_add_star: (path, opts, print) =>
+    path
+      .call(print, "body", 0)
+      .concat([concat(["*", path.call(print, "body", 1)])]),
+  mrhs_new_from_args: (path, opts, print) => {
+    const parts = path.call(print, "body", 0);
+
+    if (path.getValue().body.length > 1) {
+      parts.push(path.call(print, "body", 1));
+    }
+
+    return parts;
+  }
+};

data/src/nodes/methods.js

@@ -1,4 +1,13 @@
-const { concat, group, hardline, indent } = require("../builders");
+const {
+  align,
+  concat,
+  group,
+  hardline,
+  indent,
+  join,
+  line
+} = require("../prettier");
+const { first, literal } = require("../utils");
 
 const printMethod = offset => (path, opts, print) => {
   const [_name, params, body] = path.getValue().body.slice(offset);
@@ -37,6 +46,35 @@ const printMethod = offset => (path, opts, print) => {
 };
 
 module.exports = {
+  access_ctrl: first,
   def: printMethod(0),
-  defs: printMethod(2)
+  defs: printMethod(2),
+  methref: (path, opts, print) => join(".:", path.map(print, "body")),
+  super: (path, opts, print) => {
+    const args = path.getValue().body[0];
+
+    if (args.type === "arg_paren") {
+      // In case there are explicitly no arguments but they are using parens,
+      // we assume they are attempting to override the initializer and pass no
+      // arguments up.
+      if (args.body[0] === null) {
+        return "super()";
+      }
+
+      return concat(["super", path.call(print, "body", 0)]);
+    }
+
+    return concat(["super ", join(", ", path.call(print, "body", 0))]);
+  },
+  undef: (path, opts, print) =>
+    group(
+      concat([
+        "undef ",
+        align(
+          "undef ".length,
+          join(concat([",", line]), path.map(print, "body", 0))
+        )
+      ])
+    ),
+  zsuper: literal("super")
 };

data/src/nodes/operators.js

@@ -0,0 +1,44 @@
+const { concat, group, indent, line, softline } = require("../prettier");
+
+module.exports = {
+  binary: (path, opts, print) => {
+    const operator = path.getValue().body[1];
+    const useNoSpace = operator === "**";
+
+    return group(
+      concat([
+        concat([path.call(print, "body", 0), useNoSpace ? "" : " "]),
+        operator,
+        indent(
+          concat([useNoSpace ? softline : line, path.call(print, "body", 2)])
+        )
+      ])
+    );
+  },
+  dot2: (path, opts, print) =>
+    concat([
+      path.call(print, "body", 0),
+      "..",
+      path.getValue().body[1] ? path.call(print, "body", 1) : ""
+    ]),
+  dot3: (path, opts, print) =>
+    concat([
+      path.call(print, "body", 0),
+      "...",
+      path.getValue().body[1] ? path.call(print, "body", 1) : ""
+    ]),
+  unary: (path, opts, print) => {
+    const oper = path.getValue().body[0];
+    const doc = path.call(print, "body", 1);
+
+    if (oper === "not") {
+      // For the `not` operator, we're explicitly making the space character
+      // another element in the `concat` because there are some circumstances
+      // where we need to force parentheses (e.g., ternaries). In that case the
+      // printer for those nodes can just take out the space and put in parens.
+      return concat(["not", " ", doc]);
+    }
+
+    return concat([oper[0], doc]);
+  }
+};

data/src/nodes/params.js

@@ -1,4 +1,4 @@
-const { concat, group, join, line } = require("../builders");
+const { concat, group, join, line } = require("../prettier");
 
 const printGenericRestParam = symbol => (path, opts, print) =>
   path.getValue().body[0]
@@ -33,7 +33,7 @@ const printParams = (path, opts, print) => {
     );
   }
 
-  if (rest) {
+  if (rest && rest.type !== "excessed_comma") {
     parts.push(path.call(print, "body", 2));
   }
 
@@ -60,7 +60,18 @@ const printParams = (path, opts, print) => {
     parts.push(path.call(print, "body", 6));
   }
 
-  return group(join(concat([",", line]), parts));
+  // You can put an extra comma at the end of block args between pipes to
+  // change what it does. Below is the difference:
+  //
+  // [[1, 2], [3, 4]].each { |x| p x } # prints [1, 2] then [3, 4]
+  // [[1, 2], [3, 4]].each { |x,| p x } # prints 1 then 3
+  //
+  // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
+  // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
+  // node in the rest position. Seems odd, but it's true.
+  const comma = rest === 0 || (rest && rest.type === "excessed_comma");
+
+  return group(concat([join(concat([",", line]), parts), comma ? "," : ""]));
 };
 
 const paramError = () => {

data/src/nodes/regexp.js

@@ -1,4 +1,4 @@
-const { concat } = require("../builders");
+const { concat } = require("../prettier");
 const { makeList } = require("../utils");
 
 module.exports = {

data/src/nodes/rescue.js

@@ -6,7 +6,7 @@ const {
   indent,
   join,
   line
-} = require("../builders");
+} = require("../prettier");
 const { literal } = require("../utils");
 
 module.exports = {

data/src/nodes/scopes.js

@@ -0,0 +1,61 @@
+const {
+  concat,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  line
+} = require("../prettier");
+
+module.exports = {
+  class: (path, opts, print) => {
+    const [_constant, superclass, statements] = path.getValue().body;
+
+    const parts = ["class ", path.call(print, "body", 0)];
+    if (superclass) {
+      parts.push(" < ", path.call(print, "body", 1));
+    }
+
+    // If the body is empty, we can replace with a ;
+    const stmts = statements.body[0].body;
+    if (stmts.length === 1 && stmts[0].type === "void_stmt") {
+      return group(concat([concat(parts), ifBreak(line, "; "), "end"]));
+    }
+
+    return group(
+      concat([
+        concat(parts),
+        indent(concat([hardline, path.call(print, "body", 2)])),
+        concat([hardline, "end"])
+      ])
+    );
+  },
+  class_name_error: (_path, _opts, _print) => {
+    throw new Error("class/module name must be CONSTANT");
+  },
+  module: (path, opts, print) => {
+    const declaration = group(concat(["module ", path.call(print, "body", 0)]));
+
+    // If the body is empty, we can replace with a ;
+    const stmts = path.getValue().body[1].body[0].body;
+    if (stmts.length === 1 && stmts[0].type === "void_stmt") {
+      return group(concat([declaration, ifBreak(line, "; "), "end"]));
+    }
+
+    return group(
+      concat([
+        declaration,
+        indent(concat([hardline, path.call(print, "body", 1)])),
+        concat([hardline, "end"])
+      ])
+    );
+  },
+  sclass: (path, opts, print) =>
+    group(
+      concat([
+        concat(["class << ", path.call(print, "body", 0)]),
+        indent(concat([hardline, path.call(print, "body", 1)])),
+        concat([hardline, "end"])
+      ])
+    )
+};