i18n-tasks 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5b15ad428fdc29cc404d033f363c08708f5b815
-  data.tar.gz: c5aaaecace6c6024d544ff552c06097b9ec2f252
+  metadata.gz: 4807ae41e4ea2c7274b08bc55c2a2286a6e601d5
+  data.tar.gz: bdc921c3485e004c0e395a79afde8a5cfcfa888c
 SHA512:
-  metadata.gz: 54586d8f4fb14861a755a75325ccf73230b9e180bc590f2f7fd383dc6c10c3529943179709d1d8045873148530684625c92a53d9b997281b9078acac51c40699
-  data.tar.gz: 693ff45562b53f09a0c5baf81b0d5418227e35d182f81e51cdff99c740b2a4666c39bbf3ea84f9d64daafb5ce34b454a59410b3c73a03fadf35c3b9ee98244bb
+  metadata.gz: 3b58817464f4c4878f822606dda7ae226b33f53b6542b938a272864d1d4a92806a72d81f4d16571e8176e04687784861a7c541f1ac0e92b6ce055ed46a93b8da
+  data.tar.gz: 276c9a94d0575d383ea163a8e20d56b26248cf0c16da4caa2efd53f7530ed4632f3f264e9dcf747013db063cd19c984cd218cb60829ace938f79b6c97db7130f

data/README.md

@@ -24,7 +24,7 @@ i18n-tasks can be used with any project using the ruby [i18n gem][i18n-gem] (def
 Add i18n-tasks to the Gemfile:
 
 ```ruby
-gem 'i18n-tasks', '~> 0.9.3'
+gem 'i18n-tasks', '~> 0.9.4'
 ```
 
 Copy the default [configuration file](#configuration):

data/config/locales/en.yml

@@ -13,7 +13,7 @@ en:
           data_format: 'Data format: %{valid_text}.'
           key_pattern: Filter by key pattern (e.g. 'common.*')
           key_pattern_to_rename: Full key (pattern) to rename. Required
-          locale: Locale
+          locale: :i18n_tasks.common.locale
           locale_to_translate_from: Locale to translate from
           locales_filter: 'Locale(s) to process. Special: base'
           missing_types: 'Filter by types: %{valid}'

data/lib/i18n/tasks/data/tree/node.rb

@@ -159,12 +159,20 @@ module I18n::Tasks::Data::Tree
                 Term::ANSIColor.dark '∅'
               else
                 [Term::ANSIColor.color(1 + level % 15, key),
-                 (": #{Term::ANSIColor.cyan(value.to_s)}" if leaf?),
+                 (": #{format_value_for_inspect(value)}" if leaf?),
                  (" #{data}" if data?)].compact.join
               end
       ['  ' * level, label, ("\n" + children.map { |c| c.inspect(level + 1) }.join("\n") if children?)].compact.join
     end
 
+    def format_value_for_inspect(value)
+      if value.is_a?(Symbol)
+        "#{Term::ANSIColor.bold(Term::ANSIColor.yellow '⮕ ')}#{Term::ANSIColor.yellow value.to_s}"
+      else
+        Term::ANSIColor.cyan(value.to_s)
+      end
+    end
+
     protected
 
     def dirty!

data/lib/i18n/tasks/data/tree/siblings.rb

@@ -123,21 +123,11 @@ module I18n::Tasks::Data::Tree
     end
 
     def subtract_keys(keys)
-      to_remove = Set.new
-      keys.each do |full_key|
-        node = get full_key
-        to_remove << node if node
-      end
-      remove_nodes_collapsing_emptied_ancestors to_remove
+      remove_nodes_and_emptied_ancestors(keys.inject(Set.new) { |set, key| (node = get(key)) ? set << node : set })
     end
 
     def subtract_keys!(keys)
-      to_remove = Set.new
-      keys.each do |full_key|
-        node = get full_key
-        to_remove << node if node
-      end
-      remove_nodes_collapsing_emptied_ancestors! to_remove
+      remove_nodes_and_emptied_ancestors!(keys.inject(Set.new) { |set, key| (node = get(key)) ? set << node : set })
     end
 
     def subtract_by_key(other)
@@ -179,19 +169,20 @@ module I18n::Tasks::Data::Tree
     end
 
     # @param nodes [Enumerable] Modified in-place.
-    def remove_nodes_collapsing_emptied_ancestors(nodes)
+    def remove_nodes_and_emptied_ancestors(nodes)
       add_ancestors_that_only_contain_nodes! nodes
       select_nodes { |node| !nodes.include?(node) }
     end
 
     # @param nodes [Enumerable] Modified in-place.
-    def remove_nodes_collapsing_emptied_ancestors!(nodes)
+    def remove_nodes_and_emptied_ancestors!(nodes)
       add_ancestors_that_only_contain_nodes! nodes
       select_nodes! { |node| !nodes.include?(node) }
     end
 
     private
 
+    # Adds all the ancestors that only contain the given nodes as descendants to the given nodes.
     # @param nodes [Set] Modified in-place.
     def add_ancestors_that_only_contain_nodes!(nodes)
       levels.reverse_each do |level_nodes|

data/lib/i18n/tasks/data/tree/traversal.rb

@@ -75,6 +75,12 @@ module I18n::Tasks
         result
       end
 
+      def root_key_value_data(sort = false)
+        result = keys(root: false).map { |key, node| [node.root.key, key, node.value, node.data] }
+        result.sort! { |a, b| a[0] != b[0] ? a[0] <=> b[0] : a[1] <=> b[1] } if sort
+        result
+      end
+
       #-- modify / derive
 
       # Select the nodes for which the block returns true. Pre-order traversal.

data/lib/i18n/tasks/missing_keys.rb

@@ -89,25 +89,28 @@ module I18n::Tasks
     end
 
     # @param [::I18n::Tasks::Data::Tree::Siblings] forest
-    def collapse_missing_used_locales!(forest)
-      locales_and_nodes_by_key = {}
-      to_remove                = []
+    # @yield [::I18n::Tasks::Data::Tree::Node]
+    # @yieldreturn [Boolean] whether to collapse the node
+    def collapse_same_key_in_locales!(forest)
+      locales_and_node_by_key = {}
+      to_remove               = []
       forest.each do |root|
         locale = root.key
-        root.leaves { |node|
-          if node.data[:type] == :missing_used
-            (locales_and_nodes_by_key[node.full_key(root: false)] ||= []) << [locale, node]
-            to_remove << node
+        root.keys { |key, node|
+          next unless yield node
+          if locales_and_node_by_key.key?(key)
+            locales_and_node_by_key[key][0] << locale
+          else
+            locales_and_node_by_key[key] = [[locale], node]
           end
+          to_remove << node
         }
       end
-      forest.remove_nodes_collapsing_emptied_ancestors! to_remove
-      keys_and_nodes_by_locale = {}
-      locales_and_nodes_by_key.each { |key, locales_and_nodes|
-        locales = locales_and_nodes.map(&:first).sort.join('+')
-        (keys_and_nodes_by_locale[locales] ||= []) << [key, locales_and_nodes[0][1]]
-      }
-      keys_and_nodes_by_locale.map { |locales, keys_nodes|
+      forest.remove_nodes_and_emptied_ancestors! to_remove
+      locales_and_node_by_key.inject({}) { |inv, (key, (locales, node))|
+        (inv[locales.sort.join('+')] ||= []) << [key, node]
+        inv
+      }.map { |locales, keys_nodes|
         keys_nodes.each { |(key, node)|
           forest["#{locales}.#{key}"] = node
         }

data/lib/i18n/tasks/references.rb

@@ -26,6 +26,7 @@ module I18n::Tasks
                   else
                     resolved_node.children = usage_node.children
                   end
+                  resolved_node.leaves { |node| node.data[:ref_info] = [ref_node.full_key, ref_node.value.to_s] }
                 }.tap { |new_resolved_refs|
                   refs.key_to_node[ref_node.key].data.tap { |ref_data|
                     ref_data[:occurrences] ||= []

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

@@ -58,5 +58,11 @@ module I18n::Tasks::Reports
         locale.tr '+', ' '
       end
     end
+
+    def collapse_missing_tree!(forest)
+      forest = task.collapse_plural_nodes!(forest)
+      forest = task.collapse_same_key_in_locales!(forest) { |node| node.data[:type] == :missing_used }
+      forest
+    end
   end
 end

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

@@ -20,9 +20,7 @@ module I18n::Tasks::Reports
     private
 
     def add_missing_sheet(wb)
-      forest = task.missing_keys
-      forest = task.collapse_plural_nodes!(forest)
-      forest = task.collapse_missing_used_locales!(forest)
+      forest = collapse_missing_tree! task.missing_keys
       wb.styles do |s|
         type_cell = s.add_style :alignment => {:horizontal => :center}
         locale_cell  = s.add_style :alignment => {:horizontal => :center}

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

@@ -8,15 +8,16 @@ module I18n
         include Term::ANSIColor
 
         def missing_keys(forest = task.missing_keys)
-          forest = task.collapse_plural_nodes!(forest)
-          forest = task.collapse_missing_used_locales!(forest)
+          forest = collapse_missing_tree! forest
           if forest.present?
             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.missing.details_title')] do |t|
               t.rows = sort_by_attr!(forest_to_attr(forest)).map do |a|
-                [{value: cyan(format_locale(a[:locale])), alignment: :center}, cyan(a[:key]), missing_key_info(a)]
+                [{value: cyan(format_locale(a[:locale])), alignment: :center},
+                 format_key(a[:key], a[:data]),
+                 missing_key_info(a)]
               end
             end
           else
@@ -46,27 +47,27 @@ module I18n
         end
 
         def unused_keys(tree = task.unused_keys)
-          keys = tree.root_key_values(true)
+          keys = tree.root_key_value_data(true)
           if keys.present?
             print_title unused_title(keys)
-            print_locale_key_value_table keys
+            print_locale_key_value_data_table keys
           else
             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)
+          keys = tree.root_key_value_data(true)
           if keys.present?
             print_title eq_base_title(keys)
-            print_locale_key_value_table keys
+            print_locale_key_value_data_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)
+          print_locale_key_value_data_table tree.root_key_value_data(true)
         end
 
         def forest_stats(forest, stats = task.forest_stats(forest))
@@ -89,25 +90,37 @@ module I18n
           end
         end
 
+        def format_key(key, data)
+          if data[:ref_info]
+            from, to = data[:ref_info]
+            resolved = key[0...to.length]
+            after    = key[to.length..-1]
+            "  #{yellow from}#{cyan after}\n#{bold(yellow('⮕'))} #{bold yellow resolved}"
+          else
+            cyan(key)
+          end
+        end
+
         def format_value(val)
           val.is_a?(Symbol) ? "#{bold(yellow('⮕ '))}#{yellow(val.to_s)}" : val.to_s.strip
         end
 
-        def format_reference_desc(node)
-            case node.data[:type]
+        def format_reference_desc(node_data)
+            return nil unless node_data
+            case node_data[:ref_type]
               when :reference_usage
-                bold(yellow('(reference)'))
+                bold(yellow('(ref)'))
               when :reference_usage_resolved
-                bold(yellow('(resolved reference)'))
+                bold(yellow('(resolved ref)'))
               when :reference_usage_key
-                bold(yellow('(reference key)'))
+                bold(yellow('(ref key)'))
             end
         end
 
         def print_occurrences(node, full_key = node.full_key)
           occurrences = node.data[:occurrences]
           puts [bold("#{full_key}"),
-                format_reference_desc(node),
+                format_reference_desc(node.data),
                 (green(occurrences.size.to_s) if occurrences.size > 1)
                ].compact.join ' '
           occurrences.each do |occurrence|
@@ -115,13 +128,13 @@ module I18n
           end
         end
 
-        def print_locale_key_value_table(locale_key_values)
-          if locale_key_values.present?
+        def print_locale_key_value_data_table(locale_key_value_datas)
+          if locale_key_value_datas.present?
             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), format_value(v)]
+              t.rows = locale_key_value_datas.map { |(locale, k, v, data)|
+                [{value: cyan(locale), alignment: :center}, format_key(k, data), format_value(v)]
               }
             end
           else

data/lib/i18n/tasks/unused_keys.rb

@@ -12,9 +12,7 @@ module I18n
       # @param [String] locale
       # @param [Boolean] strict if true, do not match dynamic keys
       def unused_tree(locale: base_locale, strict: nil)
-        used_key_names = used_tree(strict: true).keys.reject {|_key, node|
-          node.data[:type] == :used_reference_key_raw
-        }.map(&:first)
+        used_key_names = used_tree(strict: true).key_names
         collapse_plural_nodes! data[locale].select_keys { |key, _node|
           !ignore_key?(key, :unused) &&
               (strict || !used_in_expr?(key)) &&

data/lib/i18n/tasks/used_keys.rb

@@ -30,14 +30,14 @@ module I18n::Tasks
     #
     # @param key_filter [String] only return keys matching this pattern.
     # @param strict [Boolean] if true, dynamic keys are excluded (e.g. `t("category.#{ category.key }")`)
+    # @param include_raw_references [Boolean] if true, includes reference usages as they appear in the source
     # @return [Data::Tree::Siblings]
     def used_tree(key_filter: nil, strict: nil, include_raw_references: false)
       src_tree = used_in_source_tree(key_filter: key_filter, strict: strict)
-
       raw_refs, resolved_refs, used_refs = process_references(src_tree['used'].children)
-      raw_refs.leaves { |node| node.data[:type] = :reference_usage }
-      resolved_refs.leaves { |node| node.data[:type] = :reference_usage_resolved }
-      used_refs.leaves { |node| node.data[:type] = :reference_usage_key }
+      raw_refs.leaves { |node| node.data[:ref_type] = :reference_usage }
+      resolved_refs.leaves { |node| node.data[:ref_type] = :reference_usage_resolved }
+      used_refs.leaves { |node| node.data[:ref_type] = :reference_usage_key }
       src_tree.tap do |result|
         tree = result['used'].children
         tree.subtract_by_key!(raw_refs)

data/lib/i18n/tasks/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module I18n
   module Tasks
-    VERSION = '0.9.3'
+    VERSION = '0.9.4'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-tasks
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - glebm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-04 00:00:00.000000000 Z
+date: 2016-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport