support extending templates with include

Author: teunmooij

src/create-commit.ts

@@ -4,44 +4,7 @@ import fs from 'node:fs';
 import { join } from 'node:path';
 
 import type { Arguments, TreePart } from './types';
-
-const templates: Record<string, string[]> = {
-  'composite-action': ['action.{yml,yaml}', 'LICENSE'],
-  'javascript-action': ['action.{yml,yaml}', 'dist/**', 'LICENSE'],
-};
-
-const extractNames = (input: string) =>
-  input
-    .split('\n')
-    .map(name => {
-      const trimmed = name.trim();
-      if (trimmed.endsWith('/')) return trimmed + '**';
-      return trimmed;
-    })
-    .filter(name => name);
-
-const getIncludePatterns = ({ template, include }: Pick<Arguments, 'include' | 'template'>) => {
-  if (template) {
-    if (!templates[template]) throw new Error(`'${template}' is not a valid template`);
-    return templates[template];
-  }
-
-  const list = extractNames(include);
-
-  if (list.length) return list;
-  return ['**/*'];
-};
-
-const getExcludePatterns = async (exclude: string) => {
-  if (exclude) {
-    return extractNames(exclude);
-  }
-
-  if (!fs.existsSync('.gvrignore')) return [];
-
-  const ignoreFile = await fs.promises.readFile('.gvrignore', 'utf8');
-  return extractNames(ignoreFile);
-};
+import { getExcludePatterns, getIncludePatterns } from './glob-patterns';
 
 export const createCommit = async ({ template, include, exclude, version }: Arguments, octokit: Octokit): Promise<string> => {
   // Determine which files to include

src/glob-patterns.ts

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+
+import type { Arguments } from './types';
+
+const templates: Record<string, string[]> = {
+  'composite-action': ['action.{yml,yaml}', 'LICENSE'],
+  'javascript-action': ['action.{yml,yaml}', 'dist/**', 'LICENSE'],
+};
+
+const extractNames = (input: string) =>
+  input
+    .split('\n')
+    .map(name => {
+      const trimmed = name.trim();
+      if (trimmed.endsWith('/')) return trimmed + '**';
+      return trimmed;
+    })
+    .filter(name => name);
+
+export const getIncludePatterns = ({ template, include }: Pick<Arguments, 'include' | 'template'>) => {
+  const list = [];
+
+  if (template) {
+    if (!templates[template]) throw new Error(`'${template}' is not a valid template`);
+    list.push(...templates[template]);
+  }
+
+  if (include) {
+    list.push(...extractNames(include));
+  }
+
+
+  if (list.length) return list;
+  return ['**/*'];
+};
+
+export const getExcludePatterns = async (exclude: string) => {
+  if (exclude) {
+    return extractNames(exclude);
+  }
+
+  if (!fs.existsSync('.gvrignore')) return [];
+
+  const ignoreFile = await fs.promises.readFile('.gvrignore', 'utf8');
+  return extractNames(ignoreFile);
+};

test/glob-patterns.spec.ts

@@ -0,0 +1,113 @@
+import { getIncludePatterns, getExcludePatterns } from '../src/glob-patterns';
+
+jest.mock('node:fs', () => ({
+  existsSync: jest.fn().mockReturnValue(false),
+}));
+
+describe('glob patterns tests', () => {
+  describe('getIncludePatterns tests', () => {
+    it('returns a default pattern when neither template nor include are specified', () => {
+      const args = { template: '', include: '' };
+
+      const result = getIncludePatterns(args);
+
+      expect(result).toEqual(['**/*']);
+    });
+
+    it('returns a composite-action pattern when template is composite-action', () => {
+      const args = { template: 'composite-action', include: '' };
+
+      const result = getIncludePatterns(args);
+
+      expect(result).toEqual(['action.{yml,yaml}', 'LICENSE']);
+    });
+
+    it('returns a javascript-action pattern when template is javascript-action', () => {
+      const args = { template: 'javascript-action', include: '' };
+
+      const result = getIncludePatterns(args);
+
+      expect(result).toEqual(['action.{yml,yaml}', 'dist/**', 'LICENSE']);
+    });
+
+    it('throws an error when an invalid template is specified', () => {
+      const args = { template: 'invalid-template', include: '' };
+
+      expect(() => getIncludePatterns(args)).toThrowError("'invalid-template' is not a valid template");
+    });
+
+    it('returns a list of patterns when include is specified', () => {
+      const args = {
+        template: '',
+        include: `
+        README.md
+        LICENSE
+        
+        src/**
+        dist/
+
+        !src/*.ts`,
+      };
+
+      const result = getIncludePatterns(args);
+
+      expect(result).toEqual([
+        'README.md',
+        'LICENSE',
+        'src/**',
+        'dist/**',
+        '!src/*.ts',
+      ]);
+    });
+
+    it('extends the template with include patterns when both are specified', () => {
+      const args = {
+        template: 'javascript-action',
+        include: `
+        README.md
+        !src/*.ts`,
+      };
+
+      const result = getIncludePatterns(args);
+
+      expect(result).toEqual([
+        'action.{yml,yaml}',
+        'dist/**',
+        'LICENSE',
+        'README.md',
+        '!src/*.ts',
+      ]);
+    });
+  });
+
+  describe('getExcludePatterns tests', () => {
+    it('returns an empty array when no exclude is specified', async () => {
+      const exclude = '';
+
+      const result = await getExcludePatterns(exclude);
+
+      expect(result).toEqual([]);
+    });
+
+    it('returns a list of patterns when exclude is specified', async () => {
+      const exclude = `
+        README.md
+        LICENSE
+        
+        src/**
+        dist/
+
+        !src/*.ts`;
+
+      const result = await getExcludePatterns(exclude);
+
+      expect(result).toEqual([
+        'README.md',
+        'LICENSE',
+        'src/**',
+        'dist/**',
+        '!src/*.ts',
+      ]);
+    });
+  });
+});