i18n-tasks 0.6.3 → 0.7.0

data/lib/i18n/tasks/command_error.rb

@@ -1,6 +1,9 @@
 # coding: utf-8
 module I18n
   module Tasks
+    # When this type of error is caught:
+    # 1. show error message of the backtrace
+    # 2. exit with non-zero exit code
     class CommandError < StandardError
     end
   end

data/lib/i18n/tasks/commands.rb

@@ -1,176 +1,29 @@
 # coding: utf-8
-require 'i18n/tasks/commands_base'
-require 'i18n/tasks/reports/terminal'
-require 'i18n/tasks/reports/spreadsheet'
+require 'i18n/tasks/command/dsl'
+require 'i18n/tasks/command/collection'
+require 'i18n/tasks/command/commands/health'
+require 'i18n/tasks/command/commands/missing'
+require 'i18n/tasks/command/commands/usages'
+require 'i18n/tasks/command/commands/eq_base'
+require 'i18n/tasks/command/commands/data'
+require 'i18n/tasks/command/commands/tree'
+require 'i18n/tasks/command/commands/meta'
+require 'i18n/tasks/command/commands/xlsx'
+require 'i18n/tasks/command/commander'
 
 module I18n::Tasks
-  class Commands < CommandsBase
+  class Commands < Command::Commander
+    extend Command::DSL
+    include Command::Commands::Health
+    include Command::Commands::Missing
+    include Command::Commands::Usages
+    include Command::Commands::EqBase
+    include Command::Commands::Data
+    include Command::Commands::Tree
+    include Command::Commands::Meta
+    include Command::Commands::XLSX
+
     include Term::ANSIColor
     require 'highline/import'
-
-    on_locale_opt = { as: Array, delimiter: /[+:,]/, default: 'all', argument: true, optional: false }
-    OPT = {
-        locale: proc {
-          on '-l', :locales=,
-             'Filter by locale(s), comma-separated list (en,fr) or all (default), or pass arguments without -l',
-             on_locale_opt
-        },
-        format: proc {
-          on '-f', :format=,
-             "Output format: #{VALID_TREE_FORMATS * ', '}. Default: terminal-table.",
-             {default: 'terminal-table', argument: true, optional: false}
-        },
-        strict: proc {
-          on :s, :strict, %Q(Do not infer dynamic key usage such as `t("category.\#{category.name}")`)
-        }
-    }
-    desc 'show missing translations'
-    opts do
-      instance_exec &OPT[:locale]
-      instance_exec &OPT[:format]
-      on '-t', :types=, 'Filter by type (types: used, diff)', as: Array, delimiter: /[+:,]/
-    end
-    cmd :missing do |opt = {}|
-      parse_locales! opt
-      print_locale_tree i18n.missing_keys(opt), opt, :missing_keys
-    end
-
-    desc 'show unused translations'
-    opts do
-      instance_exec &OPT[:locale]
-      instance_exec &OPT[:format]
-      instance_exec &OPT[:strict]
-    end
-    cmd :unused do |opt = {}|
-      parse_locales! opt
-      print_locale_tree i18n.unused_keys(opt), opt, :unused_keys
-    end
-
-    desc 'show translations equal to base value'
-    opts do
-      instance_exec &OPT[:format]
-    end
-    cmd :eq_base do |opt = {}|
-      parse_locales! opt
-      print_locale_tree i18n.eq_base_keys(opt), opt, :eq_base_keys
-    end
-
-    desc 'show where the keys are used in the code'
-    opts do
-      on '-p', :pattern=, 'Show only keys matching pattern', argument: true, optional: false
-      instance_exec &OPT[:format]
-    end
-    cmd :find do |opt = {}|
-      opt[:filter] ||= opt.delete(:pattern) || opt[:arguments].try(:first)
-      print_locale_tree i18n.used_tree(key_filter: opt[:filter].presence, source_locations: true), opt, :used_keys
-    end
-
-    desc 'show locale data'
-    opts do
-      instance_exec &OPT[:locale]
-      instance_exec &OPT[:format]
-    end
-    cmd :data do |opt = {}|
-      parse_locales! opt
-      print_locale_tree i18n.data_forest(opt[:locales]), opt
-    end
-
-    desc 'translate missing keys with Google Translate'
-    opts do
-      on '-l', :locales=, 'Locales to translate (comma-separated, default: all)', on_locale_opt
-      on '-f', :from=, 'Locale to translate from (default: base)', default: 'base', argument: true, optional: false
-    end
-    cmd :translate_missing do |opt = {}|
-      opt[:from] = base_locale if opt[:from].blank? || opt[:from] == 'base'
-      parse_locales! opt
-      i18n.fill_missing_google_translate opt
-    end
-
-    desc 'add missing keys to the locales'
-    opts do
-      on '-l', :locales=, 'Locales to add keys into (comma-separated, default: all)', on_locale_opt
-      on '-p', :placeholder=, 'Value for empty keys (default: base value or key.humanize)', argument: true, optional: false
-    end
-    cmd :add_missing do |opt = {}|
-      parse_locales! opt
-      opt[:value] ||= opt.delete(:placeholder) || proc { |key, locale|
-        # default to base value or key.humanize
-        locale != base_locale && t(key, base_locale) || SplitKey.split_key(key).last.to_s.humanize
-      }
-
-      v = opt[:value]
-      if v.is_a?(String) && v.include?('%{base_value}')
-        opt[:value] = proc { |key, locale, node|
-          base_value = node.value || t(key, base_locale) || ''
-          v % {base_value: base_value}
-        }
-      end
-
-      i18n.fill_missing_value opt
-    end
-
-    desc 'normalize translation data: sort and move to the right files'
-    opts do
-      on '-l', :locales=, 'Locales to normalize (comma-separated, default: all)', on_locale_opt
-      on '-p', :pattern_router, 'Use pattern router, regardless of config.', argument: false, optional: true
-    end
-    cmd :normalize do |opt = {}|
-      parse_locales! opt
-      i18n.normalize_store! opt[:locales], opt[:pattern_router]
-    end
-
-    desc 'remove unused keys'
-    opts do
-      on '-l', :locales=, 'Locales to remove unused keys from (comma-separated, default: all)', on_locale_opt
-      instance_exec &OPT[:strict]
-    end
-    cmd :remove_unused do |opt = {}|
-      parse_locales! opt
-      unused_keys = i18n.unused_keys(opt)
-      if unused_keys.present?
-        terminal_report.unused_keys(unused_keys)
-        unless ENV['CONFIRM']
-          exit 1 unless agree(red "#{unused_keys.leaves.count} translations will be removed in #{bold opt[:locales] * ', '}#{red '.'} " + yellow('Continue? (yes/no)') + ' ')
-        end
-        i18n.remove_unused!(opt[:locales])
-        $stderr.puts "Removed #{unused_keys.leaves.count} keys"
-      else
-        $stderr.puts bold green 'No unused keys to remove'
-      end
-    end
-
-    desc 'display i18n-tasks configuration'
-    cmd :config do
-      cfg = i18n.config_for_inspect.to_yaml
-      cfg.sub! /\A---\n/, ''
-      cfg.gsub! /^([^\s-].+?:)/, Term::ANSIColor.cyan(Term::ANSIColor.bold('\1'))
-      puts cfg
-    end
-
-    desc 'save missing and unused translations to an Excel file'
-    opts do
-      on :path=, 'Destination path', default: 'tmp/i18n-report.xlsx'
-    end
-    cmd :xlsx_report do |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
-      spreadsheet_report.save_report opt[:path]
-    end
-
-    desc 'REPL session within i18n-tasks context'
-    cmd :irb do
-      require 'i18n/tasks/console_context'
-      ::I18n::Tasks::ConsoleContext.start
-    end
-
-    desc 'show path to the gem'
-    cmd :gem_path do
-      puts File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
-    end
   end
 end

data/lib/i18n/tasks/configuration.rb

@@ -62,22 +62,7 @@ module I18n::Tasks::Configuration
 
   # @return [Array<String>] all available locales, base_locale is always first
   def locales
-    @config_sections[:locales] ||= begin
-      locales = config[:locales]
-      locales ||= data.available_locales
-      locales = locales.map(&:to_s)
-      locales = if locales.include?(base_locale)
-                  [base_locale] + (locales - [base_locale])
-                else
-                  [base_locale] + locales
-                end
-      if config[:locales]
-        log_verbose "config.locales set to #{locales}"
-      else
-        log_verbose "config.locales inferred from data #{locales}"
-      end
-      locales
-    end
+    @config_sections[:locales] ||= data.locales
   end
 
   # @return [String] default i18n locale

data/lib/i18n/tasks/console_context.rb

@@ -37,7 +37,7 @@ module I18n::Tasks
 #{yellow 'Data as trees'}
   tree(locale)
   missing_tree(locale, compared_to = base_locale)
-  used_tree(source_locations: false, key_filter: nil)
+  used_tree(source_occurrences: false, key_filter: nil)
   unused_tree(locale)
   build_tree('es' => {'hello' => 'Hola'})
 

data/lib/i18n/tasks/data.rb

@@ -8,17 +8,22 @@ module I18n::Tasks
     # @see I18n::Tasks::Data::FileSystem
     def data
       @data ||= begin
-        conf    = (config[:data] || {}).with_indifferent_access
-        adapter = (conf[:adapter].presence || conf[:class].presence || :file_system).to_s
-        if adapter !~ /[A-Z]/
-          adapter = "I18n::Tasks::Data::#{adapter.camelize}"
-        end
-        adapter.constantize.new(conf.except(:adapter, :class).merge(base_locale: base_locale))
+        data_config   = (config[:data] || {}).with_indifferent_access
+        data_config.merge!(base_locale: base_locale, locales: config[:locales])
+        adapter_class = data_config[:adapter].presence || data_config[:class].presence || :file_system
+        adapter_class = adapter_class.to_s
+        adapter_class = "I18n::Tasks::Data::#{adapter_class.camelize}" if adapter_class !~ /[A-Z]/
+        data_config.except!(:adapter, :class)
+        adapter_class.constantize.new data_config
       end
     end
 
+    def empty_forest
+      ::I18n::Tasks::Data::Tree::Siblings.new
+    end
+
     def data_forest(locales = self.locales)
-      locales.inject(Tree::Siblings.new) do |tree, locale|
+      locales.inject(empty_forest) do |tree, locale|
         tree.merge! data[locale]
       end
     end
@@ -51,7 +56,7 @@ module I18n::Tasks
 
     # write to store, normalizing all data
     def normalize_store!(from = nil, pattern_router = false)
-      from = self.locales unless from
+      from   = self.locales unless from
       router = pattern_router ? ::I18n::Tasks::Data::Router::PatternRouter.new(data, data.config) : data.router
       data.with_router(router) do
         Array(from).each do |target_locale|

data/lib/i18n/tasks/data/file_formats.rb

@@ -9,36 +9,41 @@ module I18n
           base.extend ClassMethods
         end
 
-        def adapter_for(path)
-          self.class.adapter_for(path)
-        end
+        delegate :adapter_for_path, :adapter_by_name, :adapter_name, :adapter_names, to: :class
 
-        def adapter_by_name(path)
-          self.class.adapter_by_name(path)
+        def adapter_dump(tree, format)
+          adapter_op :dump, format, tree, write_config(format)
         end
 
-        def adapter_names
-          self.class.adapter_names
+        def adapter_parse(tree, format)
+          adapter_op :parse, format, tree, read_config(format)
         end
 
-        def adapter_dump(tree, adapter_info)
-          adapter_name, adapter_pattern, adapter = adapter_info
-          adapter_options = (config[adapter_name] || {})[:write]
-          adapter.dump(tree, adapter_options)
+        def adapter_op(op, format, tree, config)
+          adapter_by_name(format).send(op, tree, config)
+        rescue Exception => e
+          raise CommandError.new("#{format} #{op} error: #{e.message}")
         end
 
         protected
 
+        def write_config(format)
+          (config[format] || {})[:write]
+        end
+
+        def read_config(format)
+          (config[format] || {})[:read]
+        end
+
         def load_file(path)
-          adapter_name, adapter_pattern, adapter = adapter_for(path)
-          adapter_options = (config[adapter_name] || {})[:read]
-          adapter.parse(::File.read(path), adapter_options)
+          adapter = adapter_for_path(path)
+          adapter.parse ::File.read(path), read_config(adapter_name(adapter))
         end
 
         def write_tree(path, tree)
           ::FileUtils.mkpath(File.dirname path)
           ::File.open(path, 'w') { |f|
-            f.write(adapter_dump(tree.to_hash, adapter_for(path)))
+            f.write(adapter_dump(tree.to_hash, adapter_name(adapter_for_path(path))))
           }
         end
 
@@ -49,21 +54,27 @@ module I18n
             (@fn_patterns ||= []) << [name, pattern, adapter]
           end
 
-          def adapter_for(path)
+          def adapter_for_path(path)
             @fn_patterns.detect { |(_name, pattern, _adapter)|
               ::File.fnmatch(pattern, path)
-            } or raise CommandError.new("Adapter not found for #{path}. Registered adapters: #{@fn_patterns.inspect}")
+            }.try(:last) or raise CommandError.new("Adapter not found for #{path}. Registered adapters: #{@fn_patterns.inspect}")
           end
 
           def adapter_names
             @fn_patterns.map(&:first)
           end
 
+          def adapter_name(adapter)
+            @fn_patterns.detect { |(adapter_name, _pattern, registered_adapter)|
+              registered_adapter == adapter
+            }.try(:first) or raise CommandError.new("Adapter #{adapter.inspect} is not registered. Registered adapters: #{@fn_patterns.inspect}")
+          end
+
           def adapter_by_name(name)
             name = name.to_s
             @fn_patterns.detect { |(adapter_name, _pattern, _adapter)|
               adapter_name.to_s == name
-            } or raise CommandError.new("Adapter with name #{name.inspect} not found. Registered adapters: #{@fn_patterns.inspect}")
+            }.try(:last) or raise CommandError.new("Adapter with name #{name.inspect} not found. Registered adapters: #{@fn_patterns.inspect}")
           end
         end
       end

data/lib/i18n/tasks/data/file_system_base.rb

@@ -9,8 +9,10 @@ module I18n::Tasks
   module Data
     class FileSystemBase
       include ::I18n::Tasks::Data::FileFormats
+      include ::I18n::Tasks::Logging
 
-      attr_reader :config, :base_locale
+      attr_reader :config, :base_locale, :locales
+      attr_accessor :locales
 
       DEFAULTS = {
           read:  ['config/locales/%{locale}.yml'],
@@ -18,8 +20,15 @@ module I18n::Tasks
       }.with_indifferent_access
 
       def initialize(config = {})
+        self.config  = config.except(:base_locale, :locales)
         @base_locale = config[:base_locale]
-        self.config = config.except(:base_locale)
+        locales = config[:locales].presence
+        @locales = LocaleList.normalize_locale_list(locales || available_locales, base_locale, true)
+        if locales.present?
+          log_verbose "data locales: #{@locales}"
+        else
+          log_verbose "data locales (inferred): #{@locales}"
+        end
       end
 
       # get locale tree
@@ -43,6 +52,28 @@ module I18n::Tasks
         @available_locales = nil
       end
 
+      def write(forest)
+        forest.each { |root| set(root.key, root) }
+      end
+
+      def merge!(forest)
+        forest.inject(Tree::Siblings.new) { |result, root|
+          locale = root.key
+          merged = get(locale).merge(root)
+          set locale, merged
+          result.merge! merged
+        }
+      end
+
+      def remove_by_key!(forest)
+        forest.inject(Tree::Siblings.new) do |removed, root|
+          locale_data = get(root.key)
+          subtracted = locale_data.subtract_by_key(forest)
+          set root.key, subtracted
+          removed.merge! locale_data.subtract_by_key(subtracted)
+        end
+      end
+
       alias []= set
 
       # @return self
@@ -56,7 +87,7 @@ module I18n::Tasks
       def available_locales
         @available_locales ||= begin
           locales = Set.new
-          config[:read].map do |pattern|
+          Array(config[:read]).map do |pattern|
             [pattern, Dir.glob(pattern % {locale: '*'})] if pattern.include?('%{locale}')
           end.compact.each do |pattern, paths|
             p  = pattern.gsub('\\', '\\\\').gsub('/', '\/').gsub('.', '\.')
@@ -97,7 +128,7 @@ module I18n::Tasks
           if name[0] != name[0].upcase
             name = "I18n::Tasks::Data::Router::#{name.classify}"
           end
-          name.constantize.new(self, @config.merge(base_locale: base_locale))
+          name.constantize.new(self, @config.merge(base_locale: base_locale, locales: locales))
         end
       end
       attr_writer :router

data/lib/i18n/tasks/data/router/conservative_router.rb

@@ -6,8 +6,9 @@ module I18n::Tasks
     # Keep the path, or infer from base locale
     class ConservativeRouter < PatternRouter
       def initialize(adapter, config)
-        @adapter       = adapter
-        @base_locale   = config[:base_locale]
+        @adapter     = adapter
+        @base_locale = config[:base_locale]
+        @locales     = config[:locales]
         super
       end
 
@@ -15,18 +16,20 @@ module I18n::Tasks
         return to_enum(:route, locale, forest) unless block
         out = Hash.new { |hash, key| hash[key] = Set.new }
         not_found = Set.new
-        forest.keys do |key, node|
-          locale_key = "#{locale}.#{key}"
-          path = adapter[locale][locale_key].try(:data).try(:[], :path)
-          # infer from base
+        forest.keys do |key, _node|
+          path = key_path(locale, key)
+          # infer from another locale
           unless path
-            path = base_tree["#{base_locale}.#{key}"].try(:data).try(:[], :path)
-            path = LocalePathname.replace_locale(path, base_locale, locale)
+            inferred_from = (locales - [locale]).detect { |loc|
+              path = key_path(loc, key)
+            }
+            path = LocalePathname.replace_locale(path, inferred_from, locale) if inferred_from
           end
+          key_with_locale = "#{locale}.#{key}"
           if path
-            out[path] << locale_key
+            out[path] << key_with_locale
           else
-            not_found << locale_key
+            not_found << key_with_locale
           end
         end
 
@@ -49,7 +52,11 @@ module I18n::Tasks
         adapter[base_locale]
       end
 
-      attr_reader :adapter, :base_locale
+      def key_path(locale, key)
+        adapter[locale]["#{locale}.#{key}"].try(:data).try(:[], :path)
+      end
+
+      attr_reader :adapter, :base_locale, :locales
     end
   end
 end