loco_strings 0.1.4.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2d39a13c5afee6bd306c83aee1793452203d521b426645f1fa885b4b3da1e29
-  data.tar.gz: bd6c23d23e3fb41c39d213f5f33b4f787cf4bea2e323a46b018382a402ca98ec
+  metadata.gz: 83291f99249e590483aa4c51d5710eada7bc80a910048bf0ba20b66a25ff187f
+  data.tar.gz: 11a3bbb921de0df05fe594518b98a254dc27531a8c312e383827090fb6816391
 SHA512:
-  metadata.gz: 90f78c9ba808022d66e4495906c67699023cf224b552ad67b28db15ef040d1da3afabb7b72423630af5d46d17f857fa77cae032881669b222e6d17cb812d8aea
-  data.tar.gz: 65d4ee5ce0b91ba6e084e0ad84942e88a499476d334d5b8990e097312983b5a0ecd4a153275ff953fe9704f72df69a83320fe02694ac8357e7b3b3130ba39aab
+  metadata.gz: 36f248bd8877845fa3983df90cf0903ca7fb26df5fefaeff0a52c98a5b5393e0d1e9a7121bc068db6b0c169b78899796807dabc119c45616d5ce8d77096ba2e5
+  data.tar.gz: 6df549b39d2ba998aff3899eb27729a988d428d76ad7c14789f5c0a1e64b920a1eb6f7f6a0051beb24754baf3825413fe2dad08519f6ffb02d7097af4255cb3b

data/lib/loco_strings/decoders/xcstrings_decoder.rb

@@ -5,7 +5,7 @@ require "json"
 module LocoStrings
   # The XCStringsDecoder class is responsible for decoding the XCStrings file format.
   class XCStringsDecoder
-    attr_reader :language, :strings, :translations, :languages
+    attr_reader :language, :strings, :translations, :languages, :extraction_states
 
     def initialize(file_path)
       @file_path = file_path
@@ -13,6 +13,7 @@ module LocoStrings
       @translations = {}
       @languages = []
       @language = nil
+      @extraction_states = {}
     end
 
     def decode
@@ -43,9 +44,12 @@ module LocoStrings
     def decode_strings(json)
       strings = json["strings"]
       strings.each do |key, value|
+        translatable = value.fetch("shouldTranslate", true)
+        @extraction_states[key] = value["extractionState"] if value.key?("extractionState")
         val = decode_string(key, value, @language)
         @strings[key] = val if val
         @strings[key] = LocoString.new(key, key, value["comment"], "new") if val.nil?
+        @strings[key].translatable = translatable
 
         decode_translations(key, value)
       end
@@ -77,7 +81,7 @@ module LocoStrings
       plural = decode_plural(variations, comment)
       return nil if plural.empty?
 
-      variation = LocoVariantions.new(key, comment)
+      variation = LocoVariantions.new(key, nil, comment)
       plural.each do |unit|
         variation.append_string(unit)
       end

data/lib/loco_strings/encoders/xcstrings_encoder.rb

@@ -7,11 +7,12 @@ module LocoStrings
   class XCStringsEncoder
     attr_reader :language, :strings, :translations, :languages
 
-    def initialize(strings, translations, languages, language)
+    def initialize(strings, translations, languages, language, extraction_states = {})
       @strings = strings
       @translations = translations
       @languages = languages
       @language = language
+      @extraction_states = extraction_states || {}
     end
 
     def encode
@@ -40,17 +41,46 @@ module LocoStrings
 
     def encode_key(key)
       row = {}
-      @translations.each do |language, translation|
-        next unless translation.key?(key)
+      sorted_keys.each do |language|
+        process_language(row, language, key)
+      end
+      state = @extraction_states[key]
+      return row if state.nil?
 
-        value = translation[key]
-        next if value.nil?
+      # Keep Xcode's alphabetical field order: comment, extractionState, localizations, shouldTranslate.
+      ordered = {}
+      ordered["comment"] = row.delete("comment") if row.key?("comment")
+      ordered["extractionState"] = state
+      ordered.merge!(row)
+      ordered
+    end
 
-        row["comment"] = value.comment unless row.key?("comment") || value.comment.nil?
-        row["localizations"] ||= {}
-        row["localizations"][language] = encode_value(value)
-      end
-      row
+    def sorted_keys
+      @translations.keys.sort_by(&:to_s)
+    end
+
+    def process_language(row, language, key)
+      return unless @translations[language].key?(key)
+
+      value = @translations[language][key]
+      return if value.nil?
+
+      add_comment(row, value)
+      add_localization(row, language, value)
+      add_translation_flag(row, value)
+    end
+
+    def add_comment(row, value)
+      row["comment"] = value.comment unless row.key?("comment") || value.comment.nil?
+    end
+
+    def add_localization(row, language, value)
+      row["localizations"] ||= {}
+      row["localizations"][language] = encode_value(value)
+    end
+
+    def add_translation_flag(row, value)
+      row["shouldTranslate"] = false if value.translatable == false
     end
 
     def encode_value(value)

data/lib/loco_strings/parsers/xcstrings_file.rb

@@ -19,13 +19,14 @@ module LocoStrings
       @strings = decoder.strings
       @translations = decoder.translations
       @languages = decoder.languages
+      @extraction_states = decoder.extraction_states
       @strings
     end
 
     def write
       raise Error, "The base language is not defined" if @language.nil?
 
-      json = XCStringsEncoder.new(@strings, @translations, @languages, @language).encode
+      json = XCStringsEncoder.new(@strings, @translations, @languages, @language, @extraction_states || {}).encode
       File.write(@file_path, json)
     end
 
@@ -52,6 +53,10 @@ module LocoStrings
       @strings[key] = variations if @language == language
     end
 
+    def update_traslatability(key, translatable)
+      @strings[key].translatable = translatable
+    end
+
     def select_language(language)
       raise Error, "The base language is aready defined" unless @language.nil?
 
@@ -95,6 +100,7 @@ module LocoStrings
       @translations = {}
       @languages = []
       @language = nil
+      @extraction_states = {}
     end
 
     private

data/lib/loco_strings/version.rb

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

data/lib/loco_strings.rb

@@ -9,42 +9,54 @@ require_relative "loco_strings/parsers/xcstrings_file"
 module LocoStrings
   class Error < StandardError; end
 
-  LocoString = Struct.new(:key, :value, :comment, :state) do
-    def initialize(key, value, comment = nil, state = nil)
-      super
+  LocoString = Struct.new(:key, :value, :comment, :state, :translatable) do
+    def initialize(key, value, comment = nil, state = nil, translatable = nil)
+      translatable = true if translatable.nil?
+      super(key, value, comment, state, translatable)
     end
 
-    def update(value, comment = nil, state = nil)
+    def update(value, comment = nil, state = nil, translatable = nil)
       self.value = value
       self.comment = comment unless comment.nil?
       self.state = state
+      self.translatable = translatable unless translatable.nil?
     end
 
     def to_s
-      "Key: #{key}, Value: #{value}, Comment: #{comment || "None"}, State: #{state || "None"}"
+      if translatable
+        "Key: #{key}, Value: #{value}, Comment: #{comment || "None"}, " \
+          "State: #{state || "None"}"
+      else
+        "Key: #{key}, Value: #{value}, Comment: #{comment || "None"}, " \
+          "State: #{state || "None"}, Translatable: #{translatable}"
+      end
     end
   end
 
-  LocoVariantions = Struct.new(:key, :strings, :comment) do
-    def initialize(key, strings = nil, comment = nil)
-      super
-      self.strings = strings || {}
+  LocoVariantions = Struct.new(:key, :strings, :comment, :translatable) do
+    def initialize(key, strings = nil, comment = nil, translatable = nil)
+      super(key, strings || {}, comment, translatable || true)
     end
 
     def append_string(string)
       strings[string.key] = string
     end
 
-    def update_variant(key, value, comment = nil, state = nil)
+    def update_variant(key, value, comment = nil, state = nil, translatable = nil)
       if strings.key? key
-        strings[key].update(value, comment, state)
+        strings[key].update(value, comment, state, translatable)
       else
-        strings[key] = LocoString.new(key, value, comment, state)
+        strings[key] = LocoString.new(key, value, comment, state, nil, translatable)
       end
     end
 
     def to_s
-      "Key: #{key}, Strings: #{strings}, Comment: #{comment || "None"}"
+      if translatable
+        "Key: #{key}, Strings: #{strings}, Comment: #{comment || "None"}"
+      else
+        "Key: #{key}, Strings: #{strings}, Comment: #{comment || "None"}, " \
+          "Translatable: #{translatable}"
+      end
     end
   end
 

data/loco_strings.gemspec

@@ -0,0 +1,41 @@
+# 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
+  spec.metadata["rubygems_mfa_required"] = "true"
+end
+
+# rubocop:enable Layout/LineLength

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loco_strings
 version: !ruby/object:Gem::Version
-  version: 0.1.4.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Aleksei Cherepanov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-26 00:00:00.000000000 Z
+date: 2026-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -60,6 +60,7 @@ files:
 - 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:
@@ -83,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: LocoStrings is a Ruby gem for working with iOS and Android localization strings.