Fix handling of empty paragraph

Author: amake

lib/src/org/grammar.dart

@@ -110,6 +110,7 @@ class OrgContentGrammarDefinition extends GrammarDefinition {
       ref0(localVariables) |
       ref0(pgpBlock) |
       ref0(comment) |
+      ref0(whitespaceOnlyParagraph) |
       ref0(paragraph);
 
   Parser elements() => ref0(element).star();
@@ -124,6 +125,11 @@ class OrgContentGrammarDefinition extends GrammarDefinition {
       ref1(textRun, ref0(paragraphEnd)).plusLazy(ref0(paragraphEnd)) &
       ref0(blankLines);
 
+  Parser whitespaceOnlyParagraph() =>
+      (lineStart() & insignificantWhitespace().plusString())
+          .flatten(message: 'Paragraph indent expected') &
+      endOfInput();
+
   Parser nonParagraphElement() =>
       element()..replace(ref0(paragraph), noOpFail());
 

lib/src/org/parser.dart

@@ -191,6 +191,12 @@ class OrgContentParserDefinition extends OrgContentGrammarDefinition {
         return OrgParagraph(indent, body, trailing);
       });
 
+  @override
+  Parser whitespaceOnlyParagraph() => super.whitespaceOnlyParagraph().map((items) {
+        final indent = items[0] as String;
+        return OrgParagraph(indent, OrgContent([]), '');
+      });
+
   @override
   Parser plainText([Parser? limit]) =>
       super.plainText(limit).map((value) => OrgPlainText(value as String));

test/org/model/parser_test.dart

@@ -552,6 +552,35 @@ baz''', interpretEmbeddedSettings: true);
       final radioLink = doc.find<OrgRadioLink>((_) => true);
       expect(radioLink!.node.content, 'baz');
     });
+    group('whitespace-only content', () {
+      test('round-trips document containing only spaces', () {
+        const markup = ' ';
+        final doc = OrgDocument.parse(markup);
+        final paragraph = doc.content!.children.single as OrgParagraph;
+        expect(paragraph.indent, ' ');
+        expect(paragraph.body.children, isEmpty);
+        expect(doc.toMarkup(), markup);
+      });
+
+      test('round-trips document containing only tabs', () {
+        const markup = '\t';
+        final doc = OrgDocument.parse(markup);
+        final paragraph = doc.content!.children.single as OrgParagraph;
+        expect(paragraph.indent, '\t');
+        expect(paragraph.body.children, isEmpty);
+        expect(doc.toMarkup(), markup);
+      });
+
+      test('round-trips section content ending with spaces only', () {
+        const markup = '* x\n ';
+        final doc = OrgDocument.parse(markup);
+        final paragraph =
+            doc.sections.single.content!.children.single as OrgParagraph;
+        expect(paragraph.indent, ' ');
+        expect(paragraph.body.children, isEmpty);
+        expect(doc.toMarkup(), markup);
+      });
+    });
   });
 }
 

test/org/parser/parser_test.dart

@@ -135,5 +135,37 @@ r0SZNYouvk7tY6rDz0Z62WRwOtrBx0D/5T0E9kT3rpnB
         baz buzz''');
       expect(doc.sections[0].headline.keyword?.value, 'TODO');
     });
+    group('whitespace-only content', () {
+      test('document containing only spaces', () {
+        final result = parser.parse(' ');
+        expect(result, isA<Success<dynamic>>());
+        final document = result.value as OrgDocument;
+        final paragraph = document.content!.children.single as OrgParagraph;
+        expect(paragraph.indent, ' ');
+        expect(paragraph.body.children, isEmpty);
+        expect(paragraph.trailing, '');
+      });
+
+      test('document containing only tabs', () {
+        final result = parser.parse('\t');
+        expect(result, isA<Success<dynamic>>());
+        final document = result.value as OrgDocument;
+        final paragraph = document.content!.children.single as OrgParagraph;
+        expect(paragraph.indent, '\t');
+        expect(paragraph.body.children, isEmpty);
+        expect(paragraph.trailing, '');
+      });
+
+      test('section content ending with spaces only', () {
+        final result = parser.parse('* x\n ');
+        expect(result, isA<Success<dynamic>>());
+        final document = result.value as OrgDocument;
+        final paragraph = document.sections.single.content!.children.single
+            as OrgParagraph;
+        expect(paragraph.indent, ' ');
+        expect(paragraph.body.children, isEmpty);
+        expect(paragraph.trailing, '');
+      });
+    });
   });
 }

test/org/parser/robustness_test.dart

@@ -0,0 +1,99 @@
+import 'dart:math';
+
+import 'package:org_parser/org_parser.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('robustness', () {
+    test('OrgDocument.parse does not throw on short punctuation-heavy inputs',
+        () {
+      const alphabet = [
+        '*',
+        ' ',
+        '\n',
+        ':',
+        '[',
+        ']',
+        '#',
+        '+',
+        '-',
+        '/',
+        '\\',
+        '{',
+        '}',
+        '<',
+        '>',
+        '|',
+        'a',
+        '1',
+        '\r',
+        '\t',
+      ];
+
+      for (var len = 0; len <= 4; len++) {
+        final total = pow(alphabet.length, len).toInt();
+        for (var i = 0; i < total; i++) {
+          var n = i;
+          final buf = StringBuffer();
+          for (var j = 0; j < len; j++) {
+            buf.write(alphabet[n % alphabet.length]);
+            n ~/= alphabet.length;
+          }
+          final input = buf.toString();
+          expect(
+            () => OrgDocument.parse(input),
+            returnsNormally,
+            reason: 'input=${_escape(input)}',
+          );
+        }
+      }
+    });
+
+    test('OrgDocument.parse does not throw on deterministic randomized inputs',
+        () {
+      const alphabet = [
+        '*',
+        ' ',
+        '\n',
+        ':',
+        '[',
+        ']',
+        '#',
+        '+',
+        '-',
+        '/',
+        '\\',
+        '{',
+        '}',
+        '<',
+        '>',
+        '|',
+        'a',
+        '1',
+        '\r',
+        '\t',
+      ];
+      final rand = Random(0);
+
+      for (var i = 0; i < 5000; i++) {
+        final len = rand.nextInt(120);
+        final buf = StringBuffer();
+        for (var j = 0; j < len; j++) {
+          buf.write(alphabet[rand.nextInt(alphabet.length)]);
+        }
+        final input = buf.toString();
+        expect(
+          () => OrgDocument.parse(input),
+          returnsNormally,
+          reason: 'case=$i input=${_escape(input)}',
+        );
+      }
+    });
+  });
+}
+
+String _escape(String input) => input
+    .replaceAll('\\', r'\\')
+    .replaceAll('\n', r'\n')
+    .replaceAll('\r', r'\r')
+    .replaceAll('\t', r'\t');