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

Renamed commands to get rid of more 'string' ambiguities.

Browse source
This commit is contained in:
Sebastian Ludwig 2016-03-31 22:29:47 +02:00
parent b1b59f4f62
commit ef84dd322c
15 changed files with 179 additions and 164 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

52
README.md
View file

@ -23,7 +23,7 @@ Make sure you run the `twine` executable at the root of the project as it proper
## Twine File Format
Twine stores everything in a single file, the Twine data file. The format of this file is a slight variant of the [Git][git] config file format, which itself is based on the old [Windows INI file][INI] format. The entire file is broken up into sections, which are created by placing the section name between two pairs of square brackets. Sections are optional, but they are the recommended way of grouping your strings into smaller, more manageable chunks.
Twine stores everything in a single file, the Twine data file. The format of this file is a slight variant of the [Git][git] config file format, which itself is based on the old [Windows INI file][INI] format. The entire file is broken up into sections, which are created by placing the section name between two pairs of square brackets. Sections are optional, but they are the recommended way of grouping your definitions into smaller, more manageable chunks.
Each grouping section contains N definitions. These definitions start with the key placed within a single pair of square brackets. It then contains a number of key-value pairs, including a comment, a comma-separated list of tags and all of the translations.
@ -100,46 +100,46 @@ If you would like to enable Twine to create localization files in another format
### Commands
#### `generate-string-file`
#### `generate-localization-file`
This command creates a localization file from the Twine data file. If the output file would not contain any translations, Twine will exit with an error.
$ twine generate-string-file /path/to/twine.txt values-ja.xml --tags common,app1
$ twine generate-string-file /path/to/twine.txt Localizable.strings --lang ja --tags mytag
$ twine generate-string-file /path/to/twine.txt all-english.strings --lang en
$ twine generate-localization-file /path/to/twine.txt values-ja.xml --tags common,app1
$ twine generate-localization-file /path/to/twine.txt Localizable.strings --lang ja --tags mytag
$ twine generate-localization-file /path/to/twine.txt all-english.strings --lang en
#### `generate-all-string-files`
#### `generate-all-localization-files`
This command is a convenient way to call [`generate-string-file`](#generate-string-file) multiple times. It uses standard conventions to figure out exactly which files to create given a parent directory. For example, if you point it to a parent directory containing `en.lproj`, `fr.lproj`, and `ja.lproj` subdirectories, Twine will create a `Localizable.strings` file of the appropriate language in each of them. However, files that would not contain any translations will not be created; instead warnings will be logged to `stderr`. This is often the command you will want to execute during the build phase of your project.
This command is a convenient way to call [`generate-localization-file`](#generate-localization-file) multiple times. It uses standard conventions to figure out exactly which files to create given a parent directory. For example, if you point it to a parent directory containing `en.lproj`, `fr.lproj`, and `ja.lproj` subdirectories, Twine will create a `Localizable.strings` file of the appropriate language in each of them. However, files that would not contain any translations will not be created; instead warnings will be logged to `stderr`. This is often the command you will want to execute during the build phase of your project.
$ twine generate-all-string-files /path/to/twine.txt /path/to/project/locales/directory --tags common,app1
$ twine generate-all-localization-files /path/to/twine.txt /path/to/project/locales/directory --tags common,app1
#### `consume-string-file`
#### `consume-localization-file`
This command slurps all of the translations from a localization file and incorporates the translated strings into the Twine data file. This is a simple way to incorporate any changes made to a single file by one of your translators. It will only identify definitions that already exist in the data file.
$ twine consume-string-file /path/to/twine.txt fr.strings
$ twine consume-string-file /path/to/twine.txt Localizable.strings --lang ja
$ twine consume-string-file /path/to/twine.txt es.xml
$ twine consume-localization-file /path/to/twine.txt fr.strings
$ twine consume-localization-file /path/to/twine.txt Localizable.strings --lang ja
$ twine consume-localization-file /path/to/twine.txt es.xml
#### `consume-all-string-files`
#### `consume-all-localization-files`
This command reads in a folder containing many localization files. These files should be in a standard folder hierarchy so that Twine knows the language of each file. When combined with the `--developer-language`, `--consume-comments`, and `--consume-all` flags, this command is a great way to create your initial Twine data file from an existing project. Just make sure that you create a blank Twine data file first!
$ twine consume-all-string-files twine.txt Resources/Locales --developer-language en --consume-all --consume-comments
$ twine consume-all-localization-files twine.txt Resources/Locales --developer-language en --consume-all --consume-comments
#### `generate-loc-drop`
This command is a convenient way to generate a zip file containing files created by the [`generate-string-file`](#generate-string-file) command. If a file would not contain any translated strings, it is skipped and a warning is logged to `stderr`. This command can be used to create a single zip containing a large number of strings in all languages which you can then hand off to your translation team.
This command is a convenient way to generate a zip file containing files created by the [`generate-localization-file`](#generate-localization-file) command. If a file would not contain any translated strings, it is skipped and a warning is logged to `stderr`. This command can be used to create a single zip containing a large number of translations in all languages which you can then hand off to your translation team.
$ twine generate-loc-drop /path/to/twine.txt LocDrop1.zip
$ twine generate-loc-drop /path/to/twine.txt LocDrop2.zip --lang en,fr,ja,ko --tags common,app1
#### `consume-loc-drop`
This command is a convenient way of taking a zip file and executing the [`consume-string-file`](#consume-string-file) command on each file within the archive. It is most often used to incorporate all of the changes made by the translation team after they have completed work on a localization drop.
This command is a convenient way of taking a zip file and executing the [`consume-localization-file`](#consume-localization-file) command on each file within the archive. It is most often used to incorporate all of the changes made by the translation team after they have completed work on a localization drop.
$ twine consume-loc-drop /path/to/twine_strings.txt LocDrop2.zip
$ twine consume-loc-drop /path/to/twine.txt LocDrop2.zip
#### `validate-twine-file`
@ -149,10 +149,10 @@ This command validates that the Twine data file can be parsed, contains no dupli
## Creating Your First Twine Data File
The easiest way to create your first Twine Data file is to run the [`consume-all-string-files`](#consume-all-string-files) command. The one caveat is to first create a blank file to use as your starting point. Then, just point the `consume-all-string-files` command at a directory in your project containing all of your localization files.
The easiest way to create your first Twine data file is to run the [`consume-all-localization-files`](#consume-all-localization-files) command. The one caveat is to first create a blank file to use as your starting point. Then, just point the `consume-all-localization-files` command at a directory in your project containing all of your localization files.
$ touch twine.txt
$ twine consume-all-string-files twine.txt Resources/Locales --developer-language en --consume-all --consume-comments
$ twine consume-all-localization-files twine.txt Resources/Locales --developer-language en --consume-all --consume-comments
## Twine and Your Build Process
@ -161,9 +161,9 @@ The easiest way to create your first Twine Data file is to run the [`consume-all
It is easy to incorporate Twine right into your iOS and OS X app build processes.
1. In your project folder, create all of the `.lproj` directories that you need. It does not really matter where they are. We tend to put them in `Resources/Locales/`.
2. Run the [`generate-all-string-files`](#generate-all-string-files) command to create all of the string files you need in these directories. For example,
2. Run the [`generate-all-localization-files`](#generate-all-localization-files) command to create all of the `.strings` files you need in these directories. For example,
$ twine generate-all-string-files twine.txt Resources/Locales/ --tags tag1,tag2
$ twine generate-all-localization-files twine.txt Resources/Locales/ --tags tag1,tag2
Make sure you point Twine at your data file, the directory that contains all of your `.lproj` directories, and the tags that describe the definitions you want to use for this project.
3. Drag the `Resources/Locales/` directory to the Xcode project navigator so that Xcode knows to include all of these `.strings` files in your build.
@ -178,8 +178,8 @@ Now, whenever you build your application, Xcode will automatically invoke Twine
Add the following task at the top level in app/build.gradle:
```
task generateStrings {
String script = 'if hash twine 2>/dev/null; then twine generate-string-file strings.txt ./src/main/res/values/generated_strings.xml; fi'
task generateLocalizations {
Localization script = 'if hash twine 2>/dev/null; then twine generate-localization-file twine.txt ./src/main/res/values/generated_strings.xml; fi'
exec {
executable "sh"
args '-c', script
@ -187,12 +187,12 @@ task generateStrings {
}
```
Now every time you build your app the strings are generated from the twine file.
Now every time you build your app the localization files are generated from the Twine file.
## User Interface
* [Twine TextMate 2 Bundle](https://github.com/mobiata/twine.tmbundle) — This [TextMate 2](https://github.com/textmate/textmate) bundle will make it easier for you to work with Twine strings files. In particular, it lets you use code folding to easily collapse and expand both strings and sections.
* [Twine TextMate 2 Bundle](https://github.com/mobiata/twine.tmbundle) — This [TextMate 2](https://github.com/textmate/textmate) bundle will make it easier for you to work with Twine files. In particular, it lets you use code folding to easily collapse and expand both definitions and sections.
* [twine_ui](https://github.com/Daij-Djan/twine_ui) — A user interface for Twine written by [Dominik Pich](https://github.com/Daij-Djan/). Consider using this if you would prefer to use Twine without dropping to a command line.
## Plugin Support
@ -229,7 +229,7 @@ Many thanks to all of the contributors to the Twine project, including:
* [Kevin Wood](https://github.com/kwood)
* [Mohammad Hejazi](https://github.com/MohammadHejazi)
* [Robert Guo](http://www.robertguo.me/)
* [sebastianludwig](https://github.com/sebastianludwig)
* [Sebastian Ludwig](https://github.com/sebastianludwig)
* [Sergey Pisarchik](https://github.com/SergeyPisarchik)
* [Shai Shamir](https://github.com/pichirichi)

109
lib/twine/cli.rb
View file

@ -3,10 +3,10 @@ require 'optparse'
module Twine
module CLI
NEEDED_COMMAND_ARGUMENTS = {
'generate-string-file' => 3,
'generate-all-string-files' => 3,
'consume-string-file' => 3,
'consume-all-string-files' => 3,
'generate-localization-file' => 3,
'generate-all-localization-files' => 3,
'consume-localization-file' => 3,
'consume-all-localization-files' => 3,
'generate-loc-drop' => 3,
'consume-loc-drop' => 3,
'validate-twine-file' => 2
@ -16,44 +16,44 @@ module Twine
options = { include: :all }
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.banner = 'Usage: twine COMMAND TWINE_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 localization files to ship with your products.'
opts.separator ''
opts.separator 'Commands:'
opts.separator ''
opts.separator '- generate-string-file'
opts.separator ' Generates a string file in a certain LANGUAGE given a particular FORMAT. This script will attempt to guess both the language and the format given the filename and extension. For example, "ko.xml" will generate a Korean language file for Android.'
opts.separator '- generate-localization-file'
opts.separator ' Generates a localization file in a certain LANGUAGE given a particular FORMAT. This script will attempt to guess both the language and the format given the filename and extension. For example, "ko.xml" will generate a Korean language file for Android.'
opts.separator ''
opts.separator '- generate-all-string-files'
opts.separator ' Generates all the string files necessary for a given project. The parent directory to all of the locale-specific directories in your project should be specified as the INPUT_OR_OUTPUT_PATH. This command will most often be executed by your build script so that each build always contains the most recent strings.'
opts.separator '- generate-all-localization-files'
opts.separator ' Generates all the localization files necessary for a given project. The parent directory to all of the locale-specific directories in your project should be specified as the INPUT_OR_OUTPUT_PATH. This command will most often be executed by your build script so that each build always contains the most recent translations.'
opts.separator ''
opts.separator '- consume-string-file'
opts.separator ' Slurps all of the strings from a translated strings file into the specified STRINGS_FILE. If you have some files returned to you by your translators you can use this command to incorporate all of their changes. This script will attempt to guess both the language and the format given the filename and extension. For example, "ja.strings" will assume that the file is a Japanese iOS strings file.'
opts.separator '- consume-localization-file'
opts.separator ' Slurps all of the translations from a localization file into the specified TWINE_FILE. If you have some files returned to you by your translators you can use this command to incorporate all of their changes. This script will attempt to guess both the language and the format given the filename and extension. For example, "ja.strings" will assume that the file is a Japanese iOS strings file.'
opts.separator ''
opts.separator '- consume-all-string-files'
opts.separator ' Slurps all of the strings from a directory into the specified STRINGS_FILE. If you have some files returned to you by your translators you can use this command to incorporate all of their changes. This script will attempt to guess both the language and the format given the filename and extension. For example, "ja.strings" will assume that the file is a Japanese iOS strings file.'
opts.separator '- consume-all-localization-files'
opts.separator ' Slurps all of the translations from a directory into the specified TWINE_FILE. If you have some files returned to you by your translators you can use this command to incorporate all of their changes. This script will attempt to guess both the language and the format given the filename and extension. For example, "ja.strings" will assume that the file is a Japanese iOS strings file.'
opts.separator ''
opts.separator '- generate-loc-drop'
opts.separator ' Generates a zip archive of strings files in any format. The purpose of this command is to create a very simple archive that can be handed off to a translation team. The translation team can unzip the archive, translate all of the strings in the archived files, zip everything back up, and then hand that final archive back to be consumed by the consume-loc-drop command.'
opts.separator ' Generates a zip archive of localization files in a given format. The purpose of this command is to create a very simple archive that can be handed off to a translation team. The translation team can unzip the archive, translate all of the strings in the archived files, zip everything back up, and then hand that final archive back to be consumed by the consume-loc-drop command.'
opts.separator ''
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-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 ' Validates that the given Twine file is parseable, contains no duplicates, and that no key contains invalid characters. Exits with a non-zero exit code if those criteria are not met.'
opts.separator ''
opts.separator 'General Options:'
opts.separator ''
opts.on('-l', '--lang LANGUAGES', Array, 'The language code(s) to use for the specified action.') do |l|
options[:languages] = l
end
opts.on('-t', '--tags TAG1,TAG2,TAG3', Array, 'The tag(s) to use for the specified action. Only strings with that tag will be processed. Omit this option to match',
' all strings in the strings data file.') do |t|
opts.on('-t', '--tags TAG1,TAG2,TAG3', Array, 'The tag(s) to use for the specified action. Only definitions with that tag will be processed. Omit this option to match',
' all definitions in the Twine data file.') do |t|
options[:tags] = t
end
opts.on('-u', '--[no-]untagged', 'If you have specified tags using the --tags flag, then only those tags will be selected. If you also want to select',
' all strings that are untagged, then you can specify this option to do so.') do |u|
' all definitions that are untagged, then you can specify this option to do so.') do |u|
options[:untagged] = u
end
formats = Formatters.formatters.map(&:format_name).map(&:downcase)
@ -61,36 +61,36 @@ module Twine
" Additional formatters can be placed in the formats/ directory.") do |f|
options[:format] = f
end
opts.on('-a', '--[no-]consume-all', 'Normally, when consuming a string file, Twine will ignore any string keys that do not exist in your master file.') do |a|
opts.on('-a', '--[no-]consume-all', 'Normally, when consuming a localization file, Twine will ignore any translation keys that do not exist in your Twine file.') do |a|
options[:consume_all] = true
end
opts.on('-i', '--include SET', [:all, :translated, :untranslated],
"This flag will determine which strings are included when generating strings files. It's possible values:",
" all: All strings both translated and untranslated for the specified language are included. This is the default value.",
" translated: Only translated strings are included.",
" untranslated: Only untranslated strings are included.") do |i|
"This flag will determine which definitions are included when generating localization files. It's possible values are:",
" all: All definitions both translated and untranslated for the specified language are included. This is the default value.",
" translated: Only definitions with translation for the specified language are included.",
" untranslated: Only definitions without translation for the specified language are included.") do |i|
options[:include] = i
end
opts.on('-o', '--output-file OUTPUT_FILE', 'Write the new strings database to this file instead of replacing the original file. This flag is only useful when',
' running the consume-string-file or consume-loc-drop commands.') do |o|
opts.on('-o', '--output-file OUTPUT_FILE', 'Write a new Twine file at this location instead of replacing the original file. This flag is only useful when',
' running the consume-localization-file or consume-loc-drop commands.') do |o|
options[:output_path] = o
end
opts.on('-n', '--file-name FILE_NAME', 'When running the generate-all-string-files command, this flag may be used to overwrite the default file name of the format.') do |n|
opts.on('-n', '--file-name FILE_NAME', 'When running the generate-all-localization-files command, this flag may be used to overwrite the default file name of the format.') do |n|
options[:file_name] = n
end
opts.on('-r', '--[no-]create-folders', "When running the generate-all-string-files command, this flag may be used to create output folders for all languages,",
opts.on('-r', '--[no-]create-folders', "When running the generate-all-localization-files command, this flag may be used to create output folders for all languages,",
" if they don't exist yet. As a result all languages will be exported, not only the ones where an output folder already",
" exists.") do |r|
options[:create_folders] = r
end
opts.on('-d', '--developer-language LANG', 'When writing the strings data file, set the specified language as the "developer language". In practice, this just',
' means that this language will appear first in the strings data file. When generating files this language will be',
' used as default language and its translations will be used if a key is not localized for the output language.') do |d|
opts.on('-d', '--developer-language LANG', 'When writing the Twine data file, set the specified language as the "developer language". In practice, this just',
' means that this language will appear first in the Twine data file. When generating files this language will be',
' used as default language and its translations will be used if a definition is not localized for the output language.') do |d|
options[:developer_language] = d
end
opts.on('-c', '--[no-]consume-comments', 'Normally, when consuming a string file, Twine will ignore all comments in the file. With this flag set, any comments',
' encountered will be read and parsed into the strings data file. This is especially useful when creating your first',
' strings data file from an existing project.') do |c|
opts.on('-c', '--[no-]consume-comments', 'Normally, when consuming a localization file, Twine will ignore all comments in the file. With this flag set, any comments',
' encountered will be read and parsed into the Twine data file. This is especially useful when creating your first',
' Twine data file from an existing project.') do |c|
options[:consume_comments] = c
end
opts.on('-e', '--encoding ENCODING', 'Twine defaults to encoding all output files in UTF-8. This flag will tell Twine to use an alternate encoding for these',
@ -99,10 +99,10 @@ module Twine
' UTF-16LE or UTF16-BE.') do |e|
options[:output_encoding] = e
end
opts.on('--[no-]validate', 'Validate the strings file before formatting it.') do |validate|
opts.on('--[no-]validate', 'Validate the Twine file before formatting it.') do |validate|
options[:validate] = validate
end
opts.on('-p', '--[no-]pedantic', 'When validating a strings file, perform additional checks that go beyond pure validity (like presence of tags).') do |p|
opts.on('-p', '--[no-]pedantic', 'When validating a Twine file, perform additional checks that go beyond pure validity (like presence of tags).') do |p|
options[:pedantic] = p
end
opts.on('-h', '--help', 'Show this message.') do |h|
@ -116,13 +116,13 @@ module Twine
opts.separator ''
opts.separator 'Examples:'
opts.separator ''
opts.separator '> twine generate-string-file strings.txt ko.xml --tags FT'
opts.separator '> twine generate-all-string-files strings.txt Resources/Locales/ --tags FT,FB'
opts.separator '> twine consume-string-file strings.txt ja.strings'
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-twine-file strings.txt'
opts.separator '> twine generate-localization-file twine.txt ko.xml --tags FT'
opts.separator '> twine generate-all-localization-files twine.txt Resources/Locales/ --tags FT,FB'
opts.separator '> twine consume-localization-file twine.txt ja.strings'
opts.separator '> twine consume-all-localization-files twine.txt Resources/Locales/ --developer-language en --tags DefaultTag1,DefaultTag2'
opts.separator '> twine generate-loc-drop twine.txt LocDrop5.zip --tags FT,FB --format android --lang de,en,en-GB,ja,ko'
opts.separator '> twine consume-loc-drop twine.txt LocDrop5.zip'
opts.separator '> twine validate-twine-file twine.txt'
end
begin
parser.parse! args
@ -136,6 +136,19 @@ module Twine
exit false
end
# TODO: Remove this mapping of deprecated commands some time in the future - added on 31.03.
deprecated_command_mappings = {
'generate-string-file' => 'generate-localization-file',
'generate-all-string-file' => 'generate-all-localization-files',
'consume-string-file' => 'consume-localization-file',
'consume-all-string-files' => 'consume-all-localization-files'
}
mapped_command = deprecated_command_mappings[args[0]]
if mapped_command
Twine::stderr.puts "WARNING: Twine commands names have changed. `#{args[0]}` is now `#{mapped_command}`. The old command is deprecated will soon stop working. For more information please check the documentation at https://github.com/mobiata/"
args[0] = mapped_command
end
number_of_needed_arguments = NEEDED_COMMAND_ARGUMENTS[args[0]]
unless number_of_needed_arguments
raise Twine::Error.new "Invalid command: #{args[0]}"
@ -154,19 +167,19 @@ module Twine
end
case options[:command]
when 'generate-string-file'
when 'generate-localization-file'
options[:output_path] = args[2]
if options[:languages] and options[:languages].length > 1
raise Twine::Error.new 'Please only specify a single language for the generate-string-file command.'
raise Twine::Error.new 'Please only specify a single language for the generate-localization-file command.'
end
when 'generate-all-string-files'
when 'generate-all-localization-files'
options[:output_path] = args[2]
when 'consume-string-file'
when 'consume-localization-file'
options[:input_path] = args[2]
if options[:languages] and options[:languages].length > 1
raise Twine::Error.new 'Please only specify a single language for the consume-string-file command.'
raise Twine::Error.new 'Please only specify a single language for the consume-localization-file command.'
end
when 'consume-all-string-files'
when 'consume-all-localization-files'
options[:input_path] = args[2]
when 'generate-loc-drop'
options[:output_path] = args[2]

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

@ -38,7 +38,7 @@ module Twine
definition.translations[lang] = value
end
elsif @options[:consume_all]
Twine::stderr.puts "Adding new string '#{key}' to twine file."
Twine::stderr.puts "Adding new definition '#{key}' to twine file."
current_section = @twine_file.sections.find { |s| s.name == 'Uncategorized' }
unless current_section
current_section = TwineSection.new('Uncategorized')
@ -111,7 +111,7 @@ module Twine
end
def should_include_definition(definition, lang)
definition.translated_string_for_lang(lang)
return !definition.translation_for_lang(lang).nil?
end
def format_section(section, lang)
@ -139,7 +139,7 @@ module Twine
end
def format_key_value(definition, lang)
value = definition.translated_string_for_lang(lang)
value = definition.translation_for_lang(lang)
key_value_pattern % { key: format_key(definition.key.dup), value: format_value(value.dup) }
end

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

@ -137,7 +137,7 @@ module Twine
# 4) escape non resource identifier @ signs (http://developer.android.com/guide/topics/resources/accessing-resources.html#ResourcesFromXml)
resource_identifier_regex = /@(?!([a-z\.]+:)?[a-z+]+\/[a-zA-Z_]+)/ # @[<package_name>:]<resource_type>/<resource_name>
value.gsub!(resource_identifier_regex, '\@')
# 5) replace beginning and end spaces with \0020. Otherwise Android strips them.
# 5) replace beginning and end spaces with \u0020. Otherwise Android strips them.
value.gsub(/\A *| *\z/) { |spaces| '\u0020' * spaces.length }
end

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

@ -79,7 +79,7 @@ module Twine
end
def should_include_definition(definition, lang)
super and definition.translated_string_for_lang(@default_lang)
super and !definition.translation_for_lang(@default_lang).nil?
end
def format_comment(definition, lang)
@ -87,7 +87,7 @@ module Twine
end
def format_key_value(definition, lang)
value = definition.translated_string_for_lang(lang)
value = definition.translation_for_lang(lang)
[format_key(definition.key.dup), format_base_translation(definition), format_value(value.dup)].compact.join
end

4
lib/twine/output_processor.rb
View file

@ -29,12 +29,12 @@ module Twine
section.definitions.each do |definition|
next unless definition.matches_tags?(@options[:tags], @options[:untagged])
value = definition.translated_string_for_lang(language)
value = definition.translation_for_lang(language)
next if value && @options[:include] == :untranslated
if value.nil? && @options[:include] != :translated
value = definition.translated_string_for_lang(fallback_languages(language))
value = definition.translation_for_lang(fallback_languages(language))
end
next unless value

40
lib/twine/runner.rb
View file

@ -13,14 +13,14 @@ module Twine
runner = new(options, twine_file)
case options[:command]
when 'generate-string-file'
runner.generate_string_file
when 'generate-all-string-files'
runner.generate_all_string_files
when 'consume-string-file'
runner.consume_string_file
when 'consume-all-string-files'
runner.consume_all_string_files
when 'generate-localization-file'
runner.generate_localization_file
when 'generate-all-localization-files'
runner.generate_all_localization_files
when 'consume-localization-file'
runner.consume_localization_file
when 'consume-all-localization-files'
runner.consume_all_localization_files
when 'generate-loc-drop'
runner.generate_loc_drop
when 'consume-loc-drop'
@ -42,7 +42,7 @@ module Twine
@twine_file.write(path)
end
def generate_string_file
def generate_localization_file
validate_twine_file if @options[:validate]
lang = nil
@ -51,12 +51,12 @@ module Twine
formatter, lang = prepare_read_write(@options[:output_path], lang)
output = formatter.format_file(lang)
raise Twine::Error.new "Nothing to generate! The resulting file would not contain any strings." unless output
raise Twine::Error.new "Nothing to generate! The resulting file would not contain any translations." unless output
IO.write(@options[:output_path], output, encoding: encoding)
end
def generate_all_string_files
def generate_all_localization_files
validate_twine_file if @options[:validate]
if !File.directory?(@options[:output_path])
@ -85,7 +85,7 @@ module Twine
output = formatter.format_file(lang)
unless output
Twine::stderr.puts "Skipping file at path #{file_path} since it would not contain any strings."
Twine::stderr.puts "Skipping file at path #{file_path} since it would not contain any translations."
next
end
@ -107,7 +107,7 @@ module Twine
file_path = File.join(output_path, file_name)
output = formatter.format_file(lang)
unless output
Twine::stderr.puts "Skipping file at path #{file_path} since it would not contain any strings."
Twine::stderr.puts "Skipping file at path #{file_path} since it would not contain any translations."
next
end
@ -121,18 +121,18 @@ module Twine
end
def consume_string_file
def consume_localization_file
lang = nil
if @options[:languages]
lang = @options[:languages][0]
end
read_string_file(@options[:input_path], lang)
read_localization_file(@options[:input_path], lang)
output_path = @options[:output_path] || @options[:twine_file]
write_twine_data(output_path)
end
def consume_all_string_files
def consume_all_localization_files
if !File.directory?(@options[:input_path])
raise Twine::Error.new("Directory does not exist: #{@options[:output_path]}")
end
@ -140,7 +140,7 @@ module Twine
Dir.glob(File.join(@options[:input_path], "**/*")) do |item|
if File.file?(item)
begin
read_string_file(item)
read_localization_file(item)
rescue Twine::Error => e
Twine::stderr.puts "#{e.message}"
end
@ -173,7 +173,7 @@ module Twine
output = formatter.format_file(lang)
unless output
Twine::stderr.puts "Skipping file #{file_name} since it would not contain any strings."
Twine::stderr.puts "Skipping file #{file_name} since it would not contain any translations."
next
end
@ -201,7 +201,7 @@ module Twine
FileUtils.mkdir_p(File.dirname(real_path))
zipfile.extract(entry.name, real_path)
begin
read_string_file(real_path)
read_localization_file(real_path)
rescue Twine::Error => e
Twine::stderr.puts "#{e.message}"
end
@ -289,7 +289,7 @@ module Twine
formatter
end
def read_string_file(path, lang = nil)
def read_localization_file(path, lang = nil)
unless File.file?(path)
raise Twine::Error.new("File does not exist: #{path}")
end

4
lib/twine/twine_file.rb
View file

@ -38,10 +38,10 @@ module Twine
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

50
test/test_cli.rb
View file

@ -13,7 +13,7 @@ class CLITestCase < TwineTestCase
@options = Twine::CLI::parse command.split
end
class TestValidateStringsFile < CLITestCase
class TestValidateTwineFile < CLITestCase
def test_command
parse "validate-twine-file #{@twine_file_path}"
@ -39,112 +39,112 @@ class CLITestCase < TwineTestCase
end
end
class TestGenerateStringFile < CLITestCase
class TestGenerateLocalizationFile < CLITestCase
def test_command
parse "generate-string-file #{@twine_file_path} #{@output_path}"
parse "generate-localization-file #{@twine_file_path} #{@output_path}"
assert_equal 'generate-string-file', @options[:command]
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_parameter
assert_raises Twine::Error do
parse 'generate-string-file twine_file'
parse 'generate-localization-file twine_file'
end
end
def test_validate
parse "generate-string-file #{@twine_file_path} #{@output_path} --validate"
parse "generate-localization-file #{@twine_file_path} #{@output_path} --validate"
assert @options[:validate]
end
def test_extra_parameter
assert_raises Twine::Error do
parse 'generate-string-file twine_file output extra'
parse 'generate-localization-file twine_file output extra'
end
end
def test_only_allows_one_language
assert_raises Twine::Error do
parse "generate-string-file twine_file output --lang en,fr"
parse "generate-localization-file twine_file output --lang en,fr"
end
end
end
class TestGenerateAllStringFiles < CLITestCase
class TestGenerateAllLocalizationFiles < CLITestCase
def test_command
parse "generate-all-string-files #{@twine_file_path} #{@output_dir}"
parse "generate-all-localization-files #{@twine_file_path} #{@output_dir}"
assert_equal 'generate-all-string-files', @options[:command]
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_missing_parameter
assert_raises Twine::Error do
parse "generate-all-string-files twine_file"
parse "generate-all-localization-files twine_file"
end
end
def test_validate
parse "generate-all-string-files #{@twine_file_path} #{@output_dir} --validate"
parse "generate-all-localization-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 twine_file output extra"
parse "generate-all-localization-files twine_file output extra"
end
end
end
class TestConsumeStringFile < CLITestCase
class TestConsumeLocalizationFile < CLITestCase
def test_command
parse "consume-string-file #{@twine_file_path} #{@input_path}"
parse "consume-localization-file #{@twine_file_path} #{@input_path}"
assert_equal 'consume-string-file', @options[:command]
assert_equal 'consume-localization-file', @options[:command]
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 twine_file"
parse "consume-localization-file twine_file"
end
end
def test_extra_parameter
assert_raises Twine::Error do
parse "consume-string-file twine_file output extra"
parse "consume-localization-file twine_file output extra"
end
end
def test_only_allows_one_language
assert_raises Twine::Error do
parse "consume-string-file twine_file output --lang en,fr"
parse "consume-localization-file twine_file output --lang en,fr"
end
end
end
class TestConsumeAllStringFiles < CLITestCase
class TestConsumeAllLocalizationFiles < CLITestCase
def test_command
parse "consume-all-string-files #{@twine_file_path} #{@input_dir}"
parse "consume-all-localization-files #{@twine_file_path} #{@input_dir}"
assert_equal 'consume-all-string-files', @options[:command]
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_missing_parameter
assert_raises Twine::Error do
parse "consume-all-string-files twine_file"
parse "consume-all-localization-files twine_file"
end
end
def test_extra_parameter
assert_raises Twine::Error do
parse "consume-all-string-files twine_file output extra"
parse "consume-all-localization-files twine_file output extra"
end
end
end

22
test/test_consume_string_file.rb → test/test_consume_localization_file.rb
View file

@ -1,6 +1,6 @@
require 'command_test_case'
class TestConsumeStringFile < CommandTestCase
class TestConsumeLocalizationFile < CommandTestCase
def new_runner(language, file)
options = {}
options[:output_path] = File.join(@output_dir, file) if file
@ -22,25 +22,25 @@ class TestConsumeStringFile < CommandTestCase
def test_deducts_android_format_from_output_path
prepare_mock_read_formatter Twine::Formatters::Android
new_runner('fr', 'fr.xml').consume_string_file
new_runner('fr', 'fr.xml').consume_localization_file
end
def test_deducts_apple_format_from_output_path
prepare_mock_read_formatter Twine::Formatters::Apple
new_runner('fr', 'fr.strings').consume_string_file
new_runner('fr', 'fr.strings').consume_localization_file
end
def test_deducts_jquery_format_from_output_path
prepare_mock_read_formatter Twine::Formatters::JQuery
new_runner('fr', 'fr.json').consume_string_file
new_runner('fr', 'fr.json').consume_localization_file
end
def test_deducts_gettext_format_from_output_path
prepare_mock_read_formatter Twine::Formatters::Gettext
new_runner('fr', 'fr.po').consume_string_file
new_runner('fr', 'fr.po').consume_localization_file
end
def test_deducts_language_from_input_path
@ -48,7 +48,7 @@ class TestConsumeStringFile < CommandTestCase
formatter = prepare_mock_formatter Twine::Formatters::Android
formatter.expects(:read).with(anything, random_language)
new_runner(nil, "#{random_language}.xml").consume_string_file
new_runner(nil, "#{random_language}.xml").consume_localization_file
end
class TestEncodings < CommandTestCase
@ -88,31 +88,31 @@ class TestConsumeStringFile < CommandTestCase
def test_reads_utf8
formatter = prepare_mock_formatter DummyFormatter
new_runner(fixture_path('enc_utf8.dummy')).consume_string_file
new_runner(fixture_path('enc_utf8.dummy')).consume_localization_file
assert_equal @expected_content, formatter.content
end
def test_reads_utf16le_bom
formatter = prepare_mock_formatter DummyFormatter
new_runner(fixture_path('enc_utf16le_bom.dummy')).consume_string_file
new_runner(fixture_path('enc_utf16le_bom.dummy')).consume_localization_file
assert_equal @expected_content, formatter.content
end
def test_reads_utf16be_bom
formatter = prepare_mock_formatter DummyFormatter
new_runner(fixture_path('enc_utf16be_bom.dummy')).consume_string_file
new_runner(fixture_path('enc_utf16be_bom.dummy')).consume_localization_file
assert_equal @expected_content, formatter.content
end
def test_reads_utf16le
formatter = prepare_mock_formatter DummyFormatter
new_runner(fixture_path('enc_utf16le.dummy'), 'UTF-16LE').consume_string_file
new_runner(fixture_path('enc_utf16le.dummy'), 'UTF-16LE').consume_localization_file
assert_equal @expected_content, formatter.content
end
def test_reads_utf16be
formatter = prepare_mock_formatter DummyFormatter
new_runner(fixture_path('enc_utf16be.dummy'), 'UTF-16BE').consume_string_file
new_runner(fixture_path('enc_utf16be.dummy'), 'UTF-16BE').consume_localization_file
assert_equal @expected_content, formatter.content
end
end

22
test/test_generate_all_string_files.rb → test/test_generate_all_localization_files.rb
View file

@ -1,6 +1,6 @@
require 'command_test_case'
class TestGenerateAllStringFiles < CommandTestCase
class TestGenerateAllLocalizationFiles < CommandTestCase
def new_runner(create_folders, twine_file = nil)
options = {}
options[:output_path] = @output_dir
@ -18,51 +18,51 @@ class TestGenerateAllStringFiles < CommandTestCase
Twine::Runner.new(options, twine_file)
end
class TestDoNotCreateFolders < TestGenerateAllStringFiles
class TestDoNotCreateFolders < TestGenerateAllLocalizationFiles
def new_runner(twine_file = nil)
super(false, twine_file)
end
def test_fails_if_output_folder_does_not_exist
assert_raises Twine::Error do
new_runner.generate_all_string_files
new_runner.generate_all_localization_files
end
end
def test_does_not_create_language_folders
Dir.mkdir File.join @output_dir, 'en.lproj'
new_runner.generate_all_string_files
new_runner.generate_all_localization_files
refute File.exists?(File.join(@output_dir, 'es.lproj')), "language folder should not be created"
end
def test_prints_empty_file_warnings
Dir.mkdir File.join @output_dir, 'en.lproj'
empty_twine_file = build_twine_file('en') {}
new_runner(empty_twine_file).generate_all_string_files
new_runner(empty_twine_file).generate_all_localization_files
assert_match "Skipping file at path", Twine::stderr.string
end
end
class TestCreateFolders < TestGenerateAllStringFiles
class TestCreateFolders < TestGenerateAllLocalizationFiles
def new_runner(twine_file = nil)
super(true, twine_file)
end
def test_creates_output_folder
FileUtils.remove_entry_secure @output_dir
new_runner.generate_all_string_files
new_runner.generate_all_localization_files
assert File.exists? @output_dir
end
def test_creates_language_folders
new_runner.generate_all_string_files
new_runner.generate_all_localization_files
assert File.exists?(File.join(@output_dir, 'en.lproj')), "language folder 'en.lproj' should be created"
assert File.exists?(File.join(@output_dir, 'es.lproj')), "language folder 'es.lproj' should be created"
end
def test_prints_empty_file_warnings
empty_twine_file = build_twine_file('en') {}
new_runner(empty_twine_file).generate_all_string_files
new_runner(empty_twine_file).generate_all_localization_files
assert_match "Skipping file at path", Twine::stderr.string
end
@ -90,12 +90,12 @@ class TestGenerateAllStringFiles < CommandTestCase
def test_does_not_validate_twine_file
prepare_mock_formatter Twine::Formatters::Android
new_runner(false).generate_all_string_files
new_runner(false).generate_all_localization_files
end
def test_validates_twine_file_if_validate
assert_raises Twine::Error do
new_runner(true).generate_all_string_files
new_runner(true).generate_all_localization_files
end
end
end

18
test/test_generate_string_file.rb → test/test_generate_localization_file.rb
View file

@ -1,6 +1,6 @@
require 'command_test_case'
class TestGenerateStringFile < CommandTestCase
class TestGenerateLocalizationFile < CommandTestCase
def new_runner(language, file)
options = {}
options[:output_path] = File.join(@output_dir, file) if file
@ -20,25 +20,25 @@ class TestGenerateStringFile < CommandTestCase
def test_deducts_android_format_from_output_path
prepare_mock_format_file_formatter Twine::Formatters::Android
new_runner('fr', 'fr.xml').generate_string_file
new_runner('fr', 'fr.xml').generate_localization_file
end
def test_deducts_apple_format_from_output_path
prepare_mock_format_file_formatter Twine::Formatters::Apple
new_runner('fr', 'fr.strings').generate_string_file
new_runner('fr', 'fr.strings').generate_localization_file
end
def test_deducts_jquery_format_from_output_path
prepare_mock_format_file_formatter Twine::Formatters::JQuery
new_runner('fr', 'fr.json').generate_string_file
new_runner('fr', 'fr.json').generate_localization_file
end
def test_deducts_gettext_format_from_output_path
prepare_mock_format_file_formatter Twine::Formatters::Gettext
new_runner('fr', 'fr.po').generate_string_file
new_runner('fr', 'fr.po').generate_localization_file
end
def test_deducts_language_from_output_path
@ -46,7 +46,7 @@ class TestGenerateStringFile < CommandTestCase
formatter = prepare_mock_formatter Twine::Formatters::Android
formatter.expects(:format_file).with(random_language).returns(true)
new_runner(nil, "#{random_language}.xml").generate_string_file
new_runner(nil, "#{random_language}.xml").generate_localization_file
end
def test_returns_error_if_nothing_written
@ -54,7 +54,7 @@ class TestGenerateStringFile < CommandTestCase
formatter.expects(:format_file).returns(false)
assert_raises Twine::Error do
new_runner('fr', 'fr.xml').generate_string_file
new_runner('fr', 'fr.xml').generate_localization_file
end
end
@ -79,12 +79,12 @@ class TestGenerateStringFile < CommandTestCase
def test_does_not_validate_twine_file
prepare_mock_formatter Twine::Formatters::Android
new_runner(false).generate_string_file
new_runner(false).generate_localization_file
end
def test_validates_twine_file_if_validate
assert_raises Twine::Error do
new_runner(true).generate_string_file
new_runner(true).generate_localization_file
end
end
end

4
test/test_twine_entry.rb → test/test_twine_definition.rb
View file

@ -36,12 +36,12 @@ class TestTwineDefinition < TwineTestCase
end
def test_reference_translation_used
assert_equal 'ref-value', @definition.translated_string_for_lang('en')
assert_equal 'ref-value', @definition.translation_for_lang('en')
end
def test_reference_translation_override
@definition.translations['en'] = 'value'
assert_equal 'value', @definition.translated_string_for_lang('en')
assert_equal 'value', @definition.translation_for_lang('en')
end
end

2
test/test_validate_strings_file.rb → test/test_validate_twine_file.rb
View file

@ -2,7 +2,7 @@
require 'command_test_case'
class TestValidateStringsFile < CommandTestCase
class TestValidateTwineFile < CommandTestCase
def setup
super
@options = { twine_file: 'input.txt' }

4
twine.gemspec
View file

@ -5,7 +5,7 @@ Gem::Specification.new do |s|
s.name = "twine"
s.version = Twine::VERSION
s.date = Time.now.strftime('%Y-%m-%d')
s.summary = "Manage strings and their translations for your iOS and Android projects."
s.summary = "Manage strings and their translations for your iOS, Android and other platform projects."
s.homepage = "https://github.com/mobiata/twine"
s.email = "twine@mobiata.com"
s.authors = [ "Sebastian Celis" ]
@ -31,4 +31,6 @@ Gem::Specification.new do |s|
It is geared toward Mac OS X, iOS, and Android developers.
desc
s.post_install_message = "Twine command names have changed! Please check the documentation for their new names."
end