i18n_add 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b12a3f21b51efeaa680e5840239fb6026c61d4d0f9ffe786e8e5160e0f0f3c3
-  data.tar.gz: 856de3b24b775ba1c60c3251f86de82f36569b6ac4252b74f848108b5a0d4dc2
+  metadata.gz: 8a2fd9352a79a42b92f80a363f304cee99b7a5b5cbfd5ac4b533f48c5665ccf3
+  data.tar.gz: d49cdae044a42f1bc93af5d5e7191926450b1b163d80c05b17c9f8877aec6e25
 SHA512:
-  metadata.gz: 8fd16a4033cb63a53a954095f7fbe941f2ea3219f80889652b3ee96b334f1eb24df3af200ac54938e946e557028c86e1f193e45e0662f89cb31757107b8b920e
-  data.tar.gz: 559a9709997cf81eed47352104e0eaaf4f1606814e286e8055048ca83f8ecc2b05591b22f008a2f22443af543a88a317e7c90394a7eeee34270bd69cb8a10d3b
+  metadata.gz: c7b2cba96f3a482d16de8f51b79541aa304a978f3dd5e24a91310abd510b33a2c2a1ec0e071c94688c8ed9a663cdf779f96d5c3b3d872f6005b2049821b5f2f2
+  data.tar.gz: c1b768c80044ac33fae0e01ff3f291d84b2ab3fdd55bf04b34ccf3b293141f1e5f3ec47f550b09b0e5465d12a01665d7594e4dc6b68edcc05fb5d8bfb37484ce

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-07-05
+
+### Changed
+- **Major refactoring for improved modularity and maintainability**
+- Refactored YamlProcessor to eliminate excessive parameter passing by using instance variables
+- Refactored CLI class to follow single-responsibility principle with helper classes
+- Updated error handling to use SystemExit exceptions instead of direct exit calls for better testability
+
+### Added
+- Comprehensive RDoc-compliant documentation for key methods
+- New helper classes: CLIConfig, TranslationEntry, FileMapBuilder, CLIError
+- New YAML processor helper classes: ProcessorState, KeyContext
+- Enhanced error handling with proper exception catching in tests
+
+### Fixed
+- Fixed test suite issues where exit calls were causing test processes to terminate
+- Improved CLI help system to work correctly with tests
+- Enhanced error message formatting and display
+
+### Technical Improvements
+- Eliminated 11+ redundant keyword arguments across multiple methods
+- Improved code organization with clear separation of concerns
+- Enhanced testability with proper exception handling
+- All tests now pass consistently (40+ tests, 200+ assertions)
+
 ## [0.2.0] - 2025-07-03
 
 - Add comprehensive GitHub repository configuration

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    i18n_add (0.2.0)
+    i18n_add (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -10,6 +10,7 @@ GEM
     json (2.12.2)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
+    minitest (5.25.5)
     parallel (1.27.0)
     parser (3.3.8.0)
       ast (~> 2.4.1)
@@ -43,6 +44,7 @@ PLATFORMS
 
 DEPENDENCIES
   i18n_add!
+  minitest (~> 5.0)
   rake (~> 13.0)
   rubocop (~> 1.21)
 

data/Rakefile

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
+require "rake/testtask"
 require "rubocop/rake_task"
 
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
 RuboCop::RakeTask.new
 
-task default: :rubocop
+task default: %i[test rubocop]
 
 # Version management tasks
 namespace :version do
@@ -34,7 +41,7 @@ end
 def bump_version(type)
   require_relative "lib/i18n_add/version"
   current = I18nAdd::VERSION
-  major, minor, patch = current.split('.').map(&:to_i)
+  major, minor, patch = current.split(".").map(&:to_i)
 
   case type
   when :patch

data/lib/i18n_add/cli.rb

@@ -1,73 +1,203 @@
 # frozen_string_literal: true
 
-require 'optparse'
-require 'yaml'
-require 'fileutils'
-require_relative 'yaml_processor'
+require "optparse"
+require "yaml"
+require "fileutils"
+require_relative "yaml_processor"
 
 module I18nAdd
+  ##
+  # Command Line Interface for the i18n_add gem.
+  #
+  # Provides a clean interface for adding translation entries to YAML files
+  # with support for multiple locales, custom file paths, and batch processing.
   class CLI
     def self.run(args = ARGV)
       new.run(args)
     end
 
     def run(args)
-      help_msg = <<~HELP
+      return show_help if should_show_help?(args)
+
+      begin
+        config = parse_arguments(args)
+        return show_help if config.help_requested
+
+        validate_configuration(config)
+        file_map = build_file_map(config)
+        process_translations(file_map)
+      rescue CLIError => e
+        puts "\e[31m#{e.message}\e[0m"
+        raise SystemExit.new(1)
+      end
+    end
+
+    private
+
+    def should_show_help?(args)
+      args.first == "help" || args.empty? || args.include?("-h") || args.include?("--help")
+    end
+
+    def show_help
+      puts help_message
+    end
+
+    def help_message
+      <<~HELP
         Usage: i18n_add [OPTIONS] [-t <locale.key=value> ...] locale.key=value
             -t, --translation TRANSLATION     [Optional] Translation entry, can be specified multiple times. Format: locale.dot.separated.key=value
-            -f, --file FILE                   [Optional] File path. If not specified, defaults to 'config/locales/%{locale}/main.%{locale}.yml' for each locale.
+            -f, --file FILE                   [Optional] File path. If not specified, defaults to 'config/locales/%<locale>s/main.%<locale>s.yml' for each locale.
             -h, --help                        Show this help message and exit.
       HELP
+    end
 
-      if args.first == 'help' || args.empty? || args.include?('-h') || args.include?('--help')
-        puts help_msg
-        return
-      end
+    def parse_arguments(args)
+      config = CLIConfig.new
+
+      option_parser = build_option_parser(config)
+      option_parser.parse!(args)
 
-      options = { translations: [] }
+      # Handle positional argument as translation if no -t flags given
+      handle_positional_translation(config, args)
+
+      config
+    end
+
+    def build_option_parser(config)
       OptionParser.new do |opts|
         opts.banner = "Usage: i18n_add help or i18n_add [options]"
-        opts.on('-tVAL', '--translation VAL', '[Optional] Translation entry, can be specified multiple times. Format: locale.dot.separated.key=value') { |v| options[:translations] << v }
-        opts.on('-f', '--file FILE', '[Optional] File path. Supports %{locale} as a placeholder for the locale. If not specified, defaults to \'config/locales/%{locale}/main.%{locale}.yml\' for each locale.') { |v| options[:file] = v }
-        opts.on('-h', '--help', 'Show this help message and exit.') do
-          puts help_msg
-          return
+
+        opts.on("-tVAL", "--translation VAL",
+                "[Optional] Translation entry, can be specified multiple times. Format: locale.dot.separated.key=value") do |translation|
+          config.add_translation(translation)
         end
-      end.parse!(args)
 
-      # If no -t given, but a single positional argument remains, treat it as a translation
-      if options[:translations].empty? && args.size == 1 && args[0] =~ /^[a-z]{2}\..+?=.*/
-        options[:translations] << args.shift
+        opts.on("-f", "--file FILE",
+                "[Optional] File path. Supports %<locale>s as a placeholder for the locale. If not specified, defaults to 'config/locales/%<locale>s/main.%<locale>s.yml' for each locale.") do |file_path|
+          config.file_template = file_path
+        end
+
+        opts.on("-h", "--help", "Show this help message and exit.") do
+          # Set a flag that we can check later, don't call show_help here
+          config.help_requested = true
+        end
+      end
+    end
+
+    def handle_positional_translation(config, args)
+      return unless config.translations.empty? && args.size == 1 && TranslationEntry.valid_format?(args[0])
+
+      config.add_translation(args.shift)
+    end
+
+    def validate_configuration(config)
+      return unless config.translations.empty?
+
+      raise CLIError, "No translations provided. Use -t or --translation."
+    end
+
+    def build_file_map(config)
+      file_map_builder = FileMapBuilder.new(config)
+      file_map_builder.build
+    end
+
+    def process_translations(file_map)
+      processor = YamlProcessor.new
+      processor.process_files(file_map)
+    end
+
+    # Configuration object to hold CLI options and translations
+    class CLIConfig
+      attr_reader :translations
+      attr_accessor :file_template, :help_requested
+
+      def initialize
+        @translations = []
+        @file_template = nil
+        @help_requested = false
+      end
+
+      def add_translation(translation_string)
+        @translations << translation_string
+      end
+
+      def has_custom_file_template?
+        !@file_template.nil?
+      end
+
+      def default_file_template
+        "config/locales/%<locale>s/main.%<locale>s.yml"
+      end
+
+      def effective_file_template
+        @file_template || default_file_template
+      end
+    end
+
+    # Represents a single translation entry with validation
+    class TranslationEntry
+      TRANSLATION_FORMAT = /^([a-z]{2})\.(.+?)=(.*)$/m
+
+      attr_reader :locale, :key_path, :value
+
+      def initialize(translation_string)
+        @raw_string = translation_string
+        parse_translation
+      end
+
+      def self.valid_format?(translation_string)
+        translation_string =~ TRANSLATION_FORMAT
       end
 
-      file_arg = options[:file]
-      translations = options[:translations]
+      def to_hash
+        { key_path: @key_path, value: @value }
+      end
+
+      private
+
+      def parse_translation
+        match = @raw_string.match(TRANSLATION_FORMAT)
 
-      if translations.empty?
-        puts "\e[31mNo translations provided. Use -t or --translation.\e[0m"
-        exit 1
+        raise CLIError, "Invalid translation format: #{@raw_string}" unless match
+
+        @locale = match[1]
+        @key_path = match[2]
+        @value = match[3]
       end
+    end
+
+    # Builds the file map structure from CLI configuration
+    class FileMapBuilder
+      def initialize(config)
+        @config = config
+      end
+
+      def build
+        file_map = {}
+
+        @config.translations.each do |translation_string|
+          entry = TranslationEntry.new(translation_string)
+          file_path = generate_file_path(entry.locale)
 
-      # Parse all entries and group by file_path
-      file_map = {}
-      translations.each do |entry|
-        if entry =~ /^([a-z]{2})\.(.+?)=(.+)$/
-          locale, key_path, value = $1, $2, $3
-          # Support only %{locale} in file_arg as a template
-          if file_arg
-            file_path = file_arg.gsub('%{locale}', locale)
-          else
-            file_path = "config/locales/#{locale}/main.#{locale}.yml"
-          end
-          file_map[file_path] ||= { locale: locale, entries: [] }
-          file_map[file_path][:entries] << { key_path: key_path, value: value }
-        else
-          puts "\e[31mInvalid translation format: #{entry}\e[0m"
+          add_entry_to_file_map(file_map, file_path, entry)
         end
+
+        file_map
       end
 
-      processor = YamlProcessor.new
-      processor.process_files(file_map)
+      private
+
+      def generate_file_path(locale)
+        @config.effective_file_template.gsub("%<locale>s", locale)
+      end
+
+      def add_entry_to_file_map(file_map, file_path, entry)
+        file_map[file_path] ||= { locale: entry.locale, entries: [] }
+        file_map[file_path][:entries] << entry.to_hash
+      end
     end
+
+    # Custom error class for CLI-specific errors
+    class CLIError < StandardError; end
   end
 end

data/lib/i18n_add/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module I18nAdd
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/i18n_add/yaml_processor.rb

@@ -2,101 +2,253 @@
 
 module I18nAdd
   class YamlProcessor
+    ##
+    # Processes multiple YAML translation files with their respective locale configurations.
+    #
+    # This is the main entry point for the YAML processor. It handles batch processing
+    # of translation entries across multiple files, ensuring that each file is properly
+    # updated with new translation keys while preserving existing content and structure.
+    #
+    # The method creates necessary directory structures, handles file creation if files
+    # don't exist, and maintains proper YAML formatting throughout the process.
+    #
+    # @param file_map [Hash<String, Hash>] A hash mapping file paths to their configurations
+    # @option file_map [String] :locale The locale identifier (e.g., 'en', 'es', 'fr')
+    # @option file_map [Array<Hash>] :entries Array of translation entries to process
+    # @option entries [String] :key_path Dot-separated key path (e.g., 'app.navigation.home')
+    # @option entries [String] :value The translation value
+    #
+    # @return [void] This method doesn't return a value but outputs processing status
+    #
+    # @example Processing translations for multiple locales
+    #   processor = YamlProcessor.new
+    #   file_map = {
+    #     'config/locales/en/main.en.yml' => {
+    #       locale: 'en',
+    #       entries: [
+    #         { key_path: 'app.title', value: 'My Application' },
+    #         { key_path: 'nav.home', value: 'Home' }
+    #       ]
+    #     },
+    #     'config/locales/es/main.es.yml' => {
+    #       locale: 'es',
+    #       entries: [
+    #         { key_path: 'app.title', value: 'Mi Aplicación' },
+    #         { key_path: 'nav.home', value: 'Inicio' }
+    #       ]
+    #     }
+    #   }
+    #   processor.process_files(file_map)
+    #
+    # @example Processing a single file
+    #   file_map = {
+    #     'translations.yml' => {
+    #       locale: 'en',
+    #       entries: [{ key_path: 'greeting', value: 'Hello World' }]
+    #     }
+    #   }
+    #   processor.process_files(file_map)
+    #
+    # @note The method automatically creates directory structures and files if they don't exist
+    # @note Existing YAML content is preserved and new keys are properly merged
+    # @note Console output shows processing progress and completion status
+    #
+    # @see #process_single_file
+    # @since 1.0.0
     def process_files(file_map)
-      file_map.each do |file_path, info|
-        locale = info[:locale]
-        FileUtils.mkdir_p(File.dirname(file_path))
-        lines = File.exist?(file_path) ? File.read(file_path, encoding: 'UTF-8').lines : ["#{locale}:\n"]
-        changed = false
-
-        info[:entries].each do |e|
-          keys = e[:key_path].split('.')
-          value = e[:value]
-          parent_line = nil
-          parent_level = 0
-          found = false
-
-          # Find the deepest parent that exists
-          cur_level = 1
-          lines.each_with_index do |line, idx|
-            next unless line =~ /^\s*(\w+):/ # only YAML key lines
-            lkey = line.strip.split(':', 2)[0]
-            lindent = line[/^ */].size / 2
-            if lkey == keys[cur_level - 1] && lindent == cur_level
-              parent_line = idx
-              parent_level = cur_level
-              cur_level += 1
-              if cur_level - 1 == keys.size
-                # Found the full key, update value
-                val_line = idx
-                # If next line is indented more, it's a block
-                if lines[val_line + 1] && lines[val_line + 1] =~ /^#{yaml_indent(cur_level + 1)}/
-                  # Remove all block lines
-                  block_end = val_line + 1
-                  while block_end < lines.size && lines[block_end] =~ /^#{yaml_indent(cur_level + 1)}/
-                    block_end += 1
-                  end
-                  lines.slice!(val_line + 1...block_end)
-                end
-                # Replace value
-                lines[val_line] = "#{yaml_indent(cur_level)}#{keys.last}: #{yaml_escape_value(value)}\n"
-                changed = true
-                found = true
-                puts "\e[32m✓ Updated #{locale}.#{e[:key_path]} in #{file_path}\e[0m"
-                break
-              end
-            end
-          end
-
-          next if found
-
-          # Insert missing parents and key at the end
-          insert_idx = lines.size
-          # Try to find the last line of the deepest parent
-          if parent_line
-            # Find last line at this or deeper indent
-            insert_idx = parent_line + 1
-            while insert_idx < lines.size && (lines[insert_idx] =~ /^#{yaml_indent(parent_level + 1)}/ || lines[insert_idx].strip.empty?)
-              insert_idx += 1
-            end
-          end
-
-          # Build missing parents and key
-          missing = keys[parent_level..-2] || []
-          frag = +""  # Make string mutable
-          cur_indent = parent_level + 1
-          missing.each do |k|
-            frag << "#{yaml_indent(cur_indent)}#{k}:\n"
-            cur_indent += 1
-          end
-          frag << "#{yaml_indent(cur_indent)}#{keys.last}: #{yaml_escape_value(value)}\n"
-          lines.insert(insert_idx, frag)
-          changed = true
-          puts "\e[32m✓ Inserted #{locale}.#{e[:key_path]} in #{file_path}\e[0m"
-        end
-
-        if changed
-          File.open(file_path, 'w:utf-8') { |f| f.write(lines.join) }
-          puts "\e[32m✓ Updated #{file_path}\e[0m"
-        else
-          puts "No changes needed for #{file_path}"
-        end
+      file_map.each do |file_path, config|
+        process_single_file(file_path, config)
       end
+      puts "Processed #{file_map.size} files successfully."
     end
 
     private
 
-    def yaml_indent(level)
-      '  ' * level
+    def process_single_file(file_path, config)
+      locale = config[:locale]
+      entries = config[:entries]
+      @file_contents = load_file_contents(file_path)
+
+      entries.each do |entry|
+        process_entry(locale: locale, entry: entry)
+        puts "\e[32m✓ Processed #{entry[:key_path]} in #{file_path}\e[0m"
+      end
+
+      save_file_contents(file_path, @file_contents)
+      puts "\e[32m✓ Updated #{file_path}\e[0m"
+    end
+
+    def load_file_contents(file_path)
+      # Create directory structure if it doesn't exist
+      FileUtils.mkdir_p(File.dirname(file_path))
+
+      # If file doesn't exist, create it as empty (processor will handle locale detection)
+      File.write(file_path, "") unless File.exist?(file_path)
+
+      File.readlines(file_path, chomp: false)
+    end
+
+    def save_file_contents(file_path, file_contents)
+      File.write(file_path, file_contents.join)
+    end
+
+    def process_entry(locale:, entry:)
+      translation = TranslationEntry.new(
+        key_path: entry[:key_path],
+        value: entry[:value]
+      )
+
+      # Ensure locale exists in file
+      ensure_locale_exists(locale)
+
+      locale_position = find_locale_position(locale)
+      processor_state = ProcessorState.new(locale_position, @file_contents.size - 1)
+
+      translation.keys.each_with_index do |key, level|
+        key_context = KeyContext.new(
+          key: key,
+          level: level,
+          translation: translation,
+          indentation: calculate_indentation(level)
+        )
+
+        process_key_level(state: processor_state, context: key_context)
+      end
+    end
+
+    def ensure_locale_exists(locale)
+      return if @file_contents.any? { |line| line.start_with?("#{locale}:") }
+
+      # Add locale at the beginning if file is empty, or at the end if it has content
+      if @file_contents.empty? || @file_contents.all? { |line| line.strip.empty? }
+        @file_contents.clear
+        @file_contents << "#{locale}:\n"
+      else
+        @file_contents << "#{locale}:\n"
+      end
+    end
+
+    def find_locale_position(locale)
+      position = @file_contents.find_index { |line| line.start_with?("#{locale}:") }
+      # If locale not found, assume it's the first line (index 0)
+      position || 0
+    end
+
+    def process_key_level(state:, context:)
+      lookup_key = "#{context.indentation}#{context.key}:"
+      existing_position = find_existing_key(lookup_key)
+
+      if existing_position
+        handle_existing_key(position: existing_position, context: context)
+      else
+        handle_new_key(state: state, context: context)
+      end
+
+      update_processor_state(
+        state: state,
+        new_position: existing_position || state.position + 1,
+        indentation: context.indentation
+      )
+    end
+
+    def calculate_indentation(level)
+      "  " * (level + 1) # Add 1 to account for locale level
+    end
+
+    def find_existing_key(lookup_key)
+      @file_contents.find_index { |line| line.start_with?(lookup_key) }
+    end
+
+    def handle_existing_key(position:, context:)
+      # Key exists, but if it's the final key, update its value
+      return unless context.final_key?
+
+      formatted_value = format_value(context.translation.value)
+      @file_contents[position] = "#{context.indentation}#{context.key}: #{formatted_value}\n"
+    end
+
+    def handle_new_key(state:, context:)
+      new_position = state.position + 1
+
+      if context.final_key?
+        # Final key gets the value
+        formatted_value = format_value(context.translation.value)
+        @file_contents.insert(new_position, "#{context.indentation}#{context.key}: #{formatted_value}\n")
+      else
+        # Intermediate key just gets a colon and newline
+        @file_contents.insert(new_position, "#{context.indentation}#{context.key}:\n")
+      end
+    end
+
+    def update_processor_state(state:, new_position:, indentation:)
+      # Update search boundaries for nested keys
+      unless new_position + 1 > state.max_position
+        next_key_offset = find_next_key_offset(
+          start_position: new_position,
+          max_position: state.max_position,
+          indentation: indentation
+        )
+        new_max_position = calculate_new_max_position(new_position, next_key_offset, @file_contents.size)
+        state.max_position = new_max_position if new_max_position
+      end
+
+      state.position = new_position
+    end
+
+    def find_next_key_offset(start_position:, max_position:, indentation:)
+      @file_contents[(start_position + 1)..max_position].each_with_index do |line, idx|
+        break idx if line =~ /^#{indentation}\w/ # next key at the same level
+      end
     end
 
-    def yaml_escape_value(val)
-      if val.include?("\n")
-        # Multiline block
-        "|\n" + val.split("\n").map { |l| "  " + l }.join("\n")
+    def calculate_new_max_position(new_position, next_key_offset, file_size)
+      if next_key_offset.is_a?(Integer)
+        new_max = new_position + next_key_offset + 1
+        new_max >= file_size ? file_size - 1 : new_max
       else
-        # Single line, quote if needed
-        val =~ /[\":{}\[\],#&*!|>'%@`]/ ? '"' + val.gsub('"', '\\"') + '"' : val
+        file_size - 1
+      end
+    end
+
+    def format_value(value)
+      # Use YAML's built-in formatting to handle all edge cases properly
+      YAML.dump(value).strip.sub(/^---\s*/, "")
+    end
+
+    # Helper class to manage processor state
+    class ProcessorState
+      attr_accessor :position, :max_position
+
+      def initialize(position, max_position)
+        @position = position
+        @max_position = max_position
+      end
+    end
+
+    # Encapsulates a translation entry with its key path and value
+    class TranslationEntry
+      attr_reader :key_path, :value, :keys
+
+      def initialize(key_path:, value:)
+        @key_path = key_path
+        @value = value
+        @keys = key_path.split(".")
+      end
+    end
+
+    # Encapsulates context for processing a single key level
+    class KeyContext
+      attr_reader :key, :level, :translation, :indentation
+
+      def initialize(key:, level:, translation:, indentation:)
+        @key = key
+        @level = level
+        @translation = translation
+        @indentation = indentation
+      end
+
+      def final_key?
+        @level == @translation.keys.size - 1
       end
     end
   end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: i18n_add
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - theExtraTerrestrial
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-07-03 00:00:00.000000000 Z
-dependencies: []
+date: 2025-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 description: A command-line tool for adding and updating internationalization (i18n)
   translations in YAML files with support for nested keys and multiple locales.
 email:
@@ -31,7 +45,6 @@ files:
 - config/locales/en/main.en.yml
 - config/locales/es/main.es.yml
 - exe/i18n_add
-- i18n_add.gemspec
 - lib/i18n_add.rb
 - lib/i18n_add/cli.rb
 - lib/i18n_add/version.rb

data/i18n_add.gemspec

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/i18n_add/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "i18n_add"
-  spec.version = I18nAdd::VERSION
-  spec.authors = ["theExtraTerrestrial"]
-  spec.email = ["erhards.timanis@miittech.lv"]
-
-  spec.summary = "Add or update multiple translations in locale YAML files efficiently"
-  spec.description = "A command-line tool for adding and updating internationalization (i18n) translations in YAML files with support for nested keys and multiple locales."
-  spec.homepage = "https://github.com/theExtraTerrestrial/i18n_add"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
-
-  spec.metadata["allowed_push_host"] = "https://rubygems.org"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/theExtraTerrestrial/i18n_add"
-  spec.metadata["changelog_uri"] = "https://github.com/theExtraTerrestrial/i18n_add/blob/main/CHANGELOG.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(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-end