i18n-processes 0.1.0

data/lib/i18n/processes/command/commands/data.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+module I18n::Processes
+  module Command
+    module Commands
+      module Data
+        include Command::Collection
+
+        arg :pattern_router,
+            '-p',
+            '--pattern_router',
+            'Use pattern router: keys moved per config data.write'
+
+        cmd :normalize,
+            pos:  '[locale ...]',
+            desc: 'normalize translation data: sort and move to the right files',
+            args: %i[locales pattern_router]
+
+        def normalize(opt = {})
+          i18n.normalize_store! locales: opt[:locales],
+                                force_pattern_router: opt[:pattern_router]
+        end
+
+        cmd :check_normalized,
+            pos: '[locale ...]',
+            desc: 'verify that all translation data is normalized',
+            args: %i[locales]
+
+        def check_normalized(opt)
+          non_normalized = i18n.non_normalized_paths locales: opt[:locales]
+          terminal_report.check_normalized_results(non_normalized)
+          :exit_1 unless non_normalized.empty?
+        end
+
+        cmd :mv,
+            pos: 'FROM_KEY_PATTERN TO_KEY_PATTERN',
+            desc: 'rename/merge the keys in locale data that match the given pattern'
+        def mv(opt = {})
+          fail CommandError, 'requires FROM_KEY_PATTERN and TO_KEY_PATTERN' if opt[:arguments].size < 2
+          from_pattern = opt[:arguments].shift
+          to_pattern = opt[:arguments].shift
+          forest = i18n.data_forest
+          results = forest.mv_key!(compile_key_pattern(from_pattern), to_pattern, root: false)
+          i18n.data.write forest
+          terminal_report.mv_results results
+        end
+
+        cmd :rm,
+            pos: 'KEY_PATTERN [KEY_PATTERN...]',
+            desc: 'remove the keys in locale data that match the given pattern'
+        def rm(opt = {})
+          fail CommandError, 'requires KEY_PATTERN' if opt[:arguments].empty?
+          forest = i18n.data_forest
+          results = opt[:arguments].each_with_object({}) do |key_pattern, h|
+            h.merge! forest.mv_key!(compile_key_pattern(key_pattern), '', root: false)
+          end
+          i18n.data.write forest
+          terminal_report.mv_results results
+        end
+
+        cmd :data,
+            pos:  '[locale ...]',
+            desc: 'show locale data',
+            args: %i[locales out_format]
+
+        def data(opt = {})
+          $stderr.puts Rainbow("data from here?!")
+          print_forest i18n.data_forest(opt[:locales]), opt
+        end
+
+        cmd :data_merge,
+            pos:  '[tree ...]',
+            desc: 'merge locale data with trees',
+            args: %i[data_format nostdin]
+
+        def data_merge(opt = {})
+          forest = merge_forests_stdin_and_pos!(opt)
+          merged = i18n.data.merge!(forest)
+          print_forest merged, opt
+        end
+
+        cmd :data_write,
+            pos:  '[tree]',
+            desc: 'replace locale data with tree',
+            args: %i[data_format nostdin]
+
+        def data_write(opt = {})
+          forest = forest_pos_or_stdin!(opt)
+          i18n.data.write forest
+          print_forest forest, opt
+        end
+
+        cmd :data_remove,
+            pos:  '[tree]',
+            desc: 'remove keys present in tree from data',
+            args: %i[data_format nostdin]
+
+        def data_remove(opt = {})
+          removed = i18n.data.remove_by_key!(forest_pos_or_stdin!(opt))
+          log_stderr 'Removed:'
+          print_forest removed, opt
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/eq_base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+module I18n::Processes
+  module Command
+    module Commands
+      module EqBase
+        include Command::Collection
+
+        cmd :eq_base,
+            pos:  '[locale ...]',
+            desc: 'show translations equal to base value',
+            args: %i[locales out_format]
+
+        def eq_base(opt = {})
+          print_forest i18n.eq_base_keys(opt), opt, :eq_base_keys
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/health.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+module I18n::Processes
+  module Command
+    module Commands
+      module Health
+        include Command::Collection
+
+        cmd :health,
+            pos:  '[locale ...]',
+            desc: 'is everything OK?',
+            args: %i[locales out_format]
+
+        def health(opt = {})
+          forest = i18n.data_forest(opt[:locales])
+          stats  = i18n.forest_stats(forest)
+          fail CommandError, 'No keys detected. Check data.read in config/i18n-processes.yml.' if stats[:key_count].zero?
+          terminal_report.forest_stats forest, stats
+          $stderr.puts Rainbow("#{opt}").green
+          [missing(opt), unused(opt), check_normalized(opt)].detect { |result| result == :exit_1 }
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/meta.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+module I18n::Processes
+  module Command
+    module Commands
+      module Meta
+        include Command::Collection
+
+        cmd :config,
+            pos:  '[section ...]',
+            desc: 'display i18n-processes configuration'
+
+        def config(opts = {})
+          cfg = i18n.config_for_inspect
+          cfg = cfg.slice(*opts[:arguments]) if opts[:arguments].present?
+          cfg = cfg.to_yaml
+          cfg.sub!(/\A---\n/, '')
+          cfg.gsub!(/^([^\s-].+?:)/, Rainbow('\1').cyan.bright)
+          puts cfg
+        end
+
+        cmd :gem_path, desc: 'show path to the gem'
+
+        def gem_path
+          puts I18n::Processes.gem_path
+        end
+
+        cmd :irb, desc: 'start REPL session within i18n-processes context'
+
+        def irb
+          require 'i18n/processes/console_context'
+          ::I18n::Processes::ConsoleContext.start
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/missing.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+require 'i18n/processes/command/commands/preprocessing'
+module I18n::Processes
+  module Command
+    module Commands
+      module Missing
+        include Command::Collection
+        include Command::Commands::Preprocessing
+
+        missing_types = I18n::Processes::MissingKeys.missing_keys_types
+        arg :missing_types,
+            '-t',
+            "--types #{missing_types * ','}",
+            Array,
+            "Filter by types: #{missing_types * ', '}",
+            parser: OptionParsers::Enum::ListParser.new(
+              missing_types,
+              proc do |invalid, valid|
+                "{:one =>'invalid type: #{invalid}. valid: #{valid}.', :other =>'unknown types: #{invalid}. valid: #{valid}.'}"
+              end
+            )
+
+        cmd :missing,
+            pos:  '[locale ...]',
+            desc: 'show missing translations',
+            args: [:locales, :out_format, :missing_types, ['-p', '--path PATH', 'Destination path', default: 'tmp/missing_keys']]
+
+        def missing(opt = {})
+          translated_locales = opt[:locales].reject{|x| x == base_locale}
+          translated_locales.each do |locale|
+            $stderr.puts Rainbow("#{base_locale} to #{locale}\n").green
+            preprocessing({:locales => [locale] })
+            missing_keys = spreadsheet_report.find_missing(locale)
+            missing_count = missing_keys.count
+            if missing_count.zero?
+              spreadsheet_report.translated_files(locale)
+            else
+              $stderr.puts Rainbow("#{missing_count} keys need to be translated to #{locale}").green
+              spreadsheet_report.missing_report(locale)
+            end
+          end
+
+        end
+
+        cmd :translate_missing,
+            pos:  '[locale ...]',
+            desc: 'translate missing keys with Google Translate',
+            args: [:locales, :locale_to_translate_from, arg(:out_format).from(1)]
+
+        def translate_missing(opt = {})
+          missing    = i18n.missing_diff_forest opt[:locales], opt[:from]
+          translated = i18n.google_translate_forest missing, opt[:from]
+          i18n.data.merge! translated
+          log_stderr "Translated #{translated.leaves.count} keys"
+          print_forest translated, opt
+        end
+
+        # cmd :add_missing,
+        #     pos:  '[locale ...]',
+        #     desc: 'add missing keys to locale data',
+        #     args: [:locales, :out_format, arg(:value) + [{ default: '%{value_or_default_or_human_key}' }],
+        #            ['--nil-value', 'Set value to nil. Takes precedence over the value argument.']]
+
+        # def add_missing(opt = {}) # rubocop:disable Metrics/AbcSize
+        #   [ # Merge base locale first, as this may affect the value for the other locales
+        #     [i18n.base_locale] & opt[:locales],
+        #     opt[:locales] - [i18n.base_locale]
+        #   ].reject(&:empty?).each_with_object(i18n.empty_forest) do |locales, added|
+        #     forest = i18n.missing_keys(locales: locales, **opt.slice(:types, :base_locale))
+        #                  .set_each_value!(opt[:'nil-value'] ? nil : opt[:value])
+        #
+        #     # call method I18n::Processes::Data::FileSystemBase merge! to generate file
+        #     i18n.data.merge! forest
+        #     # call method I18n::Processes::Data::Tree::Nodes::Siblings merge! to generate file
+        #     added.merge! forest
+        #   end.tap do |added|
+        #     log_stderr "{:one => 'Added #{added.leaves.count} key', :other => 'Added #{added.leaves.count} keys'}"
+        #     print_forest added, opt
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/preprocessing.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+require 'i18n/processes/path'
+require 'fileutils'
+
+module I18n::Processes
+  module Command
+    module Commands
+      module Preprocessing
+        include Command::Collection
+        include Path
+
+        cmd :preprocessing,
+            pos:  '[locale...]',
+            desc: 'preprocess origin data files into primitive files with key=value format',
+            args: %i[locales out_format]
+
+        def preprocessing(opt = {})
+          locale = opt[:locales].include?(base_locale) ? 'zh-CN' : opt[:locales].first
+          dic = {}
+          origin_files(locale).flatten.each do |file|
+            # dic.merge!(origin_file_read(file)) { |key, v1, v2| fail "conflict: #{key}: #{v1}, #{v2} in #{file}" unless v1 == v2 }
+            dic.merge!(origin_file_read(file))
+          end
+          ## 对比文件默认存储路径
+          path = 'tmp/'
+          keys_source(dic, path, locale)
+          $stderr.puts Rainbow('preprocess origin data files into primitive files successfully').green if locale == base_locale
+        end
+
+
+        def origin_file_read(file)
+          {}.tap do |a|
+            File.open(file).read.each_line do |line|
+              next if line =~ /^#/ || line == "\n" || !line.include?('.')
+              if line.include?('\':')
+                line.gsub!(/'|,/, '')
+                key = line.split(': ').first.delete(' ')
+                value = line.split(': ').last
+              else
+                key = line.split('=').first.delete(' ')
+                value = line.split('=').last
+              end
+              a[key] = value
+            end
+          end
+        end
+
+        def keys_source(dic, path, locale)
+          filename = path + locale
+          previous_file = "#{path}pre_#{locale}"
+          File.delete(previous_file) if File.exist?(previous_file)
+          File.rename(filename, previous_file) if File.exist?(filename)
+          local_file = File.new(filename, 'w')
+          dic.map do |key, value|
+            value.include?("\n") ? local_file.write("#{key}=#{value}") : local_file.write("#{key}=#{value}\n")
+          end
+          local_file.close
+          changed_keys(previous_file, filename) if File.exist?(previous_file) && locale == base_locale
+        end
+
+        def changed_keys(previous, current)
+          previous_dic = get_dic(previous)
+          current_dic = get_dic(current)
+          diff = current_dic.merge(previous_dic){|k, v1, v2| {:current => v1, :previous => v2} unless v1 == v2 }
+          diff.select!{ |k, v| v.is_a?(Hash)}
+          print_changed_keys(diff) unless diff == {}
+          changed_keys_save(diff) unless diff == {}
+        end
+
+        def changed_keys_save(diff)
+          file = 'tmp/changed_keys/changed_keys'
+          FileUtils::mkdir_p File.dirname(file) unless Dir.exist?File.dirname(file)
+          changed_keys = File.new(file, 'w')
+          diff.each do |k, v|
+            changed_keys.write "key: #{k}\n"
+            changed_keys.write "current: #{v[:current]}"
+            changed_keys.write "previous: #{v[:previous]}"
+            changed_keys.write "\n"
+          end
+          changed_keys.close
+          log_warn("need to update #{diff.count} keys' translation")
+          log_warn("changed_keys save to #{file}")
+        end
+
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/tree.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+module I18n::Processes
+  module Command
+    module Commands
+      module Tree
+        include Command::Collection
+        include I18n::Processes::KeyPatternMatching
+
+        cmd :tree_translate,
+            pos:  '[tree (or stdin)]',
+            desc: 'Google Translate a tree to root locales',
+            args: [:locale_to_translate_from, arg(:data_format).from(1)]
+
+        def tree_translate(opts = {})
+          forest = forest_pos_or_stdin!(opts)
+          print_forest i18n.google_translate_forest(forest, opts[:from]), opts
+        end
+
+        cmd :tree_merge,
+            pos:  '[[tree] [tree] ... (or stdin)]',
+            desc: 'merge trees',
+            args: %i[data_format nostdin]
+
+        def tree_merge(opts = {})
+          print_forest merge_forests_stdin_and_pos!(opts), opts
+        end
+
+        cmd :tree_filter,
+            pos:  '[pattern] [tree (or stdin)]',
+            desc: 'filter tree by key pattern',
+            args: %i[data_format pattern]
+
+        def tree_filter(opts = {})
+          pattern = arg_or_pos! :pattern, opts
+          forest  = forest_pos_or_stdin! opts
+          unless pattern.blank?
+            pattern_re = i18n.compile_key_pattern(pattern)
+            forest     = forest.select_keys { |full_key, _node| full_key =~ pattern_re }
+          end
+          print_forest forest, opts
+        end
+
+        cmd :tree_rename_key,
+            pos:  'KEY_PATTERN NAME [tree (or stdin)]',
+            desc: 'rename tree node',
+            args: [['-k', '--key KEY_PATTERN', 'Full key (pattern) to rename. Required'],
+                   ['-n', '--name NAME', 'New name, interpolates original name as %{key}. Required'],
+                   :data_format]
+
+        def tree_rename_key(opt = {})
+          warn_deprecated 'Use tree-mv instead.'
+          key    = arg_or_pos! :key, opt
+          name   = arg_or_pos! :name, opt
+          forest = forest_pos_or_stdin! opt
+          fail CommandError, 'pass full key to rename (-k, --key)' if key.blank?
+          fail CommandError, 'pass new name (-n, --name)' if name.blank?
+          forest.rename_each_key!(key, name)
+          print_forest forest, opt
+        end
+
+        arg :all_locales,
+            '-a',
+            '--all-locales',
+            'Do not expect key patterns to start with a locale, instead apply them to all locales implicitly.'
+
+        cmd :tree_mv,
+            pos: 'FROM_KEY_PATTERN TO_KEY_PATTERN [tree (or stdin)]',
+            desc: 'rename/merge/remove the keys matching the given pattern',
+            args: %i[data_format all_locales]
+        def tree_mv(opt = {})
+          fail CommandError, 'requires FROM_KEY_PATTERN and TO_KEY_PATTERN' if opt[:arguments].size < 2
+          from_pattern = opt[:arguments].shift
+          to_pattern = opt[:arguments].shift
+          forest = forest_pos_or_stdin!(opt)
+          forest.mv_key!(compile_key_pattern(from_pattern), to_pattern, root: !opt[:'all-locales'])
+          print_forest forest, opt
+        end
+
+        cmd :tree_subtract,
+            pos:  '[[tree] [tree] ... (or stdin)]',
+            desc: 'tree A minus the keys in tree B',
+            args: %i[data_format nostdin]
+
+        def tree_subtract(opt = {})
+          forests = forests_stdin_and_pos! opt, 2
+          forest  = forests.reduce(:subtract_by_key) || empty_forest
+          print_forest forest, opt
+        end
+
+        cmd :tree_set_value,
+            pos:  '[VALUE] [tree (or stdin)]',
+            desc: 'set values of keys, optionally match a pattern',
+            args: %i[value data_format nostdin pattern]
+
+        def tree_set_value(opt = {})
+          value       = arg_or_pos! :value, opt
+          forest      = forest_pos_or_stdin!(opt)
+          key_pattern = opt[:pattern]
+          fail CommandError, 'pass value (-v, --value)' if value.blank?
+          forest.set_each_value!(value, key_pattern)
+          print_forest forest, opt
+        end
+
+        cmd :tree_convert,
+            pos:  '[tree (or stdin)]',
+            desc: 'convert tree between formats',
+            args: [arg(:data_format).dup.tap { |a| a[0..1] = ['-f', '--from FORMAT'] },
+                   arg(:out_format).dup.tap { |a| a[0..1] = ['-t', '--to FORMAT'] }]
+
+        def tree_convert(opt = {})
+          forest = forest_pos_or_stdin! opt.merge(format: opt[:from])
+          print_forest forest, opt.merge(format: opt[:to])
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/usages.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+module I18n::Processes
+  module Command
+    module Commands
+      module Usages
+        include Command::Collection
+
+        arg :strict,
+            '--[no-]strict',
+            'Avoid inferring dynamic key usages such as t("cats.#{cat}.name"). Takes precedence over the config setting if set.'
+
+        cmd :find,
+            pos:  '[pattern]',
+            desc: 'show where keys are used in the code',
+            args: %i[out_format pattern strict]
+
+        def find(opt = {})
+          opt[:filter] ||= opt.delete(:pattern) || opt[:arguments].try(:first)
+          result = i18n.used_tree(strict: opt[:strict], key_filter: opt[:filter].presence, include_raw_references: true)
+          print_forest result, opt, :used_keys
+        end
+
+        cmd :unused,
+            pos:  '[locale ...]',
+            desc: 'show unused translations',
+            args: %i[locales out_format strict]
+
+        def unused(opt = {})
+          forest = i18n.unused_keys(opt.slice(:locales, :strict))
+          print_forest forest, opt, :unused_keys
+          :exit_1 unless forest.empty?
+        end
+
+        cmd :remove_unused,
+            pos:  '[locale ...]',
+            desc: 'remove unused keys',
+            args: %i[locales out_format strict confirm]
+
+        def remove_unused(opt = {})
+          unused_keys = i18n.unused_keys(opt.slice(:locales, :strict))
+          if unused_keys.present?
+            terminal_report.unused_keys(unused_keys)
+            confirm_remove_unused!(unused_keys, opt)
+            removed = i18n.data.remove_by_key!(unused_keys)
+            log_stderr "Removed #{unused_keys.leaves.count} keys"
+            print_forest removed, opt
+          else
+            log_stderr Rainbow("No unused keys to remove").green.bright
+          end
+        end
+
+        private
+
+        def confirm_remove_unused!(unused_keys, opt)
+          return if ENV['CONFIRM'] || opt[:confirm]
+          locales = Rainbow(unused_keys.flat_map { |root| root.key.split('+') }.sort.uniq * ', ').bright
+          msg     = [
+            Rainbow("{:one =>'#{unused_keys.leaves.count} translation will be removed from #{locales}.', :other =>'#{unused_keys.leaves.count} translation will be removed from #{locales}.'}").red,
+            Rainbow("Continue?").yellow,
+            Rainbow('(yes/no)').yellow
+          ].join(' ')
+          exit 1 unless agree msg
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/commands/xlsx.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/collection'
+module I18n::Processes
+  module Command
+    module Commands
+      module XLSX
+        include Command::Collection
+
+        cmd :xlsx_report,
+            pos:  '[locale...]',
+            desc: 'save missing and unused translations to an Excel file',
+            args: [:locales,
+                   ['-p', '--path PATH', 'Destination path', default: 'tmp/i18n-report.xlsx']]
+
+        def xlsx_report(opt = {})
+          begin
+            require 'axlsx'
+          rescue LoadError
+            message = %(For spreadsheet report please add axlsx gem to Gemfile:\ngem 'axlsx', '~> 2.0')
+            log_stderr Rainbow(message).red.bright
+            exit 1
+          end
+          spreadsheet_report.save_report opt[:path], opt.except(:path)
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/command/dsl.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module Command
+    module DSL
+      def self.included(base)
+        base.module_eval do
+          @dsl = Hash.new { |h, k| h[k] = {} }
+          extend ClassMethods
+        end
+      end
+
+      def t(*args)
+        I18n.t(*args)
+      end
+
+      module ClassMethods
+        def cmd(name, conf = nil)
+          if conf
+            conf        = conf.dup
+            conf[:args] = (conf[:args] || []).map { |arg| arg.is_a?(Symbol) ? arg(arg) : arg }
+            dsl(:cmds)[name] = conf
+          else
+            dsl(:cmds)[name]
+          end
+        end
+
+        def arg(ref, *args)
+          if args.present?
+            dsl(:args)[ref] = args
+          else
+            dsl(:args)[ref]
+          end
+        end
+
+        def cmds
+          dsl(:cmds)
+        end
+
+        def dsl(key)
+          @dsl[key]
+        end
+
+        # late-bound I18n.t for module bodies
+        def t(*args)
+          proc { I18n.t(*args) }
+        end
+
+        # if class is a module, merge DSL definitions when it is included
+        def included(base)
+          base.instance_variable_get(:@dsl).deep_merge!(@dsl)
+        end
+      end
+    end
+  end
+end