loco_tool 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 15401c4e789617502cef976d0ade6c0b5ebf4c03e26dda00f5035bca413014e3
+  data.tar.gz: f646fa2b23742856f6ee4a9a0506ebfa4d883dc3fc193a16317e3bc02013466e
+SHA512:
+  metadata.gz: 1f6249ed214cfa90157f7c8e5454232d6e6965612d6d7770032c9e646884b0486bc983b98b0da2dfd080ce099855be66be83983e7d119cf661cc5ca184a04162
+  data.tar.gz: dc8157a6d7b867f3ceab8f6a3a3f294b2fb148bc559017141e9f68e774ad68b9a7fabbc73ad4d085d0749735f05beaff538daa190bbf058dfb25efb1cf0eb726

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Aleksei Cherepanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# LocoTool
+
+LocoTool is a command-line tool for localization tasks, designed to simplify the management and validation of localization strings in iOS and Android projects.
+
+## Features
+
+- Find duplicate keys between localization files.
+- Sync and move missing strings between files.
+- Validate and verify localization files.
+
+### TODO
+
+- Convert strings between different formats.
+
+## Installation
+
+LocoTool can be installed via RubyGems. Make sure you have Ruby installed on your system, then run the following command:
+
+```
+$ gem install loco_tool
+```
+
+## Usage
+
+LocoTool provides various commands to perform localization tasks. Here are some examples:
+
+### Find Duplicate Keys
+
+```
+$ locotool duplicates [FILE_A] [FILE_B]
+```
+
+This command compares two localization files and identifies duplicate keys between them.
+
+### Sync Localization Files
+
+```
+$ locotool sync [PATH_A] [PATH_B] [BASE_LANG] [TARGET_LANG]
+```
+
+This command synchronizes localization files between two directories (`PATH_A` and `PATH_B`). It compares the base language (`BASE_LANG`) with the target language (`TARGET_LANG`) and moves missing strings from the base file to the target file.
+
+### Sync iOS Localization Files Automatically
+
+```
+$ locotool sync_ios_auto [PATH_A] [PATH_B] [BASE_LANG]
+```
+
+This command automatically finds and syncs iOS localization files in the specified directories (`PATH_A` and `PATH_B`). It iterates over the available target languages, excluding the base language (`BASE_LANG`), and performs the synchronization operation.
+
+## Contributing
+
+Contributions are welcome! If you have any suggestions, bug reports, or feature requests, please open an issue or submit a pull request on the [LocoTool GitHub repository](https://github.com/ftp27/loco_tool).
+
+## License
+
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).

data/bin/locotool

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "thor"
+require "loco_strings"
+require "./lib/logger"
+require "./lib/helper"
+
+# The Locotool class represents a CLI tool for localization tasks.
+#
+# Usage: locotool [command] [options]
+class Locotool < Thor
+  desc "dublicates FILE_A FILE_B", "Find duplicate keys in localization files"
+  def dublicates(file_a, file_b)
+    strings_a = LocoStrings.load(file_a).read
+    strings_b = LocoStrings.load(file_b).read
+
+    strings_a.each do |key, string_a|
+      next unless strings_b.key?(key)
+
+      if string_a.value == strings_b[key].value
+        Logger.string(string_a)
+      else
+        Logger.duplicate(string_a, strings_b[key])
+      end
+    end
+  end
+
+  desc "sync_ios_auto PATH_A PATH_B BASE_LANG", "Find and sync iOS localization files"
+  def sync_ios_auto(path_a, path_b, base_lang)
+    target_langs = Helper.find_lproj(path_a)
+    target_langs.each do |target_lang|
+      next if target_lang == base_lang
+
+      Logger.header("Language #{Paint[target_lang.to_s, :green]}")
+      sync_ios(path_a, path_b, base_lang, target_lang)
+    end
+  end
+
+  desc "sync PATH_A PATH_B BASE_LANG TARGET_LANG", "Sync iOS localization files"
+  def sync_ios(path_a, path_b, base_lang, target_lang)
+    file_a_base = "#{path_a}/#{base_lang}.lproj/Localizable.strings"
+    file_a_target = "#{path_a}/#{target_lang}.lproj/Localizable.strings"
+    file_b_base = "#{path_b}/#{base_lang}.lproj/Localizable.strings"
+    file_b_target = "#{path_b}/#{target_lang}.lproj/Localizable.strings"
+    unless File.exist?(file_b_target)
+      Logger.file_not_found(file_b_target)
+      return
+    end
+    sync(file_a_base, file_a_target, file_b_base, file_b_target)
+  end
+
+  desc "sync FILE_A_BASE FILE_A_TARGET FILE_B_BASE FILE_B_TARGET", "Sync localization files"
+  def sync(file_a_base, file_a_target, file_b_base, file_b_target)
+    strings_a_file = LocoStrings.load(file_a_target)
+    strings_a_target = strings_a_file.read
+    strings_b_file = LocoStrings.load(file_b_target)
+    strings_b_file.read
+
+    lost_keys = Helper.find_missing(file_b_base, file_b_target)
+    keys_b_to_a = Helper.make_keys_dict(file_a_base, file_b_base)
+    Helper.merge(strings_a_target, strings_b_file, keys_b_to_a, lost_keys)
+
+    Logger.lost_keys(lost_keys)
+    strings_b_file.write
+  end
+end
+
+Locotool.start(ARGV)

data/lib/helper.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "./lib/logger"
+
+# The Helper class provides utility methods for various tasks.
+class Helper
+  # Finds lproj localization files in the specified path.
+  #
+  # @param path [String] The path to search for localization files.
+  # @return [Array<String>] An array of language codes found in the path.
+  def self.find_lproj(path)
+    lproj_files = Dir.glob("#{path}/*.lproj").select { |f| File.directory? f }
+    lproj_files.map { |f| File.basename(f, ".lproj") }
+  end
+
+  # Creates a dictionary mapping keys between two localization files.
+  #
+  # @param base_file [String] The base localization file path.
+  # @param target_file [String] The target localization file path.
+  # @return [Hash<String, String>] A hash containing key mappings.
+  def self.make_keys_dict(base_file, target_file)
+    strings_base = LocoStrings.load(base_file).read
+    strings_target = LocoStrings.load(target_file).read
+    keys = {}
+    strings_base.each do |key_base, string_base|
+      strings_target.each do |key_target, string_target|
+        keys[key_base] = key_target if string_base.value == string_target.value
+      end
+    end
+    keys
+  end
+
+  # Finds missing keys in the target localization file compared to the base file.
+  #
+  # @param file_a [String] The base localization file path.
+  # @param file_b [String] The target localization file path.
+  # @return [Array<String>] An array of missing keys in the target file.
+  def self.find_missing(file_a, file_b)
+    strings_a = LocoStrings.load(file_a).read
+    strings_b = LocoStrings.load(file_b).read
+
+    lost_keys = []
+    strings_a.each do |key, _string_a|
+      lost_keys << key unless strings_b.key?(key)
+    end
+    lost_keys
+  end
+
+  # Merges the source strings into the target strings
+  #
+  # @param source [Hash] The source strings hash
+  # @param _target [Hash] The target strings hash (not used in this method)
+  # @param keys [Hash] A dictionary mapping source keys to target keys
+  # @param lost_keys [Array] An array of lost keys to be updated
+  #
+  # @return [void]
+  def self.merge(source, _target, keys, lost_keys)
+    source.each do |key, source_string|
+      target_key = keys[key]
+      next unless target_key
+      next unless lost_keys.include?(target_key)
+
+      strings_b_file.update(target_key, source_string.value)
+      lost_keys.delete(target_key)
+      Logger.string_value(target_key, source_string.value)
+    end
+  end
+end

data/lib/logger.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "paint"
+
+# The Logger class provides utility methods for printing console logs with different formatting.
+class Logger
+  # Prints a string value.
+  #
+  # @param string [LocoString] The LocoString object to print.
+  def self.string(string)
+    puts Formatter.string(string.key, string.value)
+  end
+
+  # Prints a string value.
+  #
+  # @param key [String] The key of the string.
+  # @param value [String] The value of the string.
+  def self.string_value(key, value)
+    puts Formatter.string(key, value)
+  end
+
+  # Prints a string and its duplicate.
+  #
+  # @param string [LocoString] The original string.
+  # @param duplicate [LocoString] The duplicate string.
+  def self.duplicate(string, duplicate)
+    puts "#{Formatter.string(string.key, string.value)} ↔ #{Paint[duplicate.value.to_s, :blue]}"
+  end
+
+  # Prints a header.
+  #
+  # @param text [String] The text to print as the header.
+  def self.header(text)
+    puts "=" * text.length
+    puts text
+    puts "=" * text.length
+  end
+
+  # Prints a file not found error message.
+  #
+  # @param file [String] The file that was not found.
+  def self.file_not_found(file)
+    puts Paint["#{file} not found", :red]
+  end
+
+  # Prints the lost keys.
+  #
+  # @param keys [Array<String>] The lost keys to print.
+  def self.lost_keys(keys)
+    return if keys.empty?
+
+    puts "Lost keys: #{keys.length}"
+    puts keys.map { |key| Paint[key.to_s, :red] }.join(", ")
+  end
+end
+
+# Provides utility methods for formatting strings
+class Formatter
+  # Formats a key-value pair as a string with colored output
+  #
+  # @param key [String] The key to be formatted
+  # @param value [String] The value to be formatted
+  #
+  # @return [String] The formatted key-value pair as a string
+  def self.string(key, value)
+    "#{Paint[key, :green]} #{Paint[value, :blue]}"
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: loco_tool
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aleksei Cherepanov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: loco_strings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.52'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.52'
+description: loco_tool is a command-line tool written in Ruby that helps parse, validate,
+  and manipulate localization strings for iOS and Android projects.
+email:
+- ftp27host@gmail.com
+executables:
+- locotool
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- bin/locotool
+- lib/helper.rb
+- lib/logger.rb
+homepage: https://github.com/ftp27/loco_tool
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.13
+signing_key:
+specification_version: 4
+summary: A CLI tool for parsing and validating localization strings
+test_files: []