prettier 1.2.4 → 1.5.1

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;

data/src/haml/parser.js

@@ -0,0 +1,22 @@
+const parseSync = require("../parser/parseSync");
+
+const parse = (text, _parsers, _opts) => {
+  return parseSync("haml", text);
+};
+
+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 = {
+  parse,
+  astFormat: "haml",
+  hasPragma,
+  locStart,
+  locEnd
+};

data/src/haml/parser.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'ripper'
+
+begin
+  require 'haml'
+rescue LoadError
+  # If we can't load the haml gem, then we're going to provide a shim parser
+  # that will warn and bail out.
+  class Prettier::HAMLParser
+    def self.parse(text)
+      warn(
+        'The `haml` gem could not be loaded. Please ensure you have it ' \
+          'installed and that it is available in the gem path.'
+      )
+
+      false
+    end
+  end
+
+  return
+end
+
+class Haml::Parser::ParseNode
+  class DeepAttributeParser
+    def parse(string)
+      Haml::AttributeParser.available? ? parse_value(string) : string
+    end
+
+    private
+
+    def literal(string, level)
+      level == 0 ? string : "&#{string}"
+    end
+
+    def parse_value(string, level = 0)
+      response = Ripper.sexp(string)
+      return literal(string, level) unless response
+
+      case response[1][0][0]
+      when :hash
+        hash = Haml::AttributeParser.parse(string)
+
+        if hash
+          # Explicitly not using Enumerable#to_h here to support Ruby 2.5
+          hash.each_with_object({}) do |(key, value), response|
+            response[key] = parse_value(value, level + 1)
+          end
+        else
+          literal(string, level)
+        end
+      when :string_literal
+        string[1...-1]
+      else
+        literal(string, level)
+      end
+    end
+  end
+
+  ESCAPE = /Haml::Helpers.html_escape\(\((.+)\)\)/.freeze
+
+  # If a node comes in as the plain type but starts with one of the special
+  # characters that haml parses, then we need to escape it with a \ when
+  # printing. So here we make a regexp pattern to check if the node needs to be
+  # escaped.
+  special_chars =
+    Haml::Parser::SPECIAL_CHARACTERS.map { |char| Regexp.escape(char) }
+
+  SPECIAL_START = /\A(?:#{special_chars.join('|')})/
+
+  def as_json
+    case type
+    when :comment, :doctype, :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 :plain
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+
+        text = json[:value][:text]
+        json[:value][:text] = "\\#{text}" if text.match?(SPECIAL_START)
+      end
+    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
+
+        # Get a reference to the dynamic attributes hash
+        dynamic_attributes = value[:dynamic_attributes].to_h
+
+        # If we have any in the old style, then we're going to pass it through
+        # the deep attribute parser filter.
+        if dynamic_attributes[:old]
+          dynamic_attributes[:old] =
+            DeepAttributeParser.new.parse(dynamic_attributes[:old])
+        end
+
+        json.merge!(
+          children: children.map(&:as_json),
+          value: value.merge(dynamic_attributes: dynamic_attributes)
+        )
+      end
+    else
+      raise ArgumentError, "Unsupported type: #{type}"
+    end
+  end
+end
+
+module Prettier
+  class HAMLParser
+    def self.parse(source)
+      Haml::Parser.new({}).call(source).as_json
+    rescue StandardError
+      false
+    end
+  end
+end