prettier 0.21.0 → 1.0.1

data/src/printer.js

@@ -0,0 +1,90 @@
+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 "heredoc":
+      return [node.beging];
+    case "rescue":
+      return [].concat(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,59 +70,43 @@ module.exports = {
     }
   ],
   parsers: {
-    ruby: {
-      parse,
-      astFormat: "ruby",
-      hasPragma,
-      locStart,
-      locEnd
-    }
+    ruby: parser
   },
   printers: {
-    ruby: {
-      embed,
-      print
-    }
+    ruby: printer
   },
   options: {
-    addTrailingCommas: {
-      type: "boolean",
-      category: "Global",
-      default: false,
-      description:
-        "Adds a trailing comma to array literals, hash literals, and method calls."
-    },
-    inlineConditionals: {
+    rubyArrayLiteral: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
-        "When it fits on one line, allows if and unless statements to use the modifier form."
+        "When possible, favor the use of string and symbol array literals."
     },
-    inlineLoops: {
+    rubyHashLabel: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
-        "When it fits on one line, allows while and until statements to use the modifier form."
+        "When possible, uses the shortened hash key syntax, as opposed to hash rockets."
     },
-    preferHashLabels: {
+    rubyModifier: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
-        "When possible, uses the shortened hash key syntax, as opposed to hash rockets."
+        "When it fits on one line, allows if, unless, while, and until statements to use the modifier form."
     },
-    preferSingleQuotes: {
+    rubySingleQuote: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
         "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals."
     },
-    toProcTransform: {
+    rubyToProc: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: false,
       description:
         "When possible, convert blocks to the more concise Symbol#to_proc syntax."
@@ -137,6 +114,7 @@ module.exports = {
   },
   defaultOptions: {
     printWidth: 80,
-    tabWidth: 2
+    tabWidth: 2,
+    trailingComma: "none"
   }
 };

data/src/toProc.js

@@ -11,8 +11,8 @@ const isCall = (node) => ["::", "."].includes(node) || node.type === "@period";
 //     [1, 2, 3].map(&:to_s)
 //
 // This works with `do` blocks as well.
-const toProc = (path, opts, node) => {
-  if (!node || !opts.toProcTransform) {
+const toProc = (path, node) => {
+  if (!node) {
     return null;
   }
 
@@ -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,14 @@
-const {
-  breakParent,
-  concat,
-  hardline,
-  lineSuffix,
-  literalline
-} = require("./prettier");
+const { concat } = require("./prettier");
 const isEmptyStmts = require("./utils/isEmptyStmts");
-
-const concatBody = (path, opts, print) => concat(path.map(print, "body"));
+const literalLineNoBreak = require("./utils/literalLineNoBreak");
+const printEmptyCollection = require("./utils/printEmptyCollection");
 
 // 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) {
@@ -35,6 +30,8 @@ const empty = () => "";
 
 const first = (path, opts, print) => path.call(print, "body", 0);
 
+const getTrailingComma = (opts) => ["all", "es5"].includes(opts.trailingComma);
+
 const hasAncestor = (path, types) => {
   let parent = 0;
   let parentNode = path.getParentNode();
@@ -53,34 +50,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,69 +60,36 @@ 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 noIndent = [
+  "array",
+  "hash",
+  "heredoc",
+  "if",
+  "method_add_block",
+  "xstring_literal"
+];
 
 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,
   containsAssignment,
   docLength,
   empty,
   first,
+  getTrailingComma,
   hasAncestor,
   isEmptyStmts,
   literal,
-  makeArgs,
+  literalLineNoBreak,
   makeCall,
-  makeList,
-  nodeDive,
+  noIndent,
   prefix,
-  printComments,
-  skipAssignIndent,
-  surround
+  printEmptyCollection,
+  skipAssignIndent
 };

data/src/utils/literalLineNoBreak.js

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

data/src/utils/printEmptyCollection.js

@@ -0,0 +1,42 @@
+const { concat, group, hardline, indent, join, line } = require("../prettier");
+
+// Empty collections are array or hash literals that do not contain any
+// contents. They can, however, have comments inside the body. You can solve
+// this by having a child node inside the array that gets the comments attached
+// to it, but that requires modifying the parser. Instead, we can just manually
+// print out the non-leading comments here.
+function printEmptyCollection(path, opts, startToken, endToken) {
+  const node = path.getValue();
+
+  // If there are no comments or only leading comments, then we can just print
+  // out the start and end token and be done, as there are no comments inside
+  // the body of this node.
+  if (!node.comments || !node.comments.some((comment) => !comment.leading)) {
+    return `${startToken}${endToken}`;
+  }
+
+  const comments = [];
+
+  // For each comment, go through its path and print it out manually.
+  const printComment = (commentPath) => {
+    const comment = commentPath.getValue();
+
+    if (!comment.leading) {
+      comment.printed = true;
+      comments.push(opts.printer.printComment(commentPath));
+    }
+  };
+
+  path.each(printComment, "comments");
+
+  return group(
+    concat([
+      startToken,
+      indent(concat([hardline, join(hardline, comments)])),
+      line,
+      endToken
+    ])
+  );
+}
+
+module.exports = printEmptyCollection;

metadata

@@ -1,57 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.13'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
+date: 2020-12-12 00:00:00.000000000 Z
+dependencies: []
 description:
 email:
 executables:
@@ -82,11 +40,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 +59,21 @@ 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
+- src/utils/printEmptyCollection.js
 homepage: https://github.com/prettier/plugin-ruby#readme
 licenses:
 - MIT
@@ -130,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language