prettier 1.0.1 → 1.2.3

data/src/{printer.js → ruby/printer.js}

@@ -1,4 +1,4 @@
-const { concat, trim } = require("./prettier");
+const { concat, trim } = require("../prettier");
 
 const embed = require("./embed");
 const nodes = require("./nodes");
@@ -20,6 +20,18 @@ function printNode(path, opts, print) {
   throw new Error(`Unsupported node encountered: ${type}\n${ast}`);
 }
 
+// This is an escape-hatch to ignore nodes in the tree. If you have a comment
+// that includes this pattern, then the entire node will be ignored and just the
+// original source will be printed out.
+function hasPrettierIgnore(path) {
+  const node = path.getValue();
+
+  return (
+    node.comments &&
+    node.comments.some((comment) => comment.value.includes("prettier-ignore"))
+  );
+}
+
 const noComments = [
   "args",
   "args_add_block",
@@ -55,6 +67,38 @@ function getCommentChildNodes(node) {
 
       return [node.body[0]].concat(values).concat(node.body[2]);
     }
+    case "params": {
+      const [reqs, optls, rest, post, kwargs, kwargRest, block] = node.body;
+      let parts = reqs || [];
+
+      (optls || []).forEach((optl) => {
+        parts = parts.concat(optl);
+      });
+
+      if (rest) {
+        parts.push(rest);
+      }
+
+      parts = parts.concat(post || []);
+
+      (kwargs || []).forEach((kwarg) => {
+        if (kwarg[1]) {
+          parts = parts.concat(kwarg);
+        } else {
+          parts.push(kwarg[0]);
+        }
+      });
+
+      if (kwargRest && kwargRest !== "nil") {
+        parts.push(kwargRest);
+      }
+
+      if (block) {
+        parts.push(block);
+      }
+
+      return parts;
+    }
     default:
       return node.body;
   }
@@ -83,6 +127,7 @@ function isBlockComment(comment) {
 module.exports = {
   embed,
   print: printNode,
+  hasPrettierIgnore,
   canAttachComment,
   getCommentChildNodes,
   printComment,

data/src/utils.js

@@ -1,95 +1,12 @@
-const { concat } = require("./prettier");
-const isEmptyStmts = require("./utils/isEmptyStmts");
-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) =>
-  node &&
-  (["assign", "massign", "opassign"].includes(node.type) ||
-    (Array.isArray(node.body) && node.body.some(containsAssignment)));
-
-const docLength = (doc) => {
-  if (doc.length) {
-    return doc.length;
-  }
-
-  if (doc.parts) {
-    return doc.parts.reduce((sum, child) => sum + docLength(child), 0);
-  }
-
-  if (doc.contents) {
-    return docLength(doc.contents);
-  }
-
-  return 0;
-};
-
-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();
-
-  while (parentNode) {
-    if (types.includes(parentNode.type)) {
-      return true;
-    }
-
-    parent += 1;
-    parentNode = path.getParentNode(parent);
-  }
-
-  return false;
-};
-
-const literal = (value) => () => value;
-
-const makeCall = (path, opts, print) => {
-  const operation = path.getValue().body[1];
-
-  if ([".", "&."].includes(operation)) {
-    return operation;
-  }
-
-  return operation === "::" ? "." : path.call(print, "body", 1);
-};
-
-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 skippable = ["array", "hash", "heredoc", "lambda", "regexp_literal"];
-const skipAssignIndent = (node) =>
-  skippable.includes(node.type) ||
-  (node.type === "call" && skipAssignIndent(node.body[0]));
-
 module.exports = {
-  containsAssignment,
-  docLength,
-  empty,
-  first,
-  getTrailingComma,
-  hasAncestor,
-  isEmptyStmts,
-  literal,
-  literalLineNoBreak,
-  makeCall,
-  noIndent,
-  prefix,
-  printEmptyCollection,
-  skipAssignIndent
+  containsAssignment: require("./utils/containsAssignment"),
+  getTrailingComma: require("./utils/getTrailingComma"),
+  isEmptyStmts: require("./utils/isEmptyStmts"),
+  hasAncestor: require("./utils/hasAncestor"),
+  literal: require("./utils/literal"),
+  literalLineNoBreak: require("./utils/literalLineNoBreak"),
+  makeCall: require("./utils/makeCall"),
+  noIndent: require("./utils/noIndent"),
+  printEmptyCollection: require("./utils/printEmptyCollection"),
+  skipAssignIndent: require("./utils/skipAssignIndent")
 };

data/src/utils/containsAssignment.js

@@ -0,0 +1,11 @@
+// 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.
+function containsAssignment(node) {
+  return (
+    node &&
+    (["assign", "massign", "opassign"].includes(node.type) ||
+      (Array.isArray(node.body) && node.body.some(containsAssignment)))
+  );
+}
+
+module.exports = containsAssignment;

data/src/utils/getTrailingComma.js

@@ -0,0 +1,5 @@
+function getTrailingComma(opts) {
+  return ["all", "es5"].includes(opts.trailingComma);
+}
+
+module.exports = getTrailingComma;

data/src/utils/hasAncestor.js

@@ -0,0 +1,17 @@
+function hasAncestor(path, types) {
+  let parent = 0;
+  let parentNode = path.getParentNode();
+
+  while (parentNode) {
+    if (types.includes(parentNode.type)) {
+      return true;
+    }
+
+    parent += 1;
+    parentNode = path.getParentNode(parent);
+  }
+
+  return false;
+}
+
+module.exports = hasAncestor;

data/src/utils/literal.js

@@ -0,0 +1,7 @@
+function literal(value) {
+  return function printLiteral() {
+    return value;
+  };
+}
+
+module.exports = literal;

data/src/utils/makeCall.js

@@ -0,0 +1,11 @@
+function makeCall(path, opts, print) {
+  const operation = path.getValue().body[1];
+
+  if ([".", "&."].includes(operation)) {
+    return operation;
+  }
+
+  return operation === "::" ? "." : path.call(print, "body", 1);
+}
+
+module.exports = makeCall;

data/src/utils/noIndent.js

@@ -0,0 +1,10 @@
+const noIndent = [
+  "array",
+  "hash",
+  "heredoc",
+  "if",
+  "method_add_block",
+  "xstring_literal"
+];
+
+module.exports = noIndent;

data/src/utils/skipAssignIndent.js

@@ -0,0 +1,10 @@
+const skippable = ["array", "hash", "heredoc", "lambda", "regexp_literal"];
+
+function skipAssignIndent(node) {
+  return (
+    skippable.includes(node.type) ||
+    (node.type === "call" && skipAssignIndent(node.body[0]))
+  );
+}
+
+module.exports = skipAssignIndent;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.3
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-12 00:00:00.000000000 Z
+date: 2021-01-03 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -30,50 +30,57 @@ files:
 - node_modules/prettier/index.js
 - node_modules/prettier/third-party.js
 - package.json
-- src/embed.js
-- src/nodes.js
-- src/nodes/alias.js
-- src/nodes/aref.js
-- src/nodes/args.js
-- src/nodes/arrays.js
-- src/nodes/assign.js
-- 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
-- src/nodes/loops.js
-- src/nodes/massign.js
-- src/nodes/methods.js
-- src/nodes/operators.js
-- src/nodes/params.js
-- src/nodes/patterns.js
-- src/nodes/regexp.js
-- src/nodes/rescue.js
-- src/nodes/return.js
-- src/nodes/statements.js
-- src/nodes/strings.js
-- src/nodes/super.js
-- src/nodes/undef.js
-- src/parser.js
-- src/parser.rb
+- src/plugin.js
 - src/prettier.js
-- src/printer.js
-- src/ruby.js
-- src/toProc.js
+- src/ruby/embed.js
+- src/ruby/nodes.js
+- src/ruby/nodes/alias.js
+- src/ruby/nodes/aref.js
+- src/ruby/nodes/args.js
+- src/ruby/nodes/arrays.js
+- src/ruby/nodes/assign.js
+- src/ruby/nodes/blocks.js
+- src/ruby/nodes/calls.js
+- src/ruby/nodes/case.js
+- src/ruby/nodes/class.js
+- src/ruby/nodes/commands.js
+- src/ruby/nodes/conditionals.js
+- src/ruby/nodes/constants.js
+- src/ruby/nodes/flow.js
+- src/ruby/nodes/hashes.js
+- src/ruby/nodes/heredocs.js
+- src/ruby/nodes/hooks.js
+- src/ruby/nodes/ints.js
+- src/ruby/nodes/lambdas.js
+- src/ruby/nodes/loops.js
+- src/ruby/nodes/massign.js
+- src/ruby/nodes/methods.js
+- src/ruby/nodes/operators.js
+- src/ruby/nodes/params.js
+- src/ruby/nodes/patterns.js
+- src/ruby/nodes/regexp.js
+- src/ruby/nodes/rescue.js
+- src/ruby/nodes/return.js
+- src/ruby/nodes/statements.js
+- src/ruby/nodes/strings.js
+- src/ruby/nodes/super.js
+- src/ruby/nodes/undef.js
+- src/ruby/parser.js
+- src/ruby/parser.rb
+- src/ruby/printer.js
+- src/ruby/toProc.js
 - src/utils.js
+- src/utils/containsAssignment.js
+- src/utils/getTrailingComma.js
+- src/utils/hasAncestor.js
 - src/utils/inlineEnsureParens.js
 - src/utils/isEmptyStmts.js
+- src/utils/literal.js
 - src/utils/literalLineNoBreak.js
+- src/utils/makeCall.js
+- src/utils/noIndent.js
 - src/utils/printEmptyCollection.js
+- src/utils/skipAssignIndent.js
 homepage: https://github.com/prettier/plugin-ruby#readme
 licenses:
 - MIT
@@ -93,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language

data/src/nodes/case.js

@@ -1,61 +0,0 @@
-const {
-  align,
-  concat,
-  fill,
-  group,
-  hardline,
-  indent,
-  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));
-  }
-};

data/src/nodes/commands.js

@@ -1,91 +0,0 @@
-const {
-  align,
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  line,
-  softline
-} = require("../prettier");
-const { docLength, makeCall } = require("../utils");
-
-const hasDef = (node) =>
-  node.body[1].type === "args_add_block" &&
-  node.body[1].body[0].type === "args" &&
-  node.body[1].body[0].body[0] &&
-  ["def", "defs"].includes(node.body[1].body[0].body[0].type);
-
-// Very special handling case for rspec matchers. In general with rspec matchers
-// you expect to see something like:
-//
-//     expect(foo).to receive(:bar).with(
-//       'one',
-//       'two',
-//       'three',
-//       'four',
-//       'five'
-//     )
-//
-// In this case the arguments are aligned to the left side as opposed to being
-// aligned with the `receive` call.
-const skipArgsAlign = (path) =>
-  ["to", "not_to"].includes(path.getValue().body[2].body);
-
-// If there is a ternary argument to a command and it's going to get broken
-// into multiple lines, then we're going to have to use parentheses around the
-// command in order to make sure operator precedence doesn't get messed up.
-const hasTernaryArg = (path) =>
-  path.getValue().body[1].body[0].body.some((node) => node.type === "ifop");
-
-module.exports = {
-  command: (path, opts, print) => {
-    const command = path.call(print, "body", 0);
-    const joinedArgs = join(concat([",", line]), path.call(print, "body", 1));
-
-    const hasTernary = hasTernaryArg(path);
-    let breakArgs;
-
-    if (hasTernary) {
-      breakArgs = indent(concat([softline, joinedArgs]));
-    } else if (hasDef(path.getValue())) {
-      breakArgs = joinedArgs;
-    } else {
-      breakArgs = align(command.length + 1, joinedArgs);
-    }
-
-    return group(
-      ifBreak(
-        concat([
-          command,
-          hasTernary ? "(" : " ",
-          breakArgs,
-          hasTernary ? concat([softline, ")"]) : ""
-        ]),
-        concat([command, " ", joinedArgs])
-      )
-    );
-  },
-  command_call: (path, opts, print) => {
-    const parts = [
-      path.call(print, "body", 0),
-      makeCall(path, opts, print),
-      path.call(print, "body", 2)
-    ];
-
-    if (!path.getValue().body[3]) {
-      return concat(parts);
-    }
-
-    parts.push(" ");
-
-    const joinedArgs = join(concat([",", line]), path.call(print, "body", 3));
-    const breakArgs = skipArgsAlign(path)
-      ? joinedArgs
-      : align(docLength(concat(parts)), joinedArgs);
-
-    return group(
-      ifBreak(concat(parts.concat(breakArgs)), concat(parts.concat(joinedArgs)))
-    );
-  }
-};