@khanacademy/perseus 0.2.7 → 0.2.8

package/src/__tests__/__snapshots__/pure-markdown_test.js.snap

@@ -1,113 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`pure markdown parser should parse titled table with unescaped dollars 1`] = `
-Array [
-  Object {
-    "table": Object {
-      "align": Array [
-        null,
-        null,
-        null,
-      ],
-      "cells": Array [
-        Array [
-          Array [
-            Object {
-              "content": "data 1",
-              "type": "text",
-            },
-          ],
-          Array [
-            Object {
-              "content": "data 2",
-              "type": "text",
-            },
-          ],
-          Array [
-            Object {
-              "content": "data 3",
-              "type": "text",
-            },
-          ],
-        ],
-        Array [
-          Array [
-            Object {
-              "content": "data 4",
-              "type": "text",
-            },
-          ],
-          Array [
-            Object {
-              "type": "unescapedDollar",
-            },
-            Object {
-              "content": "data 5",
-              "type": "text",
-            },
-          ],
-          Array [
-            Object {
-              "content": "data 6",
-              "type": "text",
-            },
-          ],
-        ],
-        Array [
-          Array [
-            Object {
-              "content": "data 7",
-              "type": "text",
-            },
-          ],
-          Array [
-            Object {
-              "content": "data 8",
-              "type": "text",
-            },
-          ],
-          Array [
-            Object {
-              "content": "data 9",
-              "type": "text",
-            },
-          ],
-        ],
-      ],
-      "header": Array [
-        Array [
-          Object {
-            "content": "header 1",
-            "type": "text",
-          },
-        ],
-        Array [
-          Object {
-            "content": "header 2",
-            "type": "text",
-          },
-        ],
-        Array [
-          Object {
-            "content": "header 3",
-            "type": "text",
-          },
-        ],
-      ],
-      "type": "table",
-    },
-    "title": Array [
-      Object {
-        "content": Array [
-          Object {
-            "content": "Table title",
-            "type": "text",
-          },
-        ],
-        "type": "strong",
-      },
-    ],
-    "type": "titledTable",
-  },
-]
-`;

package/src/__tests__/pure-markdown_test.js

@@ -1,552 +0,0 @@
-// @flow
-import {parse} from "../pure-markdown.js";
-
-describe("pure markdown", () => {
-    describe("parser", () => {
-        it.each([
-            {
-                content: "math $y = x + 1$",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "math "},
-                            {type: "math", content: "y = x + 1"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "hi $y = x + 1$ there",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "hi "},
-                            {type: "math", content: "y = x + 1"},
-                            {type: "text", content: " there"},
-                        ],
-                    },
-                ],
-            },
-        ])("should parse math", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it.each([
-            {
-                content: "math $y = \\text{$x + 1$}$",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "math "},
-                            {type: "math", content: "y = \\text{$x + 1$}"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content:
-                    "math $ x^2 \\text{blah $math \\text{some $more math$} $ } $",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "math "},
-                            {
-                                type: "math",
-                                content:
-                                    " x^2 \\text{blah $math " +
-                                    "\\text{some $more math$} $ } ",
-                            },
-                        ],
-                    },
-                ],
-            },
-        ])("should parse nested math", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it.each([
-            {
-                content: "math $\\\\$",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "math "},
-                            {type: "math", content: "\\\\"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "math $\\$$",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "math "},
-                            {type: "math", content: "\\$"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "${$",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "unescapedDollar"},
-                            {type: "text", content: "{"},
-                            {type: "unescapedDollar"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "math $\\{$",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "math "},
-                            {type: "math", content: "\\{"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "hello $ escaped dollar \\$ $ not math",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "text", content: "hello "},
-                            {type: "math", content: " escaped dollar \\$ "},
-                            {type: "text", content: " not math"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "$math$ not math $ oops extra dollar",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {content: "math", type: "math"},
-                            {content: " not math ", type: "text"},
-                            {type: "unescapedDollar"},
-                            {content: " oops extra dollar", type: "text"},
-                        ],
-                    },
-                ],
-            },
-        ])("should allow escaping in math", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it.each([
-            {
-                content: "$x + y = 7$",
-                expected: [
-                    {
-                        type: "blockMath",
-                        content: "x + y = 7",
-                    },
-                ],
-            },
-            {
-                content: "$x + y = 7$\nnot math",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "math", content: "x + y = 7"},
-                            {type: "text", content: "\nnot math"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "  $x + y = 7$  \n\n    \n$3 + 5 = 7$",
-                expected: [
-                    {
-                        type: "blockMath",
-                        content: "x + y = 7",
-                    },
-                    {
-                        type: "blockMath",
-                        content: "3 + 5 = 7",
-                    },
-                ],
-            },
-            {
-                content: "    $x + y = 7$",
-                expected: [
-                    {
-                        type: "codeBlock",
-                        content: "$x + y = 7$",
-                        lang: undefined,
-                    },
-                ],
-            },
-            {
-                content: "> $x + y = 7$",
-                expected: [
-                    {
-                        type: "blockQuote",
-                        content: [
-                            {
-                                type: "blockMath",
-                                content: "x + y = 7",
-                            },
-                        ],
-                    },
-                ],
-            },
-        ])("should parse block math", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it.each([
-            {
-                content: "hello $ single dollar paragraph\n\n not math $",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {content: "hello ", type: "text"},
-                            {type: "unescapedDollar"},
-                            {content: " single dollar paragraph", type: "text"},
-                        ],
-                    },
-                    {
-                        type: "paragraph",
-                        content: [
-                            {content: " not math ", type: "text"},
-                            {type: "unescapedDollar"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "hello $ bad { math $",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {content: "hello ", type: "text"},
-                            {type: "unescapedDollar"},
-                            {content: " bad ", type: "text"},
-                            {content: "{ math ", type: "text"},
-                            {type: "unescapedDollar"},
-                        ],
-                    },
-                ],
-            },
-        ])("should break on paragraphs", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it.each([
-            {
-                content: "[[☃ test 1]]",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "widget",
-                                widgetType: "test",
-                                id: "test 1",
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "[[☃ test 1]]+[[☃ input-number 2]]",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "widget",
-                                widgetType: "test",
-                                id: "test 1",
-                            },
-                            {
-                                type: "text",
-                                content: "+",
-                            },
-                            {
-                                type: "widget",
-                                widgetType: "input-number",
-                                id: "input-number 2",
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "*[[☃ test 2]]* [[☃ input-number 1]]",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "em",
-                                content: [
-                                    {
-                                        type: "widget",
-                                        widgetType: "test",
-                                        id: "test 2",
-                                    },
-                                ],
-                            },
-                            {
-                                type: "text",
-                                content: " ",
-                            },
-                            {
-                                type: "widget",
-                                widgetType: "input-number",
-                                id: "input-number 1",
-                            },
-                        ],
-                    },
-                ],
-            },
-        ])("should parse widget types and ids", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it("should allow escaping widget identifiers", () => {
-            // Arrange, Act
-            const parsed = parse("\\[[☃ test 1]]");
-
-            // Assert
-            expect(parsed).toEqual([
-                {
-                    type: "paragraph",
-                    content: [
-                        {content: "[", type: "text"},
-                        {content: "[☃ test 1", type: "text"},
-                        {content: "]", type: "text"},
-                        {content: "]", type: "text"},
-                    ],
-                },
-            ]);
-        });
-
-        it.each([
-            {
-                content: "[[☃ test 1]][[☃ test 2]]",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "widget", widgetType: "test", id: "test 1"},
-                            {type: "widget", widgetType: "test", id: "test 2"},
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "[[☃ test 1]] [[☃ test 2]]",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {type: "widget", widgetType: "test", id: "test 1"},
-                            {type: "text", content: " "},
-                            {type: "widget", widgetType: "test", id: "test 2"},
-                        ],
-                    },
-                ],
-            },
-        ])(
-            "should parse widgets next to each other as widgets",
-            ({content, expected}) => {
-                // Arrange, Act
-                const parsed = parse(content);
-
-                // Assert
-                expect(parsed).toEqual(expected);
-            },
-        );
-
-        it("should parse multiple columns", () => {
-            // Arrange, Act
-            const parsed = parse("hi\n\n" + "=====\n\n" + "there\n\n");
-
-            // Assert
-            expect(parsed).toEqual([
-                {
-                    type: "columns",
-                    col1: [
-                        {
-                            type: "paragraph",
-                            content: [
-                                {
-                                    type: "text",
-                                    content: "hi",
-                                },
-                            ],
-                        },
-                    ],
-                    col2: [
-                        {
-                            type: "paragraph",
-                            content: [
-                                {
-                                    type: "text",
-                                    content: "there",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            ]);
-        });
-
-        it.each([
-            {
-                content: "1. test\n\n" + "2. boo\n\n",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "text",
-                                content: "1",
-                            },
-                            {
-                                type: "text",
-                                content: ". test",
-                            },
-                        ],
-                    },
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "text",
-                                content: "2",
-                            },
-                            {
-                                type: "text",
-                                content: ". boo",
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                content: "* test\n\n" + "* boo\n\n",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "text",
-                                content: "* test",
-                            },
-                        ],
-                    },
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "text",
-                                content: "* boo",
-                            },
-                        ],
-                    },
-                ],
-            },
-        ])("should ignore lists in jipt mode", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content, {isJipt: true});
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it.each([
-            {
-                content: "$",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [{type: "unescapedDollar"}],
-                    },
-                ],
-            },
-            {
-                content: "hello $ single dollar",
-                expected: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {content: "hello ", type: "text"},
-                            {type: "unescapedDollar"},
-                            {content: " single dollar", type: "text"},
-                        ],
-                    },
-                ],
-            },
-        ])("should detect unescaped dollars", ({content, expected}) => {
-            // Arrange, Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toEqual(expected);
-        });
-
-        it("should parse titled table with unescaped dollars", () => {
-            // Arrange
-            const content =
-                "|| **Table title** ||\n" +
-                "header 1 | header 2 | header 3\n" +
-                "- | - | -\n" +
-                "data 1 | data 2 | data 3\n" +
-                "data 4 | $data 5 | data 6\n" +
-                "data 7 | data 8 | data 9";
-
-            // Act
-            const parsed = parse(content);
-
-            // Assert
-            expect(parsed).toMatchSnapshot();
-        });
-    });
-});

package/src/gorgon/README

@@ -1,40 +0,0 @@
-Gorgon is the linter engine for Perseus. It is implemented by the
-following files:
-
-tree-transformer.js:
-
-  This file defines a TreeTransformer class for traversing (and
-  optionally transforming by inserting, reparenting and removing
-  nodes) markdown parse trees. When traversing a tree, a
-  TreeTransformer calls the function you specify on each node. This is
-  a post-order traversal: the function is called on the way back up,
-  not on the way down. When the function is invoked, it is passed the
-  current node, a state object, and the concatenated content of the
-  node and its descendants.  The state object is the interesting one:
-  it is an instance of TraversalState, which is a class defined in
-  (but not exported by) this same file. TraversalState has an API for
-  querying the ancestors and siblings of the current node, and also an
-  API for replacing the current node with a new one.
-
-selector.js:
-
-  This file defines the Selector class which works like a CSS selector
-  for markdown parse trees. Selector.parse() converts strings like
-  "heading + paragraph > text" to Selector objects. A Selector object
-  has a match() method that tests whether a given node in a parse tree
-  matches. The match() method takes a TraversalState object as its
-  argument, so selectors can only be used during a TreeTransformer
-  traversal.
-
-rule.js:
-
-  This file defines the Rule class which represents a single lint
-  rule. A Rule object has a check() method that takes the same (node,
-  state, content) arguments that a TreeTransformer passes to the
-  traversal callback function. Rules can have a selector, a regular
-  expression, and a function. If a node matches the selector and its
-  content matches the regular expression, then the function is called
-  to check the node and return a warning message if the node does, in
-  fact, have lint.
-
-See the individual file for additional documentation.