i18n-tasks 0.9.6 → 0.9.7

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

@@ -25,9 +25,15 @@ module I18n::Tasks::Scanners
     def collect_results
       return [@scanners[0].keys] if @scanners.length == 1
       Array.new(@scanners.length).tap do |results|
-        @scanners.map.with_index { |scanner, i|
-          Thread.start { results[i] = scanner.keys }
-        }.each(&:join)
+        results_mutex = Mutex.new
+        @scanners.map.with_index do |scanner, i|
+          Thread.start do
+            scanner_results = scanner.keys
+            results_mutex.synchronize do
+              results[i] = scanner_results
+            end
+          end
+        end.each(&:join)
       end
     end
   end

data/lib/i18n/tasks/split_key.rb

@@ -2,7 +2,7 @@
 module I18n
   module Tasks
     module SplitKey
-      extend self
+      module_function
 
       # split a key by dots (.)
       # dots inside braces or parenthesis are not split on
@@ -37,7 +37,7 @@ module I18n
         return enum_for(:key_parts, key) unless block
         nesting = PARENS
         counts  = PARENS_ZEROS # dup'd later if key contains parenthesis
-        delim   = '.'.freeze
+        delim   = '.'
         from    = to = 0
         key.each_char do |char|
           if char == delim && PARENS_ZEROS == counts
@@ -46,7 +46,7 @@ module I18n
           else
             nest_i, nest_inc = nesting[char]
             if nest_i
-              counts         = counts.dup if counts.frozen?
+              counts = counts.dup if counts.frozen?
               counts[nest_i] += nest_inc
             end
             to += 1
@@ -56,12 +56,11 @@ module I18n
         true
       end
 
-      PARENS       = %w({} [] ()).inject({}) { |h, s|
+      PARENS = %w({} [] ()).each_with_object({}) do |s, h|
         i              = h.size / 2
         h[s[0].freeze] = [i, 1].freeze
         h[s[1].freeze] = [i, -1].freeze
-        h
-      }.freeze
+      end.freeze
       PARENS_ZEROS = Array.new(PARENS.size, 0).freeze
       private_constant :PARENS
       private_constant :PARENS_ZEROS

data/lib/i18n/tasks/stats.rb

@@ -2,18 +2,20 @@
 module I18n::Tasks
   module Stats
     def forest_stats(forest)
-      key_count    = forest.leaves.count
+      key_count = forest.leaves.count
       locale_count = forest.count
       if key_count.zero?
-        {key_count: 0}
+        { key_count: 0 }
       else
         {
-            locales:          forest.map(&:key).join(', '),
-            key_count:        key_count,
-            locale_count:     locale_count,
-            per_locale_avg:   forest.inject(0) { |sum, f| sum + f.leaves.count } / locale_count,
-            key_segments_avg: '%.1f' % (forest.leaves.inject(0) { |sum, node| sum + node.walk_to_root.count - 1 } / key_count.to_f),
-            value_chars_avg:  forest.leaves.inject(0) { |sum, node| sum + node.value.to_s.length } / key_count
+          locales: forest.map(&:key).join(', '),
+          key_count: key_count,
+          locale_count: locale_count,
+          per_locale_avg: forest.inject(0) { |sum, f| sum + f.leaves.count } / locale_count,
+          key_segments_avg: format(
+            '%.1f', forest.leaves.inject(0) { |sum, node| sum + node.walk_to_root.count - 1 } / key_count.to_f
+          ),
+          value_chars_avg: forest.leaves.inject(0) { |sum, node| sum + node.value.to_s.length } / key_count
         }
       end
     end

data/lib/i18n/tasks/string_interpolation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module I18n::Tasks
   module StringInterpolation
-    extend self
+    module_function
 
     def interpolate_soft(s, t = {})
       return s unless s

data/lib/i18n/tasks/unused_keys.rb

@@ -15,8 +15,8 @@ module I18n
         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)) &&
-              !used_key_names.include?(depluralize_key(key, locale))
+            (strict || !used_in_expr?(key)) &&
+            !used_key_names.include?(depluralize_key(key, locale))
         }
       end
     end

data/lib/i18n/tasks/used_keys.rb

@@ -6,25 +6,30 @@ require 'i18n/tasks/scanners/scanner_multiplexer'
 require 'i18n/tasks/scanners/files/caching_file_finder_provider'
 require 'i18n/tasks/scanners/files/caching_file_reader'
 
+# Require the pattern mapper even though it's not used by i18n-tasks directly.
+# This allows the user to use it in config/i18n-tasks.yml without having to require it.
+# See https://github.com/glebm/i18n-tasks/issues/204.
+require 'i18n/tasks/scanners/pattern_mapper'
+
 module I18n::Tasks
-  module UsedKeys
+  module UsedKeys # rubocop:disable Metrics/ModuleLength
     SEARCH_DEFAULTS = {
-        paths:          %w(app/).freeze,
-        relative_roots: %w(app/controllers app/helpers app/mailers app/presenters app/views).freeze,
-        scanners:       [['::I18n::Tasks::Scanners::RubyAstScanner', only: %w(*.rb)]],
-        strict:         true,
-    }.tap { |defaults|
+      paths:          %w(app/).freeze,
+      relative_roots: %w(app/controllers app/helpers app/mailers app/presenters app/views).freeze,
+      scanners:       [['::I18n::Tasks::Scanners::RubyAstScanner', only: %w(*.rb)]],
+      strict:         true
+    }.tap do |defaults|
       defaults[:scanners] << ['::I18n::Tasks::Scanners::PatternWithScopeScanner',
                               exclude:      defaults[:scanners].map { |(_, opts)| opts[:only] }.reduce(:+).freeze,
-                              ignore_lines: {'opal'   => %q(^\s*#(?!\si18n-tasks-use)),
-                                             'haml'   => %q(^\s*-\s*#(?!\si18n-tasks-use)),
-                                             'slim'   => %q(^\s*(?:-#|/)(?!\si18n-tasks-use)),
-                                             'coffee' => %q(^\s*#(?!\si18n-tasks-use)),
-                                             'erb'    => %q(^\s*<%\s*#(?!\si18n-tasks-use))}.freeze] }
-
+                              ignore_lines: { 'opal' => %q(^\s*#(?!\si18n-tasks-use)),
+                                              'haml'   => %q(^\s*-\s*#(?!\si18n-tasks-use)),
+                                              'slim'   => %q(^\s*(?:-#|/)(?!\si18n-tasks-use)),
+                                              'coffee' => %q(^\s*#(?!\si18n-tasks-use)),
+                                              'erb'    => %q(^\s*<%\s*#(?!\si18n-tasks-use)) }.freeze]
+    end
 
     ALWAYS_EXCLUDE = %w(*.jpg *.png *.gif *.svg *.ico *.eot *.otf *.ttf *.woff *.woff2 *.pdf *.css *.sass *.scss *.less
-                        *.yml *.json *.zip *.tar.gz)
+                        *.yml *.json *.zip *.tar.gz).freeze
 
     # Find all keys in the source and return a forest with the keys in absolute form and their occurrences.
     #
@@ -41,28 +46,25 @@ module I18n::Tasks
       src_tree.tap do |result|
         tree = result['used'].children
         tree.subtract_by_key!(raw_refs)
-        if include_raw_references
-          tree.merge!(raw_refs)
-        end
+        tree.merge!(raw_refs) if include_raw_references
         tree.merge!(used_refs).merge!(resolved_refs)
       end
     end
 
     def used_in_source_tree(key_filter: nil, strict: nil)
       keys = ((@keys_used_in_source_tree ||= {})[strict?(strict)] ||=
-          scanner(strict: strict).keys.freeze)
+                scanner(strict: strict).keys.freeze)
       if key_filter
         key_filter_re = compile_key_pattern(key_filter)
         keys          = keys.reject { |k| k.key !~ key_filter_re }
       end
       Data::Tree::Node.new(
-          key:      'used',
-          data:     {key_filter: key_filter},
-          children: Data::Tree::Siblings.from_key_occurrences(keys)
+        key:      'used',
+        data:     { key_filter: key_filter },
+        children: Data::Tree::Siblings.from_key_occurrences(keys)
       ).to_siblings
     end
 
-
     def scanner(strict: nil)
       (@scanner ||= {})[strict?(strict)] ||= begin
         shared_options = search_config.dup
@@ -70,16 +72,18 @@ module I18n::Tasks
         shared_options[:strict] = strict unless strict.nil?
         log_verbose 'Scanners: '
         Scanners::ScannerMultiplexer.new(
-            scanners: search_config[:scanners].map { |(class_name, args)|
-              if args && args[:strict]
-                fail CommandError.new('the strict option is global and cannot be applied on the scanner level')
-              end
-
-              ActiveSupport::Inflector.constantize(class_name).new(
-                  config:               merge_scanner_configs(shared_options, args || {}),
-                  file_finder_provider: caching_file_finder_provider,
-                  file_reader:          caching_file_reader)
-            }.tap { |scanners| log_verbose { scanners.map { |s| "  #{s.class.name} #{s.config.inspect}" } * "\n" } })
+          scanners: search_config[:scanners].map do |(class_name, args)|
+            if args && args[:strict]
+              fail CommandError, 'the strict option is global and cannot be applied on the scanner level'
+            end
+
+            ActiveSupport::Inflector.constantize(class_name).new(
+              config:               merge_scanner_configs(shared_options, args || {}),
+              file_finder_provider: caching_file_finder_provider,
+              file_reader:          caching_file_reader
+            )
+          end.tap { |scanners| log_verbose { scanners.map { |s| "  #{s.class.name} #{s.config.inspect}" } * "\n" } }
+        )
       end
     end
 
@@ -122,9 +126,9 @@ module I18n::Tasks
       @caching_file_reader ||= Scanners::Files::CachingFileReader.new
     end
 
-    # @return whether the key is potentially used in a code expression such as `t("category.#{ category_key }")`
+    # @return [Boolean] whether the key is potentially used in a code expression such as `t("category.#{category_key}")`
     def used_in_expr?(key)
-      !!(key =~ expr_key_re)
+      !!(key =~ expr_key_re) # rubocop:disable Style/DoubleNegation
     end
 
     private
@@ -137,17 +141,17 @@ module I18n::Tasks
 
     # keys in the source that end with a ., e.g. t("category.#{ cat.i18n_key }") or t("category." + category.key)
     # @param [String] replacement for interpolated values.
-    def expr_key_re(replacement: ':'.freeze)
+    def expr_key_re(replacement: ':')
       @expr_key_re ||= begin
         # disallow patterns with no keys
         ignore_pattern_re = /\A[\.#{replacement}]*\z/
-        patterns          = used_in_source_tree(strict: false).key_names.select { |k|
-          k.end_with?('.'.freeze) || k =~ /\#{/.freeze
-        }.map { |k|
-          pattern = "#{replace_key_exp(k, replacement)}#{replacement if k.end_with?('.'.freeze)}"
+        patterns          = used_in_source_tree(strict: false).key_names.select do |k|
+          k.end_with?('.') || k =~ /\#{/
+        end.map do |k|
+          pattern = "#{replace_key_exp(k, replacement)}#{replacement if k.end_with?('.')}"
           next if pattern =~ ignore_pattern_re
           pattern
-        }.compact
+        end.compact
         compile_key_pattern "{#{patterns * ','}}"
       end
     end
@@ -160,15 +164,15 @@ module I18n::Tasks
       scanner = StringScanner.new(key)
       braces  = []
       result  = []
-      while (match_until = scanner.scan_until(/(?:#?\{|})/.freeze))
-        if scanner.matched == '#{'.freeze
+      while (match_until = scanner.scan_until(/(?:#?\{|})/))
+        if scanner.matched == '#{'
           braces << scanner.matched
           result << match_until[0..-3] if braces.length == 1
         elsif scanner.matched == '}'
           prev_brace = braces.pop
-          result << replacement if braces.empty? && prev_brace == '#{'.freeze
+          result << replacement if braces.empty? && prev_brace == '#{'
         else
-          braces << '{'.freeze
+          braces << '{'
         end
       end
       result << key[scanner.pos..-1] unless scanner.eos?

data/lib/i18n/tasks/version.rb

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

data/templates/rspec/i18n_spec.rb

@@ -8,11 +8,11 @@ RSpec.describe 'I18n' do
 
   it 'does not have missing keys' do
     expect(missing_keys).to be_empty,
-      "Missing #{missing_keys.leaves.count} i18n keys, run `i18n-tasks missing' to show them"
+                            "Missing #{missing_keys.leaves.count} i18n keys, run `i18n-tasks missing' to show them"
   end
 
   it 'does not have unused keys' do
     expect(unused_keys).to be_empty,
-      "#{unused_keys.leaves.count} unused i18n keys, run `i18n-tasks unused' to show them"
+                           "#{unused_keys.leaves.count} unused i18n keys, run `i18n-tasks unused' to show them"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-tasks
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors:
 - glebm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2016-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -192,6 +192,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -330,4 +358,3 @@ signing_key:
 specification_version: 4
 summary: Manage localization and translation with the awesome power of static analysis
 test_files: []
-has_rdoc: