twine 0.7.0 → 0.8.0

data/test/test_generate_all_string_files.rb

@@ -0,0 +1,44 @@
+require 'command_test_case'
+
+class TestGenerateAllStringFiles < CommandTestCase
+  class TestCreateFolders < CommandTestCase
+    def new_runner(create_folders)
+      options = {}
+      options[:output_path] = @output_dir
+      options[:format] = 'apple'
+      options[:create_folders] = create_folders
+
+      @twine_file = build_twine_file 'en', 'es' do
+        add_section 'Section' do
+          add_row key: 'value'
+        end
+      end
+
+      Twine::Runner.new(options, @twine_file)
+    end
+
+    def test_fails_if_output_folder_does_not_exist
+      assert_raises Twine::Error do
+        new_runner(false).generate_all_string_files
+      end
+    end
+
+    def test_creates_output_folder
+      FileUtils.remove_entry_secure @output_dir
+      new_runner(true).generate_all_string_files
+      assert File.exists? @output_dir
+    end
+
+    def test_does_not_create_language_folders_by_default
+      Dir.mkdir File.join @output_dir, 'en.lproj'
+      new_runner(false).generate_all_string_files
+      refute File.exists?(File.join(@output_dir, 'es.lproj')), "language folder should not be created"
+    end
+
+    def test_creates_language_folders
+      new_runner(true).generate_all_string_files
+      assert File.exists?(File.join(@output_dir, 'en.lproj')), "language folder 'en.lproj' should be created"
+      assert File.exists?(File.join(@output_dir, 'es.lproj')), "language folder 'es.lproj' should be created"
+    end
+  end
+end

data/test/test_generate_loc_drop.rb

@@ -0,0 +1,44 @@
+require 'command_test_case'
+
+class TestGenerateLocDrop < CommandTestCase
+  def setup
+    super
+
+    options = {}
+    options[:output_path] = @output_path
+    options[:format] = 'apple'
+
+    @twine_file = build_twine_file 'en', 'fr' do
+      add_section 'Section' do
+        add_row key: 'value'
+      end
+    end
+
+    @runner = Twine::Runner.new(options, @twine_file)
+  end
+
+  def test_generates_zip_file
+    @runner.generate_loc_drop
+
+    assert File.exists?(@output_path), "language folder should not be created"
+  end
+
+  def test_zip_file_structure
+    @runner.generate_loc_drop
+
+    names = []
+    Zip::File.open(@output_path) do |zipfile|
+      zipfile.each do |entry|
+        names << entry.name
+      end
+    end
+    assert_equal ['Locales/', 'Locales/en.strings', 'Locales/fr.strings'], names
+  end
+
+  def test_uses_formatter
+    formatter = prepare_mock_formatter Twine::Formatters::Apple
+    formatter.expects(:write_file).twice.with() { |path, lang| FileUtils.touch path }
+
+    @runner.generate_loc_drop
+  end
+end

data/test/test_generate_string_file.rb

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

data/test/test_output_processor.rb

@@ -0,0 +1,85 @@
+require 'twine_test_case'
+
+class TestOutputProcessor < TwineTestCase
+  def setup
+    super
+
+    @strings = build_twine_file 'en', 'fr' do
+      add_section 'Section' do
+        add_row key1: 'value1', tags: ['tag1']
+        add_row key2: 'value2', tags: ['tag1', 'tag2']
+        add_row key3: 'value3', tags: ['tag2']
+        add_row key4: { en: 'value4-en', fr: 'value4-fr' }
+      end
+    end
+  end
+
+  def test_includes_all_keys_by_default
+    processor = Twine::Processors::OutputProcessor.new(@strings, {})
+    result = processor.process('en')
+
+    assert_equal %w(key1 key2 key3 key4), result.strings_map.keys.sort
+  end
+
+  def test_filter_by_tag
+    processor = Twine::Processors::OutputProcessor.new(@strings, { tags: ['tag1'] })
+    result = processor.process('en')
+
+    assert_equal %w(key1 key2), result.strings_map.keys.sort
+  end
+
+  def test_filter_by_multiple_tags
+    processor = Twine::Processors::OutputProcessor.new(@strings, { tags: ['tag1', 'tag2'] })
+    result = processor.process('en')
+
+    assert_equal %w(key1 key2 key3), result.strings_map.keys.sort
+  end
+
+  def test_filter_untagged
+    processor = Twine::Processors::OutputProcessor.new(@strings, { tags: ['tag1'], untagged: true })
+    result = processor.process('en')
+
+    assert_equal %w(key1 key2 key4), result.strings_map.keys.sort
+  end
+
+  def test_include_translated
+    processor = Twine::Processors::OutputProcessor.new(@strings, { include: 'translated' })
+    result = processor.process('fr')
+
+    assert_equal %w(key4), result.strings_map.keys.sort
+  end
+
+  def test_include_untranslated
+    processor = Twine::Processors::OutputProcessor.new(@strings, { include: 'untranslated' })
+    result = processor.process('fr')
+
+    assert_equal %w(key1 key2 key3), result.strings_map.keys.sort
+  end
+
+  class TranslationFallback < TwineTestCase
+    def setup
+      super
+
+      @strings = build_twine_file 'en', 'fr', 'de' do
+        add_section 'Section' do
+          add_row key1: { en: 'value1-en', fr: 'value1-fr' }
+        end
+      end
+    end
+
+    def test_fallback_to_default_language
+      processor = Twine::Processors::OutputProcessor.new(@strings, {})
+      result = processor.process('de')
+      
+      assert_equal 'value1-en', result.strings_map['key1'].translations['de']
+    end
+
+    def test_fallback_to_developer_language
+      processor = Twine::Processors::OutputProcessor.new(@strings, {developer_language: 'fr'})
+      result = processor.process('de')
+      
+      assert_equal 'value1-fr', result.strings_map['key1'].translations['de']
+    end
+  end
+
+end

data/test/test_placeholders.rb

@@ -0,0 +1,86 @@
+require 'twine_test_case'
+
+class PlaceholderTestCase < TwineTestCase
+  def assert_starts_with(prefix, value)
+    msg = message(nil) { "Expected #{mu_pp(value)} to start with #{mu_pp(prefix)}" }
+    assert value.start_with?(prefix), msg
+  end
+
+  def placeholder(type = nil)
+    # %[parameter][flags][width][.precision][length]type (see https://en.wikipedia.org/wiki/Printf_format_string#Format_placeholder_specification)
+    lucky = lambda { rand > 0.5 }
+    placeholder = '%'
+    placeholder += (rand * 20).to_i.to_s + '$' if lucky.call
+    placeholder += '-+ 0#'.chars.to_a.sample if lucky.call
+    placeholder += (0.upto(20).map(&:to_s) << "*").sample if lucky.call
+    placeholder += '.' + (0.upto(20).map(&:to_s) << "*").sample if lucky.call
+    placeholder += %w(h hh l ll L z j t).sample if lucky.call
+    placeholder += type || 'diufFeEgGxXocpaA'.chars.to_a.sample # this does not contain s or @ because strings are a special case
+  end
+end
+
+class PlaceholderTest < TwineTestCase
+  class ToAndroid < PlaceholderTestCase
+    def to_android(value)
+      Twine::Placeholders.convert_placeholders_from_twine_to_android(value)
+    end
+
+    def test_replaces_string_placeholder
+      placeholder = placeholder('@')
+      expected = placeholder
+      expected[-1] = 's'
+      assert_equal "some #{expected} value", to_android("some #{placeholder} value")
+    end
+
+    def test_does_not_change_regular_at_signs
+      input = "some @ more @@ signs @"
+      assert_equal input, to_android(input)
+    end
+
+    def test_does_not_modify_single_percent_signs
+      assert_equal "some % value", to_android("some % value")
+    end
+
+    def test_escapes_single_percent_signs_if_placeholder_present
+      assert_starts_with "some %% v", to_android("some % value #{placeholder}")
+    end
+
+    def test_does_not_modify_double_percent_signs
+      assert_equal "some %% value", to_android("some %% value")
+    end
+
+    def test_does_not_modify_double_percent_signs_if_placeholder_present
+      assert_starts_with "some %% v", to_android("some %% value #{placeholder}")
+    end
+
+    def test_does_not_modify_single_placeholder
+      input = "some #{placeholder} text"
+      assert_equal input, to_android(input)
+    end
+
+    def test_numbers_multiple_placeholders
+      assert_equal "first %1$d second %2$f", to_android("first %d second %f")
+    end
+
+    def test_does_not_modify_numbered_placeholders
+      input = "second %2$f first %1$d"
+      assert_equal input, to_android(input)
+    end
+
+    def test_raises_an_error_when_mixing_numbered_and_non_numbered_placeholders
+      assert_raises Twine::Error do
+        to_android("some %d second %2$f")
+      end
+    end
+  end
+
+  class FromAndroid < PlaceholderTestCase
+    def from_android(value)
+      Twine::Placeholders.convert_placeholders_from_android_to_twine(value)
+    end
+
+    def test_replaces_string_placeholder
+      assert_equal "some %@ value", from_android("some %s value")
+    end
+  end
+end

data/test/test_strings_file.rb

@@ -0,0 +1,58 @@
+require 'twine_test_case'
+
+class TestStringsFile < TwineTestCase
+  class Reading < TwineTestCase
+    def setup
+      super
+
+      @strings = Twine::StringsFile.new
+      @strings.read fixture('twine_accent_values.txt')
+    end
+
+    def test_reading_keeps_leading_accent
+      assert_equal '`value', @strings.strings_map['value_with_leading_accent'].translations['en']
+    end
+
+    def test_reading_keeps_trailing_accent
+      assert_equal 'value`', @strings.strings_map['value_with_trailing_accent'].translations['en']
+    end
+
+    def test_reading_keeps_leading_space
+      assert_equal ' value', @strings.strings_map['value_with_leading_space'].translations['en']
+    end
+
+    def test_reading_keeps_trailing_space
+      assert_equal 'value ', @strings.strings_map['value_with_trailing_space'].translations['en']
+    end
+
+    def test_reading_keeps_wrapping_spaces
+      assert_equal ' value ', @strings.strings_map['value_wrapped_by_spaces'].translations['en']
+    end
+
+    def test_reading_keeps_wrapping_accents
+      assert_equal '`value`', @strings.strings_map['value_wrapped_by_accents'].translations['en']
+    end
+  end
+
+  class Writing < TwineTestCase
+
+    def test_accent_wrapping
+      @strings = build_twine_file 'en' do
+        add_section 'Section' do
+          add_row value_with_leading_accent: '`value'
+          add_row value_with_trailing_accent: 'value`'
+          add_row value_with_leading_space: ' value'
+          add_row value_with_trailing_space: 'value '
+          add_row value_wrapped_by_spaces: ' value '
+          add_row value_wrapped_by_accents: '`value`'
+        end
+      end
+
+      @strings.write @output_path
+
+      assert_equal content('twine_accent_values.txt'), output_content
+    end
+
+  end
+
+end

data/test/test_strings_row.rb

@@ -0,0 +1,47 @@
+require 'twine_test_case'
+
+class TestStringsRow < TwineTestCase
+  def setup
+    super
+
+    @reference = Twine::StringsRow.new 'reference-key'
+    @reference.comment = 'reference comment'
+    @reference.tags = ['ref1']
+    @reference.translations['en'] = 'ref-value'
+
+    @row = Twine::StringsRow.new 'key'
+    @row.reference_key = @reference.key
+    @row.reference = @reference
+  end
+
+  def test_reference_comment_used
+    assert_equal 'reference comment', @row.comment
+  end
+
+  def test_reference_comment_override
+    @row.comment = 'row comment'
+
+    assert_equal 'row comment', @row.comment
+  end
+
+  def test_reference_tags_used
+    assert @row.matches_tags?(['ref1'], false)
+  end
+
+  def test_reference_tags_override
+    @row.tags = ['tag1']
+
+    refute @row.matches_tags?(['ref1'], false)
+    assert @row.matches_tags?(['tag1'], false)
+  end
+
+  def test_reference_translation_used
+    assert_equal 'ref-value', @row.translated_string_for_lang('en')
+  end
+
+  def test_reference_translation_override
+    @row.translations['en'] = 'value'
+
+    assert_equal 'value', @row.translated_string_for_lang('en')
+  end
+end

data/test/test_validate_strings_file.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'command_test_case'
+
+class TestValidateStringsFile < CommandTestCase
+  def setup
+    super
+    @options = { strings_file: 'input.txt' }
+
+    @twine_file = build_twine_file 'en' do
+      add_section 'Section 1' do
+        add_row key1: 'value1', tags: ['tag1']
+        add_row key2: 'value2', tags: ['tag1']
+      end
+
+      add_section 'Section 2' do
+        add_row key3: 'value3', tags: ['tag1', 'tag2']
+        add_row key4: 'value4', tags: ['tag2']
+      end
+    end
+  end
+
+  def random_row
+    @twine_file.strings_map[@twine_file.strings_map.keys.sample]
+  end
+
+  def test_recognizes_valid_file
+    Twine::Runner.new(@options, @twine_file).validate_strings_file
+    assert_equal "input.txt is valid.\n", Twine::stdout.string
+  end
+
+  def test_reports_duplicate_keys
+    @twine_file.sections[0].rows << random_row
+
+    assert_raises Twine::Error do
+      Twine::Runner.new(@options, @twine_file).validate_strings_file
+    end
+  end
+
+  def test_reports_missing_tags
+    random_row.tags.clear
+
+    assert_raises Twine::Error do
+      Twine::Runner.new(@options, @twine_file).validate_strings_file
+    end
+  end
+
+  def test_reports_invalid_characters_in_keys
+    random_row.key[0] = "!?;:,^`´'\"\\|/(){}[]~-+*=#$%".chars.to_a.sample
+
+    assert_raises Twine::Error do
+      Twine::Runner.new(@options, @twine_file).validate_strings_file
+    end
+  end
+end