prettier 1.2.1 → 1.3.0

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");
@@ -67,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;
   }

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

@@ -12,15 +12,11 @@ const isCall = (node) => ["::", "."].includes(node) || node.type === "@period";
 //
 // This works with `do` blocks as well.
 const toProc = (path, node) => {
-  if (!node) {
-    return null;
-  }
-
   const [variables, blockContents] = node.body;
 
   // Ensure that there are variables being passed to this block.
   const params = variables && variables.body[0];
-  if (!params || params.type !== "params") {
+  if (!params) {
     return null;
   }
 
@@ -39,7 +35,7 @@ const toProc = (path, node) => {
   if (blockContents.type === "bodystmt") {
     // We’re in a `do` block
     const blockStatements = blockContents.body[0];
-    const rescueElseEnsure = blockStatements.body.slice(1);
+    const rescueElseEnsure = blockContents.body.slice(1);
 
     // You can’t use the to_proc shortcut if you’re rescuing
     if (rescueElseEnsure.some(Boolean)) {
@@ -84,7 +80,7 @@ const toProc = (path, node) => {
 
   if (path.getValue().type === "method_add_block") {
     assocNode = path.getParentNode();
-  } else if (path.getValue().type === "args") {
+  } else {
     assocNode = path.getParentNode(2);
   }
 
@@ -97,7 +93,7 @@ const toProc = (path, node) => {
 
     if (
       key.type === "symbol_literal" &&
-      ["if", "unless"].includes(key.body[0].body[0].body)
+      ["if", "unless"].includes(key.body[0].body)
     ) {
       return null;
     }

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,14 @@
+function makeCall(path, opts, print) {
+  const operation = path.getValue().body[1];
+
+  // Ignoring the next block for coverage information because it's only relevant
+  // in Ruby 2.5 and below.
+  /* istanbul ignore next */
+  if ([".", "&."].includes(operation)) {
+    return operation;
+  }
+
+  return operation === "::" ? "." : path.call(print, "body", 1);
+}
+
+module.exports = makeCall;

data/src/utils/noIndent.js

@@ -0,0 +1,11 @@
+const noIndent = [
+  "array",
+  "hash",
+  "heredoc",
+  "if",
+  "method_add_block",
+  "unless",
+  "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.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-27 00:00:00.000000000 Z
+date: 2021-01-05 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -30,50 +30,74 @@ 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
+- rubocop.yml
+- src/haml/embed.js
+- src/haml/nodes/comment.js
+- src/haml/nodes/doctype.js
+- src/haml/nodes/filter.js
+- src/haml/nodes/hamlComment.js
+- src/haml/nodes/plain.js
+- src/haml/nodes/root.js
+- src/haml/nodes/script.js
+- src/haml/nodes/silentScript.js
+- src/haml/nodes/tag.js
+- src/haml/parser.js
+- src/haml/parser.rb
+- src/haml/printer.js
+- src/plugin.js
 - src/prettier.js
-- src/printer.js
-- src/ruby.js
-- src/toProc.js
+- src/rbs/parser.js
+- src/rbs/parser.rb
+- src/rbs/printer.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 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language

data/src/nodes/blocks.js

@@ -1,85 +0,0 @@
-const {
-  breakParent,
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  removeLines,
-  softline
-} = require("../prettier");
-const { empty, hasAncestor } = require("../utils");
-
-const printBlock = (braces) => (path, opts, print) => {
-  const [variables, statements] = path.getValue().body;
-  const stmts =
-    statements.type === "stmts" ? statements.body : statements.body[0].body;
-
-  let doBlockBody = "";
-  if (
-    stmts.length !== 1 ||
-    stmts[0].type !== "void_stmt" ||
-    stmts[0].comments
-  ) {
-    doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
-  }
-
-  // If this block is nested underneath a command or command_call node, then we
-  // can't use `do...end` because that will get associated with the parent node
-  // as opposed to the current node (because of the difference in operator
-  // precedence). Instead, we still use a multi-line format but switch to using
-  // braces instead.
-  const useBraces = braces && hasAncestor(path, ["command", "command_call"]);
-
-  const doBlock = concat([
-    useBraces ? " {" : " do",
-    variables ? concat([" ", path.call(print, "body", 0)]) : "",
-    doBlockBody,
-    concat([softline, useBraces ? "}" : "end"])
-  ]);
-
-  // We can hit this next pattern if within the block the only statement is a
-  // comment.
-  if (
-    stmts.length === 1 &&
-    stmts[0].type === "void_stmt" &&
-    stmts[0].comments
-  ) {
-    return concat([breakParent, doBlock]);
-  }
-
-  // If the parent node is a command node, then there are no parentheses around
-  // the arguments to that command, so we need to break the block
-  if (["command", "command_call"].includes(path.getParentNode().body[0].type)) {
-    return concat([breakParent, doBlock]);
-  }
-
-  const hasBody = stmts.some(({ type }) => type !== "void_stmt");
-  const braceBlock = concat([
-    " {",
-    hasBody || variables ? " " : "",
-    variables ? path.call(print, "body", 0) : "",
-    path.call(print, "body", 1),
-    hasBody ? " " : "",
-    "}"
-  ]);
-
-  return group(ifBreak(doBlock, braceBlock));
-};
-
-module.exports = {
-  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);
-  },
-  brace_block: printBlock(true),
-  do_block: printBlock(false),
-  excessed_comma: empty
-};