prettier 0.15.1 → 0.16.0

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
@@ -19,7 +19,7 @@
   },
   "homepage": "https://github.com/prettier/plugin-ruby#readme",
   "dependencies": {
-    "prettier": "^1.16.4"
+    "prettier": ">=1.10"
   },
   "devDependencies": {
     "all-contributors-cli": "^6.1.2",

data/src/haml.js

@@ -0,0 +1,21 @@
+const embed = require("./haml/embed");
+const parse = require("./haml/parse");
+const print = require("./haml/print");
+
+const pragmaPattern = /^\s*-#\s*@(prettier|format)/;
+const hasPragma = text => pragmaPattern.test(text);
+
+// These functions are just placeholders until we can actually perform this
+// properly. The functions are necessary otherwise the format with cursor
+// functions break.
+const locStart = _node => 0;
+const locEnd = _node => 0;
+
+module.exports = {
+  embed,
+  hasPragma,
+  locStart,
+  locEnd,
+  parse,
+  print
+};

data/src/haml/embed.js

@@ -0,0 +1,58 @@
+const {
+  concat,
+  hardline,
+  indent,
+  literalline,
+  mapDoc,
+  markAsRoot,
+  stripTrailingHardline
+} = require("../prettier");
+
+const parsers = {
+  css: "css",
+  javascript: "babel",
+  less: "less",
+  markdown: "markdown",
+  ruby: "ruby",
+  scss: "scss"
+};
+
+const replaceNewlines = doc =>
+  mapDoc(doc, currentDoc =>
+    typeof currentDoc === "string" && currentDoc.includes("\n")
+      ? concat(
+          currentDoc
+            .split(/(\n)/g)
+            .map((v, i) => (i % 2 === 0 ? v : literalline))
+        )
+      : currentDoc
+  );
+
+const embed = (path, print, textToDoc, _opts) => {
+  const node = path.getValue();
+  if (node.type !== "filter") {
+    return null;
+  }
+
+  const parser = parsers[node.value.name];
+  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");
+
+// http://haml.info/docs/yardoc/file.REFERENCE.html#html-comments-
+const 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,32 @@
+const { join } = require("../../prettier");
+
+const types = {
+  basic: "Basic",
+  frameset: "Frameset",
+  mobile: "Mobile",
+  rdfa: "RDFa",
+  strict: "Strict",
+  xml: "XML"
+};
+
+const versions = ["1.1", "5"];
+
+// http://haml.info/docs/yardoc/file.REFERENCE.html#doctype-
+const doctype = (path, _opts, _print) => {
+  const { value } = path.getValue();
+  const parts = ["!!!"];
+
+  if (value.type in types) {
+    parts.push(types[value.type]);
+  } else if (value.version in versions) {
+    parts.push(versions[value.version]);
+  }
+
+  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");
+
+// http://haml.info/docs/yardoc/file.REFERENCE.html#filters
+const 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");
+
+// http://haml.info/docs/yardoc/file.REFERENCE.html#haml-comments--
+const 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/script.js

@@ -0,0 +1,29 @@
+const { concat, group, hardline, indent, join } = require("../../prettier");
+
+// http://haml.info/docs/yardoc/file.REFERENCE.html#inserting-ruby-
+const 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("=");
+  }
+
+  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,30 @@
+const { concat, group, hardline, indent, join } = require("../../prettier");
+
+// http://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
+const 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") {
+      parts.push(
+        join(
+          "",
+          scripts.map((script, index) => {
+            const concated = concat([hardline, script]);
+
+            return index % 2 === 0 ? 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,151 @@
+const {
+  align,
+  concat,
+  fill,
+  group,
+  hardline,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
+
+const 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)), ")"]));
+};
+
+const getHashValue = (value, opts) => {
+  if (typeof value === "string") {
+    const quote = opts.preferSingleQuotes ? "'" : '"';
+    return `${quote}${value}${quote}`;
+  }
+
+  return value;
+};
+
+const getHashRocket = (key, value, opts) => {
+  const quote = opts.preferSingleQuotes ? "'" : '"';
+  const leftSide = key.includes(":") ? `:${quote}${key}${quote}` : `:${key}`;
+
+  return `${leftSide} => ${getHashValue(value, opts)}`;
+};
+
+const getHashLabel = (key, value, opts) => {
+  const quote = opts.preferSingleQuotes ? "'" : '"';
+  const leftSide = key.includes(":") ? `${quote}${key}${quote}` : key;
+
+  return `${leftSide}: ${getHashValue(value, opts)}`;
+};
+
+const getStaticAttributes = (header, attributes, opts) => {
+  const keys = Object.keys(attributes).filter(
+    name => !["class", "id"].includes(name)
+  );
+
+  const getKeyValuePair = opts.preferHashLabels ? getHashLabel : getHashRocket;
+  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)), "}"]));
+};
+
+const getHeader = (value, opts) => {
+  const { attributes } = value;
+  const parts = [];
+
+  if (value.name !== "div") {
+    parts.push(`%${value.name}`);
+  }
+
+  if (attributes.class) {
+    parts.push(`.${attributes.class.replace(" ", ".")}`);
+  }
+
+  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) {
+    parts.push(value.dynamic_attributes.old);
+  }
+
+  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 ? "=" : "";
+
+    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));
+};
+
+// http://haml.info/docs/yardoc/file.REFERENCE.html#element-name-
+const 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;

data/src/haml/parse.js

@@ -0,0 +1,18 @@
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+const parse = (text, _parsers, _opts) => {
+  const child = spawnSync("ruby", [path.join(__dirname, "./parse.rb")], {
+    input: text
+  });
+
+  const error = child.stderr.toString();
+  if (error) {
+    throw new Error(error);
+  }
+
+  const response = child.stdout.toString();
+  return JSON.parse(response);
+};
+
+module.exports = parse;

data/src/haml/parse.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'haml'
+
+class Haml::Parser::ParseNode
+  ESCAPE = /Haml::Helpers.html_escape\(\((.+)\)\)/.freeze
+
+  def as_json
+    case type
+    when :comment, :doctype, :plain, :silent_script
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+      end
+    when :filter, :haml_comment
+      to_h.tap { |json| json.delete(:parent) }
+    when :root
+      to_h.tap { |json| json[:children] = children.map(&:as_json) }
+    when :script
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+
+        if json[:value][:text].match?(ESCAPE)
+          json[:value][:text].gsub!(ESCAPE) { $1 }
+          json[:value].merge!(escape_html: 'escape_html', interpolate: true)
+        end
+      end
+    when :tag
+      to_h.tap do |json|
+        json.delete(:parent)
+
+        # For some reason this is actually using a symbol to represent a null
+        # object ref instead of nil itself, so just replacing it here for
+        # simplicity in the printer
+        json[:value][:object_ref] = nil if json[:value][:object_ref] == :nil
+
+        json.merge!(
+          children: children.map(&:as_json),
+          value:
+            value.merge(dynamic_attributes: value[:dynamic_attributes].to_h)
+        )
+      end
+    else
+      raise ArgumentError, "Unsupported type: #{type}"
+    end
+  end
+
+  def self.to_json(template)
+    parser = Haml::Parser.new({})
+    JSON.fast_generate(parser.call(template).as_json)
+  end
+end
+
+# If this is the main file we're executing, then most likely this is being
+# executed from the haml.js spawn. In that case, read the ruby source from
+# stdin and report back the AST over stdout.
+
+if $0 == __FILE__
+  parser = Haml::Parser.new({})
+  template = $stdin.read
+
+  puts JSON.fast_generate(parser.call(template).as_json)
+end