twine 0.9.1 → 0.10.0

data/lib/twine/{stringsfile.rb → twine_file.rb}

@@ -1,15 +1,5 @@
 module Twine
-  class StringsSection
-    attr_reader :name
-    attr_reader :rows
-
-    def initialize(name)
-      @name = name
-      @rows = []
-    end
-  end
-
-  class StringsRow
+  class TwineDefinition
     attr_reader :key
     attr_accessor :comment
     attr_accessor :tags
@@ -32,34 +22,49 @@ module Twine
       @comment
     end
 
+    # [['tag1', 'tag2'], ['~tag3']] == (tag1 OR tag2) AND (!tag3)
     def matches_tags?(tags, include_untagged)
-      if tags == nil || tags.empty?
-        # The user did not specify any tags. Everything passes.
+      if tags == nil || tags.empty?  # The user did not specify any tags. Everything passes.
         return true
-      elsif @tags == nil
-        # This row has no tags.
+      elsif @tags == nil  # This definition has no tags -> check reference (if any)
         return reference ? reference.matches_tags?(tags, include_untagged) : include_untagged
       elsif @tags.empty?
         return include_untagged
       else
-        return !(tags & @tags).empty?
+        return tags.all? do |set|
+          regular_tags, negated_tags = set.partition { |tag| tag[0] != '~' }
+          negated_tags.map! { |tag| tag[1..-1] }
+          matches_regular_tags = (!regular_tags.empty? && !(regular_tags & @tags).empty?)
+          matches_negated_tags = (!negated_tags.empty? && (negated_tags & @tags).empty?)
+          matches_regular_tags or matches_negated_tags
+        end
       end
 
       return false
     end
 
-    def translated_string_for_lang(lang)
+    def translation_for_lang(lang)
       translation = [lang].flatten.map { |l| @translations[l] }.first
 
-      translation = reference.translated_string_for_lang(lang) if translation.nil? && reference
+      translation = reference.translation_for_lang(lang) if translation.nil? && reference
 
       return translation
     end
   end
 
-  class StringsFile
+  class TwineSection
+    attr_reader :name
+    attr_reader :definitions
+
+    def initialize(name)
+      @name = name
+      @definitions = []
+    end
+  end
+
+  class TwineFile
     attr_reader :sections
-    attr_reader :strings_map
+    attr_reader :definitions_by_key
     attr_reader :language_codes
 
     private
@@ -73,7 +78,7 @@ module Twine
 
     def initialize
       @sections = []
-      @strings_map = {}
+      @definitions_by_key = {}
       @language_codes = []
     end
 
@@ -102,7 +107,7 @@ module Twine
       File.open(path, 'r:UTF-8') do |f|
         line_num = 0
         current_section = nil
-        current_row = nil
+        current_definition = nil
         while line = f.gets
           parsed = false
           line.strip!
@@ -115,20 +120,20 @@ module Twine
           if line.length > 4 && line[0, 2] == '[['
             match = /^\[\[(.+)\]\]$/.match(line)
             if match
-              current_section = StringsSection.new(match[1])
+              current_section = TwineSection.new(match[1])
               @sections << current_section
               parsed = true
             end
           elsif line.length > 2 && line[0, 1] == '['
             key = match_key(line)
             if key
-              current_row = StringsRow.new(key)
-              @strings_map[current_row.key] = current_row
+              current_definition = TwineDefinition.new(key)
+              @definitions_by_key[current_definition.key] = current_definition
               if !current_section
-                current_section = StringsSection.new('')
+                current_section = TwineSection.new('')
                 @sections << current_section
               end
-              current_section.rows << current_row
+              current_section.definitions << current_definition
               parsed = true
             end
           else
@@ -141,16 +146,16 @@ module Twine
 
               case key
               when 'comment'
-                current_row.comment = value
+                current_definition.comment = value
               when 'tags'
-                current_row.tags = value.split(',')
+                current_definition.tags = value.split(',')
               when 'ref'
-                current_row.reference_key = value if value
+                current_definition.reference_key = value if value
               else
                 if !@language_codes.include? key
                   add_language_code(key)
                 end
-                current_row.translations[key] = value
+                current_definition.translations[key] = value
               end
               parsed = true
             end
@@ -163,9 +168,9 @@ module Twine
       end
 
       # resolve_references
-      @strings_map.each do |key, row|
-        next unless row.reference_key
-        row.reference = @strings_map[row.reference_key]
+      @definitions_by_key.each do |key, definition|
+        next unless definition.reference_key
+        definition.reference = @definitions_by_key[definition.reference_key]
       end
     end
 
@@ -180,26 +185,26 @@ module Twine
 
           f.puts "[[#{section.name}]]"
 
-          section.rows.each do |row|
-            f.puts "\t[#{row.key}]"
+          section.definitions.each do |definition|
+            f.puts "\t[#{definition.key}]"
 
-            value = write_value(row, dev_lang, f)
-            if !value && !row.reference_key
-              puts "Warning: #{row.key} does not exist in developer language '#{dev_lang}'"
+            value = write_value(definition, dev_lang, f)
+            if !value && !definition.reference_key
+              puts "Warning: #{definition.key} does not exist in developer language '#{dev_lang}'"
             end
             
-            if row.reference_key
-              f.puts "\t\tref = #{row.reference_key}"
+            if definition.reference_key
+              f.puts "\t\tref = #{definition.reference_key}"
             end
-            if row.tags && row.tags.length > 0
-              tag_str = row.tags.join(',')
+            if definition.tags && definition.tags.length > 0
+              tag_str = definition.tags.join(',')
               f.puts "\t\ttags = #{tag_str}"
             end
-            if row.raw_comment and row.raw_comment.length > 0
-              f.puts "\t\tcomment = #{row.raw_comment}"
+            if definition.raw_comment and definition.raw_comment.length > 0
+              f.puts "\t\tcomment = #{definition.raw_comment}"
             end
             @language_codes[1..-1].each do |lang|
-              write_value(row, lang, f)
+              write_value(definition, lang, f)
             end
           end
         end
@@ -208,8 +213,8 @@ module Twine
 
     private
 
-    def write_value(row, language, file)
-      value = row.translations[language]
+    def write_value(definition, language, file)
+      value = definition.translations[language]
       return nil unless value
 
       if value[0] == ' ' || value[-1] == ' ' || (value[0] == '`' && value[-1] == '`')

data/lib/twine/version.rb

@@ -1,3 +1,3 @@
 module Twine
-  VERSION = '0.9.1'
+  VERSION = '0.10.0'
 end

data/test/{command_test_case.rb → command_test.rb}

@@ -1,12 +1,12 @@
-require 'twine_test_case'
+require 'twine_test'
 
-class CommandTestCase < TwineTestCase
+class CommandTest < TwineTest
   def prepare_mock_formatter(formatter_class)
-    strings = Twine::StringsFile.new
-    strings.language_codes.concat KNOWN_LANGUAGES
+    twine_file = Twine::TwineFile.new
+    twine_file.language_codes.concat KNOWN_LANGUAGES
 
     formatter = formatter_class.new
-    formatter.strings = strings
+    formatter.twine_file = twine_file
     Twine::Formatters.formatters.clear
     Twine::Formatters.formatters << formatter
     formatter

data/test/fixtures/formatter_django.po

@@ -2,7 +2,9 @@
  # Django Strings File
  # Generated by Twine <%= Twine::VERSION %>
  # Language: en
-
+msgid ""
+msgstr ""
+"Content-Type: text/plain; charset=UTF-8\n"
 
 #--------- Section 1 ---------#
 

data/test/test_abstract_formatter.rb

@@ -1,164 +1,164 @@
-require 'twine_test_case'
+require 'twine_test'
 
-class TestAbstractFormatter < TwineTestCase
-  class SetTranslation < TwineTestCase
+class TestAbstractFormatter < TwineTest
+  class SetTranslation < 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-english'
-          add_row key2: { en: 'value2-english', fr: 'value2-french' }
+          add_definition key1: 'value1-english'
+          add_definition key2: { en: 'value2-english', fr: 'value2-french' }
         end
       end
 
       @formatter = Twine::Formatters::Abstract.new
-      @formatter.strings = @strings
+      @formatter.twine_file = @twine_file
     end
 
     def test_set_translation_updates_existing_value
       @formatter.set_translation_for_key 'key1', 'en', 'value1-english-updated'
 
-      assert_equal 'value1-english-updated', @strings.strings_map['key1'].translations['en']
+      assert_equal 'value1-english-updated', @twine_file.definitions_by_key['key1'].translations['en']
     end
 
     def test_set_translation_does_not_alter_other_language
       @formatter.set_translation_for_key 'key2', 'en', 'value2-english-updated'
 
-      assert_equal 'value2-french', @strings.strings_map['key2'].translations['fr']
+      assert_equal 'value2-french', @twine_file.definitions_by_key['key2'].translations['fr']
     end
 
     def test_set_translation_escapes_newlines
       @formatter.set_translation_for_key 'key1', 'en', "new\nline"
 
-      assert_equal 'new\nline', @strings.strings_map['key1'].translations['en']
+      assert_equal 'new\nline', @twine_file.definitions_by_key['key1'].translations['en']
     end
 
     def test_set_translation_adds_translation_to_existing_key
       @formatter.set_translation_for_key 'key1', 'fr', 'value1-french'
 
-      assert_equal 'value1-french', @strings.strings_map['key1'].translations['fr']
+      assert_equal 'value1-french', @twine_file.definitions_by_key['key1'].translations['fr']
     end
 
     def test_set_translation_does_not_add_new_key
       @formatter.set_translation_for_key 'new-key', 'en', 'new-key-english'
 
-      assert_nil @strings.strings_map['new-key']
+      assert_nil @twine_file.definitions_by_key['new-key']
     end
 
     def test_set_translation_consume_all_adds_new_key
       formatter = Twine::Formatters::Abstract.new
-      formatter.strings = @strings
+      formatter.twine_file = @twine_file
       formatter.options = { consume_all: true }
       formatter.set_translation_for_key 'new-key', 'en', 'new-key-english'
 
-      assert_equal 'new-key-english', @strings.strings_map['new-key'].translations['en']
+      assert_equal 'new-key-english', @twine_file.definitions_by_key['new-key'].translations['en']
     end
 
     def test_set_translation_consume_all_adds_tags
       random_tag = SecureRandom.uuid
       formatter = Twine::Formatters::Abstract.new
-      formatter.strings = @strings
+      formatter.twine_file = @twine_file
       formatter.options = { consume_all: true, tags: [random_tag] }
       formatter.set_translation_for_key 'new-key', 'en', 'new-key-english'
 
-      assert_equal [random_tag], @strings.strings_map['new-key'].tags
+      assert_equal [random_tag], @twine_file.definitions_by_key['new-key'].tags
     end
 
     def test_set_translation_adds_new_keys_to_category_uncategoriezed
       formatter = Twine::Formatters::Abstract.new
-      formatter.strings = @strings
+      formatter.twine_file = @twine_file
       formatter.options = { consume_all: true }
       formatter.set_translation_for_key 'new-key', 'en', 'new-key-english'
 
-      assert_equal 'Uncategorized', @strings.sections[0].name 
-      assert_equal 'new-key', @strings.sections[0].rows[0].key
+      assert_equal 'Uncategorized', @twine_file.sections[0].name 
+      assert_equal 'new-key', @twine_file.sections[0].definitions[0].key
     end
   end
 
-  class ValueReference < TwineTestCase
+  class ValueReference < 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 refkey: 'ref-value'
-          add_row key: :refkey
+          add_definition refkey: 'ref-value'
+          add_definition key: :refkey
         end
       end
 
       @formatter = Twine::Formatters::Abstract.new
-      @formatter.strings = @strings
+      @formatter.twine_file = @twine_file
     end
 
     def test_set_translation_does_not_add_unchanged_translation
       @formatter.set_translation_for_key 'key', 'en', 'ref-value'
 
-      assert_nil @strings.strings_map['key'].translations['en']
+      assert_nil @twine_file.definitions_by_key['key'].translations['en']
     end
 
     def test_set_translation_adds_changed_translation
       @formatter.set_translation_for_key 'key', 'en', 'changed value'
 
-      assert_equal 'changed value', @strings.strings_map['key'].translations['en']
+      assert_equal 'changed value', @twine_file.definitions_by_key['key'].translations['en']
     end
   end
 
-  class SetComment < TwineTestCase
+  class SetComment < TwineTest
     def setup
       super
 
-      @strings = build_twine_file 'en' do
+      @twine_file = build_twine_file 'en' do
         add_section 'Section' do
-          add_row key: 'value'
+          add_definition key: 'value'
         end
       end
     end
 
     def test_set_comment_for_key_does_not_update_comment
       formatter = Twine::Formatters::Abstract.new
-      formatter.strings = @strings
+      formatter.twine_file = @twine_file
       formatter.set_comment_for_key('key', 'comment')
 
-      assert_nil formatter.strings.strings_map['key'].comment
+      assert_nil formatter.twine_file.definitions_by_key['key'].comment
     end
 
     def test_set_comment_for_key_updates_comment_with_update_comments
       formatter = Twine::Formatters::Abstract.new
-      formatter.strings = @strings
+      formatter.twine_file = @twine_file
       formatter.options = { consume_comments: true }
       formatter.set_comment_for_key('key', 'comment')
 
-      assert_equal 'comment', formatter.strings.strings_map['key'].comment
+      assert_equal 'comment', formatter.twine_file.definitions_by_key['key'].comment
     end
   end
 
-  class CommentReference < TwineTestCase
+  class CommentReference < TwineTest
     def setup
       super
 
-      @strings = build_twine_file 'en' do
+      @twine_file = build_twine_file 'en' do
         add_section 'Section' do
-          add_row refkey: 'ref-value', comment: 'reference comment'
-          add_row key: 'value', ref: :refkey
+          add_definition refkey: 'ref-value', comment: 'reference comment'
+          add_definition key: 'value', ref: :refkey
         end
       end
 
       @formatter = Twine::Formatters::Abstract.new
-      @formatter.strings = @strings
+      @formatter.twine_file = @twine_file
       @formatter.options = { consume_comments: true }
     end
 
     def test_set_comment_does_not_add_unchanged_comment
       @formatter.set_comment_for_key 'key', 'reference comment'
       
-      assert_nil @strings.strings_map['key'].raw_comment
+      assert_nil @twine_file.definitions_by_key['key'].raw_comment
     end
 
     def test_set_comment_adds_changed_comment
       @formatter.set_comment_for_key 'key', 'changed comment'
 
-      assert_equal 'changed comment', @strings.strings_map['key'].raw_comment
+      assert_equal 'changed comment', @twine_file.definitions_by_key['key'].raw_comment
     end
   end
 

data/test/test_cli.rb

@@ -1,10 +1,10 @@
-require 'twine_test_case'
+require 'twine_test'
 
-class CLITestCase < TwineTestCase
+class CLITest < TwineTest
   def setup
-    super
+    super()
 
-    @strings_file_path = File.join @output_dir, SecureRandom.uuid
+    @twine_file_path = File.join @output_dir, SecureRandom.uuid
     @input_path = File.join @output_dir, SecureRandom.uuid
     @input_dir = @output_dir
   end
@@ -13,284 +13,386 @@ class CLITestCase < TwineTestCase
     @options = Twine::CLI::parse command.split
   end
 
-  class TestValidateStringsFile < CLITestCase
-    def test_command
-      parse "validate-strings-file #{@strings_file_path}"
+  def parse_with(parameters)
+    raise "you need to implement `parse_with` in your test class"
+  end
 
-      assert_equal 'validate-strings-file', @options[:command]
-      assert_equal @strings_file_path, @options[:strings_file]
-    end
+  def assert_option_consume_all
+    parse_with '--consume-all'
+    assert @options[:consume_all]
+  end
 
-    def test_pedantic
-      parse "validate-strings-file #{@strings_file_path} --pedantic"
-      assert @options[:pedantic]
-    end
+  def assert_option_consume_comments
+    parse_with '--consume-comments'
+    assert @options[:consume_comments]
+  end
 
-    def test_missing_parameter
-      assert_raises Twine::Error do
-        parse 'validate-strings-file'
-      end
-    end
+  def assert_option_developer_language
+    random_language = KNOWN_LANGUAGES.sample
+    parse_with "--developer-language #{random_language}"
+    assert_equal random_language, @options[:developer_language]
+  end
 
-    def test_extra_parameter
-      assert_raises Twine::Error do
-        parse 'validate-strings-file strings extra'
-      end
-    end
+  def assert_option_encoding
+    parse_with '--encoding UTF16'
+    assert_equal 'UTF16', @options[:encoding]
   end
 
-  class TestGenerateStringFile < CLITestCase
-    def test_command
-      parse "generate-string-file #{@strings_file_path} #{@output_path}"
+  def assert_option_format
+    random_format = Twine::Formatters.formatters.sample.format_name.downcase
+    parse_with "--format #{random_format}"
+    assert_equal random_format, @options[:format]
+  end
 
-      assert_equal 'generate-string-file', @options[:command]
-      assert_equal @strings_file_path, @options[:strings_file]
-      assert_equal @output_path, @options[:output_path]
-    end
+  def assert_option_include
+    random_set = [:all, :translated, :untranslated].sample
+    parse_with "--include #{random_set}"
+    assert_equal random_set, @options[:include]
+  end
 
-    def test_missing_parameter
-      assert_raises Twine::Error do
-        parse 'generate-string-file strings'
-      end
-    end
+  def assert_option_single_language
+    random_language = KNOWN_LANGUAGES.sample
+    parse_with "--lang #{random_language}"
+    assert_equal [random_language], @options[:languages]
+  end
 
-    def test_validate
-      parse "generate-string-file #{@strings_file_path} #{@output_path} --validate"
-      assert @options[:validate]
-    end
+  def assert_option_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_extra_parameter
-      assert_raises Twine::Error do
-        parse 'generate-string-file strings output extra'
-      end
-    end
+  def assert_option_languages
+    assert_option_single_language
+    assert_option_multiple_languages
+  end
 
-    def test_only_allows_one_language
-      assert_raises Twine::Error do
-        parse "generate-string-file strings output --lang en,fr"
-      end
-    end
+  def assert_option_output_path
+    parse_with "--output-file #{@output_path}"
+    assert_equal @output_path, @options[:output_path]  
   end
 
-  class TestGenerateAllStringFiles < CLITestCase
-    def test_command
-      parse "generate-all-string-files #{@strings_file_path} #{@output_dir}"
+  def assert_option_tags
+    # single tag
+    random_tag = "tag#{rand(100)}"
+    parse_with "--tags #{random_tag}"
+    assert_equal [[random_tag]], @options[:tags]
+
+    # multiple OR tags
+    random_tags = ["tag#{rand(100)}", "tag#{rand(100)}", "tag#{rand(100)}"]
+    parse_with "--tags #{random_tags.join(',')}"
+    sorted_tags = @options[:tags].map { |tags| tags.sort }
+    assert_equal [random_tags.sort], sorted_tags
+
+    # multiple AND tags
+    random_tag_1 = "tag#{rand(100)}"
+    random_tag_2 = "tag#{rand(100)}"
+    parse_with "--tags #{random_tag_1} --tags #{random_tag_2}"
+    assert_equal [[random_tag_1], [random_tag_2]], @options[:tags]
+    
+    # NOT tag
+    random_tag = "~tag#{rand(100)}"
+    parse_with "--tags #{random_tag}"
+    assert_equal [[random_tag]], @options[:tags]
+  end
 
-      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 assert_option_untagged
+    parse_with '--untagged'
+    assert @options[:untagged]
+  end
 
-    def test_missing_parameter
-      assert_raises Twine::Error do
-        parse "generate-all-string-files strings"
-      end
-    end
+  def assert_option_validate
+    parse_with "--validate"
+    assert @options[:validate]
+  end
+end
 
-    def test_validate
-      parse "generate-all-string-files #{@strings_file_path} #{@output_dir} --validate"
-      assert @options[:validate]
+class TestGenerateLocalizationFileCLI < CLITest
+  def parse_with(parameters)
+    parse "generate-localization-file #{@twine_file_path} #{@output_path} " + parameters
+  end
+
+  def test_command
+    parse_with ""
+
+    assert_equal 'generate-localization-file', @options[:command]
+    assert_equal @twine_file_path, @options[:twine_file]
+    assert_equal @output_path, @options[:output_path]
+  end
+
+  def test_missing_argument
+    assert_raises Twine::Error do
+      parse "generate-localization-file #{@twine_file}"
     end
+  end
 
-    def test_extra_parameter
-      assert_raises Twine::Error do
-        parse "generate-all-string-files strings output extra"
-      end
+  def test_extra_argument
+    assert_raises Twine::Error do
+      parse_with "extra"
     end
   end
 
-  class TestConsumeStringFile < CLITestCase
-    def test_command
-      parse "consume-string-file #{@strings_file_path} #{@input_path}"
+  def test_options
+    assert_option_developer_language
+    assert_option_encoding
+    assert_option_format
+    assert_option_include
+    assert_option_single_language
+    assert_raises(Twine::Error) { assert_option_multiple_languages }
+    assert_option_tags
+    assert_option_untagged
+    assert_option_validate
+  end
+end
+
+class TestGenerateAllLocalizationFilesCLI < CLITest
+  def parse_with(parameters)
+    parse "generate-all-localization-files #{@twine_file_path} #{@output_dir} " + parameters
+  end
 
-      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_command
+    parse_with ""
 
-    def test_missing_parameter
-      assert_raises Twine::Error do
-        parse "consume-string-file strings"
-      end
-    end
+    assert_equal 'generate-all-localization-files', @options[:command]
+    assert_equal @twine_file_path, @options[:twine_file]
+    assert_equal @output_dir, @options[:output_path]
+  end
 
-    def test_extra_parameter
-      assert_raises Twine::Error do
-        parse "consume-string-file strings output extra"
-      end
+  def test_missing_argument
+    assert_raises Twine::Error do
+      parse "generate-all-localization-files twine_file"
     end
+  end
 
-    def test_only_allows_one_language
-      assert_raises Twine::Error do
-        parse "consume-string-file strings output --lang en,fr"
-      end
+  def test_extra_arguemnt
+    assert_raises Twine::Error do
+      parse_with "extra"
     end
   end
 
-  class TestConsumeAllStringFiles < CLITestCase
-    def test_command
-      parse "consume-all-string-files #{@strings_file_path} #{@input_dir}"
+  def test_options
+    assert_option_developer_language
+    assert_option_encoding
+    assert_option_format
+    assert_option_include
+    assert_option_tags
+    assert_option_untagged
+    assert_option_validate
+  end
 
-      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_option_create_folders
+    parse_with '--create-folders'
+    assert @options[:create_folders]
+  end
 
-    def test_missing_parameter
-      assert_raises Twine::Error do
-        parse "consume-all-string-files strings"
-      end
-    end
+  def test_option_file_name
+    random_filename = "#{rand(10000)}"
+    parse_with "--file-name #{random_filename}"
+    assert_equal random_filename, @options[:file_name]
+  end
+end
 
-    def test_extra_parameter
-      assert_raises Twine::Error do
-        parse "consume-all-string-files strings output extra"
-      end
-    end
+class TestGenerateLocalizationArchiveCLI < CLITest
+  def parse_with(parameters)
+    parse "generate-localization-archive #{@twine_file_path} #{@output_path} --format apple " + parameters
   end
 
-  class TestGenerateLocDrop < CLITestCase
-    def test_command
-      parse "generate-loc-drop #{@strings_file_path} #{@output_path} --format apple"
+  def test_command
+    parse_with ""
 
-      assert_equal 'generate-loc-drop', @options[:command]
-      assert_equal @strings_file_path, @options[:strings_file]
-      assert_equal @output_path, @options[:output_path]
-    end
+    assert_equal 'generate-localization-archive', @options[:command]
+    assert_equal @twine_file_path, @options[:twine_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
+  def test_missing_argument
+    assert_raises Twine::Error do
+      parse "generate-localization-archive twine_file --format apple"
     end
+  end
 
-    def test_validate
-      parse "generate-loc-drop #{@strings_file_path} #{@output_path} --format apple --validate"
-      assert @options[:validate]
+  def test_extra_argument
+    assert_raises Twine::Error do
+      parse_with "extra"
     end
+  end
 
-    def test_extra_parameter
-      assert_raises Twine::Error do
-        parse "generate-loc-drop strings output extra --format apple"
-      end
-    end
+  def test_options
+    assert_option_developer_language
+    assert_option_encoding
+    assert_option_include
+    assert_option_tags
+    assert_option_untagged
+    assert_option_validate
+  end
 
-    def test_format_needed
-      assert_raises Twine::Error do
-        parse "generate-loc-drop strings output"
-      end
+  def test_option_format_required
+    assert_raises Twine::Error do
+      parse "generate-localization-archive twine_file output"
     end
   end
 
-  class TestConsumeLocDrop < CLITestCase
-    def test_command
-      parse "consume-loc-drop #{@strings_file_path} #{@input_path}"
+  def test_supports_deprecated_command
+    parse "generate-loc-drop #{@twine_file_path} #{@output_path} --format apple"
+    assert_equal 'generate-localization-archive', @options[:command]
+  end
 
-      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_deprecated_command_prints_warning
+    parse "generate-loc-drop #{@twine_file_path} #{@output_path} --format apple"
+    assert_match "WARNING: Twine commands names have changed.", Twine::stderr.string
+  end
+end
 
-    def test_missing_parameter
-      assert_raises Twine::Error do
-        parse "consume-loc-drop strings"
-      end
-    end
+class TestConsumeLocalizationFileCLI < CLITest
+  def parse_with(parameters)
+    parse "consume-localization-file #{@twine_file_path} #{@input_path} " + parameters
+  end
 
-    def test_extra_parameter
-      assert_raises Twine::Error do
-        parse "consume-loc-drop strings input extra"
-      end
-    end
+  def test_command
+    parse_with ""
+
+    assert_equal 'consume-localization-file', @options[:command]
+    assert_equal @twine_file_path, @options[:twine_file]
+    assert_equal @input_path, @options[:input_path]
   end
 
-  class TestParameters < CLITestCase
-    def parse_with(parameter)
-      parse 'validate-strings-file input.txt ' + parameter
+  def test_missing_argument
+    assert_raises Twine::Error do
+      parse "consume-localization-file twine_file"
     end
+  end
 
-    def test_default_options
-      parse_with ''
-      expected = {command: 'validate-strings-file', strings_file: 'input.txt', include: :all}
-      assert_equal expected, @options
+  def test_extra_argument
+    assert_raises Twine::Error do
+      parse_with "extra"
     end
+  end
 
-    def test_create_folders
-      parse_with '--create-folders'
-      assert @options[:create_folders]
-    end
+  def test_options
+    assert_option_consume_all
+    assert_option_consume_comments
+    assert_option_developer_language
+    assert_option_encoding
+    assert_option_format
+    assert_option_single_language
+    assert_raises(Twine::Error) { assert_option_multiple_languages }
+    assert_option_output_path
+    assert_option_tags
+  end
+end
 
-    def test_consume_all
-      parse_with '--consume-all'
-      assert @options[:consume_all]
-    end
+class TestConsumeAllLocalizationFilesCLI < CLITest
+  def parse_with(parameters)
+    parse "consume-all-localization-files #{@twine_file_path} #{@input_dir} " + parameters
+  end
 
-    def test_consume_comments
-      parse_with '--consume-comments'
-      assert @options[:consume_comments]
-    end
+  def test_command
+    parse_with ""
 
-    def test_untagged
-      parse_with '--untagged'
-      assert @options[:untagged]
-    end
+    assert_equal 'consume-all-localization-files', @options[:command]
+    assert_equal @twine_file_path, @options[:twine_file]
+    assert_equal @input_dir, @options[:input_path]
+  end
 
-    def test_developer_language
-      random_language = KNOWN_LANGUAGES.sample
-      parse_with "--developer-lang #{random_language}"
-      assert_equal random_language, @options[:developer_language]
+  def test_missing_argument
+    assert_raises Twine::Error do
+      parse "consume-all-localization-files twine_file"
     end
+  end
 
-    def test_single_language
-      random_language = KNOWN_LANGUAGES.sample
-      parse_with "--lang #{random_language}"
-      assert_equal [random_language], @options[:languages]
+  def test_extra_argument
+    assert_raises Twine::Error do
+      parse_with "extra"
     end
+  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_options
+    assert_option_consume_all
+    assert_option_consume_comments
+    assert_option_developer_language
+    assert_option_encoding
+    assert_option_format
+    assert_option_output_path
+    assert_option_tags
+  end
+end
 
-    def test_single_tag
-      random_tag = "tag#{rand(100)}"
-      parse_with "--tags #{random_tag}"
-      assert_equal [random_tag], @options[:tags]
-    end
+class TestConsumeLocalizationArchiveCLI < CLITest
+  def parse_with(parameters)
+    parse "consume-localization-archive #{@twine_file_path} #{@input_path} " + parameters
+  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_command
+    parse_with  ""
 
-    def test_format
-      random_format = Twine::Formatters.formatters.sample.format_name.downcase
-      parse_with "--format #{random_format}"
-      assert_equal random_format, @options[:format]
-    end
+    assert_equal 'consume-localization-archive', @options[:command]
+    assert_equal @twine_file_path, @options[:twine_file]
+    assert_equal @input_path, @options[:input_path]
+  end
 
-    def test_include
-      random_set = [:all, :translated, :untranslated].sample
-      parse_with "--include #{random_set}"
-      assert_equal random_set, @options[:include]
+  def test_missing_argument
+    assert_raises Twine::Error do
+      parse "consume-localization-archive twine_file"
     end
+  end
 
-    def test_output_path
-      parse_with "--output-file #{@output_path}"
-      assert_equal @output_path, @options[:output_path]
+  def test_extra_argument
+    assert_raises Twine::Error do
+      parse_with "extra"
     end
+  end
+
+  def test_options
+    assert_option_consume_all
+    assert_option_consume_comments
+    assert_option_developer_language
+    assert_option_encoding
+    assert_option_format
+    assert_option_output_path
+    assert_option_tags
+  end
+
+  def test_supports_deprecated_command
+    parse "consume-loc-drop #{@twine_file_path} #{@input_path}"
+    assert_equal 'consume-localization-archive', @options[:command]
+  end
+
+  def test_deprecated_command_prints_warning
+    parse "consume-loc-drop #{@twine_file_path} #{@input_path}"
+    assert_match "WARNING: Twine commands names have changed.", Twine::stderr.string
+  end
+end
+
+class TestValidateTwineFileCLI < CLITest
+  def parse_with(parameters)
+    parse "validate-twine-file #{@twine_file_path} " + parameters
+  end
+
+  def test_command
+    parse_with ""
+
+    assert_equal 'validate-twine-file', @options[:command]
+    assert_equal @twine_file_path, @options[:twine_file]
+  end
 
-    def test_file_name
-      random_filename = "#{rand(10000)}"
-      parse_with "--file-name #{random_filename}"
-      assert_equal random_filename, @options[:file_name]
+  def test_missing_argument
+    assert_raises Twine::Error do
+      parse 'validate-twine-file'
     end
+  end
 
-    def test_encoding
-      parse_with '--encoding UTF16'
-      assert_equal 'UTF16', @options[:output_encoding]
+  def test_extra_argument
+    assert_raises Twine::Error do
+      parse_with 'extra'
     end
   end
+
+  def test_options
+    assert_option_developer_language
+  end
+
+  def test_option_pedantic
+    parse "validate-twine-file #{@twine_file_path} --pedantic"
+    assert @options[:pedantic]
+  end
 end