yury-twine 0.9.1

data/test/test_generate_all_localization_files.rb

@@ -0,0 +1,102 @@
+require 'command_test'
+
+class TestGenerateAllLocalizationFiles < CommandTest
+  def new_runner(create_folders, twine_file = nil)
+    options = {}
+    options[:output_path] = @output_dir
+    options[:format] = 'apple'
+    options[:create_folders] = create_folders
+
+    unless twine_file
+      twine_file = build_twine_file 'en', 'es' do
+        add_section 'Section' do
+          add_definition key: 'value'
+        end
+      end
+    end
+
+    Twine::Runner.new(options, twine_file)
+  end
+
+  class TestDoNotCreateFolders < TestGenerateAllLocalizationFiles
+    def new_runner(twine_file = nil)
+      super(false, twine_file)
+    end
+
+    def test_fails_if_output_folder_does_not_exist
+      assert_raises Twine::Error do
+        new_runner.generate_all_localization_files
+      end
+    end
+
+    def test_does_not_create_language_folders
+      Dir.mkdir File.join @output_dir, 'en.lproj'
+      new_runner.generate_all_localization_files
+      refute File.exists?(File.join(@output_dir, 'es.lproj')), "language folder should not be created"
+    end
+
+    def test_prints_empty_file_warnings
+      Dir.mkdir File.join @output_dir, 'en.lproj'
+      empty_twine_file = build_twine_file('en') {}
+      new_runner(empty_twine_file).generate_all_localization_files
+      assert_match "Skipping file at path", Twine::stderr.string
+    end
+  end
+
+  class TestCreateFolders < TestGenerateAllLocalizationFiles
+    def new_runner(twine_file = nil)
+      super(true, twine_file)
+    end
+
+    def test_creates_output_folder
+      FileUtils.remove_entry_secure @output_dir
+      new_runner.generate_all_localization_files
+      assert File.exists? @output_dir
+    end
+
+    def test_creates_language_folders
+      new_runner.generate_all_localization_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
+
+    def test_prints_empty_file_warnings
+      empty_twine_file = build_twine_file('en') {}
+      new_runner(empty_twine_file).generate_all_localization_files
+
+      assert_match "Skipping file at path", Twine::stderr.string
+    end
+  end
+
+  class TestValidate < CommandTest
+    def new_runner(validate)
+      Dir.mkdir File.join @output_dir, 'values-en'
+
+      options = {}
+      options[:output_path] = @output_dir
+      options[:format] = 'android'
+      options[:validate] = validate
+
+      twine_file = build_twine_file 'en' do
+        add_section 'Section' do
+          add_definition key: 'value'
+          add_definition key: 'value'
+        end
+      end
+
+      Twine::Runner.new(options, twine_file)
+    end
+
+    def test_does_not_validate_twine_file
+      prepare_mock_formatter Twine::Formatters::Android
+
+      new_runner(false).generate_all_localization_files
+    end
+
+    def test_validates_twine_file_if_validate
+      assert_raises Twine::Error do
+        new_runner(true).generate_all_localization_files
+      end
+    end
+  end
+end

data/test/test_generate_loc_drop.rb

@@ -0,0 +1,80 @@
+require 'command_test'
+
+class TestGenerateLocDrop < CommandTest
+  def new_runner(twine_file = nil)
+    options = {}
+    options[:output_path] = @output_path
+    options[:format] = 'apple'
+
+    unless twine_file
+      twine_file = build_twine_file 'en', 'fr' do
+        add_section 'Section' do
+          add_definition key: 'value'
+        end
+      end
+    end
+
+    Twine::Runner.new(options, twine_file)
+  end
+
+  def test_generates_zip_file
+    new_runner.generate_loc_drop
+
+    assert File.exists?(@output_path), "zip file should exist"
+  end
+
+  def test_zip_file_structure
+    new_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(:format_file).twice
+
+    new_runner.generate_loc_drop
+  end
+
+  def test_prints_empty_file_warnings
+    empty_twine_file = build_twine_file('en') {}
+    new_runner(empty_twine_file).generate_loc_drop
+    assert_match "Skipping file", Twine::stderr.string
+  end
+
+  class TestValidate < CommandTest
+    def new_runner(validate)
+      options = {}
+      options[:output_path] = @output_path
+      options[:format] = 'android'
+      options[:validate] = validate
+
+      twine_file = build_twine_file 'en' do
+        add_section 'Section' do
+          add_definition key: 'value'
+          add_definition key: 'value'
+        end
+      end
+
+      Twine::Runner.new(options, twine_file)
+    end
+
+    def test_does_not_validate_twine_file
+      prepare_mock_formatter Twine::Formatters::Android
+
+      new_runner(false).generate_loc_drop
+    end
+
+    def test_validates_twine_file_if_validate
+      assert_raises Twine::Error do
+        new_runner(true).generate_loc_drop
+      end
+    end
+  end
+end

data/test/test_generate_localization_file.rb

@@ -0,0 +1,91 @@
+require 'command_test'
+
+class TestGenerateLocalizationFile < CommandTest
+  def new_runner(language, file)
+    options = {}
+    options[:output_path] = File.join(@output_dir, file) if file
+    options[:languages] = language if language
+
+    twine_file = Twine::TwineFile.new
+    twine_file.language_codes.concat KNOWN_LANGUAGES
+
+    Twine::Runner.new(options, twine_file)
+  end
+
+  def prepare_mock_format_file_formatter(formatter_class)
+    formatter = prepare_mock_formatter(formatter_class)
+    formatter.expects(:format_file).returns(true)
+  end
+
+  def test_deducts_android_format_from_output_path
+    prepare_mock_format_file_formatter Twine::Formatters::Android
+
+    new_runner('fr', 'fr.xml').generate_localization_file
+  end
+
+  def test_deducts_apple_format_from_output_path
+    prepare_mock_format_file_formatter Twine::Formatters::Apple
+
+    new_runner('fr', 'fr.strings').generate_localization_file
+  end
+
+  def test_deducts_jquery_format_from_output_path
+    prepare_mock_format_file_formatter Twine::Formatters::JQuery
+
+    new_runner('fr', 'fr.json').generate_localization_file
+  end
+
+  def test_deducts_gettext_format_from_output_path
+    prepare_mock_format_file_formatter Twine::Formatters::Gettext
+
+    new_runner('fr', 'fr.po').generate_localization_file
+  end
+
+  def test_deducts_language_from_output_path
+    random_language = KNOWN_LANGUAGES.sample
+    formatter = prepare_mock_formatter Twine::Formatters::Android
+    formatter.expects(:format_file).with(random_language).returns(true)
+
+    new_runner(nil, "#{random_language}.xml").generate_localization_file
+  end
+
+  def test_returns_error_if_nothing_written
+    formatter = prepare_mock_formatter Twine::Formatters::Android
+    formatter.expects(:format_file).returns(false)
+
+    assert_raises Twine::Error do
+      new_runner('fr', 'fr.xml').generate_localization_file
+    end
+  end
+
+  class TestValidate < CommandTest
+    def new_runner(validate)
+      options = {}
+      options[:output_path] = @output_path
+      options[:languages] = ['en']
+      options[:format] = 'android'
+      options[:validate] = validate
+
+      twine_file = build_twine_file 'en' do
+        add_section 'Section' do
+          add_definition key: 'value'
+          add_definition key: 'value'
+        end
+      end
+
+      Twine::Runner.new(options, twine_file)
+    end
+
+    def test_does_not_validate_twine_file
+      prepare_mock_formatter Twine::Formatters::Android
+
+      new_runner(false).generate_localization_file
+    end
+
+    def test_validates_twine_file_if_validate
+      assert_raises Twine::Error do
+        new_runner(true).generate_localization_file
+      end
+    end
+  end
+end

data/test/test_output_processor.rb

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

data/test/test_placeholders.rb

@@ -0,0 +1,84 @@
+require 'twine_test'
+
+class PlaceholderTest < TwineTest
+  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
+
+  class ToAndroid < PlaceholderTest
+    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 < PlaceholderTest
+    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_twine_definition.rb

@@ -0,0 +1,111 @@
+require 'twine_test'
+
+class TestTwineDefinition < TwineTest
+  class TestTags < TwineTest
+    def setup
+      super
+      @definition = Twine::TwineDefinition.new 'key'
+    end
+
+    def test_include_untagged
+      assert @definition.matches_tags?([[rand(100000).to_s]], true)
+    end
+
+    def test_matches_no_given_tags
+      assert @definition.matches_tags?([], false)
+    end
+
+    def test_matches_tag
+      @definition.tags = ['tag1']
+
+      assert @definition.matches_tags?([['tag1']], false)
+    end
+
+    def test_matches_any_tag
+      @definition.tags = ['tag1']
+
+      assert @definition.matches_tags?([['tag0', 'tag1', 'tag2']], false)
+    end
+
+    def test_matches_all_tags
+      @definition.tags = ['tag1', 'tag2']
+
+      assert @definition.matches_tags?([['tag1'], ['tag2']], false)
+    end
+
+    def test_does_not_match_all_tags
+      @definition.tags = ['tag1']
+
+      refute @definition.matches_tags?([['tag1'], ['tag2']], false)
+    end
+
+    def test_does_not_match_excluded_tag
+      @definition.tags = ['tag1']
+
+      refute @definition.matches_tags?([['~tag1']], false)
+    end
+
+    def test_matches_excluded_tag
+      @definition.tags = ['tag2']
+
+      assert @definition.matches_tags?([['~tag1']], false)
+    end
+
+    def test_complex_rules
+      @definition.tags = ['tag1', 'tag2', 'tag3']
+
+      assert @definition.matches_tags?([['tag1']], false)
+      assert @definition.matches_tags?([['tag1', 'tag4']], false)
+      assert @definition.matches_tags?([['tag1'], ['tag2'], ['tag3']], false)
+      refute @definition.matches_tags?([['tag1'], ['tag4']], false)
+
+      assert @definition.matches_tags?([['tag4', '~tag5']], false)
+    end
+  end
+
+  class TestReferences < TwineTest
+    def setup
+      super
+
+      @reference = Twine::TwineDefinition.new 'reference-key'
+      @reference.comment = 'reference comment'
+      @reference.tags = ['ref1']
+      @reference.translations['en'] = 'ref-value'
+
+      @definition = Twine::TwineDefinition.new 'key'
+      @definition.reference_key = @reference.key
+      @definition.reference = @reference
+    end
+
+    def test_reference_comment_used
+      assert_equal 'reference comment', @definition.comment
+    end
+
+    def test_reference_comment_override
+      @definition.comment = 'definition comment'
+
+      assert_equal 'definition comment', @definition.comment
+    end
+
+    def test_reference_tags_used
+      assert @definition.matches_tags?([['ref1']], false)
+    end
+
+    def test_reference_tags_override
+      @definition.tags = ['tag1']
+
+      refute @definition.matches_tags?([['ref1']], false)
+      assert @definition.matches_tags?([['tag1']], false)
+    end
+
+    def test_reference_translation_used
+      assert_equal 'ref-value', @definition.translation_for_lang('en')
+    end
+
+    def test_reference_translation_override
+      @definition.translations['en'] = 'value'
+
+      assert_equal 'value', @definition.translation_for_lang('en')
+    end
+  end
+end