723 lines
23 KiB
PHP
723 lines
23 KiB
PHP
<?php
|
|
/**
|
|
* Translation Key Extraction Tool v3.1
|
|
*
|
|
* Comprehensive translation key extraction with multiple sources:
|
|
* 1. Generator API-driven keys (from generator definitions)
|
|
* 2. JavaScript files ($this.t() calls)
|
|
* 3. PHP files (static i18n keys)
|
|
* 4. Backup of existing translation keys
|
|
*
|
|
* Output format: JSON only
|
|
*
|
|
* Usage:
|
|
* php bin/extract-translations.php [options]
|
|
*
|
|
* Options:
|
|
* --output=file Output file path
|
|
* --context Include context information
|
|
* --template Generate template with placeholders
|
|
* --language=en Language for template generation
|
|
* --backup Create backup of existing translations
|
|
* --merge Merge with existing translations
|
|
* --js-path=path Path to JavaScript files (default: public/assets/js)
|
|
* --php-path=path Path to PHP files (default: src)
|
|
*
|
|
* Examples:
|
|
* php bin/extract-translations.php --output=locales/keys.json
|
|
* php bin/extract-translations.php --backup --merge --output=locales/en.json
|
|
* php bin/extract-translations.php --context --output=locales/keys-context.json
|
|
*
|
|
* @author Password Generator Project
|
|
* @version 3.1.0
|
|
*/
|
|
|
|
declare(strict_types=1);
|
|
|
|
require __DIR__ . '/../vendor/autoload.php';
|
|
|
|
use App\Managers\PasswordGeneratorManager;
|
|
|
|
/**
|
|
* Main extraction class
|
|
*/
|
|
class TranslationKeyExtractor
|
|
{
|
|
private PasswordGeneratorManager $generatorManager;
|
|
private array $collectedKeys = [];
|
|
private array $keysWithContext = [];
|
|
private array $existingTranslations = [];
|
|
private array $stats = [
|
|
'generator_keys' => 0,
|
|
'js_keys' => 0,
|
|
'php_keys' => 0,
|
|
'existing_keys' => 0,
|
|
'new_keys' => 0,
|
|
'obsolete_keys' => 0
|
|
];
|
|
|
|
public function __construct(PasswordGeneratorManager $generatorManager)
|
|
{
|
|
$this->generatorManager = $generatorManager;
|
|
}
|
|
|
|
/**
|
|
* Extract all i18n keys from all sources
|
|
*/
|
|
public function extractAll(array $options = []): array
|
|
{
|
|
$jsPath = $options['js_path'] ?? 'public/assets/js';
|
|
$phpPath = $options['php_path'] ?? 'src';
|
|
$existingFile = $options['existing_file'] ?? null;
|
|
|
|
echo "=== Extraction Sources ===\n";
|
|
echo "JavaScript path: {$jsPath}\n";
|
|
echo "PHP path: {$phpPath}\n";
|
|
|
|
if ($existingFile && file_exists($existingFile)) {
|
|
echo "Existing translations: {$existingFile}\n";
|
|
$this->loadExistingTranslations($existingFile);
|
|
}
|
|
|
|
echo "\n";
|
|
|
|
// Extract from generators (API-driven)
|
|
echo "=== Extracting from Password Generators ===\n";
|
|
$this->extractFromGenerators();
|
|
|
|
// Extract from JavaScript files
|
|
echo "\n=== Extracting from JavaScript Files ===\n";
|
|
$this->extractFromJavaScriptFiles($jsPath);
|
|
|
|
// Extract from PHP files
|
|
echo "\n=== Extracting from PHP Files ===\n";
|
|
$this->extractFromPhpFiles($phpPath);
|
|
|
|
// Compare with existing
|
|
if (!empty($this->existingTranslations)) {
|
|
echo "\n=== Comparing with Existing Translations ===\n";
|
|
$this->compareWithExisting();
|
|
}
|
|
|
|
// Sort keys alphabetically
|
|
ksort($this->collectedKeys);
|
|
ksort($this->keysWithContext);
|
|
|
|
return [
|
|
'keys' => $this->collectedKeys,
|
|
'keysWithContext' => $this->keysWithContext,
|
|
'stats' => $this->getStatistics(),
|
|
'existingTranslations' => $this->existingTranslations
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Load existing translations for comparison/merging
|
|
*/
|
|
private function loadExistingTranslations(string $file): void
|
|
{
|
|
try {
|
|
if (!str_ends_with($file, '.json')) {
|
|
throw new Exception('Only JSON format is supported');
|
|
}
|
|
|
|
$content = file_get_contents($file);
|
|
$this->existingTranslations = json_decode($content, true) ?? [];
|
|
|
|
// Remove comment keys
|
|
$this->existingTranslations = array_filter(
|
|
$this->existingTranslations,
|
|
fn($key) => !str_starts_with($key, '_comment'),
|
|
ARRAY_FILTER_USE_KEY
|
|
);
|
|
|
|
$this->stats['existing_keys'] = count($this->existingTranslations);
|
|
echo "✅ Loaded {$this->stats['existing_keys']} existing translations\n";
|
|
|
|
} catch (Exception $e) {
|
|
echo "⚠️ Failed to load existing translations: {$e->getMessage()}\n";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract keys from password generators using API-driven approach
|
|
*/
|
|
private function extractFromGenerators(): void
|
|
{
|
|
$generators = $this->generatorManager->getAvailableTypes();
|
|
|
|
foreach ($generators as $generator) {
|
|
$this->extractFromGenerator($generator);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract keys from a single generator
|
|
*/
|
|
private function extractFromGenerator($generator): void
|
|
{
|
|
$generatorId = $generator->getId();
|
|
echo "📦 {$generatorId}...\n";
|
|
|
|
// Get all keys using the generator's built-in method
|
|
$keys = $generator->getAllI18nKeys();
|
|
|
|
// Add keys with context information
|
|
foreach ($keys as $key) {
|
|
$this->addKey($key, 'generator', $generatorId);
|
|
}
|
|
|
|
$this->stats['generator_keys'] += count($keys);
|
|
echo " → Found " . count($keys) . " keys\n";
|
|
}
|
|
|
|
/**
|
|
* Extract i18n keys from JavaScript files
|
|
* Looks for: this.t('key'), $this.t('key'), app.t('key')
|
|
*/
|
|
private function extractFromJavaScriptFiles(string $basePath): void
|
|
{
|
|
if (!is_dir($basePath)) {
|
|
echo "⚠️ JavaScript path not found: {$basePath}\n";
|
|
return;
|
|
}
|
|
|
|
$files = $this->findFiles($basePath, ['js']);
|
|
echo "Found " . count($files) . " JavaScript files\n";
|
|
|
|
foreach ($files as $file) {
|
|
$this->extractFromJavaScriptFile($file);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract keys from a single JavaScript file
|
|
*/
|
|
private function extractFromJavaScriptFile(string $file): void
|
|
{
|
|
$content = file_get_contents($file);
|
|
$filename = basename($file);
|
|
|
|
// Pattern for this.t('key'), $this.t('key'), this.t("key")
|
|
$patterns = [
|
|
'/(?:this|\\$this)\\.t\\([\'"]([^\'"]+)[\'"]\\)/',
|
|
'/app\\.t\\([\'"]([^\'"]+)[\'"]\\)/',
|
|
'/t\\([\'"]([^\'"]+)[\'"]\\)/', // Simple t() calls
|
|
];
|
|
|
|
$foundKeys = [];
|
|
foreach ($patterns as $pattern) {
|
|
if (preg_match_all($pattern, $content, $matches)) {
|
|
$foundKeys = array_merge($foundKeys, $matches[1]);
|
|
}
|
|
}
|
|
|
|
$foundKeys = array_unique($foundKeys);
|
|
|
|
if (!empty($foundKeys)) {
|
|
echo " 📄 {$filename}: " . count($foundKeys) . " keys\n";
|
|
|
|
foreach ($foundKeys as $key) {
|
|
$this->addKey($key, 'javascript', $filename);
|
|
}
|
|
|
|
$this->stats['js_keys'] += count($foundKeys);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract i18n keys from PHP files
|
|
* Looks for static string keys in specific patterns
|
|
*/
|
|
private function extractFromPhpFiles(string $basePath): void
|
|
{
|
|
if (!is_dir($basePath)) {
|
|
echo "⚠️ PHP path not found: {$basePath}\n";
|
|
return;
|
|
}
|
|
|
|
$files = $this->findFiles($basePath, ['php']);
|
|
echo "Found " . count($files) . " PHP files\n";
|
|
|
|
foreach ($files as $file) {
|
|
$this->extractFromPhpFile($file);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract keys from a single PHP file
|
|
* Looks for static keys in comments or constants
|
|
*/
|
|
private function extractFromPhpFile(string $file): void
|
|
{
|
|
$content = file_get_contents($file);
|
|
$filename = basename($file);
|
|
|
|
// Pattern for static keys in comments like: // i18n: key_name
|
|
$patterns = [
|
|
'/\\/\\/\\s*i18n:\\s*([a-z0-9_]+)/i',
|
|
'/\\/\\*\\*.*?@i18n\\s+([a-z0-9_]+).*?\\*\\//s',
|
|
// Add more patterns as needed
|
|
];
|
|
|
|
$foundKeys = [];
|
|
foreach ($patterns as $pattern) {
|
|
if (preg_match_all($pattern, $content, $matches)) {
|
|
$foundKeys = array_merge($foundKeys, $matches[1]);
|
|
}
|
|
}
|
|
|
|
$foundKeys = array_unique($foundKeys);
|
|
|
|
if (!empty($foundKeys)) {
|
|
echo " 📄 {$filename}: " . count($foundKeys) . " keys\n";
|
|
|
|
foreach ($foundKeys as $key) {
|
|
$this->addKey($key, 'php', $filename);
|
|
}
|
|
|
|
$this->stats['php_keys'] += count($foundKeys);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find files with specific extensions recursively
|
|
*/
|
|
private function findFiles(string $dir, array $extensions): array
|
|
{
|
|
$files = [];
|
|
$iterator = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS)
|
|
);
|
|
|
|
foreach ($iterator as $file) {
|
|
if ($file->isFile()) {
|
|
$ext = strtolower($file->getExtension());
|
|
if (in_array($ext, $extensions)) {
|
|
$files[] = $file->getPathname();
|
|
}
|
|
}
|
|
}
|
|
|
|
return $files;
|
|
}
|
|
|
|
/**
|
|
* Add a key to the collection with context
|
|
*/
|
|
private function addKey(string $key, string $source, string $sourceDetail = ''): void
|
|
{
|
|
// Initialize with existing translation if available
|
|
if (!isset($this->collectedKeys[$key])) {
|
|
$this->collectedKeys[$key] = $this->existingTranslations[$key] ?? '';
|
|
}
|
|
|
|
// Add or update context
|
|
if (!isset($this->keysWithContext[$key])) {
|
|
$this->keysWithContext[$key] = [
|
|
'key' => $key,
|
|
'sources' => [],
|
|
'type' => $this->getKeyType($key),
|
|
'description' => $this->getKeyDescription($key)
|
|
];
|
|
}
|
|
|
|
// Add source information
|
|
$this->keysWithContext[$key]['sources'][] = [
|
|
'type' => $source,
|
|
'detail' => $sourceDetail
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Get key type from key pattern
|
|
*/
|
|
private function getKeyType(string $key): string
|
|
{
|
|
if (str_ends_with($key, '_name')) {
|
|
return 'generator_metadata';
|
|
}
|
|
|
|
if (str_ends_with($key, '_description')) {
|
|
return 'generator_metadata';
|
|
}
|
|
|
|
if (str_contains($key, '_option_') && str_ends_with($key, '_label')) {
|
|
return 'option_label';
|
|
}
|
|
|
|
if (str_contains($key, '_option_') && str_ends_with($key, '_description')) {
|
|
return 'option_description';
|
|
}
|
|
|
|
if (str_contains($key, '_option_') && str_contains($key, '_choice_')) {
|
|
return 'option_choice_label';
|
|
}
|
|
|
|
if (str_ends_with($key, '_validation_error')) {
|
|
return 'validation_error';
|
|
}
|
|
|
|
if (str_contains($key, '_options_group_') && str_ends_with($key, '_title')) {
|
|
return 'group_title';
|
|
}
|
|
|
|
return 'general';
|
|
}
|
|
|
|
/**
|
|
* Get key description
|
|
*/
|
|
private function getKeyDescription(string $key): string
|
|
{
|
|
$type = $this->getKeyType($key);
|
|
|
|
switch ($type) {
|
|
case 'generator_metadata':
|
|
return str_ends_with($key, '_name') ? 'Generator display name' : 'Generator description';
|
|
|
|
case 'option_label':
|
|
preg_match('/_option_(.+)_label$/', $key, $matches);
|
|
return 'Label for option: ' . ($matches[1] ?? 'unknown');
|
|
|
|
case 'option_description':
|
|
preg_match('/_option_(.+)_description$/', $key, $matches);
|
|
return 'Description for option: ' . ($matches[1] ?? 'unknown');
|
|
|
|
case 'option_choice_label':
|
|
preg_match('/_option_(.+)_choice_(.+)$/', $key, $matches);
|
|
return 'Choice label for: ' . ($matches[1] ?? 'unknown') . ' = ' . ($matches[2] ?? 'unknown');
|
|
|
|
case 'validation_error':
|
|
preg_match('/_option_(.+)_validation_error$/', $key, $matches);
|
|
return 'Validation error for: ' . ($matches[1] ?? 'unknown');
|
|
|
|
case 'group_title':
|
|
preg_match('/_options_group_(.+)_title$/', $key, $matches);
|
|
return 'Group title for: ' . ($matches[1] ?? 'unknown');
|
|
|
|
default:
|
|
return 'General UI text';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compare extracted keys with existing translations
|
|
*/
|
|
private function compareWithExisting(): void
|
|
{
|
|
$extractedKeys = array_keys($this->collectedKeys);
|
|
$existingKeys = array_keys($this->existingTranslations);
|
|
|
|
$newKeys = array_diff($extractedKeys, $existingKeys);
|
|
$obsoleteKeys = array_diff($existingKeys, $extractedKeys);
|
|
|
|
$this->stats['new_keys'] = count($newKeys);
|
|
$this->stats['obsolete_keys'] = count($obsoleteKeys);
|
|
|
|
if (!empty($newKeys)) {
|
|
echo "🆕 New keys: " . count($newKeys) . "\n";
|
|
foreach (array_slice($newKeys, 0, 10) as $key) {
|
|
echo " + {$key}\n";
|
|
}
|
|
if (count($newKeys) > 10) {
|
|
echo " ... and " . (count($newKeys) - 10) . " more\n";
|
|
}
|
|
}
|
|
|
|
if (!empty($obsoleteKeys)) {
|
|
echo "\n⚠️ Obsolete keys (not found in code): " . count($obsoleteKeys) . "\n";
|
|
foreach (array_slice($obsoleteKeys, 0, 10) as $key) {
|
|
echo " - {$key}\n";
|
|
}
|
|
if (count($obsoleteKeys) > 10) {
|
|
echo " ... and " . (count($obsoleteKeys) - 10) . " more\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get extraction statistics
|
|
*/
|
|
private function getStatistics(): array
|
|
{
|
|
$byType = [];
|
|
$bySource = [];
|
|
|
|
foreach ($this->keysWithContext as $keyData) {
|
|
$type = $keyData['type'];
|
|
$byType[$type] = ($byType[$type] ?? 0) + 1;
|
|
|
|
foreach ($keyData['sources'] as $source) {
|
|
$sourceType = $source['type'];
|
|
$bySource[$sourceType] = ($bySource[$sourceType] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
return array_merge($this->stats, [
|
|
'total_keys' => count($this->collectedKeys),
|
|
'by_type' => $byType,
|
|
'by_source' => $bySource
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Create backup of existing translations
|
|
*/
|
|
public function createBackup(string $file): bool
|
|
{
|
|
if (!file_exists($file)) {
|
|
return false;
|
|
}
|
|
|
|
$backupFile = $file . '.backup.' . date('Y-m-d_His');
|
|
|
|
if (copy($file, $backupFile)) {
|
|
echo "💾 Created backup: {$backupFile}\n";
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Export keys to JSON format
|
|
*/
|
|
public function exportToJson(): string
|
|
{
|
|
return json_encode($this->collectedKeys, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
|
|
}
|
|
|
|
/**
|
|
* Export keys with context to JSON format
|
|
*/
|
|
public function exportToJsonWithContext(): string
|
|
{
|
|
return json_encode([
|
|
'keys' => $this->collectedKeys,
|
|
'context' => array_values($this->keysWithContext),
|
|
'stats' => $this->getStatistics()
|
|
], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
|
|
}
|
|
|
|
/**
|
|
* Generate template translation file with placeholders
|
|
*/
|
|
public function generateTemplate(string $language = 'en'): string
|
|
{
|
|
$template = [];
|
|
|
|
$lastGenerator = '';
|
|
foreach ($this->keysWithContext as $keyData) {
|
|
$key = $keyData['key'];
|
|
|
|
// Add section comments for generators
|
|
if (str_contains($key, '_') && !str_starts_with($key, '_comment')) {
|
|
$generatorId = explode('_', $key)[0];
|
|
if ($generatorId !== $lastGenerator) {
|
|
$template["_comment_{$generatorId}"] = strtoupper($generatorId) . " Generator";
|
|
$lastGenerator = $generatorId;
|
|
}
|
|
}
|
|
|
|
// Use existing translation or generate placeholder
|
|
$value = $this->existingTranslations[$key] ?? $this->generatePlaceholder($keyData);
|
|
$template[$key] = $value;
|
|
}
|
|
|
|
return json_encode($template, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
|
|
}
|
|
|
|
/**
|
|
* Generate placeholder text for a key
|
|
*/
|
|
private function generatePlaceholder(array $keyData): string
|
|
{
|
|
$type = $keyData['type'];
|
|
$key = $keyData['key'];
|
|
|
|
// Extract meaningful part from key
|
|
if (preg_match('/_option_([^_]+)_/', $key, $matches)) {
|
|
$field = str_replace('_', ' ', $matches[1]);
|
|
$field = ucwords($field);
|
|
} else {
|
|
$field = 'unknown';
|
|
}
|
|
|
|
switch ($type) {
|
|
case 'generator_metadata':
|
|
return str_ends_with($key, '_name')
|
|
? 'Generator Name'
|
|
: 'Generator description text';
|
|
|
|
case 'option_label':
|
|
return $field;
|
|
|
|
case 'option_description':
|
|
return "Description for {$field}";
|
|
|
|
case 'option_choice_label':
|
|
if (preg_match('/_choice_([^_]+)$/', $key, $matches)) {
|
|
return ucfirst(str_replace('_', ' ', $matches[1]));
|
|
}
|
|
return ucfirst($field);
|
|
|
|
case 'validation_error':
|
|
return "Invalid value for {$field}";
|
|
|
|
case 'group_title':
|
|
return $field . " Options";
|
|
|
|
default:
|
|
return '';
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* CLI Interface
|
|
*/
|
|
class CLI
|
|
{
|
|
private array $options = [];
|
|
|
|
public function __construct(array $argv)
|
|
{
|
|
$this->parseArguments($argv);
|
|
}
|
|
|
|
private function parseArguments(array $argv): void
|
|
{
|
|
for ($i = 1; $i < count($argv); $i++) {
|
|
if (str_starts_with($argv[$i], '--')) {
|
|
$parts = explode('=', substr($argv[$i], 2), 2);
|
|
$this->options[$parts[0]] = $parts[1] ?? true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function getOption(string $name, $default = null)
|
|
{
|
|
return $this->options[$name] ?? $default;
|
|
}
|
|
|
|
public function hasOption(string $name): bool
|
|
{
|
|
return isset($this->options[$name]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Main execution
|
|
*/
|
|
try {
|
|
echo "=============================================\n";
|
|
echo "Translation Key Extraction Tool v3.1\n";
|
|
echo "JSON Format Only\n";
|
|
echo "=============================================\n\n";
|
|
|
|
$cli = new CLI($argv);
|
|
|
|
// Get options
|
|
$output = $cli->getOption('output');
|
|
$withContext = $cli->hasOption('context');
|
|
$template = $cli->hasOption('template');
|
|
$language = $cli->getOption('language', 'en');
|
|
$backup = $cli->hasOption('backup');
|
|
$merge = $cli->hasOption('merge');
|
|
$jsPath = $cli->getOption('js-path', 'public/assets/js');
|
|
$phpPath = $cli->getOption('php-path', 'src');
|
|
|
|
// Initialize generator manager
|
|
$generatorManager = new PasswordGeneratorManager();
|
|
|
|
// Extract keys
|
|
$extractor = new TranslationKeyExtractor($generatorManager);
|
|
|
|
$extractOptions = [
|
|
'js_path' => $jsPath,
|
|
'php_path' => $phpPath
|
|
];
|
|
|
|
// Load existing translations if merging or backing up
|
|
if (($merge || $backup) && $output && file_exists($output)) {
|
|
$extractOptions['existing_file'] = $output;
|
|
|
|
// Create backup if requested
|
|
if ($backup) {
|
|
$extractor->createBackup($output);
|
|
}
|
|
}
|
|
|
|
$result = $extractor->extractAll($extractOptions);
|
|
|
|
// Display statistics
|
|
echo "\n=== Extraction Statistics ===\n";
|
|
echo "Total keys: {$result['stats']['total_keys']}\n";
|
|
echo "Generator keys: {$result['stats']['generator_keys']}\n";
|
|
echo "JavaScript keys: {$result['stats']['js_keys']}\n";
|
|
echo "PHP keys: {$result['stats']['php_keys']}\n";
|
|
|
|
if ($result['stats']['existing_keys'] > 0) {
|
|
echo "Existing keys: {$result['stats']['existing_keys']}\n";
|
|
echo "New keys: {$result['stats']['new_keys']}\n";
|
|
echo "Obsolete keys: {$result['stats']['obsolete_keys']}\n";
|
|
}
|
|
|
|
echo "\nBy type:\n";
|
|
foreach ($result['stats']['by_type'] as $type => $count) {
|
|
echo " - {$type}: {$count}\n";
|
|
}
|
|
|
|
echo "\nBy source:\n";
|
|
foreach ($result['stats']['by_source'] as $source => $count) {
|
|
echo " - {$source}: {$count}\n";
|
|
}
|
|
|
|
// Generate output
|
|
$outputContent = '';
|
|
|
|
if ($template) {
|
|
echo "\n=== Generating template file ===\n";
|
|
$outputContent = $extractor->generateTemplate($language);
|
|
} else {
|
|
echo "\n=== Generating JSON output ===\n";
|
|
$outputContent = $withContext
|
|
? $extractor->exportToJsonWithContext()
|
|
: $extractor->exportToJson();
|
|
}
|
|
|
|
// Save or display
|
|
if ($output) {
|
|
file_put_contents($output, $outputContent);
|
|
echo "✅ Saved to: {$output}\n";
|
|
} else {
|
|
echo "\n=== Output ===\n";
|
|
echo $outputContent;
|
|
echo "\n";
|
|
}
|
|
|
|
echo "\n✅ Extraction complete!\n";
|
|
|
|
} catch (Exception $e) {
|
|
echo "ERROR: {$e->getMessage()}\n";
|
|
echo $e->getTraceAsString() . "\n";
|
|
echo "\nUsage:\n";
|
|
echo " php bin/extract-translations.php [options]\n\n";
|
|
echo "Options:\n";
|
|
echo " --output=file Output file path (JSON only)\n";
|
|
echo " --context Include context information\n";
|
|
echo " --template Generate template with placeholders\n";
|
|
echo " --language=en Language for template generation\n";
|
|
echo " --backup Create backup of existing translations\n";
|
|
echo " --merge Merge with existing translations\n";
|
|
echo " --js-path=path Path to JavaScript files (default: public/assets/js)\n";
|
|
echo " --php-path=path Path to PHP files (default: src)\n\n";
|
|
echo "Examples:\n";
|
|
echo " php bin/extract-translations.php --output=locales/keys.json\n";
|
|
echo " php bin/extract-translations.php --backup --merge --output=locales/en.json\n";
|
|
echo " php bin/extract-translations.php --context --output=locales/keys-context.json\n";
|
|
echo " php bin/extract-translations.php --template --output=locales/en-template.json\n";
|
|
|
|
exit(1);
|
|
} |