prettier 0.12.2

data/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@prettier/plugin-ruby",
+  "version": "0.12.2",
+  "description": "prettier plugin for the Ruby programming language",
+  "main": "src/ruby.js",
+  "scripts": {
+    "lint": "eslint --cache .",
+    "print": "prettier --plugin=.",
+    "rubocop": "run() { prettier --plugin=. $@ | bundle exec rubocop --stdin $1; }; run",
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prettier/plugin-ruby.git"
+  },
+  "author": "Kevin Deisz",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/prettier/plugin-ruby/issues"
+  },
+  "homepage": "https://github.com/prettier/plugin-ruby#readme",
+  "dependencies": {
+    "prettier": "^1.16.4"
+  },
+  "devDependencies": {
+    "all-contributors-cli": "^6.1.2",
+    "eslint": "^5.15.0",
+    "eslint-config-airbnb-base": "^13.1.0",
+    "eslint-config-prettier": "^4.1.0",
+    "eslint-plugin-import": "^2.16.0",
+    "jest": "^24.0.0"
+  },
+  "jest": {
+    "setupFilesAfterEnv": [
+      "./test/js/setupTests.js"
+    ],
+    "testRegex": ".test.js$"
+  }
+}

data/src/builders.js

@@ -0,0 +1,9 @@
+// If `RBPRETTIER` is set, then this is being run from the `Prettier::run` ruby
+// method. In that case, we need to pull `prettier` from the node_modules
+// directly, as it's been shipped with the gem.
+const source = process.env.RBPRETTIER ? "../node_modules/prettier" : "prettier";
+
+// eslint-disable-next-line import/no-dynamic-require
+const { builders, utils } = require(source).doc;
+
+module.exports = Object.assign({}, builders, utils);

data/src/escapePattern.js

@@ -0,0 +1,45 @@
+/**
+ * String literal syntax documentation from Ruby source (2.7.0-dev)
+ *
+ * Double-quote strings allow escaped characters such as <tt>\n</tt> for
+ * newline, <tt>\t</tt> for tab, etc.  The full list of supported escape
+ * sequences are as follows:
+ *
+ *   \a             bell, ASCII 07h (BEL)
+ *   \b             backspace, ASCII 08h (BS)
+ *   \t             horizontal tab, ASCII 09h (TAB)
+ *   \n             newline (line feed), ASCII 0Ah (LF)
+ *   \v             vertical tab, ASCII 0Bh (VT)
+ *   \f             form feed, ASCII 0Ch (FF)
+ *   \r             carriage return, ASCII 0Dh (CR)
+ *   \e             escape, ASCII 1Bh (ESC)
+ *   \s             space, ASCII 20h (SPC)
+ *   \\             backslash, \
+ *   \nnn           octal bit pattern, where nnn is 1-3 octal digits ([0-7])
+ *   \xnn           hexadecimal bit pattern, where nn is 1-2 hexadecimal digits ([0-9a-fA-F])
+ *   \unnnn         Unicode character, where nnnn is exactly 4 hexadecimal digits ([0-9a-fA-F])
+ *   \u{nnnn ...}   Unicode character(s), where each nnnn is 1-6 hexadecimal digits ([0-9a-fA-F])
+ *   \cx or \C-x    control character, where x is an ASCII printable character
+ *   \M-x           meta character, where x is an ASCII printable character
+ *   \M-\C-x        meta control character, where x is an ASCII printable character
+ *   \M-\cx         same as above
+ *   \c\M-x         same as above
+ *   \c? or \C-?    delete, ASCII 7Fh (DEL)
+ *
+ * In addition to disabling interpolation, single-quoted strings also disable all
+ * escape sequences except for the single-quote (<tt>\'</tt>) and backslash
+ * (<tt>\\\\</tt>).
+ */
+const patterns = [
+  "[abtnvfres\\\\]", // simple
+  "[0-7]{1,3}", // octal bits
+  "x[0-9a-fA-F]{1,2}", // hex bit
+  "u[0-9a-fA-F]{4}", // unicode char
+  "u\\{[0-9a-fA-F ]+\\}", // unicode chars
+  "c[ -~]|C\\-[ -~]", // control
+  "M\\-[ -~]", // meta
+  "M\\-\\\\C\\-[ -~]|M\\-\\\\c[ -~]|c\\\\M\\-[ -~]", // meta control
+  "c\\?|C\\-\\?" // delete
+];
+
+module.exports = new RegExp(`\\\\(${patterns.join("|")})`);

data/src/nodes.js

@@ -0,0 +1,594 @@
+const {
+  align,
+  breakParent,
+  concat,
+  dedent,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  join,
+  line,
+  literalline,
+  markAsRoot,
+  removeLines,
+  softline,
+  trim
+} = require("./builders");
+
+const toProc = require("./toProc");
+const {
+  concatBody,
+  empty,
+  first,
+  literal,
+  makeArgs,
+  makeCall,
+  makeList,
+  prefix,
+  skipAssignIndent
+} = require("./utils");
+
+const nodes = {
+  "@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 decimal 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;
+  },
+  "@__end__": (path, _opts, _print) => {
+    const { body } = path.getValue();
+    return concat([trim, "__END__", literalline, body]);
+  },
+  access_ctrl: first,
+  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;
+  },
+  assoc_splat: prefix("**"),
+  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");
+  },
+  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)])
+        )
+      ])
+    );
+  },
+  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);
+  },
+  blockarg: (path, opts, print) => concat(["&", path.call(print, "body", 0)]),
+  bodystmt: (path, opts, print) => {
+    const [_statements, rescue, elseClause, ensure] = path.getValue().body;
+    const parts = [path.call(print, "body", 0)];
+
+    if (rescue) {
+      parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
+    }
+
+    if (elseClause) {
+      // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+      const stmts =
+        elseClause.type === "else"
+          ? path.call(print, "body", 2, "body", 0)
+          : path.call(print, "body", 2);
+
+      parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
+    }
+
+    if (ensure) {
+      parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
+    }
+
+    return group(concat(parts));
+  },
+  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))]);
+  },
+  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");
+  },
+  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, ")"])
+      ])
+    ),
+  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) : ""
+    ]),
+  dyna_symbol: (path, opts, print) => {
+    const { quote } = path.getValue().body[0];
+
+    return concat([":", quote, concat(path.call(print, "body", 0)), quote]);
+  },
+  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)]))
+    ]);
+  },
+  embdoc: (path, _opts, _print) => concat([trim, path.getValue().body]),
+  excessed_comma: empty,
+  fcall: concatBody,
+  field: (path, opts, print) =>
+    group(
+      concat([
+        path.call(print, "body", 0),
+        concat([makeCall(path, opts, print), path.call(print, "body", 2)])
+      ])
+    ),
+  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]))
+      ])
+    );
+  },
+  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"));
+  },
+  methref: (path, opts, print) => join(".:", path.map(print, "body")),
+  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;
+  },
+  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"])
+      ])
+    );
+  },
+  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))]);
+  },
+  number_arg: first,
+  opassign: (path, opts, print) =>
+    group(
+      concat([
+        path.call(print, "body", 0),
+        " ",
+        path.call(print, "body", 1),
+        indent(concat([line, path.call(print, "body", 2)]))
+      ])
+    ),
+  paren: (path, opts, print) => {
+    if (!path.getValue().body[0]) {
+      return "()";
+    }
+
+    let content = path.call(print, "body", 0);
+
+    if (
+      ["args", "args_add_star", "args_add_block"].includes(
+        path.getValue().body[0].type
+      )
+    ) {
+      content = join(concat([",", line]), content);
+    }
+
+    return group(
+      concat([
+        "(",
+        indent(concat([softline, content])),
+        concat([softline, ")"])
+      ])
+    );
+  },
+  program: (path, opts, print) =>
+    markAsRoot(
+      concat([join(literalline, path.map(print, "body")), literalline])
+    ),
+  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"),
+  sclass: (path, opts, print) =>
+    group(
+      concat([
+        concat(["class << ", path.call(print, "body", 0)]),
+        indent(concat([hardline, path.call(print, "body", 1)])),
+        concat([hardline, "end"])
+      ])
+    ),
+  stmts: (path, opts, print) => {
+    const stmts = path.getValue().body;
+    const parts = [];
+    let lineNo = null;
+
+    stmts.forEach((stmt, index) => {
+      if (stmt.type === "void_stmt") {
+        return;
+      }
+
+      const printed = path.call(print, "body", index);
+
+      if (lineNo === null) {
+        parts.push(printed);
+      } else if (
+        stmt.start - lineNo > 1 ||
+        [stmt.type, stmts[index - 1].type].includes("access_ctrl")
+      ) {
+        parts.push(hardline, hardline, printed);
+      } else if (
+        stmt.start !== lineNo ||
+        path.getParentNode().type !== "string_embexpr"
+      ) {
+        parts.push(hardline, printed);
+      } else {
+        parts.push("; ", printed);
+      }
+
+      lineNo = stmt.end;
+    });
+
+    return concat(parts);
+  },
+  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))]);
+  },
+  symbol: prefix(":"),
+  symbol_literal: concatBody,
+  top_const_field: prefix("::"),
+  top_const_ref: prefix("::"),
+  unary: (path, opts, print) => {
+    const operator = path.getValue().body[0];
+
+    return concat([
+      operator === "not" ? "not " : operator[0],
+      path.call(print, "body", 1)
+    ]);
+  },
+  undef: (path, opts, print) =>
+    group(
+      concat([
+        "undef ",
+        align(
+          "undef ".length,
+          join(concat([",", line]), path.map(print, "body", 0))
+        )
+      ])
+    ),
+  var_field: concatBody,
+  var_ref: first,
+  vcall: first,
+  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"),
+  zsuper: literal("super")
+};
+
+module.exports = Object.assign(
+  {},
+  require("./nodes/alias"),
+  require("./nodes/arrays"),
+  require("./nodes/blocks"),
+  require("./nodes/calls"),
+  require("./nodes/case"),
+  require("./nodes/commands"),
+  require("./nodes/conditionals"),
+  require("./nodes/hashes"),
+  require("./nodes/hooks"),
+  require("./nodes/lambdas"),
+  require("./nodes/loops"),
+  require("./nodes/methods"),
+  require("./nodes/params"),
+  require("./nodes/regexp"),
+  require("./nodes/rescue"),
+  require("./nodes/strings"),
+  nodes
+);