feat: support markdown

package.json

@@ -39,9 +39,13 @@
     "postcss-scss": "1.0.0",
     "postcss-selector-parser": "2.2.3",
     "postcss-values-parser": "git://github.com/lydell/postcss-values-parser.git#af2c80b2bb558a6e7d61540d97f068f9fa162b38",
+    "remark-frontmatter": "1.1.0",
+    "remark-parse": "4.0.0",
     "strip-bom": "3.0.0",
     "typescript": "2.5.1",
-    "typescript-eslint-parser": "git://github.com/eslint/typescript-eslint-parser.git#5576fb48c89165967557e867b9462d43431dcb10"
+    "typescript-eslint-parser": "git://github.com/eslint/typescript-eslint-parser.git#5576fb48c89165967557e867b9462d43431dcb10",
+    "unified": "6.1.5",
+    "unist-util-map": "1.0.3"
   },
   "devDependencies": {
     "babel-cli": "6.24.1",

src/cli-constant.js

@@ -183,7 +183,15 @@ const detailedOptions = normalizeDetailedOptions({
     category: CATEGORY_FORMAT,
     forwardToApi: true,
     exception: value => typeof value === "string", // Allow path to a parser module.
-    choices: ["flow", "babylon", "typescript", "postcss", "json", "graphql"],
+    choices: [
+      "flow",
+      "babylon",
+      "typescript",
+      "postcss",
+      "json",
+      "graphql",
+      "markdown"
+    ],
     description: "Which parser to use.",
     getter: (value, argv) => (argv["flow-parser"] ? "flow" : value)
   },

src/options.js

@@ -40,6 +40,8 @@ function normalize(options) {
     normalized.parser = "graphql";
   } else if (/\.json$/.test(filepath)) {
     normalized.parser = "json";
+  } else if (/\.(md|markdown)$/.test(filepath)) {
+    normalized.parser = "markdown";
   }
 
   if (normalized.parser === "json") {

src/parser-markdown.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const map = require("unist-util-map");
+const remarkFrontmatter = require("remark-frontmatter");
+const remarkParse = require("remark-parse");
+const unified = require("unified");
+
+function splitText() {
+  return ast =>
+    map(ast, node => {
+      return node.type !== "text"
+        ? node
+        : Object.assign({}, node, {
+            type: "sentence",
+            children: node.value
+              .split(/(\s+)/g)
+              .map(
+                (text, index) =>
+                  index % 2 === 0
+                    ? { type: "word", value: text }
+                    : { type: "whitespace", value: " " }
+              )
+              .filter(node => node.value.length) // remove empty word
+          });
+    });
+}
+
+function parse(text /*, parsers, opts*/) {
+  const processor = unified()
+    .use(remarkParse, { position: false })
+    .use(remarkFrontmatter, ["yaml"])
+    .use(splitText);
+  return processor.runSync(processor.parse(text));
+}
+
+module.exports = parse;

src/parser.js

@@ -23,6 +23,9 @@ const parsers = {
   },
   get json() {
     return eval("require")("./parser-babylon");
+  },
+  get markdown() {
+    return eval("require")("./parser-markdown");
   }
 };
 

src/printer-markdown.js

@@ -0,0 +1,292 @@
+"use strict";
+
+const util = require("./util");
+const docBuilders = require("./doc-builders");
+const concat = docBuilders.concat;
+const join = docBuilders.join;
+const line = docBuilders.line;
+const hardline = docBuilders.hardline;
+const softline = docBuilders.softline;
+const group = docBuilders.group;
+const fill = docBuilders.fill;
+const indent = docBuilders.indent;
+const ifBreak = docBuilders.ifBreak;
+const align = docBuilders.align;
+const docPrinter = require("./doc-printer");
+const printDocToString = docPrinter.printDocToString;
+
+function genericPrint(path, options, print) {
+  const node = path.getValue();
+
+  switch (node.type) {
+    case "root":
+      return concat([printChildren(path, options, print), hardline]);
+    case "paragraph":
+      return concat([printChildren(path, options, print)]);
+    case "sentence":
+      return concat([
+        printBlockquotePrefix(path),
+        printChildren(
+          path,
+          options,
+          print,
+          (parts, childPath, index) => {
+            const childNode = childPath.getValue();
+            if (
+              !(
+                childNode.type === "whitespace" &&
+                index === node.children.length - 1
+              )
+            ) {
+              parts.push(childPath.call(print));
+            }
+          },
+          fill
+        )
+      ]);
+    case "word":
+      return node.value;
+    case "whitespace":
+      return concat([
+        // parent types that disallow multi-line content
+        hasParentType(path, ["heading", "table"]) ? " " : line,
+        ifBreak(printBlockquotePrefix(path))
+      ]);
+    case "emphasis":
+      return concat(["*", printChildren(path, options, print), "*"]);
+    case "strong":
+      return concat(["**", printChildren(path, options, print), "**"]);
+    case "delete":
+      return concat(["~~", printChildren(path, options, print), "~~"]);
+    case "inlineCode":
+      return concat(["`", node.value, "`"]);
+    case "link":
+      return concat([
+        "[",
+        printChildren(path, options, print),
+        "](",
+        node.url,
+        node.title ? ` "${node.title}"` : "",
+        ")"
+      ]);
+    case "image":
+      return concat([
+        "![",
+        node.alt || "",
+        "](",
+        node.url,
+        node.title ? ` "${node.title}"` : "",
+        ")"
+      ]);
+    case "blockquote":
+      return printChildren(path, options, print);
+    case "heading":
+      return concat([
+        "#".repeat(node.depth) + " ",
+        printChildren(path, options, print),
+        hardline,
+        hardline
+      ]);
+    case "code":
+      return concat([
+        "```",
+        node.lang || "",
+        hardline,
+        node.value,
+        hardline,
+        "```",
+        hardline
+      ]);
+    case "yaml":
+      return concat(["---", hardline, node.value, hardline, "---", hardline]);
+    case "html":
+      return node.value;
+    case "list":
+      return concat([
+        printChildren(path, options, print, (parts, childPath, index) => {
+          const prefix = node.ordered ? `${node.start + index}. ` : "- ";
+          parts.push(
+            prefix,
+            align(prefix.length, childPath.call(print)),
+            hardline
+          );
+        }),
+        hardline
+      ]);
+    case "listItem": {
+      const prefix =
+        node.checked === null ? "" : node.checked ? "[x] " : "[ ] ";
+      return concat([
+        prefix,
+        align(
+          prefix.length,
+          printChildren(path, options, print, (parts, childPath, index) => {
+            const childNode = childPath.getValue();
+            parts.push(childPath.call(print));
+            if (
+              index !== node.children.length - 1 &&
+              childNode.type === "paragraph"
+            ) {
+              parts.push(hardline);
+            }
+          })
+        )
+      ]);
+    }
+    case "thematicBreak":
+      return concat(["---", hardline]);
+    case "table":
+      return printTable(path, options, print);
+    case "tableCell":
+      return printChildren(path, options, print);
+    case "tableRow": // handled in "table"
+    default:
+      throw new Error(`Unknown markdown type ${JSON.stringify(node.type)}`);
+  }
+}
+
+function hasParentType(path, typeOrTypes) {
+  const types = [].concat(typeOrTypes);
+
+  let counter = 0;
+  let parentNode;
+
+  while ((parentNode = path.getParentNode(counter++))) {
+    if (types.indexOf(parentNode.type) !== -1) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function printTable(path, options, print) {
+  const node = path.getValue();
+  const contents = []; // { [rowIndex: number]: { [columnIndex: number]: string } }
+
+  path.map(rowPath => {
+    const rowContents = [];
+
+    rowPath.map(cellPath => {
+      rowContents.push(
+        printDocToString(cellPath.call(print), options).formatted
+      );
+    }, "children");
+
+    contents.push(rowContents);
+  }, "children");
+
+  const columnMaxWidths = contents.reduce(
+    (currentWidths, rowContents) =>
+      currentWidths.map((width, columnIndex) =>
+        Math.max(width, rowContents[columnIndex].length)
+      ),
+    contents[0].map(() => 3) // minimum width = 3 (---, :--, :-:, --:)
+  );
+
+  return concat([
+    concat(contents.slice(0, 1).map(printRow)),
+    printSeparator(),
+    concat(contents.slice(1).map(printRow))
+  ]);
+
+  function printSeparator() {
+    return concat([
+      "| ",
+      join(
+        " | ",
+        columnMaxWidths.map((width, index) => {
+          switch (node.align[index]) {
+            case "left":
+              return ":" + "-".repeat(width - 1);
+            case "right":
+              return "-".repeat(width - 1) + ":";
+            case "center":
+              return ":" + "-".repeat(width - 2) + ":";
+            default:
+              return "-".repeat(width);
+          }
+        })
+      ),
+      " |",
+      hardline
+    ]);
+  }
+
+  function printRow(rowContents) {
+    return concat([
+      "| ",
+      join(
+        " | ",
+        rowContents.map((rowContent, columnIndex) => {
+          switch (node.align[columnIndex]) {
+            case "right":
+              return alignRight(rowContent, columnMaxWidths[columnIndex]);
+            case "center":
+              return alignCenter(rowContent, columnMaxWidths[columnIndex]);
+            default:
+              return alignLeft(rowContent, columnMaxWidths[columnIndex]);
+          }
+        })
+      ),
+      " |",
+      hardline
+    ]);
+  }
+
+  function alignLeft(text, width) {
+    return concat([text, " ".repeat(width - text.length)]);
+  }
+
+  function alignRight(text, width) {
+    return concat([" ".repeat(width - text.length), text]);
+  }
+
+  function alignCenter(text, width) {
+    const spaces = width - text.length;
+    const left = Math.floor(spaces / 2);
+    const right = spaces - left;
+    return concat([" ".repeat(left), text, " ".repeat(right)]);
+  }
+}
+
+function printBlockquotePrefix(path) {
+  let blockquoteLevel = 0;
+  let counter = 0;
+  let parentNode;
+
+  while ((parentNode = path.getParentNode(counter++))) {
+    if (parentNode.type === "blockquote") {
+      blockquoteLevel++;
+    }
+  }
+
+  return blockquoteLevel ? ">".repeat(blockquoteLevel) + " " : "";
+}
+
+function printChildren(path, options, print, iterator, command) {
+  command = command || concat;
+
+  const node = path.getValue();
+
+  const callback =
+    typeof iterator === "function"
+      ? iterator
+      : (parts, childPath, index) => {
+          parts.push(childPath.call(print));
+          if (index !== node.children.length - 1) {
+            parts.push(iterator || "");
+          }
+        };
+
+  const parts = [];
+
+  path.map((childPath, index) => {
+    // TODO: prettier-ignore
+    callback(parts, childPath, index);
+  }, "children");
+
+  return command(parts);
+}
+
+module.exports = genericPrint;

src/printer.js

@@ -58,6 +58,8 @@ function getPrintFunction(options) {
       return require("./printer-htmlparser2");
     case "postcss":
       return require("./printer-postcss");
+    case "markdown":
+      return require("./printer-markdown");
     default:
       return genericPrintNoParens;
   }