svenfuchs-i18n-tools 0.0.4 → 0.0.5

data/test/commands_test.rb

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

data/test/erb_parser_test.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'erb'
-
-class ErbParserTest < Test::Unit::TestCase
-  def setup
-    @erb = File.read("#{File.dirname(__FILE__)}/fixtures/template.html.erb")
-    @ruby = I18n::ErbParser.new.to_ruby(@erb)
-    @expected = <<-src
-   f.field_set do
-	   column do
-		   [:foo].each do |foo|
-				          t(:erb_1)
-		   end
-		    t(:erb_2)
-		   t(:'foo.erb_3')
-	   end
-   end
-    src
-  end
-
-  def test_sexp_filename
-    assert_equal @erb.length, @ruby.length
-    %w(erb_1 erb_2 foo.erb_3).each do |token|
-      assert @ruby.index(token)
-      assert_equal @erb.index(token), @ruby.index(token)
-    end
-    @expected.split("\n").each do |token|
-      assert @ruby.index(token)
-    end
-  end
-end

data/test/index_test.rb

@@ -1,135 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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