i18n-tasks 0.3.6 → 0.3.7

data/lib/i18n/tasks/data/file_system_base.rb

@@ -0,0 +1,90 @@
+require 'i18n/tasks/data/locale_tree'
+require 'i18n/tasks/data/router'
+require 'i18n/tasks/data/file_formats'
+require 'i18n/tasks/key_pattern_matching'
+
+module I18n::Tasks
+  module Data
+    class FileSystemBase
+      include ::I18n::Tasks::Data::Router
+      include ::I18n::Tasks::Data::FileFormats
+
+      attr_reader :config
+
+      DEFAULTS = {
+          read:  ['config/locales/%{locale}.yml'],
+          write: ['config/locales/%{locale}.yml']
+      }.with_indifferent_access
+
+      def initialize(config = {})
+        self.config = config
+      end
+
+      def t(key, locale)
+        get(locale).t(key)
+      end
+
+      def config=(config)
+        @config = DEFAULTS.deep_merge((config || {}).with_indifferent_access)
+        @config[:write] = compile_routes @config[:write]
+        reload
+      end
+
+      # get locale tree
+      def get(locale)
+        locale               = locale.to_s
+        @locale_data[locale] ||= begin
+          hash = config[:read].map do |path|
+            Dir.glob path % {locale: locale}
+          end.reduce(:+).map do |locale_file|
+            load_file locale_file
+          end.inject({}.with_indifferent_access) do |hash, locale_data|
+            hash.deep_merge! locale_data || {}
+            hash
+          end[locale.to_s] || {}
+          LocaleTree.new locale, hash.with_indifferent_access
+        end
+      end
+
+      alias [] get
+
+      # set locale tree
+      def set(locale, values)
+        locale = locale.to_s
+        route_values config[:write], values, locale do |path, tree|
+          write_tree path, tree
+        end
+        @locale_data[locale] = nil
+      end
+
+      alias []= set
+
+      # @return self
+      def reload
+        @locale_data       = {}
+        @available_locales = nil
+        self
+      end
+
+      # Get available locales from the list of file names to read
+      def available_locales
+        @available_locales ||= begin
+          locales = Set.new
+          config[:read].map do |pattern|
+            [pattern, Dir.glob(pattern % {locale: '*'})] if pattern.include?('%{locale}')
+          end.compact.each do |pattern, paths|
+            p  = pattern.gsub('\\', '\\\\').gsub('/', '\/').gsub('.', '\.')
+            p  = p.gsub(/(\*+)/) { $1 == '**' ? '.*' : '[^/]*?' }.gsub('%{locale}', '([^/.]+)')
+            re = /\A#{p}\z/
+            paths.each do |path|
+              if re =~ path
+                locales << $1
+              end
+            end
+          end
+          locales
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/data/locale_tree.rb

@@ -0,0 +1,85 @@
+module I18n::Tasks
+  module Data
+    # A tree of keys. Roots are locales, leaves are values.
+    class LocaleTree
+      attr_reader :locale, :data
+
+      delegate :tree_data, to: :class
+
+      def initialize(locale, data = {})
+        @locale = locale.to_s
+        data    = tree_data(data)
+        @data   = data.with_indifferent_access
+      end
+
+      def merge(other)
+        self.class.new locale, data.deep_merge(tree_data(other))
+      end
+
+      alias + merge
+
+      def to_hash
+        {locale => data}
+      end
+
+      # @return [String,nil] translation of the key found in the passed hash or nil
+      def t(key)
+        key.to_s.split('.').inject(data) { |r, seg| r[seg] if r }
+      end
+
+      # traverse => map if yield(k, v)
+      # @return [Array] mapped list
+      def traverse_map_if
+        list = []
+        traverse do |k, v|
+          mapped = yield(k, v)
+          list << mapped if mapped
+        end
+        list
+      end
+
+      # traverse data, yielding with full key and value
+      # @yield [full_key, value]
+      # @return self
+      def traverse
+        q = [['', data]]
+        until q.empty?
+          path, value = q.pop
+          if value.is_a?(Hash)
+            value.each { |k, v| q << ["#{path}.#{k}", v] }
+          else
+            yield path[1..-1], value
+          end
+        end
+        self
+      end
+
+      class << self
+        def tree_data(any)
+          if any.is_a?(Hash)
+            any
+          elsif any.is_a?(Array)
+            list_to_tree_data any
+          elsif any.is_a?(LocaleTree)
+            any.data
+          else
+            raise "Can't get tree data from #{any.inspect}"
+          end
+        end
+
+        def list_to_tree_data(list)
+          key_values = list.sort
+          tree_data  = {}
+          key_values.each do |key, value|
+            key_segments            = key.to_s.split('.')
+            node                    = key_segments[0..-2].inject(tree_data) do |subtree, seg|
+              subtree[seg] ||= {}
+            end
+            node[key_segments.last] = value
+          end
+          tree_data
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/data/router.rb

@@ -0,0 +1,47 @@
+require 'i18n/tasks/data/locale_tree'
+
+module I18n::Tasks
+  module Data
+    module Router
+      include ::I18n::Tasks::KeyPatternMatching
+
+      def compile_routes(routes)
+        routes.map { |x| x.is_a?(String) ? ['*', x] : x }.map { |x|
+          [compile_key_pattern(x[0]), x[1]]
+        }
+      end
+
+      # Route keys to destinations
+      # @param routes [Array] of routes
+      # @example
+      #   # keys matched top to bottom
+      #   [['devise.*', 'config/locales/devise.%{locale}.yml'],
+      #   # default catch-all (same as ['*', 'config/locales/%{locale}.yml'])
+      #    'config/locales/%{locale}.yml']
+      # @param tree [I18n::Tasks::Data::Tree] locale tree, where roots are locales.
+      # @param route_args [Hash] route arguments, %-interpolated
+      # @return [Hash] mapping of destination => [ [key, value], ... ]
+      def route_values(routes, values, locale, &block)
+        out = {}
+        values = LocaleTree.new(locale, values) unless values.is_a?(LocaleTree)
+        values.traverse do |key, value|
+          route     = routes.detect { |route| route[0] =~ key }
+          key_match = $~
+          path      = route[1] % {locale: locale}
+          path.gsub!(/[\\]\d+/) { |m| key_match[m[1..-1].to_i] }
+          (out[path] ||= []) << [key, value]
+        end
+        out.each do |dest, key_values|
+          out[dest] = LocaleTree.new(locale, key_values)
+        end
+        if block
+          out.each(&block)
+        else
+          out
+        end
+      end
+
+    end
+  end
+end
+

data/lib/i18n/tasks/key.rb

@@ -4,6 +4,7 @@ require 'i18n/tasks/key/usages'
 
 module I18n
   module Tasks
+    # Container for i18n key and its attributes
     class Key
       include ::I18n::Tasks::Key::KeyGroup
       include ::I18n::Tasks::Key::MatchPattern
@@ -11,6 +12,8 @@ module I18n
 
       attr_accessor :own_attr
 
+      # @param [Array<Key, Value>|Hash|String] key_or_attr
+      # @param [Hash] attr optional
       def initialize(key_or_attr, own_attr = {})
         @own_attr = if key_or_attr.is_a?(Array)
                       {key: key_or_attr[0], value: key_or_attr[1]}.merge(own_attr)

data/lib/i18n/tasks/key_group.rb

@@ -1,6 +1,7 @@
 require 'set'
 module I18n
   module Tasks
+    # Container for keys with shared attributes
     class KeyGroup
       attr_reader :keys, :attr, :key_names
 

data/lib/i18n/tasks/logging.rb

@@ -9,6 +9,10 @@ module I18n::Tasks::Logging
     end
   end
 
+  def log_warn(message)
+    log_stderr Term::ANSIColor.yellow "i18n-tasks: [WARN] #{message}"
+  end
+
   def log_stderr(*args)
     STDERR.puts *args
   end

data/lib/i18n/tasks/missing_keys.rb

@@ -28,11 +28,11 @@ module I18n::Tasks
     # @return [KeyGroup] missing keys, i.e. key that are in the code but are not in the base locale data
     def keys_missing_from_base
       @keys_missing_from_base ||= begin
-        KeyGroup.new(
-            used_keys.keys.reject { |k|
-              key = k.key
-              k.expr? || key_value?(key, base_locale) || ignore_key?(key, :missing)
-            }.map(&:clone_orphan), type: :missing_from_base, locale: base_locale)
+        keys = used_keys.keys.reject { |k|
+          key = k.key
+          k.expr? || key_value?(key, base_locale) || ignore_key?(key, :missing)
+        }.map(&:clone_orphan)
+        KeyGroup.new keys, type: :missing_from_base, locale: base_locale
       end
     end
 
@@ -40,19 +40,23 @@ module I18n::Tasks
     def keys_missing_from_locale(locale)
       return keys_missing_from_base if locale == base_locale
       @keys_missing_from_locale         ||= {}
-      @keys_missing_from_locale[locale] ||= KeyGroup.new(
-          traverse_map_if(data[base_locale]) { |key, base_value|
-            key if !ignore_key?(key, :missing) && !key_value?(key, locale) && !key_value?(depluralize_key(key), locale)
-          }, type: :missing_from_locale, locale: locale)
-
+      @keys_missing_from_locale[locale] ||= begin
+        keys = data[base_locale].traverse_map_if { |key, base_value|
+          key if !ignore_key?(key, :missing) && !key_value?(key, locale) && !key_value?(depluralize_key(key), locale)
+        }
+        KeyGroup.new keys, type: :missing_from_locale, locale: locale
+      end
     end
 
     # @return [KeyGroup] keys missing value (but present in base)
     def keys_eq_base(locale)
-      @keys_eq_base ||= KeyGroup.new(
-          traverse_map_if(data[base_locale]) { |key, base_value|
-            key if base_value == t(key, locale) && !ignore_key?(key, :eq_base, locale)
-          }, type: :eq_base, locale: locale)
+      @keys_eq_base         ||= {}
+      @keys_eq_base[locale] ||= begin
+        keys = data[base_locale].traverse_map_if { |key, base_value|
+          key if base_value == t(key, locale) && !ignore_key?(key, :eq_base, locale)
+        }
+        KeyGroup.new keys, type: :eq_base, locale: locale
+      end
     end
   end
 end

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

@@ -36,7 +36,7 @@ module I18n
           end
         end
 
-        def used_keys(keys = task.used_keys(true))
+        def used_keys(keys = task.used_keys(src_locations: true))
           print_title used_title(keys)
           keys.sort_by_attr!(key: :asc)
           if keys.present?

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

@@ -1,9 +1,12 @@
+require 'i18n/tasks/key_pattern_matching'
 require 'i18n/tasks/relative_keys'
 module I18n::Tasks::Scanners
   class BaseScanner
     include ::I18n::Tasks::RelativeKeys
     include ::I18n::Tasks::KeyPatternMatching
-    attr_reader :config, :key_filter, :record_usages
+    include ::I18n::Tasks::Logging
+
+    attr_reader :config, :key_filter, :record_src_loc
 
     def initialize(config = {})
       @config        = config.dup.with_indifferent_access.tap do |conf|
@@ -16,7 +19,7 @@ module I18n::Tasks::Scanners
           conf[:exclude] = %w(*.jpg *.png *.gif *.svg *.ico *.eot *.ttf *.woff)
         end
       end
-      @record_usages = false
+      @record_src_loc = false
     end
 
     def key_filter=(value)
@@ -26,31 +29,27 @@ module I18n::Tasks::Scanners
 
     # @return [Array] found key usages, absolutized and unique
     def keys
-      if @record_usages
-        keys_with_usages
-      else
-        @keys ||= (traverse_files { |path| scan_file(path, read_file(path)).map(&:key) }.reduce(:+) || []).uniq
-      end
+      @keys ||= (traverse_files { |path| scan_file(path) }.reduce(:+) || []).uniq(&:key)
     end
 
-    def keys_with_usages
-      with_usages do
+    def keys_with_src_locations
+      with_src_locations do
         keys = traverse_files { |path|
-          ::I18n::Tasks::KeyGroup.new(scan_file(path, read_file(path)), src_path: path)
-        }.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]) }}
+          ::I18n::Tasks::KeyGroup.new(scan_file(path), src_path: path)
+        }.reduce(:+) || []
+        keys.group_by(&:key).map { |key, key_loc|
+          {key: key, usages: key_loc.map { |k| k[:src].merge(path: k[:src_path]) }}
         }
       end
     end
-
+    
     def read_file(path)
       result = nil
       File.open(path, 'rb') { |f| result = f.read }
       result
     end
 
-    # @return [String] keys used in file (unimplemented)
+    # @return [Array<Key>] keys found in file
     def scan_file(path, *args)
       raise 'Unimplemented'
     end
@@ -61,44 +60,47 @@ module I18n::Tasks::Scanners
       result = []
       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")
+        log_warn "search.paths #{config[:paths].inspect} 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])
-        result << yield(path)
+        is_dir   = File.directory?(path)
+        hidden   = File.basename(path).start_with?('.')
+        not_incl = config[:include] && !path_fnmatch_any?(path, config[:include])
+        excl     = path_fnmatch_any?(path, config[:exclude])
+        if is_dir || hidden || not_incl || excl
+          Find.prune if is_dir && (hidden || excl)
+        else
+          result << yield(path)
+        end
       end
       result
     end
 
-    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)
       filter_was      = @key_filter
       self.key_filter = key_filter
-      result          = yield
+      yield
+    ensure
       self.key_filter = filter_was
-      result
     end
 
-    def with_usages
-      was            = @record_usages
-      @record_usages = true
-      result         = yield
-      @record_usages = was
-      result
+    def with_src_locations
+      was             = @record_src_loc
+      @record_src_loc = true
+      yield
+    ensure
+      @record_src_loc = was
     end
 
     protected
 
-    def usage_context(text, src_pos)
-      return nil unless @record_usages
+    def path_fnmatch_any?(path, globs)
+      globs.any? { |glob| File.fnmatch(glob, path) }
+    end
+
+    def src_location(text, src_pos)
+      return nil unless @record_src_loc
       line_begin = text.rindex(/^/, src_pos - 1)
       line_end   = text.index(/.(?=\n|$)/, src_pos)
       {src: {