i18n-tasks 0.9.6 → 0.9.7

data/lib/i18n/tasks/plural_keys.rb

@@ -7,22 +7,21 @@ module I18n::Tasks::PluralKeys
   def collapse_plural_nodes!(tree)
     tree.leaves.map(&:parent).compact.uniq.each do |node|
       children = node.children
-      if plural_forms?(children)
-        node.value    = children.to_hash
-        node.children = nil
-        node.data.merge! children.first.data
-      end
+      next unless plural_forms?(children)
+      node.value    = children.to_hash
+      node.children = nil
+      node.data.merge! children.first.data
     end
     tree
   end
 
   # @param [String] key i18n key
   # @param [String] locale to pull key data from
-  # @return the base form if the key is a specific plural form (e.g. apple for apple.many), and the key as passed otherwise
+  # @return [String] the base form if the key is a specific plural form (e.g. apple for apple.many), the key otherwise.
   def depluralize_key(key, locale = base_locale)
     return key if key !~ PLURAL_KEY_RE
     key_name = last_key_part(key)
-    parent_key = key[0 .. - (key_name.length + 2)]
+    parent_key = key[0..- (key_name.length + 2)]
     nodes = tree("#{locale}.#{parent_key}").presence || (locale != base_locale && tree("#{base_locale}.#{parent_key}"))
     if nodes && plural_forms?(nodes)
       parent_key

data/lib/i18n/tasks/references.rb

@@ -5,64 +5,95 @@ module I18n::Tasks
     # 1. Raw references -- a subset of the usages tree with keys that are reference key usages.
     # 2. Resolved references -- all the used references in their fully resolved form.
     # 3. Reference keys -- all the used reference keys.
-    def process_references(usages, data_references = merge_reference_trees(data_forest.select_keys { |_, node| node.reference? }))
-      fail ArgumentError.new('usages must be a Data::Tree::Instance') unless usages.is_a?(Data::Tree::Siblings)
-      fail ArgumentError.new('all_references must be a Data::Tree::Instance') unless data_references.is_a?(Data::Tree::Siblings)
-      raw_refs      = empty_forest
+    def process_references(usages,
+                           data_refs = merge_reference_trees(data_forest.select_keys { |_, node| node.reference? }))
+      fail ArgumentError, 'usages must be a Data::Tree::Instance' unless usages.is_a?(Data::Tree::Siblings)
+      fail ArgumentError, 'all_references must be a Data::Tree::Instance' unless data_refs.is_a?(Data::Tree::Siblings)
+      raw_refs = empty_forest
       resolved_refs = empty_forest
-      refs          = empty_forest
-      data_references.key_to_node.each do |ref_key_part, ref_node|
+      refs = empty_forest
+      data_refs.key_to_node.each do |ref_key_part, ref_node|
         usages.each do |usage_node|
           next unless usage_node.key == ref_key_part
           if ref_node.leaf?
-            unless refs.key_to_node.key?(ref_node.key)
-              refs.merge_node!(Data::Tree::Node.new(key: ref_node.key, data: usage_node.data))
-            end
-            resolved_refs.merge!(
-                Data::Tree::Siblings.from_key_names([ref_node.value.to_s]) { |_, resolved_node|
-                  raw_refs.merge_node!(usage_node)
-                  if usage_node.leaf?
-                    resolved_node.data.merge!(usage_node.data)
-                  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] ||= []
-                    new_resolved_refs.leaves { |leaf| ref_data[:occurrences].concat(leaf.data[:occurrences] || []) }
-                    ref_data[:occurrences].sort_by!(&:path)
-                    ref_data[:occurrences].uniq!
-                  }
-                })
+            process_leaf!(ref_node, usage_node, raw_refs, resolved_refs, refs)
           else
-            child_raw_refs, child_resolved_refs, child_refs = process_references(usage_node.children, ref_node.children)
-            raw_refs.merge_node! Data::Tree::Node.new(key: ref_node.key, children: child_raw_refs) unless child_raw_refs.empty?
-            resolved_refs.merge! child_resolved_refs
-            refs.merge_node! Data::Tree::Node.new(key: ref_node.key, children: child_refs) unless child_refs.empty?
+            process_non_leaf!(ref_node, usage_node, raw_refs, resolved_refs, refs)
           end
         end
       end
       [raw_refs, resolved_refs, refs]
     end
 
+    private
+
+    # @param [I18n::Tasks::Data::Tree::Node] ref
+    # @param [I18n::Tasks::Data::Tree::Node] usage
+    # @param [I18n::Tasks::Data::Tree::Siblings] raw_refs
+    # @param [I18n::Tasks::Data::Tree::Siblings] resolved_refs
+    # @param [I18n::Tasks::Data::Tree::Siblings] refs
+    def process_leaf!(ref, usage, raw_refs, resolved_refs, refs)
+      refs.merge_node!(Data::Tree::Node.new(key: ref.key, data: usage.data)) unless refs.key_to_node.key?(ref.key)
+      new_resolved_refs = Data::Tree::Siblings.from_key_names([ref.value.to_s]) do |_, resolved_node|
+        raw_refs.merge_node!(usage)
+        if usage.leaf?
+          resolved_node.data.merge!(usage.data)
+        else
+          resolved_node.children = usage.children
+        end
+        resolved_node.leaves { |node| node.data[:ref_info] = [ref.full_key, ref.value.to_s] }
+      end
+      add_occurences! refs.key_to_node[ref.key].data, new_resolved_refs
+      resolved_refs.merge! new_resolved_refs
+    end
+
+    # @param [Hash] ref_data
+    # @param [I18n::Tasks::Data::Tree::Siblings] new_resolved_refs
+    def add_occurences!(ref_data, new_resolved_refs)
+      ref_data[:occurrences] ||= []
+      new_resolved_refs.leaves do |leaf|
+        ref_data[:occurrences].concat(leaf.data[:occurrences] || [])
+      end
+      ref_data[:occurrences].sort_by!(&:path)
+      ref_data[:occurrences].uniq!
+    end
+
+    # @param [I18n::Tasks::Data::Tree::Node] ref
+    # @param [I18n::Tasks::Data::Tree::Node] usage
+    # @param [I18n::Tasks::Data::Tree::Siblings] raw_refs
+    # @param [I18n::Tasks::Data::Tree::Siblings] resolved_refs
+    # @param [I18n::Tasks::Data::Tree::Siblings] refs
+    def process_non_leaf!(ref, usage, raw_refs, resolved_refs, refs)
+      child_raw_refs, child_resolved_refs, child_refs = process_references(usage.children, ref.children)
+      raw_refs.merge_node! Data::Tree::Node.new(key: ref.key, children: child_raw_refs) unless child_raw_refs.empty?
+      resolved_refs.merge! child_resolved_refs
+      refs.merge_node! Data::Tree::Node.new(key: ref.key, children: child_refs) unless child_refs.empty?
+    end
+
     # Given a forest of references, merge trees into one tree, ensuring there are no conflicting references.
-    # @param roots [Data::Tree::Siblings]
-    # @return [Data::Tree::Siblings]
+    # @param roots [I18n::Tasks::Data::Tree::Siblings]
+    # @return [I18n::Tasks::Data::Tree::Siblings]
     def merge_reference_trees(roots)
       roots.inject(empty_forest) do |forest, root|
-        root.keys { |full_key, node|
-          log_warn(
+        root.keys do |full_key, node|
+          if full_key == node.value.to_s
+            log_warn(
               "Self-referencing key #{node.full_key(root: false).inspect} in #{node.data[:locale].inspect}"
-          ) if full_key == node.value.to_s
-        }
+            )
+          end
+        end
         forest.merge!(
-            root.children,
-            on_leaves_merge: -> (node, other) {
+          root.children,
+          on_leaves_merge: lambda do |node, other|
+            if node.value != other.value
               log_warn(
-                  "Conflicting references: #{node.full_key(root: false)} ⮕ #{node.value} in #{node.data[:locale]}, but ⮕ #{other.value} in #{other.data[:locale]}"
-              ) if node.value != other.value
-            })
+                'Conflicting references: '\
+            "#{node.full_key(root: false)} ⮕ #{node.value} in #{node.data[:locale]},"\
+            " but ⮕ #{other.value} in #{other.data[:locale]}"
+              )
+            end
+          end
+        )
       end
     end
   end

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

@@ -30,24 +30,25 @@ module I18n::Tasks::Reports
 
     def used_title(keys_nodes, filter)
       used_n = keys_nodes.map { |_k, node| node.data[:occurrences].size }.reduce(:+).to_i
-      "#{keys_nodes.size} key#{'s' if keys_nodes.size != 1}#{" matching '#{filter}'" if filter}#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n > 0}"
+      "#{keys_nodes.size} key#{'s' if keys_nodes.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 = {locale: :asc, key: :asc})
+    def sort_by_attr!(objects, order = { locale: :asc, key: :asc })
       order_keys = order.keys
-      objects.sort! { |a, b|
+      objects.sort! do |a, b|
         by = order_keys.detect { |k| a[k] != b[k] }
         order[by] == :desc ? b[by] <=> a[by] : a[by] <=> b[by]
-      }
+      end
       objects
     end
 
     def forest_to_attr(forest)
-      forest.keys(root: false).map { |key, node|
-        {key: key, value: node.value, type: node.data[:type], locale: node.root.key, data: node.data}
-      }
+      forest.keys(root: false).map do |key, node|
+        { key: key, value: node.value, type: node.data[:type], locale: node.root.key, data: node.data }
+      end
     end
 
     def format_locale(locale)

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

@@ -4,8 +4,7 @@ require 'fileutils'
 
 module I18n::Tasks::Reports
   class Spreadsheet < Base
-
-    def save_report(path, opts)
+    def save_report(path, _opts)
       path = path.presence || 'tmp/i18n-report.xlsx'
       p = Axlsx::Package.new
       p.use_shared_strings = true # see #159
@@ -19,22 +18,24 @@ module I18n::Tasks::Reports
 
     private
 
-    def add_missing_sheet(wb)
+    def add_missing_sheet(wb) # rubocop:disable Metrics/AbcSize
       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}
+        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(forest)) { |sheet|
-          sheet.page_setup.fit_to :width => 1
-          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')]
+        wb.add_worksheet(name: missing_title(forest)) do |sheet|
+          sheet.page_setup.fit_to width: 1
+          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
           forest.keys do |key, node|
-            locale, type = format_locale(node.root.data[:locale]), node.data[:type]
+            locale = format_locale(node.root.data[:locale])
+            type = node.data[:type]
             sheet.add_row [missing_type_info(type)[:summary], locale, key, task.t(key)],
-            styles: [type_cell, locale_cell, regular_style, regular_style]
+                          styles: [type_cell, locale_cell, regular_style, regular_style]
           end
-        }
+        end
       end
     end
 
@@ -48,11 +49,10 @@ module I18n::Tasks::Reports
       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 [I18n.t('i18n_tasks.common.locale'), I18n.t('i18n_tasks.common.key'), I18n.t('i18n_tasks.common.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
@@ -60,9 +60,8 @@ module I18n::Tasks::Reports
       end
     end
 
-
     def style_header(sheet)
-      border_bottom = sheet.workbook.styles.add_style(border: {style: :thin, color: '000000', edges: [:bottom]})
+      border_bottom = sheet.workbook.styles.add_style(border: { style: :thin, color: '000000', edges: [:bottom] })
       sheet.rows.first.style = border_bottom
     end
   end

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

@@ -4,7 +4,7 @@ require 'terminal-table'
 module I18n
   module Tasks
     module Reports
-      class Terminal < Base
+      class Terminal < Base # rubocop:disable Metrics/ClassLength
         include Term::ANSIColor
 
         def missing_keys(forest = task.missing_keys)
@@ -12,10 +12,10 @@ module I18n
           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')),
+                                   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},
+                [{ value: cyan(format_locale(a[:locale])), alignment: :center },
                  format_key(a[:key], a[:data]),
                  missing_key_info(a)]
               end
@@ -27,14 +27,14 @@ module I18n
 
         def icon(type)
           glyph = missing_type_info(type)[:glyph]
-          {missing_used: red(glyph), missing_diff: yellow(glyph)}[type]
+          { missing_used: red(glyph), missing_diff: yellow(glyph) }[type]
         end
 
         def used_keys(used_tree = task.used_tree)
           # For the used tree we may have usage nodes that are not leaves as references.
-          keys_nodes = used_tree.nodes.select { |node| !!node.data[:occurrences] }.map { |node|
+          keys_nodes = used_tree.nodes.select { |node| node.data[:occurrences].present? }.map do |node|
             [node.full_key(root: false), node]
-          }
+          end
           print_title used_title(keys_nodes, used_tree.first.root.data[:key_filter])
           # Group multiple nodes
           if keys_nodes.present?
@@ -86,7 +86,8 @@ module I18n
           if leaf[:type] == :missing_used
             first_occurrence leaf
           else
-            "#{cyan leaf[:data][:missing_diff_locale]} #{format_value(leaf[:value].is_a?(String) ? leaf[:value].strip : leaf[:value])}"
+            "#{cyan leaf[:data][:missing_diff_locale]} "\
+            "#{format_value(leaf[:value].is_a?(String) ? leaf[:value].strip : leaf[:value])}"
           end
         end
 
@@ -106,23 +107,22 @@ module I18n
         end
 
         def format_reference_desc(node_data)
-            return nil unless node_data
-            case node_data[:ref_type]
-              when :reference_usage
-                bold(yellow('(ref)'))
-              when :reference_usage_resolved
-                bold(yellow('(resolved ref)'))
-              when :reference_usage_key
-                bold(yellow('(ref key)'))
-            end
+          return nil unless node_data
+          case node_data[:ref_type]
+          when :reference_usage
+            bold(yellow('(ref)'))
+          when :reference_usage_resolved
+            bold(yellow('(resolved ref)'))
+          when :reference_usage_key
+            bold(yellow('(ref key)'))
+          end
         end
 
         def print_occurrences(node, full_key = node.full_key)
           occurrences = node.data[:occurrences]
-          puts [bold("#{full_key}"),
+          puts [bold(full_key.to_s),
                 format_reference_desc(node.data),
-                (green(occurrences.size.to_s) if occurrences.size > 1)
-               ].compact.join ' '
+                (green(occurrences.size.to_s) if occurrences.size > 1)].compact.join ' '
           occurrences.each do |occurrence|
             puts "  #{key_occurrence full_key, occurrence}"
           end
@@ -134,7 +134,7 @@ module I18n
                                    bold(cyan(I18n.t('i18n_tasks.common.key'))),
                                    I18n.t('i18n_tasks.common.value')] do |t|
               t.rows = locale_key_value_datas.map { |(locale, k, v, data)|
-                [{value: cyan(locale), alignment: :center}, format_key(k, data), format_value(v)]
+                [{ value: cyan(locale), alignment: :center }, format_key(k, data), format_value(v)]
               }
             end
           else
@@ -143,15 +143,15 @@ module I18n
         end
 
         def print_title(title)
-          log_stderr "#{bold title.strip} #{dark "|"} #{"i18n-tasks v#{I18n::Tasks::VERSION}"}"
+          log_stderr "#{bold title.strip} #{dark '|'} #{"i18n-tasks v#{I18n::Tasks::VERSION}"}"
         end
 
         def print_success(message)
-          log_stderr bold(green "✓ #{I18n.t('i18n_tasks.cmd.encourage').sample} #{message}")
+          log_stderr bold(green("✓ #{I18n.t('i18n_tasks.cmd.encourage').sample} #{message}"))
         end
 
         def print_error(message)
-          log_stderr(bold red message)
+          log_stderr(bold(red(message)))
         end
 
         def print_info(message)
@@ -159,8 +159,7 @@ module I18n
         end
 
         def indent(txt, n = 2)
-          spaces = ' ' * n
-          txt.gsub /^/, spaces
+          txt.gsub(/^/, ' ' * n)
         end
 
         def print_table(opts, &block)
@@ -177,18 +176,19 @@ module I18n
           # @type [I18n::Tasks::Scanners::KeyOccurrences]
           occurrences = leaf[:data][:occurrences]
           # @type [I18n::Tasks::Scanners::Occurrence]
-          first       = occurrences.first
-          [green("#{first.path}:#{first.line_num}"),
-           ("(#{I18n.t 'i18n_tasks.common.n_more', count: occurrences.length - 1})" if occurrences.length > 1)
+          first = occurrences.first
+          [
+            green("#{first.path}:#{first.line_num}"),
+            ("(#{I18n.t 'i18n_tasks.common.n_more', count: occurrences.length - 1})" if occurrences.length > 1)
           ].compact.join(' ')
         end
 
         def highlight_key(full_key, line, range = (0..-1))
-          line.dup.tap { |s|
-            s[range] = s[range].sub(full_key) { |m|
+          line.dup.tap do |s|
+            s[range] = s[range].sub(full_key) do |m|
               highlight_string m
-            }
-          }
+            end
+          end
         end
 
         module HighlightUnderline

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

@@ -12,7 +12,8 @@ module I18n::Tasks::Scanners
     def initialize(
         config: {},
         file_finder_provider: Files::CachingFileFinderProvider.new,
-        file_reader: Files::CachingFileReader.new)
+        file_reader: Files::CachingFileReader.new
+    )
       @config      = config
       @file_reader = file_reader
       @file_finder = file_finder_provider.get(**config.slice(:paths, :only, :exclude))
@@ -20,11 +21,11 @@ module I18n::Tasks::Scanners
 
     # @return (see Scanner#keys)
     def keys
-      (traverse_files { |path|
+      (traverse_files do |path|
         scan_file(path)
-      }.reduce(:+) || []).group_by(&:first).map { |key, keys_occurrences|
+      end.reduce(:+) || []).group_by(&:first).map do |key, keys_occurrences|
         Results::KeyOccurrences.new(key: key, occurrences: keys_occurrences.map(&:second))
-      }
+      end
     end
 
     protected
@@ -32,7 +33,7 @@ module I18n::Tasks::Scanners
     # Extract all occurrences of translate calls from the file at the given path.
     #
     # @return [Array<[key, Results::KeyOccurrence]>] each occurrence found in the file
-    def scan_file(path)
+    def scan_file(_path)
       fail 'Unimplemented'
     end