comment-parser 1.2.3 → 1.3.1

package/src/transforms/align.ts

@@ -1,5 +1,5 @@
 import { Transform } from './index';
-import { Markers, Block, Line } from '../primitives';
+import { BlockMarkers, Block, Line, Markers } from '../primitives';
 import { rewireSource } from '../util';
 
 interface Width {
@@ -16,16 +16,18 @@ const zeroWidth = {
   name: 0,
 };
 
-const getWidth = (w: Width, { tokens: t }: Line) => ({
-  start: t.delimiter === Markers.start ? t.start.length : w.start,
-  tag: Math.max(w.tag, t.tag.length),
-  type: Math.max(w.type, t.type.length),
-  name: Math.max(w.name, t.name.length),
-});
+const getWidth =
+  (markers = Markers) =>
+  (w: Width, { tokens: t }: Line) => ({
+    start: t.delimiter === markers.start ? t.start.length : w.start,
+    tag: Math.max(w.tag, t.tag.length),
+    type: Math.max(w.type, t.type.length),
+    name: Math.max(w.name, t.name.length),
+  });
 
 const space = (len: number) => ''.padStart(len, ' ');
 
-export default function align(): Transform {
+export default function align(markers = Markers): Transform {
   let intoTags = false;
   let w: Width;
 
@@ -40,16 +42,16 @@ export default function align(): Transform {
       tokens.description === '';
 
     // dangling '*/'
-    if (tokens.end === Markers.end && isEmpty) {
+    if (tokens.end === markers.end && isEmpty) {
       tokens.start = space(w.start + 1);
       return { ...line, tokens };
     }
 
     switch (tokens.delimiter) {
-      case Markers.start:
+      case markers.start:
         tokens.start = space(w.start);
         break;
-      case Markers.delim:
+      case markers.delim:
         tokens.start = space(w.start + 1);
         break;
       default:
@@ -101,7 +103,7 @@ export default function align(): Transform {
   }
 
   return ({ source, ...fields }: Block): Block => {
-    w = source.reduce(getWidth, { ...zeroWidth });
+    w = source.reduce(getWidth(markers), { ...zeroWidth });
     return rewireSource({ ...fields, source: source.map(update) });
   };
 }

package/tests/e2e/examples.js

@@ -80,7 +80,7 @@ function parse_escaping(source, parse, stringify, transforms) {
   // parse(source, {fence: '###'}) -- update source correspondingly
 
   /**
-   * @example "some code" 
+   * @example "some code"
   ###
   @decorator
   function hello() {

package/tests/e2e/parse.spec.js

@@ -480,15 +480,6 @@ test('description on the first line', () => {
   ]);
 });
 
-test('skip empty blocks', () => {
-  const parsed = parse(`
-  /**
-   *
-   */
-  var a`);
-  expect(parsed).toHaveLength(0);
-});
-
 test('multiple blocks', () => {
   const parsed = parse(`
   /**

package/tests/unit/parser.spec.ts

@@ -4,7 +4,7 @@ import { seedTokens } from '../../src/util';
 test('block with tags', () => {
   const parsed = getParser()(`
   /**
-   * Description may go 
+   * Description may go\x20
    * over few lines followed by @tags
    * @param {string} name name parameter
    *
@@ -167,10 +167,10 @@ test('block with tags', () => {
   ]);
 });
 
-test('no source clonning', () => {
+test('no source cloning', () => {
   const parsed = getParser()(`
   /**
-   * Description may go 
+   * Description may go\x20
    * over few lines followed by @tags
    * @param {string} name name parameter
    *
@@ -179,11 +179,111 @@ test('no source clonning', () => {
   expect(parsed[0].tags[0].source[0] === parsed[0].source[3]).toBe(true);
 });
 
+test('empty multi-line block', () => {
+  const parsed = getParser()(`
+  /**
+   *
+   */`);
+  expect(parsed).toEqual([
+    {
+      description: '',
+      tags: [],
+      source: [
+        {
+          number: 1,
+          source: '  /**',
+          tokens: {
+            delimiter: '/**',
+            description: '',
+            end: '',
+            lineEnd: '',
+            name: '',
+            postDelimiter: '',
+            postName: '',
+            postTag: '',
+            postType: '',
+            start: '  ',
+            tag: '',
+            type: '',
+          },
+        },
+        {
+          number: 2,
+          source: '   *',
+          tokens: {
+            delimiter: '*',
+            description: '',
+            end: '',
+            lineEnd: '',
+            name: '',
+            postDelimiter: '',
+            postName: '',
+            postTag: '',
+            postType: '',
+            start: '   ',
+            tag: '',
+            type: '',
+          },
+        },
+        {
+          number: 3,
+          source: '   */',
+          tokens: {
+            delimiter: '',
+            description: '',
+            end: '*/',
+            lineEnd: '',
+            name: '',
+            postDelimiter: '',
+            postName: '',
+            postTag: '',
+            postType: '',
+            start: '   ',
+            tag: '',
+            type: '',
+          },
+        },
+      ],
+      problems: [],
+    },
+  ]);
+});
+
+test('empty one-line block', () => {
+  const parsed = getParser()(`
+  /** */`);
+  expect(parsed).toEqual([
+    {
+      description: '',
+      tags: [],
+      source: [
+        {
+          number: 1,
+          source: '  /** */',
+          tokens: {
+            delimiter: '/**',
+            description: '',
+            end: '*/',
+            lineEnd: '',
+            name: '',
+            postDelimiter: ' ',
+            postName: '',
+            postTag: '',
+            postType: '',
+            start: '  ',
+            tag: '',
+            type: '',
+          },
+        },
+      ],
+      problems: [],
+    },
+  ]);
+});
+
 test.each([
-  ['empty', '/**\n*\n*/'],
   ['one-star', '/*\n*\n*/'],
   ['three-star', '/***\n*\n*/'],
-  ['empty one-liner', '/** */'],
   ['one-star oneliner', '/* */'],
   ['three-star oneliner', '/*** */'],
 ])('skip block - %s', (name, source) => {

package/tests/unit/source-parser.spec.ts

@@ -286,3 +286,153 @@ test('carriage returns', () => {
 
   expect(parsed).toEqual([...nulls(3), block, null]);
 });
+
+test('custom markers', () => {
+  _parse = getParser({
+    markers: {
+      start: '////',
+      nostart: '// ',
+      delim: '///',
+      end: '////',
+    },
+  });
+
+  const parsed = parse(`
+    ////
+    /// description 0
+    ///
+    /// description 1
+    ///
+    /// @param {string} value value description 0
+    \`\`\`
+    @sample code
+    \`\`\`
+    /// description 1
+    ////`);
+
+  const block = [
+    {
+      number: 1,
+      source: '    ////',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '////',
+        postDelimiter: '',
+        description: '',
+        end: '',
+      }),
+    },
+    {
+      number: 2,
+      source: '    /// description 0',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '///',
+        postDelimiter: ' ',
+        description: 'description 0',
+        end: '',
+      }),
+    },
+    {
+      number: 3,
+      source: '    ///',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '///',
+        postDelimiter: '',
+        description: '',
+        end: '',
+      }),
+    },
+    {
+      number: 4,
+      source: '    /// description 1',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '///',
+        postDelimiter: ' ',
+        description: 'description 1',
+        end: '',
+      }),
+    },
+    {
+      number: 5,
+      source: '    ///',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '///',
+        postDelimiter: '',
+        description: '',
+        end: '',
+      }),
+    },
+    {
+      number: 6,
+      source: '    /// @param {string} value value description 0',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '///',
+        postDelimiter: ' ',
+        description: '@param {string} value value description 0',
+        end: '',
+      }),
+    },
+    {
+      number: 7,
+      source: '    ```',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '',
+        postDelimiter: '',
+        description: '```',
+        end: '',
+      }),
+    },
+    {
+      number: 8,
+      source: '    @sample code',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '',
+        postDelimiter: '',
+        description: '@sample code',
+        end: '',
+      }),
+    },
+    {
+      number: 9,
+      source: '    ```',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '',
+        postDelimiter: '',
+        description: '```',
+        end: '',
+      }),
+    },
+    {
+      number: 10,
+      source: '    /// description 1',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '///',
+        postDelimiter: ' ',
+        description: 'description 1',
+        end: '',
+      }),
+    },
+    {
+      number: 11,
+      source: '    ////',
+      tokens: seedTokens({
+        start: '    ',
+        delimiter: '',
+        postDelimiter: '',
+        description: '',
+        end: '////',
+      }),
+    },
+  ];
+
+  expect(parsed).toEqual([...nulls(11), block]);
+});

package/tests/unit/util.spec.ts

@@ -1,4 +1,5 @@
 import {
+  hasCR,
   isSpace,
   seedTokens,
   seedBlock,
@@ -7,6 +8,15 @@ import {
   seedSpec,
 } from '../../src/util';
 
+test.each([
+  ['beginning', '\r to end', false],
+  ['middle', 'has \r in middle', false],
+  ['ending', 'only at end \r', true],
+  ['none', 'no carriage returns', false],
+])('carriage returns - %s', (name, source, boolResult) => {
+  expect(hasCR(source)).toEqual(boolResult);
+});
+
 test.each([
   ['win', 'a\r\nb\r\nc', ['a\r', 'b\r', 'c']],
   ['unix', 'a\nb\nc', ['a', 'b', 'c']],