i18n-tasks 0.6.3 → 0.7.0

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

@@ -0,0 +1,70 @@
+module I18n::Tasks
+  module Command
+    module Commands
+      module Usages
+        include Command::Collection
+
+        cmd_opt :strict, {
+            short: :s,
+            long:  :strict,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.strict')
+        }
+
+        cmd :find,
+            args: '[pattern]',
+            desc: I18n.t('i18n_tasks.cmd.desc.find'),
+            opt:  cmd_opts(:out_format, :pattern)
+
+        def find(opt = {})
+          opt_output_format! opt
+          opt[:filter] ||= opt.delete(:pattern) || opt[:arguments].try(:first)
+          print_forest i18n.used_tree(key_filter: opt[:filter].presence, source_occurrences: true), opt, :used_keys
+        end
+
+        cmd :unused,
+            args: '[locale ...]',
+            desc: I18n.t('i18n_tasks.cmd.desc.unused'),
+            opt:  cmd_opts(:locales, :out_format, :strict)
+
+        def unused(opt = {})
+          opt_locales! opt
+          opt_output_format! opt
+          print_forest i18n.unused_keys(opt), opt, :unused_keys
+        end
+
+        cmd :remove_unused,
+            args: '[locale ...]',
+            desc: I18n.t('i18n_tasks.cmd.desc.remove_unused'),
+            opt:  cmd_opts(:locales, :out_format, :strict, :confirm)
+
+        def remove_unused(opt = {})
+          opt_locales! opt
+          opt_output_format! opt
+          unused_keys = i18n.unused_keys(opt)
+          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 I18n.t('i18n_tasks.remove_unused.removed', count: unused_keys.leaves.count)
+            print_forest removed, opt
+          else
+            log_stderr bold green I18n.t('i18n_tasks.remove_unused.noop')
+          end
+        end
+
+        private
+
+        def confirm_remove_unused!(unused_keys, opt)
+          return if ENV['CONFIRM'] || opt[:confirm]
+          locales = bold(opt[:locales] * ', ')
+          msg     = [
+              red(I18n.t('i18n_tasks.remove_unused.confirm', count: unused_keys.leaves.count, locales: locales)),
+              yellow(I18n.t('i18n_tasks.common.continue_q')),
+              yellow('(yes/no)')
+          ] * ' '
+          exit 1 unless agree msg
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module I18n::Tasks
+  module Command
+    module Commands
+      module XLSX
+        include Command::Collection
+
+        cmd :xlsx_report,
+            args: '[locale...]',
+            desc: 'save missing and unused translations to an Excel file',
+            opt:  [cmd_opt(:locales),
+                   {short: :p, long: :path=, desc: 'Destination path', conf: {default: 'tmp/i18n-report.xlsx'}}]
+
+        def xlsx_report(opt = {})
+          begin
+            require 'axlsx'
+          rescue LoadError
+            message = %Q(For spreadsheet report please add axlsx gem to Gemfile:\ngem 'axlsx', '~> 2.0')
+            log_stderr Term::ANSIColor.red Term::ANSIColor.bold message
+            exit 1
+          end
+          opt_locales! opt
+          spreadsheet_report.save_report opt[:path], opt.except(:path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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
+      include DSL::Cmd
+      include DSL::CmdOpt
+      include DSL::EnumOpt
+
+      def self.extended(base)
+        base.instance_variable_set :@dsl, HashWithIndifferentAccess.new { |h, k|
+          h[k] = HashWithIndifferentAccess.new
+        }
+      end
+
+      def included(base)
+        base.instance_variable_get(:@dsl).deep_merge!(@dsl)
+      end
+
+      def dsl(key)
+        @dsl[key]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module I18n::Tasks
+  module Command
+    module DSL
+      module Cmd
+        def cmd(name, args = nil)
+          if args
+            dsl(:cmds)[name] = args
+          else
+            dsl(:cmds)[name]
+          end
+        end
+
+        def cmds
+          dsl(:cmds)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module I18n::Tasks
+  module Command
+    module DSL
+      module CmdOpt
+        def cmd_opts(*args)
+          dsl(:cmd_opts).values_at(*args)
+        end
+
+        def cmd_opt(arg, opts = nil)
+          if opts
+            dsl(:cmd_opts)[arg] = opts
+          else
+            dsl(:cmd_opts)[arg]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module I18n::Tasks
+  module Command
+    module DSL
+      module EnumOpt
+        def enum_opt(name, list = nil)
+          if list
+            dsl(:enum_valid)[name] = list
+          else
+            dsl(:enum_valid)[name]
+          end
+        end
+
+        DEFAULT_ENUM_OPT_DESC = proc { |valid, default|
+          I18n.t('i18n_tasks.cmd.enum_opt.desc.default', valid_text: valid, default_text: default)
+        }
+
+        def enum_opt_attr(short, long, valid, &desc)
+          desc ||= DEFAULT_ENUM_OPT_DESC
+          {short: short, long: long.to_sym,
+           desc:  desc.call(valid * ', ', I18n.t('i18n_tasks.cmd.args.default_text', value: valid.first)),
+           conf:  {default: valid.first, argument: true, optional: false}}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'i18n/tasks/command/options/enum_opt'
+require 'i18n/tasks/command/options/list_opt'
+
+module I18n::Tasks
+  module Command
+    module Options
+      module Common
+        extend Command::DSL
+        include Options::EnumOpt
+        include Options::ListOpt
+
+        VALID_LOCALE_RE = /\A\w[\w\-_\.]*\z/i
+
+        cmd_opt :nostdin, {
+            short: :S,
+            long:  :nostdin,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.nostdin'),
+            conf:  {default: false}
+        }
+
+        cmd_opt :confirm, {
+            short: :y,
+            long:  :confirm,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.confirm'),
+            conf:  {default: false}
+        }
+
+        cmd_opt :pattern, {
+            short: :p,
+            long:  :pattern=,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.key_pattern'),
+            conf:  {argument: true, optional: false}
+        }
+
+        cmd_opt :value, {
+            short: :v,
+            long:  :value=,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.value'),
+            conf:  {argument: true, optional: false}
+        }
+
+        def opt_or_arg!(key, opt)
+          opt[key] ||= opt[:arguments].try(:shift)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module I18n::Tasks
+  module Command
+    module Options
+      module EnumOpt
+        delegate :enum_opt, to: :class
+
+        DEFAULT_ENUM_OPT_ERROR = proc { |bad, good|
+          I18n.t('i18n_tasks.cmd.enum_opt.invalid_one', invalid: bad, valid: good * ', ')
+        }
+
+        def parse_enum_opt(value, valid, &error_msg)
+          valid = enum_opt(valid) if Symbol === valid
+          return valid.first unless value.present?
+          if enum_opt_valid?(valid, value)
+            value
+          else
+            error_msg ||= DEFAULT_ENUM_OPT_ERROR
+            raise CommandError.new error_msg.call(value, valid)
+          end
+        end
+
+        def enum_opt_valid?(valid, value)
+          valid = enum_opt(valid) if Symbol === valid
+          valid.include?(value)
+        end
+
+        DEFAULT_ENUM_LIST_ERROR = proc { |bad, good|
+          I18n.t('i18n_tasks.cmd.enum_opt.invalid_list', invalid: bad * ', ', valid: good * ', ')
+        }
+
+        def parse_enum_list_opt(values, valid, &error_msg)
+          values  = explode_list_opt(values)
+          invalid = values - valid.map(&:to_s)
+          if invalid.empty?
+            values
+          else
+            error_msg ||= DEFAULT_ENUM_LIST_ERROR
+            raise CommandError.new error_msg.call(invalid, valid)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module I18n::Tasks
+  module Command
+    module Options
+      module ListOpt
+        def explode_list_opt(list_opt, delim = /\s*[,]\s*/)
+          Array(list_opt).compact.map { |v| v.strip.split(delim).compact.presence }.flatten.map(&:presence).compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module I18n::Tasks
+  module Command
+    module Options
+      module Locales
+        extend Command::DSL
+
+        cmd_opt :locales, {
+            short: :l,
+            long:  :locales=,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.locales_filter'),
+            conf:  {as: Array, delimiter: /\s*[+:,]\s*/, default: 'all', argument: true, optional: false}
+        }
+        cmd_opt :locale, {
+            short: :l,
+            long:  :locale=,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.locale'),
+            conf:  {default: 'base', argument: true, optional: false}
+        }
+
+        def opt_locales!(opt)
+          argv    = Array(opt[:arguments]) + Array(opt[:locales])
+          locales = if argv == ['all'] || argv == 'all' || argv.blank?
+                      i18n.locales
+                    else
+                      explode_list_opt(argv).map { |v| v == 'base' ? base_locale : v }
+                    end
+          locales.each { |locale| validate_locale!(locale) }
+          log_verbose "locales for the command are #{locales.inspect}"
+          opt[:locales] = locales
+        end
+
+        def opt_locale!(opt, key = :locale)
+          val      = opt[key]
+          opt[key] = base_locale if val.blank? || val == 'base'
+          opt[key]
+        end
+
+
+        VALID_LOCALE_RE = /\A\w[\w\-_\.]*\z/i
+
+        def validate_locale!(locale)
+          raise CommandError.new(I18n.t('i18n_tasks.cmd.errors.invalid_locale', invalid: locale)) if VALID_LOCALE_RE !~ locale
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module I18n::Tasks
+  module Command
+    module Options
+      module Trees
+        extend Command::DSL
+
+        enum_opt :data_format, %w(yaml json keys)
+        cmd_opt :data_format, enum_opt_attr(:f, :format=, enum_opt(:data_format)) { |valid_text, default_text|
+          I18n.t('i18n_tasks.cmd.args.desc.data_format', valid_text: valid_text, default_text: default_text)
+        }
+
+        enum_opt :out_format, ['terminal-table', *enum_opt(:data_format), 'inspect']
+        cmd_opt :out_format, enum_opt_attr(:f, :format=, enum_opt(:out_format)) { |valid_text, default_text|
+          I18n.t('i18n_tasks.cmd.args.desc.out_format', valid_text: valid_text, default_text: default_text)
+        }
+
+        cmd_opt :keys, {
+            short: :k,
+            long:  :keys=,
+            desc:  I18n.t('i18n_tasks.cmd.args.desc.keys'),
+            conf:  {as: Array, delimiter: /[+:,]/, argument: true, optional: false}
+        }
+
+        def print_forest(forest, opt, version = :show_tree)
+          format = opt[: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 *enum_opt(:data_format)
+              puts i18n.data.adapter_dump forest, format
+          end
+        end
+
+        INVALID_FORMAT_MSG = proc do |value, valid|
+          I18n.t('i18n_tasks.cmd.errors.invalid_format', invalid: value, valid: valid * ', ')
+        end
+
+        def opt_output_format!(opt = {}, key = :format)
+          opt[key] = parse_enum_opt opt[key], :out_format, &INVALID_FORMAT_MSG
+        end
+
+        def opt_data_format!(opt = {}, key = :format)
+          opt[key] = parse_enum_opt opt[key], :data_format, &INVALID_FORMAT_MSG
+        end
+
+        def opt_args_keys!(opt = {})
+          opt[:keys] = explode_list_opt(opt[:keys]) + Array(opt[:arguments])
+        end
+
+        def opt_forest_arg_or_stdin!(opt)
+          src = opt[:arguments].try(:shift) || $stdin.read
+          parse_forest(src, opt)
+        end
+
+        def opt_forests_stdin_args!(opt, num = false)
+          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, opt) }
+        end
+
+        def opt_forests_merged_stdin_args!(opt)
+          opt_forests_stdin_args!(opt).inject(i18n.empty_forest) { |result, forest|
+            result.merge! forest
+          }
+        end
+
+        def parse_forest(src, opt = {})
+          if !src
+            raise CommandError.new(I18n.t('i18n_tasks.cmd.errors.pass_forest'))
+          end
+          format = opt_data_format!(opt)
+          if format == 'keys'
+            Data::Tree::Siblings.from_key_names parse_keys(src)
+          else
+            Data::Tree::Siblings.from_nested_hash i18n.data.adapter_parse(src, format)
+          end
+        end
+
+        def parse_keys(src)
+          explode_list_opt(src, /\s*[,\s\n]\s*/)
+        end
+      end
+    end
+  end
+end