i18n-tools 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sven Fuchs <svenfuchs@artweb-design.de>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1 @@
+to turn off filename generation in zsh: unsetopt GLOB

data/bin/i18n-keys

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'commander'
+require File.dirname(__FILE__) + '/../lib/i18n/keys'
+require File.dirname(__FILE__) + '/../lib/i18n/keys/commands'

data/lib/ansi.rb

@@ -0,0 +1,19 @@
+module Ansi
+  COLORS = { :red =>";31", :yellow => ";33", :green => ";32" }
+  STYLES = { :bold => ";1", :underline => ";4" }
+  
+  def ansi_format(text, formats)
+    res = "\e[0"
+    if formats.is_a?(Array) || formats.is_a?(Hash)
+      COLORS.each { |k,v| res += v if formats.include?(k) }
+      STYLES.each { |k,v| res += v if formats.include?(k) }
+    elsif formats.is_a?(Symbol)
+      COLORS.each { |k,v| res += v if formats == k }
+      STYLES.each { |k,v| res += v if formats == k }
+    elsif formats.respond_to?(:to_sym)
+      COLORS.each { |k,v| res += v if formats.to_sym == k }
+      STYLES.each { |k,v| res += v if formats.to_sym == k }
+    end
+    res += "m" + text.to_s + "\e[0m"
+  end
+end

data/lib/i18n/keys.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/parser/ruby_parser'
+require File.dirname(__FILE__) + '/parser/erb_parser'
+require File.dirname(__FILE__) + '/keys/index'
+
+module I18n
+  module Keys
+    VERSION = '0.0.1'
+    
+    @@root = '.'
+    @@verbose = true
+    
+    class << self
+      def verbose?
+        @@verbose
+      end
+
+      def verbose=(verbose)
+        @@verbose = !!verbose
+      end
+      
+      def root
+        @@root
+      end
+
+      def root=(dir)
+        @@root = dir
+      end
+      
+      def meta_dir
+        dir = root + '/.i18n'
+        FileUtils.mkdir(dir) unless File.exists?(dir)
+        dir
+      end
+    
+      def config
+        @config ||= YAML.load_file(meta_dir + '/config.yml') rescue { 'indices' => {} }
+      end
+      
+      def config=(config)
+        @config = config
+      end
+      
+      def index(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        name = args.first || options.delete(:index)
+        index = Index.load_or_create_or_init(name, options)
+        index
+      end
+    end
+  end
+end

data/lib/i18n/keys/commands.rb

@@ -0,0 +1,53 @@
+program :version, I18n::Keys::VERSION
+program :description, 'ruby i18n tools'
+ 
+command :find do |c|
+  c.syntax = 'i18n find [key] --index --verbose'
+  c.summary = 'Find keys passed to I18n.t()'
+  c.example 'i18n find', 'i18n find foo bar --index'
+  c.option '--index', 'Use an index'
+  c.option '--verbose', 'Output information about index build'
+  c.when_called do |args, options|
+    I18n::Keys.verbose = options.verbose
+    index = I18n::Keys.index(:index => options.index)
+    index.each(*args.map { |arg| arg.dup }) { |occurence| puts occurence.to_s }
+  end
+end
+
+command :replace do |c|
+  c.syntax = 'i18n replace [key] [replacement] --index --verbose'
+  c.summary = 'Replace keys passed to I18n.t() by something else'
+  c.example 'i18n replace', 'i18n replace foo bar --index'
+  c.option '--index', 'Use an index'
+  c.option '--verbose', 'Output information about index build'
+  c.when_called do |args, options|
+    search, replacement = args.shift, args.shift
+    raise Commander::Runner::InvalidCommandError.new('Wrong number of arguments') unless search && replacement
+    I18n::Keys.verbose = options.verbose
+    index = I18n::Keys.index(:index => options.index)
+    index.each(search.dup, replacement.dup) do |occurence|
+      index.replace(occurence, replacement) if I18n::Commands.replace?(occurence, replacement)
+    end
+  end
+end
+
+module I18n
+  module Commands
+    class << self
+      def replace?(occurence, replacement)
+        return true if @all
+        answer = I18n::Commands.confirm_replacement(occurence, replacement)[0, 1]
+        answer == 'a' ? @all = true : answer == 'y'
+      end
+
+      def confirm_replacement(occurence, replacement)
+        puts occurence.to_s, occurence.context
+        msg = "Replace this occurence of the key \"#{occurence.key}\" with \"#{replacement}\"? [Y]es [N]o [A]ll"
+        answer = ask(msg, %w(y yes n no a all)) do |q|
+          q.case = :downcase
+          q.readline = true
+        end
+      end
+    end
+  end
+end

data/lib/i18n/keys/formatter.rb

@@ -0,0 +1,39 @@
+module I18n
+  module Keys
+    class Index
+      module Formatter
+        module Setup
+          def setup(target)
+            (class << target; self; end).send(:include, self)
+          end
+        end
+
+        module Stdin
+          extend Setup
+
+          def build(*args)
+            puts "building index \"#{name}\"" if I18n::Keys.verbose?
+            super
+            puts "\nfound #{occurences.size} occurences of #{keys.size} keys in #{files.size} files" if I18n::Keys.verbose?
+          end
+
+          def save
+            puts "saving index \"#{name}\"" if I18n::Keys.verbose?
+            super
+          end
+
+          def parse(file)
+            # puts "  parsing #{file}" if I18n::Keys.verbose?
+            putc '.' if I18n::Keys.verbose?
+            super
+          end
+
+          # def each(*keys)
+          #   puts "iterating occurences of: #{keys.map { |key| key.to_sym.inspect }.join(', ')}" if I18n::Keys.verbose?
+          #   super
+          # end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/keys/index.rb

@@ -0,0 +1,209 @@
+require 'yaml'
+require File.dirname(__FILE__) + '/formatter'
+require File.dirname(__FILE__) + '/occurence'
+
+# Keys.index(:default, :pattern => '/**/*.{rb,erb}').each(:foo, :bar) { |occurence| ... }
+#
+# when the :index name is not given it creates the index on the fly but won't save it
+# when the :index name is true it uses :default as an index name
+#
+# when an index with the given name does not exist it builds and saves an index
+# when an index with the given name exists and the given pattern does not match
+#   the index's pattern it issues a warning and rebuilds the index
+#
+# when no keys are given, occurences of all keys will be iterated
+# when keys are given, only occurences of the given keys will be iterated
+
+module I18n
+  module Keys
+    class Index
+      include Enumerable
+
+      @@formatter = Formatter::Stdin
+      @@default_pattern = '/**/*.{rb,erb}'
+
+      class << self
+        def load_or_create_or_init(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          name = TrueClass === args.first ? :default : args.first
+          index = name ? load_or_create(name, options) : new(name, options)
+          index
+        end
+
+        def load_or_create(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          name = args.first || :default
+          exists?(name) ? load(name) : create(name, options)
+        end
+
+        def create(*args)
+          index = new(*args)
+          index.update
+          index
+        end
+
+        def load(name)
+          File.open(filename(name), 'r') { |f| Marshal.load(f) } if exists?
+        end
+
+        def mk_dir
+          FileUtils.mkdir_p(store_dir) unless exists?
+        end
+
+        def exists?(name = nil)
+          name ? File.exists?(filename(name)) : File.exists?(store_dir)
+        end
+
+        def delete(name)
+          new(name).delete
+        end
+
+        def delete_all
+          FileUtils.rm_r(store_dir) if exists? rescue Errno::ENOENT
+        end
+
+        def filename(name)
+          store_dir + "/#{name.to_s}.marshal"
+        end
+
+        def store_dir
+          File.expand_path(Keys.meta_dir + '/indizes')
+        end
+      end
+
+      attr_reader :name
+
+      [:keys, :occurences, :by_key].each do |name|
+        class_eval <<-code
+          def #{name}             # def key
+            build unless built?   #   build unless built?
+            @#{name}              #   @key
+          end                     # end
+        code
+      end
+
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        @name = args.first || :default
+        @pattern = options[:pattern] || @@default_pattern
+        reset!
+        @@formatter.setup(self) if @@formatter
+      end
+
+      def reset!
+        @built = false
+        @keys = []
+        @occurences = []
+        @by_key = {}
+      end
+
+      def built?
+        @built
+      end
+
+      def build(options = {})
+        @occurences = find_occurences(options)
+        @occurences.each do |occurence|
+          @keys << occurence.key
+          (@by_key[occurence.key] ||= []) << occurence
+        end
+        @built = true
+      end
+
+      def exists?
+        File.exists?(filename)
+      end
+
+      def save
+        self.class.mk_dir
+        File.open(filename, 'w+') { |f| Marshal.dump(self, f) }
+      end
+
+      def update(options = {})
+        reset!
+        build(options)
+        save
+      end
+
+      def delete
+        FileUtils.rm(filename) if exists? rescue Errno::ENOENT
+      end
+
+      def filename
+        self.class.filename(name)
+      end
+
+      def files
+        Dir[Keys.root + pattern]
+      end
+
+      def pattern
+        @pattern ||= config['pattern'] || @@default_pattern
+      end
+
+      def config
+        @config ||= Keys.config['indices'][name] || { }
+      end
+      
+      def each(*keys)
+        patterns = key_patterns(keys)
+        occurences.each { |occurence| yield(occurence) if key_matches?(occurence.key, patterns) }
+      end
+      
+      def inject(memo, *keys)
+        each(*keys) { |occurence| yield(memo, occurence) }
+        memo
+      end
+      
+      def replace!(occurence, replacement)
+        occurence.replace!(replacement)
+        save if exists?
+      end
+
+      def marshal_dump
+        keys = :name, :pattern, :keys, :occurences, :by_key
+        keys.inject({ :built => built? }) { |result, key| result[key] = send(key); result }
+      end
+
+      def marshal_load(data)
+        keys = :name, :pattern, :keys, :occurences, :by_key, :built
+        keys.each { |key| instance_variable_set(:"@#{key}", data[key]) }
+      end
+
+      protected
+      
+        def find_occurences(options)
+          files.inject([]) do |result, file|
+            calls = parse(file).find_by_type(:call).select { |call| call[2] == :t }
+            calls.inject(result) do |result, node|
+              node.each_key_node { |key| result << Occurence.from_sexp(key, file) }
+              result
+            end
+          end
+        end
+        
+        def key_matches?(subject, key_patterns)
+          key_patterns.empty? || key_patterns.any? do |key, pattern| 
+            subject.to_sym == key || subject.to_s =~ pattern
+          end
+        end
+        
+        def key_patterns(keys)
+          keys.inject({}) { |result, key| result[key] = key_pattern(key); result }
+        end
+        
+        def key_pattern(key)
+          key = key.to_s.dup
+          match_end = key.gsub!(/\*$/, '') ? '' : '$'
+          pattern = Regexp.escape("#{key}")
+          /^#{pattern}#{match_end}/
+        end
+
+        def parse(file)
+          source = File.read(file)
+          source = ErbParser.new.to_ruby(source) if File.extname(file) == '.erb'
+          RubyParser.new.parse(source)
+        end
+    end
+  end
+end

data/lib/i18n/keys/occurence.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + '/../../ansi'
+
+module I18n
+  module Keys
+    class Occurence
+      include Ansi
+
+      @@context_lines = 2
+
+      class << self
+        def context_lines
+          @@context_lines
+        end
+
+        def context_lines=(num)
+          @@context_lines = num
+        end
+
+        def from_sexp(sexp, file = nil)
+          new(sexp[1], file || sexp.file, sexp.source_start_pos, sexp.source_end_pos)
+        end
+      end
+
+      attr_reader :key, :file, :start_pos, :end_pos
+
+      def initialize(key, file, start_pos, end_pos)
+        @key = key.to_sym
+        @file = file
+        @start_pos = start_pos
+        @end_pos = end_pos
+      end
+      
+      def replace!(replacement)
+        replacement = replacement.to_sym.inspect
+        content = content_head + replacement + content_tail
+        @key = replacement.to_sym
+        self.length = replacement.to_s.length
+        File.open(file, 'w+') { |f| f.write(content) }
+        @position, @lines, @context = nil, nil, nil
+      end
+      
+      def content
+        lines.join
+      end
+
+      def lines
+        @lines ||= File.open(file, 'r') { |f| f.readlines }
+      end
+
+      def line(highlight = false)
+        line = lines[line_num - 1].dup
+        highlight ? line_head + ansi_format(original_key, [:red, :bold]) + line_tail : line
+      end
+
+      def line_num
+        position[0]
+      end
+
+      def column
+        position[1]
+      end
+
+      def length
+        end_pos - start_pos + 1
+      end
+      
+      def length=(length)
+        @length = length
+        @end_pos = start_pos + length - 1
+      end
+      
+      def original_key
+        line[column - 1, length]
+      end
+      
+      def content_head
+        content[0..(start_pos - 1)].to_s
+      end
+      
+      def content_tail
+        content[(end_pos + 1)..-1].to_s
+      end
+      
+      def line_head
+        line[0..(column - 2)].to_s
+      end
+      
+      def line_tail
+        line[(column + length - 1)..-1].to_s
+      end
+
+      def context
+        @context ||=
+          lines[line_num - self.class.context_lines - 1, self.class.context_lines].join +
+          line(true) + lines[line_num, self.class.context_lines].join
+      end
+
+      def to_s
+        "#{key}: #{file} [#{line_num}/#{column}]"
+      end
+      
+      def ==(other)
+        key == other.key and start_pos == other.start_pos and end_pos == other.end_pos
+      end
+
+      def position
+        @position ||= begin
+          line_num, col = 1, 1
+          lines.inject(0) do |sum, line|
+            break if sum + line.length > start_pos
+            line_num += 1
+            col = start_pos - sum - line.length + 1
+            sum += line.length
+          end
+          [line_num, col]
+        end
+      end
+    end
+  end
+end

data/lib/i18n/parser/erb_parser.rb

@@ -0,0 +1,54 @@
+# replaces html and erb tags with whitespace so that we can parse the result
+# as pure ruby preserving the exact positions of tokens in the original erb
+# source code
+
+require 'erb'
+$KCODE = 'u'
+
+class String
+  def to_whitespace
+    gsub(/\S/, ' ')
+  end
+end
+
+module I18n
+  class ErbParser
+    class Scanner < ERB::Compiler::Scanner
+      def scan
+        stag_reg = /(.*?)(^[ \t]*<%-|<%%|<%=|<%#|<%-|<%|\z)/m
+        etag_reg = /(.*?)(%%>|-%>|%>|\z)/m
+        scanner = StringScanner.new(@src)
+        while !scanner.eos?
+          scanner.scan(@stag ? etag_reg : stag_reg)
+          yield(scanner[1]) unless scanner[1].nil?
+          yield(scanner[2]) unless scanner[2].nil?
+        end
+      end
+    end
+    ERB::Compiler::Scanner.regist_scanner(Scanner, nil, false)
+
+    def to_ruby(source)
+      result = ''
+      comment = false
+      scanner = ERB::Compiler.new(nil).make_scanner(source)
+      scanner.scan do |token|
+        comment = true if token == '<%#'
+        if scanner.stag.nil?
+          result << token.to_whitespace
+          scanner.stag = token if ['<%', '<%-', '<%=', '<%#', "\n"].include?(token)
+        elsif ['%>', '-%>'].include?(token)
+          result << token.to_whitespace
+          scanner.stag = nil
+        else
+          result << (comment ? token.to_whitespace : token) # so, this is the ruby code, then
+          comment = false
+        end
+      end
+      result
+    end
+    
+    def content_dump(string)
+      string.split("\n").map { |s| s.to_whitespace }.join("\n")
+    end
+  end
+end

data/lib/i18n/parser/ruby_parser.rb

@@ -0,0 +1,93 @@
+require 'rubygems'
+require 'sexp_processor'
+require 'ruby_parser'
+
+# monkey patch galore, adds the ability to inspect the original source code
+# that a :lit or :str sexp was parsed from
+
+Sexp.class_eval do
+  attr_accessor :full_source, :source_start_pos, :source_end_pos
+  
+  def value
+    self[1]
+  end
+
+  def source_range
+    source_start_pos..source_end_pos if source_start_pos && source_end_pos
+  end
+
+  def source
+    full_source[source_range] if full_source && source_range
+  end
+  
+  def find_by_type(type)
+    nodes = []
+    nodes << self if self.first == type
+    each_of_type(type) { |node| nodes << node }
+    nodes
+  end
+  
+  def each_key_node(&block)
+    each do |element|
+      next unless Sexp === element
+      element.each_key_node(&block)
+      block.call(element) if element.is_key_node?
+    end
+  end
+  
+  def is_key_node?
+    first == :str || first == :lit && self[1].is_a?(Symbol)
+  end
+end
+
+RubyLexer.class_eval do
+  attr_accessor :source_start_pos, :source_end_pos
+
+  def reset_source_positions!
+    self.source_start_pos, self.source_end_pos = nil, nil, nil
+  end
+end
+
+module I18n
+  class RubyParser < RubyParser
+    def s(*args)
+      result = super
+
+      result.full_source = lexer.src.string.dup
+      result.source_start_pos = lexer.source_start_pos
+      result.source_end_pos = lexer.source_end_pos || lexer.src.pos
+      lexer.reset_source_positions!
+
+      result
+    end
+
+    # :tSYMBOL
+    def _reduce_380(val, _values, result)
+      lexer.source_start_pos = lexer.src.pos - lexer.yacc_value.size - 1
+      lexer.source_end_pos = lexer.src.pos - 1
+      super
+    end
+
+    # :tSTRING
+    def _reduce_386(val, _values, result)
+      lexer.source_start_pos = lexer.src.pos - lexer.yacc_value.size - 2
+      lexer.source_end_pos = lexer.src.pos - 1
+      super
+    end
+  
+    # :tSYMBEG
+    def _reduce_403(val, _values, result)
+      lexer.source_start_pos = lexer.src.pos - lexer.yacc_value.size - 2
+      super
+    end
+  
+    def _reduce_418(val, _values, result)
+      result = super
+      result.source_start_pos = val[1].source_start_pos
+      result.source_end_pos = val[1].source_end_pos
+      result.full_source = val[1].full_source
+      result
+    end
+  end
+end
+

data/test/all.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/*_test.rb'].each { |file| require file }

data/test/commands_test.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/test_helper'

data/test/erb_parser_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'erb'
+
+class ErbParserTest < Test::Unit::TestCase
+  def test_sexp_filename
+    erb = File.read("#{File.dirname(__FILE__)}/fixtures/template.html.erb")
+    ruby = I18n::ErbParser.new.to_ruby(erb)
+    assert_equal erb.length, ruby.length
+    %w(erb_1 erb_2 foo.erb_3).each do |key|
+      assert ruby.index(key)
+      assert_equal erb.index(key), ruby.index(key)
+    end
+  end
+end

data/test/fixtures/source_1.rb

@@ -0,0 +1,14 @@
+class Foo
+  def foo
+    t(:bar)
+    t(:"baaar")
+    t(:'baar')
+    t(:'foo.bar')
+    t("bar")
+    t('bar_1')
+    1 + 1
+    t(1)
+    t(1.1)
+  end
+  foo(:outside_)
+end

data/test/fixtures/source_2.rb

@@ -0,0 +1 @@
+t(:bar_2)

data/test/fixtures/template.html.erb

@@ -0,0 +1,19 @@
+<html>
+<ul>
+<% [:foo].each do |foo| %>
+	<li>
+
+		<span><%= t(:erb_1) %></span>
+		<%#= comment
+		     comment
+		     comment  %>
+	</li>
+<% end %>
+<br>
+
+<%- t(:erb_2) -%>
+
+<%- t(:'foo.erb_3') -%>
+
+</ul>
+</html>

data/test/index_test.rb

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class IndexTest < Test::Unit::TestCase
+  include I18n
+
+  def setup
+    I18n::Keys.verbose = false
+    @filenames = %W( #{File.dirname(__FILE__)}/fixtures/source_1.rb
+                     #{File.dirname(__FILE__)}/fixtures/source_2.rb )
+    @default_keys_root, Keys.root = Keys.root, File.expand_path(File.dirname(__FILE__)) + '/fixtures'
+    FileUtils.cp(@filenames[0], "#{@filenames[0]}.backup")
+  end
+
+  def teardown
+    Keys::Index.delete_all
+    Keys.root = @default_keys_root
+    FileUtils.mv("#{@filenames[0]}.backup", @filenames[0])
+  end
+
+  def test_index_default_pattern
+    Keys.config = nil
+    assert_equal '/**/*.{rb,erb}', Keys::Index.new.pattern
+  end
+
+  def test_index_finds_files
+    expected = %w(test/fixtures/source_1.rb test/fixtures/source_2.rb).map { |p| File.expand_path(p) }
+    assert_equal expected, Keys::Index.new.files & expected
+  end
+
+  def test_occurences_built_lazily_on_a_fresh_index
+    index = Keys::Index.new(:default)
+    expected = [:bar, :baaar, :baar, :bar, :bar_1, :bar_2]
+    assert_equal expected, index.occurences.select { |key| expected.include?(key.key) }.map(&:key)
+  end
+
+  def test_occurences_from_marshalled_index
+    index = Keys::Index.new(:marshalled)
+    index.update
+    index = Keys::Index.load(:marshalled)
+    expected = [:bar, :baaar, :baar, :bar, :bar_1, :bar_2]
+    assert_equal expected, index.occurences.select { |key| expected.include?(key.key) }.map(&:key)
+  end
+
+  def test_index_create_builds_and_saves_the_index
+    index = Keys::Index.new(:create)
+    assert !index.exists?
+    index = Keys::Index.create(:create, :pattern => '/**/*.{rb}')
+    assert index.built?
+    assert index.exists?
+    assert_equal '/**/*.{rb}', index.pattern
+  end
+
+  def test_index_load_or_create_creates_an_index
+    index = Keys::Index.load_or_create(:load_or_create, :pattern => '/**/*.{rb}')
+    assert index.exists?
+    assert_equal '/**/*.{rb}', index.pattern
+  end
+
+  def test_index_load_or_create_or_init_with_no_name_given_does_not_save_the_index
+    index = Keys::Index.load_or_create_or_init(:pattern => '/**/*.{rb}')
+    assert !index.exists?
+    assert_equal '/**/*.{rb}', index.pattern
+  end
+
+  def test_index_load_or_create_or_init_with_true_given_saves_the_default_index
+    index = Keys::Index.load_or_create_or_init(true, :pattern => '/**/*.{rb}')
+    assert index.exists?
+    assert_equal :default, index.name
+    assert_equal '/**/*.{rb}', index.pattern
+  end
+
+  def test_index_load_or_create_or_init_with_name_given_saves_the_named_index
+    index = Keys::Index.load_or_create_or_init(:foo, :pattern => '/**/*.{rb}')
+    assert index.exists?
+    assert_equal :foo, index.name
+    assert_equal '/**/*.{rb}', index.pattern
+  end
+
+  def test_index_exists_is_true_when_index_directory_exists
+    index = Keys::Index.create('foo')
+    assert index.exists?
+    FileUtils.rm_r(index.filename)
+    assert !index.exists?
+  end
+
+  def test_index_inject_with_no_keys_given_iterates_over_all_occurences
+    index = Keys::Index.new(:pattern => '/**/*.{rb}')
+    expected = [:bar, :baaar, :baar, :'foo.bar', :bar, :bar_1, :bar_2]
+    result = index.inject([]) { |result, occurence| result << occurence.key }
+    assert_equal expected, result
+  end
+
+  def test_index_inject_with_keys_given_iterates_over_occurences_of_given_keys
+    index = Keys::Index.new(:pattern => '/**/*.{rb}')
+    expected = [:bar, :baaar, :baar, :bar]
+    result = index.inject([], :bar, :baaar, :baar) { |result, occurence| result << occurence.key }
+    assert_equal expected, result
+  end
+
+  def test_key_included_with_no_keys_given_returns_true
+    index = Keys::Index.new
+    assert index.send(:key_matches?, :foo, [])
+  end
+
+  def test_key_included_with_the_key_included_returns_true
+    index = Keys::Index.new
+    assert index.send(:key_matches?, :foo, { :foo => /^foo$/, :bar => /^bar$/ })
+  end
+
+  def test_key_pattern_with_no_wild_cards_returns_a_pattern_matching_only_the_key
+    index = Keys::Index.new
+    assert_equal /^foo\.bar$/, index.send(:key_pattern, :'foo.bar')
+  end
+
+  def test_key_pattern_with_a_dot_separated_wild_card_at_the_end_returns_a_pattern_matching_all_keys_starting_with_key
+    index = Keys::Index.new
+    assert_equal /^foo\.bar\./, index.send(:key_pattern, :'foo.bar.*')
+  end
+  
+  def test_replace_replaces_key_without_wildcard_in_source_file
+    index = Keys::Index.create(:replace)
+    bar = index.by_key[:bar].first
+    index.replace!(bar, 'foo')
+    assert_equal "    t(:foo)\n", bar.line
+    
+    index = Keys::Index.load(:replace)
+    foo = index.by_key[:bar].first
+    assert foo == bar
+  end
+  
+  # TODO
+  # - after replace make sure the index is updated
+  # - somehow also update the yaml/rb files
+  
+end

data/test/keys_test.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class KeysTest < Test::Unit::TestCase
+  include I18n
+
+  def setup
+    @filenames = %W( #{File.dirname(__FILE__)}/fixtures/source_1.rb
+                     #{File.dirname(__FILE__)}/fixtures/source_2.rb )
+    @default_keys_root, Keys.root = Keys.root, File.expand_path(File.dirname(__FILE__))
+  end
+
+  def teardown
+    Keys::Index.delete_all
+    Keys.root = @default_keys_root
+    Keys.config = nil
+  end
+  
+  def test_root_defaults_to_dot
+    assert_equal '.', @default_keys_root
+  end
+  
+  def test_can_set_root
+    old_root = I18n::Keys.root
+    assert_nothing_raised { I18n::Keys.root = 'path/to/root' }
+    assert_equal 'path/to/root', I18n::Keys.root
+    I18n::Keys.root = old_root
+  end
+  
+  def test_index_given_no_name_returns_an_unbuilt_and_unsaved_index
+    index = Keys.index
+    assert_equal Keys::Index, index.class
+    assert !index.built?
+    assert !index.exists?
+  end
+  
+  def test_index_given_true_as_a_name_returns_the_built_default_index
+    index = Keys.index(true)
+    assert_equal Keys::Index, index.class
+    assert_equal :default, index.name
+    assert index.built?
+    assert index.exists?
+  end
+  
+  def test_index_given_a_regular_name_returns_the_built_named_index
+    index = Keys.index(:foo)
+    assert_equal Keys::Index, index.class
+    assert_equal :foo, index.name
+    assert index.built?
+    assert index.exists?
+  end
+
+  # def test_find_all_in_file
+  #   expected = [:bar, :baaar, :baar, "bar", "bar_1"]
+  #   keys = I18n::Keys.find(:files => @filenames[0])
+  #   assert_equal expected, keys.select { |key| expected.include?(key.key) }.map(&:key)
+  # end
+  # 
+  # def test_find_all_in_files
+  #   expected = ['bar_1', :bar_2]
+  #   keys = I18n::Keys.find(:files => @filenames)
+  #   assert_equal expected, keys.select { |key| expected.include?(key.key) }.map(&:key)
+  # end
+  # 
+  # def test_find_key_in_file
+  #   expected = [:bar]
+  #   keys = I18n::Keys.find(:keys => :bar, :files => @filenames[0])
+  #   assert_equal expected, keys.select { |key| expected.include?(key.key) }.map(&:key)
+  # end
+  # 
+  # def test_find_key_in_files
+  #   expected = [:bar]
+  #   keys = I18n::Keys.find(:keys => :bar, :files => @filenames)
+  #   assert_equal expected, keys.select { |key| expected.include?(key.key) }.map(&:key)
+  # end
+end

data/test/occurence_test.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class OccurenceTest < Test::Unit::TestCase
+  def setup
+    I18n::Keys.verbose = false
+  end
+  
+  def setup
+    I18n::Keys.verbose = false
+    @filename = "#{File.dirname(__FILE__)}/fixtures/source_1.rb"
+    FileUtils.cp(@filename, "#{@filename}.backup")
+  end
+
+  def teardown
+    FileUtils.mv("#{@filename}.backup", @filename)
+  end
+
+  def occurence(key = :bar)
+    index = I18n::Keys::Index.new
+    index.update
+    index.by_key[key.to_sym].first
+  end
+  
+  def test_line_without_highlighting
+    assert_equal "    t(:'baar')\n", occurence(:baar).line
+  end
+  
+  def test_line_with_highlighting
+    assert_equal "    t(\e[0;31;1m:'baar'\e[0m)\n", occurence(:baar).line(true)
+  end
+  
+  def test_occurence_line_num
+    assert_equal 3, occurence.line_num
+  end
+  
+  def test_occurence_column
+    assert_equal 7, occurence.column
+  end
+  
+  def test_occurence_length
+    assert_equal 4, occurence.length
+  end
+  
+  def test_original_key
+    assert ":bar", occurence.original_key
+  end
+  
+  def test_content_head
+    assert_equal "def foo\n    t(", occurence.content_head[-14, 999]
+  end
+  
+  def test_content_tail
+    assert_equal ")\n    t(:\"baaar\")\n", occurence.content_tail[0, 18]
+  end
+  
+  def test_line_head
+    assert_equal "    t(", occurence.line_head
+  end
+  
+  def test_line_tail
+    assert_equal ")\n", occurence.line_tail
+  end
+  
+  def test_context_returns_the_context_of_the_occurence_with_2_lines_setting
+    context = occurence(:baar).context.split("\n")
+    assert_equal 5, context.length
+    assert_equal "    t(\e[0;31;1m:'baar'\e[0m)", context[2]
+  end
+  
+  def test_context_returns_the_context_of_the_occurence_with_3_lines_setting
+    I18n::Keys::Occurence.context_lines = 3
+    context = occurence(:baar).context.split("\n")
+    assert_equal 7, context.length
+    assert_equal "    t(\e[0;31;1m:'baar'\e[0m)", context[3]
+  end
+  
+  def test_replace_simple_symbol_with_simple_symbol
+    bar = occurence(:bar)
+    bar.replace!(:oooooooo)
+    assert_equal "    t(\e[0;31;1m:oooooooo\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_simple_symbol_with_quoted_symbol
+    bar = occurence(:bar)
+    bar.replace!(:'oooo.oooo')
+    assert_equal "    t(\e[0;31;1m:\"oooo.oooo\"\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_simple_symbol_with_string
+    bar = occurence(:bar)
+    bar.replace!('oooooooo')
+    assert_equal "    t(\e[0;31;1m:oooooooo\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_quoted_symbol_with_simple_symbol
+    bar = occurence(:'foo.bar')
+    bar.replace!(:oooooooo)
+    assert_equal "    t(\e[0;31;1m:oooooooo\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_quoted_symbol_with_quoted_symbol
+    bar = occurence(:'foo.bar')
+    bar.replace!(:'oooo.oooo')
+    assert_equal "    t(\e[0;31;1m:\"oooo.oooo\"\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_quoted_symbol_with_string
+    bar = occurence(:'foo.bar')
+    bar.replace!('oooooooo')
+    assert_equal "    t(\e[0;31;1m:oooooooo\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_string_with_simple_symbol
+    bar = occurence('bar_1')
+    bar.replace!(:oooooooo)
+    assert_equal "    t(\e[0;31;1m:oooooooo\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_string_with_quoted_symbol
+    bar = occurence('bar_1')
+    bar.replace!(:'oooo.oooo')
+    assert_equal "    t(\e[0;31;1m:\"oooo.oooo\"\e[0m)\n", bar.line(true)
+  end
+  
+  def test_replace_string_with_string
+    bar = occurence('bar_1')
+    bar.replace!('oooooooo')
+    assert_equal "    t(\e[0;31;1m:oooooooo\e[0m)\n", bar.line(true)
+  end
+end

data/test/ruby_parser_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RubyParserTest < Test::Unit::TestCase
+  def test_sexp_filename
+    filename = File.dirname(__FILE__) + '/fixtures/source_1.rb'
+    sexp = I18n::RubyParser.new.parse(File.read(filename), filename)
+    assert_equal filename, sexp.file
+  end
+
+  def test_sexp_source_positions
+    assert_equal 2, 't(:foo)'.to_sexp.find_node(:lit).source_start_pos
+    assert_equal 5, 't(:foo)'.to_sexp.find_node(:lit).source_end_pos
+  end
+
+  def test_sexp_source_symbol
+    assert_equal ':foo', 't(:foo)'.to_sexp.find_node(:lit).source
+  end
+
+  def test_sexp_source_symbol_and_options
+    assert_equal ':foo', 't(:foo, :bar => :baz)'.to_sexp.find_node(:lit).source
+  end
+  
+  def test_sexp_source_symbol_with_double_quotes
+    assert_equal ':"foo"', 't(:"foo")'.to_sexp.find_node(:lit).source
+  end
+  
+  def test_sexp_source_symbol_with_double_quotes_and_options
+    assert_equal ':"foo"', 't(:"foo", :bar => :baz)'.to_sexp.find_node(:lit).source
+  end
+  
+  def test_sexp_source_symbol_with_single_quotes
+    assert_equal ":'foo'", "t(:'foo')".to_sexp.find_node(:lit).source
+  end
+  
+  def test_sexp_source_symbol_with_single_quotes_and_options
+    assert_equal ":'foo'", "t(:'foo', :bar => :baz)".to_sexp.find_node(:lit).source
+  end
+  
+  def test_sexp_source_string_with_double_quotes
+    assert_equal '"foo"', 't("foo")'.to_sexp.find_node(:str).source
+  end
+  
+  def test_sexp_source_string_with_double_quotes_and_options
+    assert_equal '"foo"', 't("foo", :bar => :baz)'.to_sexp.find_node(:str).source
+  end
+  
+  def test_sexp_source_string_with_single_quotes
+    assert_equal "'foo'", "t('foo')".to_sexp.find_node(:str).source
+  end
+  
+  def test_sexp_source_string_with_single_quotes_and_options
+    assert_equal "'foo'", "t('foo', :bar => :baz)".to_sexp.find_node(:str).source
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/i18n/keys'
+
+class String
+  def to_sexp
+    I18n::RubyParser.new.parse(self)
+  end
+end
+
+class Sexp
+  def find_node(type)
+    each_of_type(type) { |node| return node }
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: i18n-tools
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Sven Fuchs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-26 09:00:00 +02:00
+default_executable: i18n-keys
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: visionmedia-commander
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.5.7
+    version: 
+description: Tools for Ruby/Rails I18n
+email: rails-i18n@googlegroups.com
+executables: 
+- i18n-keys
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/i18n-keys
+- lib/ansi.rb
+- lib/i18n/keys/commands.rb
+- lib/i18n/keys/formatter.rb
+- lib/i18n/keys/index.rb
+- lib/i18n/keys/occurence.rb
+- lib/i18n/keys.rb
+- lib/i18n/parser/erb_parser.rb
+- lib/i18n/parser/ruby_parser.rb
+- MIT-LICENSE
+- README.textile
+has_rdoc: false
+homepage: http://rails-i18n.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Tools for Ruby/Rails I18n
+test_files: 
+- test/all.rb
+- test/commands_test.rb
+- test/erb_parser_test.rb
+- test/fixtures/source_1.rb
+- test/fixtures/source_2.rb
+- test/fixtures/template.html.erb
+- test/index_test.rb
+- test/keys_test.rb
+- test/occurence_test.rb
+- test/ruby_parser_test.rb
+- test/test_helper.rb