xcstrings-cli 1.0.0

package/tests/commands.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { add, remove } from '../src/commands/index';
+import { readFile } from 'node:fs/promises';
+import { setupTempFile, cleanupTempFiles } from './utils/testFileHelper';
+
+afterEach(async () => await cleanupTempFiles());
+
+describe('commands', () => {
+    it('add: should add a string to no-strings.xcstrings', async () => {
+        const tempFile = await setupTempFile('no-strings.xcstrings');
+
+        await add(tempFile, 'greeting', 'Hello World', {
+            en: 'Hello',
+            ja: 'こんにちは'
+        });
+
+        const contentString = await readFile(tempFile, 'utf-8');
+        const content = JSON.parse(contentString);
+        expect(content.strings).toHaveProperty('greeting');
+        expect(content.strings.greeting.comment).toBe('Hello World');
+        expect(content.strings.greeting.localizations.en.stringUnit.value).toBe('Hello');
+        expect(content.strings.greeting.localizations.ja.stringUnit.value).toBe('こんにちは');
+        expect(content.strings.greeting.extractionState).toBe('manual');
+    });
+
+    it('remove: should remove a string from manual-comment-3langs.xcstrings', async () => {
+        const tempFile = await setupTempFile('manual-comment-3langs.xcstrings');
+
+        let content = JSON.parse(await readFile(tempFile, 'utf-8'));
+        expect(content.strings).toHaveProperty('closeAction');
+
+        await remove(tempFile, 'closeAction');
+
+        content = JSON.parse(await readFile(tempFile, 'utf-8'));
+        expect(content.strings).not.toHaveProperty('closeAction');
+        expect(content).toHaveProperty('sourceLanguage', 'en');
+    });
+});

package/tests/config.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { loadConfig } from '../src/utils/config';
+import { resolve } from 'path';
+import fs from 'fs/promises';
+
+describe('loadConfig', () => {
+    const cwd = process.cwd();
+    const configJsonPath = resolve(cwd, 'xcstrings-cli.json');
+    const configJson5Path = resolve(cwd, 'xcstrings-cli.json5');
+
+    beforeEach(async () => {
+        try { await fs.unlink(configJsonPath); } catch { }
+        try { await fs.unlink(configJson5Path); } catch { }
+    });
+
+    afterEach(async () => {
+        try { await fs.unlink(configJsonPath); } catch { }
+        try { await fs.unlink(configJson5Path); } catch { }
+    });
+
+    it('should load config from xcstrings-cli.json', async () => {
+        const config = { xcstringsPaths: ['path/to/Localizable.xcstrings'] };
+        await fs.writeFile(configJsonPath, JSON.stringify(config));
+
+        const result = await loadConfig();
+        expect(result).toEqual(config);
+    });
+
+    it('should load config from xcstrings-cli.json5', async () => {
+        const configContent = "{ xcstringsPaths: ['path/to/Localizable.xcstrings'] }";
+        await fs.writeFile(configJson5Path, configContent);
+
+        const result = await loadConfig();
+        expect(result).toEqual({ xcstringsPaths: ['path/to/Localizable.xcstrings'] });
+    });
+
+    it('should prefer explicit path', async () => {
+        const explicitPath = resolve(cwd, 'custom-config.json');
+        const config = { xcstringsPaths: ['custom/path'] };
+        await fs.writeFile(explicitPath, JSON.stringify(config));
+
+        try {
+            const result = await loadConfig(explicitPath);
+            expect(result).toEqual(config);
+        } finally {
+            await fs.unlink(explicitPath);
+        }
+    });
+
+    it('should return null if no config found', async () => {
+        const result = await loadConfig();
+        expect(result).toBeNull();
+    });
+});

package/tests/fixtures/manual-comment-3langs.xcstrings

@@ -0,0 +1,32 @@
+{
+  "sourceLanguage" : "en",
+  "strings" : {
+    "nonTranslatableString" : {
+      "shouldTranslate" : false
+    },
+    "closeAction" : {
+      "comment" : "Button title of closing a dialog, etc.",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Close"
+          }
+        },
+        "ja" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "閉じる"
+          }
+        },
+        "zh-Hans" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "关闭"
+          }
+        }
+      }
+    }
+  }
+}

package/tests/fixtures/no-strings.xcstrings

@@ -0,0 +1,5 @@
+{
+  "sourceLanguage" : "en",
+  "strings" : {
+  }
+}

package/tests/fixtures/test.xcodeproj/project.pbxproj

@@ -0,0 +1,86 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 56;
+	objects = {
+
+/* Begin PBXGroup section */
+		13B07FAE1A68108700A75B9A = {
+			isa = PBXGroup;
+			children = (
+			);
+			name = TestApp;
+			sourceTree = "<group>";
+		};
+		83CBB9F61A601CBA00E9B192 = {
+			isa = PBXGroup;
+			children = (
+				13B07FAE1A68108700A75B9A /* TestApp */,
+			);
+			indentWidth = 2;
+			sourceTree = "<group>";
+			tabWidth = 2;
+			usesTabs = 0;
+		};
+/* End PBXGroup section */
+
+/* Begin PBXProject section */
+		83CBB9F71A601CBA00E9B192 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastSwiftUpdateCheck = 1340;
+				LastUpgradeCheck = 1130;
+				TargetAttributes = {
+				};
+			};
+			buildConfigurationList = 83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "TestApp" */;
+			compatibilityVersion = "Xcode 12.0";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+				ja,
+				de,
+			);
+			mainGroup = 83CBB9F61A601CBA00E9B192;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+			);
+		};
+/* End PBXProject section */
+
+/* Begin XCBuildConfiguration section */
+		83CBBA201A601CBA00E9B192 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+			};
+			name = Debug;
+		};
+		83CBBA211A601CBA00E9B192 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "TestApp" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				83CBBA201A601CBA00E9B192 /* Debug */,
+				83CBBA211A601CBA00E9B192 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 83CBB9F71A601CBA00E9B192 /* Project object */;
+}

package/tests/formatting.test.ts

@@ -0,0 +1,72 @@
+
+import { describe, it, expect } from 'vitest';
+import { formatXCStrings } from '../src/commands/index';
+
+describe('formatXCStrings', () => {
+    it('should add space before colon in simple objects', () => {
+        const input = JSON.stringify({ key: "value" }, null, 2);
+        const expected = input.replace('":', '" :');
+        expect(formatXCStrings(input)).toBe(expected);
+        expect(formatXCStrings(input)).toContain('"key" : "value"');
+    });
+
+    it('should handle nested objects', () => {
+        const obj = {
+            nested: {
+                child: "grandchild"
+            }
+        };
+        const input = JSON.stringify(obj, null, 2);
+        const output = formatXCStrings(input);
+        expect(output).toContain('"nested" : {');
+        expect(output).toContain('"child" : "grandchild"');
+    });
+
+    it('should not affect colons inside string values', () => {
+        const obj = {
+            "key:with:colons": "value:with:colons"
+        };
+        const input = JSON.stringify(obj, null, 2);
+        const output = formatXCStrings(input);
+        expect(output).toContain('"key:with:colons" : "value:with:colons"');
+    });
+
+    it('should handle escaped quotes inside strings', () => {
+        const obj = {
+            tricky: 'value has ": sequence inside'
+        };
+        const input = JSON.stringify(obj, null, 2);
+        const output = formatXCStrings(input);
+        expect(output).toContain('"tricky" : "value has \\": sequence inside"');
+    });
+
+    it('should handle backslashes correctly', () => {
+        const obj = {
+            path: 'C:\\Windows\\System32'
+        };
+        const input = JSON.stringify(obj, null, 2);
+        const output = formatXCStrings(input);
+        expect(output).toContain('"path" : "C:\\\\Windows\\\\System32"');
+    });
+
+    it('should maintain data integrity when parsed back', () => {
+        const obj = {
+            "normalKey": "normalValue",
+            "key with spaces": "value with spaces",
+            "key:with:colons": "value:with:colons",
+            "key\"with\"quotes": "value\"with\"quotes",
+            "key\\with\\backslashes": "value\\with\\backslashes",
+            "nested": {
+                "child": "grandchild"
+            },
+            "empty": {},
+            "tricky": "value has \": sequence inside",
+            "tricky2": "value ending in quote\"",
+            "tricky3": "value ending in backslash\\"
+        };
+        const input = JSON.stringify(obj, null, 2);
+        const output = formatXCStrings(input);
+        const parsed = JSON.parse(output);
+        expect(parsed).toEqual(obj);
+    });
+});

package/tests/languages.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { getLanguagesFromXcodeproj, getLanguagesFromXCStrings } from '../src/commands/languages';
+import { resolve } from 'node:path';
+import { FIXTURES_DIR } from './utils/resources';
+
+describe('languages', () => {
+    it('should extract knownRegions from xcodeproj', () => {
+        const xcodeprojPath = resolve(FIXTURES_DIR, 'test.xcodeproj');
+        const languages = getLanguagesFromXcodeproj(xcodeprojPath);
+
+        expect(languages).toEqual(['en', 'Base', 'ja', 'de']);
+    });
+
+    it('should extract languages from xcstrings file', async () => {
+        const xcstringsPath = resolve(FIXTURES_DIR, 'manual-comment-3langs.xcstrings');
+        const languages = await getLanguagesFromXCStrings(xcstringsPath);
+        expect(languages).toContain('ja');
+        expect(languages).toContain('en');
+        expect(languages).toContain('zh-Hans');
+    });
+});

package/tests/utils/resources.ts

@@ -0,0 +1,4 @@
+import { resolve } from "path";
+
+export const FIXTURES_DIR = resolve(__dirname, '..', 'fixtures');
+export const TEMP_DIR = resolve(__dirname, '..', 'temp');

package/tests/utils/testFileHelper.ts

@@ -0,0 +1,30 @@
+import { resolve, basename, extname } from 'node:path';
+import { copyFile, mkdir, unlink } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { FIXTURES_DIR, TEMP_DIR } from './resources';
+
+export const createdFiles: string[] = [];
+
+export async function setupTempFile(fileName: string): Promise<string> {
+    if (!existsSync(TEMP_DIR)) {
+        await mkdir(TEMP_DIR);
+    }
+    const source = resolve(FIXTURES_DIR, fileName);
+    const base = basename(fileName, extname(fileName));
+    const unique = `${base}-${Date.now()}-${Math.random().toString(36).slice(2)}${extname(fileName)}`;
+    const dest = resolve(TEMP_DIR, unique);
+    await copyFile(source, dest);
+    createdFiles.push(dest);
+    return dest;
+}
+
+export async function cleanupTempFiles(): Promise<void> {
+    for (const f of createdFiles) {
+        try {
+            await unlink(f);
+        } catch {
+            // ignore: best effort cleanup
+        }
+    }
+    createdFiles.length = 0;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "outDir": "./dist",
+        "declaration": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
+}

package/vite.config.ts

@@ -0,0 +1,32 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+
+export default defineConfig({
+    build: {
+        lib: {
+            entry: resolve(__dirname, 'src/index.ts'),
+            fileName: 'index',
+            formats: ['es'],
+        },
+        rollupOptions: {
+            external: [
+                /^node:.*/,
+                'fs',
+                'path',
+                'os',
+                'crypto',
+                'assert',
+                'util',
+                'yargs',
+                'yargs/helpers',
+                'cosmiconfig',
+                'json5',
+                '@inquirer/prompts',
+                '@bacons/xcode',
+                'chalk',
+            ],
+        },
+        target: 'node18',
+        emptyOutDir: true,
+    },
+});