Added a parseContents method for parsing strings.

Added tests.

Author: neogeek

packages/doxdox-parser-jsdoc/src/index.test.ts

@@ -0,0 +1,90 @@
+import { parseContents } from './index';
+
+describe('jsdoc parser', () => {
+    it('parse example jsdoc header', async () => {
+        await expect(
+            parseContents(
+                'cache/',
+                'utils.js',
+                `/**
+* Finds file in path.
+*
+*     console.log(await findFileInPath('./', 'package.json'));
+*     console.log(await findFileInPath('../', 'package.json'));
+*     console.log(await findFileInPath('~/git/github/doxdox/', '.package.json'));
+*
+* @param {string} [input] Directory to check for file.
+* @param {string?} [fileName = 'package.json'] File name to check for.
+* @return {Promise<string | null>} Path to package.json file.
+* @public
+*/
+
+const findFileInPath = async (input, fileName = 'package.json') => {};
+
+/**
+ * Get the root directory of the package, supplied path or URL.
+ *
+ * @param {string?} [url] Optional path or URL.
+ * @return {string} Directory path.
+ * @public
+ */
+
+const getRootDirPath = (url) => {}`
+            )
+        ).resolves.toEqual(
+            expect.objectContaining({
+                path: 'utils.js',
+                methods: expect.arrayContaining([
+                    expect.objectContaining({
+                        fullName: 'findFileInPath(input, fileName)',
+                        name: 'findFileInPath',
+                        params: expect.arrayContaining([
+                            expect.objectContaining({
+                                name: 'input',
+                                types: ['string']
+                            }),
+                            expect.objectContaining({
+                                name: 'fileName',
+                                types: ['string']
+                            })
+                        ]),
+                        private: false,
+                        returns: expect.arrayContaining([
+                            expect.objectContaining({
+                                name: undefined,
+                                types: ['Promise.<(string|null)>']
+                            })
+                        ]),
+                        slug: 'utils-js-findfileinpath'
+                    }),
+                    expect.objectContaining({
+                        fullName: 'getRootDirPath(url)',
+                        name: 'getRootDirPath',
+                        params: expect.arrayContaining([
+                            expect.objectContaining({
+                                name: 'url',
+                                types: ['string']
+                            })
+                        ]),
+                        private: false,
+                        returns: expect.arrayContaining([
+                            expect.objectContaining({
+                                name: undefined,
+                                types: ['string']
+                            })
+                        ]),
+                        slug: 'utils-js-getrootdirpath'
+                    })
+                ])
+            })
+        );
+    });
+    it('parse empty string', async () => {
+        await expect(parseContents('cache/', 'test.js', '')).resolves.toEqual(
+            expect.objectContaining({
+                path: 'test.js',
+                methods: []
+            })
+        );
+    });
+});

packages/doxdox-parser-jsdoc/src/index.ts

@@ -1,3 +1,5 @@
+import { promises as fs } from 'fs';
+
 import { platform } from 'os';
 
 import { dirname, join } from 'path';
@@ -10,7 +12,7 @@ import { File } from 'doxdox-core';
 
 import { Jsdoc } from './types';
 
-export default async (cwd: string, path: string): Promise<File> => {
+const parser = async (cwd: string, path: string): Promise<File> => {
     try {
         const nodeModulesDir = await findParentNodeModules(
             dirname(sanitizePath(import.meta.url))
@@ -93,3 +95,28 @@ export default async (cwd: string, path: string): Promise<File> => {
 
     return { path, methods: [] };
 };
+
+export const parseContents = async (
+    tempDir: string,
+    path: string,
+    content: string
+): Promise<File> => {
+    const tempPath = `${tempDir}/${path}`;
+
+    await fs.mkdir(dirname(tempPath), { recursive: true });
+
+    await fs.writeFile(tempPath, content);
+
+    const file = await parser(tempDir, path);
+
+    try {
+        await fs.unlink(tempPath);
+        await fs.rm(tempDir, { recursive: true });
+    } catch (error) {
+        console.log(error);
+    }
+
+    return file;
+};
+
+export default parser;