i18n-tasks 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f116de755ba0474543cb353a777bf20e7eeab5ac
-  data.tar.gz: 2850693394e00b2c1aad7421695aa4d42d4c4f45
+  metadata.gz: 9c0488a6ce907e9327da7ed07ffea723e8f8010f
+  data.tar.gz: 8f5042c6c785f81d5c75bc953fcd7d2cce496870
 SHA512:
-  metadata.gz: 85aa544fd0af018aade6cf796efbfbd20028a0f296b06f48e4f4c9941fa1c79862ecd5a31c9f8aa34d0abc9908d3dd6c1a56a696557e99a10d55866a4c3d4363
-  data.tar.gz: cc88b01eb13bbe1c00e3d3ef89f2ec239f4b673a124cb436dc612ced9c318bd977baa32bc8daf50ae62fcfe4b7161afa686bc4225484a4598f380e7f4fded9bf
+  metadata.gz: 9297eb48c4d50a91e4825b2a3867360f0296f780bfecb7fd9e6ae39b98501ca916557f3ab12501be96ab45eccfbad46628d315b297edf761887d6c9471a98579
+  data.tar.gz: 6eebe2d12de95e7e8563409007dd2df906768e7860047370d3e5cd9952b6382ac8abcb3096b14e404431c9477c5a54793e4a2068df956346d57536c4338008f2

data/.gitignore

@@ -32,3 +32,4 @@ test/version_tmp
 tmp
 .ruby-version
 .ruby-gemset
+*~

data/.travis.yml

@@ -3,10 +3,12 @@ rvm:
   - 2.0.0
   - 1.9.3
   - jruby
+  - jruby-head
   - rbx-19mode
 
 matrix:
   allow_failures:
     - rvm: jruby
+    - rvm: jruby-head
     - rvm: rbx-19mode
 

data/CHANGES.md

@@ -0,0 +1,4 @@
+## v0.1.2
+
+* added grep config options (thanks @dmke)
+* improved terminal output

data/README.md

@@ -1,17 +1,17 @@
-i18n-tasks  [![Build Status](https://travis-ci.org/glebm/i18n-tasks.png?branch=master)](https://travis-ci.org/glebm/i18n-tasks)
-==========
+# i18n-tasks [![Build Status](https://travis-ci.org/glebm/i18n-tasks.png?branch=master)](https://travis-ci.org/glebm/i18n-tasks) [![Code Climate](https://codeclimate.com/github/glebm/i18n-tasks.png)](https://codeclimate.com/github/glebm/i18n-tasks)
+
 
 Rails I18n tasks to find missing / unused translations and more. Works with slim / coffee / haml etc.
 
-![i18n-missing-screenshot]
+![i18n-missing-screenshot](https://raw.github.com/glebm/i18n-tasks/master/doc/img/i18n-tasks.png "rake i18n:missing output screenshot")
 
 Use `rake -T i18n` to get the list of tasks with descriptions. There are 3 tasks available at the moment:
 
-* `i18n:missing` task shows all the keys that have not been translated yet *([source](https://github.com/glebm/i18n-tasks/blob/master/lib/i18n/tasks/missing.rb))*
-* `i18n:prefill` task normalizes locale files, and adds missing keys from base locale to others *([source](https://github.com/glebm/i18n-tasks/blob/master/lib/i18n/tasks/prefill.rb))*
-* `i18n:unused` task shows potentially unused translations *([source](https://github.com/glebm/i18n-tasks/blob/master/lib/i18n/tasks/unused.rb))*
+* `i18n:missing` task shows all the keys that have not been translated yet *([source](./blob/master/lib/i18n/tasks/missing.rb))*
+* `i18n:prefill` task normalizes locale files, and adds missing keys from base locale to others *([source](./blob/master/lib/i18n/tasks/prefill.rb))*
+* `i18n:unused` task shows potentially unused translations *([source](./blob/master/lib/i18n/tasks/unused.rb))*
 
-`i18n:unused` will detect pattern translations and not report them, e.g.:
+The `i18n:unused` task will detect pattern translations and not report them, e.g.:
 
 ```ruby
 t 'category.' + category.key # 'category.arts_and_crafts' considered used
@@ -20,10 +20,10 @@ t "category.#{category.key}" # also works
 
 Relative keys (`t '.title'`) are supported too.
 
-For more examples see [the tests](https://github.com/glebm/i18n-tasks/blob/master/spec/i18n_tasks_spec.rb#L43-L59).
+For more examples see [the tests](./blob/master/spec/i18n_tasks_spec.rb#L43-L59).
+
 
-Installation
-------------
+## Installation
 
 Simply add to Gemfile:
 
@@ -33,9 +33,8 @@ gem 'i18n-tasks', '~> 0.1.0'
 
 `grep` is required. You likely have it already on Linux / Mac / BSD, Windows users will need to [install](http://gnuwin32.sourceforge.net/packages/grep.htm) and make sure it's available in `PATH`.
 
-Configuration
--------------
 
+## Configuration
 
 Tasks may incorrectly report framework i18n keys as missing. You can add `config/i18n-tasks.yml` to work around this:
 
@@ -59,6 +58,19 @@ ignore_unused:
 # do not report these keys ever
 ignore:
   - kaminari.
+
+# grep configuration
+grep:
+  # search these directories (relative to your Rails.root directory, default: 'app/')
+  paths:
+    - 'app/'
+    - 'vendor/'
+  # include only files matching this glob pattern (default: blank = include all files)
+  include:
+    - '*.rb'
+    - '*.html*'
+  # explicitly exclude files (default: blank = exclude no files)
+  exclude: '*.js'
 ```
 
 
@@ -75,8 +87,11 @@ I18n::Tasks.get_locale_data = ->(locale) {
 }
 ```
 
+## i18n-tasks HTML report
+
+While i18n-tasks does not provide an HTML version of the report, it's easy to roll your own, see [the example](https://gist.github.com/glebm/6887030).
+
 ---
 
 This was originally developed for [Zuigo](http://zuigo.com/), a platform to organize and discover events.
 
-  [i18n-missing-screenshot]: https://raw.github.com/glebm/i18n-tasks/master/doc/img/i18n-missing.png "rake i18n:missing output screenshot"

data/i18n-tasks.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'yard'
 end

data/lib/i18n/tasks/base_task.rb

@@ -5,78 +5,125 @@ require 'i18n/tasks/task_helpers'
 module I18n
   module Tasks
     class BaseTask
-      include Term::ANSIColor
       include TaskHelpers
 
       # locale data hash, with locale name as root
+      # @return [Hash{String => String,Hash}] locale data in nested hash format
       def get_locale_data(locale)
         (@locale_data ||= {})[locale] ||= I18n::Tasks.get_locale_data.call(locale)
       end
 
       # main locale file path (for writing to)
+      # @return [String]
       def locale_file_path(locale)
         "config/locales/#{locale}.yml"
       end
 
       # find all keys in the source (relative keys are returned in absolutized)
+      # @return [Array<String>]
       def find_source_keys
         @source_keys ||= begin
-          grep_out  = run_command 'grep', '-HorI', %q{\\bt(\\?\\s*['"]\\([^'"]*\\)['"]}, 'app/'
-          if grep_out
-            used_keys = grep_out.split("\n").map { |r|
+          if (grep_out = run_grep)
+            grep_out.split("\n").map { |r|
               key = r.match(/['"](.*?)['"]/)[1]
-              # absolutize relative key:
               if key.start_with? '.'
-                path = r.split(':')[0]
-                # normalized path
-                path = Pathname.new(File.expand_path path).relative_path_from(Pathname.new(Dir.pwd)).to_s
-                # key prefix based on path
-                prefix = path.gsub(%r(app/views/|(\.[^/]+)*$), '').tr('/', '.')
-                "#{prefix}#{key}"
+                absolutize_key key, r.split(':')[0]
               else
                 key
               end
-            }.uniq
-            used_keys.reject { |k| k !~ /^[\w.\#{}]+$/ }
+            }.uniq.reject { |k| k !~ /^[\w.\#{}]+$/ }
           else
             []
           end
         end
       end
 
+      # whether the key is used in the source
+      def used_key?(key)
+        @used_keys ||= find_source_keys.to_set
+        @used_keys.include?(key)
+      end
+
+      # whether to ignore the key. ignore_type one of :missing, :eq_base, :blank, :unused.
+      # will apply global ignore rules as well
+      def ignore_key?(key, ignore_type, locale = nil)
+        key =~ ignore_pattern(ignore_type, locale)
+      end
 
-      def find_source_pattern_keys
-        @source_pattern_keys ||= find_source_keys.select { |k| k =~ /\#{.*?}/ || k.ends_with?('.') }
+      # 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
       end
 
-      def find_source_pattern_prefixes
-        @source_pattern_prefixes ||= find_source_pattern_keys.map { |k| k.split(/\.?#/)[0] }
+      # 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 ||=
+            find_source_keys.select { |k| k =~ /\#{.*?}/ || k.ends_with?('.') }.map { |k| k.split(/\.?#/)[0].presence }.compact
+      end
+
+      # whether the value for key exists in locale (defaults: base_locale)
+      def key_has_value?(key, locale = base_locale)
+        t(get_locale_data(locale)[locale], key).present?
       end
 
       # traverse hash, yielding with full key and value
+      # @param hash [Hash{String => String,Hash}] translation data to traverse
+      # @yield [full_key, value] yields full key and value for every translation in #hash
+      # @return [nil]
       def traverse(path = '', hash)
         q = [ [path, hash] ]
         until q.empty?
           path, value = q.pop
           if value.is_a?(Hash)
-            value.each { |k, v| q << ["#{path}.#{k}", v] }
+            value.each { |k,v| q << ["#{path}.#{k}", v] }
           else
             yield path[1..-1], value
           end
         end
       end
 
+      # translation of the key found in the passed hash or nil
+      # @return [String,nil]
       def t(hash, key)
-        key.split('.').inject(hash) { |r, seg| r[seg] if r }
+        key.split('.').inject(hash) { |r,seg| r[seg] if r }
+      end
+
+      # @param key [String] relative i18n key (starts with a .)
+      # @param path [String] path to the file containing the key
+      # @return [String] absolute version of the key
+      def absolutize_key(key, path)
+        # normalized path
+        path = Pathname.new(File.expand_path path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+        # key prefix based on path
+        prefix = path.gsub(%r(app/views/|(\.[^/]+)*$), '').tr('/', '.')
+        "#{prefix}#{key}"
       end
 
+
+      # @return [String] default i18n locale
       def base_locale
         I18n.default_locale.to_s
       end
 
-      def base
-        @base ||= get_locale_data(base_locale)
+      # @return [Hash{String => String,Hash}] default i18n locale data
+      def base_locale_data
+        get_locale_data(base_locale)[base_locale]
+      end
+
+      # Run grep searching for source keys and return grep output
+      # @return [String] output of the grep command
+      def run_grep
+        args = ['grep', '-HoRI']
+        [:include, :exclude].each do |opt|
+          next unless (val = grep_config[opt]).present?
+          args += Array(val).map { |v| "--#{opt}=#{v}" }
+        end
+        args += [ %q{\\bt(\\?\\s*['"]\\([^'"]*\\)['"]}, *grep_config[:paths]]
+        args.compact!
+        run_command *args
       end
+
     end
   end
 end

data/lib/i18n/tasks/missing.rb

@@ -4,73 +4,51 @@ require 'i18n/tasks/base_task'
 module I18n
   module Tasks
     class Missing < BaseTask
-      DESC = 'Missing keys and translations'
 
-      def perform
-        missing = find_missing
-        STDERR.puts bold cyan("= #{DESC} (#{missing.length}) =")
-        STDERR.puts cyan(" This task may report framework i18n keys as missing (use .i18nignore if that happens)")
-        STDERR.puts cyan " Legend:\t#{red '✗'} - key is missing\t#{yellow bold '∅'} - translation is blank\t#{yellow bold '='} - value same as base locale"
-        status_texts = {
-            none: red("✗".ljust(6)),
-            blank: yellow(bold '∅'.ljust(6)),
-            eq_base: yellow(bold "=".ljust(6))
-        }
-
-        missing.sort { |a, b| (l = a[:locale] <=> b[:locale]).zero? ? a[:type] <=> b[:type] : l }.each do |m|
-          locale, key, base_value = m[:locale], m[:key], m[:base_value]
-          status_text = ' ' + status_texts[m[:type]]
-          case m[:type]
-            when :none
-              puts "#{red p_locale base_locale} #{status_text} #{p_key key}"
-            when :blank
-              puts "#{p_locale locale} #{status_text} #{p_key key} #{cyan base_value}"
-            when :eq_base
-              puts "#{p_locale locale} #{status_text} #{p_key key} #{cyan base_value}"
-          end
-        end
+      # Get all the missing translations as an array of missing keys as hashes with the following options:
+      # :locale
+      # :key
+      # :type — :blank, :missing, or :eq_base
+      # :base_value — translation value in base locale if one is present
+      # @return [Array<Hash{Symbol => String,Symbol,nil}>]
+      def find_keys
+        other_locales = I18n.available_locales.map(&:to_s) - [base_locale]
+        sort_keys keys_missing_base_value + other_locales.map { |locale| keys_missing_translation(locale) }.flatten(1)
       end
 
+      private
 
+      # missing keys, i.e. key that are in the code but are not in the base locale data
+      # @return Array{Hash}
+      def keys_missing_base_value
+        find_source_keys.reject { |key|
+          key_has_value?(key, base_locale) || pattern_key?(key) || ignore_key?(key, :missing)
+        }.map { |key| {locale: base_locale, type: :none, key: key} }
+      end
 
-      # get all the missing translations as list of missing keys as hashes with:
-      #  {:locale, :key, :type, and optionally :base_value}
-      #  :type — :blank, :missing, or :eq_base
-      #  :base_value — translation value in base locale if one is present
-      def find_missing
-        # dynamically generated keys in the source, e.g t("category.#{category_key}")
-        pattern_re = compile_start_with_re find_source_pattern_prefixes
-
-        # missing keys (in the code but not in base locale data)
-        keys = find_source_keys
-        missing = keys.select { |key| t(base[base_locale], key).blank? && key !~ pattern_re && key !~ ignore_pattern(:missing) }.map do |key|
-          {locale: base_locale, type: :none, key: key}
-        end
-
-        # missing translations (present in base locale, but untranslated in another locale )
-        (I18n.available_locales.map(&:to_s) - [base_locale]).each do |locale|
-          trn = get_locale_data(locale)[locale]
-          traverse base[base_locale] do |key, base_value|
-            translated = t(trn, key)
-            if translated.blank? && key !~ ignore_pattern(:missing)
-              missing << {locale: locale, key: key, type: :blank, base_value: base_value}
-            elsif translated == base_value && key !~ ignore_pattern(:eq_base, locale)
-              missing << {locale: locale, key: key, type: :eq_base, base_value: base_value}
-            end
+      # present in base locale, but untranslated in another locale
+      # @return Array{Hash}
+      def keys_missing_translation(locale)
+        trn = get_locale_data(locale)[locale]
+        r   = []
+        traverse base_locale_data do |key, base_value|
+          value_in_locale = t(trn, key)
+          if value_in_locale.blank? && !ignore_key?(key, :missing)
+            r << {locale: locale, key: key, type: :blank, base_value: base_value}
+          elsif value_in_locale == base_value && !ignore_key?(key, :eq_base, locale)
+            r << {locale: locale, key: key, type: :eq_base, base_value: base_value}
           end
         end
-
-        missing
-      end
-
-      def p_locale(locale)
-        ' ' + bold(locale.ljust(5))
+        r
       end
 
-      def p_key(key)
-        magenta(key).ljust(50)
+      # sort first by locale, then by type
+      # @return Array{Hash}
+      def sort_keys(keys)
+        keys.sort { |a, b|
+          (l = a[:locale] <=> b[:locale]).zero? ? a[:type] <=> b[:type] : l
+        }
       end
-
     end
   end
 end

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

@@ -0,0 +1,44 @@
+# coding: utf-8
+module I18n
+  module Tasks
+    module Output
+      class Terminal
+        include Term::ANSIColor
+
+        def missing(missing)
+          $stderr.puts bold cyan "Missing keys and translations (#{missing.length})"
+          $stderr.puts "#{bold 'Legend:'} #{red '✗'} key missing, #{yellow bold '∅'} translation blank, #{blue bold '='} value equal to base locale; #{cyan 'value in base locale'}"
+          key_col_width = missing.map { |x| x[:key] }.max_by(&:length).length + 2
+          missing.each { |m| print_missing_translation m, key_col_width: key_col_width }
+        end
+
+        def unused(unused)
+          $stderr.puts bold cyan("Unused i18n keys (#{unused.length})")
+          key_col_width = unused.max_by { |x| x[0].length }[0].length + 2
+          unused.each { |(key, value)| puts "#{magenta key.ljust(key_col_width)}#{cyan value.strip}" }
+        end
+
+        private
+
+        extend Term::ANSIColor
+        STATUS_TEXTS = {
+            none:    red("✗".ljust(6)),
+            blank:   yellow(bold '∅'.ljust(6)),
+            eq_base: blue(bold "=".ljust(6))
+        }
+
+        def print_missing_translation(m, opts)
+          locale, key, base_value, status_text = m[:locale], m[:key], m[:base_value].try(:strip), " #{STATUS_TEXTS[m[:type]]}"
+
+          key = magenta key.ljust(opts[:key_col_width])
+          s   = if m[:type] == :none
+                  "#{red bold locale.ljust(4)} #{status_text} #{key}"
+                else
+                  "#{bold locale.ljust(4)} #{status_text} #{key} #{cyan base_value}"
+                end
+          puts s
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/prefill.rb

@@ -7,7 +7,7 @@ module I18n
         # Will also rewrite en, good for ordering
         I18n.available_locales.map(&:to_s).each do |target_locale|
           trn = get_locale_data(target_locale)
-          prefilled = { target_locale => base[base_locale] }.deep_merge(trn)
+          prefilled = { target_locale => base_locale_data }.deep_merge(trn)
           File.open(locale_file_path(target_locale), 'w'){ |f| f.write prefilled.to_yaml }
         end
       end

data/lib/i18n/tasks/task_helpers.rb

@@ -1,15 +1,20 @@
 # coding: utf-8
 require 'open3'
+
 module I18n
   module Tasks
     module TaskHelpers
       # Run command and get only stdout output
+      # @return [String] output
+      # @raise [RuntimeError] if grep returns with exit code other than 0
       def run_command(*args)
-        _in, out, _err = Open3.popen3(*args)
-        out.gets nil
+        o, e, s = Open3.capture3(*args)
+        raise "#{args[0]} failed with status #{s.exitstatus} (stderr: #{e})" unless s.success?
+        o
       end
 
       # compile prefix matching Regexp from the list of prefixes
+      # @return [Regexp] regexp matching any of the prefixes
       def compile_start_with_re(prefixes)
         if prefixes.blank?
           /\Z\A/ # match nothing
@@ -18,30 +23,42 @@ module I18n
         end
       end
 
-      # exclude @keys with prefixes matching @patterns
+      # @return [Array<String>] keys sans passed patterns
       def exclude_patterns(keys, patterns)
         pattern_re = compile_start_with_re patterns.select { |p| p.end_with?('.') }
         (keys - patterns).reject { |k| k =~ pattern_re }
       end
 
-      # type: missing, eq_base, unused
+      # @param type [:missing, :eq_base, :unused] type
+      # @param locale [String] only when type is :eq_base
+      # @return [Regexp] a regexp that matches all the keys ignored for the type (and locale)
       def ignore_pattern(type, locale = nil)
         ((@ignore_patterns ||= HashWithIndifferentAccess.new)[type] ||= {})[locale] = begin
-          global      = config[:ignore] || []
-          type_ignore = config["ignore_#{type}"] || []
+          global, type_ignore = config[:ignore].presence || [], config["ignore_#{type}"].presence || []
           if type_ignore.is_a?(Array)
-            compile_start_with_re global + type_ignore
+            patterns = global + type_ignore
           elsif type_ignore.is_a?(Hash)
-            p = global + (type_ignore[:all] || [])
-            type_ignore.each { |key, value| p += (value || []) if key.to_s =~ /\b#{locale}\b/ } if locale
-            compile_start_with_re p
+            # ignore per locale
+            patterns = global + (type_ignore[:all] || []) +
+                type_ignore.select { |k, v| k.to_s =~ /\b#{locale}\b/ }.values.flatten(1).compact
           end
+          compile_start_with_re patterns
         end
       end
 
+      # i18n-tasks config (defaults + config/i18n-tasks.yml)
+      # @return [Hash{String => String,Hash,Array}]
       def config
         I18n::Tasks.config
       end
+
+      # grep config, also from config/i18n-tasks.yml
+      # @return [Hash{String => String,Hash,Array}]
+      def grep_config
+        @grep_config ||= (config[:grep] || {}).with_indifferent_access.tap do |conf|
+          conf[:paths] = ['app/'] if conf[:paths].blank?
+        end
+      end
     end
   end
 end

data/lib/i18n/tasks/unused.rb

@@ -4,24 +4,11 @@ require 'i18n/tasks/base_task'
 module I18n
   module Tasks
     class Unused < BaseTask
-      DESC = 'Unused i18n keys'
-      def perform
-        unused = find_unused
-        STDERR.puts bold cyan("= #{DESC} (#{unused.length}) =")
-        unused.each do |(key, value)|
-          puts " #{magenta(key).ljust(60)}\t#{cyan value}"
-        end
-      end
-
-      def find_unused
-        used_keys = find_source_keys.to_set
+      # @return [Array<[String, String]>] all the unused translations as an array of [key, value] pairs
+      def find_keys
         r = []
-        ignore_re = ignore_pattern(:unused)
-        pattern_re = compile_start_with_re find_source_pattern_prefixes
-        traverse base[base_locale] do |key, value|
-          unless used_keys.include?(key) || key =~ pattern_re || key =~ ignore_re
-            r << [key, value]
-          end
+        traverse base_locale_data do |key, value|
+          r << [key, value] unless used_key?(key) || pattern_key?(key) || ignore_key?(key, :unused)
         end
         r
       end

data/lib/i18n/tasks/version.rb

@@ -1,5 +1,5 @@
 module I18n
   module Tasks
-    VERSION = '0.1.1'
+    VERSION = '0.1.2'
   end
 end

data/lib/tasks/i18n-tasks.rake

@@ -4,6 +4,7 @@ require 'active_support/core_ext'
 require 'i18n/tasks/missing'
 require 'i18n/tasks/prefill'
 require 'i18n/tasks/unused'
+require 'i18n/tasks/output/terminal'
 
 namespace :i18n do
   desc 'add keys from base locale to others'
@@ -14,14 +15,14 @@ namespace :i18n do
   desc 'show keys with translation values identical to base'
   task :missing => :environment do
     if File.exists?('.i18nignore')
-      STDERR.puts "!!!! Looks like you are using .i18ignore. It is no longer used in favour of config/i18n-tasks.yml.\n
-            See README.md https://github.com/glebm/i18n-tasks"
+      STDERR.puts 'Looks like you are using .i18ignore. It is no longer used in favour of config/i18n-tasks.yml.'
+      STDERR.puts 'See README.md https://github.com/glebm/i18n-tasks'
     end
-    I18n::Tasks::Missing.new.perform
+    I18n::Tasks::Output::Terminal.new.missing I18n::Tasks::Missing.new.find_keys
   end
 
   desc 'find potentially unused translations'
   task :unused => :environment do
-    I18n::Tasks::Unused.new.perform
+    I18n::Tasks::Output::Terminal.new.unused I18n::Tasks::Unused.new.find_keys
   end
 end

data/spec/fixtures/app/assets/javascripts/application.js

@@ -0,0 +1,3 @@
+//= require t
+
+window.t = new Matrix.t(this)

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

@@ -0,0 +1,9 @@
+class EventsController < ApplicationController
+  def show
+    redirect_to :edit, notice: I18n.t('cb.a')
+    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"
+  end
+end

data/spec/fixtures/app/views/index.html.slim

@@ -0,0 +1,9 @@
+p #{t('ca.a')} #{t 'ca.b'} #{t "ca.c"}
+p #{t 'ca.d'} #{t 'ca.f', i: 'world'} #{t 'ca.e', i: 'world'}
+p #{t 'missing_in_es.a'} #{t 'same_in_es.a'} #{t 'blank_in_es.a'}
+p = t 'used_but_missing.a'
+p = t 'ignored_missing_key.a'
+p = t 'ignore.a'
+p = t 'ignored_pattern.some_key'
+p = t 'ignore_eq_base_all.a'
+p = t 'ignore_eq_base_es.a'

data/spec/fixtures/app/views/relative/index.html.slim

@@ -0,0 +1 @@
+p = t '.title'

data/spec/fixtures/config/i18n-tasks.yml

@@ -0,0 +1,33 @@
+# do not report these keys as missing:
+ignore_missing:
+  - ignored_missing_key.a # one key to ignore
+  - ignored_pattern.      # ignore the whole pattern
+
+# do not report these keys when they have the same value as the base locale version
+ignore_eq_base:
+  all:
+    - ignore_eq_base_all.a
+  es:
+    - ignore_eq_base_es.a
+
+# do not report these keys as unused
+ignore_unused:
+  - ignore_unused.a
+
+# do not report these keys ever
+ignore:
+  - ignore.a
+
+# grep configuration
+grep:
+  # search these directories (relative to your Rails.root directory, default: 'app/')
+  paths:
+    - 'app/'
+    - 'vendor/'
+  # include only files matching this glob pattern (default: blank = include all files)
+  include:
+    - '*.rb'
+    - '*.html.*'
+    - '*.file'
+  # explicitly exclude files (default: blank = exclude no files)
+  exclude: '*.js'

data/spec/i18n_tasks_spec.rb

@@ -4,13 +4,17 @@ require 'spec_helper'
 describe 'rake i18n' do
   describe 'missing' do
     it 'detects missing or identical' do
-      TestCodebase.rake_result('i18n:missing').should be_i18n_keys %w(en.used_but_missing.a es.missing_in_es.a es.blank_in_es.a es.same_in_es.a)
+      TestCodebase.capture_stderr do
+        TestCodebase.rake_result('i18n:missing').should be_i18n_keys %w(en.used_but_missing.a es.missing_in_es.a es.blank_in_es.a es.same_in_es.a)
+      end.should =~ /Missing keys and translations \(4\)/
     end
   end
 
   describe 'unused' do
     it 'detects unused' do
-      TestCodebase.rake_result('i18n:unused').should be_i18n_keys %w(unused.a)
+      TestCodebase.capture_stderr do
+        TestCodebase.rake_result('i18n:unused').should be_i18n_keys %w(unused.a)
+      end.should =~ /Unused i18n keys \(1\)/
     end
   end
 
@@ -23,86 +27,46 @@ describe 'rake i18n' do
   end
 
   # --- setup ---
-  BENCH_KEYS = 3000
+  BENCH_KEYS = 30
   before do
     gen_data = ->(v) {
       {
-          'ca'            => {'a' => v, 'b' => v, 'c' => v, 'd' => v, 'e' => "#{v}%{i}", 'f' => "#{v}%{i}"},
-          'cb'            => {'a' => v, 'b' => "#{v}%{i}"},
-          'hash_pattern'  => {'a' => v},
-          'hash_pattern2' => {'a' => v},
-          'unused'        => {'a' => v},
-          'ignore_unused' => {'a' => v},
-          'missing_in_es' => {'a' => v},
-          'same_in_es'    => {'a' => v},
-          'ignore_eq_base_all' => {'a' => v},
-          'ignore_eq_base_es' => {'a' => v},
-          'blank_in_es'   => {'a' => v},
-          'relative'      => {'index' => {'title' => v}}
-
-      }.tap {|r|
+        'ca'                  => {'a' => v, 'b' => v, 'c' => v, 'd' => v, 'e' => "#{v}%{i}", 'f' => "#{v}%{i}"},
+        'cb'                  => {'a' => v, 'b' => "#{v}%{i}"},
+        'hash_pattern'        => {'a' => v},
+        'hash_pattern2'       => {'a' => v},
+        'unused'              => {'a' => v},
+        'ignore_unused'       => {'a' => v},
+        'missing_in_es'       => {'a' => v},
+        'same_in_es'          => {'a' => v},
+        'ignore_eq_base_all'  => {'a' => v},
+        'ignore_eq_base_es'   => {'a' => v},
+        'blank_in_es'         => {'a' => v},
+        'relative'            => {'index' => {'title' => v}}
+      }.tap { |r|
         gen = r["bench"] = {}
-        BENCH_KEYS.times.map { |i| gen["key#{i}"] = v }
+        BENCH_KEYS.times { |i| gen["key#{i}"] = v }
       }
     }
 
-    en_data                     = gen_data.('EN_TEXT')
-    es_data                     = gen_data.('ES_TEXT').except('missing_in_es')
+    en_data = gen_data.('EN_TEXT')
+    es_data = gen_data.('ES_TEXT').except('missing_in_es')
     es_data['same_in_es']['a']  = 'EN_TEXT'
     es_data['blank_in_es']['a'] = ''
     es_data['ignore_eq_base_all']['a'] = 'EN_TEXT'
     es_data['ignore_eq_base_es']['a']  = 'EN_TEXT'
 
     fs = {
-        'config/locales/en.yml' => {'en' => en_data}.to_yaml,
-        'config/locales/es.yml' => {'es' => es_data}.to_yaml,
-        'config/i18n-tasks.yml' => <<-YML,
-# do not report these keys as missing:
-ignore_missing:
-  - ignored_missing_key.a # one key to ignore
-  - ignored_pattern.      # ignore the whole pattern
-
-# do not report these keys when they have the same value as the base locale version
-ignore_eq_base:
-  all:
-    - ignore_eq_base_all.a
-  es:
-    - ignore_eq_base_es.a
-
-# do not report these keys as unused
-ignore_unused:
-  - ignore_unused.a
+      'config/locales/en.yml'                 => {'en' => en_data}.to_yaml,
+      'config/locales/es.yml'                 => {'es' => es_data}.to_yaml,
+      'config/i18n-tasks.yml'                 => load_fixture('config/i18n-tasks.yml'),
+      'app/views/index.html.slim'             => load_fixture('app/views/index.html.slim'),
+      'app/views/relative/index.html.slim'    => load_fixture('app/views/relative/index.html.slim'),
+      'app/controllers/events_controller.rb'  => load_fixture('app/controllers/events_controller.rb'),
+      'app/assets/javascripts/application.js' => load_fixture('app/assets/javascripts/application.js'),
 
-# do not report these keys ever
-ignore:
-  - ignore.a
-YML
-        'app/views/index.html.slim' => <<-SLIM,
-        p \#{t('ca.a')} \#{t 'ca.b'} \#{t "ca.c"}
-                p \#{t 'ca.d'} \#{t 'ca.f', i: 'world'} \#{t 'ca.e', i: 'world'}
-                p \#{t 'missing_in_es.a'} \#{t 'same_in_es.a'} \#{t 'blank_in_es.a'}
-                p = t 'used_but_missing.a'
-                p = t 'ignored_missing_key.a'
-                p = t 'ignore.a'
-                p = t 'ignored_pattern.some_key'
-                p = t 'ignore_eq_base_all.a'
-                p = t 'ignore_eq_base_es.a'
-        SLIM
-        'app/views/relative/index.html.slim' => <<-SLIM,
-                p = t '.title'
-        SLIM
-        'app/controllers/events_controller.slim' => <<-RUBY,
-        class EventsController < ApplicationController
-                   def show
-                      redirect_to :edit, notice: I18n.t('cb.a')
-                      I18n.t("cb.b", i: "Hello")
-                      I18n.t("hash_pattern.\#{some_value}", i: "Hello")
-                      I18n.t("hash_pattern2." + some_value, i: "Hello")
-                   end
-                end
-        RUBY
-        # test that our algorithms can scale to the order of {BENCH_KEYS} keys.
-        'app/heavy.file' => BENCH_KEYS.times.map { |i| "t('bench.key#{i}') " }.join
+      # test that our algorithms can scale to the order of {BENCH_KEYS} keys.
+      'vendor/heavy.file' => BENCH_KEYS.times.map { |i| "t('bench.key#{i}') " }.join
     }
     TestCodebase.setup fs
   end

data/spec/spec_helper.rb

@@ -1,14 +1,18 @@
 ENV['RAKE_ENV'] ||= 'test'
 require 'rspec/autorun'
 $: << File.expand_path('../lib', __FILE__)
+
 require 'i18n/tasks'
 require 'rake'
+
 Rake.load_rakefile 'tasks/i18n-tasks.rake'
 Rake.load_rakefile 'support/test_codebase_env.rake'
+
 require 'term/ansicolor'
 Term::ANSIColor::coloring = false
+
 Dir['spec/support/**/*.rb'].each { |f| require "./#{f}" }
 
 RSpec.configure do |config|
-end
-
+  config.include FixturesSupport
+end

data/spec/support/fixtures.rb

@@ -0,0 +1,7 @@
+# quick'n'dirty fixture loader
+module FixturesSupport
+  def load_fixture(path)
+    Pathname.new('spec/fixtures').join(path).expand_path.read
+  end
+end
+

data/spec/support/i18n_tasks_output_matcher.rb

@@ -1,25 +1,35 @@
 # coding: utf-8
 RSpec::Matchers.define :be_i18n_keys do |expected|
-  locale_re = /^\w{2}\b/
-  extract_keys = ->(actual){
+  def locale_re
+    /^\w{2}\b/
+  end
+  
+  def extract_keys(actual)
     locales = I18n.available_locales.map(&:to_s)
     actual.split("\n").map { |x|
       x.strip!
       key = x.gsub(/\s+/, ' ').split(' ').reverse.detect { |p| p && p.include?('.') }
-      if x =~ locale_re && locales.include?(x[0..1]) && !(key =~ locale_re && locales.include(key[0..1]))
+      if x =~ locale_re && locales.include?(x[0..1]) && !(key =~ locale_re && locales.include?(key[0..1]))
         x.split(' ', 2)[0] + '.' + key
       else
         key
       end
     }
-  }
+  end
 
   match do |actual|
-    extract_keys.(actual).sort == expected.sort
+    extract_keys(actual).should =~ expected
   end
 
   failure_message_for_should do |actual|
-    "Expected #{expected.sort}, but had #{extract_keys.(actual).sort}"
+    e = expected.sort
+    a = extract_keys(actual).sort
+
+    <<-MSG.strip
+Expected #{e}, but had #{a}. Diff:
 
+missing: #{e-a}
+extra:   #{a-e}
+    MSG
   end
 end

data/spec/support/test_codebase.rb

@@ -1,11 +1,12 @@
 require 'fileutils'
+
 module TestCodebase
   extend self
   AT = 'tmp/test_codebase'
 
   DEFAULTS = {
-      'config/locales/en.yml' => {'en' => {}}.to_yaml,
-      'config/locales/es.yml' => {'es' => {}}.to_yaml
+    'config/locales/en.yml' => {'en' => {}}.to_yaml,
+    'config/locales/es.yml' => {'es' => {}}.to_yaml
   }
 
   def setup(files)
@@ -38,13 +39,19 @@ module TestCodebase
     Dir.chdir pwd
   end
 
-  private
+  def capture_stderr
+    err, $stderr = $stderr, StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = err
+  end
+
   def capture_stdout
-    out = StringIO.new
-    $stdout = out
+    out, $stdout = $stdout, StringIO.new
     yield
-    out.string
+    $stdout.string
   ensure
-    $stdout = STDOUT
+    $stdout = out
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-tasks
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - glebm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-28 00:00:00.000000000 Z
+date: 2013-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,6 +94,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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'
 description: Rails I18n tasks to find missing / unused translations and more
 email:
 - glex.spb@gmail.com
@@ -103,24 +117,32 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - doc/img/i18n-missing.png
+- doc/img/i18n-tasks.png
 - i18n-tasks.gemspec
 - lib/i18n/tasks.rb
 - lib/i18n/tasks/base_task.rb
 - lib/i18n/tasks/missing.rb
+- lib/i18n/tasks/output/terminal.rb
 - lib/i18n/tasks/prefill.rb
 - lib/i18n/tasks/railtie.rb
 - lib/i18n/tasks/task_helpers.rb
 - lib/i18n/tasks/unused.rb
 - lib/i18n/tasks/version.rb
 - lib/tasks/i18n-tasks.rake
+- spec/fixtures/app/assets/javascripts/application.js
+- spec/fixtures/app/controllers/events_controller.rb
+- spec/fixtures/app/views/index.html.slim
+- spec/fixtures/app/views/relative/index.html.slim
+- spec/fixtures/config/i18n-tasks.yml
 - spec/i18n_tasks_spec.rb
 - spec/spec_helper.rb
-- spec/support/0_test_codebase_env.rake
+- spec/support/fixtures.rb
 - spec/support/i18n_tasks_output_matcher.rb
 - spec/support/test_codebase.rb
 - spec/support/test_codebase_env.rake
@@ -149,9 +171,15 @@ signing_key:
 specification_version: 4
 summary: Rails I18n tasks to find missing / unused translations and more
 test_files:
+- spec/fixtures/app/assets/javascripts/application.js
+- spec/fixtures/app/controllers/events_controller.rb
+- spec/fixtures/app/views/index.html.slim
+- spec/fixtures/app/views/relative/index.html.slim
+- spec/fixtures/config/i18n-tasks.yml
 - spec/i18n_tasks_spec.rb
 - spec/spec_helper.rb
-- spec/support/0_test_codebase_env.rake
+- spec/support/fixtures.rb
 - spec/support/i18n_tasks_output_matcher.rb
 - spec/support/test_codebase.rb
 - spec/support/test_codebase_env.rake
+has_rdoc: 

data/spec/support/0_test_codebase_env.rake

@@ -1,4 +0,0 @@
-task :environment do
-  I18n.default_locale = 'en'
-  I18n.available_locales = %w(en es)
-end