i18n-tasks 0.2.22 → 0.3.0.rc1

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

@@ -4,26 +4,52 @@ module I18n::Tasks::Scanners
   # Scans for I18n.t usages
   #
   class PatternScanner < BaseScanner
-    LITERAL_RE      = /:?".+?"|:?'.+?'|:\w+/
-    DEFAULT_PATTERN = /\bt(?:ranslate)?[( ]\s*(#{LITERAL_RE})/
-
     # Extract i18n keys from file based on the pattern which must capture the key literal.
     # @return [String] keys found in file
     def scan_file(path, text = read_file(path))
       keys = []
       text.scan(pattern) do |match|
         src_pos = Regexp.last_match.offset(0).first
-        key     = extract_key_from_match(match, path)
+        key     = match_to_key(match, path)
         next unless valid_key?(key)
         keys << ::I18n::Tasks::Key.new(key, usage_context(text, src_pos))
       end
       keys
     end
 
+    def default_pattern
+      # capture only the first argument
+      /
+      #{translate_call_re} [\( ] \s* (?# fn call begin )
+      (#{literal_re})                (?# capture the first argument)
+      /x
+    end
+
     protected
 
+    # Given
+    # @param [MatchData] match
+    # @param [String] path
+    # @return [String] full absolute key name
+    def match_to_key(match, path)
+      key = strip_literal(match[0])
+      key = absolutize_key(key, path) if path && key.start_with?('.')
+      key
+    end
+
     def pattern
-      @pattern ||= config[:pattern].present? ? Regexp.new(config[:pattern]) : DEFAULT_PATTERN
+      @pattern ||= config[:pattern].present? ? Regexp.new(config[:pattern]) : default_pattern
+    end
+
+    def translate_call_re
+      /\bt(?:ranslate)?/
+    end
+
+    # Match literals:
+    # * String: '', "#{}"
+    # * Symbol: :sym, :'', :"#{}"
+    def literal_re
+      /:?".+?"|:?'.+?'|:\w+/
     end
   end
 end

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

@@ -0,0 +1,75 @@
+require 'i18n/tasks/scanners/pattern_scanner'
+
+module I18n::Tasks::Scanners
+  # Scans for I18n.t(key, scope: ...) usages
+  # both scope: "literal", and scope: [:array, :of, 'literals'] forms are supported
+  # Caveat: scope is only detected when it is the first argument
+  class PatternWithScopeScanner < PatternScanner
+
+    def default_pattern
+      # capture the first argument and scope argument if present
+      /#{super}
+      (?: \s*,\s* #{scope_arg_re} )? (?# capture scope in second argument )
+      /x
+    end
+
+    protected
+
+    # Given
+    # @param [MatchData] match
+    # @param [String] path
+    # @return [String] full absolute key name with scope resolved if any
+    def match_to_key(match, path)
+      key   = super
+      scope = match[1]
+      if scope
+        scope_ns = scope.gsub(/[\[\]\s]+/, '').split(',').map { |arg| strip_literal(arg) } * '.'
+        "#{scope_ns}.#{key}"
+      else
+        key unless match[0] =~ /\A\w/
+      end
+    end
+
+
+    # also parse expressions with literals
+    def literal_re
+      /(?: (?: #{super} ) | #{expr_re} )/x
+    end
+
+    # strip literals, convert expressions to #{interpolations}
+    def strip_literal(val)
+      if val =~ /\A\w/
+        "\#{#{val}}"
+      else
+        super(val)
+      end
+    end
+
+    # Regexps:
+
+    # scope: literal or code expression or an array of these
+    def scope_arg_re
+      /(?:
+         :#{scope_arg_name}\s*=>\s* | (?# :scope => :home )
+         #{scope_arg_name}:\s*        (?#    scope: :home )
+        ) (#{array_or_one_literal_re})/x
+    end
+
+    def scope_arg_name
+      'scope'
+    end
+
+    # match code expression
+    # matches characters until , as a heuristic to parse scopes like [:categories, cat.key]
+    # can be massively improved by matching parenthesis
+    def expr_re
+      /[\w():"'.\s]+/x
+    end
+
+    # match +el+ or array of +el+
+    def array_or_one_literal_re(el = literal_re)
+      /#{el} |
+       \[\s* (?:#{el}\s*,\s*)* #{el} \s*\]/x
+    end
+  end
+end

data/lib/i18n/tasks/translation_data.rb

@@ -13,17 +13,7 @@ module I18n::Tasks::TranslationData
 
   # whether the value for key exists in locale (defaults: base_locale)
   def key_value?(key, locale = base_locale)
-    t(data[locale], key).present?
-  end
-
-  # @return [Array<String>] all available locales
-  def locales
-    config[:locales] ||= I18n.available_locales.map(&:to_s)
-  end
-
-  # @return [String] default i18n locale
-  def base_locale
-    config[:base_locale] ||= I18n.default_locale.to_s
+    t(key, locale).present?
   end
 
   def non_base_locales(from = nil)
@@ -39,4 +29,35 @@ module I18n::Tasks::TranslationData
       data[target_locale] = data[target_locale]
     end
   end
+
+  # @param locales
+  # @param locale
+  # @param keys
+  # @param value
+  # @param values
+  def update_data(opts = {})
+    if opts.key?(:locales)
+      locales = (Array(opts[:locales]).presence || self.locales).map(&:to_s)
+      # make sure base_locale always comes first if present
+      locales = [base_locale] + (locales - [base_locale]) if locales.include?(base_locale)
+      opts    = opts.except(:locales)
+      locales.each { |locale| update_data(opts.merge(locale: locale)) }
+      return
+    end
+    locale = opts[:locale] || base_locale
+    keys   = opts[:keys]
+    keys   = keys.call(locale) if keys.respond_to?(:call)
+    return if keys.empty?
+    values = opts[:values]
+    values = values.call(keys, locale) if values.respond_to?(:call)
+    unless values
+      value  = opts[:value]
+      values = if value.respond_to?(:call)
+                 keys.map { |key| value.call(key, locale) }
+               else
+                 [value] * keys.size
+               end
+    end
+    data[locale] = data[locale].deep_merge(list_to_tree keys.map(&:to_s).zip(values))
+  end
 end

data/lib/i18n/tasks/unused_keys.rb

@@ -9,13 +9,14 @@ module I18n
         @unused_keys         ||= {}
         @unused_keys[locale] ||= ::I18n::Tasks::KeyGroup.new(
             traverse_map_if(data[locale]) { |key, value|
-              next if pattern_key?(key) || ignore_key?(key, :unused)
+              next if used_in_expr?(key) || ignore_key?(key, :unused)
               key = depluralize_key(locale, key)
               [key, value] unless used_key?(key)
             }.uniq, locale: locale, type: :unused)
       end
 
-      def remove_unused!(locales = self.locales)
+      def remove_unused!(locales = nil)
+        locales ||= self.locales
         unused = unused_keys
         locales.each do |locale|
           data[locale] = list_to_tree traverse_map_if(data[locale]) { |key, value|

data/lib/i18n/tasks/used_keys.rb

@@ -1,21 +1,25 @@
 require 'find'
-require 'i18n/tasks/scanners/pattern_scanner'
+require 'i18n/tasks/scanners/pattern_with_scope_scanner'
 
 module I18n::Tasks::UsedKeys
   # find all keys in the source (relative keys are absolutized)
   # @return [Array<String>]
   def used_keys(with_usages = false)
     if with_usages
-      I18n::Tasks::KeyGroup.new(scanner.keys_with_usages, type: :used, key_filter: scanner.key_filter)
+      used_keys_group scanner.keys_with_usages
     else
-      @used_keys ||= I18n::Tasks::KeyGroup.new(scanner.keys, type: :used, key_filter: scanner.key_filter)
+      @used_keys ||= used_keys_group scanner.keys
     end
   end
 
+  def used_keys_group(keys, opts = {})
+    ::I18n::Tasks::KeyGroup.new(keys, {type: :used, key_filter: scanner.key_filter}.merge(opts))
+  end
+
   def scanner
     @scanner ||= begin
       search_config = (config[:search] || {}).with_indifferent_access
-      class_name    = search_config[:scanner] || '::I18n::Tasks::Scanners::PatternScanner'
+      class_name    = search_config[:scanner] || '::I18n::Tasks::Scanners::PatternWithScopeScanner'
       class_name.constantize.new search_config.merge(relative_roots: relative_roots)
     end
   end
@@ -25,15 +29,14 @@ module I18n::Tasks::UsedKeys
     used_keys.include?(key)
   end
 
-  # dynamically generated keys in the source, e.g t("category.#{category_key}")
-  def pattern_key?(key)
-    @pattern_keys_re ||= compile_start_with_re(pattern_key_prefixes)
-    !!(key =~ @pattern_keys_re)
+  # @return 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)
   end
 
   # keys in the source that end with a ., e.g. t("category.#{cat.i18n_key}") or t("category." + category.key)
-  def pattern_key_prefixes
-    @pattern_keys_prefixes ||=
-        used_keys.key_names.select { |k| k =~ /\#{.*?}/ || k.ends_with?('.') }.map { |k| k.split(/\.?#/)[0].presence }.compact
+  def expr_key_re
+    @expr_key_re ||= compile_key_pattern "{#{used_keys.keys.select(&:expr?).map(&:key_match_pattern) * ','}}"
   end
 end

data/lib/i18n/tasks/version.rb

@@ -1,5 +1,5 @@
 module I18n
   module Tasks
-    VERSION = '0.2.22'
+    VERSION = '0.3.0.rc1'
   end
 end

data/lib/tasks/i18n-tasks.rake

@@ -1,130 +1,79 @@
-require 'set'
 require 'i18n/tasks'
-require 'i18n/tasks/reports/terminal'
-require 'active_support/core_ext/module/delegation'
-require 'i18n/tasks/reports/spreadsheet'
+require 'i18n/tasks/commands'
 
-namespace :i18n do
-  require 'highline/import'
+cmd = I18n::Tasks::Commands.new
 
+namespace :i18n do
   task :setup do
   end
 
-  desc 'show missing translations'
+  desc cmd.desc :missing
   task :missing, [:locales] => 'i18n:setup' do |t, args|
-    i18n_report.missing_keys i18n_task.missing_keys(locales: i18n_parse_locales(args[:locales]))
+    cmd.missing locales: args[:locales]
   end
 
   namespace :missing do
     desc 'keys present in code but not existing in base locale data'
-    task :missing_from_base => 'i18n:setup' do |t, args|
-      i18n_report.missing_keys i18n_task.keys_missing_from_base
+    task :missing_from_base => 'i18n:setup' do
+      cmd.missing type: :missing_from_base
     end
 
     desc 'keys present but with value same as in base locale'
     task :eq_base, [:locales] => 'i18n:setup' do |t, args|
-      i18n_report.missing_keys i18n_task.missing_keys(type: :eq_base, locales: i18n_parse_locales(args[:locales]))
+      cmd.missing type: :eq_base, locales: args[:locales]
     end
 
     desc 'keys that exist in base locale but are blank in passed locales'
     task :missing_from_locale, [:locales] => 'i18n:setup' do |t, args|
-      i18n_report.missing_keys i18n_task.missing_keys(type: :missing_from_locale, locales: i18n_parse_locales(args[:locales]))
+      cmd.missing type: :missing_from_locale, locales: args[:locales]
     end
   end
 
-  desc 'show unused translations'
+  desc cmd.desc :show_unused
   task :unused => 'i18n:setup' do
-    i18n_report.unused_keys
-  end
-
-  desc 'add placeholder for missing values to the base locale (default: key.humanize)'
-  task :add_missing, [:placeholder] => 'i18n:setup' do |t, args|
-    i18n_task.add_missing! base_locale, args[:placeholder]
+    cmd.unused
   end
 
-  desc 'remove unused keys'
+  desc cmd.desc :remove_unused
   task :remove_unused, [:locales] => 'i18n:setup' do |t, args|
-    locales     = i18n_parse_locales(args[:locales]) || i18n_task.locales
-    unused_keys = i18n_task.unused_keys
-    if unused_keys.present?
-      i18n_report.unused_keys(unused_keys)
-      unless ENV['CONFIRM']
-        exit 1 unless agree(red "All these translations will be removed in #{bold locales * ', '}#{red '.'} " + yellow('Continue? (yes/no)') + ' ')
-      end
-      i18n_task.remove_unused!(locales)
-    else
-      STDERR.puts bold green 'No unused keys to remove'
-    end
+    cmd.remove_unused
   end
-  
-  desc 'show usages of the keys in the codebase'
+
+  desc cmd.desc :usages
   task :usages, [:filter] => 'i18n:setup' do |t, args|
-    filter = args[:filter] ? args[:filter].tr('+', ',') : nil
-    i18n_report.used_keys(
-        i18n_task.scanner.with_key_filter(filter) {
-          i18n_task.used_keys(true)
-        }
-    )
+    cmd.find filter: args[:filter]
   end
 
-  desc 'normalize translation data: sort and move to the right files'
+  desc cmd.desc :normalize
   task :normalize, [:locales] => 'i18n:setup' do |t, args|
-    i18n_task.normalize_store! args[:locales]
+    cmd.normalize locales: args[:locales]
   end
 
-  desc 'save missing and unused translations to an Excel file'
-  task :spreadsheet_report, [:path] => 'i18n:setup' do |t, args|
-    begin
-      require 'axlsx'
-    rescue LoadError
-      message = %Q(To use i18n:spreadsheet_report please add axlsx gem to Gemfile:\ngem 'axlsx', '~> 2.0')
-      STDERR.puts Term::ANSIColor.red Term::ANSIColor.bold message
-      exit 1
-    end
-    args.with_defaults path: 'tmp/i18n-report.xlsx'
-    i18n_spreadsheet_report.save_report(args[:path])
-  end
-
-  desc 'fill translations with values'
-  namespace :fill do
-
-    desc 'add "" values for missing and untranslated keys to locales (default: all)'
-    task :blanks, [:locales] => 'i18n:setup' do |t, args|
-      i18n_task.fill_with_blanks! i18n_parse_locales args[:locales]
-    end
-
+  namespace :add_missing do
     desc 'add Google Translated values for untranslated keys to locales (default: all non-base)'
-    task :google_translate, [:locales] => 'i18n:setup' do |t, args|
-      i18n_task.fill_with_google_translate! i18n_parse_locales args[:locales]
+    task :translate, [:locales] => 'i18n:setup' do |t, args|
+      cmd.translate locales: args[:locales]
     end
 
     desc 'copy base locale values for all untranslated keys to locales (default: all non-base)'
-    task :base_value, [:locales] => 'i18n:setup' do |t, args|
-      i18n_task.fill_with_base_values! i18n_parse_locales args[:locales]
-    end
-  end
-
-  module ::I18n::Tasks::RakeHelpers
-    include Term::ANSIColor
-
-    delegate :base_locale, to: :i18n_task
-
-    def i18n_task
-      @i18n_task ||= I18n::Tasks::BaseTask.new
+    task :placeholder, [:locales, :placeholder] => 'i18n:setup' do |t, args|
+      cmd.add_missing locale: args[:locales], placeholder: args[:placeholder]
     end
 
-    def i18n_report
-      @i18n_report ||= I18n::Tasks::Reports::Terminal.new
+    desc 'add values for missing and untranslated keys to locales (default: all)'
+    task :empty_string, [:locales] => 'i18n:setup' do |t, args|
+      cmd.add_missing locales: args[:locales], placeholder: ''
     end
+  end
 
-    def i18n_spreadsheet_report
-      @i18n_spreadsheet_report ||= I18n::Tasks::Reports::Spreadsheet.new
-    end
+  desc cmd.desc(:config)
+  task :tasks_config => 'i18n:setup' do
+    cmd.config
+  end
 
-    def i18n_parse_locales(arg = nil)
-      arg.try(:strip).try(:split, /\s*\+\s*/).try(:compact).try(:presence)
-    end
+  desc cmd.desc :save_spreadsheet
+  task :spreadsheet_report, [:path] => 'i18n:setup' do |t, args|
+    cmd.xlsx_report path: args[:path]
   end
-  include ::I18n::Tasks::RakeHelpers
 end
 

data/spec/fixtures/app/controllers/events_controller.rb

@@ -1,9 +1,29 @@
 class EventsController < ApplicationController
   def show
     redirect_to :edit, notice: I18n.t('cb.a')
+
+    # args are ignored
     I18n.t("cb.b", i: "Hello")
-    I18n.t("hash_pattern.#{some_value}", i: "Hello")
-    I18n.t("hash_pattern2." + some_value, i: "Hello")
-    I18n.t "hash_pattern3", scope: "foo.bar"
+
+    # pattern not reported as unused
+    I18n.t("hash.pattern.#{some_value}", i: "Hello")
+
+    # pattern also not reported as unused
+    I18n.t("hash.pattern2." + some_value, i: "Hello")
+
+    # same as above but with scope argument
+    I18n.t(some_value, scope: [:hash, :pattern3])
+
+    # missing:
+    I18n.t 'pattern_missing.a', scope: :hash, other: 1
+
+    # missing:
+    I18n.t :b, scope: [:hash, :pattern_missing], other: 1
+
+    # missing, but not yet detected as such :(
+    I18n.t "#{stuff}.pattern_missing.c"
+
+    # not missing
+    I18n.t "hash.#{stuff}.a"
   end
 end