prettier 0.20.0 → 1.0.0.pre.rc2

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,14 +1,5 @@
-const embed = require("./embed");
-const parse = require("./parse");
-const print = require("./print");
-
-const haml = require("./haml");
-
-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:
@@ -76,86 +67,54 @@ module.exports = {
       interpreters: ["jruby", "macruby", "rake", "rbx", "ruby"],
       linguistLanguageId: 326,
       vscodeLanguageIds: ["ruby"]
-    },
-    {
-      name: "HAML",
-      parsers: ["haml"],
-      extensions: [".haml"],
-      vscodeLanguageIds: ["haml"]
     }
   ],
   parsers: {
-    ruby: {
-      parse,
-      astFormat: "ruby",
-      hasPragma,
-      locStart,
-      locEnd
-    },
-    haml: {
-      parse: haml.parse,
-      astFormat: "haml",
-      hasPragma: haml.hasPragma,
-      locStart: haml.locStart,
-      locEnd: haml.locEnd
-    }
+    ruby: parser
   },
   printers: {
-    ruby: {
-      embed,
-      print
-    },
-    haml: {
-      embed: haml.embed,
-      print: haml.print
-    }
+    ruby: printer
   },
   options: {
-    addTrailingCommas: {
+    rubyArrayLiteral: {
       type: "boolean",
-      category: "Global",
-      default: false,
-      description:
-        "Adds a trailing comma to array literals, hash literals, and method calls."
-    },
-    inlineConditionals: {
-      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",
-      default: true,
+      category: "Ruby",
+      default: false,
       description:
         "When possible, convert blocks to the more concise Symbol#to_proc syntax."
     }
   },
   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,18 +1,13 @@
-const {
-  breakParent,
-  concat,
-  hardline,
-  lineSuffix,
-  literalline
-} = require("./prettier");
-
-const concatBody = (path, opts, print) => concat(path.map(print, "body"));
+const { concat } = require("./prettier");
+const isEmptyStmts = require("./utils/isEmptyStmts");
+const literalLineNoBreak = require("./utils/literalLineNoBreak");
 
 // 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) {
@@ -34,6 +29,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();
@@ -52,45 +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) => {
-    let pattern;
-    let heredoc;
-
-    if (argNode.type === "heredoc") {
-      pattern = [index, "body"];
-      heredoc = argNode;
-    } else if (
-      argNode.type === "string_literal" &&
-      argNode.body[0].type === "heredoc"
-    ) {
-      pattern = [index, "body", 0, "body"];
-      [heredoc] = argNode.body;
-    } else {
-      return;
-    }
-
-    const content = path.map.apply(path, argPattern.slice().concat(pattern));
-    heredocs.push(
-      concat([literalline].concat(content).concat([heredoc.ending]))
-    );
-    args[index] = heredoc.beging;
-  });
-
-  return { args, heredocs };
-};
-
 const makeCall = (path, opts, print) => {
   const operation = path.getValue().body[1];
 
@@ -101,57 +59,35 @@ const makeCall = (path, opts, print) => {
   return operation === "::" ? "." : path.call(print, "body", 1);
 };
 
-const makeList = (path, opts, print) => path.map(print, "body");
+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,
+  noIndent,
   prefix,
-  printComments,
-  skipAssignIndent,
-  surround
+  skipAssignIndent
 };

data/src/utils/inlineEnsureParens.js

@@ -0,0 +1,42 @@
+const needsParens = ["args", "assign", "assoc_new", "massign", "opassign"];
+
+// If you have a modifier statement (for instance an inline if statement or an
+// inline while loop) there are times when you need to wrap the entire statement
+// in parentheses. This occurs when you have something like:
+//
+//     foo[:foo] =
+//       if bar?
+//         baz
+//       end
+//
+// Normally we would shorten this to an inline version, which would result in:
+//
+//     foo[:foo] = baz if bar?
+//
+// but this actually has different semantic meaning. The first example will
+// result in a nil being inserted into the hash for the :foo key, whereas the
+// second example will result in an empty hash because the if statement applies
+// to the entire assignment.
+//
+// We can fix this in a couple of ways. We can use the then keyword, as in:
+//
+//     foo[:foo] = if bar? then baz end
+//
+// but I haven't actually seen this anywhere. We can also just leave it as is
+// with the multi-line version, but for a short predicate and short value it
+// looks pretty silly. The last option and the one I've selected here is to add
+// parentheses on both sides of the expression, as in:
+//
+//     foo[:foo] = (baz if bar?)
+//
+// This approach maintains the nice conciseness of the inline version, while
+// keeping the correct semantic meaning.
+const inlineEnsureParens = (path, parts) => {
+  if (needsParens.includes(path.getParentNode().type)) {
+    return ["("].concat(parts, ")");
+  }
+
+  return parts;
+};
+
+module.exports = inlineEnsureParens;

data/src/utils/isEmptyStmts.js

@@ -0,0 +1,7 @@
+const isEmptyStmts = (node) =>
+  node &&
+  node.type === "stmts" &&
+  node.body.length === 1 &&
+  node.body[0].type === "void_stmt";
+
+module.exports = isEmptyStmts;

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.20.0
+  version: 1.0.0.pre.rc2
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-28 00:00:00.000000000 Z
+date: 2020-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,31 +73,22 @@ files:
 - node_modules/prettier/third-party.js
 - package.json
 - src/embed.js
-- src/haml.js
-- 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/script.js
-- src/haml/nodes/silentScript.js
-- src/haml/nodes/tag.js
-- src/haml/parse.js
-- src/haml/parse.rb
-- src/haml/print.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
@@ -110,16 +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/ripper.rb
+- 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
@@ -135,9 +130,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: