prettier 1.2.5 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a18f7e5ef9f61a53a91bda2f64e3e2a1e6e6541676a581a99128f363468b0c4
-  data.tar.gz: 374f7b95865b7ec4cf2bd16276b6c71f8b4bd4f62b34d860a773f3186bf8f308
+  metadata.gz: 657db7d1eef6e33d72337eb6b666678675c9eced4cc19716466b4bd74c039cfc
+  data.tar.gz: d69ffa4e3b2b48146c112a9ceb0d4ddab3351119c1bb2b9d92848f7beb3f40e4
 SHA512:
-  metadata.gz: b793f8694680859cca6c85b0786e3a4a608b3e0bb8cca23387995b694d03dcc8098821d259e855cb3ff690ceb2fd4d43587423d61945aec5dde8c8a48b4910f4
-  data.tar.gz: cb27a126a66d8ca08319dd45fc9207e7549ea084e0f4c5c787d05c36bc92c300ed396d1d9c8be664d697d625e1901abb907d031dcfdedc518f4c6beb5b0504f2
+  metadata.gz: d7c4d27daddee1e5d07393c5358e48a419c75a6e1aff62b36779d093f16f3da613c938b98c188752c93835e66ddd9578ebf6595fcde1a1f69f40f2613b492ddd
+  data.tar.gz: c586e33dcd0057779689df71ab68d8858aac27c9e89cf2f500edd2b55779b26693cf6756815cc616054c364b6bc4e1adff05263036f74025425218c04676969c

data/CHANGELOG.md

@@ -6,6 +6,13 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [1.3.0] - 2021-01-05
+
+### Added
+
+- [@kddeisz] - Handling of the RBS language.
+- [@kddeisz] - Incorporate the HAML plugin.
+
 ## [1.2.5] - 2021-01-04
 
 ### Changed
@@ -1028,7 +1035,8 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.2.5...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.3.0...HEAD
+[1.3.0]: https://github.com/prettier/plugin-ruby/compare/v1.2.5...v1.3.0
 [1.2.5]: https://github.com/prettier/plugin-ruby/compare/v1.2.4...v1.2.5
 [1.2.4]: https://github.com/prettier/plugin-ruby/compare/v1.2.3...v1.2.4
 [1.2.3]: https://github.com/prettier/plugin-ruby/compare/v1.2.2...v1.2.3
@@ -1102,6 +1110,7 @@ would previously result in `array[]`, but now prints properly.
 [@cldevs]: https://github.com/cldevs
 [@codingitwrong]: https://github.com/CodingItWrong
 [@coiti]: https://github.com/coiti
+[@cvoege]: https://github.com/cvoege
 [@deecewan]: https://github.com/deecewan
 [@dudeofawesome]: https://github.com/dudeofawesome
 [@eins78]: https://github.com/eins78
@@ -1152,6 +1161,7 @@ would previously result in `array[]`, but now prints properly.
 [@sviccari]: https://github.com/SViccari
 [@tobyndockerill]: https://github.com/tobyndockerill
 [@uri]: https://github.com/uri
+[@valscion]: https://github.com/valscion
 [@xipgroc]: https://github.com/xipgroc
 [@ykpythemind]: https://github.com/ykpythemind
 [@yuki24]: https://github.com/yuki24

data/README.md

@@ -72,6 +72,12 @@ To run `prettier` with the Ruby plugin, you're going to need [`ruby`](https://ww
 
 Note that currently the editor integrations work best with the `npm` package, as most of the major editor plugins expect a `node_modules` directory. You can get them to work with the Ruby gem, but it requires manually configuring the paths.
 
+This plugin currently supports formatting the following kinds of files:
+
+- All varieties of Ruby source files (e.g., `*.rb`, `*.gemspec`, `Gemfile`, etc.)
+- [RBS type language](https://github.com/ruby/rbs) files - requires having the `rbs` gem in your gem path
+- [HAML template language](https://haml.info/) files - requires having the `haml` gem in your gem path
+
 ### Ruby gem
 
 Add this line to your application's Gemfile:
@@ -95,7 +101,7 @@ gem install prettier
 The `rbprettier` executable is now installed and ready for use:
 
 ```bash
-bundle exec rbprettier --write '**/*.rb'
+bundle exec rbprettier --write '**/*'
 ```
 
 ### `npm` package
@@ -115,7 +121,7 @@ yarn add --dev prettier @prettier/plugin-ruby
 The `prettier` executable is now installed and ready for use:
 
 ```bash
-./node_modules/.bin/prettier --write '**/*.rb'
+./node_modules/.bin/prettier --write '**/*'
 ```
 
 ## Configuration
@@ -146,7 +152,7 @@ file](https://prettier.io/docs/en/configuration.html). For example:
 Or, they can be passed to `prettier` as arguments:
 
 ```bash
-prettier --ruby-single-quote false --write '**/*.rb'
+prettier --ruby-single-quote false --write '**/*'
 ```
 
 ### Usage with RuboCop

data/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/plugin.js",
   "scripts": {
     "check-format": "prettier --check '**/*'",
     "lint": "eslint --cache .",
-    "test": "jest"
+    "test": "PORT=$(bin/port) jest"
   },
   "repository": {
     "type": "git",

data/src/haml/embed.js

@@ -0,0 +1,87 @@
+const {
+  concat,
+  hardline,
+  indent,
+  literalline,
+  markAsRoot,
+  mapDoc,
+  stripTrailingHardline
+} = require("../prettier");
+
+// Get the name of the parser that is represented by the given element node,
+// return null if a matching parser cannot be found
+function getParser(name, opts) {
+  let parser = name;
+
+  // We don't want to deal with some weird recursive parser situation, so we
+  // need to explicitly call out the HAML parser here and just return null
+  if (parser === "haml") {
+    return null;
+  }
+
+  // In HAML the name of the JS filter is :javascript, whereas in prettier the
+  // name of the JS parser is babel. Here we explicitly handle that conversion.
+  if (parser === "javascript") {
+    parser = "babel";
+  }
+
+  // If there is a plugin that has a parser that matches the name of this
+  // element, then we're going to assume that's correct for embedding and go
+  // ahead and switch to that parser
+  if (
+    opts.plugins.some(
+      (plugin) =>
+        plugin.parsers &&
+        Object.prototype.hasOwnProperty.call(plugin.parsers, parser)
+    )
+  ) {
+    return parser;
+  }
+
+  return null;
+}
+
+// This function is in here because it handles embedded parser values. I don't
+// have a test that exercises it because I'm not sure for which parser it is
+// necessary, but since it's in prettier core I'm keeping it here.
+/* istanbul ignore next */
+function replaceNewlines(doc) {
+  return mapDoc(doc, (currentDoc) =>
+    typeof currentDoc === "string" && currentDoc.includes("\n")
+      ? concat(
+          currentDoc
+            .split(/(\n)/g)
+            .map((v, i) => (i % 2 === 0 ? v : literalline))
+        )
+      : currentDoc
+  );
+}
+
+function embed(path, _print, textToDoc, opts) {
+  const node = path.getValue();
+  if (node.type !== "filter") {
+    return null;
+  }
+
+  const parser = getParser(node.value.name, opts);
+  if (!parser) {
+    return null;
+  }
+
+  return markAsRoot(
+    concat([
+      ":",
+      node.value.name,
+      indent(
+        concat([
+          hardline,
+          replaceNewlines(
+            stripTrailingHardline(textToDoc(node.value.text, { parser }))
+          )
+        ])
+      )
+    ])
+  );
+}
+
+module.exports = embed;

data/src/haml/nodes/comment.js

@@ -0,0 +1,27 @@
+const { concat, group, hardline, indent, join } = require("../../prettier");
+
+// https://haml.info/docs/yardoc/file.REFERENCE.html#html-comments-
+function comment(path, _opts, print) {
+  const { children, value } = path.getValue();
+  const parts = ["/"];
+
+  if (value.revealed) {
+    parts.push("!");
+  }
+
+  if (value.conditional) {
+    parts.push(value.conditional);
+  } else if (value.text) {
+    parts.push(" ", value.text);
+  }
+
+  if (children.length > 0) {
+    parts.push(
+      indent(concat([hardline, join(hardline, path.map(print, "children"))]))
+    );
+  }
+
+  return group(concat(parts));
+}
+
+module.exports = comment;

data/src/haml/nodes/doctype.js

@@ -0,0 +1,34 @@
+const { join } = require("../../prettier");
+
+const types = {
+  basic: "Basic",
+  frameset: "Frameset",
+  mobile: "Mobile",
+  rdfa: "RDFa",
+  strict: "Strict",
+  xml: "XML"
+};
+
+const versions = ["1.1", "5"];
+
+// https://haml.info/docs/yardoc/file.REFERENCE.html#doctype-
+function doctype(path, _opts, _print) {
+  const { value } = path.getValue();
+  const parts = ["!!!"];
+
+  if (value.type in types) {
+    parts.push(types[value.type]);
+  } else if (versions.includes(value.version)) {
+    parts.push(value.version);
+  } else {
+    parts.push(value.type);
+  }
+
+  if (value.encoding) {
+    parts.push(value.encoding);
+  }
+
+  return join(" ", parts);
+}
+
+module.exports = doctype;

data/src/haml/nodes/filter.js

@@ -0,0 +1,16 @@
+const { concat, group, hardline, indent, join } = require("../../prettier");
+
+// https://haml.info/docs/yardoc/file.REFERENCE.html#filters
+function filter(path, _opts, _print) {
+  const { value } = path.getValue();
+
+  return group(
+    concat([
+      ":",
+      value.name,
+      indent(concat([hardline, join(hardline, value.text.trim().split("\n"))]))
+    ])
+  );
+}
+
+module.exports = filter;

data/src/haml/nodes/hamlComment.js

@@ -0,0 +1,21 @@
+const { concat, hardline, indent, join } = require("../../prettier");
+
+// https://haml.info/docs/yardoc/file.REFERENCE.html#haml-comments--
+function hamlComment(path, opts, _print) {
+  const node = path.getValue();
+  const parts = ["-#"];
+
+  if (node.value.text) {
+    if (opts.originalText.split("\n")[node.line - 1].trim() === "-#") {
+      const lines = node.value.text.trim().split("\n");
+
+      parts.push(indent(concat([hardline, join(hardline, lines)])));
+    } else {
+      parts.push(" ", node.value.text.trim());
+    }
+  }
+
+  return concat(parts);
+}
+
+module.exports = hamlComment;

data/src/haml/nodes/plain.js

@@ -0,0 +1,6 @@
+// https://haml.info/docs/yardoc/file.REFERENCE.html#plain-text
+function plain(path, _opts, _print) {
+  return path.getValue().value.text;
+}
+
+module.exports = plain;

data/src/haml/nodes/root.js

@@ -0,0 +1,8 @@
+const { concat, hardline, join } = require("../../prettier");
+
+// The root node in the AST
+function root(path, _opts, print) {
+  return concat([join(hardline, path.map(print, "children")), hardline]);
+}
+
+module.exports = root;

data/src/haml/nodes/script.js

@@ -0,0 +1,33 @@
+const { concat, group, hardline, indent, join } = require("../../prettier");
+
+// https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
+function script(path, opts, print) {
+  const { children, value } = path.getValue();
+  const parts = [];
+
+  if (value.escape_html) {
+    parts.unshift("&");
+  }
+
+  if (value.preserve) {
+    parts.push("~");
+  } else if (!value.interpolate) {
+    parts.push("=");
+  }
+
+  if (value.escape_html && !value.preserve && value.interpolate) {
+    parts.push(" ", value.text.trim().slice(1, -1));
+  } else {
+    parts.push(" ", value.text.trim());
+  }
+
+  if (children.length > 0) {
+    parts.push(
+      indent(concat([hardline, join(hardline, path.map(print, "children"))]))
+    );
+  }
+
+  return group(concat(parts));
+}
+
+module.exports = script;

data/src/haml/nodes/silentScript.js

@@ -0,0 +1,59 @@
+const { concat, group, hardline, indent, join } = require("../../prettier");
+
+function findKeywordIndices(children, keywords) {
+  const indices = [];
+
+  children.forEach((child, index) => {
+    if (child.type !== "silent_script") {
+      return;
+    }
+
+    if (keywords.includes(child.value.keyword)) {
+      indices.push(index);
+    }
+  });
+
+  return indices;
+}
+
+// https://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
+function silentScript(path, _opts, print) {
+  const { children, value } = path.getValue();
+  const parts = [`- ${value.text.trim()}`];
+
+  if (children.length > 0) {
+    const scripts = path.map(print, "children");
+
+    if (value.keyword === "case") {
+      const keywordIndices = findKeywordIndices(children, ["when", "else"]);
+
+      parts.push(
+        concat(
+          scripts.map((script, index) => {
+            const concated = concat([hardline, script]);
+
+            return keywordIndices.includes(index) ? concated : indent(concated);
+          })
+        )
+      );
+    } else if (["if", "unless"].includes(value.keyword)) {
+      const keywordIndices = findKeywordIndices(children, ["elsif", "else"]);
+
+      parts.push(
+        concat(
+          scripts.map((script, index) => {
+            const concated = concat([hardline, script]);
+
+            return keywordIndices.includes(index) ? concated : indent(concated);
+          })
+        )
+      );
+    } else {
+      parts.push(indent(concat([hardline, join(hardline, scripts)])));
+    }
+  }
+
+  return group(concat(parts));
+}
+
+module.exports = silentScript;

data/src/haml/nodes/tag.js

@@ -0,0 +1,193 @@
+const {
+  align,
+  concat,
+  fill,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
+
+function getDynamicAttributes(header, attributes) {
+  const pairs = attributes
+    .slice(1, -2)
+    .split(",")
+    .map((pair) => pair.slice(1).split('" => '));
+
+  const parts = [concat([pairs[0][0], "=", pairs[0][1]])];
+  pairs.slice(1).forEach((pair) => {
+    parts.push(line, concat([pair[0], "=", pair[1]]));
+  });
+
+  return group(concat(["(", align(header + 1, fill(parts)), ")"]));
+}
+
+function getHashValue(value, opts) {
+  if (typeof value !== "string") {
+    return value.toString();
+  }
+
+  // This is a very special syntax created by the parser to let us know that
+  // this should be printed literally instead of as a string.
+  if (value.startsWith("&")) {
+    return value.slice(1);
+  }
+
+  const quote = opts.rubySingleQuote ? "'" : '"';
+  return `${quote}${value}${quote}`;
+}
+
+function getHashKey(key, opts) {
+  let quoted = key;
+  const joiner = opts.rubyHashLabel ? ":" : " =>";
+
+  if (key.includes(":") || key.includes("-")) {
+    const quote = opts.rubySingleQuote ? "'" : '"';
+    quoted = `${quote}${key}${quote}`;
+  }
+
+  return `${opts.rubyHashLabel ? "" : ":"}${quoted}${joiner}`;
+}
+
+function getKeyValuePair(key, value, opts) {
+  return `${getHashKey(key, opts)} ${getHashValue(value, opts)}`;
+}
+
+function getStaticAttributes(header, attributes, opts) {
+  const keys = Object.keys(attributes).filter(
+    (name) => !["class", "id"].includes(name)
+  );
+
+  const parts = [getKeyValuePair(keys[0], attributes[keys[0]], opts)];
+
+  keys.slice(1).forEach((key) => {
+    parts.push(",", line, getKeyValuePair(key, attributes[key], opts));
+  });
+
+  return group(concat(["{", align(header + 1, fill(parts)), "}"]));
+}
+
+function getAttributesObject(object, opts, level = 0) {
+  if (typeof object !== "object") {
+    return getHashValue(object, opts);
+  }
+
+  const boundary = level === 0 ? softline : line;
+  const parts = Object.keys(object).map((key) =>
+    concat([
+      getHashKey(key, opts),
+      " ",
+      getAttributesObject(object[key], opts, level + 1)
+    ])
+  );
+
+  return group(
+    concat([
+      "{",
+      indent(group(concat([boundary, join(concat([",", line]), parts)]))),
+      boundary,
+      "}"
+    ])
+  );
+}
+
+function getHeader(value, opts) {
+  const { attributes } = value;
+  const parts = [];
+
+  if (value.name !== "div") {
+    parts.push(`%${value.name}`);
+  }
+
+  if (attributes.class) {
+    parts.push(`.${attributes.class.replace(/ /g, ".")}`);
+  }
+
+  if (attributes.id) {
+    parts.push(`#${attributes.id}`);
+  }
+
+  if (value.dynamic_attributes.new) {
+    parts.push(
+      getDynamicAttributes(parts.join("").length, value.dynamic_attributes.new)
+    );
+  }
+
+  if (
+    Object.keys(attributes).some((name) => name !== "class" && name !== "id")
+  ) {
+    parts.push(getStaticAttributes(parts.join("").length, attributes, opts));
+  }
+
+  if (value.dynamic_attributes.old) {
+    if (parts.length === 0) {
+      parts.push("%div");
+    }
+
+    if (typeof value.dynamic_attributes.old === "string") {
+      parts.push(value.dynamic_attributes.old);
+    } else {
+      parts.push(getAttributesObject(value.dynamic_attributes.old, opts));
+    }
+  }
+
+  if (value.object_ref) {
+    if (parts.length === 0) {
+      parts.push("%div");
+    }
+    parts.push(value.object_ref);
+  }
+
+  if (value.nuke_outer_whitespace) {
+    parts.push(">");
+  }
+
+  if (value.nuke_inner_whitespace) {
+    parts.push("<");
+  }
+
+  if (value.self_closing) {
+    parts.push("/");
+  }
+
+  if (value.value) {
+    const prefix = value.parse ? "= " : ifBreak("", " ");
+
+    return group(
+      concat([
+        group(concat(parts)),
+        indent(concat([softline, prefix, value.value]))
+      ])
+    );
+  }
+
+  // In case none of the other if statements have matched and we're printing a
+  // div, we need to explicitly add it back into the array.
+  if (parts.length === 0 && value.name === "div") {
+    parts.push("%div");
+  }
+
+  return group(concat(parts));
+}
+
+// https://haml.info/docs/yardoc/file.REFERENCE.html#element-name-
+function tag(path, opts, print) {
+  const { children, value } = path.getValue();
+  const header = getHeader(value, opts);
+
+  if (children.length === 0) {
+    return header;
+  }
+
+  return group(
+    concat([
+      header,
+      indent(concat([hardline, join(hardline, path.map(print, "children"))]))
+    ])
+  );
+}
+
+module.exports = tag;