svenfuchs-i18n-tools 0.0.4 → 0.0.5

data/test/i18n/backend/translation_properties_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'i18n'
+require 'i18n/backend/simple_storage'
+
+class I18nTranslationPropertiesTest < Test::Unit::TestCase
+  def setup
+    @backend = I18n.backend = I18n::Backend::SimpleStorage.new
+    @data = { :foo => 'Foo', :bar => 'Bar' }
+    @backend.send(:set_translation_properties, @data, :filename => 'path/to/file.yml')
+  end
+
+  define_method :"test: set_translation_properties includes TranslationProperties to the value's metaclass" do
+    assert @data[:foo].meta_class.include?(I18n::TranslationProperties)
+    assert @data[:bar].meta_class.include?(I18n::TranslationProperties)
+  end
+
+  define_method :"test: set_translation_properties defines the properties on TranslationProperties" do
+    assert_equal [:filename], I18n::TranslationProperties.property_names
+  end
+
+  define_method :"test: set_translation_properties sets the property values on the objects" do
+    assert_equal 'path/to/file.yml', @data[:foo].filename
+    assert_equal 'path/to/file.yml', @data[:bar].filename
+  end
+
+  define_method :"test: unset_translation_properties unsets the property instance_variables on the objects" do
+    @backend.send(:unset_translation_properties, @data)
+    assert_equal nil, @data[:foo].filename
+    assert_equal nil, @data[:bar].filename
+    assert_equal nil, @data[:foo].instance_variable_get(:@filename)
+    assert_equal nil, @data[:bar].instance_variable_get(:@filename)
+  end
+end

data/test/i18n/index/all.rb

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

data/test/i18n/index/args_replace_test.rb

@@ -0,0 +1,218 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class I18nArgsReplaceTest < Test::Unit::TestCase
+  include Ruby
+
+  def init(src)
+    @code = Ripper::RubyBuilder.new(src).parse
+    @args = @code.select(Ruby::ArgsList).first.to_translate_args_list
+  end
+
+  # test type variations
+
+  define_method "test: replace a simple symbol at position 1 with a simple symbol" do
+    init("t(:bar)")
+  
+    @args.replace_key(:bar, :oooooooo)
+      
+    assert_equal [0, 1], @args.position.to_a
+    assert_equal 11, @args.length
+      
+    assert_equal '(:oooooooo)', @args.to_ruby
+    assert_equal '(:oooooooo)', @args.src
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a simple symbol at position 2 with a simple symbol" do
+    init("t(:'foo.bar')")
+    @args.replace_key(:bar, :oooooooo)
+    assert_equal '(:"foo.oooooooo")', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a simple symbol at position 1 with a quoted symbol" do
+    init("t(:bar)")
+    @args.replace_key(:bar, :'oooo.oooo')
+    assert_equal '(:"oooo.oooo")', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a simple symbol at position 2 with a quoted symbol" do
+    init("t(:'foo.bar')")
+    @args.replace_key(:bar, :'oooo.oooo')
+    assert_equal '(:"foo.oooo.oooo")', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a simple symbol at position 1 with a string (results in a symbol)" do
+    init("t(:bar)")
+    @args.replace_key(:bar, 'oooooooo')
+    assert_equal '(:oooooooo)', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a simple symbol at position 2 with a string (results in a symbol)" do
+    init("t(:'foo.bar')")
+    @args.replace_key(:bar, 'oooooooo')
+    assert_equal '(:"foo.oooooooo")', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a quoted symbol at position 1 with a simple symbol" do
+    init("t(:'foo.bar')")
+    @args.replace_key(:'foo.bar', :oooooooo)
+    assert_equal '(:oooooooo)', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a quoted symbol at position 2 with a simple symbol" do
+    init("t(:'bar.baz', :scope => :foo)")
+    @args.replace_key(:'bar.baz', :oooooooo)
+    assert_equal '(:"foo.oooooooo")', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a quoted symbol at position 1 with a quoted symbol" do
+    init("t(:'foo.bar')")
+    @args.replace_key(:'foo.bar', :'oooo.oooo')
+    assert_equal "(:\"oooo.oooo\")", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a quoted symbol at position 2 with a quoted symbol" do
+    init("t(:'bar.baz', :scope => :foo)")
+    @args.replace_key(:'bar.baz', :'oooo.oooo')
+    assert_equal "(:\"oooo.oooo\", :scope => :foo)", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a quoted symbol at position 1 with a string (results in a symbol)" do
+    init("t(:'foo.bar')")
+    @args.replace_key(:'foo.bar', 'oooooooo')
+    assert_equal "(:oooooooo)", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a quoted symbol at position 2 with a string (results in a symbol)" do
+    init("t(:'bar.baz', :scope => :foo)")
+    @args.replace_key(:'bar.baz', 'oooooooo')
+    assert_equal '(:"foo.oooooooo")', @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a string at position 1 with a simple symbol" do
+    init("t('bar_1')")
+    @args.replace_key('bar_1', :oooooooo)
+    assert_equal "(:oooooooo)", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a string at position 1 with a quoted symbol" do
+    init("t('bar_1')")
+    @args.replace_key('bar_1', :'oooo.oooo')
+    assert_equal "(:\"oooo.oooo\")", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method "test: replace a string at position 1 with a string (results in a symbol)" do
+    init("t('bar_1')")
+    @args.replace_key('bar_1', 'oooooooo')
+    assert_equal "(:oooooooo)", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  
+  # test count variations
+  
+  define_method :"test: replace_key :foo with :fuh in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo], [:fuh])
+    assert_equal "(:baz, :scope => [:fuh, :bar])", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo, :bar] with [:fuh, :bah] in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo, :bar], [:fuh, :bah])
+    assert_equal "(:baz, :scope => [:fuh, :bah])", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo, :bar] with [:fuh] in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo, :bar], [:fuh])
+    assert_equal "(:baz, :scope => :fuh)", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo] with [:foo, :fuh] in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo], [:foo, :fuh])
+    assert_equal "(:baz, :scope => [:foo, :fuh, :bar])", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo, :bar, :baz] with [:foo] in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo, :bar, :baz], [:foo])
+    assert_equal "(:foo)", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo, :bar, :baz] with [:foo, :bar] in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo, :bar, :baz], [:foo, :bar])
+    assert_equal "(:bar, :scope => :foo)", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo, :bar, :baz] with [:foo, :bar, :buz] in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo, :bar, :baz], [:foo, :bar, :buz])
+    assert_equal "(:buz, :scope => [:foo, :bar])", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo, :bar, :baz] with [:foo, :bar, :baz, :buz] in (:baz, :scope => [:foo, :bar])" do
+    init("t(:baz, :scope => [:'foo', :bar])")
+  
+    @args.replace_key([:foo, :bar, :baz], [:foo, :bar, :baz, :buz])
+    assert_equal "(:buz, :scope => [:foo, :bar, :baz])", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace_key [:foo, :bar] with [:foo, :bar, :baz] in (:bar, :scope => [:foo])" do
+    init("t(:bar, :scope => [:foo])")
+  
+    @args.replace_key([:foo, :bar], [:foo, :bar, :baz])
+    assert_equal "(:baz, :scope => [:foo, :bar])", @args.to_ruby
+    assert_equal @args.parent.to_ruby, @args.root.src
+  end
+  
+  define_method :"test: replace a few keys on the same line and next line" do
+    src = "t(:a, :scope => [:a]); t(:b, :scope => [:b]);\n t(:c, :scope => [:ccc])\nt(:d, :scope => :d)\ne(:e)"
+    calls = Ripper::RubyBuilder.new(src).parse.statements
+  
+    tokens = %w(a b c d e)
+    calls = ::Hash[*tokens.zip(calls).flatten]
+    src   = ::Hash[*tokens.zip(calls.values.map { |c| c.src }).flatten]
+  
+    calls['a'].to_translate_call.arguments.replace_key([:a], [:aaa])
+    calls['b'].to_translate_call.arguments.replace_key([:b], [:bbb])
+    calls['c'].to_translate_call.arguments.replace_key([:ccc], [:cc])
+  
+    assert_equal 't(:a, :scope => :aaa)', calls['a'].src
+    assert_equal 't(:b, :scope => :bbb)', calls['b'].src
+    assert_equal 't(:c, :scope => :cc)',  calls['c'].src
+    assert_equal 't(:d, :scope => :d)',   calls['d'].src
+    assert_equal 'e(:e)',                 calls['e'].src
+  end
+end
+

data/test/i18n/index/calls_replace_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'i18n/index'
+
+class I18nCallReplaceTest < Test::Unit::TestCase
+  def setup
+    @root_dir = File.expand_path(File.dirname(__FILE__) + '/../../fixtures')
+  end
+
+  def teardown
+    @index.filenames.each { |file| FileUtils.mv("#{file}.backup", file) } if @index
+    @index.delete
+  end
+
+  def index(file)
+    @index ||= I18n::Index.load_or_create(:root_dir => @root_dir, :pattern => '/translate/' + file).tap do |index|
+      index.filenames.each { |file| FileUtils.cp(file, "#{file}.backup") }
+    end
+  end
+
+  def root(index)
+    index.files[index.occurences.first.filename].ruby.root
+  end
+
+  def assert_key_replacements(index, search, replace)
+    calls = []
+
+    while call = index.find_call(search)
+      calls << call
+      index.replace_key(call, search, replace)
+      putc '.'
+    end
+    src = root(index).src
+
+    search.to_s.gsub(/[^\w\.]/, '').split('.').each { |key| assert src.scan(key.to_s).empty? unless key.empty? }
+    replace.to_s.gsub(/[^\w\.]/, '').split('.').each { |key| assert src.scan(key.to_s).size == calls.size }
+
+    assert_equal src, calls.map { |c| c.to_ruby }.join("\n")
+    assert_equal src, calls.map { |c| c.src }.join("\n")
+  end
+
+  define_method :"test subsequent key replacements in: t(:foo)" do
+    2.times do
+      index = index('single_key.rb')
+      assert_key_replacements(index, :foo, :'fuh.bah') and putc '.'
+      assert_key_replacements(index, '*.bah', :foo)    and putc '.'
+      assert_key_replacements(index, 'fuh.*', '')      and putc '.'
+    end
+  end
+
+  define_method :"test subsequent key replacements in: t(:bar, :scope => :foo)" do
+    2.times do
+      index = index('single_scope.rb')
+      assert_key_replacements(index, :'*.bar', :'bah.bas') and putc '.'
+      assert_key_replacements(index, :'*.bah.bas', :'bar') and putc '.'
+    end
+  end
+
+  define_method :"test subsequent key replacements in: t(:'bar.baz', :scope => :foo)" do
+    2.times do
+      index = index('double_key.rb')
+      assert_key_replacements(index, :'foo.bar.baz', :'fuh.bah.bas.bus') and putc '.'
+      assert_key_replacements(index, :'fuh.bah.bas.bus', :'foo.bar.baz') and putc '.'
+    end
+  end
+
+  # TODO add more tests for partial key matches
+end

data/test/i18n/index/commands_test.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'i18n/backend/simple_storage'
+
+class I18nCommandsKeysTest < Test::Unit::TestCase
+  @@fixtures_dir = File.expand_path(File.dirname(__FILE__) + '/../../fixtures/')
+  @@backup_dir = File.expand_path(File.dirname(__FILE__) + '/../../tmp/')
+
+  def setup
+    I18n.backend = I18n::Backend::SimpleStorage.new
+    @options = { :root_dir => @@fixtures_dir, :pattern => 'source_1.rb', :interactive => false }
+    FileUtils.cp_r(@@fixtures_dir, @@backup_dir)
+    @io = StringIO.new
+    @commands = I18n::Commands::Keys.new(nil, @io)
+  end
+
+  def teardown
+    FileUtils.rm_r(@@fixtures_dir)
+    FileUtils.mv(@@backup_dir, @@fixtures_dir)
+    I18n::Index.new.delete
+  end
+  
+  def source(filename)
+    File.read(@@fixtures_dir + "/#{filename}")
+  end
+
+  define_method :"test find command" do
+    key = 'baaar'
+    filename = 'source_1.rb'
+    @commands.find(key, @options)
+
+    assert_match @io.string, %r(indexing files)
+    assert_match @io.string, %r(#{key}:.*#{filename})
+  end
+
+  define_method :"test replace command" do
+    filename = 'source_1.rb'
+    I18n.load_path += Dir[@@fixtures_dir + '/locale/*.yml']
+    
+    assert_not_nil I18n.t(:foo)
+    assert_match %r(foo\.bar), source(filename)
+    assert_equal [:bar, :baaar, :"baz.fooo.baar", :"foo.bar", :bar_1], indexed_keys
+    
+    @commands.replace('foo.*', 'baz', @options)
+      
+    assert_equal({ :bar => 'Bar', :baz => 'Baz' }, I18n.t(:baz))
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:foo, :raise => true) }
+    assert_match %r(baz\.bar), source(filename)
+    assert_no_match %r(foo\.bar), source(filename)
+    assert_equal [:bar, :baaar, :"baz.fooo.baar", :bar_1, :"baz.bar"].sort, indexed_keys.sort
+      
+    @commands.replace('baz.bar', 'bazzz', @options)
+      
+    assert_equal 'Bar', I18n.t(:bazzz)
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:'baz.bar', :raise => true) }
+    assert_match %r(bazzz), source(filename)
+    assert_no_match %r(baz\.bar), source(filename)
+    assert_equal [:bar, :baaar, :"baz.fooo.baar", :bar_1, :"bazzz"].sort, indexed_keys.sort
+  end
+
+  protected
+  
+    def indexed_keys
+      I18n::Index.load_or_create(@options).keys.map(&:key)
+    end
+
+    def stub_output(target)
+      (class << target; self; end).class_eval do
+        attr_accessor :out
+        define_method(:puts) { |str| out.puts(str) }
+        define_method(:string) { out.string }
+      end
+      target.out = StringIO.new
+      target
+    end
+end

data/test/i18n/index/key_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+require 'i18n/index/simple'
+require 'yaml'
+
+class I18nIndexKeyTest < Test::Unit::TestCase
+  include I18n::Index
+  
+  define_method :"test matches? given no keys returns true" do
+    assert Key.new(:foo).send(:matches?)
+  end
+
+  define_method :"test matches? given a literally matching key returns true" do
+    assert Key.new(:foo).send(:matches?, :foo, :bar)
+  end
+
+  define_method :"test pattern with no wildcards" do
+    assert_equal /^foo\.bar$/, Key.send(:pattern, :'foo.bar')
+  end
+
+  define_method :"test pattern with a dot separated wildcard at the beginning" do
+    assert_equal /\.foo\.bar$/, Key.send(:pattern, :'*.foo.bar')
+  end
+
+  define_method :"test pattern with a dot separated wildcard at the end" do
+    assert_equal /^foo\.bar\./, Key.send(:pattern, :'foo.bar.*')
+  end
+
+  define_method :"test pattern with a dot separated wildcard at the beginning and end" do
+    assert_equal /\.foo\.bar\./, Key.send(:pattern, :'*.foo.bar.*')
+  end
+end

data/test/i18n/index/simple_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+require 'i18n/index'
+require 'yaml'
+
+class I18nIndexSimpleTest < Test::Unit::TestCase
+  def setup
+    @root_dir = File.dirname(__FILE__) + '/../../fixtures'
+    @filename = @root_dir + '/source_1.rb'
+    @index = I18n::Index::Simple.new(:root_dir => @root_dir, :pattern => File.basename(@filename))
+    FileUtils.cp(@filename, "#{@filename}.backup")
+  end
+
+  def teardown
+    @index.delete
+    FileUtils.mv("#{@filename}.backup", @filename)
+  end
+
+
+  def assert_valid_index(index)
+    assert_equal 'source_1.rb', index.pattern
+    assert_equal 'fixtures', File.basename(index.root_dir)
+
+    keys = [:baaar, :bar, :bar_1, :"baz.fooo.baar", :"foo.bar"]
+    assert_equal keys.sort, index.data.keys.map(&:key).sort
+    assert_equal 2, index.data[:bar][:occurences].size
+
+    occurence = index.send(:data)[:bar][:occurences].first
+    assert_equal :bar, occurence.key.key # yuck
+    assert_equal 'source_1.rb', File.basename(occurence.filename)
+    assert_equal [2, 4], occurence.position.to_a
+  end
+
+  define_method :"test data is built lazily" do
+    assert_valid_index(@index)
+  end
+
+  define_method :"test update builds and saves index" do
+    @index.update
+    index = I18n::Index::Simple.send(:load, :root_dir => @root_dir)
+    assert_valid_index(index)
+  end
+
+  define_method :"test finds a call" do
+    assert_equal 't(:bar)', @index.find_call(:bar).to_ruby
+  end
+
+  define_method :"test subsequently replaces keys" do
+    @index.update # build and save
+
+    call = @index.find_call(:bar)
+    assert call
+
+    @index.replace_key(call, :bar, :bazooh)
+    assert File.read(@filename) =~ /:bazooh/
+
+    index = I18n::Index::Simple.send(:load, :root_dir => @root_dir) # reload the index
+    call = index.find_call(:bar)
+    assert call
+
+    index.replace_key(call, :bar, :bazuuh)
+    assert File.read(@filename) =~ /:bazuuh/
+
+    index = I18n::Index::Simple.send(:load, :root_dir => @root_dir) # reload the index
+    assert_nil index.find_call(:bar)
+  end
+end