i18n_uno 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a96558cb92d39d42fcaafb70c1ff3b9ca633cc2d4fb4849bb7bf7243ea09954e
+  data.tar.gz: eab75bee802e842847a77288aaec1dfc7bb1ee9785bdf290687c973249d6dd40
+SHA512:
+  metadata.gz: ac9a40dbfad9a8b5ef8e29a3fb69f78c9d0fd5311691a240c0a9227f93606ac536e65afce3bead3820c39f3d9778eb0663ebb5acdb66df302605fd7f35e9c4a7
+  data.tar.gz: 0ef6c4fcbd31728906dfe936dbb55af29a8165e09a5e1096be623b8cc302b2c4a90701dcacd53b5170ad1ae874af8555d2066a2cfade60a631dda9c7e05c5216

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in i18n_uno.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    i18n_uno (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.1)
+    rake (10.5.0)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  i18n_uno!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.17.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 pythagora-north
+
+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,90 @@
+# i18nUno
+
+i18nUno is a gem that helps you translate your Rails application into any language you choose. It utilizes the OpenAI API for translations and supports all languages. It's easy to use, and by implementing Git hooks, you can set it up to automatically add new translations or delete old ones as a pre-commit hook.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :development do
+  ...
+  gem 'i18n_uno'
+end
+```
+
+And then execute:
+
+    $ bundle install
+
+## Prerequisites
+
+To use the gem, adhere to the standard procedures outlined in the [Rails I18n support guide](https://guides.rubyonrails.org/i18n.html). While you may organize your folders as you wish, all localization files must be named following the `$locale.yml` format, such as `en.yml` for English. The i18n Uno gem will leverage these files to generate new ones for additional languages you wish to include, for instance, `es.yml` for Spanish, `de.yml` for German etc.
+
+## Configuration
+
+To utilize the gem, create a file `config/initializers/i18n_uno.rb` and configure the gem with your OpenAI credentials. Additional settings are available for customization.
+
+```ruby
+I18nUno.configure do |config|
+  config.open_ai_key = ENV['OPEN_AI_API_KEY']         # Required: Found at https://platform.openai.com/account/api-keys
+  config.default_locale                               # Required: You can set it to I18n.config.default_locale
+  config.available_locales                            # Required: I18n.config.default_locale and locales you want to translate to
+  config.open_ai_model                                # Optional: Defaults to 'gpt-4-0613'
+  config.load_path                                    # Optional: Defaults to 'config/locales'
+end
+```
+
+Although changing the model is supported, it is strongly recommended to stick with gpt-4 models due to the significant quality difference compared to gpt-3 models.
+
+## Usage
+
+Before running the gem, ensure you've added the desired languages to `config.available_locales` or in the `config/application.rb` file.
+
+```ruby
+config.i18n.available_locales = [:en, :bs, :de]
+```
+
+With these settings, translations will be executed to add all necessary files to support these languages. From this point, simply run:
+
+```bash
+rake i18n_uno:translate
+```
+
+from your application folder. i18n Uno will then add new translation files, and you'll be ready to go. If new keys are added during development, running the above command again will automatically add and translate these new keys. Key removal is also supported and will be propagated to all language files.
+
+## Continuous Management of Internationalization
+
+Your default locale serves as the foundational reference for your application's internationalization. Whenever modifications are made to the localization files, executing the previously mentioned gem command will automatically update translations across all other supported languages, adding or removing them as necessary.
+
+To ensure seamless integration of this process, it's advisable to configure a pre-commit hook that triggers the above command. This step helps maintain consistency by preventing the introduction of new keys without their corresponding translations.
+
+It's important to note that the gem is designed to respect the integrity of your source of truth files (the default locale) and, as such, will not alter these files directly. Additionally, it does not track changes to existing keys, focusing instead on the addition or removal of translations based on the current state of your default locale files.
+
+## Setting up application for internationalization
+
+If you are not already supporting internationalization in your rails application you can do that simply by adding `locale` field to your `user` model.
+
+```ruby
+  class AddLocaleToUsers < ActiveRecord::Migration
+    def change
+      add_column :users, :locale, :string, default: 'en'
+    end
+  end
+```
+
+From there adding you simply need to add before action to `app/controllers/authenticated_controller.rb`. This would very based on your application but this would be the standard way.
+
+```ruby
+  before_action :set_locale!
+
+  def set_locale!
+    I18n.locale = current_user.locale
+  end
+```
+
+That would be it, magic of rails will take care of the rest.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/i18n_uno.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/i18n_uno.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'i18n_uno/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'i18n_uno'
+  spec.version       = I18nUno::VERSION
+  spec.authors       = ['Haris Krajina', 'hkraji']
+  spec.email         = ['haris@pythagoranorth.com']
+
+  spec.summary       = 'i18n Uno levrages power of ChatGPT API to translate your i18n files.'
+  spec.description   = 'i18n Uno is simple CLI tool that will completly translate your application to any desired language.'
+  spec.homepage      = 'https://github.com/pythagora-north/i18n_uno'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/pythagora-north/i18n_uno'
+  spec.metadata['changelog_uri'] = 'https://github.com/pythagora-north/i18n_uno/blob/main/Changes.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/i18n_uno/arbiter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module I18nUno
+  class Arbiter
+    attr_reader :translators, :trees, :source_of_truth_tree, :target_locales
+
+    def initialize
+      @translators = []
+      @trees  = {}
+
+      setup_configurations
+    end
+
+    def translate
+      print_translations_info
+
+      target_locales.each do |target_locale|
+        collect_locale_changes(target_locale)
+        process_changes(target_locale)
+      end
+    end
+
+    private
+
+    def setup_configurations
+      check_locale_availability
+      setup_signal_handling
+      setup_target_locales
+      setup_translation_trees
+    end
+
+    def check_locale_availability
+      if I18nUno.config.available_locales.nil?
+        raise I18nUno::ConfigurationError, 'No available locales specified. Please set the available locales in the configuration file.'
+      end
+    end
+
+    def setup_target_locales
+      @target_locales = I18nUno.config.available_locales - [I18nUno.config.default_locale]
+    end
+
+    def setup_translation_trees
+      @target_locales.each { |locale| @trees[locale] = I18nUno::Tree.new(locale) }
+      @source_of_truth_tree = I18nUno::Tree.new(I18nUno.config.default_locale)
+    end
+
+    def collect_locale_changes(target_locale)
+      puts "\nChecking for translation changes for locale '#{target_locale}'\n"
+
+      source_of_truth_tree.each do |sot_file|
+        target_file = @trees[target_locale].find_or_create_file(sot_file)
+
+        comparer = I18nUno::Comparer.new(sot_file, target_file)
+        diff_delta = comparer.compare
+        @trees[target_locale].add_delta!(target_file, diff_delta)
+      end
+    end
+
+    def process_changes(target_locale)
+      @trees[target_locale].process_delta_changes(source_of_truth_tree)
+    end
+
+    def setup_signal_handling
+      Signal.trap('SIGINT') do
+        puts "\nExiting I18n Uno ..."
+        target_locales.each do |target_locale|
+          @trees[target_locale].clean_not_processed_files
+        end
+        exit
+      end
+    end
+
+    def print_translations_info
+      if source_of_truth_tree.empty?
+        puts "No translation files found in the specified path (#{I18nUno.config.load_path}}/**/#{I18nUno.config.default_locale}.yml). Please check the path and try again."
+        exit(0)
+      else
+        puts "Listing translation files for the default locale '#{I18nUno.config.default_locale}':\n\n"
+        source_of_truth_tree.files.each_slice(2) do |file_pair|
+          file_pair.map! { |file| file.file_path.gsub(%r{#{I18nUno.config.load_path}/?}, '') }
+          print_string = file_pair.size.even? ? "- %-40s - %-40s\n" : "- %-40s\n"
+          printf(print_string, *file_pair)
+        end
+      end
+    end
+  end
+end

data/lib/i18n_uno/comparer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module I18nUno
+  class Error < StandardError; end
+
+  class Comparer
+    attr_accessor :source_file, :target_file
+
+    def initialize(source_file, target_file)
+      @source_file = source_file
+      @target_file = target_file
+    end
+
+    def compare
+      source_keys = flatten_keys(normalize_data(source_file.content_hash))
+      target_keys = flatten_keys(normalize_data(target_file.content_hash))
+
+      new_keys     = compare_keys(target_keys, source_keys)
+      removed_keys = compare_keys(source_keys, target_keys)
+
+      I18nUno::Delta.new(
+        new_keys: new_keys,
+        removed_keys: removed_keys,
+        target_keys_size: target_keys.size
+      )
+    end
+
+    private
+
+    def compare_keys(source_keys, target_keys)
+      target_keys - source_keys
+    end
+
+    # Flattens the nested hash of translation keys into a flat array of dot-prefixed keys.
+    # @param data [Hash] the translation file content
+    # @param prefix [String] the current prefix to prepend to keys (used in recursion)
+    # @return [Array] an array of flattened key strings
+    def flatten_keys(data, prefix = '')
+      data.each_with_object([]) do |(key, value), keys|
+        full_key = "#{prefix}#{key}"
+        if value.is_a?(Hash)
+          keys.concat(flatten_keys(value, "#{full_key}."))
+        else
+          keys << full_key unless value.nil?
+        end
+      end
+    end
+
+
+    # Removes the first key for the data, since that is locale for that file content
+    # @param data [Hash] the translation file content
+    # @return [Hash] the translation file content without the locale key
+    def normalize_data(data)
+      if data.keys.first.length == 2 && data.keys.length == 1
+        data[data.keys.first]
+      else
+        data
+      end
+    end
+  end
+end

data/lib/i18n_uno/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module I18nUno
+  class Configuration
+    attr_accessor :load_path, :open_ai_model, :open_ai_key, :default_locale, :available_locales
+
+    def initialize
+      raise ConfigurationError, 'Rails must be present to use I18nUno' unless defined?(Rails)
+
+      @load_path = ::File.join(Rails.root, 'config', 'locales')
+      @open_ai_model = 'gpt-4-0613'
+      @open_ai_key = nil
+      @default_locale = nil
+      @available_locales = nil
+    end
+
+    def validate!
+      raise ConfigurationError, 'open_ai_key must be set for API operations' unless open_ai_key
+      raise ConfigurationError, 'available_locales must be set' unless available_locales
+      raise ConfigurationError, 'default_locale must be included in available_locales' if available_locales && !available_locales.include?(default_locale)
+    end
+  end
+
+  class ConfigurationError < StandardError; end
+end

data/lib/i18n_uno/delta.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module I18nUno
+  class Delta
+    attr_accessor :new_keys, :removed_keys, :values, :translated_values, :target_file
+
+    # @param new_keys [Array<String>] keys that are newly added.
+    # @param removed_keys [Array<String>] keys that have been removed.
+    # @param target_keys_size [Integer] the total number of keys in the target file.
+    def initialize(new_keys: [], removed_keys: [], target_keys_size: 0)
+      @new_keys = new_keys
+      @removed_keys = removed_keys
+      @values = []
+      @translated_values = []
+      @complete_file_diff = calculate_complete_file_diff(new_keys, target_keys_size)
+    end
+
+    # Calculates if the delta represents a complete difference of a file.
+    # @return [Boolean] true if the new keys are equal to the total number of keys in the target.
+    def calculate_complete_file_diff(new_keys, target_keys_size)
+      new_keys.any? && new_keys.size == target_keys_size
+    end
+
+    # Determines if the entire file has been changed based on the delta.
+    # @return [Boolean] true if all keys in the file are considered new.
+    def complete_file_diff?
+      @complete_file_diff
+    end
+
+    # Checks if there are any changes (new or removed keys).
+    # @return [Boolean] true if there are any new or removed keys.
+    def any_changes?
+      any_new_keys? || any_removed_keys?
+    end
+
+    # Checks if there are any new keys in the delta.
+    # @return [Boolean] true if there are new keys present.
+    def any_new_keys?
+      new_keys.any?
+    end
+
+    # Checks if there are any removed keys in the delta.
+    # @return [Boolean] true if there are keys that have been removed.
+    def any_removed_keys?
+      removed_keys.any?
+    end
+
+    # Determines if there are any values ready to be translated.
+    # This checks for the presence of non-nil entries in the values list.
+    # @return [Boolean] true if there are non-nil values to translate.
+    def anything_to_translate?
+      values.compact.any?
+    end
+
+    # Populates the values list from a specified file based on the new keys.
+    # This is intended to gather the actual values to be translated.
+    # @param file [Object] typically an instance of a File class, used to extract values.
+    def values_from!(file)
+      @values = file.values_from_keys(new_keys)
+    end
+  end
+end

data/lib/i18n_uno/file.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'i18n_uno/files/content_change'
+
+module I18nUno
+  class File
+    include I18nUno::Files::ContentChange
+
+    attr_accessor :content_hash
+    attr_reader   :file_path, :locale
+
+    def initialize(file_path)
+      @file_path = file_path
+
+      @locale = ::File.basename(file_path, '.yml')
+      @content_hash = YAML.load_file(file_path)
+    end
+
+    def pp_file_name
+      file_path.gsub(%r{#{I18nUno.config.load_path}/?}, '')
+    end
+
+    def file_identifier
+      file_path.gsub(%r{/#{locale}\.yml$}, '')
+    end
+
+    def create_in_locale(locale, save_file = false)
+      new_path = path_in_locale(locale)
+      FileUtils.cp(file_path, path_in_locale(locale))
+
+      file = I18nUno::File.new(new_path)
+      file.setup_new_file(save_file)
+      file
+    end
+
+    def path_in_locale(locale)
+      new_path = file_path.gsub(%r{/#{self.locale}\.yml$}, "/#{locale}.yml")
+    end
+  end
+end

data/lib/i18n_uno/files/content_change.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module I18nUno
+  module Files
+    module ContentChange
+      # Reorders keys in the file to match the order of the source file.
+      # @param sot_file [I18nUno::File] The source of truth file with the desired key order.
+      def match_order_as_file!(sot_file)
+        ordered_hash = {}
+        ordered_hash[locale] = merge_preserving_key_order(
+          sot_file.content_hash.values.first,
+          content_hash.values.first
+        )
+
+        @content_hash = ordered_hash
+      end
+
+      # Adds missing keys to the target file and initializes them to nil.
+      # @param delta [I18nUno::Delta] Contains the new keys to be added.
+      def add_missing_keys_to_target_file!(delta)
+        delta.new_keys.each do |key_path|
+          keys = key_path.split('.').unshift(locale)
+          deep_set_to_nil!(content_hash, keys)
+        end
+      end
+
+      # Retrieves values from the file using dot-separated keys.
+      # @param dot_keys [Array<String>] Array of keys to retrieve values for.
+      # @return [Array] The values corresponding to the dot_keys.
+      def values_from_keys(dot_keys)
+        dot_keys.collect do |dot_keys|
+          keys = dot_keys.split('.').unshift(locale)
+          value = content_hash
+
+          loop do
+            value = value[keys.shift]
+            break if keys.empty?
+          end
+
+          value
+        end
+      end
+
+      # Updates the file with values from translated deltas.
+      # @param delta [I18nUno::Delta] Contains the keys and their translated values.
+      def set_values_from_delta!(delta)
+        delta.new_keys.each_with_index do |key_path, index|
+          keys = key_path.split('.').unshift(locale)
+          value = content_hash
+
+          loop do
+            current_key = keys.shift
+
+            if keys.empty?
+              value[current_key] = delta.translated_values[index]
+              break
+            else
+              value = value[current_key]
+            end
+          end
+        end
+      end
+
+      # Removes specified keys from the file.
+      # @param delta [I18nUno::Delta] Contains the keys to be removed.
+      def remove_keys_from_file!(delta)
+        delta.removed_keys.each do |key_path|
+          keys = key_path.split('.').unshift(locale)
+          deep_key_remove!(content_hash, keys)
+        end
+        save!
+      end
+
+      # Saves the file to HDD
+      def save!
+        ::File.open(file_path, 'w') do |file|
+          yaml_content = content_hash.to_yaml(options: { line_width: -1 })
+          yaml_content.sub!(/\A---\s*\n/, '')
+          file.write(yaml_content)
+        end
+      end
+
+      # Prepares a new file with all primitive values set to nil.
+      # @param save_file [Boolean] Determines if the file should be saved immediately after setup.
+      def setup_new_file(save_file)
+        original_locale = @content_hash.keys.first
+        @content_hash[locale] = @content_hash.delete(original_locale)
+        set_primitives_to_nil!(@content_hash)
+        save! if save_file
+      end
+
+      private
+
+      # Recursively sets all primitive values in a hash to nil.
+      # @param hash [Hash] The hash to modify.
+      def set_primitives_to_nil!(hash)
+        hash.each do |key, value|
+          if value.is_a?(Hash)
+            set_primitives_to_nil!(value)
+          else
+            hash[key] = nil
+          end
+        end
+      end
+
+      # Merges two hashes preserving the order of keys from the source hash.
+      # @param source_hash [Hash] The source hash defining the order of keys.
+      # @param target_hash [Hash] The target hash to merge.
+      # @return [Hash] The merged hash with preserved key order.
+      def merge_preserving_key_order(source_hash, target_hash)
+        merged_hash = {}
+
+        source_hash.each_key do |key|
+          merged_hash[key] = if source_hash[key].is_a?(Hash) && target_hash[key].is_a?(Hash)
+                               merge_preserving_key_order(source_hash[key], target_hash[key])
+                             else
+                               target_hash[key]
+                             end
+        end
+
+        merged_hash
+      end
+
+      # Recursively removes a key from a nested hash.
+      # @param obj [Hash] The hash from which to remove the key.
+      # @param keys [Array<String>] The path of keys leading to the key to remove.
+      def deep_key_remove!(obj, keys)
+        first_key = keys.shift
+
+        if keys.empty?
+          obj.delete(first_key)
+        else
+          deep_key_remove!(obj[first_key], keys)
+        end
+      end
+
+      # Sets all leaf nodes of a nested hash to nil.
+      # @param obj [Hash] The hash to modify.
+      # @param keys [Array<String>] The path of keys.
+      def deep_set_to_nil!(obj, keys)
+        last_key = keys.pop
+        last_hash = keys.inject(obj) do |o, k|
+          o[k] ||= {}
+        end
+        last_hash[last_key] = nil
+      end
+    end
+  end
+end

data/lib/i18n_uno/open_ai_client.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module I18nUno
+  class OpenAIClient
+    def initialize
+      @connection = Faraday.new(
+        url: 'https://api.openai.com',
+        headers: { 'Authorization' => "Bearer #{I18nUno.config.open_ai_key}",
+                   'Content-Type' => 'application/json; charset=utf-8' }
+      ) do |faraday|
+        faraday.adapter Faraday.default_adapter
+        faraday.options[:timeout] = 600
+        faraday.options[:open_timeout] = 30
+      end
+    end
+
+    def complete(messages:)
+      response = @connection.post('/v1/chat/completions') do |request|
+        request.body = {
+          model: I18nUno.config.open_ai_model,
+          messages: messages.map { |message| { role: :user, content: message } },
+          max_tokens: 4096
+        }.to_json
+      end
+
+      JSON.parse(response.body)['choices'].first['message']['content']
+    rescue StandardError => e
+      Rails.logger.error(e)
+      raise
+    end
+  end
+end

data/lib/i18n_uno/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Geocoder
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load 'tasks/i18n_uno.rake'
+      end
+    end
+  end
+end

data/lib/i18n_uno/translator.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'i18n_uno/open_ai_client'
+
+module I18nUno
+  class Translator
+    attr_reader :source_file, :target_file
+
+    def initialize(sot_file, target_file)
+      @source_file  = sot_file
+      @target_file  = target_file
+      @target_file_yaml = YAML.load_file(target_file.file_path)
+    end
+
+    def process(delta)
+      delta.values_from!(@source_file)
+
+      if delta.anything_to_translate?
+        delta = send_to_chatgpt_api(delta)
+
+        target_file.add_missing_keys_to_target_file!(delta)
+        target_file.match_order_as_file!(source_file)
+        target_file.set_values_from_delta!(delta)
+        target_file.save!
+      else
+        puts 'Missing keys are all null, nothing to translate'
+      end
+    end
+
+    private
+
+    def send_to_chatgpt_api(delta)
+      values_to_translate = delta.values
+      client = OpenAIClient.new
+      translated_values = []
+
+      values_to_translate.each_slice(200) do |chunk|
+        messages = ["Please translate the following list of strings from the source language specified by '#{source_file.locale}' to the target language indicated by '#{target_file.locale}'. The translations should be suitable for use in a user interface, taking into account that shorter strings are likely to be used as button labels or element captions. The output should be in the form of an array containing the translated messages, ensuring that each translated value is accurate and correctly formatted for JSON parsing. Special attention should be paid to maintaining the context and usability of each UI element in the target language. Below is the list for translation:"]
+
+        messages << chunk.to_json
+
+        response = client.complete(messages: messages)
+        chunk_translated_values = JSON.parse(response)
+
+        translated_values.concat(chunk_translated_values)
+      end
+
+      delta.translated_values = translated_values
+      delta
+    end
+  end
+end

data/lib/i18n_uno/tree.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module I18nUno
+  class Tree
+    attr_reader :locale
+
+    def initialize(locale)
+      @locale = locale
+      @data   = []       # [{ file: I18nUno::File, delta: I18nUno::DiffDelta }]
+      collect_files
+    end
+
+    def process_delta_changes(source_of_truth_tree)
+      entries_with_delta = extract_entries_with_delta
+
+      if entries_with_delta.empty?
+        puts "No changes detected for '#{locale}' locale."
+        return
+      end
+
+      files_completed  = 0
+      puts "Processing locale '#{locale}' there are #{entries_with_delta.count} files with changes. "
+      entries_with_delta.each_with_index do |entry, index|
+        printf("Processing file %-40s [#{index + 1}/#{entries_with_delta.count}] ... ", "'#{entry[:file].pp_file_name}'")
+
+        if entry[:delta].any_new_keys?
+          sot_file = source_of_truth_tree.find_file(entry[:file])
+          translator = I18nUno::Translator.new(sot_file, entry[:file])
+          translator.process(entry[:delta])
+        end
+
+        if entry[:delta].any_removed_keys? && !entry[:delta].complete_file_diff?
+          entry[:file].remove_keys_from_file!(entry[:delta])
+        end
+
+        entry[:processed] = true
+
+        puts 'OK'
+      end
+    end
+
+    def extract_entries_with_delta
+      @data.select do |entry|
+        entry[:delta].present? && entry[:delta].any_changes?
+      end
+    end
+
+    def add_delta!(file, diff_delta)
+      @data.each do |entry|
+        if entry[:file] == file
+          entry[:delta] = diff_delta
+          break
+        end
+      end
+    end
+
+    def files
+      @data.map { |entry| entry[:file] }
+    end
+
+    def any?
+      @data.any?
+    end
+
+    def empty?
+      @data.empty?
+    end
+
+    def each(&block)
+      files.each(&block)
+    end
+
+    def find_file(target_file)
+      files.find { |file| file.file_path.match(/#{target_file.file_identifier}/) }
+    end
+
+    def find_or_create_file(sot_file)
+      file = find_file(sot_file)
+
+      if file.nil?
+        file = sot_file.create_in_locale(locale)
+        @data << { file: file, delta: nil, new_file: true, processed: false }
+      end
+
+      file
+    end
+
+    def clean_not_processed_files
+      @data.each do |entry|
+        if (entry[:new_file] && !entry[:processed])
+          ::File.delete(entry[:file].file_path)
+        end
+      end
+
+    end
+
+    private
+
+    def collect_files
+      path_pattern = ::File.join(I18nUno.config.load_path, '**', "#{locale}.yml")
+      Dir.glob(path_pattern).map do |file_path|
+        @data << { file: I18nUno::File.new(file_path), delta: nil }
+      end
+    end
+  end
+end

data/lib/i18n_uno/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module I18nUno
+  VERSION = '0.1.0'
+end

data/lib/i18n_uno.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'i18n_uno/version'
+require 'i18n_uno/configuration'
+require 'i18n_uno/railtie' if defined?(Rails)
+require 'i18n_uno/arbiter'
+require 'i18n_uno/comparer'
+require 'i18n_uno/translator'
+require 'i18n_uno/tree'
+require 'i18n_uno/file'
+require 'i18n_uno/delta'
+
+module I18nUno
+  class << self
+    attr_accessor :config
+  end
+
+  def self.config
+    @config ||= I18nUno::Configuration.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+end

data/lib/tasks/i18n_uno.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+namespace :i18n_uno do
+  desc 'Translate all your I18n files'
+  task translate: :environment do
+    begin
+      I18nUno.config.validate!
+
+      i18n_uno = I18nUno::Arbiter.new
+      i18n_uno.translate
+    rescue I18nUno::ConfigurationError => e
+      puts("#{e.class}: #{e.message}")
+    end
+  end
+end

data/rubocop.yml

@@ -0,0 +1,240 @@
+require:
+  - rubocop-performance
+  - rubocop-rails
+  - rubocop-minitest
+
+inherit_mode:
+  merge:
+    - Exclude
+
+AllCops:
+  SuggestExtensions: false
+  DisabledByDefault: true
+  Exclude:
+    - "data/**/*"
+
+# Align `when` with `end`.
+Layout/CaseIndentation:
+  Enabled: true
+  EnforcedStyle: end
+
+# Align comments with method definitions.
+Layout/CommentIndentation:
+  Enabled: true
+
+Layout/ElseAlignment:
+  Enabled: true
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: true
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: true
+
+# In a regular class definition, no empty lines around the body.
+Layout/EmptyLinesAroundClassBody:
+  Enabled: true
+
+# In a regular method definition, no empty lines around the body.
+Layout/EmptyLinesAroundMethodBody:
+  Enabled: true
+
+# In a regular module definition, no empty lines around the body.
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: true
+
+# Align `end` with the matching keyword or starting expression except for
+# assignments, where it should be aligned with the LHS.
+Layout/EndAlignment:
+  Enabled: true
+  EnforcedStyleAlignWith: variable
+  AutoCorrect: true
+
+# Method definitions after `private` or `protected` isolated calls need one
+# extra level of indentation.
+#
+# We break this rule in context, though, e.g. for private-only concerns,
+# so we leave it disabled.
+Layout/IndentationConsistency:
+  Enabled: false
+  EnforcedStyle: indented_internal_methods
+
+# Detect hard tabs, no hard tabs.
+Layout/IndentationStyle:
+  Enabled: true
+
+# Two spaces, no tabs (for indentation).
+#
+# Doesn't behave properly with private-only concerns, so it's disabled.
+Layout/IndentationWidth:
+  Enabled: false
+
+Layout/LeadingCommentSpace:
+  Enabled: true
+
+Layout/SpaceAfterColon:
+  Enabled: true
+
+Layout/SpaceAfterComma:
+  Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: true
+
+Layout/SpaceAroundKeyword:
+  Enabled: true
+
+# Use `foo {}` not `foo{}`.
+Layout/SpaceBeforeBlockBraces:
+  Enabled: true
+
+Layout/SpaceBeforeComma:
+  Enabled: true
+
+Layout/SpaceBeforeFirstArg:
+  Enabled: true
+
+# Use `->(x, y) { x + y }` not `-> (x, y) { x + y }`
+Layout/SpaceInLambdaLiteral:
+  Enabled: true
+
+# Use `[ a, [ b, c ] ]` not `[a, [b, c]]`
+# Use `[]` not `[ ]`
+Layout/SpaceInsideArrayLiteralBrackets:
+  Enabled: true
+  EnforcedStyle: space
+  EnforcedStyleForEmptyBrackets: no_space
+
+# Use `%w[ a b ]` not `%w[ a   b ]`.
+Layout/SpaceInsideArrayPercentLiteral:
+  Enabled: true
+
+# Use `foo { bar }` not `foo {bar}`.
+# Use `foo { }` not `foo {}`.
+Layout/SpaceInsideBlockBraces:
+  Enabled: true
+  EnforcedStyleForEmptyBraces: space
+
+# Use `{ a: 1 }` not `{a:1}`.
+# Use `{}` not `{  }`.
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: true
+  EnforcedStyle: space
+  EnforcedStyleForEmptyBraces: no_space
+
+# Use `foo(bar)` not `foo( bar )`
+Layout/SpaceInsideParens:
+  Enabled: true
+
+# Requiring a space is not yet supported as of 0.59.2
+# Use `%w[ foo ]` not `%w[foo]`
+Layout/SpaceInsidePercentLiteralDelimiters:
+  Enabled: false
+  #EnforcedStyle: space
+
+# Use `hash[:key]` not `hash[ :key ]`
+Layout/SpaceInsideReferenceBrackets:
+  Enabled: true
+
+# Blank lines should not have any spaces.
+Layout/TrailingEmptyLines:
+  Enabled: true
+
+# No trailing whitespace.
+Layout/TrailingWhitespace:
+  Enabled: true
+
+Lint/RedundantStringCoercion:
+  Enabled: true
+
+# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
+Lint/RequireParentheses:
+  Enabled: true
+
+Lint/UriEscapeUnescape:
+  Enabled: true
+
+Performance:
+  Exclude:
+    - "test/**/*"
+
+Performance/FlatMap:
+  Enabled: true
+
+Performance/UnfreezeString:
+  Enabled: true
+
+# Prefer assert_not over assert !
+Rails/AssertNot:
+  Include:
+    - "test/**/*"
+
+# Prefer assert_not_x over refute_x
+Rails/RefuteMethods:
+  Include:
+    - "test/**/*"
+
+# We generally prefer &&/|| but like low-precedence and/or in context
+Style/AndOr:
+  Enabled: false
+
+# Prefer Foo.method over Foo::method
+Style/ColonMethodCall:
+  Enabled: true
+
+Style/DefWithParentheses:
+  Enabled: true
+
+# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
+Style/HashSyntax:
+  Enabled: true
+  EnforcedShorthandSyntax: either
+
+# Defining a method with parameters needs parentheses.
+Style/MethodDefParentheses:
+  Enabled: true
+
+Style/ParenthesesAroundCondition:
+  Enabled: true
+
+Style/PercentLiteralDelimiters:
+  Enabled: true
+  PreferredDelimiters:
+    default: "()"
+    "%i": "[]"
+    "%I": "[]"
+    "%r": "{}"
+    "%w": "[]"
+    "%W": "[]"
+
+# Use quotes for string literals when they are enough.
+Style/RedundantPercentQ:
+  Enabled: false
+
+Style/RedundantReturn:
+  Enabled: true
+  AllowMultipleReturnValues: true
+
+Style/Semicolon:
+  Enabled: true
+  AllowAsExpressionSeparator: true
+
+Style/StabbyLambdaParentheses:
+  Enabled: true
+
+# Use `"foo"` not `'foo'` unless escaping is required
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+  Include:
+    - "app/**/*"
+    - "config/**/*"
+    - "lib/**/*"
+    - "test/**/*"
+    - "Gemfile"
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: i18n_uno
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Haris Krajina
+- hkraji
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-04-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: i18n Uno is simple CLI tool that will completly translate your application
+  to any desired language.
+email:
+- haris@pythagoranorth.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- i18n_uno.gemspec
+- lib/.DS_Store
+- lib/i18n_uno.rb
+- lib/i18n_uno/.DS_Store
+- lib/i18n_uno/arbiter.rb
+- lib/i18n_uno/comparer.rb
+- lib/i18n_uno/configuration.rb
+- lib/i18n_uno/delta.rb
+- lib/i18n_uno/file.rb
+- lib/i18n_uno/files/content_change.rb
+- lib/i18n_uno/open_ai_client.rb
+- lib/i18n_uno/railtie.rb
+- lib/i18n_uno/translator.rb
+- lib/i18n_uno/tree.rb
+- lib/i18n_uno/version.rb
+- lib/tasks/i18n_uno.rake
+- rubocop.yml
+homepage: https://github.com/pythagora-north/i18n_uno
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/pythagora-north/i18n_uno
+  source_code_uri: https://github.com/pythagora-north/i18n_uno
+  changelog_uri: https://github.com/pythagora-north/i18n_uno/blob/main/Changes.md
+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.5.3
+signing_key:
+specification_version: 4
+summary: i18n Uno levrages power of ChatGPT API to translate your i18n files.
+test_files: []