i18n-tasks 0.5.4 → 0.6.0

data/lib/i18n/tasks/plural_keys.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+require 'set'
 module I18n::Tasks::PluralKeys
   PLURAL_KEY_SUFFIXES = Set.new %w(zero one two few many other)
   PLURAL_KEY_RE = /\.(?:#{PLURAL_KEY_SUFFIXES.to_a * '|'})$/
@@ -20,10 +21,10 @@ module I18n::Tasks::PluralKeys
   # @return the base form if the key is a specific plural form (e.g. apple for apple.many), and the key as passed otherwise
   def depluralize_key(key, locale = base_locale)
     return key if key !~ PLURAL_KEY_RE
-    node = node(key, locale)
-    nodes = node.try(:siblings).presence || (locale != base_locale && node(key, base_locale).try(:siblings))
+    parent_key = split_key(key)[0..-2] * '.'
+    nodes = tree("#{locale}.#{parent_key}").presence || (locale != base_locale && tree("#{base_locale}.#{parent_key}"))
     if nodes && nodes.all? { |x| x.leaf? && ".#{x.key}" =~ PLURAL_KEY_RE }
-      key.split('.')[0..-2] * '.'
+      parent_key
     else
       key
     end

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

@@ -13,9 +13,8 @@ module I18n::Tasks::Reports
     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'},
-        eq_base: {glyph: '=', summary: 'value equals base value'}
+        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
@@ -30,11 +29,15 @@ module I18n::Tasks::Reports
       "Unused keys (#{key_values.count || '∅'})"
     end
 
+    def eq_base_title(key_values, locale = base_locale)
+      "Same value as #{locale} (#{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}"
+      "#{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
@@ -50,7 +53,7 @@ module I18n::Tasks::Reports
 
     def forest_to_attr(forest)
       forest.keys(root: false).map { |key, node|
-        {key: key, type: node.data[:type], locale: node.root.key}
+        {key: key, value: node.value, type: node.data[:type], locale: node.root.key, data: node.data}
       }
     end
   end

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

@@ -10,6 +10,7 @@ module I18n::Tasks::Reports
       p = Axlsx::Package.new
       add_missing_sheet p.workbook
       add_unused_sheet p.workbook
+      add_eq_base_sheet p.workbook
       p.use_shared_strings = true
       FileUtils.mkpath(File.dirname(path))
       p.serialize(path)
@@ -37,9 +38,20 @@ module I18n::Tasks::Reports
       end
     end
 
+    def add_eq_base_sheet(wb)
+      keys = task.eq_base_keys.root_key_values(true)
+      add_locale_key_value_table wb, keys, name: eq_base_title(keys)
+    end
+
     def add_unused_sheet(wb)
-      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|
+      keys = task.unused_keys.root_key_values(true)
+      add_locale_key_value_table wb, keys, name: unused_title(keys)
+    end
+
+    private
+
+    def add_locale_key_value_table(wb, keys, worksheet_opts = {})
+      wb.add_worksheet worksheet_opts do |sheet|
         sheet.add_row ['Locale', 'Key', 'Value']
         style_header sheet
         keys.each do |locale_k_v|
@@ -48,7 +60,7 @@ module I18n::Tasks::Reports
       end
     end
 
-    private
+
     def style_header(sheet)
       border_bottom = sheet.workbook.styles.add_style(border: {style: :thin, color: '000000', edges: [:bottom]})
       sheet.rows.first.style = border_bottom

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

@@ -11,26 +11,21 @@ module I18n
           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_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 = ''
+            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
-                  locale     = magenta locale
-                  base_value = task.t(key, base_locale).to_s.strip
+                  info = a[:value].to_s.strip
                 end
-                [{value: locale, alignment: :center},
-                 {value: glyph, alignment: :center},
-                 magenta(key),
-                 cyan(base_value)]
+                [{value: cyan(locale), alignment: :center},
+                 cyan(key),
+                 wrap_string(info, 60)]
               end
             end
           else
@@ -38,6 +33,11 @@ module I18n
           end
         end
 
+        def icon(type)
+          glyph = missing_types[type][:glyph]
+          {missing_used: red(glyph), missing_diff: yellow(glyph)}[type]
+        end
+
         def used_keys(used_tree = task.used_tree(source_locations: true))
           print_title used_title(used_tree)
           keys_nodes = used_tree.keys.to_a
@@ -60,21 +60,43 @@ module I18n
         end
 
         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] }
+          keys = tree.root_key_values(true)
           print_title unused_title(keys)
           if keys.present?
-            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
+            print_locale_key_value_table keys
           else
             print_success 'Every translation is used!'
           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_locale_key_value_table keys
+          else
+            print_info cyan('No translations are the same as base value')
+          end
+        end
+
+        def show_tree(tree)
+          print_locale_key_value_table tree.root_key_values(true)
+        end
+
         private
 
+        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|
+              t.rows = locale_key_values.map { |(locale, k, v)| [{value: cyan(locale), alignment: :center}, cyan(k), v.to_s] }
+            end
+          else
+            puts 'ø'
+          end
+        end
+
         def print_title(title)
-          log_stderr "#{bold cyan title.strip} #{dark "|"} #{bold "i18n-tasks v#{I18n::Tasks::VERSION}"}"
+          log_stderr "#{bold title.strip} #{dark "|"} #{"i18n-tasks v#{I18n::Tasks::VERSION}"}"
         end
 
         def print_success(message)
@@ -97,6 +119,23 @@ module I18n
         def print_table(opts, &block)
           puts ::Terminal::Table.new(opts, &block)
         end
+
+        def wrap_string(s, max)
+          chars = []
+          dist = 0
+          s.chars.each do |c|
+            chars << c
+            dist += 1
+            if c == "\n"
+              dist = 0
+            elsif dist == max
+              dist = 0
+              chars << "\n"
+            end
+          end
+          chars = chars[0..-2] if chars.last == "\n"
+          chars.join
+        end
       end
     end
   end

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

@@ -1,9 +1,10 @@
 # coding: utf-8
 require 'i18n/tasks/key_pattern_matching'
-require 'i18n/tasks/relative_keys'
+require 'i18n/tasks/scanners/relative_keys'
+
 module I18n::Tasks::Scanners
   class BaseScanner
-    include ::I18n::Tasks::RelativeKeys
+    include RelativeKeys
     include ::I18n::Tasks::KeyPatternMatching
     include ::I18n::Tasks::Logging
 
@@ -11,6 +12,7 @@ module I18n::Tasks::Scanners
 
     def initialize(config = {})
       @config = config.dup.with_indifferent_access.tap do |conf|
+        conf[:relative_roots] = %w(app/views) if conf[:relative_roots].blank?
         conf[:paths]   = %w(app/) if conf[:paths].blank?
         conf[:include] = Array(conf[:include]) if conf[:include].present?
         if conf.key?(:exclude)

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

@@ -0,0 +1,21 @@
+# coding: utf-8
+module I18n
+  module Tasks
+    module Scanners
+      module RelativeKeys
+        # @param key [String] relative i18n key (starts with a .)
+        # @param path [String] path to the file containing the key
+        # @return [String] absolute version of the key
+        def absolutize_key(key, path, roots = relative_roots)
+          # normalized path
+          path = File.expand_path path
+          (path_root = roots.map { |path| File.expand_path path }.sort.reverse.detect { |root| path.start_with?(root + '/') }) or
+              raise CommandError.new("Error scanning #{path}: cannot resolve relative key \"#{key}\".\nSet relative_roots in config/i18n-tasks.yml (currently #{relative_roots.inspect})")
+          # key prefix based on path
+          prefix = path.gsub(%r(#{path_root}/|(\.[^/]+)*$), '').tr('/', '.').gsub(%r(\._), '.')
+          "#{prefix}#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/split_key.rb

@@ -0,0 +1,39 @@
+module SplitKey
+  extend self
+
+  # split a key taking parenthesis into account
+  # split_key 'a.b'      # => ['a', 'b']
+  # split_key 'a.#{b.c}' # => ['a', '#{b.c}']
+  # split_key 'a.b.c', 2 # => ['a', 'b.c']
+  def split_key(key, max = Float::INFINITY)
+    parts = []
+    nesting = NESTING_CHARS
+    counts  = Array.new(NESTING_CHARS.size, 0)
+    delim   = '.'.freeze
+    buf = []
+    key.to_s.chars.each do |char|
+      nest_i, nest_inc = nesting[char]
+      if nest_i
+        counts[nest_i] += nest_inc
+        buf << char
+      elsif char == delim && parts.length + 1 < max && counts.all?(&:zero?)
+        part = buf.join
+        buf.clear
+        parts << part
+        yield part if block_given?
+      else
+        buf << char
+      end
+    end
+    parts << buf.join unless buf.empty?
+    parts
+  end
+
+  NESTING_CHARS = %w({} [] ()).inject({}) { |h, s|
+    i = h.size / 2
+    h[s[0].freeze] = [i, 1].freeze
+    h[s[1].freeze] = [i, -1].freeze
+    h
+  }.freeze
+  private_constant :NESTING_CHARS
+end

data/lib/i18n/tasks/used_keys.rb

@@ -22,7 +22,7 @@ module I18n::Tasks
       @scanner ||= begin
         search_config = (config[:search] || {}).with_indifferent_access
         class_name    = search_config[:scanner] || '::I18n::Tasks::Scanners::PatternWithScopeScanner'
-        class_name.constantize.new search_config.merge(relative_roots: relative_roots)
+        class_name.constantize.new search_config
       end
     end
 

data/lib/i18n/tasks/version.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 module I18n
   module Tasks
-    VERSION = '0.5.4'
+    VERSION = '0.6.0'
   end
 end

data/spec/fixtures/app/views/index.html.slim

@@ -2,6 +2,7 @@
 | x-t :fp_dash_before
 / t(:fp_comment)
 / i18n-tasks-use t(:fn_comment)
+= t 'only_in_es'
 p #{t('ca.a')} #{t 'ca.b'} #{t "ca.c"}
 p #{t 'ca.d'} #{t 'ca.f', i: 'world'} #{t 'ca.e', i: 'world'}
 p #{t 'missing_in_es.a'} #{t 'same_in_es.a'} #{t 'blank_in_es.a'}
@@ -22,3 +23,4 @@ p = t 'missing_in_es_plural_2.a', count: 2
 p = t 'devise.a'
 p = t :missing_symbol_key
 p #{t :"missing_symbol.key_two"} #{t :'missing_symbol.key_three'}
+= t 'present_in_es_but_not_en.a'

data/spec/i18n_tasks_spec.rb

@@ -9,15 +9,16 @@ describe 'i18n-tasks' do
   describe 'missing' do
     let (:expected_missing_keys) {
       %w( en.used_but_missing.key en.relative.index.missing
-          es.missing_in_es.a es.same_in_es.a
+          es.missing_in_es.a
+          en.present_in_es_but_not_en.a
           en.hash.pattern_missing.a en.hash.pattern_missing.b
           en.missing_symbol_key en.missing_symbol.key_two en.missing_symbol.key_three
           es.missing_in_es_plural_1.a es.missing_in_es_plural_2.a
           en.missing-key-with-a-dash.key
-          en.fn_comment
+          en.fn_comment en.only_in_es
         )
     }
-    it 'detects missing or identical' do
+    it 'detects missing' do
       capture_stderr do
         expect(run_cmd :missing).to be_i18n_keys expected_missing_keys
         es_keys = expected_missing_keys.grep(/^es\./)
@@ -28,6 +29,14 @@ describe 'i18n-tasks' do
     end
   end
 
+  describe 'eq_base' do
+    it 'detects eq_base' do
+      capture_stderr do
+        expect(run_cmd :eq_base).to be_i18n_keys %w(es.same_in_es.a)
+      end
+    end
+  end
+
   let(:expected_unused_keys) { %w(unused.a unused.numeric unused.plural).map { |k| %w(en es).map { |l| "#{l}.#{k}" } }.reduce(:+) }
   describe 'unused' do
     it 'detects unused' do
@@ -41,7 +50,7 @@ describe 'i18n-tasks' do
     it 'removes unused' do
       in_test_app_dir do
         t = i18n_task
-        unused = expected_unused_keys.map { |k| k.split('.', 2)[1] }
+        unused = expected_unused_keys.map { |k| SplitKey.split_key(k, 2)[1] }
         unused.each do |key|
           expect(t.key_value?(key, :en)).to be true
           expect(t.key_value?(key, :es)).to be true
@@ -88,6 +97,7 @@ describe 'i18n-tasks' do
       run_cmd :add_missing, locales: 'base'
       in_test_app_dir {
         expect(YAML.load_file('config/locales/en.yml')['en']['used_but_missing']['key']).to eq 'Key'
+        expect(YAML.load_file('config/locales/en.yml')['en']['present_in_es_but_not_en']['a']).to eq 'A'
       }
     end
 
@@ -111,6 +121,7 @@ describe 'i18n-tasks' do
       in_test_app_dir {
         expect(YAML.load_file('config/locales/es.yml')['es']['missing_in_es']['a']).to eq 'TRME'
         expect(YAML.load_file('config/locales/devise.es.yml')['es']['devise']['a']).to eq 'ES_TEXT'
+        expect(YAML.load_file('config/locales/en.yml')['en']['present_in_es_but_not_en']['a']).to eq 'TRME'
       }
     end
 
@@ -121,6 +132,7 @@ describe 'i18n-tasks' do
       run_cmd :add_missing, locales: 'all', placeholder: 'TRME %{base_value}'
       in_test_app_dir {
         expect(YAML.load_file('config/locales/es.yml')['es']['missing_in_es']['a']).to eq 'TRME EN_TEXT'
+        expect(YAML.load_file('config/locales/en.yml')['en']['present_in_es_but_not_en']['a']).to eq 'TRME ES_TEXT'
       }
     end
   end
@@ -148,7 +160,7 @@ used.a 2
 
 
   # --- setup ---
-  BENCH_KEYS = 100
+  BENCH_KEYS = 10
   before(:each) do
     gen_data = ->(v) {
       v_num = v.chars.map(&:ord).join('').to_i
@@ -194,6 +206,8 @@ used.a 2
     es_data['blank_in_es']['a']        = ''
     es_data['ignore_eq_base_all']['a'] = 'EN_TEXT'
     es_data['ignore_eq_base_es']['a']  = 'EN_TEXT'
+    es_data['only_in_es'] = 1
+    es_data['present_in_es_but_not_en'] = {'a' => 'ES_TEXT'}
 
     fs = fixtures_contents.merge(
         'config/locales/en.yml' => {'en' => en_data}.to_yaml,

data/spec/locale_pathname_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'LocalePathname' do
+  include ::I18n::Tasks::LocalePathname
+  context '#replace_locale' do
+
+    it 'es.yml' do
+      expect(replace_locale 'es.yml', 'es', 'fr').to eq 'fr.yml'
+    end
+
+    it 'scope.es.yml' do
+      expect(replace_locale 'scope.es.yml', 'es', 'fr').to eq 'scope.fr.yml'
+    end
+
+    it 'path/es.yml' do
+      expect(replace_locale 'path/es.yml', 'es', 'fr').to eq 'path/fr.yml'
+    end
+
+    it 'path/scope.es.yml' do
+      expect(replace_locale 'path/scope.es.yml', 'es', 'fr').to eq 'path/scope.fr.yml'
+    end
+
+  end
+end

data/spec/locale_tree/siblings_spec.rb

@@ -10,12 +10,12 @@ describe 'Tree siblings / forest' do
           key: 'fr',
           children: children
       )
-      expect(node.to_siblings.first.children.first.parent.key).to eq 'fr'
+      expect(node.to_siblings.first.children.parent.key).to eq 'fr'
     end
   end
 
   context 'a tree' do
-    let(:a_hash) { {a: 1, b: {ba: 1, bb: 2}}.deep_stringify_keys }
+    let(:a_hash) { {'a' => 1, 'b' => {'ba' => 1, 'bb' => 2}} }
 
     it '::from_nested_hash' do
       a = build_tree(a_hash)
@@ -34,14 +34,34 @@ describe 'Tree siblings / forest' do
 
     it '#merge' do
       a      = build_tree(a_hash)
-      b_hash = {b: {bc: 1}, c: 1}.deep_stringify_keys
+      b_hash = {'b' => {'bc' => 1}, 'c' => 1}
       expect(a.merge(build_tree(b_hash)).to_hash).to eq(a_hash.deep_merge(b_hash))
     end
 
+    it '#merge does not modify self' do
+      a = build_tree(a: 1)
+      b = build_tree(a: 2)
+      c = a.merge b
+      expect(a['a'].value).to eq 1
+      expect(c['a'].value).to eq 2
+      expect(b['a'].value).to eq 2
+    end
+
+    it '#merge conflict value <- scope' do
+      a = build_tree(a: 1)
+      b = build_tree(a: {b: 1})
+      expect { silence_stderr { a.merge(b) } }.to_not raise_error
+    end
+
+    it '#set conflict value <- scope' do
+      a = build_tree(a: 1)
+      expect { silence_stderr { a.set('a.b', build_node(key: 'b', value: 1)) } }.to_not raise_error
+    end
+
     it '#intersect' do
       x = {a: 1, b: {ba: 1, bb: 2}}
       y = {b: {ba: 1, bc: 3}, c: 1}
-      intersection = {b: {ba: 1}}.deep_stringify_keys
+      intersection = {'b' => {'ba' => 1}}
       a = build_tree(x)
       b = build_tree(y)
       expect(a.intersect_keys(b, root: true).to_hash).to eq(intersection)
@@ -50,5 +70,22 @@ describe 'Tree siblings / forest' do
     it '#select_keys' do
       expect(build_tree(a: 1, b: 1).select_keys {|k, node| k == 'b'}.to_hash).to eq({'b' => 1})
     end
+
+    it '#append!' do
+      expect(build_tree({'a' => 1}).append!(build_node(key: 'b', value: 2)).to_hash).to eq('a' => 1, 'b' => 2)
+    end
+
+    it '#set replace value' do
+      expect(build_tree(a: {b: 1}).tap {|t| t['a.b'] = build_node(key: 'b', value: 2) }.to_hash).to(
+          eq('a' => {'b' => 2})
+      )
+    end
+
+    it '#set get' do
+      t = build_tree(a: {x: 1})
+      node = build_node(key: 'd', value: 'e')
+      t['a.b.c.' + node.key] = node
+      expect(t['a.b.c.d'].value).to eq('e')
+    end
   end
 end