i18n-tasks 1.0.15 → 1.1.0

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Command
+    module Commands
+      module CheckPrism
+        include Command::Collection
+
+        arg :prism_mode,
+          "--prism_mode MODE",
+          "Prism parser mode: 'rails' or 'ruby'. Defaults to 'rails' if Rails is available in the project, otherwise 'ruby'."
+
+        cmd :check_prism,
+          desc: t("i18n_tasks.cmd.desc.check_prism"),
+          args: %i[prism_mode]
+
+        # Run both the default (Parser-based) and the Prism-enabled scanning
+        # and produce a plain-text report in tmp/i18n_tasks_check_prism.md suitable
+        # for pasting into an issue.
+        def check_prism(opt = {})
+          now = Time.now
+          report_path = File.join(Dir.pwd, "tmp", "i18n_tasks_check_prism.md")
+          FileUtils.mkdir_p(File.dirname(report_path))
+
+          # keep original search config and clear caches helper
+          orig_search = (i18n.config[:search] || {}).dup
+
+          results = {}
+
+          # determine prism mode: use provided opt or default to rails when Rails present
+          chosen_prism_mode = (opt[:prism_mode].presence || (rails_available? ? "rails" : "ruby")).to_s
+          unless %w[rails ruby].include?(chosen_prism_mode)
+            fail CommandError, "--prism-mode must be 'rails' or 'ruby'"
+          end
+
+          {default: nil, prism: chosen_prism_mode}.each do |label, prism_mode|
+            i18n.config[:search] = orig_search.merge(prism: prism_mode)
+            # clear caches used by UsedKeys
+            i18n.instance_variable_set(:@scanner, nil)
+            i18n.instance_variable_set(:@search_config, nil)
+            i18n.instance_variable_set(:@keys_used_in_source_tree, nil)
+
+            tree = i18n.used_in_source_tree
+            keys = tree.nodes.select { |n| n.data[:occurrences].present? }
+            results[label] = keys.each_with_object({}) do |node, h|
+              full_key = node.full_key(root: false)
+              h[full_key] = node.data[:occurrences]
+            end
+          end
+
+          # restore original config and caches
+          i18n.config[:search] = orig_search
+          i18n.instance_variable_set(:@scanner, nil)
+          i18n.instance_variable_set(:@search_config, nil)
+          i18n.instance_variable_set(:@keys_used_in_source_tree, nil)
+
+          default_keys = results[:default].keys
+          prism_keys = results[:prism].keys
+
+          only_default = (default_keys - prism_keys).sort
+          only_prism = (prism_keys - default_keys).sort
+          both = (default_keys & prism_keys).sort
+
+          File.open(report_path, "w") do |f|
+            f.puts "# i18n-tasks check_prism report"
+            f.puts "Generated at: #{now.utc}"
+            f.puts "Prism mode: #{chosen_prism_mode}"
+            f.puts "Gem version: #{I18n::Tasks::VERSION}"
+            f.puts ""
+            f.puts "Summary"
+            f.puts "- total keys (default parser): #{default_keys.size}"
+            f.puts "- total keys (prism): #{prism_keys.size}"
+            f.puts "- keys in both: #{both.size}"
+            f.puts "- keys only in default parser: #{only_default.size}"
+            f.puts "- keys only in prism: #{only_prism.size}"
+            f.puts ""
+
+            unless only_default.empty?
+              f.puts "## Keys found by the default parser but NOT by Prism (#{only_default.size})"
+              only_default.each do |k|
+                f.puts "\n### #{k}"
+                results[:default][k].first(5).each do |occ|
+                  src = (occ.raw_key || k).to_s
+                  line = (occ.line || "").strip
+                  highlighted = line.gsub(src) { |m| "`#{m}`" }
+                  f.puts "- #{occ.path}:#{occ.line_num} `#{src}` — #{highlighted}"
+                end
+              end
+            end
+
+            unless only_prism.empty?
+              f.puts "## Keys found by Prism but NOT by the default parser (#{only_prism.size})"
+              only_prism.each do |k|
+                f.puts "\n### #{k}"
+                results[:prism][k].each do |occ|
+                  src = (occ.raw_key || k).to_s
+                  line = (occ.line || "").strip
+                  highlighted = line.gsub(src) { |m| "`#{m}`" }
+                  f.puts "- #{occ.path}:#{occ.line_num} `#{src}` — #{highlighted}"
+                end
+              end
+            end
+
+            f.puts "\n## Notes"
+            f.puts "- This report compares keys discovered by the project default parser and by Prism (rails mode)."
+          end
+
+          log_stderr "Wrote check_prism report: #{report_path}"
+          puts File.read(report_path)
+        end
+
+        private
+
+        def rails_available?
+          return true if defined?(Rails)
+          return true if Gem.loaded_specs.key?("rails")
+          lock = File.join(Dir.pwd, "Gemfile.lock")
+          return false unless File.exist?(lock)
+          File.read(lock).lines.any? { |l| l.strip.start_with?("rails ") || l.strip =~ /^rails \(/ }
+        rescue
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -7,24 +7,24 @@ module I18n::Tasks
         include Command::Collection
 
         arg :pattern_router,
-            '-p',
-            '--pattern_router',
-            t('i18n_tasks.cmd.args.desc.pattern_router')
+          "-p",
+          "--pattern_router",
+          t("i18n_tasks.cmd.args.desc.pattern_router")
 
         cmd :normalize,
-            pos: '[locale ...]',
-            desc: t('i18n_tasks.cmd.desc.normalize'),
-            args: %i[locales pattern_router]
+          pos: "[locale ...]",
+          desc: t("i18n_tasks.cmd.desc.normalize"),
+          args: %i[locales pattern_router]
 
         def normalize(opt = {})
           i18n.normalize_store! locales: opt[:locales],
-                                force_pattern_router: opt[:pattern_router]
+            force_pattern_router: opt[:pattern_router]
         end
 
         cmd :check_normalized,
-            pos: '[locale ...]',
-            desc: t('i18n_tasks.cmd.desc.check_normalized'),
-            args: %i[locales]
+          pos: "[locale ...]",
+          desc: t("i18n_tasks.cmd.desc.check_normalized"),
+          args: %i[locales]
 
         def check_normalized(opt)
           non_normalized = i18n.non_normalized_paths locales: opt[:locales]
@@ -33,10 +33,10 @@ module I18n::Tasks
         end
 
         cmd :mv,
-            pos: 'FROM_KEY_PATTERN TO_KEY_PATTERN',
-            desc: t('i18n_tasks.cmd.desc.mv')
+          pos: "FROM_KEY_PATTERN TO_KEY_PATTERN",
+          desc: t("i18n_tasks.cmd.desc.mv")
         def mv(opt = {})
-          fail CommandError, 'requires FROM_KEY_PATTERN and TO_KEY_PATTERN' if opt[:arguments].size < 2
+          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
@@ -47,10 +47,10 @@ module I18n::Tasks
         end
 
         cmd :cp,
-            pos: 'FROM_KEY_PATTERN TO_KEY_PATTERN',
-            desc: t('i18n_tasks.cmd.desc.cp')
+          pos: "FROM_KEY_PATTERN TO_KEY_PATTERN",
+          desc: t("i18n_tasks.cmd.desc.cp")
         def cp(opt = {})
-          fail CommandError, 'requires FROM_KEY_PATTERN and TO_KEY_PATTERN' if opt[:arguments].size < 2
+          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
@@ -61,32 +61,32 @@ module I18n::Tasks
         end
 
         cmd :rm,
-            pos: 'KEY_PATTERN [KEY_PATTERN...]',
-            desc: t('i18n_tasks.cmd.desc.rm')
+          pos: "KEY_PATTERN [KEY_PATTERN...]",
+          desc: t("i18n_tasks.cmd.desc.rm")
         def rm(opt = {})
-          fail CommandError, 'requires KEY_PATTERN' if opt[:arguments].empty?
+          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)
+            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: t('i18n_tasks.cmd.desc.data'),
-            args: %i[locales out_format]
+          pos: "[locale ...]",
+          desc: t("i18n_tasks.cmd.desc.data"),
+          args: %i[locales out_format]
 
         def data(opt = {})
           print_forest i18n.data_forest(opt[:locales]), opt
         end
 
         cmd :data_merge,
-            pos: '[tree ...]',
-            desc: t('i18n_tasks.cmd.desc.data_merge'),
-            args: %i[data_format nostdin]
+          pos: "[tree ...]",
+          desc: t("i18n_tasks.cmd.desc.data_merge"),
+          args: %i[data_format nostdin]
 
         def data_merge(opt = {})
           forest = merge_forests_stdin_and_pos!(opt)
@@ -95,9 +95,9 @@ module I18n::Tasks
         end
 
         cmd :data_write,
-            pos: '[tree]',
-            desc: t('i18n_tasks.cmd.desc.data_write'),
-            args: %i[data_format nostdin]
+          pos: "[tree]",
+          desc: t("i18n_tasks.cmd.desc.data_write"),
+          args: %i[data_format nostdin]
 
         def data_write(opt = {})
           forest = forest_pos_or_stdin!(opt)
@@ -106,13 +106,13 @@ module I18n::Tasks
         end
 
         cmd :data_remove,
-            pos: '[tree]',
-            desc: t('i18n_tasks.cmd.desc.data_remove'),
-            args: %i[data_format nostdin]
+          pos: "[tree]",
+          desc: t("i18n_tasks.cmd.desc.data_remove"),
+          args: %i[data_format nostdin]
 
         def data_remove(opt = {})
           removed = i18n.data.remove_by_key!(forest_pos_or_stdin!(opt))
-          log_stderr 'Removed:'
+          log_stderr "Removed:"
           print_forest removed, opt
         end
       end

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

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

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

@@ -7,20 +7,21 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :health,
-            pos: '[locale ...]',
-            desc: t('i18n_tasks.cmd.desc.health'),
-            args: %i[locales out_format config]
+          pos: "[locale ...]",
+          desc: t("i18n_tasks.cmd.desc.health"),
+          args: %i[locales out_format config]
 
         def health(opt = {})
           forest = i18n.data_forest(opt[:locales])
-          stats  = i18n.forest_stats(forest)
-          fail CommandError, t('i18n_tasks.health.no_keys_detected') if stats[:key_count].zero?
+          stats = i18n.forest_stats(forest)
+          fail CommandError, t("i18n_tasks.health.no_keys_detected") if stats[:key_count].zero?
 
           terminal_report.forest_stats forest, stats
           [
             missing(**opt),
             unused(**opt),
             check_consistent_interpolations(**opt),
+            check_reserved_interpolations(**opt),
             check_normalized(**opt)
           ].detect { |result| result == :exit1 }
         end

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

@@ -7,15 +7,26 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :check_consistent_interpolations,
-            pos: '[locale ...]',
-            desc: t('i18n_tasks.cmd.desc.check_consistent_interpolations'),
-            args: %i[locales out_format]
+          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
+
+        cmd :check_reserved_interpolations,
+          pos: "[locale]",
+          desc: t("i18n_tasks.cmd.desc.check_reserved_interpolations"),
+          args: %i[locales out_format]
+
+        def check_reserved_interpolations(opt = {})
+          forest = i18n.reserved_interpolations(**opt.slice(:locale))
+          print_forest forest, opt, :reserved_interpolations
+          :exit1 unless forest.empty?
+        end
       end
     end
   end

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

@@ -7,28 +7,28 @@ module I18n::Tasks
         include Command::Collection
 
         cmd :config,
-            pos: '[section ...]',
-            desc: t('i18n_tasks.cmd.desc.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.sub!(/\A---\n/, "")
           cfg.gsub!(/^([^\s-].+?:)/, Rainbow('\1').cyan.bright)
           puts cfg
         end
 
-        cmd :gem_path, desc: t('i18n_tasks.cmd.desc.gem_path')
+        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')
+        cmd :irb, desc: t("i18n_tasks.cmd.desc.irb")
 
         def irb
-          require 'i18n/tasks/console_context'
+          require "i18n/tasks/console_context"
           ::I18n::Tasks::ConsoleContext.start
         end
       end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/command/collection'
+require "i18n/tasks/command/collection"
 
 module I18n::Tasks
   module Command
@@ -10,22 +10,22 @@ module I18n::Tasks
 
         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
-            )
+          "-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 pattern]
+          pos: "[locale ...]",
+          desc: t("i18n_tasks.cmd.desc.missing"),
+          args: %i[locales out_format missing_types pattern]
 
         def missing(opt = {})
           forest = i18n.missing_keys(**opt.slice(:locales, :base_locale, :types))
@@ -38,9 +38,9 @@ module I18n::Tasks
         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, :pattern]
+          pos: "[locale ...]",
+          desc: t("i18n_tasks.cmd.desc.translate_missing"),
+          args: [:locales, :locale_to_translate_from, arg(:out_format).from(1), :translation_backend, :pattern]
 
         def translate_missing(opt = {})
           missing = i18n.missing_diff_forest opt[:locales], opt[:from]
@@ -52,15 +52,15 @@ module I18n::Tasks
           backend = opt[:backend].presence || i18n.translation_config[:backend]
           translated = i18n.translate_forest missing, from: opt[:from], backend: backend.to_sym
           i18n.data.merge! translated
-          log_stderr t('i18n_tasks.translate_missing.translated', count: translated.leaves.count)
+          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, :pattern, arg(:value) + [{ default: '%{value_or_default_or_human_key}' }],
-                   ['--nil-value', 'Set value to nil. Takes precedence over the value argument.']]
+          pos: "[locale ...]",
+          desc: t("i18n_tasks.cmd.desc.add_missing"),
+          args: [:locales, :out_format, :pattern, 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 = {}) # rubocop:disable Metrics/AbcSize
@@ -69,7 +69,7 @@ module I18n::Tasks
             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])
+              .set_each_value!(opt[:"nil-value"] ? nil : opt[:value])
             if opt[:pattern]
               pattern_re = i18n.compile_key_pattern(opt[:pattern])
               forest.select_keys! { |full_key, _node| full_key =~ pattern_re }
@@ -77,7 +77,7 @@ module I18n::Tasks
             i18n.data.merge! forest
             added.merge! forest
           end.tap do |added|
-            log_stderr t('i18n_tasks.add_missing.added', count: added.leaves.count)
+            log_stderr t("i18n_tasks.add_missing.added", count: added.leaves.count)
             print_forest added, opt
           end
         end

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

@@ -8,9 +8,9 @@ module I18n::Tasks
         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]
+          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)
@@ -18,79 +18,79 @@ module I18n::Tasks
         end
 
         cmd :tree_merge,
-            pos: '[[tree] [tree] ... (or stdin)]',
-            desc: t('i18n_tasks.cmd.desc.tree_merge'),
-            args: %i[data_format nostdin]
+          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]
+          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
+          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 }
+            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')
+          "-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]
+          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
+          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'])
+          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]
+          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
+          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]
+          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)
+          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?
+          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'] }]
+          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])