i18n-youdao-tasks 0.9.37

data/lib/i18n/tasks/command/commands/interpolations.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Command
+    module Commands
+      module Interpolations
+        include Command::Collection
+
+        cmd :check_consistent_interpolations,
+            pos: '[locale ...]',
+            desc: t('i18n_tasks.cmd.desc.check_consistent_interpolations'),
+            args: %i[locales out_format]
+
+        def check_consistent_interpolations(opt = {})
+          forest = i18n.inconsistent_interpolations(**opt.slice(:locales, :base_locale))
+          print_forest forest, opt, :inconsistent_interpolations
+          :exit1 unless forest.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Command
+    module Commands
+      module Meta
+        include Command::Collection
+
+        cmd :config,
+            pos: '[section ...]',
+            desc: t('i18n_tasks.cmd.desc.config')
+
+        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: t('i18n_tasks.cmd.desc.gem_path')
+
+        def gem_path
+          puts I18n::Tasks.gem_path
+        end
+
+        cmd :irb, desc: t('i18n_tasks.cmd.desc.irb')
+
+        def irb
+          require 'i18n/tasks/console_context'
+          ::I18n::Tasks::ConsoleContext.start
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/command/collection'
+
+module I18n::Tasks
+  module Command
+    module Commands
+      module Missing
+        include Command::Collection
+
+        missing_types = I18n::Tasks::MissingKeys.missing_keys_types
+        arg :missing_types,
+            '-t',
+            "--types #{missing_types * ','}",
+            Array,
+            t('i18n_tasks.cmd.args.desc.missing_types', valid: missing_types * ', '),
+            parser: OptionParsers::Enum::ListParser.new(
+              missing_types,
+              proc do |invalid, valid|
+                I18n.t('i18n_tasks.cmd.errors.invalid_missing_type',
+                       invalid: invalid * ', ', valid: valid * ', ', count: invalid.length)
+              end
+            )
+
+        cmd :missing,
+            pos: '[locale ...]',
+            desc: t('i18n_tasks.cmd.desc.missing'),
+            args: %i[locales out_format missing_types]
+
+        def missing(opt = {})
+          forest = i18n.missing_keys(**opt.slice(:locales, :base_locale, :types))
+          print_forest forest, opt, :missing_keys
+          :exit1 unless forest.empty?
+        end
+
+        cmd :translate_missing,
+            pos: '[locale ...]',
+            desc: t('i18n_tasks.cmd.desc.translate_missing'),
+            args: [:locales, :locale_to_translate_from, arg(:out_format).from(1), :translation_backend]
+
+        def translate_missing(opt = {})
+          missing    = i18n.missing_diff_forest opt[:locales], opt[:from]
+          translated = i18n.translate_forest missing, from: opt[:from], backend: opt[:backend].to_sym
+          i18n.data.merge! translated
+          log_stderr t('i18n_tasks.translate_missing.translated', count: translated.leaves.count)
+          print_forest translated, opt
+        end
+
+        cmd :add_missing,
+            pos: '[locale ...]',
+            desc: t('i18n_tasks.cmd.desc.add_missing'),
+            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.']]
+
+        # Merge base locale first, as this may affect the value for the other locales
+        def add_missing(opt = {})
+          [
+            [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])
+            i18n.data.merge! forest
+            added.merge! forest
+          end.tap do |added|
+            log_stderr t('i18n_tasks.add_missing.added', count: added.leaves.count)
+            print_forest added, opt
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Command
+    module Commands
+      module Tree
+        include Command::Collection
+        include I18n::Tasks::KeyPatternMatching
+
+        cmd :tree_translate,
+            pos: '[tree (or stdin)]',
+            desc: t('i18n_tasks.cmd.desc.tree_translate'),
+            args: [:locale_to_translate_from, arg(:data_format).from(1), :translation_backend]
+
+        def tree_translate(opts = {})
+          forest = forest_pos_or_stdin!(opts)
+          print_forest i18n.translate_forest(forest, from: opts[:from], backend: opts[:backend].to_sym), opts
+        end
+
+        cmd :tree_merge,
+            pos: '[[tree] [tree] ... (or stdin)]',
+            desc: t('i18n_tasks.cmd.desc.tree_merge'),
+            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: t('i18n_tasks.cmd.desc.tree_filter'),
+            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
+
+        arg :all_locales,
+            '-a',
+            '--all-locales',
+            t('i18n_tasks.cmd.args.desc.all_locales')
+
+        cmd :tree_mv,
+            pos: 'FROM_KEY_PATTERN TO_KEY_PATTERN [tree (or stdin)]',
+            desc: t('i18n_tasks.cmd.desc.tree_mv_key'),
+            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: t('i18n_tasks.cmd.desc.tree_subtract'),
+            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: t('i18n_tasks.cmd.desc.tree_set_value'),
+            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: t('i18n_tasks.cmd.desc.tree_convert'),
+            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/tasks/command/commands/usages.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Command
+    module Commands
+      module Usages
+        include Command::Collection
+
+        arg :strict,
+            '--[no-]strict',
+            t('i18n_tasks.cmd.args.desc.strict')
+
+        arg :keep_order,
+            '-k',
+            '--keep-order',
+            t('i18n_tasks.cmd.args.desc.keep_order')
+
+        cmd :find,
+            pos: '[pattern]',
+            desc: t('i18n_tasks.cmd.desc.find'),
+            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: t('i18n_tasks.cmd.desc.unused'),
+            args: %i[locales out_format strict]
+
+        def unused(opt = {})
+          forest = i18n.unused_keys(**opt.slice(:locales, :strict))
+          print_forest forest, opt, :unused_keys
+          :exit1 unless forest.empty?
+        end
+
+        cmd :remove_unused,
+            pos: '[locale ...]',
+            desc: t('i18n_tasks.cmd.desc.remove_unused'),
+            args: %i[locales out_format strict keep_order confirm pattern]
+
+        def remove_unused(opt = {}) # rubocop:disable Metrics/AbcSize
+          unused_keys = i18n.unused_keys(**opt.slice(:locales, :strict))
+
+          if opt[:pattern]
+            pattern_re = i18n.compile_key_pattern(opt[:pattern])
+            unused_keys = unused_keys.select_keys { |full_key, _node| full_key =~ pattern_re }
+          end
+
+          if unused_keys.present?
+            terminal_report.unused_keys(unused_keys)
+            confirm_remove_unused!(unused_keys, opt)
+            i18n.data.config = i18n.data.config.merge(sort: false) if opt[:'keep-order']
+            removed = i18n.data.remove_by_key!(unused_keys)
+            log_stderr t('i18n_tasks.remove_unused.removed', count: unused_keys.leaves.count)
+            print_forest removed, opt
+          else
+            log_stderr Rainbow(t('i18n_tasks.remove_unused.noop')).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(t('i18n_tasks.remove_unused.confirm', count: unused_keys.leaves.count, locales: locales)).red,
+            Rainbow(t('i18n_tasks.common.continue_q')).yellow,
+            Rainbow('(yes/no)').yellow
+          ].join(' ')
+          exit 1 unless agree msg
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  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, **kwargs)
+        I18n.t(*args, **kwargs)
+      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, **kwargs)
+          proc { I18n.t(*args, **kwargs) }
+        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

data/lib/i18n/tasks/command/option_parsers/enum.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Command
+    module OptionParsers
+      module Enum
+        class Parser
+          DEFAULT_ERROR = proc do |invalid, valid|
+            I18n.t('i18n_tasks.cmd.enum_opt.invalid', invalid: invalid, valid: valid * ', ')
+          end
+
+          def initialize(valid, error_message = DEFAULT_ERROR)
+            @valid         = valid.map(&:to_s)
+            @error_message = error_message
+          end
+
+          def call(value, *)
+            return @valid.first unless value.present?
+
+            if @valid.include?(value)
+              value
+            else
+              fail CommandError, @error_message.call(value, @valid)
+            end
+          end
+        end
+
+        class ListParser
+          DEFAULT_ERROR = proc do |invalid, valid|
+            I18n.t('i18n_tasks.cmd.enum_list_opt.invalid', invalid: invalid * ', ', valid: valid * ', ')
+          end
+
+          def initialize(valid, error_message = DEFAULT_ERROR)
+            @valid         = valid.map(&:to_s)
+            @error_message = error_message
+          end
+
+          def call(values, *)
+            values = Array(values)
+            return @valid if values == %w[all]
+
+            invalid = values - @valid
+            if invalid.empty?
+              if values.empty?
+                @valid
+              else
+                values
+              end
+            else
+              fail CommandError, @error_message.call(invalid, @valid)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/command/option_parsers/locale.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Command
+    module OptionParsers
+      module Locale
+        module Validator
+          VALID_LOCALE_RE = /\A\w[\w\-.]*\z/i.freeze
+
+          def validate!(locale)
+            if VALID_LOCALE_RE !~ locale
+              fail CommandError, I18n.t('i18n_tasks.cmd.errors.invalid_locale', invalid: locale)
+            end
+
+            locale
+          end
+        end
+
+        module Parser
+          module_function
+
+          extend Validator
+
+          # @param [#base_locale, #locales] context
+          def call(val, context)
+            if val.blank? || val == 'base'
+              context.base_locale
+            else
+              validate! val
+            end
+          end
+        end
+
+        module ListParser
+          module_function
+
+          extend Validator
+
+          # @param [#base_locale,#locales] context
+          def call(vals, context)
+            if vals == %w[all] || vals.blank?
+              context.locales
+            else
+              move_base_locale_to_front!(vals.map { |v| v == 'base' ? context.base_locale : v }, context.base_locale)
+            end.tap do |locales|
+              locales.each { |locale| validate! locale }
+            end
+          end
+
+          def move_base_locale_to_front!(locales, base_locale)
+            if (pos = locales.index(base_locale)) && pos.positive?
+              locales[pos], locales[0] = locales[0], locales[pos]
+            end
+            locales
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/command/options/common.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/command/dsl'
+
+module I18n::Tasks
+  module Command
+    module Options
+      module Common
+        include Command::DSL
+
+        arg :nostdin,
+            '-S',
+            '--nostdin',
+            t('i18n_tasks.cmd.args.desc.nostdin')
+
+        arg :confirm,
+            '-y',
+            '--confirm',
+            desc: t('i18n_tasks.cmd.args.desc.confirm')
+
+        arg :pattern,
+            '-p',
+            '--pattern PATTERN',
+            t('i18n_tasks.cmd.args.desc.key_pattern')
+
+        arg :value,
+            '-v',
+            '--value VALUE',
+            t('i18n_tasks.cmd.args.desc.value')
+
+        arg :config,
+            '-c',
+            '--config FILE',
+            t('i18n_tasks.cmd.args.desc.config')
+
+
+        def arg_or_pos!(key, opts)
+          opts[key] ||= opts[:arguments].try(:shift)
+        end
+
+        def pos_or_stdin!(opts)
+          opts[:arguments].try(:shift) || $stdin.read
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/command/options/data.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/command/option_parsers/enum'
+
+module I18n::Tasks
+  module Command
+    module Options
+      module Data
+        include Command::DSL
+
+        DATA_FORMATS = %w[yaml json keys].freeze
+        OUT_FORMATS  = ['terminal-table', *DATA_FORMATS, 'inspect', 'key-values'].freeze
+
+        format_arg = proc do |type, values|
+          default = values.first
+          arg type,
+              '-f',
+              '--format FORMAT',
+              values,
+              { 'yml' => 'yaml' },
+              t("i18n_tasks.cmd.args.desc.#{type}", valid_text: values * ', ', default_text: default),
+              parser: OptionParsers::Enum::Parser.new(values,
+                                                      proc do |value, valid|
+                                                        I18n.t('i18n_tasks.cmd.errors.invalid_format',
+                                                               invalid: value, valid: valid * ', ')
+                                                      end)
+        end
+
+        # i18n-tasks-use t('i18n_tasks.cmd.args.desc.data_format')
+        format_arg.call(:data_format, DATA_FORMATS)
+
+        # i18n-tasks-use t('i18n_tasks.cmd.args.desc.out_format')
+        format_arg.call(:out_format, OUT_FORMATS)
+
+        # @return [I18n::Tasks::Data::Tree::Siblings]
+        def forest_pos_or_stdin!(opt, format = opt[:format])
+          parse_forest(pos_or_stdin!(opt), format)
+        end
+
+        # @return [Array<I18n::Tasks::Data::Tree::Siblings>] trees read from stdin and positional arguments
+        def forests_stdin_and_pos!(opt, num = false, format = opt[:format])
+          args = opt[:arguments] || []
+          if opt[:nostdin]
+            sources = []
+          else
+            sources = [$stdin.read]
+            num -= 1 if num
+          end
+          if num
+            num.times { sources << args.shift }
+          else
+            sources += args
+            args.clear
+          end
+          sources.map { |src| parse_forest(src, format) }
+        end
+
+        def merge_forests_stdin_and_pos!(opt)
+          forests_stdin_and_pos!(opt).inject(i18n.empty_forest) do |result, forest|
+            result.merge! forest
+          end
+        end
+
+        # @return [I18n::Tasks::Data::Tree::Siblings]
+        def parse_forest(src, format)
+          fail CommandError, I18n.t('i18n_tasks.cmd.errors.pass_forest') unless src
+
+          if format == 'keys'
+            ::I18n::Tasks::Data::Tree::Siblings.from_key_names parse_keys(src)
+          else
+            ::I18n::Tasks::Data::Tree::Siblings.from_nested_hash i18n.data.adapter_parse(src, format)
+          end
+        end
+
+        def parse_keys(src)
+          Array(src).compact.flat_map { |v| v.strip.split(/\s*[,\s\n]\s*/) }.map(&:presence).compact
+        end
+
+        def print_forest(forest, opts, version = :show_tree)
+          format = opts[:format].to_s
+          case format
+          when 'terminal-table'
+            terminal_report.send(version, forest)
+          when 'inspect'
+            puts forest.inspect
+          when 'keys'
+            puts forest.key_names(root: true)
+          when 'key-values'
+            puts forest.key_values(root: true).map { |kv| kv.join("\t") }
+          when *DATA_FORMATS
+            puts i18n.data.adapter_dump forest.to_hash(true), format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/command/options/locales.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/command/option_parsers/locale'
+
+module I18n::Tasks
+  module Command
+    module Options
+      module Locales
+        include Command::DSL
+
+        arg :locales,
+            '-l',
+            '--locales en,es,ru',
+            Array,
+            t('i18n_tasks.cmd.args.desc.locales_filter'),
+            parser: OptionParsers::Locale::ListParser,
+            default: 'all',
+            consume_positional: true
+
+        arg :locale,
+            '-l',
+            '--locale en',
+            t('i18n_tasks.cmd.args.desc.locale'),
+            parser: OptionParsers::Locale::Parser,
+            default: 'base'
+
+        arg :locale_to_translate_from,
+            '-f',
+            '--from en',
+            t('i18n_tasks.cmd.args.desc.locale_to_translate_from'),
+            parser: OptionParsers::Locale::Parser,
+            default: 'base'
+
+        TRANSLATION_BACKENDS = %w[google deepl].freeze
+        arg :translation_backend,
+            '-b',
+            '--backend BACKEND',
+            t('i18n_tasks.cmd.args.desc.translation_backend'),
+            parser: OptionParsers::Locale::Parser,
+            default: TRANSLATION_BACKENDS[0]
+      end
+    end
+  end
+end