twine 0.9.1 → 0.10.0

data/test/{test_generate_all_string_files.rb → test_generate_all_localization_files.rb}

@@ -1,6 +1,6 @@
-require 'command_test_case'
+require 'command_test'
 
-class TestGenerateAllStringFiles < CommandTestCase
+class TestGenerateAllLocalizationFiles < CommandTest
   def new_runner(create_folders, twine_file = nil)
     options = {}
     options[:output_path] = @output_dir
@@ -10,7 +10,7 @@ class TestGenerateAllStringFiles < CommandTestCase
     unless twine_file
       twine_file = build_twine_file 'en', 'es' do
         add_section 'Section' do
-          add_row key: 'value'
+          add_definition key: 'value'
         end
       end
     end
@@ -18,57 +18,57 @@ class TestGenerateAllStringFiles < CommandTestCase
     Twine::Runner.new(options, twine_file)
   end
 
-  class TestDoNotCreateFolders < TestGenerateAllStringFiles
+  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_string_files
+        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_string_files
+      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_string_files
+      new_runner(empty_twine_file).generate_all_localization_files
       assert_match "Skipping file at path", Twine::stderr.string
     end
   end
 
-  class TestCreateFolders < TestGenerateAllStringFiles
+  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_string_files
+      new_runner.generate_all_localization_files
       assert File.exists? @output_dir
     end
 
     def test_creates_language_folders
-      new_runner.generate_all_string_files
+      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_string_files
+      new_runner(empty_twine_file).generate_all_localization_files
 
       assert_match "Skipping file at path", Twine::stderr.string
     end
   end
 
-  class TestValidate < CommandTestCase
+  class TestValidate < CommandTest
     def new_runner(validate)
       Dir.mkdir File.join @output_dir, 'values-en'
 
@@ -79,23 +79,23 @@ class TestGenerateAllStringFiles < CommandTestCase
 
       twine_file = build_twine_file 'en' do
         add_section 'Section' do
-          add_row key: 'value'
-          add_row key: 'value'
+          add_definition key: 'value'
+          add_definition key: 'value'
         end
       end
 
       Twine::Runner.new(options, twine_file)
     end
 
-    def test_does_not_validate_strings_file
+    def test_does_not_validate_twine_file
       prepare_mock_formatter Twine::Formatters::Android
 
-      new_runner(false).generate_all_string_files
+      new_runner(false).generate_all_localization_files
     end
 
-    def test_validates_strings_file_if_validate
+    def test_validates_twine_file_if_validate
       assert_raises Twine::Error do
-        new_runner(true).generate_all_string_files
+        new_runner(true).generate_all_localization_files
       end
     end
   end

data/test/{test_generate_loc_drop.rb → test_generate_localization_archive.rb}

@@ -1,6 +1,6 @@
-require 'command_test_case'
+require 'command_test'
 
-class TestGenerateLocDrop < CommandTestCase
+class TestGenerateLocalizationArchive < CommandTest
   def new_runner(twine_file = nil)
     options = {}
     options[:output_path] = @output_path
@@ -9,7 +9,7 @@ class TestGenerateLocDrop < CommandTestCase
     unless twine_file
       twine_file = build_twine_file 'en', 'fr' do
         add_section 'Section' do
-          add_row key: 'value'
+          add_definition key: 'value'
         end
       end
     end
@@ -18,13 +18,13 @@ class TestGenerateLocDrop < CommandTestCase
   end
 
   def test_generates_zip_file
-    new_runner.generate_loc_drop
+    new_runner.generate_localization_archive
 
     assert File.exists?(@output_path), "zip file should exist"
   end
 
   def test_zip_file_structure
-    new_runner.generate_loc_drop
+    new_runner.generate_localization_archive
 
     names = []
     Zip::File.open(@output_path) do |zipfile|
@@ -39,16 +39,16 @@ class TestGenerateLocDrop < CommandTestCase
     formatter = prepare_mock_formatter Twine::Formatters::Apple
     formatter.expects(:format_file).twice
 
-    new_runner.generate_loc_drop
+    new_runner.generate_localization_archive
   end
 
   def test_prints_empty_file_warnings
     empty_twine_file = build_twine_file('en') {}
-    new_runner(empty_twine_file).generate_loc_drop
+    new_runner(empty_twine_file).generate_localization_archive
     assert_match "Skipping file", Twine::stderr.string
   end
 
-  class TestValidate < CommandTestCase
+  class TestValidate < CommandTest
     def new_runner(validate)
       options = {}
       options[:output_path] = @output_path
@@ -57,23 +57,23 @@ class TestGenerateLocDrop < CommandTestCase
 
       twine_file = build_twine_file 'en' do
         add_section 'Section' do
-          add_row key: 'value'
-          add_row key: 'value'
+          add_definition key: 'value'
+          add_definition key: 'value'
         end
       end
 
       Twine::Runner.new(options, twine_file)
     end
 
-    def test_does_not_validate_strings_file
+    def test_does_not_validate_twine_file
       prepare_mock_formatter Twine::Formatters::Android
 
-      new_runner(false).generate_loc_drop
+      new_runner(false).generate_localization_archive
     end
 
-    def test_validates_strings_file_if_validate
+    def test_validates_twine_file_if_validate
       assert_raises Twine::Error do
-        new_runner(true).generate_loc_drop
+        new_runner(true).generate_localization_archive
       end
     end
   end

data/test/{test_generate_string_file.rb → test_generate_localization_file.rb}

@@ -1,15 +1,15 @@
-require 'command_test_case'
+require 'command_test'
 
-class TestGenerateStringFile < CommandTestCase
+class TestGenerateLocalizationFile < CommandTest
   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_file = Twine::TwineFile.new
+    twine_file.language_codes.concat KNOWN_LANGUAGES
 
-    Twine::Runner.new(options, strings)
+    Twine::Runner.new(options, twine_file)
   end
 
   def prepare_mock_format_file_formatter(formatter_class)
@@ -20,25 +20,25 @@ class TestGenerateStringFile < CommandTestCase
   def test_deducts_android_format_from_output_path
     prepare_mock_format_file_formatter Twine::Formatters::Android
 
-    new_runner('fr', 'fr.xml').generate_string_file
+    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_string_file
+    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_string_file
+    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_string_file
+    new_runner('fr', 'fr.po').generate_localization_file
   end
 
   def test_deducts_language_from_output_path
@@ -46,7 +46,7 @@ class TestGenerateStringFile < CommandTestCase
     formatter = prepare_mock_formatter Twine::Formatters::Android
     formatter.expects(:format_file).with(random_language).returns(true)
 
-    new_runner(nil, "#{random_language}.xml").generate_string_file
+    new_runner(nil, "#{random_language}.xml").generate_localization_file
   end
 
   def test_returns_error_if_nothing_written
@@ -54,11 +54,11 @@ class TestGenerateStringFile < CommandTestCase
     formatter.expects(:format_file).returns(false)
 
     assert_raises Twine::Error do
-      new_runner('fr', 'fr.xml').generate_string_file
+      new_runner('fr', 'fr.xml').generate_localization_file
     end
   end
 
-  class TestValidate < CommandTestCase
+  class TestValidate < CommandTest
     def new_runner(validate)
       options = {}
       options[:output_path] = @output_path
@@ -68,23 +68,23 @@ class TestGenerateStringFile < CommandTestCase
 
       twine_file = build_twine_file 'en' do
         add_section 'Section' do
-          add_row key: 'value'
-          add_row key: 'value'
+          add_definition key: 'value'
+          add_definition key: 'value'
         end
       end
 
       Twine::Runner.new(options, twine_file)
     end
 
-    def test_does_not_validate_strings_file
+    def test_does_not_validate_twine_file
       prepare_mock_formatter Twine::Formatters::Android
 
-      new_runner(false).generate_string_file
+      new_runner(false).generate_localization_file
     end
 
-    def test_validates_strings_file_if_validate
+    def test_validates_twine_file_if_validate
       assert_raises Twine::Error do
-        new_runner(true).generate_string_file
+        new_runner(true).generate_localization_file
       end
     end
   end

data/test/test_output_processor.rb

@@ -1,84 +1,84 @@
-require 'twine_test_case'
+require 'twine_test'
 
-class TestOutputProcessor < TwineTestCase
+class TestOutputProcessor < TwineTest
   def setup
     super
 
-    @strings = build_twine_file 'en', 'fr' do
+    @twine_file = 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' }
+        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(@strings, {})
+    processor = Twine::Processors::OutputProcessor.new(@twine_file, {})
     result = processor.process('en')
 
-    assert_equal %w(key1 key2 key3 key4), result.strings_map.keys.sort
+    assert_equal %w(key1 key2 key3 key4), result.definitions_by_key.keys.sort
   end
 
   def test_filter_by_tag
-    processor = Twine::Processors::OutputProcessor.new(@strings, { tags: ['tag1'] })
+    processor = Twine::Processors::OutputProcessor.new(@twine_file, { tags: [['tag1']] })
     result = processor.process('en')
 
-    assert_equal %w(key1 key2), result.strings_map.keys.sort
+    assert_equal %w(key1 key2), result.definitions_by_key.keys.sort
   end
 
   def test_filter_by_multiple_tags
-    processor = Twine::Processors::OutputProcessor.new(@strings, { tags: ['tag1', 'tag2'] })
+    processor = Twine::Processors::OutputProcessor.new(@twine_file, { tags: [['tag1', 'tag2']] })
     result = processor.process('en')
 
-    assert_equal %w(key1 key2 key3), result.strings_map.keys.sort
+    assert_equal %w(key1 key2 key3), result.definitions_by_key.keys.sort
   end
 
   def test_filter_untagged
-    processor = Twine::Processors::OutputProcessor.new(@strings, { tags: ['tag1'], untagged: true })
+    processor = Twine::Processors::OutputProcessor.new(@twine_file, { tags: [['tag1']], untagged: true })
     result = processor.process('en')
 
-    assert_equal %w(key1 key2 key4), result.strings_map.keys.sort
+    assert_equal %w(key1 key2 key4), result.definitions_by_key.keys.sort
   end
 
   def test_include_translated
-    processor = Twine::Processors::OutputProcessor.new(@strings, { include: :translated })
+    processor = Twine::Processors::OutputProcessor.new(@twine_file, { include: :translated })
     result = processor.process('fr')
 
-    assert_equal %w(key4), result.strings_map.keys.sort
+    assert_equal %w(key4), result.definitions_by_key.keys.sort
   end
 
   def test_include_untranslated
-    processor = Twine::Processors::OutputProcessor.new(@strings, { include: :untranslated })
+    processor = Twine::Processors::OutputProcessor.new(@twine_file, { include: :untranslated })
     result = processor.process('fr')
 
-    assert_equal %w(key1 key2 key3), result.strings_map.keys.sort
+    assert_equal %w(key1 key2 key3), result.definitions_by_key.keys.sort
   end
 
-  class TranslationFallback < TwineTestCase
+  class TranslationFallback < TwineTest
     def setup
       super
 
-      @strings = build_twine_file 'en', 'fr', 'de' do
+      @twine_file = build_twine_file 'en', 'fr', 'de' do
         add_section 'Section' do
-          add_row key1: { en: 'value1-en', fr: 'value1-fr' }
+          add_definition key1: { en: 'value1-en', fr: 'value1-fr' }
         end
       end
     end
 
     def test_fallback_to_default_language
-      processor = Twine::Processors::OutputProcessor.new(@strings, {})
+      processor = Twine::Processors::OutputProcessor.new(@twine_file, {})
       result = processor.process('de')
       
-      assert_equal 'value1-en', result.strings_map['key1'].translations['de']
+      assert_equal 'value1-en', result.definitions_by_key['key1'].translations['de']
     end
 
     def test_fallback_to_developer_language
-      processor = Twine::Processors::OutputProcessor.new(@strings, {developer_language: 'fr'})
+      processor = Twine::Processors::OutputProcessor.new(@twine_file, {developer_language: 'fr'})
       result = processor.process('de')
       
-      assert_equal 'value1-fr', result.strings_map['key1'].translations['de']
+      assert_equal 'value1-fr', result.definitions_by_key['key1'].translations['de']
     end
   end
 

data/test/test_placeholders.rb

@@ -1,6 +1,6 @@
-require 'twine_test_case'
+require 'twine_test'
 
-class PlaceholderTestCase < TwineTestCase
+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
@@ -11,23 +11,25 @@ class PlaceholderTestCase < TwineTestCase
     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#'.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
+  class ToAndroid < PlaceholderTest
     def to_android(value)
       Twine::Placeholders.convert_placeholders_from_twine_to_android(value)
     end
 
-    def test_replaces_string_placeholder
+    def test_replaces_simple_string_placeholder
+      assert_equal "some '%s' value", to_android("some '%@' value")
+    end
+
+    def test_replaces_complicated_string_placeholder
       placeholder = placeholder('@')
-      expected = placeholder
+      expected = placeholder.dup
       expected[-1] = 's'
       assert_equal "some #{expected} value", to_android("some #{placeholder} value")
     end
@@ -41,6 +43,11 @@ class PlaceholderTest < TwineTestCase
       assert_equal "some % value", to_android("some % value")
     end
 
+    def test_does_not_modify_single_percent_signs_when_followed_by_space_and_format_letter
+      # Said differently: formartter parser should not recognize %a in "70% and"
+      assert_equal 'If 70% and 30% dog 80% end', to_android('If 70% and 30% dog 80% end')
+    end
+
     def test_escapes_single_percent_signs_if_placeholder_present
       assert_starts_with "some %% v", to_android("some % value #{placeholder}")
     end
@@ -74,7 +81,7 @@ class PlaceholderTest < TwineTestCase
     end
   end
 
-  class FromAndroid < PlaceholderTestCase
+  class FromAndroid < PlaceholderTest
     def from_android(value)
       Twine::Placeholders.convert_placeholders_from_android_to_twine(value)
     end
@@ -83,4 +90,32 @@ class PlaceholderTest < TwineTestCase
       assert_equal "some %@ value", from_android("some %s value")
     end
   end
+
+  class ToFlash < PlaceholderTest
+    def to_flash(value)
+      Twine::Placeholders.convert_placeholders_from_twine_to_flash(value)
+    end
+
+    def test_replaces_placeholder
+      assert_equal "some {0} text", to_flash("some #{placeholder} text")
+    end
+
+    def test_replaces_string_placeholder
+      assert_equal "some {0} text", to_flash("some #{placeholder('@')} text")
+    end
+
+    def test_numbers_placeholders
+      assert_equal "some {0} more {1} text {2}", to_flash("some #{placeholder('@')} more #{placeholder('@')} text #{placeholder('@')}")
+    end
+  end
+
+  class FromFlash < PlaceholderTest
+    def from_flash(value)
+      Twine::Placeholders.convert_placeholders_from_flash_to_twine(value)
+    end
+
+    def test_maps_all_placeholders_to_string
+      assert_equal "some %@ more %@ text %@", from_flash("some {0} more {1} text {2}")
+    end
+  end
 end