i18n-tasks 0.6.3 → 0.7.0

data/lib/i18n/tasks/html_keys.rb

@@ -0,0 +1,10 @@
+module I18n::Tasks
+  module HtmlKeys
+    extend self
+    HTML_KEY_PATTERN = /[.\-_]html\z/.freeze
+
+    def html_key?(full_key)
+      !!(full_key =~ HTML_KEY_PATTERN)
+    end
+  end
+end

data/lib/i18n/tasks/key_pattern_matching.rb

@@ -1,5 +1,6 @@
 # coding: utf-8
 module I18n::Tasks::KeyPatternMatching
+  extend self
   MATCH_NOTHING = /\z\A/
 
   # one regex to match any

data/lib/i18n/tasks/locale_list.rb

@@ -0,0 +1,19 @@
+module I18n::Tasks
+  module LocaleList
+    extend self
+
+    # @return locales converted to strings, with base locale first, the rest sorted alphabetically
+    def normalize_locale_list(locales, base_locale, include_base = false)
+      locales = Array(locales).map(&:to_s).sort
+      if locales.include?(base_locale)
+        [base_locale] + (locales - [base_locale])
+      else
+        if include_base
+          [base_locale] + locales
+        else
+          locales
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/missing_keys.rb

@@ -1,34 +1,40 @@
 # coding: utf-8
 module I18n::Tasks
   module MissingKeys
+
+    MISSING_TYPES = {
+        used: {glyph: '✗', summary: 'used in code but missing from base locale'},
+        diff: {glyph: '∅', summary: 'translated in one locale but not in the other'}
+    }
+
+    def self.missing_keys_types
+      @missing_keys_types ||= MISSING_TYPES.keys
+    end
+
     def missing_keys_types
-      @missing_keys_types ||= [:used, :diff]
+      MissingKeys.missing_keys_types
     end
 
-    # @param [:missing_used, :missing_diff] type (default nil)
+    # @param [:missing_used, :missing_diff] types (default nil)
     # @return [Siblings]
     def missing_keys(opts = {})
-      locales = Array(opts[:locales]).presence || self.locales
-      types   = (Array(opts[:types]).presence || missing_keys_types).map(&:to_s)
-      validate_missing_types! types
+      locales = opts[:locales].presence || self.locales
+      types   = opts[:types].presence || missing_keys_types
       base    = opts[:base_locale] || base_locale
-      tree    = Data::Tree::Siblings.new
-
-      types.each do |type|
-        tree.merge! send(:"missing_#{type}_forest", locales, base)
+      types.inject(empty_forest) do |f, type|
+        f.merge! send(:"missing_#{type}_forest", locales, base)
       end
-      tree
     end
 
     def eq_base_keys(opts = {})
       locales = Array(opts[:locales]).presence || self.locales
-      (locales - [base_locale]).inject(Data::Tree::Siblings.new) { |tree, locale|
+      (locales - [base_locale]).inject(empty_forest) { |tree, locale|
         tree.merge! equal_values_tree(locale, base_locale)
       }
     end
 
     def missing_diff_forest(locales, base = base_locale)
-      tree = Data::Tree::Siblings.new
+      tree = empty_forest
       # present in base but not locale
       (locales - [base]).each { |locale|
         tree.merge! missing_diff_tree(locale, base)
@@ -36,7 +42,7 @@ module I18n::Tasks
       if locales.include?(base)
         # present in locale but not base
         (self.locales - [base]).each { |locale|
-          tree.merge! missing_diff_tree(base, locale).set_root_key(base)
+          tree.merge! missing_diff_tree(base, locale)
         }
       end
       tree
@@ -46,30 +52,35 @@ module I18n::Tasks
       if locales.include?(base)
         missing_used_tree(base)
       else
-        Data::Tree::Siblings.new
+        empty_forest
       end
     end
 
-    def missing_tree(locale, compared_to, collapse_plural = true)
+    def missing_tree(locale, compared_to)
       if locale == compared_to
         missing_used_tree locale
       else
-        missing_diff_tree locale, compared_to, collapse_plural
+        missing_diff_tree locale, compared_to
       end
     end
 
     # keys present in compared_to, but not in locale
-    def missing_diff_tree(locale, compared_to = base_locale, collapse_plural = true)
+    def missing_diff_tree(locale, compared_to = base_locale)
       data[compared_to].select_keys { |key, _node|
-        locale_key_missing?(locale, key)
-      }.set_root_key(locale, type: :missing_diff).tap { |t| collapse_plural_nodes!(t) if collapse_plural }
+        locale_key_missing? locale, depluralize_key(key, locale)
+      }.set_root_key!(locale, type: :missing_diff).keys { |_key, node|
+        if node.data.key?(:path)
+          # change path and locale to base
+          node.data.update path: LocalePathname.replace_locale(node.data[:path], node.data[:locale], locale), locale: locale
+        end
+      }
     end
 
     # keys used in the code missing translations in locale
     def missing_used_tree(locale)
       used_tree(strict: true).select_keys { |key, _node|
         locale_key_missing?(locale, key)
-      }.set_root_key(locale, type: :missing_used)
+      }.set_root_key!(locale, type: :missing_used)
     end
 
     def equal_values_tree(locale, compare_to = base_locale)
@@ -77,23 +88,11 @@ module I18n::Tasks
       data[locale].select_keys(root: false) { |key, node|
         other_node = base[key]
         other_node && node.value == other_node.value && !ignore_key?(key, :eq_base, locale)
-      }.set_root_key(locale, type: :eq_base)
+      }.set_root_key!(locale, type: :eq_base)
     end
 
     def locale_key_missing?(locale, key)
       !key_value?(key, locale) && !ignore_key?(key, :missing)
     end
-
-    private
-
-    def validate_missing_types!(types)
-      valid_types = missing_keys_types.map(&:to_s)
-      types = types.map(&:to_s)
-      invalid_types = types - valid_types
-      if invalid_types.present?
-        raise CommandError.new("Unknown types: #{invalid_types * ', '}. Valid types are: #{valid_types * ', '}.")
-      end
-      true
-    end
   end
 end

data/lib/i18n/tasks/plural_keys.rb

@@ -5,7 +5,7 @@ module I18n::Tasks::PluralKeys
   PLURAL_KEY_RE = /\.(?:#{PLURAL_KEY_SUFFIXES.to_a * '|'})$/
 
   def collapse_plural_nodes!(tree)
-    tree.leaves.map(&:parent).uniq.each do |node|
+    tree.leaves.select(&:parent?).map(&:parent).uniq.each do |node|
       children = node.children
       if children.present? && children.all? { |c| PLURAL_KEY_SUFFIXES.include?(c.key) }
         node.value    = children.to_hash

data/lib/i18n/tasks/reports/base.rb

@@ -12,13 +12,8 @@ module I18n::Tasks::Reports
 
     protected
 
-    MISSING_TYPES = {
-        missing_used:   {glyph: '✗', summary: 'used in code but missing from base locale'},
-        missing_diff: {glyph: '∅', summary: 'translated in one locale but not in the other'}
-    }
-
-    def missing_types
-      MISSING_TYPES
+    def missing_type_info(type)
+      ::I18n::Tasks::MissingKeys::MISSING_TYPES[type.to_s.sub(/\Amissing_/, '').to_sym]
     end
 
     def missing_title(forest)
@@ -36,13 +31,13 @@ module I18n::Tasks::Reports
     def used_title(used_tree)
       leaves = used_tree.leaves.to_a
       filter = used_tree.first.root.data[:key_filter]
-      used_n = leaves.map { |node| node.data[:source_locations].size }.reduce(:+).to_i
+      used_n = leaves.map { |node| node.data[:source_occurrences].size }.reduce(:+).to_i
       "#{leaves.length} key#{'s' if leaves.size != 1}#{" matching '#{filter}'" if filter}#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n > 0}"
     end
 
     # Sort keys by their attributes in order
     # @param [Hash] order e.g. {locale: :asc, type: :desc, key: :asc}
-    def sort_by_attr!(objects, order)
+    def sort_by_attr!(objects, order = {locale: :asc, key: :asc})
       order_keys = order.keys
       objects.sort! { |a, b|
         by = order_keys.detect { |by| a[by] != b[by] }

data/lib/i18n/tasks/reports/spreadsheet.rb

@@ -5,8 +5,8 @@ require 'fileutils'
 module I18n::Tasks::Reports
   class Spreadsheet < Base
 
-    def save_report(path = nil)
-      path = 'tmp/i18n-report.xlsx' if path.blank?
+    def save_report(path, opts)
+      path = path.presence || 'tmp/i18n-report.xlsx'
       p = Axlsx::Package.new
       add_missing_sheet p.workbook
       add_unused_sheet p.workbook
@@ -27,11 +27,11 @@ module I18n::Tasks::Reports
         regular_style = s.add_style
         wb.add_worksheet(name: missing_title(tree)) { |sheet|
           sheet.page_setup.fit_to :width => 1
-          sheet.add_row ['Type', 'Locale', 'Key', 'Base Value']
+          sheet.add_row [I18n.t('i18n_tasks.common.type'), I18n.t('i18n_tasks.common.locale'), I18n.t('i18n_tasks.common.key'), I18n.t('i18n_tasks.common.base_value')]
           style_header sheet
           tree.keys do |key, node|
             locale, type = node.root.data[:locale], node.data[:type]
-            sheet.add_row [missing_types[type][:summary], locale, key, task.t(key)],
+            sheet.add_row [missing_type_info(type)[:summary], locale, key, task.t(key)],
             styles: [type_cell, locale_cell, regular_style, regular_style]
           end
         }
@@ -52,7 +52,7 @@ module I18n::Tasks::Reports
 
     def add_locale_key_value_table(wb, keys, worksheet_opts = {})
       wb.add_worksheet worksheet_opts do |sheet|
-        sheet.add_row ['Locale', 'Key', 'Value']
+        sheet.add_row [I18n.t('i18n_tasks.common.locale'), I18n.t('i18n_tasks.common.key'), I18n.t('i18n_tasks.common.value')]
         style_header sheet
         keys.each do |locale_k_v|
           sheet.add_row locale_k_v

data/lib/i18n/tasks/reports/terminal.rb

@@ -8,71 +8,50 @@ module I18n
         include Term::ANSIColor
 
         def missing_keys(forest = task.missing_keys)
-          print_title missing_title(forest)
-
+          forest = task.collapse_plural_nodes!(forest)
           if forest.present?
-            keys_attr = sort_by_attr! forest_to_attr(forest), {locale: :asc, type: :desc, key: :asc}
-            print_table headings: [cyan(bold('Locale')), cyan(bold 'Key'), 'Details'] do |t|
-              t.rows = keys_attr.map do |a|
-                locale, key = a[:locale], a[:key], a[:type]
-                if a[:type] == :missing_used
-                  occ = a[:data][:source_locations]
-                  first = occ.first
-                  info = [green("#{first[:src_path]}:#{first[:line_num]}"),
-                          ("(#{occ.length - 1} more)" if occ.length > 1)].compact.join(' ')
-                else
-                  info = a[:value].to_s.strip
-                end
-                [{value: cyan(locale), alignment: :center},
-                 cyan(key),
-                 wrap_string(info, 60)]
+            print_title missing_title(forest)
+            print_table headings: [cyan(bold(I18n.t('i18n_tasks.common.locale'))), cyan(bold I18n.t('i18n_tasks.common.key')), I18n.t('i18n_tasks.common.details')] do |t|
+              t.rows = sort_by_attr!(forest_to_attr(forest)).map do |a|
+                [{value: cyan(a[:locale]), alignment: :center}, cyan(a[:key]), wrap_string(key_info(a), 60)]
               end
             end
           else
-            print_success 'No translations missing!'
+            print_success I18n.t('i18n_tasks.missing.none')
           end
         end
 
         def icon(type)
-          glyph = missing_types[type][:glyph]
+          glyph = missing_type_info(type)[:glyph]
           {missing_used: red(glyph), missing_diff: yellow(glyph)}[type]
         end
 
-        def used_keys(used_tree = task.used_tree(source_locations: true))
+        def used_keys(used_tree = task.used_tree(source_occurrences: true))
           print_title used_title(used_tree)
           keys_nodes = used_tree.keys.to_a
           if keys_nodes.present?
-            keys_nodes.sort! { |a, b| a[0] <=> b[0] }
-            keys_nodes.each do |key, node|
-              usages = node.data[:source_locations]
-              puts "#{bold "#{key}"} #{green(usages.size.to_s) if usages.size > 1}"
-              usages.each do |u|
-                line = u[:line].dup.tap { |line|
-                  line.strip!
-                  line.sub!(/(.*?)(#{key})(.*)$/) { dark($1) + underline($2) + dark($3) }
-                }
-                puts "  #{green "#{u[:src_path]}:#{u[:line_num]}"} #{line}"
-              end
+            keys_nodes.sort! { |a, b| a[0] <=> b[0] }.each do |key, node|
+              print_occurrences node, key
             end
           else
-            print_error 'No key usages found'
+            print_error I18n.t('i18n_tasks.usages.none')
           end
         end
 
         def unused_keys(tree = task.unused_keys)
           keys = tree.root_key_values(true)
-          print_title unused_title(keys)
           if keys.present?
+            print_title unused_title(keys)
             print_locale_key_value_table keys
           else
-            print_success 'Every translation is used!'
+            print_success I18n.t('i18n_tasks.unused.none')
           end
         end
 
         def eq_base_keys(tree = task.eq_base_keys)
           keys = tree.root_key_values(true)
-          print_title eq_base_title(keys)
           if keys.present?
+            print_title eq_base_title(keys)
             print_locale_key_value_table keys
           else
             print_info cyan('No translations are the same as base value')
@@ -83,11 +62,29 @@ module I18n
           print_locale_key_value_table tree.root_key_values(true)
         end
 
+        def forest_stats(forest, stats = task.forest_stats(forest))
+          text = if stats[:locale_count] == 1
+                   I18n.t('i18n_tasks.data_stats.text_single_locale', stats)
+                 else
+                   I18n.t('i18n_tasks.data_stats.text', stats)
+                 end
+          title = bold(I18n.t('i18n_tasks.data_stats.title', stats.slice(:locales)))
+          print_info "#{cyan title} #{cyan text}"
+        end
+
         private
 
+        def print_occurrences(node, full_key = node.full_key)
+          occurrences = node.data[:source_occurrences]
+          puts "#{bold "#{full_key}"} #{green(occurrences.size.to_s) if occurrences.size > 1}"
+          occurrences.each do |occurrence|
+            puts "  #{key_occurrence full_key, occurrence}"
+          end
+        end
+
         def print_locale_key_value_table(locale_key_values)
           if locale_key_values.present?
-            print_table headings: [bold(cyan('Locale')), bold(cyan('Key')), 'Value'] do |t|
+            print_table headings: [bold(cyan(I18n.t('i18n_tasks.common.locale'))), bold(cyan(I18n.t('i18n_tasks.common.key'))), I18n.t('i18n_tasks.common.value')] do |t|
               t.rows = locale_key_values.map { |(locale, k, v)| [{value: cyan(locale), alignment: :center}, cyan(k), v.to_s] }
             end
           else
@@ -100,7 +97,7 @@ module I18n
         end
 
         def print_success(message)
-          log_stderr(bold green ['Good job!', 'Well done!'].sample + ' ' + message)
+          log_stderr bold(green "✓ #{I18n.t('i18n_tasks.cmd.encourage').sample} #{message}")
         end
 
         def print_error(message)
@@ -120,9 +117,36 @@ module I18n
           puts ::Terminal::Table.new(opts, &block)
         end
 
+        def key_occurrence(full_key, info)
+          location = green "#{info[:src_path]}:#{info[:line_num]}"
+          source   = highlight_key(full_key, info[:line], info[:line_pos]..-1).strip
+          "#{location} #{source}"
+        end
+
+        def highlight_key(full_key, line, range = (0..-1))
+          result = line.dup
+          result[range] = result[range].sub!(full_key) { |m| underline m }
+          result
+        end
+
+        def key_info(leaf)
+          if leaf[:type] == :missing_used
+            first_occurrence leaf
+          else
+            leaf[:value].to_s.strip
+          end
+        end
+
+        def first_occurrence(leaf)
+          usages = leaf[:data][:source_occurrences]
+          first  = usages.first
+          [green("#{first[:src_path]}:#{first[:line_num]}"),
+           ("(#{I18n.t 'i18n_tasks.common.n_more', count: usages.length - 1})" if usages.length > 1)].compact.join(' ')
+        end
+
         def wrap_string(s, max)
           chars = []
-          dist = 0
+          dist  = 0
           s.chars.each do |c|
             chars << c
             dist += 1

data/lib/i18n/tasks/scanners/base_scanner.rb

@@ -36,13 +36,13 @@ module I18n::Tasks::Scanners
       @key_filter_pattern = compile_key_pattern(value) if @key_filter
     end
 
-    # @return [Array<{key,data:{source_locations:[]}}]
+    # @return [Array<{key,data:{source_occurrences:[]}}]
     def keys(opts = {})
       keys = traverse_files { |path|
         scan_file(path, opts)
       }.reduce(:+) || []
       keys.group_by(&:first).map { |key, key_loc|
-        [key, data: {source_locations: key_loc.map { |(k, attr)| attr[:data] }}]
+        [key, data: {source_occurrences: key_loc.map { |(k, attr)| attr[:data] }}]
       }
     end
 
@@ -115,8 +115,9 @@ module I18n::Tasks::Scanners
       key
     end
 
-    VALID_KEY_RE = /^[-\w.\#{}]+$/
-    VALID_KEY_RE_STRICT = /^[-\w.]+$/
+    VALID_KEY_CHARS = /[-\w.?!;:]/
+    VALID_KEY_RE_STRICT = /^#{VALID_KEY_CHARS}+$/
+    VALID_KEY_RE = /^(#{VALID_KEY_CHARS}|[\#{}])+$/
 
     def valid_key?(key, strict = false)
       return false if @key_filter && @key_filter_pattern !~ key

data/lib/i18n/tasks/slop_command.rb

@@ -0,0 +1,27 @@
+module I18n::Tasks::SlopCommand
+  extend self
+
+  def slop_command(name, attr, &block)
+    proc {
+      command name.tr('_', '-') do
+        opts = attr[:opt]
+        args = attr[:args]
+        banner "Usage: i18n-tasks #{name} [options] #{args}" if args.present?
+        desc = attr[:desc]
+        description desc if desc
+        if opts
+          opts.each do |opt|
+            on *[:short, :long, :desc, :conf].map { |k| opt[k] }.compact
+          end
+        end
+        run { |opts, args| block.call(name, opts, args) }
+      end
+    }
+  end
+
+  def parse_slop_opts_args(opts, args)
+    opts = opts.to_hash(true).reject { |k, v| v.nil? }
+    opts.merge!(arguments: args) unless args.empty?
+    opts
+  end
+end