twine 0.7.0 → 0.8.0

data/test/test_cli.rb

@@ -0,0 +1,288 @@
+require 'twine_test_case'
+
+class CLITestCase < TwineTestCase
+  def setup
+    super
+
+    @strings_file_path = File.join @output_dir, SecureRandom.uuid
+    @input_path = File.join @output_dir, SecureRandom.uuid
+    @input_dir = @output_dir
+  end
+
+  def parse(command)
+    @options = Twine::CLI::parse command.split
+  end
+
+  class TestValidateStringsFile < CLITestCase
+    def test_command
+      parse "validate-strings-file #{@strings_file_path}"
+
+      assert_equal 'validate-strings-file', @options[:command]
+      assert_equal @strings_file_path, @options[:strings_file]
+    end
+
+    def test_missing_parameter
+      assert_raises Twine::Error do
+        parse 'validate-strings-file'
+      end
+    end
+
+    def test_extra_parameter
+      assert_raises Twine::Error do
+        parse 'validate-strings-file strings extra'
+      end
+    end
+  end
+
+  class TestGenerateStringFile < CLITestCase
+    def test_command
+      parse "generate-string-file #{@strings_file_path} #{@output_path}"
+
+      assert_equal 'generate-string-file', @options[:command]
+      assert_equal @strings_file_path, @options[:strings_file]
+      assert_equal @output_path, @options[:output_path]
+    end
+
+    def test_missing_parameter
+      assert_raises Twine::Error do
+        parse 'generate-string-file strings'
+      end
+    end
+
+    def test_extra_parameter
+      assert_raises Twine::Error do
+        parse 'generate-string-file strings output extra'
+      end
+    end
+
+    def test_only_allows_one_language
+      assert_raises Twine::Error do
+        parse "generate-string-file strings output --lang en,fr"
+      end
+    end
+  end
+
+  class TestGenerateAllStringFiles < CLITestCase
+    def test_command
+      parse "generate-all-string-files #{@strings_file_path} #{@output_dir}"
+
+      assert_equal 'generate-all-string-files', @options[:command]
+      assert_equal @strings_file_path, @options[:strings_file]
+      assert_equal @output_dir, @options[:output_path]
+    end
+
+    def test_missing_parameter
+      assert_raises Twine::Error do
+        parse "generate-all-string-files strings"
+      end
+    end
+
+    def test_extra_parameter
+      assert_raises Twine::Error do
+        parse "generate-all-string-files strings output extra"
+      end
+    end
+  end
+
+  class TestConsumeStringFile < CLITestCase
+    def test_command
+      parse "consume-string-file #{@strings_file_path} #{@input_path}"
+
+      assert_equal 'consume-string-file', @options[:command]
+      assert_equal @strings_file_path, @options[:strings_file]
+      assert_equal @input_path, @options[:input_path]
+    end
+
+    def test_missing_parameter
+      assert_raises Twine::Error do
+        parse "consume-string-file strings"
+      end
+    end
+
+    def test_extra_parameter
+      assert_raises Twine::Error do
+        parse "consume-string-file strings output extra"
+      end
+    end
+
+    def test_only_allows_one_language
+      assert_raises Twine::Error do
+        parse "consume-string-file strings output --lang en,fr"
+      end
+    end
+  end
+
+  class TestConsumeAllStringFiles < CLITestCase
+    def test_command
+      parse "consume-all-string-files #{@strings_file_path} #{@input_dir}"
+
+      assert_equal 'consume-all-string-files', @options[:command]
+      assert_equal @strings_file_path, @options[:strings_file]
+      assert_equal @input_dir, @options[:input_path]
+    end
+
+    def test_missing_parameter
+      assert_raises Twine::Error do
+        parse "consume-all-string-files strings"
+      end
+    end
+
+    def test_extra_parameter
+      assert_raises Twine::Error do
+        parse "consume-all-string-files strings output extra"
+      end
+    end
+  end
+
+  class TestGenerateLocDrop < CLITestCase
+    def test_command
+      parse "generate-loc-drop #{@strings_file_path} #{@output_path} --format apple"
+
+      assert_equal 'generate-loc-drop', @options[:command]
+      assert_equal @strings_file_path, @options[:strings_file]
+      assert_equal @output_path, @options[:output_path]
+    end
+
+    def test_missing_parameter
+      assert_raises Twine::Error do
+        parse "generate-loc-drop strings --format apple"
+      end
+    end
+
+    def test_extra_parameter
+      assert_raises Twine::Error do
+        parse "generate-loc-drop strings output extra --format apple"
+      end
+    end
+
+    def test_format_needed
+      assert_raises Twine::Error do
+        parse "generate-loc-drop strings output"
+      end
+    end
+  end
+
+  class TestConsumeLocDrop < CLITestCase
+    def test_command
+      parse "consume-loc-drop #{@strings_file_path} #{@input_path}"
+
+      assert_equal 'consume-loc-drop', @options[:command]
+      assert_equal @strings_file_path, @options[:strings_file]
+      assert_equal @input_path, @options[:input_path]
+    end
+
+    def test_missing_parameter
+      assert_raises Twine::Error do
+        parse "consume-loc-drop strings"
+      end
+    end
+
+    def test_extra_parameter
+      assert_raises Twine::Error do
+        parse "consume-loc-drop strings input extra"
+      end
+    end
+  end
+
+  class TestParameters < CLITestCase
+    def parse_with(parameter)
+      parse 'validate-strings-file input.txt ' + parameter
+    end
+
+    def test_default_options
+      parse_with ''
+      expected = {command: 'validate-strings-file', strings_file: 'input.txt', include: "all"}
+      assert_equal expected, @options
+    end
+
+    def test_create_folders
+      parse_with '--create-folders'
+      assert @options[:create_folders]
+    end
+
+    def test_consume_all
+      parse_with '--consume-all'
+      assert @options[:consume_all]
+    end
+
+    def test_consume_comments
+      parse_with '--consume-comments'
+      assert @options[:consume_comments]
+    end
+
+    def test_untagged
+      parse_with '--untagged'
+      assert @options[:untagged]
+    end
+
+    def test_developer_language
+      random_language = KNOWN_LANGUAGES.sample
+      parse_with "--developer-lang #{random_language}"
+      assert_equal random_language, @options[:developer_language]
+    end
+
+    def test_single_language
+      random_language = KNOWN_LANGUAGES.sample
+      parse_with "--lang #{random_language}"
+      assert_equal [random_language], @options[:languages]
+    end
+
+    def test_multiple_languages
+      random_languages = KNOWN_LANGUAGES.shuffle[0, 3]
+      parse_with "--lang #{random_languages.join(',')}"
+      assert_equal random_languages.sort, @options[:languages].sort
+    end
+
+    def test_single_tag
+      random_tag = "tag#{rand(100)}"
+      parse_with "--tags #{random_tag}"
+      assert_equal [random_tag], @options[:tags]
+    end
+
+    def test_multiple_tags
+      random_tags = ([nil] * 3).map { "tag#{rand(100)}" }
+      parse_with "--tags #{random_tags.join(',')}"
+      assert_equal random_tags.sort, @options[:tags].sort
+    end
+
+    def test_format
+      random_format = Twine::Formatters.formatters.sample::FORMAT_NAME
+      parse_with "--format #{random_format}"
+      assert_equal random_format, @options[:format]
+    end
+
+    def test_format_ignores_case
+      random_format = Twine::Formatters.formatters.sample::FORMAT_NAME
+      parse_with "--format #{random_format.upcase}"
+      assert_equal random_format, @options[:format]
+    end
+
+    def test_include
+      random_set = ['all', 'translated', 'untranslated'].sample
+      parse_with "--include #{random_set}"
+      assert_equal random_set, @options[:include]
+    end
+
+    def test_include_ignores_case
+      random_set = ['all', 'translated', 'untranslated'].sample
+      parse_with "--include #{random_set.upcase}"
+      assert_equal random_set, @options[:include]
+    end
+
+    def test_output_path
+      parse_with "--output-file #{@output_path}"
+      assert_equal @output_path, @options[:output_path]
+    end
+
+    def test_file_name
+      random_filename = "#{rand(10000)}"
+      parse_with "--file-name #{random_filename}"
+      assert_equal random_filename, @options[:file_name]
+    end
+
+    def test_encoding
+      parse_with '--encoding UTF16'
+      assert_equal 'UTF16', @options[:output_encoding]
+    end
+  end
+end

data/test/test_consume_loc_drop.rb

@@ -0,0 +1,27 @@
+require 'command_test_case'
+
+class TestConsumeLocDrop < CommandTestCase
+  def setup
+    super
+
+    options = {}
+    options[:input_path] = fixture 'consume_loc_drop.zip'
+    options[:output_path] = @output_path
+    options[:format] = 'apple'
+
+    @twine_file = build_twine_file 'en', 'es' do
+      add_section 'Section' do
+        add_row key1: 'value1'
+      end
+    end
+
+    @runner = Twine::Runner.new(options, @twine_file)
+  end
+
+  def test_consumes_zip_file
+    @runner.consume_loc_drop
+
+    assert @twine_file.strings_map['key1'].translations['en'], 'value1-english'
+    assert @twine_file.strings_map['key1'].translations['es'], 'value1-spanish'
+  end
+end

data/test/test_consume_string_file.rb

@@ -0,0 +1,53 @@
+require 'command_test_case'
+
+class TestConsumeStringFile < CommandTestCase
+  def new_runner(language, file)
+    options = {}
+    options[:output_path] = File.join(@output_dir, file) if file
+    options[:input_path] = File.join(@output_dir, file) if file
+    FileUtils.touch options[:input_path]
+    options[:languages] = language if language
+
+    @strings = Twine::StringsFile.new
+    @strings.language_codes.concat KNOWN_LANGUAGES
+
+    Twine::Runner.new(options, @strings)
+  end
+
+  def prepare_mock_read_file_formatter(formatter_class)
+    formatter = prepare_mock_formatter(formatter_class)
+    formatter.expects(:read_file)
+  end
+
+  def test_deducts_android_format_from_output_path
+    prepare_mock_read_file_formatter Twine::Formatters::Android
+
+    new_runner('fr', 'fr.xml').consume_string_file
+  end
+
+  def test_deducts_apple_format_from_output_path
+    prepare_mock_read_file_formatter Twine::Formatters::Apple
+
+    new_runner('fr', 'fr.strings').consume_string_file
+  end
+
+  def test_deducts_jquery_format_from_output_path
+    prepare_mock_read_file_formatter Twine::Formatters::JQuery
+
+    new_runner('fr', 'fr.json').consume_string_file
+  end
+
+  def test_deducts_gettext_format_from_output_path
+    prepare_mock_read_file_formatter Twine::Formatters::Gettext
+
+    new_runner('fr', 'fr.po').consume_string_file
+  end
+
+  def test_deducts_language_from_input_path
+    random_language = KNOWN_LANGUAGES.sample
+    formatter = prepare_mock_formatter Twine::Formatters::Android
+    formatter.expects(:read_file).with(anything, random_language)
+
+    new_runner(nil, "#{random_language}.xml").consume_string_file
+  end
+end

data/test/test_formatters.rb

@@ -0,0 +1,236 @@
+require 'twine_test_case'
+
+class FormatterTest < TwineTestCase
+  def setup(formatter_class)
+    super()
+
+    @twine_file = build_twine_file 'en' do
+      add_section 'Section 1' do
+        add_row key1: 'value1-english', comment: 'comment key1'
+        add_row key2: 'value2-english'
+      end
+
+      add_section 'Section 2' do
+        add_row key3: 'value3-english'
+        add_row key4: 'value4-english', comment: 'comment key4'
+      end
+    end
+
+    @strings = Twine::StringsFile.new
+    @formatter = formatter_class.new @strings, { consume_all: true, consume_comments: true }
+  end
+
+  def assert_translations_read_correctly
+    1.upto(4) do |i|
+      assert_equal "value#{i}-english", @strings.strings_map["key#{i}"].translations['en']
+    end
+  end
+
+  def assert_file_contents_read_correctly
+    assert_translations_read_correctly
+
+    assert_equal "comment key1", @strings.strings_map["key1"].comment
+    assert_equal "comment key4", @strings.strings_map["key4"].comment
+  end
+end
+
+class TestAndroidFormatter < FormatterTest
+  def setup
+    super Twine::Formatters::Android
+  end
+
+  def test_read_file_format
+    @formatter.read_file fixture('formatter_android.xml'), 'en'
+
+    assert_file_contents_read_correctly
+  end
+
+  def test_set_translation_converts_leading_spaces
+    @formatter.set_translation_for_key 'key1', 'en', "\u0020value"
+    assert_equal ' value', @strings.strings_map['key1'].translations['en']
+  end
+
+  def test_set_translation_coverts_trailing_spaces
+    @formatter.set_translation_for_key 'key1', 'en', "value\u0020\u0020"
+    assert_equal 'value  ', @strings.strings_map['key1'].translations['en']
+  end
+
+  def test_set_translation_converts_string_placeholders
+    @formatter.set_translation_for_key 'key1', 'en', "value %s"
+    assert_equal 'value %@', @strings.strings_map['key1'].translations['en']
+  end
+
+  def test_set_translation_unescapes_at_signs
+    @formatter.set_translation_for_key 'key1', 'en', '\@value'
+    assert_equal '@value', @strings.strings_map['key1'].translations['en']
+  end
+
+  def test_write_file_output_format
+    formatter = Twine::Formatters::Android.new @twine_file, {}
+    formatter.write_file @output_path, 'en'
+    assert_equal content('formatter_android.xml'), output_content
+  end
+
+  def test_format_key_with_space
+    assert_equal 'key ', @formatter.format_key('key ')
+  end
+
+  def test_format_value_with_leading_space
+    assert_equal "\\u0020value", @formatter.format_value(' value')
+  end
+
+  def test_format_value_with_trailing_space
+    assert_equal "value\\u0020", @formatter.format_value('value ')
+  end
+
+  def test_format_value_escapes_single_quotes
+    skip 'not working with ruby 2.0'
+    # http://stackoverflow.com/questions/18735608/cgiescapehtml-is-escaping-single-quote
+    assert_equal "not \\'so\\' easy", @formatter.format_value("not 'so' easy")
+  end
+
+  def test_format_value_escapes_non_resource_identifier_at_signs
+    assert_equal '\@whatever  \@\@', @formatter.format_value('@whatever  @@')
+  end
+
+  def test_format_value_does_not_modify_resource_identifiers
+    identifier = '@android:string/cancel'
+    assert_equal identifier, @formatter.format_value(identifier)
+  end
+end
+
+class TestAppleFormatter < FormatterTest
+  def setup
+    super Twine::Formatters::Apple
+  end
+
+  def test_read_file_format
+    @formatter.read_file fixture('formatter_apple.strings'), 'en'
+
+    assert_file_contents_read_correctly
+  end
+
+  def test_write_file_output_format
+    formatter = Twine::Formatters::Apple.new @twine_file, {}
+    formatter.write_file @output_path, 'en'
+    assert_equal content('formatter_apple.strings'), output_content
+  end
+
+  def test_format_key_with_space
+    assert_equal 'key ', @formatter.format_key('key ')
+  end
+
+  def test_format_value_with_leading_space
+    assert_equal ' value', @formatter.format_value(' value')
+  end
+
+  def test_format_value_with_trailing_space
+    assert_equal 'value ', @formatter.format_value('value ')
+  end
+end
+
+class TestJQueryFormatter < FormatterTest
+
+  def setup
+    super Twine::Formatters::JQuery
+  end
+
+  def test_read_file_format
+    @formatter.read_file fixture('formatter_jquery.json'), 'en'
+
+    assert_translations_read_correctly
+  end
+
+  def test_write_file_output_format
+    formatter = Twine::Formatters::JQuery.new @twine_file, {}
+    formatter.write_file @output_path, 'en'
+    assert_equal content('formatter_jquery.json'), output_content
+  end
+
+  def test_format_value_with_newline
+    assert_equal "value\nwith\nline\nbreaks", @formatter.format_value("value\nwith\nline\nbreaks")
+  end
+end
+
+class TestGettextFormatter < FormatterTest
+
+  def setup
+    super Twine::Formatters::Gettext
+  end
+
+  def test_read_file_format
+    @formatter.read_file fixture('formatter_gettext.po'), 'en'
+
+    assert_file_contents_read_correctly
+  end
+
+  def test_read_file_with_multiple_line_value
+    @formatter.read_file fixture('gettext_multiline.po'), 'en'
+
+    assert_equal 'multiline\nstring', @strings.strings_map['key1'].translations['en']
+  end
+
+  def test_write_file_output_format
+    formatter = Twine::Formatters::Gettext.new @twine_file, {}
+    formatter.write_file @output_path, 'en'
+    assert_equal content('formatter_gettext.po'), output_content
+  end
+
+end
+
+class TestTizenFormatter < FormatterTest
+
+  def setup
+    super Twine::Formatters::Tizen
+  end
+
+  def test_read_file_format
+    skip 'the current implementation of Tizen formatter does not support read_file'
+    @formatter.read_file fixture('formatter_tizen.xml'), 'en'
+
+    assert_file_contents_read_correctly
+  end
+
+  def test_write_file_output_format
+    formatter = Twine::Formatters::Tizen.new @twine_file, {}
+    formatter.write_file @output_path, 'en'
+    assert_equal content('formatter_tizen.xml'), output_content
+  end
+
+end
+
+class TestDjangoFormatter < FormatterTest
+  def setup
+    super Twine::Formatters::Django
+  end
+
+  def test_read_file_format
+    @formatter.read_file fixture('formatter_django.po'), 'en'
+
+    assert_file_contents_read_correctly
+  end
+
+  def test_write_file_output_format
+    formatter = Twine::Formatters::Django.new @twine_file, {}
+    formatter.write_file @output_path, 'en'
+    assert_equal content('formatter_django.po'), output_content
+  end
+end
+
+class TestFlashFormatter < FormatterTest
+  def setup
+    super Twine::Formatters::Flash
+  end
+
+  def test_read_file_format
+    @formatter.read_file fixture('formatter_flash.properties'), 'en'
+
+    assert_file_contents_read_correctly
+  end
+
+  def test_write_file_output_format
+    formatter = Twine::Formatters::Flash.new @twine_file, {}
+    formatter.write_file @output_path, 'en'
+    assert_equal content('formatter_flash.properties'), output_content
+  end
+end