prettier 0.21.0 → 0.22.0

data/src/printer.js

@@ -0,0 +1,88 @@
+const { concat, trim } = require("./prettier");
+
+const embed = require("./embed");
+const nodes = require("./nodes");
+
+// This is the generic node print function, used to convert any node in the AST
+// into its equivalent Doc representation.
+function printNode(path, opts, print) {
+  const { type, body } = path.getValue();
+
+  if (type in nodes) {
+    return nodes[type](path, opts, print);
+  }
+
+  if (type[0] === "@") {
+    return body;
+  }
+
+  const ast = JSON.stringify(body, null, 2);
+  throw new Error(`Unsupported node encountered: ${type}\n${ast}`);
+}
+
+const noComments = [
+  "args",
+  "args_add_block",
+  "args_add_star",
+  "mlhs",
+  "mlhs_add_post",
+  "mlhs_add_star"
+];
+
+// Certain nodes are used more for organizational purposed than for actually
+// displaying content, so we tell prettier that we don't want comments attached
+// to them.
+function canAttachComment(node) {
+  return !noComments.includes(node.type);
+}
+
+// This function tells prettier how to recurse down our AST so that it can find
+// where it needs to attach the comments.
+function getCommentChildNodes(node) {
+  switch (node.type) {
+    case "rescue":
+      return node.body[0].concat(node.body.slice(1));
+    case "aryptn":
+      return [node.body[0]]
+        .concat(node.body[1])
+        .concat(node.body[2])
+        .concat(node.body[3]);
+    case "hshptn": {
+      const pairs = node.body[1];
+      const values = pairs.reduce((left, right) => left.concat(right), []);
+
+      return [node.body[0]].concat(values).concat(node.body[2]);
+    }
+    default:
+      return node.body;
+  }
+}
+
+// This is the generic print function for any comment in the AST. It handles
+// both regular comments that begin with a # and embdoc comments, which are
+// surrounded by =begin..=end.
+function printComment(path, _opts) {
+  const comment = path.getValue();
+
+  if (comment.type === "@comment") {
+    return `#${comment.value}`;
+  }
+
+  return concat([trim, comment.value]);
+}
+
+// To be honest I'm not 100% sure this function is actually necessary, but it
+// *feels* like a block comment equivalent in JavaScript so I'm going to leave
+// it in place for now.
+function isBlockComment(comment) {
+  return comment.type === "@embdoc";
+}
+
+module.exports = {
+  embed,
+  print: printNode,
+  canAttachComment,
+  getCommentChildNodes,
+  printComment,
+  isBlockComment
+};

data/src/ruby.js

@@ -1,12 +1,5 @@
-const embed = require("./embed");
-const parse = require("./parse");
-const print = require("./print");
-
-const pragmaPattern = /#\s*@(prettier|format)/;
-const hasPragma = (text) => pragmaPattern.test(text);
-
-const locStart = (node) => node.char_start;
-const locEnd = (node) => node.char_end;
+const printer = require("./printer");
+const parser = require("./parser");
 
 /*
  * metadata mostly pulled from linguist and rubocop:
@@ -77,19 +70,10 @@ module.exports = {
     }
   ],
   parsers: {
-    ruby: {
-      parse,
-      astFormat: "ruby",
-      hasPragma,
-      locStart,
-      locEnd
-    }
+    ruby: parser
   },
   printers: {
-    ruby: {
-      embed,
-      print
-    }
+    ruby: printer
   },
   options: {
     addTrailingCommas: {

data/src/toProc.js

@@ -57,9 +57,9 @@ const toProc = (path, opts, node) => {
     return null;
   }
 
-  // Ensure that statement is a call
+  // Ensure that statement is a call and that it has no comments attached
   const [statement] = statements.body;
-  if (statement.type !== "call") {
+  if (statement.type !== "call" || statement.comments) {
     return null;
   }
 

data/src/utils.js

@@ -1,19 +1,15 @@
-const {
-  breakParent,
-  concat,
-  hardline,
-  lineSuffix,
-  literalline
-} = require("./prettier");
+const { concat } = require("./prettier");
 const isEmptyStmts = require("./utils/isEmptyStmts");
+const literalLineNoBreak = require("./utils/literalLineNoBreak");
 
 const concatBody = (path, opts, print) => concat(path.map(print, "body"));
 
 // If the node is a type of assignment or if the node is a paren and nested
 // inside that paren is a node that is a type of assignment.
 const containsAssignment = (node) =>
-  ["assign", "massign"].includes(node.type) ||
-  (node.type === "paren" && node.body[0].body.some(containsAssignment));
+  node &&
+  (["assign", "massign", "opassign"].includes(node.type) ||
+    (Array.isArray(node.body) && node.body.some(containsAssignment)));
 
 const docLength = (doc) => {
   if (doc.length) {
@@ -53,34 +49,6 @@ const hasAncestor = (path, types) => {
 
 const literal = (value) => () => value;
 
-const makeArgs = (path, opts, print, argsIndex) => {
-  let argNodes = path.getValue().body[argsIndex];
-  const argPattern = [print, "body", argsIndex, "body"];
-
-  if (argNodes.type === "args_add_block") {
-    [argNodes] = argNodes.body;
-    argPattern.push(0, "body");
-  }
-
-  const args = path.call(print, "body", argsIndex);
-  const heredocs = [];
-
-  argNodes.body.forEach((argNode, index) => {
-    if (argNode.type === "heredoc") {
-      const content = path.map.apply(
-        path,
-        argPattern.slice().concat([index, "body"])
-      );
-      heredocs.push(
-        concat([literalline].concat(content).concat([argNode.ending]))
-      );
-      args[index] = argNode.beging;
-    }
-  });
-
-  return { args, heredocs };
-};
-
 const makeCall = (path, opts, print) => {
   const operation = path.getValue().body[1];
 
@@ -91,53 +59,13 @@ const makeCall = (path, opts, print) => {
   return operation === "::" ? "." : path.call(print, "body", 1);
 };
 
-const makeList = (path, opts, print) => path.map(print, "body");
-
-const nodeDive = (node, steps) => {
-  let current = node;
-
-  steps.forEach((step) => {
-    current = current[step];
-  });
-
-  return current;
-};
-
 const prefix = (value) => (path, opts, print) =>
   concat([value, path.call(print, "body", 0)]);
 
-const printComments = (printed, start, comments) => {
-  let node = printed;
-
-  comments.forEach((comment) => {
-    if (comment.start < start) {
-      node = concat([
-        comment.break ? breakParent : "",
-        comment.body,
-        hardline,
-        node
-      ]);
-    } else {
-      node = concat([
-        node,
-        comment.break ? breakParent : "",
-        lineSuffix(` ${comment.body}`)
-      ]);
-    }
-  });
-
-  return node;
-};
-
+const skippable = ["array", "hash", "heredoc", "lambda", "regexp_literal"];
 const skipAssignIndent = (node) =>
-  ["array", "hash", "heredoc", "lambda", "regexp_literal"].includes(
-    node.type
-  ) ||
-  (node.type === "call" && skipAssignIndent(node.body[0])) ||
-  (node.type === "string_literal" && node.body[0].type === "heredoc");
-
-const surround = (left, right) => (path, opts, print) =>
-  concat([left, path.call(print, "body", 0), right]);
+  skippable.includes(node.type) ||
+  (node.type === "call" && skipAssignIndent(node.body[0]));
 
 module.exports = {
   concatBody,
@@ -148,12 +76,8 @@ module.exports = {
   hasAncestor,
   isEmptyStmts,
   literal,
-  makeArgs,
+  literalLineNoBreak,
   makeCall,
-  makeList,
-  nodeDive,
   prefix,
-  printComments,
-  skipAssignIndent,
-  surround
+  skipAssignIndent
 };

data/src/utils/literalLineNoBreak.js

@@ -0,0 +1,7 @@
+const literalLineNoBreak = {
+  type: "line",
+  hard: true,
+  literal: true
+};
+
+module.exports = literalLineNoBreak;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-02 00:00:00.000000000 Z
+date: 2020-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,11 +82,13 @@ files:
 - src/nodes/blocks.js
 - src/nodes/calls.js
 - src/nodes/case.js
+- src/nodes/class.js
 - src/nodes/commands.js
 - src/nodes/conditionals.js
 - src/nodes/constants.js
 - src/nodes/flow.js
 - src/nodes/hashes.js
+- src/nodes/heredocs.js
 - src/nodes/hooks.js
 - src/nodes/ints.js
 - src/nodes/lambdas.js
@@ -99,18 +101,20 @@ files:
 - src/nodes/regexp.js
 - src/nodes/rescue.js
 - src/nodes/return.js
-- src/nodes/scopes.js
 - src/nodes/statements.js
 - src/nodes/strings.js
-- src/parse.js
+- src/nodes/super.js
+- src/nodes/undef.js
+- src/parser.js
 - src/parser.rb
 - src/prettier.js
-- src/print.js
+- src/printer.js
 - src/ruby.js
 - src/toProc.js
 - src/utils.js
 - src/utils/inlineEnsureParens.js
 - src/utils/isEmptyStmts.js
+- src/utils/literalLineNoBreak.js
 homepage: https://github.com/prettier/plugin-ruby#readme
 licenses:
 - MIT

data/src/nodes/scopes.js

@@ -1,61 +0,0 @@
-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"])
-      ])
-    )
-};

data/src/parse.js

@@ -1,37 +0,0 @@
-const { spawnSync } = require("child_process");
-const path = require("path");
-
-// In order to properly parse ruby code, we need to tell the ruby process to
-// parse using UTF-8. Unfortunately, the way that you accomplish this looks
-// differently depending on your platform. This object below represents all of
-// the possible values of process.platform per:
-//   https://nodejs.org/api/process.html#process_process_platform
-const LANG = {
-  aix: "C.UTF-8",
-  darwin: "en_US.UTF-8",
-  freebsd: "C.UTF-8",
-  linux: "C.UTF-8",
-  openbsd: "C.UTF-8",
-  sunos: "C.UTF-8",
-  win32: ".UTF-8"
-}[process.platform];
-
-module.exports = (text, _parsers, _opts) => {
-  const child = spawnSync(
-    "ruby",
-    ["--disable-gems", path.join(__dirname, "./parser.rb")],
-    {
-      env: Object.assign({}, process.env, { LANG }),
-      input: text,
-      maxBuffer: 10 * 1024 * 1024 // 10MB
-    }
-  );
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
-};

data/src/print.js

@@ -1,23 +0,0 @@
-const { printComments } = require("./utils");
-const nodes = require("./nodes");
-
-module.exports = (path, opts, print) => {
-  const { type, body, comments, start } = path.getValue();
-
-  if (type in nodes) {
-    const printed = nodes[type](path, opts, print);
-
-    if (comments) {
-      return printComments(printed, start, comments);
-    }
-    return printed;
-  }
-
-  if (type[0] === "@") {
-    return body;
-  }
-
-  throw new Error(
-    `Unsupported node encountered: ${type}\n${JSON.stringify(body, null, 2)}`
-  );
-};