twine 0.8.1 → 0.9.0

data/lib/twine/version.rb

@@ -1,3 +1,3 @@
 module Twine
-  VERSION = '0.8.1'
+  VERSION = '0.9.0'
 end

data/test/fixtures/enc_utf8.dummy

@@ -0,0 +1,2 @@
+Üß`
+da

data/test/test_cli.rb

@@ -211,7 +211,7 @@ class CLITestCase < TwineTestCase
 
     def test_default_options
       parse_with ''
-      expected = {command: 'validate-strings-file', strings_file: 'input.txt', include: "all"}
+      expected = {command: 'validate-strings-file', strings_file: 'input.txt', include: :all}
       assert_equal expected, @options
     end
 
@@ -266,29 +266,17 @@ class CLITestCase < TwineTestCase
     end
 
     def test_format
-      random_format = Twine::Formatters.formatters.sample.format_name
+      random_format = Twine::Formatters.formatters.sample.format_name.downcase
       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
+      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]

data/test/test_consume_loc_drop.rb

@@ -5,7 +5,7 @@ class TestConsumeLocDrop < CommandTestCase
     super
 
     options = {}
-    options[:input_path] = fixture 'consume_loc_drop.zip'
+    options[:input_path] = fixture_path 'consume_loc_drop.zip'
     options[:output_path] = @output_path
     options[:format] = 'apple'
 

data/test/test_consume_string_file.rb

@@ -14,31 +14,31 @@ class TestConsumeStringFile < CommandTestCase
     Twine::Runner.new(options, @strings)
   end
 
-  def prepare_mock_read_file_formatter(formatter_class)
+  def prepare_mock_read_formatter(formatter_class)
     formatter = prepare_mock_formatter(formatter_class)
-    formatter.expects(:read_file)
+    formatter.expects(:read)
   end
 
   def test_deducts_android_format_from_output_path
-    prepare_mock_read_file_formatter Twine::Formatters::Android
+    prepare_mock_read_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
+    prepare_mock_read_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
+    prepare_mock_read_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
+    prepare_mock_read_formatter Twine::Formatters::Gettext
 
     new_runner('fr', 'fr.po').consume_string_file
   end
@@ -46,8 +46,74 @@ class TestConsumeStringFile < CommandTestCase
   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)
+    formatter.expects(:read).with(anything, random_language)
 
     new_runner(nil, "#{random_language}.xml").consume_string_file
   end
+
+  class TestEncodings < CommandTestCase
+    class DummyFormatter < Twine::Formatters::Abstract
+      attr_reader :content
+
+      def extension
+        '.dummy'
+      end
+
+      def format_name
+        'dummy'
+      end
+
+      def read(io, lang)
+        @content = io.read
+      end
+    end
+
+    def new_runner(input_path, encoding = nil)
+      options = {}
+      options[:output_path] = @output_path
+      options[:input_path] = input_path
+      options[:encoding] = encoding if encoding
+      options[:languages] = 'en'
+
+      @strings = Twine::StringsFile.new
+      @strings.language_codes.concat KNOWN_LANGUAGES
+
+      Twine::Runner.new(options, @strings)
+    end
+
+    def setup
+      super
+      @expected_content = "Üß`\nda\n"
+    end
+
+    def test_reads_utf8
+      formatter = prepare_mock_formatter DummyFormatter
+      new_runner(fixture_path('enc_utf8.dummy')).consume_string_file
+      assert_equal @expected_content, formatter.content
+    end
+
+    def test_reads_utf16le_bom
+      formatter = prepare_mock_formatter DummyFormatter
+      new_runner(fixture_path('enc_utf16le_bom.dummy')).consume_string_file
+      assert_equal @expected_content, formatter.content
+    end
+
+    def test_reads_utf16be_bom
+      formatter = prepare_mock_formatter DummyFormatter
+      new_runner(fixture_path('enc_utf16be_bom.dummy')).consume_string_file
+      assert_equal @expected_content, formatter.content
+    end
+
+    def test_reads_utf16le
+      formatter = prepare_mock_formatter DummyFormatter
+      new_runner(fixture_path('enc_utf16le.dummy'), 'UTF-16LE').consume_string_file
+      assert_equal @expected_content, formatter.content
+    end
+
+    def test_reads_utf16be
+      formatter = prepare_mock_formatter DummyFormatter
+      new_runner(fixture_path('enc_utf16be.dummy'), 'UTF-16BE').consume_string_file
+      assert_equal @expected_content, formatter.content
+    end
+  end
 end

data/test/test_formatters.rb

@@ -41,8 +41,8 @@ class TestAndroidFormatter < FormatterTest
     super Twine::Formatters::Android
   end
 
-  def test_read_file_format
-    @formatter.read_file fixture('formatter_android.xml'), 'en'
+  def test_read_format
+    @formatter.read content_io('formatter_android.xml'), 'en'
 
     assert_file_contents_read_correctly
   end
@@ -67,11 +67,10 @@ class TestAndroidFormatter < FormatterTest
     assert_equal '@value', @strings.strings_map['key1'].translations['en']
   end
 
-  def test_write_file_output_format
+  def test_format_file
     formatter = Twine::Formatters::Android.new
     formatter.strings = @twine_file
-    formatter.write_file @output_path, 'en'
-    assert_equal content('formatter_android.xml'), output_content
+    assert_equal content('formatter_android.xml'), formatter.format_file('en')
   end
 
   def test_format_key_with_space
@@ -100,6 +99,31 @@ class TestAndroidFormatter < FormatterTest
     identifier = '@android:string/cancel'
     assert_equal identifier, @formatter.format_value(identifier)
   end
+
+  def test_deducts_language_from_resource_folder
+    language = %w(en de fr).sample
+    assert_equal language, @formatter.determine_language_given_path("res/values-#{language}")
+  end
+
+  def test_deducts_language_and_region_from_resource_folder
+    assert_equal 'de-AT', @formatter.determine_language_given_path("res/values-de-rAT")
+  end
+
+  def test_maps_laguage_deducted_from_resource_folder
+    assert_equal 'zh-Hans', @formatter.determine_language_given_path("res/values-zh-rCN")
+  end
+
+  def test_does_not_deduct_language_from_device_capability_resource_folder
+    assert_nil @formatter.determine_language_given_path('res/values-w820dp')
+  end
+
+  def test_output_path_is_prefixed
+    assert_equal 'values-en', @formatter.output_path_for_language('en')
+  end
+
+  def test_output_path_language_mappings
+    assert_equal 'values-zh-rCN', @formatter.output_path_for_language('zh-Hans')
+  end
 end
 
 class TestAppleFormatter < FormatterTest
@@ -107,17 +131,56 @@ class TestAppleFormatter < FormatterTest
     super Twine::Formatters::Apple
   end
 
-  def test_read_file_format
-    @formatter.read_file fixture('formatter_apple.strings'), 'en'
+  def test_read_format
+    @formatter.read content_io('formatter_apple.strings'), 'en'
 
     assert_file_contents_read_correctly
   end
 
-  def test_write_file_output_format
+  def test_reads_quoted_keys
+    @formatter.read StringIO.new('"key" = "value"'), 'en'
+    assert_equal 'value', @strings.strings_map['key'].translations['en']
+  end
+
+  def test_reads_unquoted_keys
+    @formatter.read StringIO.new('key = "value"'), 'en'
+    assert_equal 'value', @strings.strings_map['key'].translations['en']
+  end
+
+  def test_ignores_leading_whitespace_before_quoted_keys
+    @formatter.read StringIO.new("\t  \"key\" = \"value\""), 'en'
+    assert_equal 'value', @strings.strings_map['key'].translations['en']
+  end
+
+  def test_ignores_leading_whitespace_before_unquoted_keys
+    @formatter.read StringIO.new("\t  key = \"value\""), 'en'
+    assert_equal 'value', @strings.strings_map['key'].translations['en']
+  end
+
+  def test_allows_quotes_in_quoted_keys
+    @formatter.read StringIO.new('"ke\"y" = "value"'), 'en'
+    assert_equal 'value', @strings.strings_map['ke"y'].translations['en']
+  end
+
+  def test_does_not_allow_quotes_in_quoted_keys
+    @formatter.read StringIO.new('ke"y = "value"'), 'en'
+    assert_nil @strings.strings_map['key']
+  end
+
+  def test_allows_equal_signs_in_quoted_keys
+    @formatter.read StringIO.new('"k=ey" = "value"'), 'en'
+    assert_equal 'value', @strings.strings_map['k=ey'].translations['en']
+  end
+
+  def test_does_not_allow_equal_signs_in_unquoted_keys
+    @formatter.read StringIO.new('k=ey = "value"'), 'en'
+    assert_nil @strings.strings_map['key']
+  end
+
+  def test_format_file
     formatter = Twine::Formatters::Apple.new
     formatter.strings = @twine_file
-    formatter.write_file @output_path, 'en'
-    assert_equal content('formatter_apple.strings'), output_content
+    assert_equal content('formatter_apple.strings'), formatter.format_file('en')
   end
 
   def test_format_key_with_space
@@ -139,17 +202,16 @@ class TestJQueryFormatter < FormatterTest
     super Twine::Formatters::JQuery
   end
 
-  def test_read_file_format
-    @formatter.read_file fixture('formatter_jquery.json'), 'en'
+  def test_read_format
+    @formatter.read content_io('formatter_jquery.json'), 'en'
 
     assert_translations_read_correctly
   end
 
-  def test_write_file_output_format
+  def test_format_file
     formatter = Twine::Formatters::JQuery.new
     formatter.strings = @twine_file
-    formatter.write_file @output_path, 'en'
-    assert_equal content('formatter_jquery.json'), output_content
+    assert_equal content('formatter_jquery.json'), formatter.format_file('en')
   end
 
   def test_format_value_with_newline
@@ -163,23 +225,22 @@ class TestGettextFormatter < FormatterTest
     super Twine::Formatters::Gettext
   end
 
-  def test_read_file_format
-    @formatter.read_file fixture('formatter_gettext.po'), 'en'
+  def test_read_format
+    @formatter.read content_io('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'
+  def test_read_with_multiple_line_value
+    @formatter.read content_io('gettext_multiline.po'), 'en'
 
     assert_equal 'multiline\nstring', @strings.strings_map['key1'].translations['en']
   end
 
-  def test_write_file_output_format
+  def test_format_file
     formatter = Twine::Formatters::Gettext.new
     formatter.strings = @twine_file
-    formatter.write_file @output_path, 'en'
-    assert_equal content('formatter_gettext.po'), output_content
+    assert_equal content('formatter_gettext.po'), formatter.format_file('en')
   end
 
 end
@@ -190,18 +251,17 @@ class TestTizenFormatter < FormatterTest
     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'
+  def test_read_format
+    skip 'the current implementation of Tizen formatter does not support reading'
+    @formatter.read content_io('formatter_tizen.xml'), 'en'
 
     assert_file_contents_read_correctly
   end
 
-  def test_write_file_output_format
+  def test_format_file
     formatter = Twine::Formatters::Tizen.new
     formatter.strings = @twine_file
-    formatter.write_file @output_path, 'en'
-    assert_equal content('formatter_tizen.xml'), output_content
+    assert_equal content('formatter_tizen.xml'), formatter.format_file('en')
   end
 
 end
@@ -211,17 +271,16 @@ class TestDjangoFormatter < FormatterTest
     super Twine::Formatters::Django
   end
 
-  def test_read_file_format
-    @formatter.read_file fixture('formatter_django.po'), 'en'
+  def test_read_format
+    @formatter.read content_io('formatter_django.po'), 'en'
 
     assert_file_contents_read_correctly
   end
 
-  def test_write_file_output_format
+  def test_format_file
     formatter = Twine::Formatters::Django.new
     formatter.strings = @twine_file
-    formatter.write_file @output_path, 'en'
-    assert_equal content('formatter_django.po'), output_content
+    assert_equal content('formatter_django.po'), formatter.format_file('en')
   end
 end
 
@@ -230,16 +289,15 @@ class TestFlashFormatter < FormatterTest
     super Twine::Formatters::Flash
   end
 
-  def test_read_file_format
-    @formatter.read_file fixture('formatter_flash.properties'), 'en'
+  def test_read_format
+    @formatter.read content_io('formatter_flash.properties'), 'en'
 
     assert_file_contents_read_correctly
   end
 
-  def test_write_file_output_format
+  def test_format_file
     formatter = Twine::Formatters::Flash.new
     formatter.strings = @twine_file
-    formatter.write_file @output_path, 'en'
-    assert_equal content('formatter_flash.properties'), output_content
+    assert_equal content('formatter_flash.properties'), formatter.format_file('en')
   end
 end

data/test/test_generate_all_string_files.rb

@@ -1,48 +1,74 @@
 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
+  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_row key: 'value'
         end
       end
+    end
 
-      Twine::Runner.new(options, twine_file)
+    Twine::Runner.new(options, twine_file)
+  end
+
+  class TestDoNotCreateFolders < TestGenerateAllStringFiles
+    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(false).generate_all_string_files
+        new_runner.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
+    def test_does_not_create_language_folders
+      Dir.mkdir File.join @output_dir, 'en.lproj'
+      new_runner.generate_all_string_files
+      refute File.exists?(File.join(@output_dir, 'es.lproj')), "language folder should not be created"
     end
 
-    def test_does_not_create_language_folders_by_default
+    def test_prints_empty_file_warnings
       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"
+      empty_twine_file = build_twine_file('en') {}
+      new_runner(empty_twine_file).generate_all_string_files
+      assert_match "Skipping file at path", Twine::stderr.string
+    end
+  end
+
+  class TestCreateFolders < TestGenerateAllStringFiles
+    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
+      assert File.exists? @output_dir
     end
 
     def test_creates_language_folders
-      new_runner(true).generate_all_string_files
+      new_runner.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
+
+    def test_prints_empty_file_warnings
+      empty_twine_file = build_twine_file('en') {}
+      new_runner(empty_twine_file).generate_all_string_files
+
+      assert_match "Skipping file at path", Twine::stderr.string
+    end
   end
 
-  class TestDeliberate < CommandTestCase
+  class TestValidate < CommandTestCase
     def new_runner(validate)
       Dir.mkdir File.join @output_dir, 'values-en'