prettier 1.2.1 → 1.3.0

data/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "prettier plugin for the Ruby programming language",
-  "main": "src/ruby.js",
+  "main": "src/plugin.js",
   "scripts": {
     "check-format": "prettier --check '**/*'",
     "lint": "eslint --cache .",
-    "test": "jest"
+    "test": "PORT=$(bin/port) jest"
   },
   "repository": {
     "type": "git",
@@ -22,7 +22,6 @@
     "prettier": ">=1.10"
   },
   "devDependencies": {
-    "all-contributors-cli": "^6.14.1",
     "eslint": "^7.8.1",
     "eslint-config-prettier": "^7.0.0",
     "husky": "^4.3.5",

data/rubocop.yml

@@ -0,0 +1,26 @@
+# Disabling all Layout/* rules, as they're unnecessary when the user is using
+# prettier to handle all of the formatting.
+
+Layout:
+  Enabled: false
+
+# Disabling all of the following options because they could conflict with a
+# prettier configuration setting.
+
+Style/MultilineIfModifier: # rubyModifier
+  Enabled: false
+
+Style/SymbolArray: # rubyArrayLiteral
+  Enabled: false
+
+Style/WordArray: # rubyArrayLiteral
+  Enabled: false
+
+Style/TrailingCommaInArguments: # trailingComma
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral: # trailingComma
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral: # trailingComma
+  Enabled: false

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;