Add tests and bones of paths input

Author: roryabraham

scripts/generateTranslations.ts

@@ -14,6 +14,7 @@ import dedent from '@libs/StringUtils/dedent';
 import hashStr from '@libs/StringUtils/hash';
 import {isTranslationTargetLocale, LOCALES, TRANSLATION_TARGET_LOCALES} from '@src/CONST/LOCALES';
 import type {Locale, TranslationTargetLocale} from '@src/CONST/LOCALES';
+import type {TranslationPaths} from '@src/languages/types';
 import CLI from './utils/CLI';
 import Prettier from './utils/Prettier';
 import PromisePool from './utils/PromisePool';
@@ -87,6 +88,11 @@ class TranslationGenerator {
      */
     private readonly compareRef: string;
 
+    /**
+     * Specific paths to retranslate (supersedes compareRef).
+     */
+    private readonly paths: TranslationPaths[] | undefined;
+
     /**
      * Should we print verbose logs?
      */
@@ -99,13 +105,22 @@ class TranslationGenerator {
      */
     private readonly translatedSpanHashToEnglishSpanHash = new Map<number, number>();
 
-    constructor(config: {targetLanguages: TranslationTargetLocale[]; languagesDir: string; sourceFile: string; translator: Translator; compareRef: string; verbose: boolean}) {
+    constructor(config: {
+        targetLanguages: TranslationTargetLocale[];
+        languagesDir: string;
+        sourceFile: string;
+        translator: Translator;
+        compareRef: string;
+        paths?: TranslationPaths[];
+        verbose: boolean;
+    }) {
         this.targetLanguages = config.targetLanguages;
         this.languagesDir = config.languagesDir;
         const sourceCode = fs.readFileSync(config.sourceFile, 'utf8');
         this.sourceFile = ts.createSourceFile(config.sourceFile, sourceCode, ts.ScriptTarget.Latest, true);
         this.translator = config.translator;
         this.compareRef = config.compareRef;
+        this.paths = config.paths;
         this.verbose = config.verbose;
     }
 
@@ -115,8 +130,11 @@ class TranslationGenerator {
         // map of translations for each locale
         const translations = new Map<TranslationTargetLocale, Map<number, string>>();
 
-        // If a compareRef is provided, fetch the old version of the files, and traverse the ASTs in parallel to extract existing translations
-        if (this.compareRef) {
+        // If paths are specified, we only retranslate those paths and skip comparing with existing translations
+        const shouldUseExistingTranslations = !this.paths && this.compareRef;
+
+        // If a compareRef is provided and we're not filtering by paths, fetch the old version of the files, and traverse the ASTs in parallel to extract existing translations
+        if (shouldUseExistingTranslations) {
             const allLocales: Locale[] = [LOCALES.EN, ...this.targetLanguages];
 
             // An array of labeled "translation nodes", where "translations node" refers to the main object in en.ts and
@@ -192,6 +210,7 @@ class TranslationGenerator {
             const translationsForLocale = translations.get(targetLanguage) ?? new Map<number, string>();
 
             // Extract strings to translate
+            // TODO: filter stringsToTranslate based on paths
             const stringsToTranslate = new Map<number, StringWithContext>();
             this.extractStringsToTranslate(this.sourceFile, stringsToTranslate);
 
@@ -597,6 +616,17 @@ async function main(): Promise<void> {
                     'For incremental translations, this ref is the previous version of the codebase to compare to. Only strings that changed or had their context changed since this ref will be retranslated.',
                 default: '',
             },
+            paths: {
+                description: 'Comma-separated list of specific translation paths to retranslate (e.g., "common.save,errors.generic").',
+                parse: (val: string): TranslationPaths[] => {
+                    const rawPaths = val.split(',').map((translationPath) => translationPath.trim());
+                    const validatedPaths: TranslationPaths[] = [];
+
+                    // TODO: validate paths
+                },
+                supersedes: ['compare-ref'],
+                required: false,
+            },
         },
     } as const);
     /* eslint-enable @typescript-eslint/naming-convention */
@@ -626,6 +656,7 @@ async function main(): Promise<void> {
         sourceFile: enSourceFile,
         translator,
         compareRef: cli.namedArgs['compare-ref'],
+        paths: cli.namedArgs.paths,
         verbose: cli.flags.verbose,
     });
 

tests/unit/generateTranslationsTest.ts

@@ -561,4 +561,187 @@ describe('generateTranslations', () => {
 
         fs.rmSync(oldDir, {recursive: true});
     });
+
+    it('translates only specified paths when --paths is provided', async () => {
+        fs.writeFileSync(
+            EN_PATH,
+            dedent(`
+                const strings = {
+                    greeting: 'Hello',
+                    farewell: 'Goodbye',
+                    common: {
+                        save: 'Save',
+                        cancel: 'Cancel',
+                    },
+                    errors: {
+                        generic: 'An error occurred',
+                        network: 'Network error',
+                    },
+                };
+                export default strings;
+            `),
+            'utf8',
+        );
+
+        // Override process.argv to specify only certain paths
+        process.argv = ['ts-node', 'generateTranslations.ts', '--dry-run', '--verbose', '--locales', 'it', '--paths', 'common.save,errors.generic'];
+
+        const translateSpy = jest.spyOn(Translator.prototype, 'translate');
+
+        await generateTranslations();
+        const itContent = fs.readFileSync(IT_PATH, 'utf8');
+
+        // Only the specified paths should be translated
+        expect(itContent).toContain('[it] Save');
+        expect(itContent).toContain('[it] An error occurred');
+
+        // Other paths should not be translated
+        expect(itContent).not.toContain('[it] Hello');
+        expect(itContent).not.toContain('[it] Goodbye');
+        expect(itContent).not.toContain('[it] Cancel');
+        expect(itContent).not.toContain('[it] Network error');
+
+        expect(translateSpy).toHaveBeenCalledTimes(2);
+        expect(translateSpy).toHaveBeenCalledWith('it', 'Save', undefined);
+        expect(translateSpy).toHaveBeenCalledWith('it', 'An error occurred', undefined);
+    });
+
+    it('translates nested paths when parent path is specified', async () => {
+        fs.writeFileSync(
+            EN_PATH,
+            dedent(`
+                const strings = {
+                    greeting: 'Hello',
+                    common: {
+                        save: 'Save',
+                        cancel: 'Cancel',
+                        nested: {
+                            deep: 'Deep value',
+                        },
+                    },
+                    errors: {
+                        generic: 'An error occurred',
+                    },
+                };
+                export default strings;
+            `),
+            'utf8',
+        );
+
+        // Override process.argv to specify parent path
+        process.argv = ['ts-node', 'generateTranslations.ts', '--dry-run', '--verbose', '--locales', 'it', '--paths', 'common'];
+
+        const translateSpy = jest.spyOn(Translator.prototype, 'translate');
+
+        await generateTranslations();
+        const itContent = fs.readFileSync(IT_PATH, 'utf8');
+
+        // All nested paths under 'common' should be translated
+        expect(itContent).toContain('[it] Save');
+        expect(itContent).toContain('[it] Cancel');
+        expect(itContent).toContain('[it] Deep value');
+
+        // Other paths should not be translated
+        expect(itContent).not.toContain('[it] Hello');
+        expect(itContent).not.toContain('[it] An error occurred');
+
+        expect(translateSpy).toHaveBeenCalledTimes(3);
+        expect(translateSpy).toHaveBeenCalledWith('it', 'Save', undefined);
+        expect(translateSpy).toHaveBeenCalledWith('it', 'Cancel', undefined);
+        expect(translateSpy).toHaveBeenCalledWith('it', 'Deep value', undefined);
+    });
+
+    it('ignores --compare-ref when --paths is provided', async () => {
+        fs.writeFileSync(
+            EN_PATH,
+            dedent(`
+                const strings = {
+                    greeting: 'Hello',
+                    common: {
+                        save: 'Save',
+                    },
+                };
+                export default strings;
+            `),
+            'utf8',
+        );
+
+        // Override process.argv to specify both paths and compare-ref
+        process.argv = ['ts-node', 'generateTranslations.ts', '--dry-run', '--verbose', '--locales', 'it', '--paths', 'common.save', '--compare-ref', 'main'];
+
+        const translateSpy = jest.spyOn(Translator.prototype, 'translate');
+        const githubSpy = jest.spyOn(GitHubUtils, 'getFileContents');
+
+        await generateTranslations();
+        const itContent = fs.readFileSync(IT_PATH, 'utf8');
+
+        // Only the specified path should be translated
+        expect(itContent).toContain('[it] Save');
+        expect(itContent).not.toContain('[it] Hello');
+
+        // GitHubUtils.getFileContents should not be called since --compare-ref is ignored
+        expect(githubSpy).not.toHaveBeenCalled();
+        expect(translateSpy).toHaveBeenCalledTimes(1);
+        expect(translateSpy).toHaveBeenCalledWith('it', 'Save', undefined);
+    });
+
+    it('throws error for invalid paths', async () => {
+        fs.writeFileSync(
+            EN_PATH,
+            dedent(`
+                const strings = {
+                    greeting: 'Hello',
+                    common: {
+                        save: 'Save',
+                    },
+                };
+                export default strings;
+            `),
+            'utf8',
+        );
+
+        // Override process.argv to specify a non-existent path
+        process.argv = ['ts-node', 'generateTranslations.ts', '--dry-run', '--verbose', '--locales', 'it', '--paths', 'nonexistent.path'];
+
+        // Expect the script to throw an error during CLI parsing
+        await expect(generateTranslations()).rejects.toThrow('Translation path not found: nonexistent.path');
+    });
+
+    it('validates paths against actual translation structure', async () => {
+        fs.writeFileSync(
+            EN_PATH,
+            dedent(`
+                const strings = {
+                    greeting: 'Hello',
+                    common: {
+                        save: 'Save',
+                        cancel: 'Cancel',
+                    },
+                    errors: {
+                        generic: 'An error occurred',
+                    },
+                };
+                export default strings;
+            `),
+            'utf8',
+        );
+
+        // Test that valid paths work
+        process.argv = ['ts-node', 'generateTranslations.ts', '--dry-run', '--verbose', '--locales', 'it', '--paths', 'greeting,common.save'];
+
+        const translateSpy = jest.spyOn(Translator.prototype, 'translate');
+
+        await generateTranslations();
+        const itContent = fs.readFileSync(IT_PATH, 'utf8');
+
+        // Should translate the specified paths
+        expect(itContent).toContain('[it] Hello');
+        expect(itContent).toContain('[it] Save');
+
+        // Should not translate other paths
+        expect(itContent).not.toContain('[it] Cancel');
+        expect(itContent).not.toContain('[it] An error occurred');
+
+        expect(translateSpy).toHaveBeenCalledTimes(2);
+    });
 });