loco_strings 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ae94b18e40b03e455e87bd4c5a4a4b2139ee822e0f67fb7bddd4f525027a936
-  data.tar.gz: f4decc1b1751dc3f9cdafdf7db9ac9e950f344e3990c2ed7db9373238e760193
+  metadata.gz: 36daf9f28f2ff56c824968da9a23422d2a3d50e8260154469cb93b8637097350
+  data.tar.gz: 948f62e57518bc34201c1f6ae67f66ca2f8a0b10662389caeaf908505a12e2e5
 SHA512:
-  metadata.gz: 7be956a59f8a41eabf7a7196cd03e0979f411b4f511c43c0c4a607af32b680e85b1e7d210445070786f43024d9eabcfe7b6c504283b93c1ddc1ca2206cd7b36e
-  data.tar.gz: e80e535b831507b88eeb25e9d392ca4f39b91112c73d5f2074f69965cacbb8109d0cf3806694ed9164ce5cee417849e4ed13130885edd5efdab9b9dd6181fd2c
+  metadata.gz: '028dc48c692c84b7e6fc97b0bbd572faedb686a59c50084e2aa9bd0cc95b7f88d6a82cad905fd984a44bdf7a6b2de1166ba00a1390bf115131ca5ddb8af0246b'
+  data.tar.gz: a88259d18e7893c48bea667080de5d2ccd2ee4904fc7a83f7a219abcc70d47cf7a1004658a06b6f83673b2cea0c5532352e6712c30d6b3a599a0a7f256176c9c

data/.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
   TargetRubyVersion: 2.6
+  NewCops: enable
 
 Style/StringLiterals:
   Enabled: true

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    loco_strings (0.1.1)
+    loco_strings (0.1.3)
       nokogiri (~> 1.13, >= 1.13.8)
 
 GEM

data/lib/loco_strings/decoders/xcstrings_decoder.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LocoStrings
+  # The XCStringsDecoder class is responsible for decoding the XCStrings file format.
+  class XCStringsDecoder
+    attr_reader :language, :strings, :translations, :languages
+
+    def initialize(file_path)
+      @file_path = file_path
+      @strings = {}
+      @translations = {}
+      @languages = []
+      @language = nil
+    end
+
+    def decode
+      return @strings unless File.exist?(@file_path)
+
+      file = File.read(@file_path)
+      json = JSON.parse(file)
+      extract_languages(json)
+      @language = json["sourceLanguage"]
+      decode_strings(json)
+      @strings
+    end
+
+    private
+
+    def extract_languages(json)
+      @languages = []
+      json["strings"].each do |_key, value|
+        next unless value.key?("localizations")
+
+        value["localizations"].each do |lang, _loc|
+          @languages << lang
+        end
+      end
+      @languages.uniq!
+    end
+
+    def decode_strings(json)
+      strings = json["strings"]
+      strings.each do |key, value|
+        @strings[key] = decode_string(key, value, @language)
+        decode_translations(key, value)
+      end
+    end
+
+    def decode_string(key, value, language)
+      return LocoString.new(key, key, value["comment"], "new") unless value.key?("localizations")
+
+      loc = value.dig("localizations", language)
+      return if loc.nil?
+
+      if loc.key?("stringUnit")
+        decode_string_unit(key, loc, value["comment"])
+      elsif loc.key?("variations")
+        decode_variations(key, loc, value["comment"])
+      else
+        LocoString.new(key, key, value["comment"], "new")
+      end
+    end
+
+    def decode_string_unit(key, value, comment)
+      return nil unless value.key?("stringUnit")
+
+      unit = value["stringUnit"]
+      translation = unit["value"]
+      LocoString.new(key, translation, comment, unit["state"]) unless translation.nil?
+    end
+
+    def decode_variations(key, value, comment)
+      variations = value["variations"]
+      plural = decode_plural(variations, comment)
+      return nil if plural.empty?
+
+      variation = LocoVariantions.new(key, comment)
+      plural.each do |unit|
+        variation.append_string(unit)
+      end
+      variation
+    end
+
+    def decode_plural(variation, comment)
+      plural = variation["plural"]
+      return [] if plural.nil?
+
+      result = []
+      plural.each do |key, value|
+        unit = decode_string_unit(key, value, comment)
+        result << unit unless unit.nil?
+      end
+      result
+    end
+
+    def decode_translations(key, value)
+      @languages.each do |language|
+        string = decode_string(key, value, language)
+        @translations[language] ||= {}
+        @translations[language][key] = string
+      end
+    end
+  end
+end

data/lib/loco_strings/encoders/xcstrings_encoder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LocoStrings
+  # The XCStringsEncoder class is responsible for encoding the LocoStrings data to the XCStrings format.
+  class XCStringsEncoder
+    attr_reader :language, :strings, :translations, :languages
+
+    def initialize(strings, translations, languages, language)
+      @strings = strings
+      @translations = translations
+      @languages = languages
+      @language = language
+    end
+
+    def encode
+      raise Error, "The base language is not defined" if @language.nil?
+
+      json = {
+        "sourceLanguage" => @language,
+        "strings" => {},
+        "version" => "1.0"
+      }
+      generate_keys.each do |key|
+        json["strings"][key] = encode_key(key)
+      end
+      JSON.pretty_generate(json, { space_before: " " })
+    end
+
+    private
+
+    def generate_keys
+      keys = []
+      @translations.each do |_, translation|
+        keys += translation.keys
+      end
+      keys.uniq
+    end
+
+    def encode_key(key)
+      row = {}
+      @translations.each do |language, translation|
+        next unless translation.key?(key)
+
+        value = translation[key]
+        next if value.nil?
+
+        row["comment"] = value.comment unless row.key?("comment") || value.comment.nil?
+        row["localizations"] ||= {}
+        row["localizations"][language] = encode_value(value)
+      end
+      row
+    end
+
+    def encode_value(value)
+      if value.is_a?(LocoVariantions)
+        encode_variations(value)
+      else
+        encode_string_unit(value)
+      end
+    end
+
+    def encode_string_unit(unit)
+      res = { "stringUnit" => {} }
+      res["stringUnit"]["state"] = unit.state unless unit.state.nil?
+      res["stringUnit"]["value"] = unit.value
+      res
+    end
+
+    def encode_variations(variations)
+      plural = {}
+      variations.strings.each do |key, string|
+        plural[key] = encode_string_unit(string) unless string.nil?
+      end
+      {
+        "variations" => {
+          "plural" => plural
+        }
+      }
+    end
+  end
+end

data/lib/loco_strings/parsers/android_file.rb

@@ -29,7 +29,7 @@ module LocoStrings
           end
         end
       end
-      File.open(@file_path, "w") { |file| file.write(builder.to_xml) }
+      File.write(@file_path, builder.to_xml)
     end
 
     private

data/lib/loco_strings/parsers/ios_file.rb

@@ -25,7 +25,7 @@ module LocoStrings
         output += "/* #{value.comment} */\n" if value.comment
         output += "\"#{key}\" = \"#{value.value}\";\n"
       end
-      File.open(@file_path, "w") { |file| file.write(output) }
+      File.write(@file_path, output)
     end
 
     private

data/lib/loco_strings/parsers/loco_file.rb

@@ -23,7 +23,7 @@ module LocoStrings
     end
 
     def update(key, value, comment = nil)
-      comment = @strings[key].comment if comment.nil? && @strings.has_key?(key)
+      comment = @strings[key].comment if comment.nil? && @strings.key?(key)
       @strings[key] = LocoString.new key, value, comment
     end
 

data/lib/loco_strings/parsers/xcstrings_file.rb

@@ -1,69 +1,107 @@
+# frozen_string_literal: true
+
 require_relative "loco_file"
+require_relative "../encoders/xcstrings_encoder"
+require_relative "../decoders/xcstrings_decoder"
 require "json"
 
 module LocoStrings
+  # The XCStringsFile class is responsible for reading and writing the XCStrings file format.
   class XCStringsFile < LocoFile
-    def initialize(file_path, language)
-      @file_path = file_path
-      @language = language
-      clean
-    end
-
     def read
       clean
       return @strings unless File.exist?(@file_path)
 
-      comment = nil
-      file = File.read(@file_path)
-      json = JSON.parse(file)
-      sourceLanguage = json["sourceLanguage"]
-      strings = json["strings"]
-      strings.each do |key, value|
-        comment = value["comment"]
-        translation = key unless @language != sourceLanguage
-        if value.has_key?("localizations") && value["localizations"].has_key?(@language)
-          loc = value["localizations"][@language]
-        end
-        translation = loc["stringUnit"]["value"] unless loc.nil?
-        @strings[key] = LocoString.new key, translation, comment unless translation.nil?
-      end
+      decoder = XCStringsDecoder.new(@file_path)
+      decoder.decode
+
+      @language = decoder.language
+      @strings = decoder.strings
+      @translations = decoder.translations
+      @languages = decoder.languages
       @strings
     end
 
-    def write(files = [])
-      json = {}
-      json["sourceLanguage"] = @language
-      json["strings"] = {}
+    def write
+      raise Error, "The base language is not defined" if @language.nil?
+
+      json = XCStringsEncoder.new(@strings, @translations, @languages, @language).encode
+      File.write(@file_path, json)
+    end
+
+    def update(key, value, comment = nil, stage = nil, language = @language)
+      raise Error, "The base language is not defined" if @language.nil?
+
+      stage = "translated" if stage.nil?
+      string = make_strings(key, value, comment, stage, language)
+      return if string.nil?
+
+      @translations[language] ||= {}
+      @translations[language][key] = string
+      @strings[key] = string if @language == language
+    end
+
+    def update_variation(key, variant, strings, comment = nil, state = nil, language = @language) # rubocop:disable Metrics/ParameterLists
+      raise Error, "The base language is not defined" if @language.nil?
+
+      variations = make_variations(key, variant, strings, comment, state, language)
+      return if variations.nil?
+
+      @translations[language] ||= {}
+      @translations[language][key] = variations
+      @strings[key] = variations if @language == language
+    end
+
+    def select_language(language)
+      raise Error, "The base language is aready defined" unless @language.nil?
+
+      @language = language
+    end
+
+    def to_s
+      result = ""
+      result += "Base language: #{@language}\n" unless @language.nil?
+      result += "Languages: #{@languages}\n" unless @languages.empty?
+      result += "Strings:\n"
       @strings.each do |key, value|
-        row = {}
-        row["comment"] = value.comment unless value.comment.nil?
-        localizations = {}
-        if value.value != key && !value.value.nil?
-          localizations[@language] = {
-            "stringUnit" => {
-              "state" => "translated",
-              "value" => value.value
-            }
-          }
-        end
-        files.each do |file|
-          translation = file.value(key)
-          next unless translation
-
-          next unless key != translation
-
-          localizations[file.language] = {
-            "stringUnit" => {
-              "state" => "translated",
-              "value" => translation
-            }
-          }
-        end
-        row["localizations"] = localizations unless localizations.empty?
-        json["strings"][key] = row
+        result += "#{key}: #{value}\n"
       end
-      json["version"] = "1.0"
-      File.open(@file_path, "w") { |file| file.write(JSON.pretty_generate(json)) }
+      result
+    end
+
+    def clean
+      @strings = {}
+      @translations = {}
+      @languages = []
+      @language = nil
+    end
+
+    private
+
+    def make_strings(key, value, comment = nil, state = nil, language = @language)
+      unit = @translations.dig(language, key)
+      return LocoString.new(key, value, comment, state) if unit.nil?
+
+      if unit.is_a?(LocoVariantions)
+        puts "Variations not supported through this method"
+        return nil
+      end
+      unit.update(value, comment, state)
+      unit
+    end
+
+    def make_variations(key, variant, value, comment = nil, state = nil, language = @language) # rubocop:disable Metrics/ParameterLists
+      variants = @translations.dig(language, key)
+
+      return make_strings(key, value, comment, state, language) if variants.is_a?(LocoString)
+
+      if variants.nil?
+        state = "new" if state.nil?
+        return LocoVariantions.new(key, { variant => LocoString.new(variant, value, comment, state) })
+      end
+
+      variants.update_variant(variant, value, comment, state)
+      variants
     end
   end
 end

data/lib/loco_strings/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LocoStrings
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/loco_strings.rb

@@ -9,13 +9,46 @@ require_relative "loco_strings/parsers/xcstrings_file"
 module LocoStrings
   class Error < StandardError; end
 
-  LocoString = Struct.new(:key, :value, :comment) do
-    def initialize(key, value, comment = nil)
+  LocoString = Struct.new(:key, :value, :comment, :state) do
+    def initialize(key, value, comment = nil, state = nil)
       super
     end
+
+    def update(value, comment = nil, state = nil)
+      self.value = value
+      self.comment = comment unless comment.nil?
+      self.state = state
+    end
+
+    def to_s
+      "Key: #{key}, Value: #{value}, Comment: #{comment || "None"}, State: #{state || "None"}"
+    end
   end
 
-  def self.load(file_path, language = nil)
+  LocoVariantions = Struct.new(:key, :strings, :comment) do
+    def initialize(key, strings = nil, comment = nil)
+      super
+      self.strings = strings || {}
+    end
+
+    def append_string(string)
+      strings[string.key] = string
+    end
+
+    def update_variant(key, value, comment = nil, state = nil)
+      if strings.key? key
+        strings[key].update(value, comment, state)
+      else
+        strings[key] = LocoString.new(key, value, comment, state)
+      end
+    end
+
+    def to_s
+      "Key: #{key}, Strings: #{strings}, Comment: #{comment || "None"}"
+    end
+  end
+
+  def self.load(file_path) # rubocop:disable Metrics/MethodLength
     ext = File.extname(file_path)
     raise Error, "Unsupported file format: #{ext}" unless [".strings", ".xml", ".xcstrings"].include? ext
 
@@ -25,9 +58,7 @@ module LocoStrings
     when ".xml"
       AndroidFile.new file_path
     when ".xcstrings"
-      raise Error, "Language is required for xcstrings files" unless language
-
-      XCStringsFile.new file_path, language
+      XCStringsFile.new file_path
     else
       raise Error, "Not implemented"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loco_strings
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Aleksei Cherepanov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -53,12 +53,13 @@ files:
 - README.md
 - Rakefile
 - lib/loco_strings.rb
+- lib/loco_strings/decoders/xcstrings_decoder.rb
+- lib/loco_strings/encoders/xcstrings_encoder.rb
 - lib/loco_strings/parsers/android_file.rb
 - lib/loco_strings/parsers/ios_file.rb
 - lib/loco_strings/parsers/loco_file.rb
 - lib/loco_strings/parsers/xcstrings_file.rb
 - lib/loco_strings/version.rb
-- loco_strings.gemspec
 - sig/loco_strings.rbs
 homepage: https://github.com/ftp27/loco_strings
 licenses:
@@ -66,6 +67,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/ftp27/loco_strings
   source_code_uri: https://github.com/ftp27/loco_strings
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:

data/loco_strings.gemspec

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Layout/LineLength
-
-require_relative "lib/loco_strings/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "loco_strings"
-  spec.version = LocoStrings::VERSION
-  spec.authors = ["Aleksei Cherepanov"]
-  spec.email = ["ftp27host@gmail.com"]
-
-  spec.summary = "LocoStrings is a Ruby gem for working with iOS and Android localization strings."
-  spec.description = "LocoStrings is a powerful and easy-to-use Ruby gem that simplifies the process of managing localization strings for iOS and Android apps. With LocoStrings, you can easily extract, organize, and update your app's localized strings in one place, making it easy to maintain consistency across all of your app's translations. LocoStrings supports multiple file formats, including XLIFF and CSV, and provides a simple and intuitive API for working with your app's strings in code. Whether you're a solo developer or part of a team, LocoStrings makes managing your app's localization a breeze."
-  spec.homepage = "https://github.com/ftp27/loco_strings"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-
-  # 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 "nokogiri", "~> 1.13", ">= 1.13.8"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-end
-
-# rubocop:enable Layout/LineLength