i18n-tasks 0.2.19 → 0.2.20

data/lib/i18n/tasks/data_traversal.rb

@@ -3,11 +3,11 @@ module I18n::Tasks::DataTraversal
   # @return [String,nil]
   def t(hash = data[base_locale], key)
     if hash.is_a?(String)
-      # has is a locale
+      # hash is a locale
       raise ArgumentError.new("invalid locale: #{hash}") if hash =~ /[^A-z\d-]/
       hash = data[hash]
     end
-    key.split('.').inject(hash) { |r, seg| r[seg] if r }
+    key.to_s.split('.').inject(hash) { |r, seg| r[seg] if r }
   end
 
   # traverse => map if yield(k, v)

data/lib/i18n/tasks/fill_tasks.rb

@@ -22,7 +22,7 @@ module I18n::Tasks::FillTasks
     locales = non_base_locales(locales)
     normalize_store! locales
     locales.each do |locale|
-      blank_keys = find_blank_keys(locale).select { |k|
+      blank_keys = keys_missing_from_locale(locale).key_names.select { |k|
         tr = t(k)
         tr.present? && tr.is_a?(String)
       }
@@ -48,17 +48,8 @@ module I18n::Tasks::FillTasks
   # fill blank values with values from passed block
   # @param [String] locale
   def set_blank_values!(locale = base_locale, &fill_with)
-    blank_keys   = find_blank_keys locale
+    blank_keys   = keys_missing_from_locale(locale).key_names
     list         = blank_keys.zip fill_with.call(blank_keys)
     data[locale] = data[locale].deep_merge(list_to_tree(list))
   end
-
-
-  def find_blank_keys(locale, include_missing = (locale == base_locale))
-    blank_keys = traverse_map_if(data[base_locale]) { |key, value|
-      key if !key_value?(key, locale) && !ignore_key?(key, :missing)
-    }
-    blank_keys += keys_not_in_base if include_missing
-    blank_keys.uniq
-  end
 end

data/lib/i18n/tasks/ignore_keys.rb

@@ -10,7 +10,9 @@ module I18n::Tasks::IgnoreKeys
   # @param locale [String] only when type is :eq_base
   # @return [Regexp] a regexp that matches all the keys ignored for the type (and locale)
   def ignore_pattern(type, locale = nil)
-    ((@ignore_patterns ||= HashWithIndifferentAccess.new)[type] ||= {})[locale] = begin
+    @ignore_patterns              ||= HashWithIndifferentAccess.new
+    @ignore_patterns[type]        ||= {}
+    @ignore_patterns[type][locale] ||= begin
       global, type_ignore = config[:ignore].presence || [], config["ignore_#{type}"].presence || []
       if type_ignore.is_a?(Array)
         patterns = global + type_ignore

data/lib/i18n/tasks/key.rb

@@ -0,0 +1,60 @@
+module I18n
+  module Tasks
+    class Key
+      attr_accessor :own_attr, :key_group
+
+      def initialize(key_or_attr, own_attr = {})
+        @own_attr = if key_or_attr.is_a?(Array)
+                      {key: key_or_attr[0], value: key_or_attr[1]}.merge(own_attr)
+                    elsif key_or_attr.is_a?(Hash)
+                      key_or_attr.merge(own_attr)
+                    else
+                      own_attr.merge(key: key_or_attr)
+                    end
+
+        @own_attr[:key] = @own_attr[:key].to_s
+      end
+
+      def [](prop)
+        @own_attr[prop] || key_group.attr[prop]
+      end
+
+      def attr
+        key_group.attr.merge @own_attr
+      end
+
+      def ==(other)
+        self.attr == other.attr
+      end
+
+      def inspect
+        "#<#{self.class.name}#{attr.inspect}>"
+      end
+
+      def clone_orphan
+        clone.tap { |k| k.key_group = nil }
+      end
+
+      def key
+        @own_attr[:key]
+      end
+      alias to_s key
+
+      def value
+        self[:value]
+      end
+
+      def locale
+        self[:locale]
+      end
+
+      def type
+        self[:type]
+      end
+
+      def src_pos
+        self[:src_pos]
+      end
+    end
+  end
+end

data/lib/i18n/tasks/key_group.rb

@@ -0,0 +1,65 @@
+require 'set'
+module I18n
+  module Tasks
+    class KeyGroup
+      attr_reader :keys, :attr, :key_names
+
+      delegate :size, :length, :each, :[], to: :keys
+      include Enumerable
+
+      def initialize(keys, attr = {})
+        @keys = if keys && !keys[0].is_a?(::I18n::Tasks::Key)
+                  keys.map { |key| I18n::Tasks::Key.new(key) }
+                else
+                  keys
+                end
+        @keys.each { |key| key.key_group ||= self } unless attr.delete(:orphan)
+
+        @keys_by_name = @keys.inject({}) { |h, k| h[k.key.to_s] = k; h }
+        @key_names    = @keys.map(&:key)
+        @attr         = attr
+      end
+
+      def find_by_name(key)
+        @keys_by_name[key.to_s]
+      end
+
+      def key_names_set
+        @key_names_set ||= Set.new(@key_names)
+      end
+
+      def include?(key)
+        key_names_set.include?(key.to_s)
+      end
+
+      # order, e.g: {locale: :asc, type: :desc, key: :asc}
+      def sort!(&block)
+        @keys.sort!(&block)
+        @key_names = @keys.map(&:to_s)
+        self
+      end
+
+      def sort_by_attr!(order)
+        order_keys = order.keys
+        sort! { |a, b|
+          by = order_keys.detect { |by| a[by] != b[by] }
+          order[by] == :desc ? b[by] <=> a[by] : a[by] <=> b[by]
+        }
+        self
+      end
+
+      def to_a
+        @array ||= keys.map(&:attr)
+      end
+
+      alias as_json to_a
+
+      def merge(other)
+        KeyGroup.new(keys + other.keys,
+                     type: [attr[:type], other.attr[:type]].flatten.compact)
+      end
+
+      alias + merge
+    end
+  end
+end

data/lib/i18n/tasks/missing_keys.rb

@@ -1,23 +1,56 @@
-module I18n::Tasks::MissingKeys
-  # @return Array missing keys, i.e. key that are in the code but are not in the base locale data
-  def keys_not_in_base
-    find_source_keys.reject { |key|
-      key_value?(key, base_locale) || pattern_key?(key) || ignore_key?(key, :missing)
-    }
-  end
+module I18n::Tasks
+  module MissingKeys
+    # @param [:missing_from_base, :missing_from_locale, :eq_base] type (default nil)
+    # @return [KeyGroup]
+    def missing_keys(opts = {})
+      type = opts[:type]
+      locales = non_base_locales(opts[:locales])
+      if type
+        if type == :missing_from_base
+          keys_missing_from_base
+        else
+          locales.map { |locale| send("keys_#{type}", locale) }.reduce(:+)
+        end
+      else
+        missing_keys(type: :missing_from_base) +
+          missing_keys(type: :eq_base, locales: locales) +
+          missing_keys(type: :missing_from_locale, locales: locales)
+      end
+    end
 
-  # @return Array keys missing (nil or blank?) in locale but present in base
-  def keys_blank_in_locale(locale)
-    traverse_map_if data[base_locale] do |key, base_value|
-      key if !ignore_key?(key, :missing) && !key_value?(key, locale) && !key_value?(depluralize_key(key), locale)
+    def untranslated_keys(locales = nil)
+      I18n::Tasks.warn_deprecated("#untranslated_keys. Please use #missing_keys instead")
+      missing_keys(locales: locales)
     end
-  end
 
-  # @return Array keys missing value (but present in base)
-  def keys_eq_base(locale)
-    traverse_map_if data[base_locale] do |key, base_value|
-      key if base_value == t(locale, key) && !ignore_key?(key, :eq_base, locale)
+    # @return [KeyGroup] missing keys, i.e. key that are in the code but are not in the base locale data
+    def keys_missing_from_base
+      @keys_missing_from_base ||= begin
+        KeyGroup.new(
+            used_keys.keys.reject { |k|
+              key = k.key
+              key_value?(key, base_locale) || pattern_key?(key) || ignore_key?(key, :missing)
+            }.map(&:clone_orphan), type: :missing_from_base, locale: base_locale)
+      end
     end
-  end
 
-end
+    # @return [KeyGroup] keys missing (nil or blank?) in locale but present in base
+    def keys_missing_from_locale(locale)
+      return keys_missing_from_base if locale == base_locale
+      @keys_missing_from_locale         ||= {}
+      @keys_missing_from_locale[locale] ||= KeyGroup.new(
+          traverse_map_if(data[base_locale]) { |key, base_value|
+            key if !ignore_key?(key, :missing) && !key_value?(key, locale) && !key_value?(depluralize_key(key), locale)
+          }, type: :missing_from_locale, locale: locale)
+
+    end
+
+    # @return [KeyGroup] keys missing value (but present in base)
+    def keys_eq_base(locale)
+      @keys_eq_base ||= KeyGroup.new(
+          traverse_map_if(data[base_locale]) { |key, base_value|
+            key if base_value == t(locale, key) && !ignore_key?(key, :eq_base, locale)
+          }, type: :eq_base, locale: locale)
+    end
+  end
+end

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

@@ -9,9 +9,9 @@ module I18n::Tasks::Reports
     attr_reader :task
 
     MISSING_TYPES = {
-        none:    {glyph: '✗', summary: 'key missing'},
-        blank:   {glyph: '∅', summary: 'translation blank'},
-        eq_base: {glyph: '=', summary: 'value same as base value'}
+        missing_from_base:   {glyph: '✗', summary: 'missing from base locale'},
+        missing_from_locale: {glyph: '∅', summary: 'missing from locale but present in base locale'},
+        eq_base: {glyph: '=', summary: 'value equals base value'}
     }
 
     def missing_types
@@ -25,5 +25,9 @@ module I18n::Tasks::Reports
     def unused_title(recs)
       "Unused keys (#{recs.length})"
     end
+
+    def used_title(keys)
+      "#{keys.length} keys used #{keys.map { |k| k[:usages].size }.reduce(:+)} times"
+    end
   end
-end
+end

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

@@ -17,17 +17,17 @@ module I18n::Tasks::Reports
     private
 
     def add_missing_sheet(wb)
-      recs = task.untranslated_keys
+      keys = task.missing_keys
       wb.styles do |s|
         type_cell = s.add_style :alignment => {:horizontal => :center}
         locale_cell  = s.add_style :alignment => {:horizontal => :center}
         regular_style = s.add_style
-        wb.add_worksheet(name: missing_title(recs)) { |sheet|
+        wb.add_worksheet(name: missing_title(keys)) { |sheet|
           sheet.page_setup.fit_to :width => 1
           sheet.add_row ['Type', 'Locale', 'Key', 'Base Value']
           style_header sheet
-          recs.each do |rec|
-            sheet.add_row [missing_types[rec[:type]][:summary], rec[:locale], rec[:key], rec[:base_value]],
+          keys.each do |key|
+            sheet.add_row [missing_types[key.type][:summary], key.locale, key.key, task.t(key)],
             styles: [type_cell, locale_cell, regular_style, regular_style]
           end
         }
@@ -35,12 +35,12 @@ module I18n::Tasks::Reports
     end
 
     def add_unused_sheet(wb)
-      recs = task.unused_keys
-      wb.add_worksheet name: unused_title(recs) do |sheet|
+      keys = task.unused_keys
+      wb.add_worksheet name: unused_title(keys) do |sheet|
         sheet.add_row ['Key', 'Base Value']
         style_header sheet
-        recs.each do |rec|
-          sheet.add_row rec
+        keys.each do |key|
+          sheet.add_row [key.key, task.t(key)]
         end
       end
     end

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

@@ -7,26 +7,27 @@ module I18n
       class Terminal < Base
         include Term::ANSIColor
 
-        def missing_translations(recs = task.untranslated_keys)
-          print_title missing_title(recs)
-          if recs.present?
+        def missing_keys(keys = task.missing_keys)
+          keys.sort_by_attr!(locale: :asc, type: :asc, key: :asc)
+          print_title missing_title(keys)
+          if keys.present?
 
             $stderr.puts "#{bold 'Types:'} #{missing_types.values.map { |t| "#{t[:glyph]} #{t[:summary]}" } * ', '}"
 
             print_table headings: [magenta(bold('Locale')), bold('Type'), magenta('i18n Key'), bold(cyan "Base value (#{base_locale})")] do |t|
-              t.rows = recs.map { |rec|
-                glyph = missing_types[rec[:type]][:glyph]
-                glyph = {none: red(glyph), blank: yellow(glyph), eq_base: bold(blue(glyph))}[rec[:type]]
-                if rec[:type] == :none
-                  locale     = magenta bold rec[:locale]
+              t.rows = keys.map { |key|
+                glyph = missing_types[key.type][:glyph]
+                glyph = {missing_from_base: red(glyph), missing_from_locale: yellow(glyph), eq_base: bold(blue(glyph))}[key.type]
+                if key[:type] == :missing_from_base
+                  locale     = magenta bold key.locale
                   base_value = ''
                 else
-                  locale     = magenta rec[:locale]
-                  base_value = cyan rec[:base_value].to_s.strip
+                  locale     = magenta key.locale
+                  base_value = task.t(key.key).to_s.strip
                 end
                 [{value: locale, alignment: :center},
                  {value: glyph, alignment: :center},
-                 magenta(rec[:key]),
+                 magenta(key[:key]),
                  base_value]
               }
             end
@@ -35,11 +36,30 @@ module I18n
           end
         end
 
-        def unused_translations(recs = task.unused_keys)
-          print_title unused_title(recs)
-          if recs.present?
+        def used_keys(keys = task.used_keys)
+          print_title used_title(keys)
+          keys.sort_by_attr!(key: :asc)
+          if keys.present?
+            keys.each do |k|
+              puts "#{bold k.key} (#{k[:usages].size}):"
+              k[:usages].each do |u|
+                line = faint u[:line].dup.tap { |line|
+                  line.sub!(k[:key], underline(k[:key]))
+                  line.strip!
+                }
+                puts "  #{u[:path]}:#{u[:line_num]}: #{faint line}"
+              end
+            end
+          else
+            print_error 'No key usages found. Please check configuration in config/i18n-tasks.yml'
+          end
+        end
+
+        def unused_keys(keys = task.unused_keys)
+          print_title unused_title(keys)
+          if keys.present?
             print_table headings: [bold(magenta('i18n Key')), cyan("Base value (#{base_locale})")] do |t|
-              t.rows = recs.map { |x| [magenta(x[0]), cyan(x[1])] }
+              t.rows = keys.map { |k| [magenta(k.key), cyan(k.value)] }
             end
           else
             print_success 'Good job! Every translation is used!'
@@ -56,7 +76,10 @@ module I18n
           $stderr.puts(bold green message)
         end
 
-        private
+        def print_error(message)
+          $stderr.puts(bold red message)
+        end
+
         def indent(txt, n = 2)
           spaces = ' ' * n
           txt.gsub /^/, spaces

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

@@ -14,11 +14,36 @@ module I18n::Tasks::Scanners
 
     # @return [Array] found key usages, absolutized and unique
     def keys
-      @keys ||= traverse_files { |path| scan_file(path) }.flatten.uniq
+      @keys ||= begin
+        @keys_by_name = {}
+        keys   = []
+        usages = traverse_files { |path|
+          ::I18n::Tasks::KeyGroup.new(scan_file(path), src_path: path) }.map(&:keys).flatten
+        usages.group_by(&:key).each do |key, instances|
+          key = {
+              key: key,
+              usages: instances.map { |inst| inst[:src].merge(path: inst[:src_path]) }
+          }
+          @keys_by_name[key.to_s] = key
+          keys << key
+        end
+        keys
+      end
+    end
+
+    def key_usages(key)
+      keys
+      @keys_by_name[key.to_s][:usages]
+    end
+
+    def read_file(path)
+      result = nil
+      File.open(path, 'rb') { |f| result = f.read }
+      result
     end
 
     # @return [String] keys used in file (unimplemented)
-    def scan_file(path)
+    def scan_file(path, *args)
       raise 'Unimplemented'
     end
 
@@ -37,6 +62,15 @@ module I18n::Tasks::Scanners
 
     protected
 
+    def usage_context(text, src_pos)
+      line_begin = text.rindex(/^/, src_pos - 1)
+      line_end   = text.index(/.(?=\n|$)/, src_pos)
+      {pos:      src_pos,
+       line_num: text[0..src_pos].count("\n") + 1,
+       line_pos: src_pos - line_begin + 1,
+       line:     text[line_begin..line_end]}
+    end
+
     def extract_key_from_match(match, path)
       key = strip_literal(match[0])
       key = absolutize_key(key, path) if path && key.start_with?('.')