organicmaps/twine
Archived
13
Fork 0
Code Issues 1 Pull requests 2 Projects Releases Wiki Activity Actions

Renamed StringsFile to TwineFile, StringsSection to TwineSection and StringsRow to TwineDefinition.

Browse source
This commit is contained in:
Sebastian Ludwig 2016-03-26 16:24:27 -05:00
parent 043836e84f
commit 594fbfddcc
29 changed files with 467 additions and 467 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
lib/twine.rb
View file

@ -23,7 +23,7 @@ module Twine
require 'twine/plugin'
require 'twine/cli'
require 'twine/stringsfile'
require 'twine/twine_file'
require 'twine/encoding'
require 'twine/output_processor'
require 'twine/placeholders'

14
lib/twine/cli.rb
View file

@ -9,7 +9,7 @@ module Twine
'consume-all-string-files' => 3,
'generate-loc-drop' => 3,
'consume-loc-drop' => 3,
'validate-strings-file' => 2
'validate-twine-file' => 2
}
def self.parse(args)
@ -18,7 +18,7 @@ module Twine
parser = OptionParser.new do |opts|
opts.banner = 'Usage: twine COMMAND STRINGS_FILE [INPUT_OR_OUTPUT_PATH] [--lang LANG1,LANG2...] [--tags TAG1,TAG2,TAG3...] [--format FORMAT]'
opts.separator ''
opts.separator 'The purpose of this script is to convert back and forth between multiple data formats, allowing us to treat our strings (and translations) as data stored in a text file. We can then use the data file to create drops for the localization team, consume similar drops returned by the localization team, and create formatted string files to ship with your products.'
opts.separator 'The purpose of this script is to convert back and forth between multiple data formats, allowing us to treat our strings (and translations) as data stored in a text file. We can then use the data file to create drops for the localization team, consume similar drops returned by the localization team, and create formatted localization files to ship with your products.'
opts.separator ''
opts.separator 'Commands:'
opts.separator ''
@ -40,7 +40,7 @@ module Twine
opts.separator '- consume-loc-drop'
opts.separator ' Consumes an archive of translated files. This archive should be in the same format as the one created by the generate-loc-drop command.'
opts.separator ''
opts.separator '- validate-strings-file'
opts.separator '- validate-twine-file'
opts.separator ' Validates that the given strings file is parseable, contains no duplicates, and that every string has a tag. Exits with a non-zero exit code if those criteria are not met.'
opts.separator ''
opts.separator 'General Options:'
@ -122,7 +122,7 @@ module Twine
opts.separator '> twine consume-all-string-files strings.txt Resources/Locales/ --developer-language en --tags DefaultTag1,DefaultTag2'
opts.separator '> twine generate-loc-drop strings.txt LocDrop5.zip --tags FT,FB --format android --lang de,en,en-GB,ja,ko'
opts.separator '> twine consume-loc-drop strings.txt LocDrop5.zip'
opts.separator '> twine validate-strings-file strings.txt'
opts.separator '> twine validate-twine-file strings.txt'
end
begin
parser.parse! args
@ -143,9 +143,9 @@ module Twine
options[:command] = args[0]
if args.length < 2
raise Twine::Error.new 'You must specify your strings file.'
raise Twine::Error.new 'You must specify your twine file.'
end
options[:strings_file] = args[1]
options[:twine_file] = args[1]
if args.length < number_of_needed_arguments
raise Twine::Error.new 'Not enough arguments.'
@ -175,7 +175,7 @@ module Twine
end
when 'consume-loc-drop'
options[:input_path] = args[2]
when 'validate-strings-file'
when 'validate-twine-file'
end
return options

84
lib/twine/formatters/abstract.rb
View file

@ -3,11 +3,11 @@ require 'fileutils'
module Twine
module Formatters
class Abstract
attr_accessor :strings
attr_accessor :twine_file
attr_accessor :options
def initialize
@strings = StringsFile.new
@twine_file = TwineFile.new
@options = {}
end
@ -30,47 +30,47 @@ module Twine
def set_translation_for_key(key, lang, value)
value = value.gsub("\n", "\\n")
if @strings.strings_map.include?(key)
row = @strings.strings_map[key]
reference = @strings.strings_map[row.reference_key] if row.reference_key
if @twine_file.definitions_by_key.include?(key)
definition = @twine_file.definitions_by_key[key]
reference = @twine_file.definitions_by_key[definition.reference_key] if definition.reference_key
if !reference or value != reference.translations[lang]
row.translations[lang] = value
definition.translations[lang] = value
end
elsif @options[:consume_all]
Twine::stderr.puts "Adding new string '#{key}' to strings data file."
current_section = @strings.sections.find { |s| s.name == 'Uncategorized' }
Twine::stderr.puts "Adding new string '#{key}' to twine file."
current_section = @twine_file.sections.find { |s| s.name == 'Uncategorized' }
unless current_section
current_section = StringsSection.new('Uncategorized')
@strings.sections.insert(0, current_section)
current_section = TwineSection.new('Uncategorized')
@twine_file.sections.insert(0, current_section)
end
current_row = StringsRow.new(key)
current_section.rows << current_row
current_definition = TwineDefinition.new(key)
current_section.definitions << current_definition
if @options[:tags] && @options[:tags].length > 0
current_row.tags = @options[:tags]
current_definition.tags = @options[:tags]
end
@strings.strings_map[key] = current_row
@strings.strings_map[key].translations[lang] = value
@twine_file.definitions_by_key[key] = current_definition
@twine_file.definitions_by_key[key].translations[lang] = value
else
Twine::stderr.puts "Warning: '#{key}' not found in strings data file."
Twine::stderr.puts "Warning: '#{key}' not found in twine file."
end
if !@strings.language_codes.include?(lang)
@strings.add_language_code(lang)
if !@twine_file.language_codes.include?(lang)
@twine_file.add_language_code(lang)
end
end
def set_comment_for_key(key, comment)
return unless @options[:consume_comments]
if @strings.strings_map.include?(key)
row = @strings.strings_map[key]
if @twine_file.definitions_by_key.include?(key)
definition = @twine_file.definitions_by_key[key]
reference = @strings.strings_map[row.reference_key] if row.reference_key
reference = @twine_file.definitions_by_key[definition.reference_key] if definition.reference_key
if !reference or comment != reference.raw_comment
row.comment = comment
definition.comment = comment
end
end
end
@ -88,35 +88,35 @@ module Twine
end
def format_file(lang)
output_processor = Processors::OutputProcessor.new(@strings, @options)
processed_strings = output_processor.process(lang)
output_processor = Processors::OutputProcessor.new(@twine_file, @options)
processed_twine_file = output_processor.process(lang)
return nil if processed_strings.strings_map.empty?
return nil if processed_twine_file.definitions_by_key.empty?
header = format_header(lang)
result = ""
result += header + "\n" if header
result += format_sections(processed_strings, lang)
result += format_sections(processed_twine_file, lang)
end
def format_header(lang)
end
def format_sections(strings, lang)
sections = strings.sections.map { |section| format_section(section, lang) }
def format_sections(twine_file, lang)
sections = twine_file.sections.map { |section| format_section(section, lang) }
sections.compact.join("\n")
end
def format_section_header(section)
end
def should_include_row(row, lang)
row.translated_string_for_lang(lang)
def should_include_definition(definition, lang)
definition.translated_string_for_lang(lang)
end
def format_section(section, lang)
rows = section.rows.select { |row| should_include_row(row, lang) }
return if rows.empty?
definitions = section.definitions.select { |definition| should_include_definition(definition, lang) }
return if definitions.empty?
result = ""
@ -125,22 +125,22 @@ module Twine
result += "\n#{section_header}" if section_header
end
rows.map! { |row| format_row(row, lang) }
rows.compact! # remove nil entries
rows.map! { |row| "\n#{row}" } # prepend newline
result += rows.join
definitions.map! { |definition| format_definition(definition, lang) }
definitions.compact! # remove nil definitions
definitions.map! { |definition| "\n#{definition}" } # prepend newline
result += definitions.join
end
def format_row(row, lang)
[format_comment(row, lang), format_key_value(row, lang)].compact.join
def format_definition(definition, lang)
[format_comment(definition, lang), format_key_value(definition, lang)].compact.join
end
def format_comment(row, lang)
def format_comment(definition, lang)
end
def format_key_value(row, lang)
value = row.translated_string_for_lang(lang)
key_value_pattern % { key: format_key(row.key.dup), value: format_value(value.dup) }
def format_key_value(definition, lang)
value = definition.translated_string_for_lang(lang)
key_value_pattern % { key: format_key(definition.key.dup), value: format_value(value.dup) }
end
def key_value_pattern

8
lib/twine/formatters/android.rb
View file

@ -37,7 +37,7 @@ module Twine
path_arr = path.split(File::SEPARATOR)
path_arr.each do |segment|
if segment == 'values'
return @strings.language_codes[0]
return @twine_file.language_codes[0]
else
# The language is defined by a two-letter ISO 639-1 language code, optionally followed by a two letter ISO 3166-1-alpha-2 region code (preceded by lowercase "r").
# see http://developer.android.com/guide/topics/resources/providing-resources.html#AlternativeResources
@ -105,7 +105,7 @@ module Twine
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!-- Android Strings File -->\n<!-- Generated by Twine #{Twine::VERSION} -->\n<!-- Language: #{lang} -->"
end
def format_sections(strings, lang)
def format_sections(twine_file, lang)
result = '<resources>'
result += super + "\n"
@ -117,8 +117,8 @@ module Twine
"\t<!-- SECTION: #{section.name} -->"
end
def format_comment(row, lang)
"\t<!-- #{row.comment.gsub('--', '—')} -->\n" if row.comment
def format_comment(definition, lang)
"\t<!-- #{definition.comment.gsub('--', '—')} -->\n" if definition.comment
end
def key_value_pattern

4
lib/twine/formatters/apple.rb
View file

@ -73,8 +73,8 @@ module Twine
"\"%{key}\" = \"%{value}\";\n"
end
def format_comment(row, lang)
"/* #{row.comment.gsub('*/', '* /')} */\n" if row.comment
def format_comment(definition, lang)
"/* #{definition.comment.gsub('*/', '* /')} */\n" if definition.comment
end
def format_key(key)

14
lib/twine/formatters/django.rb
View file

@ -63,7 +63,7 @@ module Twine
end
def format_file(lang)
@default_lang = @strings.language_codes[0]
@default_lang = @twine_file.language_codes[0]
result = super
@default_lang = nil
result
@ -77,12 +77,12 @@ module Twine
"#--------- #{section.name} ---------#\n"
end
def format_row(row, lang)
[format_comment(row, lang), format_base_translation(row), format_key_value(row, lang)].compact.join
def format_definition(definition, lang)
[format_comment(definition, lang), format_base_translation(definition), format_key_value(definition, lang)].compact.join
end
def format_base_translation(row)
base_translation = row.translations[@default_lang]
def format_base_translation(definition)
base_translation = definition.translations[@default_lang]
"# base translation: \"#{base_translation}\"\n" if base_translation
end
@ -91,8 +91,8 @@ module Twine
"msgstr \"%{value}\"\n"
end
def format_comment(row, lang)
"#. #{escape_quotes(row.comment)}\n" if row.comment
def format_comment(definition, lang)
"#. #{escape_quotes(definition.comment)}\n" if definition.comment
end
def format_key(key)

6
lib/twine/formatters/flash.rb
View file

@ -44,7 +44,7 @@ module Twine
end
end
def format_sections(strings, lang)
def format_sections(twine_file, lang)
super + "\n"
end
@ -56,8 +56,8 @@ module Twine
"## #{section.name} ##\n"
end
def format_comment(row, lang)
"# #{row.comment}\n" if row.comment
def format_comment(definition, lang)
"# #{definition.comment}\n" if definition.comment
end
def key_value_pattern

20
lib/twine/formatters/gettext.rb
View file

@ -64,7 +64,7 @@ module Twine
end
def format_file(lang)
@default_lang = strings.language_codes[0]
@default_lang = twine_file.language_codes[0]
result = super
@default_lang = nil
result
@ -78,25 +78,25 @@ module Twine
"# SECTION: #{section.name}"
end
def should_include_row(row, lang)
super and row.translated_string_for_lang(@default_lang)
def should_include_definition(definition, lang)
super and definition.translated_string_for_lang(@default_lang)
end
def format_comment(row, lang)
"#. \"#{escape_quotes(row.comment)}\"\n" if row.comment
def format_comment(definition, lang)
"#. \"#{escape_quotes(definition.comment)}\"\n" if definition.comment
end
def format_key_value(row, lang)
value = row.translated_string_for_lang(lang)
[format_key(row.key.dup), format_base_translation(row), format_value(value.dup)].compact.join
def format_key_value(definition, lang)
value = definition.translated_string_for_lang(lang)
[format_key(definition.key.dup), format_base_translation(definition), format_value(value.dup)].compact.join
end
def format_key(key)
"msgctxt \"#{key}\"\n"
end
def format_base_translation(row)
"msgid \"#{row.translations[@default_lang]}\"\n"
def format_base_translation(definition)
"msgid \"#{definition.translations[@default_lang]}\"\n"
end
def format_value(value)

12
lib/twine/formatters/jquery.rb
View file

@ -48,8 +48,8 @@ module Twine
"{\n#{super}\n}\n"
end
def format_sections(strings, lang)
sections = strings.sections.map { |section| format_section(section, lang) }
def format_sections(twine_file, lang)
sections = twine_file.sections.map { |section| format_section(section, lang) }
sections.join(",\n\n")
end
@ -57,11 +57,11 @@ module Twine
end
def format_section(section, lang)
rows = section.rows.dup
definitions = section.definitions.dup
rows.map! { |row| format_row(row, lang) }
rows.compact! # remove nil entries
rows.join(",\n")
definitions.map! { |definition| format_definition(definition, lang) }
definitions.compact! # remove nil definitions
definitions.join(",\n")
end
def key_value_pattern

6
lib/twine/formatters/tizen.rb
View file

@ -94,7 +94,7 @@ module Twine
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!-- Tizen Strings File -->\n<!-- Generated by Twine #{Twine::VERSION} -->\n<!-- Language: #{lang} -->"
end
def format_sections(strings, lang)
def format_sections(twine_file, lang)
result = '<string_table Bversion="2.0.0.201311071819" Dversion="20120315">'
result += super + "\n"
@ -106,8 +106,8 @@ module Twine
"\t<!-- SECTION: #{section.name} -->"
end
def format_comment(row, lang)
"\t<!-- #{row.comment.gsub('--', '—')} -->\n" if row.comment
def format_comment(definition, lang)
"\t<!-- #{definition.comment.gsub('--', '—')} -->\n" if definition.comment
end
def key_value_pattern

30
lib/twine/output_processor.rb
View file

@ -2,13 +2,13 @@ module Twine
module Processors
class OutputProcessor
def initialize(strings, options)
@strings = strings
def initialize(twine_file, options)
@twine_file = twine_file
@options = options
end
def default_language
@options[:developer_language] || @strings.language_codes[0]
@options[:developer_language] || @twine_file.language_codes[0]
end
def fallback_languages(language)
@ -20,30 +20,30 @@ module Twine
end
def process(language)
result = StringsFile.new
result = TwineFile.new
result.language_codes.concat @strings.language_codes
@strings.sections.each do |section|
new_section = StringsSection.new section.name
result.language_codes.concat @twine_file.language_codes
@twine_file.sections.each do |section|
new_section = TwineSection.new section.name
section.rows.each do |row|
next unless row.matches_tags?(@options[:tags], @options[:untagged])
section.definitions.each do |definition|
next unless definition.matches_tags?(@options[:tags], @options[:untagged])
value = row.translated_string_for_lang(language)
value = definition.translated_string_for_lang(language)
next if value && @options[:include] == :untranslated
if value.nil? && @options[:include] != :translated
value = row.translated_string_for_lang(fallback_languages(language))
value = definition.translated_string_for_lang(fallback_languages(language))
end
next unless value
new_row = row.dup
new_row.translations[language] = value
new_definition = definition.dup
new_definition.translations[language] = value
new_section.rows << new_row
result.strings_map[new_row.key] = new_row
new_section.definitions << new_definition
result.definitions_by_key[new_definition.key] = new_definition
end
result.sections << new_section

76
lib/twine/runner.rb
View file

@ -8,9 +8,9 @@ module Twine
def self.run(args)
options = CLI.parse(args)
strings = StringsFile.new
strings.read options[:strings_file]
runner = new(options, strings)
twine_file = TwineFile.new
twine_file.read options[:twine_file]
runner = new(options, twine_file)
case options[:command]
when 'generate-string-file'
@ -25,25 +25,25 @@ module Twine
runner.generate_loc_drop
when 'consume-loc-drop'
runner.consume_loc_drop
when 'validate-strings-file'
runner.validate_strings_file
when 'validate-twine-file'
runner.validate_twine_file
end
end
def initialize(options = {}, strings = StringsFile.new)
def initialize(options = {}, twine_file = TwineFile.new)
@options = options
@strings = strings
@twine_file = twine_file
end
def write_strings_data(path)
def write_twine_data(path)
if @options[:developer_language]
@strings.set_developer_language_code(@options[:developer_language])
@twine_file.set_developer_language_code(@options[:developer_language])
end
@strings.write(path)
@twine_file.write(path)
end
def generate_string_file
validate_strings_file if @options[:validate]
validate_twine_file if @options[:validate]
lang = nil
lang = @options[:languages][0] if @options[:languages]
@ -57,7 +57,7 @@ module Twine
end
def generate_all_string_files
validate_strings_file if @options[:validate]
validate_twine_file if @options[:validate]
if !File.directory?(@options[:output_path])
if @options[:create_folders]
@ -76,7 +76,7 @@ module Twine
file_name = @options[:file_name] || formatter.default_file_name
if @options[:create_folders]
@strings.language_codes.each do |lang|
@twine_file.language_codes.each do |lang|
output_path = File.join(@options[:output_path], formatter.output_path_for_language(lang))
FileUtils.mkdir_p(output_path)
@ -128,8 +128,8 @@ module Twine
end
read_string_file(@options[:input_path], lang)
output_path = @options[:output_path] || @options[:strings_file]
write_strings_data(output_path)
output_path = @options[:output_path] || @options[:twine_file]
write_twine_data(output_path)
end
def consume_all_string_files
@ -147,12 +147,12 @@ module Twine
end
end
output_path = @options[:output_path] || @options[:strings_file]
write_strings_data(output_path)
output_path = @options[:output_path] || @options[:twine_file]
write_twine_data(output_path)
end
def generate_loc_drop
validate_strings_file if @options[:validate]
validate_twine_file if @options[:validate]
require_rubyzip
@ -165,7 +165,7 @@ module Twine
zipfile.mkdir('Locales')
formatter = formatter_for_format(@options[:format])
@strings.language_codes.each do |lang|
@twine_file.language_codes.each do |lang|
if @options[:languages] == nil || @options[:languages].length == 0 || @options[:languages].include?(lang)
file_name = lang + formatter.extension
temp_path = File.join(temp_dir, file_name)
@ -209,28 +209,28 @@ module Twine
end
end
output_path = @options[:output_path] || @options[:strings_file]
write_strings_data(output_path)
output_path = @options[:output_path] || @options[:twine_file]
write_twine_data(output_path)
end
def validate_strings_file
total_strings = 0
def validate_twine_file
total_definitions = 0
all_keys = Set.new
duplicate_keys = Set.new
keys_without_tags = Set.new
invalid_keys = Set.new
valid_key_regex = /^[A-Za-z0-9_]+$/
@strings.sections.each do |section|
section.rows.each do |row|
total_strings += 1
@twine_file.sections.each do |section|
section.definitions.each do |definition|
total_definitions += 1
duplicate_keys.add(row.key) if all_keys.include? row.key
all_keys.add(row.key)
duplicate_keys.add(definition.key) if all_keys.include? definition.key
all_keys.add(definition.key)
keys_without_tags.add(row.key) if row.tags == nil or row.tags.length == 0
keys_without_tags.add(definition.key) if definition.tags == nil or definition.tags.length == 0
invalid_keys << row.key unless row.key =~ valid_key_regex
invalid_keys << definition.key unless definition.key =~ valid_key_regex
end
end
@ -238,14 +238,14 @@ module Twine
join_keys = lambda { |set| set.map { |k| " " + k }.join("\n") }
unless duplicate_keys.empty?
errors << "Found duplicate string key(s):\n#{join_keys.call(duplicate_keys)}"
errors << "Found duplicate key(s):\n#{join_keys.call(duplicate_keys)}"
end
if @options[:pedantic]
if keys_without_tags.length == total_strings
errors << "None of your strings have tags."
if keys_without_tags.length == total_definitions
errors << "None of your definitions have tags."
elsif keys_without_tags.length > 0
errors << "Found strings without tags:\n#{join_keys.call(keys_without_tags)}"
errors << "Found definitions without tags:\n#{join_keys.call(keys_without_tags)}"
end
end
@ -255,7 +255,7 @@ module Twine
raise Twine::Error.new errors.join("\n\n") unless errors.empty?
Twine::stdout.puts "#{@options[:strings_file]} is valid."
Twine::stdout.puts "#{@options[:twine_file]} is valid."
end
private
@ -274,7 +274,7 @@ module Twine
def determine_language_given_path(path)
code = File.basename(path, File.extname(path))
return code if @strings.language_codes.include? code
return code if @twine_file.language_codes.include? code
end
def formatter_for_format(format)
@ -284,7 +284,7 @@ module Twine
def find_formatter(&block)
formatter = Formatters.formatters.find &block
return nil unless formatter
formatter.strings = @strings
formatter.twine_file = @twine_file
formatter.options = @options
formatter
end
@ -317,7 +317,7 @@ module Twine
raise Twine::Error.new "Unable to determine language for #{path}"
end
@strings.language_codes << lang unless @strings.language_codes.include? lang
@twine_file.language_codes << lang unless @twine_file.language_codes.include? lang
return formatter, lang
end

84
lib/twine/stringsfile.rb → lib/twine/twine_file.rb
View file

@ -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
@ -37,7 +27,7 @@ module Twine
# The user did not specify any tags. Everything passes.
return true
elsif @tags == nil
# This row has no tags.
# This definition has no tags.
return reference ? reference.matches_tags?(tags, include_untagged) : include_untagged
elsif @tags.empty?
return include_untagged
@ -57,9 +47,19 @@ module Twine
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 +73,7 @@ module Twine
def initialize
@sections = []
@strings_map = {}
@definitions_by_key = {}
@language_codes = []
end
@ -102,7 +102,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 +115,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 +141,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 +163,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 +180,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 +208,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] == '`')

6
test/command_test_case.rb
View file

@ -2,11 +2,11 @@ require 'twine_test_case'
class CommandTestCase < TwineTestCase
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

68
test/test_abstract_formatter.rb
View file

@ -5,74 +5,74 @@ class TestAbstractFormatter < TwineTestCase
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
@ -80,27 +80,27 @@ class TestAbstractFormatter < TwineTestCase
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
@ -108,28 +108,28 @@ class TestAbstractFormatter < TwineTestCase
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
@ -137,28 +137,28 @@ class TestAbstractFormatter < TwineTestCase
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

78
test/test_cli.rb
View file

@ -4,7 +4,7 @@ class CLITestCase < TwineTestCase
def setup
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
@ -15,203 +15,203 @@ class CLITestCase < TwineTestCase
class TestValidateStringsFile < CLITestCase
def test_command
parse "validate-strings-file #{@strings_file_path}"
parse "validate-twine-file #{@twine_file_path}"
assert_equal 'validate-strings-file', @options[:command]
assert_equal @strings_file_path, @options[:strings_file]
assert_equal 'validate-twine-file', @options[:command]
assert_equal @twine_file_path, @options[:twine_file]
end
def test_pedantic
parse "validate-strings-file #{@strings_file_path} --pedantic"
parse "validate-twine-file #{@twine_file_path} --pedantic"
assert @options[:pedantic]
end
def test_missing_parameter
assert_raises Twine::Error do
parse 'validate-strings-file'
parse 'validate-twine-file'
end
end
def test_extra_parameter
assert_raises Twine::Error do
parse 'validate-strings-file strings extra'
parse 'validate-twine-file twine_file extra'
end
end
end
class TestGenerateStringFile < CLITestCase
def test_command
parse "generate-string-file #{@strings_file_path} #{@output_path}"
parse "generate-string-file #{@twine_file_path} #{@output_path}"
assert_equal 'generate-string-file', @options[:command]
assert_equal @strings_file_path, @options[:strings_file]
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-string-file strings'
parse 'generate-string-file twine_file'
end
end
def test_validate
parse "generate-string-file #{@strings_file_path} #{@output_path} --validate"
parse "generate-string-file #{@twine_file_path} #{@output_path} --validate"
assert @options[:validate]
end
def test_extra_parameter
assert_raises Twine::Error do
parse 'generate-string-file strings output extra'
parse 'generate-string-file twine_file output extra'
end
end
def test_only_allows_one_language
assert_raises Twine::Error do
parse "generate-string-file strings output --lang en,fr"
parse "generate-string-file twine_file output --lang en,fr"
end
end
end
class TestGenerateAllStringFiles < CLITestCase
def test_command
parse "generate-all-string-files #{@strings_file_path} #{@output_dir}"
parse "generate-all-string-files #{@twine_file_path} #{@output_dir}"
assert_equal 'generate-all-string-files', @options[:command]
assert_equal @strings_file_path, @options[:strings_file]
assert_equal @twine_file_path, @options[:twine_file]
assert_equal @output_dir, @options[:output_path]
end
def test_missing_parameter
assert_raises Twine::Error do
parse "generate-all-string-files strings"
parse "generate-all-string-files twine_file"
end
end
def test_validate
parse "generate-all-string-files #{@strings_file_path} #{@output_dir} --validate"
parse "generate-all-string-files #{@twine_file_path} #{@output_dir} --validate"
assert @options[:validate]
end
def test_extra_parameter
assert_raises Twine::Error do
parse "generate-all-string-files strings output extra"
parse "generate-all-string-files twine_file output extra"
end
end
end
class TestConsumeStringFile < CLITestCase
def test_command
parse "consume-string-file #{@strings_file_path} #{@input_path}"
parse "consume-string-file #{@twine_file_path} #{@input_path}"
assert_equal 'consume-string-file', @options[:command]
assert_equal @strings_file_path, @options[:strings_file]
assert_equal @twine_file_path, @options[:twine_file]
assert_equal @input_path, @options[:input_path]
end
def test_missing_parameter
assert_raises Twine::Error do
parse "consume-string-file strings"
parse "consume-string-file twine_file"
end
end
def test_extra_parameter
assert_raises Twine::Error do
parse "consume-string-file strings output extra"
parse "consume-string-file twine_file output extra"
end
end
def test_only_allows_one_language
assert_raises Twine::Error do
parse "consume-string-file strings output --lang en,fr"
parse "consume-string-file twine_file output --lang en,fr"
end
end
end
class TestConsumeAllStringFiles < CLITestCase
def test_command
parse "consume-all-string-files #{@strings_file_path} #{@input_dir}"
parse "consume-all-string-files #{@twine_file_path} #{@input_dir}"
assert_equal 'consume-all-string-files', @options[:command]
assert_equal @strings_file_path, @options[:strings_file]
assert_equal @twine_file_path, @options[:twine_file]
assert_equal @input_dir, @options[:input_path]
end
def test_missing_parameter
assert_raises Twine::Error do
parse "consume-all-string-files strings"
parse "consume-all-string-files twine_file"
end
end
def test_extra_parameter
assert_raises Twine::Error do
parse "consume-all-string-files strings output extra"
parse "consume-all-string-files twine_file output extra"
end
end
end
class TestGenerateLocDrop < CLITestCase
def test_command
parse "generate-loc-drop #{@strings_file_path} #{@output_path} --format apple"
parse "generate-loc-drop #{@twine_file_path} #{@output_path} --format apple"
assert_equal 'generate-loc-drop', @options[:command]
assert_equal @strings_file_path, @options[:strings_file]
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"
parse "generate-loc-drop twine_file --format apple"
end
end
def test_validate
parse "generate-loc-drop #{@strings_file_path} #{@output_path} --format apple --validate"
parse "generate-loc-drop #{@twine_file_path} #{@output_path} --format apple --validate"
assert @options[:validate]
end
def test_extra_parameter
assert_raises Twine::Error do
parse "generate-loc-drop strings output extra --format apple"
parse "generate-loc-drop twine_file output extra --format apple"
end
end
def test_format_needed
assert_raises Twine::Error do
parse "generate-loc-drop strings output"
parse "generate-loc-drop twine_file output"
end
end
end
class TestConsumeLocDrop < CLITestCase
def test_command
parse "consume-loc-drop #{@strings_file_path} #{@input_path}"
parse "consume-loc-drop #{@twine_file_path} #{@input_path}"
assert_equal 'consume-loc-drop', @options[:command]
assert_equal @strings_file_path, @options[:strings_file]
assert_equal @twine_file_path, @options[:twine_file]
assert_equal @input_path, @options[:input_path]
end
def test_missing_parameter
assert_raises Twine::Error do
parse "consume-loc-drop strings"
parse "consume-loc-drop twine_file"
end
end
def test_extra_parameter
assert_raises Twine::Error do
parse "consume-loc-drop strings input extra"
parse "consume-loc-drop twine_file input extra"
end
end
end
class TestParameters < CLITestCase
def parse_with(parameter)
parse 'validate-strings-file input.txt ' + parameter
parse 'validate-twine-file input.txt ' + parameter
end
def test_default_options
parse_with ''
expected = {command: 'validate-strings-file', strings_file: 'input.txt', include: :all}
expected = {command: 'validate-twine-file', twine_file: 'input.txt', include: :all}
assert_equal expected, @options
end

6
test/test_consume_loc_drop.rb
View file

@ -11,7 +11,7 @@ class TestConsumeLocDrop < CommandTestCase
@twine_file = build_twine_file 'en', 'es' do
add_section 'Section' do
add_row key1: 'value1'
add_definition key1: 'value1'
end
end
@ -21,7 +21,7 @@ class TestConsumeLocDrop < CommandTestCase
def test_consumes_zip_file
@runner.consume_loc_drop
assert @twine_file.strings_map['key1'].translations['en'], 'value1-english'
assert @twine_file.strings_map['key1'].translations['es'], 'value1-spanish'
assert @twine_file.definitions_by_key['key1'].translations['en'], 'value1-english'
assert @twine_file.definitions_by_key['key1'].translations['es'], 'value1-spanish'
end
end

12
test/test_consume_string_file.rb
View file

@ -8,10 +8,10 @@ class TestConsumeStringFile < CommandTestCase
FileUtils.touch options[:input_path]
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_read_formatter(formatter_class)
@ -75,10 +75,10 @@ class TestConsumeStringFile < CommandTestCase
options[:encoding] = encoding if encoding
options[:languages] = 'en'
@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 setup

58
test/test_formatters.rb
View file

@ -6,33 +6,33 @@ class FormatterTest < TwineTestCase
@twine_file = build_twine_file 'en' do
add_section 'Section 1' do
add_row key1: 'value1-english', comment: 'comment key1'
add_row key2: 'value2-english'
add_definition key1: 'value1-english', comment: 'comment key1'
add_definition key2: 'value2-english'
end
add_section 'Section 2' do
add_row key3: 'value3-english'
add_row key4: 'value4-english', comment: 'comment key4'
add_definition key3: 'value3-english'
add_definition key4: 'value4-english', comment: 'comment key4'
end
end
@strings = Twine::StringsFile.new
@empty_twine_file = Twine::TwineFile.new
@formatter = formatter_class.new
@formatter.strings = @strings
@formatter.twine_file = @empty_twine_file
@formatter.options = { consume_all: true, consume_comments: true }
end
def assert_translations_read_correctly
1.upto(4) do |i|
assert_equal "value#{i}-english", @strings.strings_map["key#{i}"].translations['en']
assert_equal "value#{i}-english", @empty_twine_file.definitions_by_key["key#{i}"].translations['en']
end
end
def assert_file_contents_read_correctly
assert_translations_read_correctly
assert_equal "comment key1", @strings.strings_map["key1"].comment
assert_equal "comment key4", @strings.strings_map["key4"].comment
assert_equal "comment key1", @empty_twine_file.definitions_by_key["key1"].comment
assert_equal "comment key4", @empty_twine_file.definitions_by_key["key4"].comment
end
end
@ -49,27 +49,27 @@ class TestAndroidFormatter < FormatterTest
def test_set_translation_converts_leading_spaces
@formatter.set_translation_for_key 'key1', 'en', "\u0020value"
assert_equal ' value', @strings.strings_map['key1'].translations['en']
assert_equal ' value', @empty_twine_file.definitions_by_key['key1'].translations['en']
end
def test_set_translation_coverts_trailing_spaces
@formatter.set_translation_for_key 'key1', 'en', "value\u0020\u0020"
assert_equal 'value ', @strings.strings_map['key1'].translations['en']
assert_equal 'value ', @empty_twine_file.definitions_by_key['key1'].translations['en']
end
def test_set_translation_converts_string_placeholders
@formatter.set_translation_for_key 'key1', 'en', "value %s"
assert_equal 'value %@', @strings.strings_map['key1'].translations['en']
assert_equal 'value %@', @empty_twine_file.definitions_by_key['key1'].translations['en']
end
def test_set_translation_unescapes_at_signs
@formatter.set_translation_for_key 'key1', 'en', '\@value'
assert_equal '@value', @strings.strings_map['key1'].translations['en']
assert_equal '@value', @empty_twine_file.definitions_by_key['key1'].translations['en']
end
def test_format_file
formatter = Twine::Formatters::Android.new
formatter.strings = @twine_file
formatter.twine_file = @twine_file
assert_equal content('formatter_android.xml'), formatter.format_file('en')
end
@ -139,47 +139,47 @@ class TestAppleFormatter < FormatterTest
def test_reads_quoted_keys
@formatter.read StringIO.new('"key" = "value"'), 'en'
assert_equal 'value', @strings.strings_map['key'].translations['en']
assert_equal 'value', @empty_twine_file.definitions_by_key['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']
assert_equal 'value', @empty_twine_file.definitions_by_key['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']
assert_equal 'value', @empty_twine_file.definitions_by_key['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']
assert_equal 'value', @empty_twine_file.definitions_by_key['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']
assert_equal 'value', @empty_twine_file.definitions_by_key['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']
assert_nil @empty_twine_file.definitions_by_key['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']
assert_equal 'value', @empty_twine_file.definitions_by_key['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']
assert_nil @empty_twine_file.definitions_by_key['key']
end
def test_format_file
formatter = Twine::Formatters::Apple.new
formatter.strings = @twine_file
formatter.twine_file = @twine_file
assert_equal content('formatter_apple.strings'), formatter.format_file('en')
end
@ -210,7 +210,7 @@ class TestJQueryFormatter < FormatterTest
def test_format_file
formatter = Twine::Formatters::JQuery.new
formatter.strings = @twine_file
formatter.twine_file = @twine_file
assert_equal content('formatter_jquery.json'), formatter.format_file('en')
end
@ -234,12 +234,12 @@ class TestGettextFormatter < FormatterTest
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']
assert_equal 'multiline\nstring', @empty_twine_file.definitions_by_key['key1'].translations['en']
end
def test_format_file
formatter = Twine::Formatters::Gettext.new
formatter.strings = @twine_file
formatter.twine_file = @twine_file
assert_equal content('formatter_gettext.po'), formatter.format_file('en')
end
@ -260,7 +260,7 @@ class TestTizenFormatter < FormatterTest
def test_format_file
formatter = Twine::Formatters::Tizen.new
formatter.strings = @twine_file
formatter.twine_file = @twine_file
assert_equal content('formatter_tizen.xml'), formatter.format_file('en')
end
@ -279,7 +279,7 @@ class TestDjangoFormatter < FormatterTest
def test_format_file
formatter = Twine::Formatters::Django.new
formatter.strings = @twine_file
formatter.twine_file = @twine_file
assert_equal content('formatter_django.po'), formatter.format_file('en')
end
end
@ -297,7 +297,7 @@ class TestFlashFormatter < FormatterTest
def test_format_file
formatter = Twine::Formatters::Flash.new
formatter.strings = @twine_file
formatter.twine_file = @twine_file
assert_equal content('formatter_flash.properties'), formatter.format_file('en')
end
end

10
test/test_generate_all_string_files.rb
View file

@ -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
@ -79,21 +79,21 @@ 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
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
end

10
test/test_generate_loc_drop.rb
View file

@ -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
@ -57,21 +57,21 @@ 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
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
end

14
test/test_generate_string_file.rb
View file

@ -6,10 +6,10 @@ class TestGenerateStringFile < CommandTestCase
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)
@ -68,21 +68,21 @@ 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
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
end

46
test/test_output_processor.rb
View file

@ -4,81 +4,81 @@ class TestOutputProcessor < TwineTestCase
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
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

58
test/test_strings_file.rb
View file

@ -1,58 +0,0 @@
require 'twine_test_case'
class TestStringsFile < TwineTestCase
class Reading < TwineTestCase
def setup
super
@strings = Twine::StringsFile.new
@strings.read fixture_path('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'), File.read(@output_path)
end
end
end

47
test/test_strings_row.rb
View file

@ -1,47 +0,0 @@
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

47
test/test_twine_entry.rb Normal file
View file

@ -0,0 +1,47 @@
require 'twine_test_case'
class TestTwineDefinition < TwineTestCase
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.translated_string_for_lang('en')
end
def test_reference_translation_override
@definition.translations['en'] = 'value'
assert_equal 'value', @definition.translated_string_for_lang('en')
end
end

58
test/test_twine_file.rb Normal file
View file

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

32
test/test_validate_strings_file.rb
View file

@ -5,57 +5,57 @@ require 'command_test_case'
class TestValidateStringsFile < CommandTestCase
def setup
super
@options = { strings_file: 'input.txt' }
@options = { twine_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']
add_definition key1: 'value1', tags: ['tag1']
add_definition key2: 'value2', tags: ['tag1']
end
add_section 'Section 2' do
add_row key3: 'value3', tags: ['tag1', 'tag2']
add_row key4: 'value4', tags: ['tag2']
add_definition key3: 'value3', tags: ['tag1', 'tag2']
add_definition key4: 'value4', tags: ['tag2']
end
end
end
def random_row
@twine_file.strings_map[@twine_file.strings_map.keys.sample]
def random_definition
@twine_file.definitions_by_key[@twine_file.definitions_by_key.keys.sample]
end
def test_recognizes_valid_file
Twine::Runner.new(@options, @twine_file).validate_strings_file
Twine::Runner.new(@options, @twine_file).validate_twine_file
assert_equal "input.txt is valid.\n", Twine::stdout.string
end
def test_reports_duplicate_keys
@twine_file.sections[0].rows << random_row
@twine_file.sections[0].definitions << random_definition
assert_raises Twine::Error do
Twine::Runner.new(@options, @twine_file).validate_strings_file
Twine::Runner.new(@options, @twine_file).validate_twine_file
end
end
def test_reports_invalid_characters_in_keys
random_row.key[0] = "!?;:,^`´'\"\\|/(){}[]~-+*=#$%".chars.to_a.sample
random_definition.key[0] = "!?;:,^`´'\"\\|/(){}[]~-+*=#$%".chars.to_a.sample
assert_raises Twine::Error do
Twine::Runner.new(@options, @twine_file).validate_strings_file
Twine::Runner.new(@options, @twine_file).validate_twine_file
end
end
def test_does_not_reports_missing_tags_by_default
random_row.tags.clear
random_definition.tags.clear
Twine::Runner.new(@options, @twine_file).validate_strings_file
Twine::Runner.new(@options, @twine_file).validate_twine_file
end
def test_reports_missing_tags
random_row.tags.clear
random_definition.tags.clear
assert_raises Twine::Error do
Twine::Runner.new(@options.merge(pedantic: true), @twine_file).validate_strings_file
Twine::Runner.new(@options.merge(pedantic: true), @twine_file).validate_twine_file
end
end
end

24
test/twine_file_dsl.rb
View file

@ -1,6 +1,6 @@
module TwineFileDSL
def build_twine_file(*languages)
@currently_built_twine_file = Twine::StringsFile.new
@currently_built_twine_file = Twine::TwineFile.new
@currently_built_twine_file.language_codes.concat languages
yield
result = @currently_built_twine_file
@ -10,37 +10,37 @@ module TwineFileDSL
def add_section(name)
return unless @currently_built_twine_file
@currently_built_twine_file_section = Twine::StringsSection.new name
@currently_built_twine_file_section = Twine::TwineSection.new name
@currently_built_twine_file.sections << @currently_built_twine_file_section
yield
@currently_built_twine_file_section = nil
end
def add_row(parameters)
def add_definition(parameters)
return unless @currently_built_twine_file
return unless @currently_built_twine_file_section
# this relies on Ruby preserving the order of hash elements
key, value = parameters.first
row = Twine::StringsRow.new(key.to_s)
definition = Twine::TwineDefinition.new(key.to_s)
if value.is_a? Hash
value.each do |language, translation|
row.translations[language.to_s] = translation
definition.translations[language.to_s] = translation
end
elsif !value.is_a? Symbol
language = @currently_built_twine_file.language_codes.first
row.translations[language] = value
definition.translations[language] = value
end
row.comment = parameters[:comment] if parameters[:comment]
row.tags = parameters[:tags] if parameters[:tags]
definition.comment = parameters[:comment] if parameters[:comment]
definition.tags = parameters[:tags] if parameters[:tags]
if parameters[:ref] || value.is_a?(Symbol)
reference_key = (parameters[:ref] || value).to_s
row.reference_key = reference_key
row.reference = @currently_built_twine_file.strings_map[reference_key]
definition.reference_key = reference_key
definition.reference = @currently_built_twine_file.definitions_by_key[reference_key]
end
@currently_built_twine_file_section.rows << row
@currently_built_twine_file.strings_map[row.key] = row
@currently_built_twine_file_section.definitions << definition
@currently_built_twine_file.definitions_by_key[definition.key] = definition
end
end