i18n-tasks 0.9.6 → 0.9.7

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

@@ -2,8 +2,7 @@
 module I18n::Tasks
   module Data::Tree
     # Any Enumerable that yields nodes can mix in this module
-    module Traversal
-
+    module Traversal # rubocop:disable Metrics/ModuleLength
       def nodes(&block)
         depth_first(&block)
       end
@@ -41,12 +40,13 @@ module I18n::Tasks
 
       def depth_first(&visitor)
         return to_enum(:depth_first) unless visitor
-        each { |node|
+        each do |node|
           visitor.yield node
+          next unless node.children?
           node.children.each do |child|
             child.depth_first(&visitor)
-          end if node.children?
-        }
+          end
+        end
         self
       end
 
@@ -58,7 +58,6 @@ module I18n::Tasks
         self
       end
 
-
       def key_names(opts = {})
         opts[:root] = false unless opts.key?(:root)
         keys(opts).map { |key, _node| key }
@@ -88,12 +87,11 @@ module I18n::Tasks
       def select_nodes(&block)
         tree = Siblings.new
         each do |node|
-          if block.yield(node)
-            tree.append! node.derive(
-                             parent:   tree.parent,
-                             children: (node.children.select_nodes(&block).to_a if node.children)
-                         )
-          end
+          next unless block.yield(node)
+          tree.append! node.derive(
+            parent: tree.parent,
+            children: (node.children.select_nodes(&block).to_a if node.children)
+          )
         end
         tree
       end
@@ -117,56 +115,55 @@ module I18n::Tasks
       # @return Siblings
       def select_keys(opts = {}, &block)
         root = opts.key?(:root) ? opts[:root] : false
-        ok   = {}
+        ok = {}
         keys(root: root) do |full_key, node|
           if block.yield(full_key, node)
-            node.walk_to_root { |p|
+            node.walk_to_root do |p|
               break if ok[p]
               ok[p] = true
-            }
+            end
           end
         end
-        select_nodes { |node|
+        select_nodes do |node|
           ok[node]
-        }
+        end
       end
 
       # @return Siblings
       def intersect_keys(other_tree, key_opts = {}, &block)
         if block
-          select_keys(key_opts) { |key, node|
+          select_keys(key_opts) do |key, node|
             other_node = other_tree[key]
-            other_node && block.call(key, node, other_node)
-          }
+            other_node && yield(key, node, other_node)
+          end
         else
-          select_keys(key_opts) { |key, node| other_tree[key] }
+          select_keys(key_opts) { |key, _node| other_tree[key] }
         end
       end
 
       def grep_keys(match, opts = {})
         select_keys(opts) do |full_key, _node|
-          match === full_key
+          match === full_key # rubocop:disable Style/CaseEquality
         end
       end
 
       def set_each_value!(val_pattern, key_pattern = nil, &value_proc)
-        value_proc ||= proc { |node|
+        value_proc ||= proc do |node|
           node_value = node.value
           next node_value if node.reference?
-          human_key  = ActiveSupport::Inflector.humanize(node.key.to_s)
-          full_key   = node.full_key
+          human_key = ActiveSupport::Inflector.humanize(node.key.to_s)
+          full_key = node.full_key
+          default = (node.data[:occurrences] || []).detect { |o| o.default_arg.presence }.try(:default_arg)
           StringInterpolation.interpolate_soft(
-              val_pattern,
-              value:                         node_value,
-              human_key:                     human_key,
-              key:                           full_key,
-              value_or_human_key:            node_value.presence || human_key,
-              value_or_default_or_human_key: node_value.presence ||
-                                                 (node.data[:occurrences] || []).detect { |o|
-                                                   o.default_arg.presence }.try(:default_arg) ||
-                                                 human_key
+            val_pattern,
+            value: node_value,
+            human_key: human_key,
+            key: full_key,
+            default: default,
+            value_or_human_key: node_value.presence || human_key,
+            value_or_default_or_human_key: node_value.presence || default || human_key
           )
-        }
+        end
         if key_pattern.present?
           pattern_re = I18n::Tasks::KeyPatternMatching.compile_key_pattern(key_pattern)
         end

data/lib/i18n/tasks/google_translation.rb

@@ -4,7 +4,6 @@ require 'i18n/tasks/html_keys'
 
 module I18n::Tasks
   module GoogleTranslation
-
     # @param [I18n::Tasks::Tree::Siblings] forest to translate to the locales of its root nodes
     # @param [String] from locale
     # @return [I18n::Tasks::Tree::Siblings] translated forest
@@ -17,18 +16,18 @@ module I18n::Tasks
 
     # @param [Array<[String, Object]>] list of key-value pairs
     # @return [Array<[String, Object]>] translated list
-    def google_translate_list(list, opts)
+    def google_translate_list(list, opts) # rubocop:disable Metrics/AbcSize
       return [] if list.empty?
-      opts       = opts.dup
+      opts = opts.dup
       opts[:key] ||= translation_config[:api_key]
       validate_google_translate_api_key! opts[:key]
-      key_pos = list.each_with_index.inject({}) { |idx, ((k, _v), i)| idx[k] = i; idx }
+      key_pos = list.each_with_index.inject({}) { |idx, ((k, _v), i)| idx.update(k => i) }
       # copy reference keys as is, instead of translating
       reference_key_vals = list.select { |_k, v| v.is_a? Symbol } || []
       list -= reference_key_vals
-      result  = list.group_by { |k_v| html_key? k_v[0], opts[:from] }.map { |is_html, list_slice|
-        fetch_google_translations list_slice, opts.merge(is_html ? {html: true} : {format: 'text'})
-      }.reduce(:+) || []
+      result = list.group_by { |k_v| html_key? k_v[0], opts[:from] }.map do |is_html, list_slice|
+        fetch_google_translations list_slice, opts.merge(is_html ? { html: true } : { format: 'text' })
+      end.reduce(:+) || []
       result.concat(reference_key_vals)
       result.sort! { |a, b| key_pos[a[0]] <=> key_pos[b[0]] }
       result
@@ -39,7 +38,7 @@ module I18n::Tasks
     def fetch_google_translations(list, opts)
       from_values(list, EasyTranslate.translate(to_values(list), opts)).tap do |result|
         if result.blank?
-          raise CommandError.new(I18n.t('i18n_tasks.google_translate.errors.no_results'))
+          fail CommandError, I18n.t('i18n_tasks.google_translate.errors.no_results')
         end
       end
     end
@@ -48,7 +47,7 @@ module I18n::Tasks
 
     def validate_google_translate_api_key!(key)
       if key.blank?
-        raise CommandError.new(I18n.t('i18n_tasks.google_translate.errors.no_api_key'))
+        fail CommandError, I18n.t('i18n_tasks.google_translate.errors.no_api_key')
       end
     end
 
@@ -71,13 +70,11 @@ module I18n::Tasks
     # @return [String, Array<String, nil>, nil] value for Google Translate or nil for non-string values
     def dump_value(value)
       case value
-        when Array
-          # dump recursively
-          value.map { |v| dump_value v }
-        when String
-          replace_interpolations value
-        else
-          nil
+      when Array
+        # dump recursively
+        value.map { |v| dump_value v }
+      when String
+        replace_interpolations value
       end
     end
 
@@ -87,18 +84,18 @@ module I18n::Tasks
     # @return [Object] final translated value
     def parse_value(untranslated, each_translated)
       case untranslated
-        when Array
-          # implode array
-          untranslated.map { |from| parse_value(from, each_translated) }
-        when String
-          restore_interpolations untranslated, each_translated.next
-        else
-          untranslated
+      when Array
+        # implode array
+        untranslated.map { |from| parse_value(from, each_translated) }
+      when String
+        restore_interpolations untranslated, each_translated.next
+      else
+        untranslated
       end
     end
 
-    INTERPOLATION_KEY_RE  = /%\{[^}]+\}/.freeze
-    UNTRANSLATABLE_STRING = 'zxzxzx'.freeze
+    INTERPOLATION_KEY_RE  = /%\{[^}]+\}/
+    UNTRANSLATABLE_STRING = 'zxzxzx'
 
     # @param [String] value
     # @return [String] 'hello, %{name}' => 'hello, <round-trippable string>'

data/lib/i18n/tasks/html_keys.rb

@@ -5,9 +5,11 @@ module I18n::Tasks
     MAYBE_PLURAL_HTML_KEY_PATTERN = /[.\-_]html\.[^.]+\z/
 
     def html_key?(full_key, locale)
+      # rubocop:disable Style/DoubleNegation
       !!(full_key =~ HTML_KEY_PATTERN ||
           full_key =~ MAYBE_PLURAL_HTML_KEY_PATTERN &&
               depluralize_key(split_key(full_key, 2)[1], locale) =~ HTML_KEY_PATTERN)
+      # rubocop:enable Style/DoubleNegation
     end
   end
 end

data/lib/i18n/tasks/ignore_keys.rb

@@ -14,13 +14,14 @@ module I18n::Tasks::IgnoreKeys
     @ignore_patterns              ||= HashWithIndifferentAccess.new
     @ignore_patterns[type]        ||= {}
     @ignore_patterns[type][locale] ||= begin
-      global, type_ignore = ignore_config.presence || [], ignore_config(type).presence || []
+      global = ignore_config.presence || []
+      type_ignore = ignore_config(type).presence || []
       patterns = if type_ignore.is_a?(Array)
                    global + type_ignore
                  elsif type_ignore.is_a?(Hash)
                    # ignore per locale
                    global + (type_ignore['all'] || []) +
-                       type_ignore.select { |k, v| k.to_s =~ /\b#{locale}\b/ }.values.flatten(1).compact
+                     type_ignore.select { |k, _v| k.to_s =~ /\b#{locale}\b/ }.values.flatten(1).compact
                  end
       compile_patterns_re patterns
     end

data/lib/i18n/tasks/key_pattern_matching.rb

@@ -2,8 +2,9 @@
 require 'strscan'
 
 module I18n::Tasks::KeyPatternMatching
-  extend self
-  MATCH_NOTHING = /\z\A/.freeze
+  extend self # rubocop:disable Style/ModuleFunction
+
+  MATCH_NOTHING = /\z\A/
 
   # one regex to match any
   def compile_patterns_re(key_patterns)
@@ -11,7 +12,7 @@ module I18n::Tasks::KeyPatternMatching
       # match nothing
       MATCH_NOTHING
     else
-      /(?:#{ key_patterns.map { |p| compile_key_pattern p } * '|'.freeze })/m
+      /(?:#{ key_patterns.map { |p| compile_key_pattern p } * '|' })/m
     end
   end
 
@@ -26,10 +27,10 @@ module I18n::Tasks::KeyPatternMatching
   end
 
   def key_pattern_re_body(key_pattern)
-    key_pattern.
-        gsub(/\./, '\.'.freeze).
-        gsub(/\*/, '.*'.freeze).
-        gsub(/:/, '(?<=^|\.)[^.]+?(?=\.|$)'.freeze).
-        gsub(/\{(.*?)}/) { "(#{$1.strip.gsub /\s*,\s*/, '|'.freeze})" }
+    key_pattern
+      .gsub(/\./, '\.')
+      .gsub(/\*/, '.*')
+      .gsub(/:/, '(?<=^|\.)[^.]+?(?=\.|$)')
+      .gsub(/\{(.*?)}/) { "(#{Regexp.last_match(1).strip.gsub(/\s*,\s*/, '|')})" }
   end
 end

data/lib/i18n/tasks/locale_list.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 module I18n::Tasks
   module LocaleList
-    extend self
+    module_function
 
     # @return locales converted to strings, with base locale first, the rest sorted alphabetically
     def normalize_locale_list(locales, base_locale, include_base = false)
       locales = Array(locales).map(&:to_s).sort
       if locales.include?(base_locale)
         [base_locale] + (locales - [base_locale])
+      elsif include_base
+        [base_locale] + locales
       else
-        if include_base
-          [base_locale] + locales
-        else
-          locales
-        end
+        locales
       end
     end
   end

data/lib/i18n/tasks/locale_pathname.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 module I18n::Tasks
   module LocalePathname
-    extend self
+    class << self
+      def replace_locale(path, from, to)
+        path && path.gsub(path_locale_re(from), to)
+      end
 
-    def replace_locale(path, from, to)
-      path && path.gsub(path_locale_re(from), to)
-    end
-
-    private
+      private
 
-    def path_locale_re(locale)
-      (@path_locale_res ||= {})[locale] ||= /(?<=^|[\/.])#{locale}(?=[\/.])/.freeze
+      def path_locale_re(locale)
+        (@path_locale_res ||= {})[locale] ||= %r{(?<=^|[/.])#{locale}(?=[/.])}
+      end
     end
   end
 end

data/lib/i18n/tasks/logging.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 module I18n::Tasks::Logging
-  extend self
+  module_function
 
   def warn_deprecated(message)
     log_stderr Term::ANSIColor.yellow Term::ANSIColor.bold "#{program_name}: [DEPRECATED] #{message}"
   end
 
-  def log_verbose(message = nil, &block)
+  def log_verbose(message = nil)
     if ::I18n::Tasks.verbose?
-      log_stderr Term::ANSIColor.bright_blue(message || block.call)
+      log_stderr Term::ANSIColor.bright_blue(message || yield)
     end
   end
 

data/lib/i18n/tasks/missing_keys.rb

@@ -2,11 +2,10 @@
 require 'set'
 module I18n::Tasks
   module MissingKeys
-
     MISSING_TYPES = {
-        used: {glyph: '✗', summary: 'used in code but missing from base locale'},
-        diff: {glyph: '∅', summary: 'translated in one locale but not in the other'}
-    }
+      used: { glyph: '✗', summary: 'used in code but missing from base locale' },
+      diff: { glyph: '∅', summary: 'translated in one locale but not in the other' }
+    }.freeze
 
     def self.missing_keys_types
       @missing_keys_types ||= MISSING_TYPES.keys
@@ -19,9 +18,9 @@ module I18n::Tasks
     # @param types [:missing_used, :missing_diff] all if `nil`.
     # @return [Siblings]
     def missing_keys(locales: nil, types: nil, base_locale: nil)
-      locales = locales.presence || self.locales
-      types   = types.presence || missing_keys_types
-      base    = base_locale || self.base_locale
+      locales ||= self.locales
+      types   ||= missing_keys_types
+      base = base_locale || self.base_locale
       types.inject(empty_forest) do |f, type|
         f.merge! send(:"missing_#{type}_forest", locales, base)
       end
@@ -29,59 +28,59 @@ module I18n::Tasks
 
     def eq_base_keys(opts = {})
       locales = Array(opts[:locales]).presence || self.locales
-      (locales - [base_locale]).inject(empty_forest) { |tree, locale|
+      (locales - [base_locale]).inject(empty_forest) do |tree, locale|
         tree.merge! equal_values_tree(locale, base_locale)
-      }
+      end
     end
 
     def missing_diff_forest(locales, base = base_locale)
       tree = empty_forest
       # present in base but not locale
-      (locales - [base]).each { |locale|
+      (locales - [base]).each do |locale|
         tree.merge! missing_diff_tree(locale, base)
-      }
+      end
       if locales.include?(base)
         # present in locale but not base
-        (self.locales - [base]).each { |locale|
+        (self.locales - [base]).each do |locale|
           tree.merge! missing_diff_tree(base, locale)
-        }
+        end
       end
       tree
     end
 
     def missing_used_forest(locales, _base = base_locale)
-      locales.inject(empty_forest) { |forest, locale|
+      locales.inject(empty_forest) do |forest, locale|
         forest.merge! missing_used_tree(locale)
-      }
+      end
     end
 
     # keys present in compared_to, but not in locale
     def missing_diff_tree(locale, compared_to = base_locale)
-      data[compared_to].select_keys { |key, _node|
+      data[compared_to].select_keys do |key, _node|
         locale_key_missing? locale, depluralize_key(key, compared_to)
-      }.set_root_key!(locale, type: :missing_diff).keys { |_key, node|
+      end.set_root_key!(locale, type: :missing_diff).keys do |_key, node|
         # change path and locale to base
-        data = {locale: locale, missing_diff_locale: node.data[:locale]}
+        data = { locale: locale, missing_diff_locale: node.data[:locale] }
         if node.data.key?(:path)
           data[:path] = LocalePathname.replace_locale(node.data[:path], node.data[:locale], locale)
         end
         node.data.update data
-      }
+      end
     end
 
     # keys used in the code missing translations in locale
     def missing_used_tree(locale)
-      used_tree(strict: true).select_keys { |key, _node|
+      used_tree(strict: true).select_keys do |key, _node|
         locale_key_missing?(locale, key)
-      }.set_root_key!(locale, type: :missing_used)
+      end.set_root_key!(locale, type: :missing_used)
     end
 
     def equal_values_tree(locale, compare_to = base_locale)
       base = data[compare_to].first.children
-      data[locale].select_keys(root: false) { |key, node|
+      data[locale].select_keys(root: false) do |key, node|
         other_node = base[key]
         other_node && !node.reference? && node.value == other_node.value && !ignore_key?(key, :eq_base, locale)
-      }.set_root_key!(locale, type: :eq_base)
+      end.set_root_key!(locale, type: :eq_base)
     end
 
     def locale_key_missing?(locale, key)
@@ -96,7 +95,7 @@ module I18n::Tasks
       to_remove               = []
       forest.each do |root|
         locale = root.key
-        root.keys { |key, node|
+        root.keys do |key, node|
           next unless yield node
           if locales_and_node_by_key.key?(key)
             locales_and_node_by_key[key][0] << locale
@@ -104,17 +103,16 @@ module I18n::Tasks
             locales_and_node_by_key[key] = [[locale], node]
           end
           to_remove << node
-        }
+        end
       end
       forest.remove_nodes_and_emptied_ancestors! to_remove
-      locales_and_node_by_key.inject({}) { |inv, (key, (locales, node))|
+      locales_and_node_by_key.each_with_object({}) do |(key, (locales, node)), inv|
         (inv[locales.sort.join('+')] ||= []) << [key, node]
-        inv
-      }.map { |locales, keys_nodes|
-        keys_nodes.each { |(key, node)|
+      end.map do |locales, keys_nodes|
+        keys_nodes.each do |(key, node)|
           forest["#{locales}.#{key}"] = node
-        }
-      }
+        end
+      end
       forest
     end
   end