i18n-tools 0.0.4 → 0.0.5

data/lib/core_ext/hash/iterate_nested.rb

@@ -0,0 +1,35 @@
+class Hash
+  def each_nested(data = nil, keys = [], &block)
+    (data || self).each do |key, value|
+      case value
+      when Hash
+        each_nested(value, keys + [key], &block)
+      else
+        yield(keys + [key], value)
+      end
+    end
+  end
+
+  def select_nested(data = self, keys = [], &block)
+    case data
+    when Hash
+      data.inject({}) do |result, (key, value)|
+        value = select_nested(value, keys + [key], &block)
+        result[key] = value unless value.nil? || value.empty?
+        result
+      end
+    else
+      data if yield(keys, data)
+    end
+  end
+  
+  def delete_nested_if(data = self, keys = [], &block)
+    data.each do |key, value|
+      if yield(keys + [key], value)
+        data.delete(key)
+      else
+        delete_nested_if(value, keys + [key], &block)
+      end
+    end if data.is_a?(Hash)
+  end
+end

data/lib/core_ext/hash/slice.rb

@@ -0,0 +1,20 @@
+# from activesupport
+
+class Hash
+  # Returns a new hash with only the given keys.
+  def slice(*keys)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end
+  
+  # Replaces the hash with only the given keys.
+  # Returns a hash contained the removed key/value pairs
+  #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d =>4}
+  def slice!(*keys)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    replace(hash)
+    omit
+  end
+end

data/lib/core_ext/hash/sorted_yaml_style.rb

@@ -0,0 +1,17 @@
+class Hash
+  attr_accessor :to_yaml_style
+  
+  def set_yaml_style(style)
+    self.to_yaml_style = style
+    each { |key, value| value.set_yaml_style(style) if value.is_a?(Hash) }
+  end
+
+  def to_yaml(opts = {})
+    YAML::quick_emit(object_id, opts) do |out|
+      out.map(taguri, to_yaml_style) do |map|
+        elements = to_yaml_style == :sorted ? sort : self
+        elements.each { |k, v| map.add(k, v) }
+      end
+    end
+  end
+end

data/lib/core_ext/hash/symbolize_keys.rb

@@ -0,0 +1,14 @@
+class Hash
+  # Return a new hash with all keys converted to symbols.
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  # Destructively convert all keys to symbols.
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+end

data/lib/core_ext/module/attribute_accessors.rb

@@ -0,0 +1,48 @@
+#  from activesupport
+
+class Module
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}  # unless defined? @@pagination_options
+          @@#{sym} = nil          #   @@pagination_options = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.pagination_options
+          @@#{sym}                #   @@pagination_options
+        end                       # end
+                                  #
+        def #{sym}                # def pagination_options
+          @@#{sym}                #   @@pagination_options
+        end                       # end
+      EOS
+    end
+  end
+  
+  def mattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}                       # unless defined? @@pagination_options
+          @@#{sym} = nil                               #   @@pagination_options = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.pagination_options=(obj)
+          @@#{sym} = obj                               #   @@pagination_options = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def pagination_options=(obj)
+          @@#{sym} = obj                               #   @@pagination_options = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+      EOS
+    end
+  end
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/lib/core_ext/object/deep_clone.rb

@@ -0,0 +1,5 @@
+class Object
+  def deep_clone
+    Marshal::load(Marshal::dump(self))
+  end
+end

data/lib/core_ext/object/instance_variables.rb

@@ -0,0 +1,9 @@
+class Object
+  def instance_variables_get(*keys)
+    keys.inject({}) { |result, key| result[key] = instance_variable_get(:"@#{key}"); result }
+  end
+  
+  def instance_variables_set(vars)
+    vars.each { |key, value| instance_variable_set(:"@#{key}", value) }
+  end
+end

data/lib/core_ext/object/meta_class.rb

@@ -0,0 +1,5 @@
+class Object
+  def meta_class
+    (class << self; self; end)
+  end
+end

data/lib/core_ext/object/tap.rb

@@ -0,0 +1,6 @@
+class Object
+  def tap
+    yield self
+    self
+  end
+end

data/lib/i18n/backend/simple_storage.rb

@@ -0,0 +1,119 @@
+require 'i18n'
+require 'i18n/exceptions/key_exists'
+require 'i18n/translation_properties'
+require 'core_ext/object/deep_clone'
+require 'core_ext/hash/iterate_nested'
+require 'core_ext/hash/sorted_yaml_style'
+
+module I18n
+  module Backend
+    class SimpleStorage < Simple
+      @@sort_keys = true
+
+      class << self
+        def sort_keys
+          @@sort_keys
+        end
+
+        def sort_keys=(sort_keys)
+          @@sort_keys = sort_keys
+        end
+      end
+
+      def interpolate(locale, original, values = {})
+        return original unless original.is_a?(String)
+        super.tap { |string| set_translation_properties(string, original.properties) }
+      end
+
+      def store_translations(locale, data)
+        data.each_nested { |key, value| raise KeyExists.new(locale, key) if lookup(locale, key) }
+        super
+      end
+
+      def copy_translations(from, to)
+        init_translations unless initialized?
+        I18n.available_locales.each do |locale|
+          store_translations(locale, to => I18n.t(from, :raise => true))
+        end
+      end
+
+      def remove_translation(key)
+        init_translations unless initialized?
+        key = I18n.send(:normalize_translation_keys, nil, key, nil)
+        keys = available_locales.map { |locale| [locale] + key }
+        translations.delete_nested_if { |k, v| keys.include?(k) }
+      end
+
+      def save_translations(filenames = I18n.load_path.flatten)
+        Array(filenames).each do |filename|
+          save_file(filename, by_filename(filename))
+        end
+      end
+
+      protected
+
+        def load_yml(filename)
+          YAML::load(IO.read(filename)).tap do |data|
+            set_translation_properties(data, :filename => filename) if data
+          end
+        end
+
+        def by_filename(filename)
+          select_translations { |keys, translation| translation.filename == filename }
+        end
+
+        def select_translations(&block)
+          init_translations unless initialized?
+          translations.select_nested(&block)
+        end
+
+        def each_translation(&block)
+          init_translations unless initialized?
+          translations.each_nested { |keys, t| block.call(keys.first, keys[1..-1], t) }
+        end
+
+        def save_file(filename, data)
+          type = File.extname(filename).tr('.', '').downcase
+          raise UnknownFileType.new(type, filename) unless respond_to?(:"save_#{type}")
+          send(:"save_#{type}", filename, data)
+        end
+
+        def save_yml(filename, data)
+          data = unset_translation_properties(data.deep_clone)
+          data = deep_stringify_keys(data)
+          File.open(filename, 'w+') do |f|
+            data.set_yaml_style(:sorted) if self.class.sort_keys
+            f.write(data.to_yaml)
+          end
+        end
+
+        def set_translation_properties(value, properties)
+          case value
+          when Hash
+            value.each_nested { |key, value| set_translation_properties(value, properties) }
+          else
+            value.meta_class.send(:include, TranslationProperties) unless value.respond_to?(:property_names)
+            value.set_properties(properties)
+          end
+        end
+
+        def unset_translation_properties(value)
+          case value
+          when Hash
+            value.each_nested { |key, value| value.unset_properties }
+          else
+            value.unset_properties
+          end
+        end
+
+        # Return a new hash with all keys and nested keys converted to strings.
+        def deep_stringify_keys(hash)
+          hash.inject({}) { |result, (key, value)|
+            value = deep_stringify_keys(value) if value.is_a?(Hash)
+            result[key.to_s] = value
+            result
+          }
+        end
+      end
+  end
+end

data/lib/i18n/commands/keys.rb

@@ -0,0 +1,84 @@
+require 'i18n/index'
+require 'i18n/exceptions/key_exists'
+require 'core_ext/hash/slice'
+require 'highline/import'
+require 'highlighters/ansi'
+
+module I18n
+  module Commands
+    class Keys
+      def initialize(highlighter = Highlighters::Ansi.new(:bold), out = $stdout)
+        @highlighter = highlighter
+        @out = out
+      end
+
+      def find(keys, options = {})
+        index = index(options)
+        index.find_calls(*keys).each do |call|
+          log "\n" + call.to_s(:context => options[:context], :highlight => @highlighter).gsub(Dir.pwd, '')
+        end
+      end
+
+      def replace(search, replace, options)
+        key = search.gsub(/^\*\.|\.\*$/, '')
+        interactive = options.has_key?(:'interactive') ? options[:'interactive'] : true
+        index = index(options)
+        found = false
+        
+        index.find_calls(search).each do |call|
+          if replace?(call, replace, :interactive => interactive)
+            I18n.backend.copy_translations(key, replace)
+            index.replace_key(call, search, replace)
+            I18n.backend.remove_translation(key)
+            found = true
+          end
+          break if cancelled?
+        end
+        
+        log "No occurences were found or no replacements made for: #{search}." unless found
+      rescue I18n::KeyExists => e
+        log e.message
+      end
+
+      protected
+      
+        def log(str)
+          @out.puts(str)
+        end
+
+        def index(options) # TODO use context + verbose options
+          method = options.delete(:index) ? :load_or_create : :new
+          options = options.slice(:root_dir, :pattern, :format, :context)
+          options[:format] ||= I18n::Index::Format::Stdout.new(@out)
+          I18n::Index.send(method, options)
+        end
+        
+        def cancelled?
+          @cancelled
+        end
+
+        def replace?(call, replace, options = { :interactive => true })
+          return true if @all || !options[:interactive]
+          return false if @cancelled
+          case answer = confirm_replace(call, replace)[0, 1]
+          when 'a'
+            @all = true
+          when 'c'
+            @cancelled = true and false
+          else
+            answer == 'y'
+          end
+        end
+
+        def confirm_replace(call, replace)
+          log call.to_s
+          log call.context(:highlight => @highlighter)
+          msg = "Replace this occurence of the key \"#{call.key}\" with \"#{replace}\"? [Y]es [N]o [A]ll [C]ancel"
+          answer = ask(msg, %w(y yes n no a all c cancel)) do |q|
+            q.case = :downcase
+            q.readline = true
+          end
+        end
+    end
+  end
+end

data/lib/i18n/exceptions/key_exists.rb

@@ -0,0 +1,9 @@
+module I18n
+  class KeyExists < ArgumentError
+    attr_reader :locale, :key
+    def initialize(locale, key)
+      @key, @locale = key, locale
+      super "key exists: (#{locale}) :#{key.join('.')}"
+    end
+  end
+end

data/lib/i18n/index.rb

@@ -0,0 +1,33 @@
+require 'core_ext/module/attribute_accessors'
+
+require 'i18n/index/file'
+require 'i18n/index/simple'
+require 'i18n/ripper2ruby'
+
+module I18n
+  module Index
+    mattr_accessor :pattern, :implementation, :parser, :filters
+
+    @@implementation  = I18n::Index::Simple
+    @@parser          = Ripper::RubyBuilder
+    @@filters         = { '.erb' => lambda { |source| Erb::Stripper.new.to_ruby(source) } }
+    @@pattern         = '**/*.{rb,erb}'
+
+    class << self
+      def new(*args)
+        implementation.new(*args)
+      end
+
+      def load_or_create(*args)
+        implementation.load_or_create(*args)
+      end
+
+      def filter(source, filename)
+        filters.each do |extname, filter|
+          source = filter.call(source) if ::File.extname(filename) == extname
+        end
+        source
+      end
+    end
+  end
+end

data/lib/i18n/index/base.rb

@@ -0,0 +1,38 @@
+require 'core_ext/object/instance_variables'
+
+module I18n
+  module Index
+    class Base
+      attr_accessor :root_dir, :pattern
+
+      def initialize(options = {})
+        @root_dir = options[:root_dir] || Dir.pwd
+        @pattern = options[:pattern] || Index.pattern
+        options[:format].setup(self) if options[:format]
+      end
+
+      def filenames
+        Dir[root_dir + '/' + pattern]
+      end
+
+      def files
+        @files ||= Files.new
+      end
+
+      protected
+      
+        def marshalled_vars
+          # TODO marshalling :files works but makes things much slower during tests - check this for real situations
+          [:root_dir, :pattern] 
+        end
+
+        def marshal_dump
+          instance_variables_get(*marshalled_vars)
+        end
+
+        def marshal_load(data)
+          instance_variables_set(data.slice(*marshalled_vars))
+        end
+    end
+  end
+end