sync-strings 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 173b46f90fc054e72d5c6232cf60e6c64cf8fa8f1f5b060ca6597eccc08268ca
+  data.tar.gz: 337b2fcd5fe8d8a0f75ef61c712d15dcb7d202455c87165ab0bdb9d9c0bb90ff
+SHA512:
+  metadata.gz: 3e37f09832ecbc46081bba33532e880498b4afa6060327459954747c9fa27772406f36054df76916f31b3a8eb04e4c195b11f484f3b107e72ecae7a720293acd
+  data.tar.gz: d667b9ccb9b2ec15ba22990330d460a2f9bd000937b2deb4bec6302603d942d210672c021ea600669083610e94d0bfe4ab86f4b3566c19e565d23ead0c263039

data/bin/sync-strings

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'sync-strings'
+require 'optparse'
+
+@options = {}
+
+option_parser = OptionParser.new do |parser|
+    parser.banner = "Usage: sync-string [paths]"
+    parser.on("-c", "--copy-mismatched-keys-as-values", "Copy Mismatched keys as values") do
+        @options[:copy_mismatched_keys_as_values] = true
+    end
+    parser.on("-s", "--scan[=PATH]", "Recursively scan for localization files relative to the current working directory") do |path|
+        @options[:scan] = true
+        if !path.nil?
+            @options[:scan_path] = path
+        end
+    end
+    parser.on("--paths x,y,z", Array, "Recursively scan for localization files relative to the current working directory") do |path_list|
+        @options[:path_list] = path_list
+    end
+    parser.on("--ignore x,y,z", Array, "When scanning, ignore paths containing these strings e.g. --ignore \"Pods/\",\"Carthage/\",\".build/\"") do |ignore_list|
+        @options[:ignore_list] = ignore_list
+    end
+    parser.on("-h", "--help", "Print the help menu") do
+        puts parser
+        exit
+    end
+end.parse!
+
+if @options[:scan]
+    files = StringFileFinder.new.find(@options[:scan_path] || Dir.pwd, @options[:ignore_list])
+
+    files.each { |group|
+        if group.length == 1
+            puts "Warning. Found a localization file with no matching translations #{group[0]}"
+        end
+    }
+elsif @options[:path_list] 
+    files = [@options[:path_list]]
+else
+    puts "No files to synchronize. Either pass files using --paths=x,y,z or use --scan."
+    exit
+end
+
+puts "Starting synchronization"
+puts "----------------------"
+
+for groupIndex in 0 ... files.length do
+    for i in 1 ... files[groupIndex].length do
+        synchronizer = Synchronizer.new(files[groupIndex][i - 1], files[groupIndex][i])
+
+        synchronizer.print_stats
+
+        if @options[:copy_mismatched_keys_as_values]
+            synchronizer.sync()
+        elsif synchronizer.key_differences?
+            raise "Missing translations for keys: #{synchronizer.key_differences}"
+        end
+        
+        puts "Done. Writing to file."
+        synchronizer.write()
+        puts "----------------------"
+    end
+end
+
+puts "Done synchronizing #{files.reduce(0) { |acc, curr| acc += curr.length}} files."

data/lib/sync-strings.rb

@@ -0,0 +1,130 @@
+require 'apfel'
+
+class HashStringFileWriter
+    def write(hash, to_filename)
+        file_format = file_format(hash)
+        File.open(to_filename,"w") do |file|
+            file.puts file_format
+        end
+    end
+
+    private
+
+    def file_format(hash)
+        hash
+            .filter { |key, value| 
+                !key.nil? && !key.empty?
+            }
+            .map { |key, value|
+                "\"#{key}\" = \"#{value}\";"
+            }
+            .sort
+    end
+end
+
+class Synchronizer
+    def initialize(a_filename, b_filename)
+        @a_filename = a_filename
+        @b_filename = b_filename
+
+        @a_hash = Apfel.parse(@a_filename).to_hash(with_comments: false)
+        @b_hash = Apfel.parse(@b_filename).to_hash(with_comments: false)
+
+        @a_subtract_b = difference(@a_hash, @b_hash)
+        @b_subtract_a = difference(@b_hash, @a_hash)
+    end
+
+    def print_stats()
+        puts "File A: #{@a_filename}"
+        puts "File B: #{@b_filename}"
+        puts "A - B = #{@a_subtract_b.length}"
+        puts "B - A = #{@b_subtract_a.length}"
+    end
+
+    def key_differences()
+        @a_subtract_b + @b_subtract_a
+    end
+
+    def key_differences?()
+        !@a_subtract_b.empty? || !@b_subtract_a.empty?
+    end
+
+    def sync()
+        add(@b_subtract_a, @a_hash)
+        add(@a_subtract_b, @b_hash)
+    end
+
+    def write()
+        writer = HashStringFileWriter.new
+        writer.write(@a_hash, @a_filename)
+        writer.write(@b_hash, @b_filename)
+    end
+
+    private
+
+    def difference(hash, subtracting_hash)
+        keys = hash.keys
+        subtracting_keys = subtracting_hash.keys
+        return keys.difference(subtracting_keys)
+    end
+
+    def add(keys, into_hash)
+        keys.each { |key|
+            into_hash[key] = key
+        }
+    end
+end
+
+require 'find'
+
+class StringFileFinder
+    def find(dir, ignore_list)
+        paths = []
+        ignore_list = ignore_list || []
+
+        Find.find(dir) do |path|
+            paths << path if path =~ /.*\.strings$/ && ignore_list.none? { |ignore| path.include? ignore }
+        end
+    
+        def split_path(path)
+            path.split(File::SEPARATOR).reject(&:empty?)
+        end
+
+        paths_hashed_by_base_path = paths.reduce({}) { |acc, path|
+            base_path = split_path(path)[0...-2].join("/")
+
+            if acc.key?(base_path)
+                acc[base_path].push(path)
+            elsif
+                acc[base_path] = [path]
+            end
+    
+            acc 
+        }
+    
+        paths_by_length_and_name = []
+        paths_hashed_by_base_path.each { |key, same_length_paths|
+            same_name = []
+            same_length_paths.each { |same_length_path|
+                i = same_name.index { |array| 
+                    array.any? { |v|
+                        name = split_path(v).last
+                        same_length_path_name = split_path(same_length_path).last
+                        name == same_length_path_name
+                    }
+                }
+                if i.nil?
+                    same_name.push([same_length_path])
+                elsif
+                    same_name[i].push(same_length_path)
+                end        
+            }
+    
+            same_name.each{ |entry| 
+                paths_by_length_and_name.push(entry)
+            }
+        }
+
+        paths_by_length_and_name
+    end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: sync-strings
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Nico Richard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: apfel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+description: Adds missing values between .strings files then sorts and filters the
+  result so that line numbers always match between your languages.
+email: nicorichard@gmail.com
+executables:
+- sync-strings
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/sync-strings
+- lib/sync-strings.rb
+homepage: https://rubygems.org/gems/sync-strings
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Synchronize Xcode .strings files
+test_files: []