i18n-tasks 0.3.6 → 0.3.7

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

@@ -1,127 +0,0 @@
-require 'i18n/tasks/data_traversal'
-require 'i18n/tasks/key_pattern_matching'
-
-module I18n::Tasks
-  module Data
-    module Storage
-      module FileStorage
-
-        def self.included(base)
-          base.extend KlassMethods
-        end
-
-        include ::I18n::Tasks::DataTraversal
-        include ::I18n::Tasks::KeyPatternMatching
-        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 config=(config)
-          opt          = DEFAULTS.deep_merge((config || {}).with_indifferent_access)
-          @read        = opt[:read]
-          @write       = opt[:write].map { |x| x.is_a?(String) ? ['*', x] : x }.map { |x|
-            [compile_key_pattern(x[0]), x[1]]
-          }
-          @locale_data = {}
-        end
-
-        # get locale tree
-        def get(locale)
-          locale               = locale.to_s
-          @locale_data[locale] ||= begin
-            @read.map do |path|
-              Dir.glob path % {locale: locale}
-            end.flatten.map do |locale_file|
-              load_file locale_file
-            end.inject({}) do |hash, locale_data|
-              hash.deep_merge! locale_data || {}
-              hash
-            end[locale.to_s] || {}
-          end.with_indifferent_access
-        end
-
-        alias [] get
-
-        # set locale tree
-        def set(locale, value_tree)
-          locale = locale.to_s
-          out    = {}
-          traverse value_tree do |key, value|
-            route     = @write.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 |path, data|
-            tree = {locale => list_to_tree(data)}
-            write_tree(path, tree)
-          end
-          @locale_data[locale] = nil
-        end
-
-        alias []= set
-
-        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
-            @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
-
-        protected
-
-        def load_file(file)
-          adapter_for(file).parse ::File.read(file)
-        end
-
-        def write_tree(path, tree)
-          ::File.open(path, 'w') { |f| f.write(adapter_for(path).dump(tree)) }
-        end
-
-        def adapter_for(file)
-          self.class.adapter_for(file)
-        end
-
-        module KlassMethods
-          # @param pattern [String] File.fnmatch pattern
-          # @param adapter [responds to parse(string)->hash and dump(hash)->string]
-          def register_adapter(pattern, adapter)
-            (@fn_patterns ||= {})[pattern] = adapter
-          end
-
-          def adapter_for(path)
-            @fn_patterns.detect { |pattern, adapter| ::File.fnmatch(pattern, path) }[1] or
-                raise "Adapter not found for #{path}. Registered adapters: #{@fn_patterns.inspect}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/i18n/tasks/data_traversal.rb

@@ -1,51 +0,0 @@
-module I18n::Tasks::DataTraversal
-  # translation of the key found in the passed hash or nil
-  # @return [String,nil]
-  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)
-  def traverse_map_if(hash)
-    list = []
-    traverse hash do |k, v|
-      mapped = yield(k, v)
-      list << mapped if mapped
-    end
-    list
-  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] }
-      else
-        yield path[1..-1], value
-      end
-    end
-  end
-
-  # [[key, value], ...] list to tree
-  def list_to_tree(list)
-    list = list.sort
-    tree = {}
-    list.each do |key, value|
-      key_segments            = key.to_s.split('.')
-      node                    = key_segments[0..-2].inject(tree) do |r, segment|
-        r[segment] ||= {}
-      end
-      node[key_segments.last] = value
-    end
-    tree
-  end
-end

data/lib/i18n/tasks/translation_data.rb

@@ -1,60 +0,0 @@
-require 'i18n/tasks/data/file_system'
-
-module I18n::Tasks::TranslationData
-
-  # I18n data provider
-  # @see I18n::Tasks::Data::Yaml
-  def data
-    @data ||= data_config[:adapter].constantize.new(data_config[:options])
-  end
-
-  # whether the value for key exists in locale (defaults: base_locale)
-  def key_value?(key, locale = base_locale)
-    t(key, locale).present?
-  end
-
-  def non_base_locales(from = nil)
-    from = self.locales unless from
-    Array(from) - [base_locale]
-  end
-
-  # write to store, normalizing all data
-  def normalize_store!(from = nil)
-    from = self.locales unless from
-    Array(from).each do |target_locale|
-      # the store itself handles normalization
-      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