i18n-tasks 0.2.22 → 0.3.0.rc1

data/lib/i18n/tasks/data/storage/file_storage.rb

@@ -44,7 +44,7 @@ module I18n::Tasks
               hash.deep_merge! locale_data || {}
               hash
             end[locale.to_s] || {}
-          end
+          end.with_indifferent_access
         end
 
         alias [] get

data/lib/i18n/tasks/data_traversal.rb

@@ -1,13 +1,12 @@
 module I18n::Tasks::DataTraversal
   # translation of the key found in the passed hash or nil
   # @return [String,nil]
-  def t(hash = data[base_locale], key)
-    if hash.is_a?(String)
-      # hash is a locale
-      raise ArgumentError.new("invalid locale: #{hash}") if hash =~ /[^A-z\d-]/
-      hash = data[hash]
-    end
-    key.to_s.split('.').inject(hash) { |r, seg| r[seg] if r }
+  def t(key, locale = base_locale)
+    key.to_s.split('.').inject(self.data[locale]) { |r, seg| r[seg] if r }
+  end
+
+  def t_proc(locale = base_locale)
+    proc { |k| t(k, locale) }
   end
 
   # traverse => map if yield(k, v)

data/lib/i18n/tasks/fill_tasks.rb

@@ -1,55 +1,27 @@
 module I18n::Tasks::FillTasks
-  def add_missing!(locale = base_locale, placeholder = nil)
-    normalize_store! locale
-    set_blank_values! locale do |keys|
-      keys.map { |key|
-        placeholder || key.split('.').last.to_s.humanize
-      }
-    end
+  def fill_missing_value(opts = {})
+    opts = opts.merge(
+        keys:  proc { |locale| keys_to_fill(locale) }
+    )
+    opts[:value] ||= '' unless opts[:values].present?
+    update_data opts
   end
 
-  def fill_with_blanks!(locales = nil)
-    locales = non_base_locales(locales)
-    add_missing! base_locale, ''
-    normalize_store! locales
-    locales.each do |locale|
-      add_missing! locale, ''
-    end
+  def fill_missing_google_translate(opts = {})
+    from = opts[:from] || base_locale
+    opts = opts.merge(
+        locales: non_base_locales(opts[:locales]),
+        keys:    proc { |locale| keys_to_fill(locale).select(&t_proc(from)).select { |k| t(k).is_a?(String) } },
+        values:  proc { |keys, locale|
+          google_translate keys.zip(keys.map(&t_proc(from))),
+                           to:   locale,
+                           from: from
+        }
+    )
+    update_data opts
   end
 
-  def fill_with_google_translate!(locales = nil)
-    normalize_store! base_locale
-    locales = non_base_locales(locales)
-    normalize_store! locales
-    locales.each do |locale|
-      blank_keys = keys_missing_from_locale(locale).key_names.select { |k|
-        tr = t(k)
-        tr.present? && tr.is_a?(String)
-      }
-      if blank_keys.present?
-        data[locale] = data[locale].deep_merge(
-          list_to_tree google_translate(blank_keys.zip(blank_keys.map { |k| t(k) }), to: locale, from: base_locale)
-        )
-      end
-    end
-  end
-
-  def fill_with_base_values!(locales = nil)
-    normalize_store! base_locale
-    locales = non_base_locales(locales)
-    normalize_store! locales
-    locales.each do |locale|
-      set_blank_values! locale do |blank_keys|
-        blank_keys.map { |k| t(k) }
-      end
-    end
-  end
-
-  # fill blank values with values from passed block
-  # @param [String] locale
-  def set_blank_values!(locale = base_locale, &fill_with)
-    blank_keys   = keys_missing_from_locale(locale).key_names
-    list         = blank_keys.zip fill_with.call(blank_keys)
-    data[locale] = data[locale].deep_merge(list_to_tree(list))
+  def keys_to_fill(locale)
+    keys_missing_from_locale(locale).key_names
   end
 end

data/lib/i18n/tasks/google_translation.rb

@@ -9,7 +9,7 @@ module I18n::Tasks::GoogleTranslation
       opts[:key] = key
     end
     if opts[:key].blank?
-      $stderr.puts(Term::ANSIColor.red Term::ANSIColor.yellow 'You may need to provide Google API key as GOOGLE_TRANSLATE_API_KEY or in config/i18n-tasks.yml.
+      $stderr.puts(Term::ANSIColor.red Term::ANSIColor.yellow 'You may need to provide Google API key as GOOGLE_TRANSLATE_API_KEY env var or translation.api_key in config/i18n-tasks.yml.
 You can obtain the key at https://code.google.com/apis/console.')
     end
     list.group_by { |k_v| k_v[0].end_with?('_html'.freeze) ? opts.merge(html: true) : opts.merge(format: 'text') }.map do |opts, strings|

data/lib/i18n/tasks/key.rb

@@ -1,7 +1,15 @@
+require 'i18n/tasks/key/key_group'
+require 'i18n/tasks/key/match_pattern'
+require 'i18n/tasks/key/usages'
+
 module I18n
   module Tasks
     class Key
-      attr_accessor :own_attr, :key_group
+      include ::I18n::Tasks::Key::KeyGroup
+      include ::I18n::Tasks::Key::MatchPattern
+      include ::I18n::Tasks::Key::Usages
+
+      attr_accessor :own_attr
 
       def initialize(key_or_attr, own_attr = {})
         @own_attr = if key_or_attr.is_a?(Array)
@@ -14,14 +22,6 @@ module I18n
         @own_attr[:key] = @own_attr[:key].to_s
       end
 
-      def [](prop)
-        @own_attr[prop] || key_group.attr[prop]
-      end
-
-      def attr
-        key_group.attr.merge @own_attr
-      end
-
       def ==(other)
         self.attr == other.attr
       end
@@ -30,29 +30,14 @@ module I18n
         "#<#{self.class.name}#{attr.inspect}>"
       end
 
-      def clone_orphan
-        clone.tap { |k| k.key_group = nil }
-      end
-
       def key
         @own_attr[:key]
       end
+
       alias to_s key
 
       def value
-        self[:value]
-      end
-
-      def locale
-        self[:locale]
-      end
-
-      def type
-        self[:type]
-      end
-
-      def src_pos
-        self[:src_pos]
+        @own_attr[:value]
       end
     end
   end

data/lib/i18n/tasks/key/key_group.rb

@@ -0,0 +1,44 @@
+module I18n
+  module Tasks
+    class Key
+      module KeyGroup
+        attr_accessor :key_group
+
+        def self.included(base)
+          base.class_eval do
+            extend ClassMethods
+            delegate_to_attr :[], :key?
+            delegate_to_attr_accessor :type, :locale
+          end
+        end
+
+        def attr
+          key_group.attr.merge @own_attr
+        end
+
+        def clone_orphan
+          clone.tap { |k| k.key_group = nil }
+        end
+
+        module ClassMethods
+          def delegate_to_attr_accessor(*methods)
+            methods.each do |m|
+              define_method(m) do
+                @own_attr[m] || (kg = key_group) && kg.attr[m]
+              end
+            end
+          end
+
+          def delegate_to_attr(*methods)
+            methods.each do |m|
+              define_method(m) do |*args|
+                @own_attr.send(m, *args) ||
+                    (kg = key_group) && kg.attr.send(m, *args)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/key/match_pattern.rb

@@ -0,0 +1,23 @@
+module I18n
+  module Tasks
+    class Key
+      module MatchPattern
+        def key_match_pattern
+          @key_match_pattern ||= begin
+            k = key
+            "#{k.gsub(/\#{.*?}/, '*')}#{'*' if k.end_with?('.')}"
+          end
+        end
+
+        # A key interpolated with expression
+        def expr?
+          if @is_expr.nil?
+            k        = key
+            @is_expr = (k =~ /\#{.*?}/ || k.end_with?('.'))
+          end
+          @is_expr
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/key/usages.rb

@@ -0,0 +1,11 @@
+module I18n
+  module Tasks
+    class Key
+      module Usages
+        def usages
+          self[:usages]
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/key_pattern_matching.rb

@@ -17,12 +17,16 @@ module I18n::Tasks::KeyPatternMatching
   #      :     matches a single key
   #   {a, b.c} match any in set, can use : and *, match is captured
   def compile_key_pattern(key_pattern)
-    /^#{key_pattern.
+    return key_pattern if key_pattern.is_a?(Regexp)
+    /\A#{key_pattern_re_body(key_pattern)}\z/
+  end
+
+  def key_pattern_re_body(key_pattern)
+    key_pattern.
         gsub(/\./, '\.').
         gsub(/\*/, '.*').
         gsub(/:/, '(?<=^|\.)[^.]+?(?=\.|$)').
         gsub(/\{(.*?)}/) { "(#{$1.strip.gsub /\s*,\s*/, '|'})" }
-    }$/
   end
 
   # @return [Array<String>] keys sans passed patterns

data/lib/i18n/tasks/missing_keys.rb

@@ -3,21 +3,24 @@ module I18n::Tasks
     # @param [:missing_from_base, :missing_from_locale, :eq_base] type (default nil)
     # @return [KeyGroup]
     def missing_keys(opts = {})
-      type = opts[:type]
       locales = non_base_locales(opts[:locales])
-      if type
-        if type == :missing_from_base
-          keys_missing_from_base
-        else
-          locales.map { |locale| send("keys_#{type}", locale) }.reduce(:+) || KeyGroup.new([])
-        end
+      type    = opts[:type]
+      unless type
+        types = opts[:types] || missing_keys_types
+        opts  = opts.except(:types).merge(locales: locales)
+        return types.map { |t| missing_keys(opts.merge(type: t)) }.reduce(:+)
+      end
+      if type == :missing_from_base
+        keys_missing_from_base
       else
-        missing_keys(type: :missing_from_base) +
-          missing_keys(type: :eq_base, locales: locales) +
-          missing_keys(type: :missing_from_locale, locales: locales)
+        locales.map { |locale| send("keys_#{type}", locale) }.reduce(:+) || KeyGroup.new([])
       end
     end
 
+    def missing_keys_types
+      @missing_keys_types ||= [:missing_from_base, :eq_base, :missing_from_locale]
+    end
+
     def untranslated_keys(locales = nil)
       I18n::Tasks.warn_deprecated("#untranslated_keys. Please use #missing_keys instead")
       missing_keys(locales: locales)
@@ -29,7 +32,7 @@ module I18n::Tasks
         KeyGroup.new(
             used_keys.keys.reject { |k|
               key = k.key
-              key_value?(key, base_locale) || pattern_key?(key) || ignore_key?(key, :missing)
+              k.expr? || key_value?(key, base_locale) || ignore_key?(key, :missing)
             }.map(&:clone_orphan), type: :missing_from_base, locale: base_locale)
       end
     end
@@ -49,7 +52,7 @@ module I18n::Tasks
     def keys_eq_base(locale)
       @keys_eq_base ||= KeyGroup.new(
           traverse_map_if(data[base_locale]) { |key, base_value|
-            key if base_value == t(locale, key) && !ignore_key?(key, :eq_base, locale)
+            key if base_value == t(key, locale) && !ignore_key?(key, :eq_base, locale)
           }, type: :eq_base, locale: locale)
     end
   end

data/lib/i18n/tasks/plural_keys.rb

@@ -5,13 +5,13 @@ module I18n::Tasks::PluralKeys
   # @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
   def depluralize_key(locale = base_locale, key)
-    return key if key !~ PLURAL_KEY_RE || t(locale, key).is_a?(Hash)
+    return key if key !~ PLURAL_KEY_RE || t(key, locale).is_a?(Hash)
     parent_key      = key.split('.')[0..-2] * '.'
-    plural_versions = t(locale, parent_key)
+    plural_versions = t(parent_key, locale)
     if plural_versions.is_a?(Hash) && plural_versions.all? { |k, v| ".#{k}" =~ PLURAL_KEY_RE && !v.is_a?(Hash) }
       parent_key
     else
       key
     end
   end
-end
+end

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

@@ -2,11 +2,12 @@
 module I18n::Tasks::Reports
   class Base
 
-    def initialize
-      @task = I18n::Tasks::BaseTask.new
+    def initialize(task = I18n::Tasks::BaseTask.new)
+      @task = task
     end
 
     attr_reader :task
+    delegate :base_locale, :locales, to: :task
 
     MISSING_TYPES = {
         missing_from_base:   {glyph: '✗', summary: 'missing from base locale'},

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

@@ -4,7 +4,8 @@ require 'fileutils'
 module I18n::Tasks::Reports
   class Spreadsheet < Base
 
-    def save_report(path = 'tmp/i18n-report.xlsx')
+    def save_report(path = nil)
+      path = 'tmp/i18n-report.xlsx' if path.blank?
       p = Axlsx::Package.new
       add_missing_sheet p.workbook
       add_unused_sheet p.workbook

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

@@ -14,12 +14,12 @@ module I18n
 
             print_info "#{bold 'Types:'} #{missing_types.values.map { |t| "#{t[:glyph]} #{t[:summary]}" } * ', '}"
 
-            print_table headings: [magenta(bold('Locale')), bold('Type'), magenta('i18n Key'), bold(cyan "Base value (#{base_locale})")] do |t|
+            print_table headings: [magenta(bold('Locale')), bold('Type'), magenta(bold 'i18n Key'), bold(cyan "Base value (#{base_locale})")] do |t|
               t.rows = keys.map { |key|
                 glyph = missing_types[key.type][:glyph]
                 glyph = {missing_from_base: red(glyph), missing_from_locale: yellow(glyph), eq_base: bold(blue(glyph))}[key.type]
                 if key[:type] == :missing_from_base
-                  locale     = magenta bold key.locale
+                  locale     = magenta key.locale
                   base_value = ''
                 else
                   locale     = magenta key.locale
@@ -28,7 +28,7 @@ module I18n
                 [{value: locale, alignment: :center},
                  {value: glyph, alignment: :center},
                  magenta(key[:key]),
-                 base_value]
+                 cyan(base_value)]
               }
             end
           else
@@ -41,8 +41,8 @@ module I18n
           keys.sort_by_attr!(key: :asc)
           if keys.present?
             keys.each do |k|
-              puts "#{bold "#{k.key}"} #{green k[:usages].size if k[:usages].size > 1}"
-              k[:usages].each do |u|
+              puts "#{bold "#{k.key}"} #{green(k.usages.size.to_s) if k.usages.size > 1}"
+              k.usages.each do |u|
                 line = u[:line].dup.tap { |line|
                   line.strip!
                   line.sub!(/(.*?)(#{k[:key]})(.*)$/) { dark($1) + underline($2) + dark($3)}
@@ -58,7 +58,7 @@ module I18n
         def unused_keys(keys = task.unused_keys)
           print_title unused_title(keys)
           if keys.present?
-            print_table headings: [bold(magenta('i18n Key')), cyan("Base value (#{base_locale})")] do |t|
+            print_table headings: [bold(magenta('i18n Key')), bold(cyan("Base value (#{base_locale})"))] do |t|
               t.rows = keys.map { |k| [magenta(k.key), cyan(k.value)] }
             end
           else

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

@@ -5,17 +5,22 @@ module I18n::Tasks::Scanners
     include ::I18n::Tasks::KeyPatternMatching
     attr_reader :config, :key_filter, :record_usages
 
-    def initialize(config)
+    def initialize(config = {})
       @config        = config.dup.with_indifferent_access.tap do |conf|
         conf[:paths]   = %w(app/) if conf[:paths].blank?
         conf[:include] = Array(conf[:include]) if conf[:include].present?
-        conf[:exclude] = Array(conf[:exclude])
+        if conf.key?(:exclude)
+          conf[:exclude] = Array(conf[:exclude])
+        else
+          # exclude common binary extensions by default (images and fonts)
+          conf[:exclude] = %w(*.jpg *.png *.gif *.svg *.ico *.eot *.ttf *.woff)
+        end
       end
       @record_usages = false
     end
 
     def key_filter=(value)
-      @key_filter = value
+      @key_filter         = value
       @key_filter_pattern = compile_key_pattern(value) if @key_filter
     end
 
@@ -24,15 +29,16 @@ module I18n::Tasks::Scanners
       if @record_usages
         keys_with_usages
       else
-        @keys ||= traverse_files { |path| scan_file(path, read_file(path)).map(&:key) }.reduce(:+).uniq
+        @keys ||= (traverse_files { |path| scan_file(path, read_file(path)).map(&:key) }.reduce(:+) || []).uniq
       end
     end
 
     def keys_with_usages
       with_usages do
-        traverse_files { |path|
+        keys = traverse_files { |path|
           ::I18n::Tasks::KeyGroup.new(scan_file(path, read_file(path)), src_path: path)
-        }.map(&:keys).reduce(:+).group_by(&:key).map { |key, key_usages|
+        }.map(&:keys).reduce(:+) || []
+        keys.group_by(&:key).map { |key, key_usages|
           {key: key, usages: key_usages.map { |usage| usage[:src].merge(path: usage[:src_path]) }}
         }
       end
@@ -53,7 +59,12 @@ module I18n::Tasks::Scanners
     # @return [Array] Results of block calls
     def traverse_files
       result = []
-      Find.find(*config[:paths]) do |path|
+      paths  = config[:paths].select { |p| File.exists?(p) }
+      if paths.empty?
+        STDERR.puts Term::ANSIColor.yellow("i18n-tasks: [WARN] search.paths (#{config[:paths]}) do not exist")
+        return result
+      end
+      Find.find(*paths) do |path|
         next if File.directory?(path) ||
             config[:include] && !path_fnmatch_any?(path, config[:include]) ||
             path_fnmatch_any?(path, config[:exclude])
@@ -65,6 +76,7 @@ module I18n::Tasks::Scanners
     def path_fnmatch_any?(path, globs)
       globs.any? { |glob| File.fnmatch(glob, path) }
     end
+
     protected :path_fnmatch_any?
 
     def with_key_filter(key_filter = nil)
@@ -97,16 +109,10 @@ module I18n::Tasks::Scanners
       }}
     end
 
-    def extract_key_from_match(match, path)
-      key = strip_literal(match[0])
-      key = absolutize_key(key, path) if path && key.start_with?('.')
-      key
-    end
-
     # remove the leading colon and unwrap quotes from the key match
     def strip_literal(literal)
       key = literal
-      key.slice!(0) if ':' == key[0]
+      key = key[1..-1] if ':' == key[0]
       key = key[1..-2] if %w(' ").include?(key[0])
       key
     end