chore(plugin-doc-coverage): wip request in pr

Author: aramirezj

code-pushup.config.ts

@@ -1,12 +1,6 @@
 import 'dotenv/config';
 import { z } from 'zod';
-import {
-  coverageCoreConfigNx,
-  docCoverageCoreConfig,
-  eslintCoreConfigNx,
-  jsPackagesCoreConfig,
-  lighthouseCoreConfig,
-} from './code-pushup.preset.js';
+import { docCoverageCoreConfig } from './code-pushup.preset.js';
 import type { CoreConfig } from './packages/models/src/index.js';
 import { mergeConfigs } from './packages/utils/src/index.js';
 
@@ -34,20 +28,18 @@ const config: CoreConfig = {
 
 export default mergeConfigs(
   config,
-  await coverageCoreConfigNx(),
-  await jsPackagesCoreConfig(),
-  await lighthouseCoreConfig(
-    'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/',
-  ),
-  await eslintCoreConfigNx(),
-  await docCoverageCoreConfig({
-    sourceGlob: [
-      'packages/**/src/**/*.ts',
-      '!packages/**/node_modules',
-      '!packages/**/{mocks,mock}',
-      '!**/*.{spec,test}.ts',
-      '!**/implementation/**',
-      '!**/internal/**',
-    ],
-  }),
+  // await coverageCoreConfigNx(),
+  // await jsPackagesCoreConfig(),
+  // await lighthouseCoreConfig(
+  //   'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/',
+  // ),
+  // await eslintCoreConfigNx(),
+  docCoverageCoreConfig([
+    'packages/**/src/**/*.ts',
+    '!packages/**/node_modules',
+    '!packages/**/{mocks,mock}',
+    '!**/*.{spec,test}.ts',
+    '!**/implementation/**',
+    '!**/internal/**',
+  ]),
 );

code-pushup.preset.ts

@@ -95,8 +95,8 @@ export function getDocCoverageCategories(
 ): CategoryConfig[] {
   return [
     {
-     slug: 'docs',
-     title: 'Documentation',
+      slug: 'docs',
+      title: 'Documentation',
       description: 'Measures how much of your code is **documented**.',
       refs: filterGroupsByOnlyAudits(groups, config).map(group => ({
         weight: 1,
@@ -141,11 +141,15 @@ export const lighthouseCoreConfig = async (
 };
 
 export const docCoverageCoreConfig = (
-  config: DocCoveragePluginConfig,
+  config: DocCoveragePluginConfig | string[],
 ): CoreConfig => {
   return {
-    plugins: [docCoveragePlugin(config)],
-    categories: getDocCoverageCategories(config),
+    plugins: [
+      docCoveragePlugin(Array.isArray(config) ? { patterns: config } : config),
+    ],
+    categories: getDocCoverageCategories(
+      Array.isArray(config) ? { patterns: config } : config,
+    ),
   };
 };
 

packages/plugin-doc-coverage/README.md

@@ -45,7 +45,7 @@ Measured documentation types are mapped to Code PushUp audits in the following w
      plugins: [
        // ...
        docCoveragePlugin({
-         sourceGlob: ['**/*.ts'],
+         patterns: ['**/*.ts'],
        }),
      ],
    };
@@ -100,13 +100,13 @@ These audits are grouped together to provide a comprehensive view of your codeba
 
 The plugin accepts the following parameters:
 
-#### SourceGlob
+#### patterns
 
-Required parameter. The `sourceGlob` option accepts an array of strings that define patterns to include or exclude files. You can use glob patterns to match files and the `!` symbol to exclude specific patterns. Example:
+Required parameter. The `patterns` option accepts an array of strings that define patterns to include or exclude files. You can use glob patterns to match files and the `!` symbol to exclude specific patterns. Example:
 
 ```js
 docCoveragePlugin({
-  sourceGlob: [
+  patterns: [
     'src/**/*.ts',              // include all TypeScript files in src
     '!src/**/*.{spec,test}.ts', // exclude test files
     '!src/**/testing/**/*.ts'   // exclude testing utilities
@@ -120,7 +120,7 @@ Optional parameter. The `onlyAudits` option allows you to specify which document
 
 ```js
 docCoveragePlugin({
-  sourceGlob: ['src/**/*.ts'],
+  patterns: ['src/**/*.ts'],
   onlyAudits: [
     'classes-coverage',
     'functions-coverage'
@@ -134,7 +134,7 @@ Optional parameter. The `skipAudits` option allows you to exclude specific docum
 
 ```js
 docCoveragePlugin({
-  sourceGlob: ['src/**/*.ts'],
+  patterns: ['src/**/*.ts'],
   skipAudits: [
     'variables-coverage',
     'interfaces-coverage'

packages/plugin-doc-coverage/src/lib/config.ts

@@ -1,6 +1,10 @@
 import { z } from 'zod';
 
-export const docCoveragePluginConfigSchema = z
+const patternsSchema = z.union([z.string(), z.array(z.string()).min(1)], {
+  description: 'Glob pattern to match source files to evaluate.',
+});
+
+const docCoverageTargetObjectSchema = z
   .object({
     skipAudits: z
       .array(z.string())
@@ -14,16 +18,21 @@ export const docCoveragePluginConfigSchema = z
       .describe(
         'List of audit slugs to evaluate. When specified, only these audits will be evaluated.',
       ),
-    sourceGlob: z
-      .array(z.string())
-      .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'])
-      .describe('Glob pattern to match source files to evaluate.'),
+    patterns: patternsSchema,
   })
   .refine(data => !(data.skipAudits && data.onlyAudits), {
     message: "You can't define 'skipAudits' and 'onlyAudits' simultaneously",
     path: ['skipAudits', 'onlyAudits'],
   });
 
+export const docCoveragePluginConfigSchema = z
+  .union([patternsSchema, docCoverageTargetObjectSchema])
+  .transform(target =>
+    typeof target === 'string' || Array.isArray(target)
+      ? { patterns: target }
+      : target,
+  );
+
 export type DocCoveragePluginConfig = z.infer<
   typeof docCoveragePluginConfigSchema
 >;

packages/plugin-doc-coverage/src/lib/config.unit.test.ts

@@ -9,7 +9,7 @@ describe('DocCoveragePlugin Configuration', () => {
     it('accepts a valid configuration', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
-          sourceGlob: ['src/**/*.ts'],
+          patterns: ['src/**/*.ts'],
           onlyAudits: ['functions-coverage'],
         } satisfies DocCoveragePluginConfig),
       ).not.toThrow();
@@ -18,6 +18,7 @@ describe('DocCoveragePlugin Configuration', () => {
     it('throws when skipAudits and onlyAudits are defined', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
+          patterns: ['src/**/*.ts'],
           skipAudits: ['functions-coverage'],
           onlyAudits: ['classes-coverage'],
         }),
@@ -27,28 +28,29 @@ describe('DocCoveragePlugin Configuration', () => {
     });
   });
 
-  describe('sourceGlob', () => {
-    it('accepts a valid source glob pattern', () => {
+  describe('patterns', () => {
+    it('accepts a valid patterns array', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
-          sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'],
+          patterns: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'],
         } satisfies DocCoveragePluginConfig),
       ).not.toThrow();
     });
 
-    it('uses default value for missing sourceGlob', () => {
-      const result = docCoveragePluginConfigSchema.parse({});
-      expect(result.sourceGlob).toEqual([
-        'src/**/*.{ts,tsx}',
-        '!**/*.spec.ts',
-        '!**/*.test.ts',
-      ]);
+    it('accepts a valid patterns array directly', () => {
+      expect(() =>
+        docCoveragePluginConfigSchema.parse([
+          'src/**/*.{ts,tsx}',
+          '!**/*.spec.ts',
+          '!**/*.test.ts',
+        ]),
+      ).not.toThrow();
     });
 
-    it('throws for invalid sourceGlob type', () => {
+    it('throws for invalid patterns type', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
-          sourceGlob: 123,
+          patterns: 123,
         }),
       ).toThrow('Expected array');
     });
@@ -59,7 +61,7 @@ describe('DocCoveragePlugin Configuration', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           onlyAudits: ['functions-coverage', 'classes-coverage'],
-          sourceGlob: ['src/**/*.ts'],
+          patterns: ['src/**/*.ts'],
         }),
       ).not.toThrow();
     });
@@ -68,20 +70,23 @@ describe('DocCoveragePlugin Configuration', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           onlyAudits: [],
-          sourceGlob: ['src/**/*.ts'],
+          patterns: ['src/**/*.ts'],
         }),
       ).not.toThrow();
     });
 
     it('allows onlyAudits to be undefined', () => {
-      const result = docCoveragePluginConfigSchema.parse({});
+      const result = docCoveragePluginConfigSchema.parse({
+        patterns: ['src/**/*.ts'],
+      });
       expect(result.onlyAudits).toBeUndefined();
     });
 
     it('throws for invalid onlyAudits type', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           onlyAudits: 'functions-coverage',
+          patterns: ['src/**/*.ts'],
         }),
       ).toThrow('Expected array');
     });
@@ -90,6 +95,7 @@ describe('DocCoveragePlugin Configuration', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           onlyAudits: [123, true],
+          patterns: ['src/**/*.ts'],
         }),
       ).toThrow('Expected string, received number');
     });
@@ -100,7 +106,7 @@ describe('DocCoveragePlugin Configuration', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           skipAudits: ['functions-coverage', 'classes-coverage'],
-          sourceGlob: ['src/**/*.ts'],
+          patterns: ['src/**/*.ts'],
         }),
       ).not.toThrow();
     });
@@ -109,20 +115,23 @@ describe('DocCoveragePlugin Configuration', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           skipAudits: [],
-          sourceGlob: ['src/**/*.ts'],
+          patterns: ['src/**/*.ts'],
         }),
       ).not.toThrow();
     });
 
     it('allows skipAudits to be undefined', () => {
-      const result = docCoveragePluginConfigSchema.parse({});
+      const result = docCoveragePluginConfigSchema.parse({
+        patterns: ['src/**/*.ts'],
+      });
       expect(result.skipAudits).toBeUndefined();
     });
 
     it('throws for invalid skipAudits type', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           skipAudits: 'functions-coverage',
+          patterns: ['src/**/*.ts'],
         }),
       ).toThrow('Expected array');
     });
@@ -131,6 +140,7 @@ describe('DocCoveragePlugin Configuration', () => {
       expect(() =>
         docCoveragePluginConfigSchema.parse({
           skipAudits: [123, true],
+          patterns: ['src/**/*.ts'],
         }),
       ).toThrow('Expected string');
     });

packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts

@@ -29,7 +29,7 @@ export const PLUGIN_DOCS_URL =
  *   plugins: [
  *     // ... other plugins ...
  *     docCoveragePlugin({
- *       sourceGlob: ['src/**/*.{ts,tsx}']
+ *       patterns: ['src/**/*.{ts,tsx}']
  *     })
  *   ]
  * }

packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts

@@ -25,13 +25,13 @@ describe('docCoveragePlugin', () => {
   it('should create a valid plugin config', () => {
     expect(
       docCoveragePlugin({
-        sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'],
+        patterns: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'],
       }),
     ).toStrictEqual(
       expect.objectContaining({
         slug: PLUGIN_SLUG,
         title: PLUGIN_TITLE,
-        icon: 'folder-src',
+        icon: 'folder-docs',
         description: PLUGIN_DESCRIPTION,
         docsUrl: PLUGIN_DOCS_URL,
         groups: expect.any(Array),
@@ -45,27 +45,27 @@ describe('docCoveragePlugin', () => {
     expect(() =>
       docCoveragePlugin({
         // @ts-expect-error testing invalid config
-        sourceGlob: 123,
+        patterns: 123,
       }),
     ).toThrow('Expected array, received number');
   });
 
   it('should filter groups', () => {
-    const config = { sourceGlob: ['src/**/*.ts'] };
+    const config = { patterns: ['src/**/*.ts'] };
     docCoveragePlugin(config);
 
     expect(filterGroupsByOnlyAudits).toHaveBeenCalledWith(groups, config);
   });
 
   it('should filter audits', async () => {
-    const config = { sourceGlob: ['src/**/*.ts'] };
+    const config = { patterns: ['src/**/*.ts'] };
     docCoveragePlugin(config);
 
     expect(filterAuditsByPluginConfig).toHaveBeenCalledWith(config);
   });
 
   it('should forward options to runner function', async () => {
-    const config = { sourceGlob: ['src/**/*.ts'] };
+    const config = { patterns: ['src/**/*.ts'] };
     docCoveragePlugin(config);
 
     expect(createRunnerFunction).toHaveBeenCalledWith(config);