i18n-tasks 0.4.5 → 0.5.0

data/lib/i18n/tasks/ignore_keys.rb

@@ -14,7 +14,7 @@ module I18n::Tasks::IgnoreKeys
     @ignore_patterns              ||= HashWithIndifferentAccess.new
     @ignore_patterns[type]        ||= {}
     @ignore_patterns[type][locale] ||= begin
-      global, type_ignore = config[:ignore].presence || [], config["ignore_#{type}"].presence || []
+      global, type_ignore = ignore_config.presence || [], ignore_config(type).presence || []
       if type_ignore.is_a?(Array)
         patterns = global + type_ignore
       elsif type_ignore.is_a?(Hash)

data/lib/i18n/tasks/key_pattern_matching.rb

@@ -29,4 +29,21 @@ module I18n::Tasks::KeyPatternMatching
         gsub(/:/, '(?<=^|\.)[^.]+?(?=\.|$)').
         gsub(/\{(.*?)}/) { "(#{$1.strip.gsub /\s*,\s*/, '|'})" }
   end
+
+  def key_match_pattern(k)
+    @key_match_pattern ||= {}
+    @key_match_pattern[k] ||= begin
+      "#{k.gsub(KEY_INTERPOLATION_RE, '*')}#{'*' if k.end_with?('.')}"
+    end
+  end
+
+  # @return true if the key looks like an expression
+  KEY_INTERPOLATION_RE = /(?:\#{.*?}|\*+)/.freeze
+  def key_expression?(k)
+    @key_is_expr ||= {}
+    if @key_is_expr[k].nil?
+      @key_is_expr[k] = (k =~ KEY_INTERPOLATION_RE || k.end_with?('.'))
+    end
+    @key_is_expr[k]
+  end
 end

data/lib/i18n/tasks/missing_keys.rb

@@ -1,61 +1,56 @@
 # coding: utf-8
 module I18n::Tasks
   module MissingKeys
+    def missing_keys_types
+      @missing_keys_types ||= [:missing_from_base, :eq_base, :missing_from_locale]
+    end
+
     # @param [:missing_from_base, :missing_from_locale, :eq_base] type (default nil)
-    # @return [KeyGroup]
+    # @return [Siblings]
     def missing_keys(opts = {})
       locales = Array(opts[:locales]).presence || self.locales
-      type    = opts[:type]
-      unless type
-        types = opts[:types].presence || missing_keys_types
-        opts  = opts.except(:types).merge(locales: locales)
-        return types.map { |t| missing_keys(opts.merge(type: t)) }.reduce(:+)
-      end
-
-      if type.to_s == 'missing_from_base'
-        keys = keys_missing_from_base if locales.include?(base_locale)
-      else
-        keys = non_base_locales(locales).map { |locale|
-          send("keys_#{type}", locale)
-        }.reduce(:+)
-      end
-      keys || KeyGroup.new([])
-    end
+      types   = Array(opts[:type] || opts[:types].presence || missing_keys_types)
 
-    def missing_keys_types
-      @missing_keys_types ||= [:missing_from_base, :eq_base, :missing_from_locale]
+      types.map { |type|
+        case type.to_s
+          when 'missing_from_base'
+            missing_tree(base_locale) if locales.include?(base_locale)
+          when 'missing_from_locale'
+            non_base_locales(locales).map { |locale| missing_tree(locale) }.reduce(:merge!)
+          when 'eq_base'
+            non_base_locales(locales).map { |locale| eq_base_tree(locale) }.reduce(:merge!)
+        end
+      }.compact.reduce(:merge!)
     end
 
-    # @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
-        keys = used_keys.keys.reject { |k|
-          key = k.key
-          k.expr? || key_value?(key, base_locale) || ignore_key?(key, :missing)
-        }.map(&:clone_orphan)
-        KeyGroup.new keys, type: :missing_from_base, locale: base_locale
+    def missing_tree(locale, compared_to = base_locale)
+      if locale == compared_to
+        # keys used, but not present in locale
+        set_locale_tree_type used_tree.select_keys { |key, node|
+          !(key_expression?(key) || key_value?(key, locale) || ignore_key?(key, :missing))
+        }, locale, :missing_from_base
+      else
+        # keys present in compared_to, but not in locale
+        collapse_plural_nodes! set_locale_tree_type data[compared_to].select_keys { |key, node|
+          !key_value?(key, locale) && !ignore_key?(key, :missing)
+        }, locale, :missing_from_locale
       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] ||= begin
-        keys = missing_tree(locale).key_names.map { |key| depluralize_key(key, locale) }.uniq
-        KeyGroup.new keys, type: :missing_from_locale, locale: locale
-      end
+    def eq_base_tree(locale, compare_to = base_locale)
+      base = data[compare_to].first.children
+      set_locale_tree_type 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)
+      }, locale, :eq_base
     end
 
-    # @return [KeyGroup] keys missing value (but present in base)
-    def keys_eq_base(locale)
-      @keys_eq_base         ||= {}
-      @keys_eq_base[locale] ||= begin
-        keys = data[base_locale].keys(root: false).map { |key, node|
-          key if node.value == t(key, locale) && !ignore_key?(key, :eq_base, locale)
-        }.compact
-        KeyGroup.new keys, type: :eq_base, locale: locale
-      end
+    def set_locale_tree_type(tree, locale, type)
+      tree.siblings { |root|
+        root.key = locale
+      }.leaves { |node|
+        node.data[:type] = type
+      }
     end
   end
 end

data/lib/i18n/tasks/plural_keys.rb

@@ -1,6 +1,19 @@
 # coding: utf-8
 module I18n::Tasks::PluralKeys
-  PLURAL_KEY_RE = /\.(?:zero|one|two|few|many|other)$/
+  PLURAL_KEY_SUFFIXES = Set.new %w(zero one two few many other)
+  PLURAL_KEY_RE = /\.(?:#{PLURAL_KEY_SUFFIXES.to_a * '|'})$/
+
+  def collapse_plural_nodes!(tree)
+    tree.leaves.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
+        node.data.merge!(children.first.data)
+        node.children = nil
+      end
+    end
+    tree
+  end
 
   # @param [String] key i18n key
   # @param [String] locale to pull key data from

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

@@ -10,6 +10,8 @@ module I18n::Tasks::Reports
     attr_reader :task
     delegate :base_locale, :locales, to: :task
 
+    protected
+
     MISSING_TYPES = {
         missing_from_base:   {glyph: '✗', summary: 'missing from base locale'},
         missing_from_locale: {glyph: '∅', summary: 'missing from locale but present in base locale'},
@@ -20,18 +22,36 @@ module I18n::Tasks::Reports
       MISSING_TYPES
     end
 
-    def missing_title(recs)
-      "Missing translations (#{recs.length})"
+    def missing_title(forest)
+      "Missing translations (#{forest.leaves.count || '∅'})"
+    end
+
+    def unused_title(key_values)
+      "Unused keys (#{key_values.count || '∅'})"
+    end
+
+    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
+      "#{leaves.length} key#{'s' if leaves.size != 1}#{" ~ filter: '#{filter}'" if filter}#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n > 0}"
     end
 
-    def unused_title(recs)
-      "Unused keys (#{recs.length})"
+    # Sort keys by their attributes in order
+    # @param [Hash] order e.g. {locale: :asc, type: :desc, key: :asc}
+    def sort_by_attr!(objects, order)
+      order_keys = order.keys
+      objects.sort! { |a, b|
+        by = order_keys.detect { |by| a[by] != b[by] }
+        order[by] == :desc ? b[by] <=> a[by] : a[by] <=> b[by]
+      }
+      objects
     end
 
-    def used_title(keys)
-      filter = keys.attr[:key_filter]
-      used_n = keys.map { |k| k[:usages].size }.reduce(:+).to_i
-      "#{keys.length} key#{'s' if keys.size != 1}#{" ~ '#{filter}'" if filter}#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n > 0}"
+    def forest_to_attr(forest)
+      forest.keys(root: false).map { |key, node|
+        {key: key, type: node.data[:type], locale: node.root.key}
+      }
     end
   end
 end

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

@@ -19,17 +19,18 @@ module I18n::Tasks::Reports
     private
 
     def add_missing_sheet(wb)
-      keys = task.missing_keys
+      tree = 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(keys)) { |sheet|
+        wb.add_worksheet(name: missing_title(tree)) { |sheet|
           sheet.page_setup.fit_to :width => 1
           sheet.add_row ['Type', 'Locale', 'Key', 'Base Value']
           style_header sheet
-          keys.each do |key|
-            sheet.add_row [missing_types[key.type][:summary], key.locale, key.key, task.t(key)],
+          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)],
             styles: [type_cell, locale_cell, regular_style, regular_style]
           end
         }
@@ -37,12 +38,12 @@ module I18n::Tasks::Reports
     end
 
     def add_unused_sheet(wb)
-      keys = task.unused_keys
+      keys = task.unused_keys.root_key_values.sort { |a, b| a[0] != b[0] ? a[0] <=> b[0] : a[1] <=> b[1] }
       wb.add_worksheet name: unused_title(keys) do |sheet|
-        sheet.add_row ['Key', 'Base Value']
+        sheet.add_row ['Locale', 'Key', 'Value']
         style_header sheet
-        keys.each do |key|
-          sheet.add_row [key.key, task.t(key)]
+        keys.each do |locale_k_v|
+          sheet.add_row locale_k_v
         end
       end
     end

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

@@ -7,45 +7,49 @@ module I18n
       class Terminal < Base
         include Term::ANSIColor
 
-        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?
+        def missing_keys(forest = task.missing_keys)
+          print_title missing_title(forest)
 
+          if forest.present?
             print_info "#{bold 'Types:'} #{missing_types.values.map { |t| "#{t[:glyph]} #{t[:summary]}" } * ', '}"
-
+            keys_data = sort_by_attr! forest_to_attr(forest), {locale: :asc, type: :asc, key: :asc}
             print_table headings: [magenta(bold('Locale')), bold('Type'), magenta(bold 'i18n Key'), bold(cyan "Base value (#{base_locale})")] do |t|
-              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 key.locale
+              t.rows = keys_data.map do |d|
+                key    = d[:key]
+                type   = d[:type]
+                locale = d[:locale]
+                glyph  = missing_types[type][:glyph]
+                glyph  = {missing_from_base: red(glyph), missing_from_locale: yellow(glyph), eq_base: bold(blue(glyph))}[type]
+                if type == :missing_from_base
+                  locale     = magenta locale
                   base_value = ''
                 else
-                  locale     = magenta key.locale
-                  base_value = task.t(key.key).to_s.strip
+                  locale     = magenta locale
+                  base_value = task.t(key, base_locale).to_s.strip
                 end
                 [{value: locale, alignment: :center},
                  {value: glyph, alignment: :center},
-                 magenta(key[:key]),
+                 magenta(key),
                  cyan(base_value)]
-              }
+              end
             end
           else
-            print_success 'Good job! No translations missing!'
+            print_success 'No translations missing!'
           end
         end
 
-        def used_keys(keys = task.used_keys(src_locations: true))
-          print_title used_title(keys)
-          keys.sort_by_attr!(key: :asc)
-          if keys.present?
-            keys.each do |k|
-              puts "#{bold "#{k.key}"} #{green(k.usages.size.to_s) if k.usages.size > 1}"
-              k.usages.each do |u|
+        def used_keys(used_tree = task.used_tree(source_locations: 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!(/(.*?)(#{k[:key]})(.*)$/) { dark($1) + underline($2) + dark($3)}
+                  line.sub!(/(.*?)(#{key})(.*)$/) { dark($1) + underline($2) + dark($3) }
                 }
                 puts "  #{green "#{u[:path]}:#{u[:line_num]}"} #{line}"
               end
@@ -55,15 +59,15 @@ module I18n
           end
         end
 
-        def unused_keys(keys = task.unused_keys)
+        def unused_keys(tree = task.unused_keys)
+          keys = tree.root_key_values.sort { |a, b| a[0] != b[0] ? a[0] <=> b[0] : a[1] <=> b[1] }
           print_title unused_title(keys)
-          keys.sort_by_attr!(key: :asc)
           if keys.present?
-            print_table headings: [bold(magenta('i18n Key')), bold(cyan("Base value (#{base_locale})"))] do |t|
-              t.rows = keys.map { |k| [magenta(k.key), cyan(k.value)] }
+            print_table headings: [bold(magenta('Locale')), bold(magenta('i18n Key')), bold(cyan("Base value (#{base_locale})"))] do |t|
+              t.rows = keys.map { |(locale, k, v)| [magenta(locale), magenta(k), cyan(v.to_s)] }
             end
           else
-            print_success 'Good job! Every translation is used!'
+            print_success 'Every translation is used!'
           end
         end
 
@@ -74,7 +78,7 @@ module I18n
         end
 
         def print_success(message)
-          log_stderr(bold green message)
+          log_stderr(bold green ['Good job!', 'Well done!'].sample + ' ' + message)
         end
 
         def print_error(message)

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

@@ -10,7 +10,7 @@ module I18n::Tasks::Scanners
     attr_reader :config, :key_filter, :record_src_loc
 
     def initialize(config = {})
-      @config        = config.dup.with_indifferent_access.tap do |conf|
+      @config         = config.dup.with_indifferent_access.tap do |conf|
         conf[:paths]   = %w(app/) if conf[:paths].blank?
         conf[:include] = Array(conf[:include]) if conf[:include].present?
         if conf.key?(:exclude)
@@ -28,22 +28,23 @@ module I18n::Tasks::Scanners
       @key_filter_pattern = compile_key_pattern(value) if @key_filter
     end
 
-    # @return [Array] found key usages, absolutized and unique
+    # @return [Array] keys used in source, absolutized and unique
     def keys
-      @keys ||= (traverse_files { |path| scan_file(path) }.reduce(:+) || []).uniq(&:key)
+      @keys ||= (traverse_files { |path| scan_file(path) }.reduce(:+) || []).uniq(&:first)
     end
 
-    def keys_with_src_locations
-      with_src_locations do
+    # @return [Array<{key,usages}]
+    def keys_with_source_locations
+      recording_source_locations do
         keys = traverse_files { |path|
-          ::I18n::Tasks::KeyGroup.new(scan_file(path), src_path: path)
+          scan_file(path)
         }.reduce(:+) || []
-        keys.group_by(&:key).map { |key, key_loc|
-          {key: key, usages: key_loc.map { |k| k[:src].merge(path: k[:src_path]) }}
+        keys.group_by(&:first).map { |key, key_loc|
+          [key, data: {source_locations: key_loc.map { |(k, attr)| attr[:data] }}]
         }
       end
     end
-    
+
     def read_file(path)
       result = nil
       File.open(path, 'rb') { |f| result = f.read }
@@ -86,7 +87,7 @@ module I18n::Tasks::Scanners
       self.key_filter = filter_was
     end
 
-    def with_src_locations
+    def recording_source_locations
       was             = @record_src_loc
       @record_src_loc = true
       yield
@@ -100,16 +101,23 @@ module I18n::Tasks::Scanners
       globs.any? { |glob| File.fnmatch(glob, path) }
     end
 
-    def src_location(text, src_pos)
-      return nil unless @record_src_loc
+    def src_location(path, text, src_pos)
+      src = {path: path}
+      if @record_src_loc
+        src.merge!(src_text_location(text, src_pos))
+      end
+      src
+    end
+
+    def src_text_location(text, src_pos)
       line_begin = text.rindex(/^/, src_pos - 1)
       line_end   = text.index(/.(?=\n|$)/, src_pos)
-      {src: {
+      {
           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
 
     # remove the leading colon and unwrap quotes from the key match

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

@@ -13,7 +13,7 @@ module I18n::Tasks::Scanners
         src_pos = Regexp.last_match.offset(0).first
         key     = match_to_key(match, path)
         next unless valid_key?(key)
-        keys << ::I18n::Tasks::Key.new(key, src_location(text, src_pos))
+        keys << [key, data: src_location(path, text, src_pos)]
       end
       keys
     end
@@ -34,6 +34,7 @@ module I18n::Tasks::Scanners
     # @return [String] full absolute key name
     def match_to_key(match, path)
       key = strip_literal(match[0])
+      key = key + '*' if key.end_with?('.')
       key = absolutize_key(key, path) if path && key.start_with?('.')
       key
     end

data/lib/i18n/tasks/unused_keys.rb

@@ -4,24 +4,24 @@ require 'set'
 module I18n
   module Tasks
     module UnusedKeys
-      # @return [Array<[String, String]>] all the unused translations as an array of [key, value] pairs
-      def unused_keys(locale = base_locale)
-        @unused_keys         ||= {}
-        @unused_keys[locale] ||= begin
-          keys = data[locale].keys(root: false).map { |key, value|
-            next if used_in_expr?(key) || ignore_key?(key, :unused)
-            key = depluralize_key(key, locale)
-            key unless used_key?(key)
-          }.compact.uniq
-          KeyGroup.new keys, locale: locale, type: :unused
-        end
+      def unused_keys(opts = {})
+        locales = Array(opts[:locales]).presence || self.locales
+        locales.map { |locale| unused_tree locale }.compact.reduce(:merge!)
+      end
+
+      def unused_tree(locale = base_locale)
+        collapse_plural_nodes! data[locale].select_keys { |key, _node|
+          !ignore_key?(key, :unused) &&
+              !used_in_expr?(key) &&
+              !used_key?(depluralize_key(key, locale))
+        }
       end
 
       def remove_unused!(locales = nil)
         locales ||= self.locales
-        unused  = unused_keys
         locales.each do |locale|
-          data[locale] = data[locale].select_keys(root: false) { |key, value|
+          unused       = unused_tree(locale).key_names.to_set
+          data[locale] = data[locale].select_keys { |key, value|
             !unused.include?(depluralize_key(key, locale))
           }
         end