babelish 0.5.5 → 0.6.5

data/test/babelish/test_csv2android.rb

@@ -1,72 +0,0 @@
-require "test_helper"
-class TestCSV2Android < Test::Unit::TestCase
-
-  def test_converting_csv_to_xml
-    csv_file = "test/data/test_data.csv"
-    converter = Babelish::CSV2Android.new(csv_file, "English" => "en")
-    converter.convert
-    assert File.exist?("values-en/strings.xml"), "the ouptut file does not exist"
-
-    # clean up
-    system("rm -rf ./values-en")
-  end
-
-  def test_converting_csv_with_special_chars
-    csv_file = "test/data/android_special_chars.csv"
-    converter = Babelish::CSV2Android.new(csv_file, "german" => "de")
-    converter.convert
-    assert File.exist?("values-de/strings.xml"), "the ouptut file does not exist"
-    assert_equal File.read("test/data/android_special_chars_test_result.xml"), File.read("values-de/strings.xml")
-
-    # clean up
-    system("rm -rf ./values-de")
-  end
-
-  def test_converting_csv_to_dotstrings_one_output_option
-    csv_file = "test/data/test_data.csv"
-    single_file = "myApp.xml"
-    converter = Babelish::CSV2Android.new(
-      csv_file,
-      { "English" => "en" },
-      :output_basename => "myApp",
-      :ignore_lang_path => true
-    )
-    converter.convert
-    assert File.exist?(single_file), "the ouptut file does not exist"
-
-    # clean up
-    system("rm -rf ./" + single_file)
-  end
-
-  def test_converting_with_comments
-    csv_file = "test/data/test_data_with_comments.csv"
-    french_file = "values-fr/strings.xml"
-    expected_output = File.read("test/data/test_data_fr_with_comments.xml")
-    converter = Babelish::CSV2Android.new(
-      csv_file,
-      { "French" => "fr" },
-      :default_lang => "English",
-      :comments_column => 5
-    )
-    converter.convert
-    assert File.exist?(french_file), "the ouptut file does not exist"
-    result = File.read(french_file)
-    assert_equal expected_output, result
-
-    # clean up
-    system("rm -rf values-fr")
-  end
-
-  def test_converting_with_basename
-    csv_file = "test/data/test_data.csv"
-    converter = Babelish::CSV2Android.new(csv_file,
-                                          { "English" => "en" },
-                                          { output_basename: "super_strings" })
-    converter.convert
-    exist = File.exist?("values-en/super_strings.xml")
-    assert exist, "the ouptut file does not exist"
-
-    # clean up
-    system("rm -rf ./values-en")
-  end
-end

data/test/babelish/test_csv2base.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-class TestCsv2Base < Test::Unit::TestCase
-
-  def test_initialize
-    csv_filename = "file.csv"
-    excluded_states = ["German"]
-    state_column = "Local"
-    keys_column = 23
-    converter = Babelish::Csv2Base.new(csv_filename, {"English" => ["en"]}, {
-      :excluded_states => excluded_states,
-      :state_column => state_column,
-      :keys_column => keys_column })
-
-    assert_equal csv_filename, converter.csv_filename
-    assert_equal excluded_states, converter.excluded_states
-    assert_equal state_column, converter.state_column
-    assert_equal keys_column, converter.keys_column
-  end
-
-  def test_initialize_with_default_values
-    converter = Babelish::Csv2Base.new("file.csv", "English" => ["en"])
-    assert_not_nil converter.csv_filename
-  end
-
-  def test_initialize_with_custom_separator
-    converter = Babelish::Csv2Base.new("file.csv", { "English" => ["en"] }, { :csv_separator => ";" })
-    assert_not_nil converter.csv_filename
-  end
-
-  def test_create_file_from_path
-    test_file = "test_file.txt"
-    Babelish::Csv2Base.new("file.csv", "English" => ["en"]).create_file_from_path test_file
-    assert File.exist?(test_file)
-
-    # clean up
-    system("rm -rf ./" + test_file)
-  end
-
-  def test_get_row_format
-    expected_output = "\"test_key\" = \"test_value\""
-    output = Babelish::Csv2Base.new("file.csv", "English" => ["en"]).get_row_format("test_key", "test_value")
-    assert_equal expected_output, output
-  end
-end

data/test/babelish/test_csv2json.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-class TestCSV2JSON < Test::Unit::TestCase
-
-  def test_converting_csv_to_dotstrings
-    csv_file = "test/data/test_data.csv"
-    converter = Babelish::CSV2JSON.new(csv_file, 'English' => "en")
-    converter.convert
-    assert File.exist?("en.json"), "the ouptut file does not exist"
-
-    # clean up
-    system("rm -rf en.json")
-  end
-
-  def test_converting_csv_to_dotstrings_one_output_option
-    csv_file = "test/data/test_data.csv"
-    single_file = 'myfile.json'
-    converter = Babelish::CSV2JSON.new(csv_file,
-    {'English' => "en"},
-    :output_basename => 'myfile',
-    :ignore_lang_path => true)
-    converter.convert
-    assert File.exist?(single_file), "the ouptut file does not exist"
-
-    # clean up
-    system("rm -rf ./" + single_file)
-  end
-end

data/test/babelish/test_csv2php.rb

@@ -1,27 +0,0 @@
-require "test_helper"
-class TestCSV2Php < Test::Unit::TestCase
-
-  def test_converting_csv_to_dotstrings
-    csv_file = "test/data/test_data.csv"
-    converter = Babelish::CSV2Php.new(csv_file, 'English' => "en")
-    converter.convert
-    assert File.exist?("en/lang.php"), "the ouptut file does not exist"
-
-    # clean up
-    system("rm -rf ./en")
-  end
-
-  def test_converting_csv_to_dotstrings_one_output_option
-    csv_file = "test/data/test_data.csv"
-    single_file = 'myApp.php'
-    converter = Babelish::CSV2Php.new(csv_file,
-    {'English' => "en"},
-    :output_basename => 'myApp',
-    :ignore_lang_path => true)
-    converter.convert
-    assert File.exist?(single_file), "the ouptut file does not exist"
-
-    # clean up
-    system("rm -rf ./" + single_file)
-  end
-end

data/test/babelish/test_csv2strings.rb

@@ -1,154 +0,0 @@
-require 'test_helper'
-class TestCSV2Strings < Test::Unit::TestCase
-
-  def test_converting_csv_to_dotstrings
-    csv_file = "test/data/test_data.csv"
-    converter = Babelish::CSV2Strings.new(csv_file, 'English' => [:en])
-    converter.convert
-    assert File.exist?("en.lproj/Localizable.strings"), "the ouptut file does not exist"
-    system("rm -rf en.lproj/")
-  end
-
-  def test_converting_csv_to_dotstrings_one_output_option
-    csv_file = "test/data/test_data.csv"
-    single_file = 'myApp.strings'
-    converter = Babelish::CSV2Strings.new(csv_file,
-    {'English' => [:en]},
-    :output_basename => 'myApp',
-    :ignore_lang_path => true)
-    converter.convert
-    assert File.exist?(single_file), "the ouptut file does not exist"
-    system("rm -f #{single_file}")
-  end
-
-  def test_converting_csv_to_dotstrings_default_lang
-    expected_output = String.new(<<-EOS)
-"GREETINGS"      = "Buenos dias";
-"ANOTHER_STRING" = "testEN";
-    EOS
-    csv_file = "test/data/test_data_multiple_langs.csv"
-    spanish_file = "es.lproj/Localizable.strings"
-    converter = Babelish::CSV2Strings.new(csv_file,
-    {'English' => [:en], "French" => "fr", "German" => "de", "Spanish" => "es"},
-    :default_lang => "English")
-    converter.convert
-    assert File.exist?(spanish_file), "the ouptut file does not exist"
-    result = File.read(spanish_file)
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_csv_to_dotstrings_with_no_default_lang_is_empty
-    expected_output = String.new(<<-EOS)
-"GREETINGS"      = "Buenos dias";
-"ANOTHER_STRING" = "";
-    EOS
-    csv_file = "test/data/test_data_multiple_langs.csv"
-    spanish_file = "es.lproj/Localizable.strings"
-    converter = Babelish::CSV2Strings.new(csv_file,
-    {'English' => [:en], "French" => "fr", "German" => "de", "Spanish" => "es"})
-    converter.convert
-    assert File.exist?(spanish_file), "the ouptut file does not exist"
-    result = File.read(spanish_file)
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_csv_to_dotstrings_default_lang_to_key
-    expected_output = String.new(<<-EOS)
-"GREETINGS"      = "Buenos dias";
-"ANOTHER_STRING" = "ANOTHER_STRING";
-    EOS
-    csv_file = "test/data/test_data_multiple_langs.csv"
-    spanish_file = "es.lproj/Localizable.strings"
-    converter = Babelish::CSV2Strings.new(csv_file,
-    {'English' => [:en], "French" => "fr", "German" => "de", "Spanish" => "es"},
-    :default_lang => "variables")
-    converter.convert
-    assert File.exist?(spanish_file), "the ouptut file does not exist"
-    result = File.read(spanish_file)
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_csv_to_dotstrings_keys
-    expected_output = String.new(<<-EOS)
-"GREETINGS"      = "Buenos dias";
-"ANOTHER_STRING" = "ANOTHER_STRING";
-    EOS
-    csv_file = "test/data/test_data_multiple_langs.csv"
-    converter = Babelish::CSV2Strings.new(csv_file,
-    {'English' => [:en], "French" => "fr", "German" => "de", "Spanish" => "es"},
-    :default_lang => "variables")
-    converter.convert
-    assert !converter.keys.empty?
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_csv_to_dotstrings_with_percent
-    expected_output = String.new(<<-EOS)
-"GREETINGS"      = "hello_%@";
-"ANOTHER_STRING" = "hello";
-    EOS
-    csv_file = "test/data/test_data_with_percent.csv"
-    converter = Babelish::CSV2Strings.new(csv_file, "English" => [:en])
-    converter.convert
-    result = File.read("en.lproj/Localizable.strings")
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_csv_to_dotstrings_with_spaces
-    expected_output = String.new(<<-EOS)
-"GREETINGS "     = "hello ";
-"ANOTHER_STRING" = " my other string with space at begin";
-    EOS
-    csv_file = "test/data/test_data_with_spaces.csv"
-    converter = Babelish::CSV2Strings.new(csv_file, "English" => [:en])
-    converter.convert
-    result = File.read("en.lproj/Localizable.strings")
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_csv_to_dotstrings_with_percent_space
-    expected_output = String.new(<<-EOS)
-"GREETINGS"       = "you have %d points";
-"ANOTHER_STRING"  = "this is a string with 10% of juice";
-"ANOTHER_EXAMPLE" = "tu as fait 10% d'efforts";
-    EOS
-    csv_file = "test/data/test_data_with_percent_space.csv"
-    converter = Babelish::CSV2Strings.new(csv_file, "English" => [:en])
-    converter.convert
-    result = File.read("en.lproj/Localizable.strings")
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_csv_to_dotstrings_with_stripping_option
-    expected_output = String.new(<<-EOS)
-"GREETINGS"      = "hello";
-"ANOTHER_STRING" = "my other string with space at begin";
-    EOS
-    csv_file = "test/data/test_data_with_spaces.csv"
-    converter = Babelish::CSV2Strings.new(csv_file, {"English" => [:en]}, :stripping => true)
-    converter.convert
-    result = File.read("en.lproj/Localizable.strings")
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-
-  def test_converting_with_comments
-    csv_file = "test/data/test_data_with_comments.csv"
-    spanish_file = "fr.lproj/Localizable.strings"
-    expected_output = File.read("test/data/test_data_fr_with_comments.strings")
-    converter = Babelish::CSV2Strings.new(csv_file,
-    {"French" => "fr"},
-    :default_lang => "English", :comments_column => 5)
-    converter.convert
-    assert File.exist?(spanish_file), "the ouptut file does not exist"
-    result = File.read(spanish_file)
-    assert_equal expected_output, result
-    system("rm -rf *.lproj")
-  end
-end

data/test/babelish/test_json2csv.rb

@@ -1,34 +0,0 @@
-require 'test_helper'
-class JSON2CSVTest < Test::Unit::TestCase
-
-  def test_load_strings_with_wrong_file
-    assert_raise(Errno::ENOENT) do
-      output = Babelish::JSON2CSV.new.load_strings "file that does not exist.strings"
-    end
-  end
-
-  def test_load_strings
-    expected_output = {"app_name" => "json2csv", "action_greetings" => "hello", "ANOTHER_STRING" => "testEN", "empty" => ""}
-    output = Babelish::JSON2CSV.new.load_strings "test/data/json.json"
-    assert_equal expected_output, output
-  end
-
-  def test_initialize
-    csv_filename = "file.csv"
-    filenames = %w{"french.strings english.strings"}
-    headers = %w{"constants french english"}
-    converter = Babelish::JSON2CSV.new({
-      :csv_filename => csv_filename,
-      :headers => headers,
-      :filenames => filenames })
-
-    assert_equal csv_filename, converter.csv_filename
-    assert_equal headers, converter.headers
-    assert_equal filenames, converter.filenames
-  end
-
-  def test_initialize_with_default_values
-    converter = Babelish::JSON2CSV.new
-    assert_not_nil converter.csv_filename
-  end
-end

data/test/babelish/test_php2csv.rb

@@ -1,73 +0,0 @@
-require 'test_helper'
-class TestPhp2CSV < Test::Unit::TestCase
-
-  def test_parse_dotstrings_line_with_good_string
-    input = String.new(<<-EOS)
-    $lang['MY_CONSTANT'] = "This is ok";
-    EOS
-    expected_output = {"MY_CONSTANT" => "This is ok"}
-
-    output = Babelish::Php2CSV.new.parse_dotstrings_line input
-    assert_equal output, expected_output
-  end
-
-  def test_parse_dotstrings_line_with_single_quote
-    input = String.new(<<-EOS)
-    $lang['MY_CONSTANT'] = "This 'is' ok";
-    EOS
-    expected_output = {"MY_CONSTANT" => "This 'is' ok"}
-
-    output = Babelish::Php2CSV.new.parse_dotstrings_line input
-    assert_equal output, expected_output
-  end
-
-  def test_parse_dotstrings_line_with_double_quotes
-    input = String.new(<<-EOS)
-    $lang['MY_CONSTANT'] = "This "is" ok";
-    EOS
-    expected_output = {"MY_CONSTANT" => "This \"is\" ok"}
-
-    output = Babelish::Php2CSV.new.parse_dotstrings_line input
-    assert_equal output, expected_output
-  end
-
-  def test_parse_dotstrings_line_with_wrong_string
-    input = String.new(<<-EOS)
-    $lang['MY_CONSTANT'] = "wrong syntax"
-    EOS
-
-    output = Babelish::Php2CSV.new.parse_dotstrings_line input
-    assert_nil output, "output should be nil with wrong syntax"
-  end
-
-  def test_load_strings_with_wrong_file
-    assert_raise(Errno::ENOENT) do
-      output = Babelish::Php2CSV.new.load_strings "file that does not exist.strings"
-    end
-  end
-
-  def test_load_strings
-    expected_output = {"app_name" => "php2csv", "action_greetings" => "Hello", "ANOTHER_STRING" => "testEN", "empty" => ""}
-    output = Babelish::Php2CSV.new.load_strings "test/data/php_lang.php"
-    assert_equal expected_output, output
-  end
-
-  def test_initialize
-    csv_filename = "file.csv"
-    filenames = %w{"french.php english.php"}
-    headers = %w{"constants french english"}
-    converter = Babelish::Php2CSV.new({
-      :csv_filename => csv_filename,
-      :headers => headers,
-      :filenames => filenames })
-
-    assert_equal csv_filename, converter.csv_filename
-    assert_equal headers, converter.headers
-    assert_equal filenames, converter.filenames
-  end
-
-  def test_initialize_with_default_values
-    converter = Babelish::Php2CSV.new
-    assert_not_nil converter.csv_filename
-  end
-end

data/test/babelish/test_strings2csv.rb

@@ -1,147 +0,0 @@
-require 'test_helper'
-class TestStrings2CSV < Test::Unit::TestCase
-
-  def test_parse_dotstrings_line_with_good_string
-    input = String.new(<<-EOS)
-    "MY_CONSTANT" = "This is ok";
-    EOS
-    expected_output = ["MY_CONSTANT","This is ok"]
-
-    output = Babelish::Strings2CSV.new.parse_dotstrings_line input
-    assert_equal expected_output, output
-  end
-
-  def test_parse_dotstrings_line_with_single_quote
-    input = String.new(<<-EOS)
-    "MY_CONSTANT" = "This 'is' ok";
-    EOS
-    expected_output = ["MY_CONSTANT","This 'is' ok"]
-
-    output = Babelish::Strings2CSV.new.parse_dotstrings_line input
-    assert_equal expected_output, output
-  end
-
-  def test_parse_dotstrings_line_with_double_quotes
-    input = String.new(<<-EOS)
-    "MY_CONSTANT" = "This "is" ok";
-    EOS
-    expected_output = ["MY_CONSTANT","This \"is\" ok"]
-
-    output = Babelish::Strings2CSV.new.parse_dotstrings_line input
-    assert_equal expected_output, output
-  end
-
-  def test_parse_dotstrings_line_with_wrong_string
-    input = String.new(<<-EOS)
-    "MY_CONSTANT" = "wrong syntax"
-    EOS
-
-    output = Babelish::Strings2CSV.new.parse_dotstrings_line input
-    assert_nil output, "output should be nil with wrong syntax"
-  end
-
-  def test_parse_dotstrings_line_with_comment
-    input = String.new(<<-EOS)
-    /* Class = "IBUIButton"; normalTitle = "Wibble"; ObjectID = "xxx-xx-123"; */
-    EOS
-
-    output = Babelish::Strings2CSV.new.parse_dotstrings_line input
-    assert_nil output, "output should be nil with comment"
-  end
-
-  def test_parse_comment
-    comment= "/* this is a comment */"
-    output = Babelish::Strings2CSV.new.parse_comment_line comment
-    assert_equal "this is a comment", output
-  end
-
-  def test_load_strings_with_wrong_file
-    assert_raise(Errno::ENOENT) do
-      output = Babelish::Strings2CSV.new.load_strings "file that does not exist.strings"
-    end
-  end
-
-  def test_load_strings
-    expected_output = [{"ERROR_HANDLER_WARNING_DISMISS" => "OK", "ANOTHER_STRING" => "hello"}, {}]
-    output = Babelish::Strings2CSV.new.load_strings "test/data/test_data.strings"
-    assert_equal expected_output, output
-  end
-
-  def test_load_strings_with_spaces
-    expected_output = [{ "name" => "definition",
-                         "name1" => "definition1",
-                         "name2" => "definition2",
-                         "name3" => "definition3",
-                         "name4" => "definition4",
-                         "this is a name" => "a definition"
-                      }, {}]
-    output = Babelish::Strings2CSV.new.load_strings "test/data/test_space.strings"
-    assert_equal expected_output, output
-  end
-
-  def test_load_strings_with_comments
-    expected_output = [{"MY_CONSTANT"=>"This 'is' ok"}, {"MY_CONSTANT"=> "this is a comment"}]
-
-    output = Babelish::Strings2CSV.new.load_strings "test/data/test_comments.strings"
-    assert_equal expected_output, output
-  end
-
-  def test_load_strings_with_empty_lines
-    assert_nothing_raised do
-      output = Babelish::Strings2CSV.new.load_strings "test/data/test_with_nil.strings"
-    end
-  end
-
-  def test_load_strings_with_empty_lines_and_comments
-    assert_nothing_raised do
-      output = Babelish::Strings2CSV.new.load_strings "test/data/xcode_empty.strings"
-    end
-  end
-
-  def test_load_strings_with_genstrings_file
-    assert_nothing_raised do
-      output = Babelish::Strings2CSV.new.load_strings "test/data/genstrings.strings"
-    end
-  end
-
-  def test_dotstrings_to_csv
-    converter = Babelish::Strings2CSV.new(:filenames => ["test/data/test_data.strings"])
-    keys, strings = converter.convert(false)
-    assert_equal ["ERROR_HANDLER_WARNING_DISMISS", "ANOTHER_STRING"], keys
-
-  end
-
-  def test_create_csv_file
-    keys = ["ERROR_HANDLER_WARNING_DISMISS", "ANOTHER_STRING"]
-    filename = "test_data"
-    strings = {filename => {"ERROR_HANDLER_WARNING_DISMISS" => "OK", "ANOTHER_STRING" => "hello"}}
-
-    converter = Babelish::Strings2CSV.new(:headers => %w{variables english}, :filenames => [filename])
-
-    converter.send :create_csv_file, keys, strings
-    assert File.exist?(converter.csv_filename)
-
-    # clean up
-    system("rm -rf ./" + converter.csv_filename)
-  end
-
-  def test_initialize
-    csv_filename = "file.csv"
-    filenames = %w{french.strings english.strings}
-    headers = %w{constants french english}
-    converter = Babelish::Strings2CSV.new({
-      :csv_filename => csv_filename,
-      :headers => headers,
-      :filenames => filenames })
-
-      assert_equal csv_filename, converter.csv_filename
-      assert_equal headers, converter.headers
-      assert_equal filenames, converter.filenames
-    end
-
-  def test_initialize_with_default_values
-    converter = Babelish::Strings2CSV.new
-    assert_not_nil converter.csv_filename
-  end
-
-end