i18n-tasks 0.7.13 → 0.8.0

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

@@ -1,6 +1,6 @@
 require 'i18n/tasks/command/options/common'
 require 'i18n/tasks/command/options/locales'
-require 'i18n/tasks/command/options/trees'
+require 'i18n/tasks/command/options/data'
 
 module I18n::Tasks
   module Command
@@ -10,7 +10,7 @@ module I18n::Tasks
           include Command::DSL
           include Command::Options::Common
           include Command::Options::Locales
-          include Command::Options::Trees
+          include Command::Options::Data
         end
       end
     end

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

@@ -1,5 +1,5 @@
 # coding: utf-8
-require 'i18n/tasks/slop_command'
+require 'i18n/tasks/cli'
 require 'i18n/tasks/reports/terminal'
 require 'i18n/tasks/reports/spreadsheet'
 
@@ -12,29 +12,13 @@ module I18n::Tasks
         @i18n = i18n
       end
 
-      def safe_run(name, opts)
-        begin
-          coloring_was             = Term::ANSIColor.coloring?
-          Term::ANSIColor.coloring = ENV['I18N_TASKS_COLOR'] || STDOUT.isatty
-          run name, opts
-        rescue CommandError => e
-          log_error e.message
-          log_verbose e.backtrace * "\n"
-          exit 78
-        ensure
-          Term::ANSIColor.coloring = coloring_was
-        end
-      end
-
       def run(name, opts = {})
         name = name.to_sym
         public_name = name.to_s.tr '_', '-'
-        SlopCommand.parse_opts! opts, self.class.cmds[name][:opt], self
-        if opts.empty?
-          log_verbose "run #{public_name} without arguments"
+        log_verbose "task: #{public_name}(#{opts.map { |k, v| "#{k}: #{v.inspect}" } * ', '})"
+        if opts.empty? || method(name).arity.zero?
           send name
         else
-          log_verbose "run #{public_name} with #{opts.map { |k, v| "#{k}=#{v}" } * ' '}"
           send name, opts
         end
       end
@@ -53,15 +37,11 @@ module I18n::Tasks
         @spreadsheet_report ||= I18n::Tasks::Reports::Spreadsheet.new(i18n)
       end
 
-      def desc(name)
-        self.class.cmds.try(:[], name).try(:desc)
-      end
-
       def i18n
         @i18n ||= I18n::Tasks::BaseTask.new
       end
 
-      delegate :base_locale, :t, to: :i18n
+      delegate :base_locale, :locales, :t, to: :i18n
     end
   end
 end

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

@@ -4,60 +4,58 @@ module I18n::Tasks
       module Data
         include Command::Collection
 
-        cmd_opt :pattern_router, {
-            short: :p,
-            long:  :pattern_router,
-            desc: t('i18n_tasks.cmd.args.desc.pattern_router'),
-            conf:  {argument: false, optional: true}
-        }
+        arg :pattern_router,
+            '-p',
+            '--pattern_router',
+            t('i18n_tasks.cmd.args.desc.pattern_router')
 
         cmd :normalize,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.normalize'),
-            opt:  cmd_opts(:locales, :pattern_router)
+            args: [:locales, :pattern_router]
 
         def normalize(opt = {})
           i18n.normalize_store! opt[:locales], opt[:pattern_router]
         end
 
         cmd :data,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.data'),
-            opt:  cmd_opts(:locales, :out_format)
+            args: [:locales, :out_format]
 
         def data(opt = {})
           print_forest i18n.data_forest(opt[:locales]), opt
         end
 
         cmd :data_merge,
-            args: '[tree ...]',
+            pos:  '[tree ...]',
             desc: t('i18n_tasks.cmd.desc.data_merge'),
-            opt:  cmd_opts(:data_format, :nostdin)
+            args: [:data_format, :nostdin]
 
         def data_merge(opt = {})
-          forest = opt_forests_merged_stdin_args!(opt)
+          forest = merge_forests_stdin_and_pos!(opt)
           merged = i18n.data.merge!(forest)
           print_forest merged, opt
         end
 
         cmd :data_write,
-            args: '[tree]',
+            pos:  '[tree]',
             desc: t('i18n_tasks.cmd.desc.data_write'),
-            opt:  cmd_opts(:data_format, :nostdin)
+            args: [:data_format, :nostdin]
 
         def data_write(opt = {})
-          forest = opt_forest_arg_or_stdin!(opt)
+          forest = forest_pos_or_stdin!(opt)
           i18n.data.write forest
           print_forest forest, opt
         end
 
         cmd :data_remove,
-            args: '[tree]',
+            pos:  '[tree]',
             desc: t('i18n_tasks.cmd.desc.data_remove'),
-            opt:  cmd_opts(:data_format, :nostdin)
+            args: [:data_format, :nostdin]
 
         def data_remove(opt = {})
-          removed = i18n.data.remove_by_key!(opt_forest_arg_or_stdin!(opt))
+          removed = i18n.data.remove_by_key!(forest_pos_or_stdin!(opt))
           log_stderr 'Removed:'
           print_forest removed, opt
         end

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

@@ -5,9 +5,9 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :eq_base,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.eq_base'),
-            opt:  cmd_opts(:locales, :out_format)
+            args: [:locales, :out_format]
 
         def eq_base(opt = {})
           print_forest i18n.eq_base_keys(opt), opt, :eq_base_keys

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

@@ -5,9 +5,9 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :health,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.health'),
-            opt:  cmd_opts(:locales, :out_format)
+            args: [:locales, :out_format]
 
         def health(opt = {})
           forest = i18n.data_forest(opt[:locales])

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

@@ -5,12 +5,12 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :config,
-            args: '[section ...]',
+            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]
+          cfg = cfg.slice(*opts[:arguments]) if opts[:arguments].present?
           cfg = cfg.to_yaml
           cfg.sub! /\A---\n/, ''
           cfg.gsub! /^([^\s-].+?:)/, Term::ANSIColor.cyan(Term::ANSIColor.bold('\1'))

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

@@ -4,25 +4,30 @@ module I18n::Tasks
       module Missing
         include Command::Collection
 
-        enum_opt :missing_types, I18n::Tasks::MissingKeys.missing_keys_types
-        cmd_opt :missing_types, enum_list_opt_attr(
-            :t, :types=, enum_opt(:missing_types),
-            proc { |valid, default| t('i18n_tasks.cmd.args.desc.missing_types', valid: valid, default: default) },
-            proc { |invalid, valid| t('i18n_tasks.cmd.errors.invalid_missing_type', invalid: invalid * ', ', valid: valid * ', ', count: invalid.length) })
+        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 { |invalid, valid| I18n.t('i18n_tasks.cmd.errors.invalid_missing_type',
+                                               invalid: invalid * ', ', valid: valid * ', ', count: invalid.length) })
 
         cmd :missing,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.missing'),
-            opt:  cmd_opts(:locales, :out_format, :missing_types)
+            args: [:locales, :out_format, :missing_types]
 
         def missing(opt = {})
           print_forest i18n.missing_keys(opt), opt, :missing_keys
         end
 
         cmd :translate_missing,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.translate_missing'),
-            opt:  cmd_opts(:locales, :locale_to_translate_from) << cmd_opt(:out_format).except(:short)
+            args: [:locales, :locale_to_translate_from, arg(:out_format).from(1)]
 
         def translate_missing(opt = {})
           missing    = i18n.missing_diff_forest opt[:locales], opt[:from]
@@ -32,17 +37,19 @@ module I18n::Tasks
           print_forest translated, opt
         end
 
-        DEFAULT_ADD_MISSING_VALUE = '%{value_or_human_key}'
-
         cmd :add_missing,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.add_missing'),
-            opt:  cmd_opts(:locales, :out_format) <<
-                      cmd_opt(:value).merge(desc: proc { "#{cmd_opt(:value)[:desc].call}. #{t('i18n_tasks.cmd.args.default_text', value: DEFAULT_ADD_MISSING_VALUE)}" })
+            args: [:locales, :out_format, arg(:value) + [{default: '%{value_or_human_key}'}]]
 
         def add_missing(opt = {})
-          forest = i18n.missing_keys(opt).set_each_value!(opt[:value] || DEFAULT_ADD_MISSING_VALUE)
+          forest = i18n.missing_keys(opt).set_each_value!(opt[:value])
           i18n.data.merge! forest
+          # missing keys detected in the source are only returned in the base locale tree
+          # merge again in case such keys have been added to add them to other locales
+          forest_2 = i18n.missing_keys(opt).set_each_value!(opt[:value])
+          i18n.data.merge! forest_2
+          forest.merge! forest_2
           log_stderr t('i18n_tasks.add_missing.added', count: forest.leaves.count)
           print_forest forest, opt
         end

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

@@ -5,54 +5,50 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :tree_translate,
-            args: '[tree]',
+            pos:  '[tree (or stdin)]',
             desc: t('i18n_tasks.cmd.desc.tree_translate'),
-            opt:  cmd_opts(:locale_to_translate_from) << cmd_opt(:data_format).except(:short)
+            args: [:locale_to_translate_from, arg(:data_format).from(1)]
 
         def tree_translate(opts = {})
-          forest     = opt_forest_arg_or_stdin!(opts)
-          from       = opts[:from]
-          translated = i18n.google_translate_forest(forest, from)
-          print_forest translated, opts
+          forest = forest_pos_or_stdin!(opts)
+          print_forest i18n.google_translate_forest(forest, opts[:from]), opts
         end
 
         cmd :tree_merge,
-            args: '[tree ...]',
+            pos:  '[[tree] [tree] ... (or stdin)]',
             desc: t('i18n_tasks.cmd.desc.tree_merge'),
-            opt:  cmd_opts(:data_format, :nostdin)
+            args: [:data_format, :nostdin]
 
         def tree_merge(opts = {})
-          print_forest opt_forests_merged_stdin_args!(opts), opts
+          print_forest merge_forests_stdin_and_pos!(opts), opts
         end
 
         cmd :tree_filter,
-            args: '[pattern] [tree]',
+            pos:  '[pattern] [tree (or stdin)]',
             desc: t('i18n_tasks.cmd.desc.tree_filter'),
-            opt:  cmd_opts(:data_format, :pattern)
+            args: [:data_format, :pattern]
 
-        def tree_filter(opt = {})
-          pattern = opt_or_arg! :pattern, opt
-          forest  = opt_forest_arg_or_stdin!(opt)
+        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, opt
+          print_forest forest, opts
         end
 
         cmd :tree_rename_key,
-            args: '<key> <name> [tree]',
+            pos:  'KEY_PATTERN NAME [tree (or stdin)]',
             desc: t('i18n_tasks.cmd.desc.tree_rename_key'),
-            opt:  [cmd_opt(:pattern).merge(short: :k, long: :key=,
-                                           desc:  t('i18n_tasks.cmd.args.desc.key_pattern_to_rename')),
-                   cmd_opt(:pattern).merge(short: :n, long: :name=,
-                                           desc:  t('i18n_tasks.cmd.args.desc.new_key_name')),
-                   *cmd_opts(:data_format)]
+            args: [['-k', '--key KEY_PATTERN', t('i18n_tasks.cmd.args.desc.key_pattern_to_rename')],
+                   ['-n', '--name NAME', t('i18n_tasks.cmd.args.desc.new_key_name')],
+                   :data_format]
 
         def tree_rename_key(opt = {})
-          key    = opt_or_arg! :key, opt
-          name   = opt_or_arg! :name, opt
-          forest = opt_forest_arg_or_stdin! opt
+          key    = arg_or_pos! :key, opt
+          name   = arg_or_pos! :name, opt
+          forest = forest_pos_or_stdin! opt
           raise CommandError.new('pass full key to rename (-k, --key)') if key.blank?
           raise CommandError.new('pass new name (-n, --name)') if name.blank?
           forest.rename_each_key!(key, name)
@@ -60,24 +56,24 @@ module I18n::Tasks
         end
 
         cmd :tree_subtract,
-            args: '[tree A] [tree B ...]',
+            pos:  '[[tree] [tree] ... (or stdin)]',
             desc: t('i18n_tasks.cmd.desc.tree_subtract'),
-            opt:  cmd_opts(:data_format, :nostdin)
+            args: [:data_format, :nostdin]
 
         def tree_subtract(opt = {})
-          forests = opt_forests_stdin_args! opt, 2
+          forests = forests_stdin_and_pos! opt, 2
           forest  = forests.reduce(:subtract_by_key) || empty_forest
           print_forest forest, opt
         end
 
         cmd :tree_set_value,
-            args: '[value] [tree]',
+            pos:  '[VALUE] [tree (or stdin)]',
             desc: t('i18n_tasks.cmd.desc.tree_set_value'),
-            opt:  cmd_opts(:value, :data_format, :nostdin, :pattern)
+            args: [:value, :data_format, :nostdin, :pattern]
 
         def tree_set_value(opt = {})
-          value       = opt_or_arg! :value, opt
-          forest      = opt_forest_arg_or_stdin!(opt)
+          value       = arg_or_pos! :value, opt
+          forest      = forest_pos_or_stdin!(opt)
           key_pattern = opt[:pattern]
           raise CommandError.new('pass value (-v, --value)') if value.blank?
           forest.set_each_value!(value, key_pattern)
@@ -85,13 +81,13 @@ module I18n::Tasks
         end
 
         cmd :tree_convert,
-            args: '<tree>',
+            pos:  '[tree (or stdin)]',
             desc: t('i18n_tasks.cmd.desc.tree_convert'),
-            opt:  [cmd_opt(:data_format).merge(short: :f, long: :from=),
-                   cmd_opt(:out_format).merge(short: :t, long: :to=)]
+            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 = opt_forest_arg_or_stdin! opt.merge(format: opt[:from])
+          forest = forest_pos_or_stdin! opt.merge(format: opt[:from])
           print_forest forest, opt.merge(format: opt[:to])
         end
       end

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

@@ -4,16 +4,15 @@ module I18n::Tasks
       module Usages
         include Command::Collection
 
-        cmd_opt :strict, {
-            short: :s,
-            long:  :strict,
-            desc:  t('i18n_tasks.cmd.args.desc.strict')
-        }
+        arg :strict,
+            '-s',
+            '--strict',
+            t('i18n_tasks.cmd.args.desc.strict')
 
         cmd :find,
-            args: '[pattern]',
+            pos:  '[pattern]',
             desc: t('i18n_tasks.cmd.desc.find'),
-            opt:  cmd_opts(:out_format, :pattern)
+            args: [:out_format, :pattern]
 
         def find(opt = {})
           opt[:filter] ||= opt.delete(:pattern) || opt[:arguments].try(:first)
@@ -21,18 +20,18 @@ module I18n::Tasks
         end
 
         cmd :unused,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.unused'),
-            opt:  cmd_opts(:locales, :out_format, :strict)
+            args: [:locales, :out_format, :strict]
 
         def unused(opt = {})
           print_forest i18n.unused_keys(opt), opt, :unused_keys
         end
 
         cmd :remove_unused,
-            args: '[locale ...]',
+            pos:  '[locale ...]',
             desc: t('i18n_tasks.cmd.desc.remove_unused'),
-            opt:  cmd_opts(:locales, :out_format, :strict, :confirm)
+            args: [:locales, :out_format, :strict, :confirm]
 
         def remove_unused(opt = {})
           unused_keys = i18n.unused_keys(opt)

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

@@ -5,10 +5,10 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :xlsx_report,
-            args: '[locale...]',
+            pos:  '[locale...]',
             desc: t('i18n_tasks.cmd.desc.xlsx_report'),
-            opt:  [cmd_opt(:locales),
-                   {short: :p, long: :path=, desc: 'Destination path', conf: {default: 'tmp/i18n-report.xlsx'}}]
+            args: [:locales,
+                   ['-p', '--path PATH', 'Destination path', default: 'tmp/i18n-report.xlsx']]
 
         def xlsx_report(opt = {})
           begin

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

@@ -1,7 +1,3 @@
-require 'i18n/tasks/command/dsl/cmd'
-require 'i18n/tasks/command/dsl/cmd_opt'
-require 'i18n/tasks/command/dsl/enum_opt'
-
 module I18n::Tasks
   module Command
     module DSL
@@ -19,9 +15,28 @@ module I18n::Tasks
       end
 
       module ClassMethods
-        include DSL::Cmd
-        include DSL::CmdOpt
-        include DSL::EnumOpt
+        def cmd(name, conf = nil)
+          if conf
+            conf        = conf.dup
+            conf[:args] = (args = conf[:args]) ? args.map { |arg| Symbol === arg ? 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]