Update website

vendor/doctrine/rst-parser/tests/Parser/ParserTest.php

@@ -0,0 +1,455 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\RST\Parser;
+
+use Doctrine\RST\Nodes\CodeNode;
+use Doctrine\RST\Nodes\DocumentNode;
+use Doctrine\RST\Nodes\DummyNode;
+use Doctrine\RST\Nodes\ListNode;
+use Doctrine\RST\Nodes\Node;
+use Doctrine\RST\Nodes\ParagraphNode;
+use Doctrine\RST\Nodes\QuoteNode;
+use Doctrine\RST\Nodes\TableNode;
+use Doctrine\RST\Nodes\TitleNode;
+use Doctrine\RST\Parser;
+use Exception;
+use InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+
+use function assert;
+use function count;
+use function file_get_contents;
+use function sprintf;
+use function trim;
+
+/**
+ * Unit testing for RST
+ */
+class ParserTest extends TestCase
+{
+    /** @var Parser $parser */
+    protected $parser;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $directory = __DIR__ . '/files/';
+        $parser    = new Parser();
+
+        $parser->getEnvironment()->setCurrentDirectory($directory);
+
+        $this->parser = $parser;
+    }
+
+    public function testGetSubParserPassesConfiguration(): void
+    {
+        $parser = new Parser();
+
+        $configuration = $parser->getEnvironment()->getConfiguration();
+
+        $subParser = $parser->getSubParser();
+
+        self::assertSame($configuration, $subParser->getEnvironment()->getConfiguration());
+    }
+
+    /**
+     * Testing that code node value is good
+     */
+    public function testCodeNode(): void
+    {
+        $document = $this->parse('code-block-lastline.rst');
+
+        $nodes = $document->getNodes(static function ($node): bool {
+            return $node instanceof CodeNode;
+        });
+
+        self::assertSame(1, count($nodes));
+        self::assertSame("A\nB\n C", trim($nodes[0]->getValueString()));
+    }
+
+    /**
+     * Testing that code node options are parsed
+     */
+    public function testCodeNodeWithOptions(): void
+    {
+        $document = $this->parse('code-block-with-options.rst');
+
+        $nodes = $document->getNodes(static function (Node $node): bool {
+            return $node instanceof CodeNode;
+        });
+
+        self::assertSame(1, count($nodes));
+        $codeNode = $nodes[0];
+        assert($codeNode instanceof CodeNode);
+        self::assertSame("A\nB\nC", trim($codeNode->getValueString()));
+        self::assertSame(['name' => 'My Very Best Code'], $codeNode->getOptions());
+    }
+
+    /**
+     * Testing paragraph nodes
+     */
+    public function testParagraphNode(): void
+    {
+        $document = $this->parse('paragraph.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof ParagraphNode;
+        }, 1);
+        self::assertStringContainsString('Hello world!', $document->render());
+    }
+
+    /**
+     * Testing multi-paragraph nodes
+     */
+    public function testParagraphNodes(): void
+    {
+        $document = $this->parse('paragraphs.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof ParagraphNode;
+        }, 3);
+    }
+
+    /**
+     * Testing quote and block code
+     */
+    public function testBlockNode(): void
+    {
+        $quote = $this->parse('quote.rst');
+
+        self::assertHasNode($quote, static function ($node): bool {
+            return $node instanceof QuoteNode;
+        }, 1);
+
+        $code = $this->parse('code.rst');
+
+        self::assertHasNode($quote, static function ($node): bool {
+            return $node instanceof QuoteNode;
+        }, 1);
+
+        self::assertStringNotContainsString('::', $code->render());
+    }
+
+    /**
+     * Testing the titling
+     */
+    public function testTitles(): void
+    {
+        $document = $this->parse('title.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof TitleNode
+                && $node->getLevel() === 1;
+        }, 1);
+
+        $document = $this->parse('title2.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof TitleNode
+                && $node->getLevel() === 2;
+        }, 1);
+    }
+
+    public function testTitlesWithCustomInitialHeaderLevel(): void
+    {
+        $this->parser->getEnvironment()->getConfiguration()->setInitialHeaderLevel(2);
+
+        $document = $this->parse('title.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof TitleNode && $node->getLevel() === 2;
+        }, 1);
+
+        $document = $this->parse('title2.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof TitleNode && $node->getLevel() === 3;
+        }, 1);
+    }
+
+    public function testList(): void
+    {
+        $document = $this->parse('list.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof ListNode;
+        }, 1);
+
+        $document = $this->parse('list.rst');
+
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof ListNode;
+        }, 1);
+
+        $document = $this->parse('list-empty.rst');
+        self::assertHasNode($document, static function ($node): bool {
+            return $node instanceof ListNode;
+        }, 1);
+    }
+
+    /**
+     * Testing the titles retrieving
+     */
+    public function testGetTitles(): void
+    {
+        $document = $this->parse('titles.rst');
+
+        self::assertSame($document->getTitle(), 'The main title');
+        self::assertSame($document->getTitles(), [
+            [
+                'The main title',
+                [
+                    [
+                        'First level title',
+                        [
+                            ['Second level title', []],
+                            ['Other second level title', []],
+                        ],
+                    ],
+                    [
+                        'Other first level title',
+                        [
+                            ['Next second level title', []],
+                            ['Yet another second level title', []],
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+    }
+
+    /**
+     * Testing the table feature
+     */
+    public function testTable(): void
+    {
+        $document = $this->parse('table.rst');
+
+        $nodes = $document->getNodes(static function ($node): bool {
+            return $node instanceof TableNode;
+        });
+
+        self::assertSame(count($nodes), 1);
+
+        $table = $nodes[0];
+        assert($table instanceof TableNode);
+
+        self::assertSame(3, $table->getCols());
+        self::assertSame(3, $table->getRows());
+
+        $document = $this->parse('pretty-table.rst');
+
+        $nodes = $document->getNodes(static function ($node): bool {
+            return $node instanceof TableNode;
+        });
+
+        self::assertSame(count($nodes), 1);
+
+        $table = $nodes[0];
+        assert($table instanceof TableNode);
+
+        self::assertSame(3, $table->getCols());
+        self::assertSame(2, $table->getRows());
+    }
+
+    /**
+     * Tests that a simple replace works
+     */
+    public function testReplace(): void
+    {
+        $document = $this->parse('replace.rst');
+
+        self::assertStringContainsString('Hello world!', $document->render());
+    }
+
+    /**
+     * Test the include:: pseudo-directive
+     */
+    public function testInclusion(): void
+    {
+        $document = $this->parse('inclusion.rst');
+
+        self::assertStringContainsString('I was actually included', $document->renderDocument());
+    }
+
+    public function testThrowExceptionOnInvalidFileInclude(): void
+    {
+        $parser      = new Parser();
+        $environment = $parser->getEnvironment();
+
+        $data = file_get_contents(__DIR__ . '/files/inclusion-bad.rst');
+
+        self::assertIsString($data);
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Include ".. include:: non-existent-file.rst" does not exist or is not readable.');
+
+        $parser->parse($data);
+    }
+
+    public function testDirective(): void
+    {
+        $document = $this->parse('directive.rst');
+
+        $nodes = $document->getNodes(static function ($node): bool {
+            return $node instanceof DummyNode;
+        });
+
+        self::assertSame(1, count($nodes));
+
+        $node = $nodes[0];
+        assert($node instanceof DummyNode);
+
+        $data = $node->data;
+
+        self::assertSame('some data', $data['data']);
+        $options = $data['options'];
+        self::assertTrue(isset($options['maxdepth']));
+        self::assertTrue(isset($options['titlesonly']));
+        self::assertTrue(isset($options['glob']));
+        self::assertTrue($options['titlesonly']);
+        self::assertSame('123', $options['maxdepth']);
+    }
+
+    public function testSubsequentParsesDontHaveTheSameTitleLevelOrder(): void
+    {
+        $directory = __DIR__ . '/files';
+
+        $parser = new Parser();
+        $parser->getEnvironment()->setCurrentDirectory($directory);
+
+        /** @var TitleNode[] $nodes1 */
+        $nodes1 = $parser->parseFile(sprintf('%s/mixed-titles-1.rst', $directory))->getNodes();
+        /** @var TitleNode[] $nodes2 */
+        $nodes2 = $parser->parseFile(sprintf('%s/mixed-titles-2.rst', $directory))->getNodes();
+
+        $node = $nodes1[1];
+        self::assertSame(1, $node->getLevel());
+
+        $node = $nodes1[3];
+        self::assertSame(2, $node->getLevel());
+
+        $node = $nodes2[1];
+        self::assertSame(1, $node->getLevel(), 'Title level in second parse is influenced by first parse');
+
+        $node = $nodes2[3];
+        self::assertSame(2, $node->getLevel(), 'Title level in second parse is influenced by first parse');
+    }
+
+    public function testNewlineBeforeAnIncludedIsntGobbled(): void
+    {
+        /** @var Node[] $nodes */
+        $nodes = $this->parse('inclusion-newline.rst')->getNodes();
+
+        self::assertCount(5, $nodes);
+        self::assertInstanceOf('Doctrine\RST\Nodes\SectionBeginNode', $nodes[0]);
+        self::assertInstanceOf('Doctrine\RST\Nodes\TitleNode', $nodes[1]);
+        self::assertInstanceOf('Doctrine\RST\Nodes\ParagraphNode', $nodes[2]);
+        self::assertInstanceOf('Doctrine\RST\Nodes\ParagraphNode', $nodes[3]);
+        self::assertStringContainsString('<p>Test this paragraph is present.</p>', $nodes[2]->render());
+        self::assertStringContainsString('<p>And this one as well.</p>', $nodes[3]->render());
+    }
+
+    public function testIncludesKeepScope(): void
+    {
+        // See http://docutils.sourceforge.net/docs/ref/rst/directives.html#including-an-external-document-fragment
+
+        /** @var Node[] $nodes */
+        $nodes = $this->parse('inclusion-scope.rst')->getNodes();
+
+        self::assertCount(4, $nodes);
+
+        $node = $nodes[0]->getValue();
+        assert($node instanceof Node);
+        self::assertSame("This first example will be parsed at the document level, and can\nthus contain any construct, including section headers.", $node->render());
+
+        $node = $nodes[1]->getValue();
+        assert($node instanceof Node);
+        self::assertSame('This is included.', $node->render());
+
+        $node = $nodes[2]->getValue();
+        assert($node instanceof Node);
+        self::assertSame('Back in the main document.', $node->render());
+
+        self::assertInstanceOf('Doctrine\RST\Nodes\QuoteNode', $nodes[3]);
+
+        $node = $nodes[3]->getValue();
+        self::assertStringContainsString('This is included.', $node->render());
+    }
+
+    public function testIncludesPolicy(): void
+    {
+        $directory   = __DIR__ . '/files/';
+        $parser      = new Parser();
+        $environment = $parser->getEnvironment();
+        $environment->setCurrentDirectory($directory);
+
+        // Test defaults
+        self::assertTrue($parser->getIncludeAllowed());
+        self::assertSame('', $parser->getIncludeRoot());
+
+        // Default policy:
+        $document = $parser->parseFile($directory . 'inclusion-policy.rst')->render();
+        self::assertStringContainsString('SUBDIRECTORY OK', $document);
+        self::assertStringContainsString('EXTERNAL FILE INCLUDED!', $document);
+
+        // Disbaled policy:
+        $parser->setIncludePolicy(false);
+        $nodes = $parser->parseFile($directory . 'inclusion-policy.rst')->getNodes();
+        self::assertCount(1, $nodes);
+
+        // Enabled
+        $parser->setIncludePolicy(true);
+        $nodes = $parser->parseFile($directory . 'inclusion-policy.rst')->getNodes();
+        self::assertCount(6, $nodes);
+
+        // Jailed
+        $parser->setIncludePolicy(true, $directory);
+        $nodes = $parser->parseFile($directory . 'inclusion-policy.rst')->getNodes();
+        self::assertCount(5, $nodes);
+    }
+
+    public function testParseFileThrowsInvalidArgumentExceptionForMissingFile(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('File at path does-not-exist.rst does not exist');
+
+        $parser = new Parser();
+        $parser->parseFile('does-not-exist.rst');
+    }
+
+    /**
+     * Helper function, parses a file and returns the document
+     * produced by the parser
+     */
+    private function parse(string $file): DocumentNode
+    {
+        $directory = $this->parser->getEnvironment()->getCurrentDirectory();
+        $data      = file_get_contents($directory . $file);
+
+        if ($data === false) {
+            throw new Exception('Could not open file.');
+        }
+
+        return $this->parser->parse($data);
+    }
+
+    /**
+     * Asserts that a document has nodes that satisfy the function
+     */
+    private function assertHasNode(DocumentNode $document, callable $function, ?int $count = null): void
+    {
+        $nodes = $document->getNodes($function);
+        self::assertNotEmpty($nodes);
+
+        if ($count === null) {
+            return;
+        }
+
+        self::assertSame($count, count($nodes));
+    }
+}