Initial commit.

Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

LICENSE

@@ -0,0 +1,30 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2012, Mobiata, LLC
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, with or
+without modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the organization nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,120 @@
+# Twine
+
+Twine is a command line tool for managing your strings and their translations. These strings are all stored in a master text file and then Twine uses this file to import and export strings in a variety of file types, including iOS and Mac OS X `.strings` files as well as Android `.xml` files. This allows individuals and companies to easily share strings across multiple projects, as well as export strings in any format the user wants.
+
+## Install
+
+### As a Gem
+
+Twine is most easily installed as a Gem.
+
+	sudo gem install twine
+
+### From Source
+
+You can also run Twine directly from source. However, it requires [rubyzip][rubyzip] in order to create and read standard zip files.
+
+	sudo gem install rubyzip
+	git clone git://github.com/mobiata/twine.git
+	cd twine
+	./twine --help
+
+Make sure you run the `twine` executable at the root of the project as it properly sets up your Ruby library path. The `bin/twine` executable does not.
+
+## String File Format
+
+Twine stores all of its strings in a single 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 a recommended way of breaking your strings into smaller, more manageable chunks.
+
+Each grouping section contains N string definitions. These string definitions start with the string key placed within a single pair of square brackets. This string definition then contains a number of key-value pairs, including a comment, a comma-separated list of tags (which are used by Twine to select a subset of strings), and all of the translations.
+
+### Tags
+
+Tags are used by Twine as a way to only work with a subset of your strings at any given point in time. Each string can be assigned zero or more tags which are separated by commas. When a string has no tags, that string will never be selected by Twine. You can get a list of all strings currently missing tags by executing the `generate-report` command.
+
+### Whitespace
+
+Whitepace in this file is mostly ignored. If you absolutely need to put spaces at the beginning or end of your translated string, you can wrap the entire string in a pair of `` ` `` characters. If your actual string needs to start *and* end with a grave accent, you can wrap it in another pair of `` ` `` characters. See the example, below.
+
+### Example
+
+	[[General]]
+		[yes]
+			en = Yes
+			es = Sí
+			fr = Oui
+			ja = はい
+		[no]
+			en = No
+			fr = Non
+			ja = いいえ
+			
+	[[Errors]]
+		[path_not_found_error]
+			en = The file '%@' could not be found.
+			tags = app1,app6
+			comment = An error describing when a path on the filesystem could not be found.
+		[network_unavailable_error]
+			en = The network is currently unavailable.
+			tags = app1
+			comment = An error describing when the device can not connect to the internet.
+			
+	[[Escaping Example]]
+		[list_item_separator]
+			en = `, `
+			tags = mytag
+			comment = A string that should be placed between multiple items in a list. For example: Red, Green, Blue
+		[grave_accent_quoted_string]
+			en = ``%@``
+			tags = myothertag
+			comment = This string will evaluate to `%@`.
+
+## Usage
+
+	Usage: twine COMMAND STRINGS_FILE [INPUT_OR_OUTPUT_PATH] [--lang LANG1,LANG2...] [--tag TAG1,TAG2,TAG3...] [--format FORMAT]
+	
+### Commands
+
+#### `generate-string-file`
+
+This command creates an Apple or Android strings file from the master strings data file.
+
+	> twine generate-string-file /path/to/strings.txt values-ja.xml --tag common,app1
+	> twine generate-string-file /path/to/strings.txt Localizable.strings --lang ja --tag mytag
+	> twine generate-string-file /path/to/strings.txt all-english.strings --lang en
+
+#### `generate-all-string-files`
+
+This command is a convenient way to call `generate-string-file` multiple times. It uses standard Mac OS X, iOS, and Android 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. This is often the command you will want to execute during the build phase of your project.
+
+	> twine generate-all-string-files /path/to/strings.txt /path/to/project/locales/directory --tag common,app1
+
+#### `consume-string-file`
+
+This command slurps all of the strings from a `.strings` or `.xml` file and incorporates the translated text into the master strings 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 strings that already exist in the master data file.
+
+	> twine consume-string-file /path/to/strings.txt fr.strings
+	> twine consume-string-file /path/to/strings.txt Localizable.strings --lang ja
+	> twine consume-string-file /path/to/strings.txt es.xml
+
+#### `generate-loc-drop`
+
+This command is a convenient way to generate a zip file containing files created by the `generate-string-file` command. It is often used for creating a single zip containing a large number of strings in all languages which you can then hand off to your translation team.
+
+	> twine generate-loc-drop /path/to/strings.txt LocDrop1.zip
+	> twine generate-loc-drop /path/to/strings.txt LocDrop2.zip --lang en,fr,ja,ko --tag common,app1
+
+#### `consume-loc-drop`
+
+This command is a convenient way of taking a zip file and executing the `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.
+
+	> twine consume-loc-drop /path/to/strings.txt LocDrop2.zip
+
+#### `generate-report`
+
+This command gives you useful information about your strings. It will tell you how many strings you have, how many have been translated into each language, and whether your master strings data file has any duplicate string keys.
+
+	> twine generate-report /path/to/strings.txt
+
+[rubyzip]: http://rubygems.org/gems/rubyzip
+[git]: http://git-scm.org/
+[INI]: http://en.wikipedia.org/wiki/INI_file

bin/twine

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'twine'
+Twine::Runner.run(ARGV)

lib/twine.rb

@@ -0,0 +1,10 @@
+module Twine
+  class Error < StandardError
+  end
+  
+  require 'twine/cli'
+  require 'twine/formatters'
+  require 'twine/runner'
+  require 'twine/stringsfile'
+  require 'twine/version'
+end

lib/twine/cli.rb

@@ -0,0 +1,166 @@
+require 'optparse'
+
+module Twine
+  class CLI
+    def initialize(args, options)
+      @options = options
+      @args = args
+    end
+
+    def self.parse_args(args, options)
+      new(args, options).parse_args
+    end
+
+    def parse_args
+      parser = OptionParser.new(@args) do |opts|
+        opts.banner = 'Usage: twine COMMAND STRINGS_FILE [INPUT_OR_OUTPUT_PATH] [--lang LANG1,LANG2...] [--tag 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, generate reports on the strings, as well as create iOS and Android string files to ship with our products.'
+        opts.separator ''
+        opts.separator 'Commands:'
+        opts.separator ''
+        opts.separator 'generate-strings-file -- 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 ''
+        opts.separator 'generate-all-string-files -- 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 ''
+        opts.separator 'consume-string-file -- 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 ''
+        opts.separator 'generate-loc-drop -- 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 ''
+        opts.separator 'consume-loc-drop -- 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 'generate-report -- Generates a report containing data about your strings. For example, it will tell you if you have any duplicate strings or if any of your strings are missing tags. In addition, it will tell you how many strings you have and how many of those strings have been translated into each language.'
+        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 |langs|
+          @options[:languages] = langs
+        end
+        opts.on('-t', '--tag TAGS', Array, 'The tag(s) to use for the specified action. Only strings with that tag will be processed.') do |tags|
+          @options[:tags] = tags
+        end
+        opts.on('-f', '--format FORMAT', 'The file format to read or write (iOS, Android). Additional formatters can be placed in the formats/ directory.') do |format|
+          lformat = format.downcase
+          found_format = false
+          Formatters::FORMATTERS.each do |formatter|
+            if formatter::FORMAT_NAME == lformat
+              found_format = true
+              break
+            end
+          end
+          if !found_format
+            puts "Invalid format: #{format}"
+          end
+          @options[:format] = lformat
+        end
+        opts.on('-h', '--help', 'Show this message.') do |h|
+          puts opts.help
+          exit
+        end
+        opts.on('--version', 'Print the version number and exit.') do |x|
+          puts "Twine version #{Twine::VERSION}"
+          exit
+        end
+        opts.separator ''
+        opts.separator 'Examples:'
+        opts.separator ''
+        opts.separator '> twine generate-string-file strings.txt ko.xml --tag FT'
+        opts.separator '> twine generate-all-string-files strings.txt Resources/Locales/ --tag FT,FB'
+        opts.separator '> twine consume-string-file strings.txt ja.strings'
+        opts.separator '> twine generate-loc-drop strings.txt LocDrop5.zip --tag FT,FB --format android --lang de,en,en-GB,ja,ko'
+        opts.separator '> twine consume-loc-drop strings.txt LocDrop5.zip'
+        opts.separator '> twine generate-report strings.txt'
+      end
+      parser.parse!
+
+      if @args.length == 0
+        puts parser.help
+        exit
+      end
+
+      @options[:command] = @args[0]
+
+      if !VALID_COMMANDS.include? @options[:command]
+        puts "Invalid command: #{@options[:command]}"
+        exit
+      end
+
+      if @args.length == 1
+        puts 'You must specify your strings file.'
+        exit
+      end
+
+      @options[:strings_file] = @args[1]
+
+      case @options[:command]
+      when 'generate-string-file'
+        if @args.length == 3
+          @options[:output_path] = @args[2]
+        elsif @args.length > 3
+          puts "Unknown argument: #{@args[3]}"
+          exit
+        else
+          puts 'Not enough arguments.'
+          exit
+        end
+        if @options[:languages] and @options[:languages].length > 1
+          puts 'Please only specify a single language for the generate-string-file command.'
+          exit
+        end
+      when 'generate-all-string-files'
+        if ARGV.length == 3
+          @options[:output_path] = @args[2]
+        elsif @args.length > 3
+          puts "Unknown argument: #{@args[3]}"
+          exit
+        else
+          puts 'Not enough arguments.'
+          exit
+        end
+      when 'consume-string-file'
+        if @args.length == 3
+          @options[:input_path] = @args[2]
+        elsif @args.length > 3
+          puts "Unknown argument: #{@args[3]}"
+          exit
+        else
+          puts 'Not enough arguments.'
+          exit
+        end
+        if @options[:languages] and @options[:languages].length > 1
+          puts 'Please only specify a single language for the consume-string-file command.'
+          exit
+        end
+      when 'generate-loc-drop'
+        if @args.length == 3
+          @options[:output_path] = @args[2]
+        elsif @args.length > 3
+          puts "Unknown argument: #{@args[3]}"
+          exit
+        else
+          puts 'Not enough arguments.'
+          exit
+        end
+        if !@options[:format]
+          puts 'You must specify a format.'
+          exit
+        end
+      when 'consume-loc-drop'
+        if @args.length == 3
+          @options[:input_path] = @args[2]
+        elsif @args.length > 3
+          puts "Unknown argument: #{@args[3]}"
+          exit
+        else
+          puts 'Not enough arguments.'
+          exit
+        end
+      when 'generate-report'
+        if @args.length > 2
+          puts "Unknown argument: #{@args[2]}"
+          exit
+        end
+      end
+    end
+  end
+end

lib/twine/formatters.rb

@@ -0,0 +1,9 @@
+require 'twine/formatters/abstract'
+require 'twine/formatters/android'
+require 'twine/formatters/apple'
+
+module Twine
+  module Formatters
+    FORMATTERS = [Formatters::Apple, Formatters::Android]
+  end
+end

lib/twine/formatters/abstract.rb

@@ -0,0 +1,58 @@
+module Twine
+  module Formatters
+    class Abstract
+      def self.can_handle_directory?(path)
+        return false
+      end
+
+      def default_file_name
+        raise NotImplementedError.new("You must implement default_file_name in your formatter class.")
+      end
+
+      def determine_language_given_path(path)
+        raise NotImplementedError.new("You must implement determine_language_given_path in your formatter class.")
+      end
+
+      def read_file(path, lang, strings)
+        raise NotImplementedError.new("You must implement read_file in your formatter class.")
+      end
+
+      def write_file(path, lang, tags, strings)
+        raise NotImplementedError.new("You must implement write_file in your formatter class.")
+      end
+
+      def write_all_files(path, tags, strings)
+        if !File.directory?(path)
+          raise Twine::Error.new("Directory does not exist: #{path}")
+        end
+
+        Dir.foreach(path) do |item|
+          lang = determine_language_given_path(item)
+          if lang
+            write_file(File.join(path, item, default_file_name), lang, tags, strings)
+          end
+        end
+      end
+
+      def row_matches_tags?(row, tags)
+        if tags == nil || tags.length == 0
+          return true
+        end
+
+        if tags != nil && row.tags != nil
+          tags.each do |tag|
+            if row.tags.include? tag
+              return true
+            end
+          end
+        end
+
+        return false
+      end
+
+      def translated_string_for_row_and_lang(row, lang, default_lang)
+        row.translations[lang] || row.translations[default_lang]
+      end
+    end
+  end
+end

lib/twine/formatters/android.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+require 'cgi'
+require 'rexml/document'
+
+module Twine
+  module Formatters
+    class Android < Abstract
+      FORMAT_NAME = 'android'
+      EXTENSION = '.xml'
+      DEFAULT_FILE_NAME = 'strings.xml'
+
+      def self.can_handle_directory?(path)
+        Dir.entries(path).any? { |item| /^values-.+$/.match(item) }
+      end
+
+      def default_file_name
+        return DEFAULT_FILE_NAME
+      end
+
+      def determine_language_given_path(path)
+        path_arr = path.split(File::SEPARATOR)
+        path_arr.each do |segment|
+          match = /^values-(.*)$/.match(path_arr)
+          if match
+            lang = match[1]
+            lang.sub!('-r', '-')
+            return lang
+          end
+        end
+
+        return
+      end
+
+      def read_file(path, lang, strings)
+        File.open(path, 'r:UTF-8') do |f|
+          doc = REXML::Document.new(f)
+          doc.elements.each('resources/string') do |ele|
+            key = ele.attributes["name"]
+            if strings.strings_map.include? key
+              value = ele.text
+              value.gsub!('\\\'', '\'')
+              value.gsub!('%s', '%@')
+              strings.strings_map[key].translations[lang] = value
+            else
+              puts "#{key} not found in strings data file."
+            end
+          end
+        end
+      end
+
+      def write_file(path, lang, tags, strings)
+        default_lang = strings.language_codes[0]
+        File.open(path, 'w:UTF-8') do |f|
+          f.puts "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!-- Android Strings File -->\n<!-- Generated by Twine -->\n<!-- Language: #{lang} -->"
+          f.puts '<resources>'
+          section_num = -1
+          strings.sections.each do |section|
+            section_num += 1
+            if section_num > 0
+              f.puts ''
+            end
+
+            section_name = section.name.gsub('--', '—')
+            f.puts "\t<!-- #{section_name} -->"
+            section.rows.each do |row|
+              if row_matches_tags?(row, tags)
+                key = row.key
+                key = CGI.escapeHTML(key)
+
+                value = translated_string_for_row_and_lang(row, lang, default_lang)
+                value.gsub!('\'', '\\\\\'')
+                value.gsub!('%@', '%s')
+                value = CGI.escapeHTML(value)
+
+                comment = row.comment
+                if comment
+                  comment = comment.gsub('--', '—')
+                end
+
+                if comment && comment.length > 0
+                  f.puts "\t<!-- #{comment} -->\n"
+                end
+                f.puts "\t<string name=\"#{key}\">#{value}</string>"
+              end
+            end
+          end
+
+          f.puts '</resources>'
+        end
+      end
+    end
+  end
+end

lib/twine/formatters/apple.rb

@@ -0,0 +1,79 @@
+module Twine
+  module Formatters
+    class Apple < Abstract
+      FORMAT_NAME = 'apple'
+      EXTENSION = '.strings'
+      DEFAULT_FILE_NAME = 'Localizable.strings'
+
+      def self.can_handle_directory?(path)
+        Dir.entries(path).any? { |item| /^.+\.lproj$/.match(item) }
+      end
+
+      def default_file_name
+        return DEFAULT_FILE_NAME
+      end
+
+      def determine_language_given_path(path)
+        path_arr = path.split(File::SEPARATOR)
+        path_arr.each do |segment|
+          match = /^(.+)\.lproj$/.match(segment)
+          if match
+            return match[1]
+          end
+        end
+
+        return
+      end
+
+      def read_file(path, lang, strings)
+        File.open(path, 'r:UTF-16') do |f|
+          while line = f.gets
+            match = /"((?:[^"\\]|\\.)+)"\s*=\s*"((?:[^"\\]|\\.)*)/.match(line)
+            if match
+              key = match[1]
+              key.gsub!('\\"', '"')
+              if strings.strings_map.include? key
+                value = match[2]
+                value.gsub!('\\"', '"')
+                strings.strings_map[key].translations[lang] = value
+              else
+                puts "#{key} not found in strings data file."
+              end
+            end
+          end
+        end
+      end
+
+      def write_file(path, lang, tags, strings)
+        default_lang = strings.language_codes[0]
+        File.open(path, 'w:UTF-16') do |f|
+          f.puts "/**\n * iOS Strings File\n * Generated by Twine\n * Language: #{lang}\n */"
+          strings.sections.each do |section|
+            f.puts "\n/* #{section.name} */"
+            section.rows.each do |row|
+              if row_matches_tags?(row, tags)
+                key = row.key
+                key = key.gsub('"', '\\\\"')
+
+                value = translated_string_for_row_and_lang(row, lang, default_lang)
+                value = value.gsub('"', '\\\\"')
+
+                comment = row.comment
+                if comment
+                  comment = comment.gsub('*/', '* /')
+                end
+
+                f.print "\"#{key}\" = \"#{value}\";"
+                if comment && comment.length > 0
+                  f.print "  /* #{comment} */\n"
+                else
+                  f.print "\n"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/twine/runner.rb

@@ -0,0 +1,265 @@
+require 'tmpdir'
+
+module Twine
+  VALID_COMMANDS = ['generate-string-file', 'generate-all-string-files', 'consume-string-file', 'generate-loc-drop', 'consume-loc-drop', 'generate-report']
+
+  class Runner
+    def initialize(args)
+      @options = {}
+      @args = args
+    end
+
+    def self.run(args)
+      new(args).run
+    end
+
+    def run
+      # Parse all CLI arguments.
+      CLI::parse_args(@args, @options)
+
+      begin
+        read_strings_data
+        execute_command
+      rescue Twine::Error => e
+        puts e.message
+      end
+    end
+
+    def read_strings_data
+      @strings = StringsFile.new
+      @strings.read @options[:strings_file]
+    end
+
+    def execute_command
+      case @options[:command]
+      when 'generate-string-file'
+        generate_string_file
+      when 'generate-all-string-files'
+        generate_all_string_files
+      when 'consume-string-file'
+        consume_string_file
+      when 'generate-loc-drop'
+        generate_loc_drop
+      when 'consume-loc-drop'
+        consume_loc_drop
+      when 'generate-report'
+        generate_report
+      end
+    end
+
+    def generate_string_file
+      lang = nil
+      if @options[:languages]
+        lang = @options[:languages][0]
+      end
+
+      read_write_string_file(@options[:output_path], false, lang, @options[:format], @options[:tags])
+    end
+
+    def generate_all_string_files
+      if !File.directory?(@options[:output_path])
+        raise Twine::Error.new("Directory does not exist: #{@options[:output_path]}")
+      end
+      
+      format = @options[:format]
+      if !format
+        format = determine_format_given_directory(@options[:output_path])
+      end
+      if !format
+        raise Twine::Error.new "Could not determine format given the contents of #{@options[:output_path]}"
+      end
+
+      formatter = formatter_for_format(format)
+
+      formatter.write_all_files(@options[:output_path], @options[:tags], @strings)
+    end
+
+    def consume_string_file
+      lang = nil
+      if @options[:languages]
+        lang = @options[:languages][0]
+      end
+
+      read_write_string_file(@options[:input_path], true, lang, @options[:format], nil)
+      @strings.write(@options[:strings_file])
+    end
+
+    def read_write_string_file(path, is_read, lang, format, tags)
+      if is_read && !File.file?(path)
+        raise Twine::Error.new("File does not exist: #{path}")
+      end
+
+      if !format
+        format = determine_format_given_path(path)
+      end
+      if !format
+        raise Twine::Error.new "Unable to determine format of #{path}"
+      end
+
+      formatter = formatter_for_format(format)
+
+      if !lang
+        lang = determine_language_given_path(path)
+      end
+      if !lang
+        lang = formatter.determine_language_given_path(path)
+      end
+      if !lang
+        raise Twine::Error.new "Unable to determine language for #{path}"
+      end
+
+      if is_read
+        formatter.read_file(path, lang, @strings)
+      else
+        formatter.write_file(path, lang, tags, @strings)
+      end
+    end
+
+    def generate_loc_drop
+      begin
+        require 'zip/zip'
+      rescue LoadError
+        raise Twine::Error.new "You must 'gem install rubyzip' in order to create or consume localization drops."
+      end
+
+      if File.file?(@options[:output_path])
+        File.delete(@options[:output_path])
+      end
+
+      Dir.mktmpdir do |dir|
+        Zip::ZipFile.open(@options[:output_path], Zip::ZipFile::CREATE) do |zipfile|
+          zipfile.mkdir('Locales')
+
+          formatter = formatter_for_format(@options[:format])
+          @strings.language_codes.each do |lang|
+            if @options[:languages] == nil || @options[:languages].length == 0 || @options[:languages].include?(lang)
+              file_name = lang + formatter.class::EXTENSION
+              real_path = File.join(dir, file_name)
+              zip_path = File.join('Locales', file_name)
+              formatter.write_file(real_path, lang, @options[:tags], @strings)
+              zipfile.add(zip_path, real_path)
+            end
+          end
+        end
+      end
+    end
+
+    def consume_loc_drop
+      if !File.file?(@options[:input_path])
+        raise Twine::Error.new("File does not exist: #{@options[:input_path]}")
+      end
+
+      begin
+        require 'zip/zip'
+      rescue LoadError
+        raise Twine::Error.new "You must 'gem install rubyzip' in order to create or consume localization drops."
+      end
+
+      Dir.mktmpdir do |dir|
+        Zip::ZipFile.open(@options[:input_path]) do |zipfile|
+          zipfile.each do |entry|
+            if !entry.name.end_with?'/'
+              real_path = File.join(dir, entry.name)
+              FileUtils.mkdir_p(File.dirname(real_path))
+              zipfile.extract(entry.name, real_path)
+              read_write_string_file(real_path, true, nil, nil, @options[:tags])
+            end
+          end
+        end
+      end
+      
+      @strings.write @options[:strings_file]
+    end
+
+    def generate_report
+      total_strings = 0
+      strings_per_lang = {}
+      all_keys = Set.new
+      duplicate_keys = Set.new
+      keys_without_tags = Set.new
+      @strings.language_codes.each do |code|
+        strings_per_lang[code] = 0
+      end
+
+      @strings.sections.each do |section|
+        section.rows.each do |row|
+          total_strings += 1
+
+          if all_keys.include? row.key
+            duplicate_keys.add(row.key)
+          else
+            all_keys.add(row.key)
+          end
+
+          row.translations.each_key do |code|
+            strings_per_lang[code] += 1
+          end
+
+          if row.tags == nil || row.tags.length == 0
+            keys_without_tags.add(row.key)
+          end
+        end
+      end
+
+      # Print the report.
+      puts "Total number of strings = #{total_strings}"
+      @strings.language_codes.each do |code|
+        puts "#{code}: #{strings_per_lang[code]}"
+      end
+
+      if duplicate_keys.length > 0
+        puts "\nDuplicate string keys:"
+        duplicate_keys.each do |key|
+          puts key
+        end
+      end
+
+      if keys_without_tags.length > 0
+        puts "\nStrings without tags:"
+        keys_without_tags.each do |key|
+          puts key
+        end
+      end
+    end
+
+    def determine_language_given_path(path)
+      code = File.basename(path, File.extname(path))
+      if !@strings.language_codes.include? code
+        code = nil
+      end
+
+      code
+    end
+
+    def determine_format_given_path(path)
+      ext = File.extname(path)
+      Formatters::FORMATTERS.each do |formatter|
+        if formatter::EXTENSION == ext
+          return formatter::FORMAT_NAME
+        end
+      end
+
+      return
+    end
+
+    def determine_format_given_directory(directory)
+      Formatters::FORMATTERS.each do |formatter|
+        if formatter.can_handle_directory?(directory)
+          return formatter::FORMAT_NAME
+        end
+      end
+
+      return
+    end
+
+    def formatter_for_format(format)
+      Formatters::FORMATTERS.each do |formatter|
+        if formatter::FORMAT_NAME == format
+          return formatter.new
+        end
+      end
+
+      return
+    end
+  end
+end

lib/twine/stringsfile.rb

@@ -0,0 +1,151 @@
+module Twine
+  class StringsSection
+    attr_reader :name
+    attr_reader :rows
+
+    def initialize(name)
+      @name = name
+      @rows = []
+    end
+  end
+
+  class StringsRow
+    attr_reader :key
+    attr_accessor :comment
+    attr_accessor :tags
+    attr_reader :translations
+
+    def initialize(key)
+      @key = key
+      @comment = nil
+      @tags = nil
+      @translations = {}
+    end
+  end
+
+  class StringsFile
+    attr_reader :sections
+    attr_reader :strings_map
+    attr_reader :language_codes
+
+    def initialize
+      @sections = []
+      @strings_map = {}
+      @language_codes = []
+    end
+
+    def read(path)
+      if !File.file?(path)
+        raise Twine::Error.new("File does not exist: #{path}")
+      end
+
+      File.open(path, 'r:UTF-8') do |f|
+        line_num = 0
+        current_section = nil
+        current_row = nil
+        while line = f.gets
+          parsed = false
+          line.strip!
+          line_num += 1
+
+          if line.length == 0
+            next
+          end
+
+          if line.length > 4 && line[0, 2] == '[['
+            match = /^\[\[(.+)\]\]$/.match(line)
+            if match
+              current_section = StringsSection.new(match[1].strip)
+              @sections << current_section
+              parsed = true
+            end
+          elsif line.length > 2 && line[0, 1] == '['
+            match = /^\[(.+)\]$/.match(line)
+            if match
+              current_row = StringsRow.new(match[1].strip)
+              @strings_map[current_row.key] = current_row
+              if !current_section
+                current_section = StringsSection.new('')
+                @sections << current_section
+              end
+              current_section.rows << current_row
+              parsed = true
+            end
+          else
+            match = /^([^=]+)=(.+)$/.match(line)
+            if match
+              key = match[1].strip
+              value = match[2].strip
+              if value[0,1] == '`' && value[-1,1] == '`'
+                value = value[1..-2]
+              end
+
+              case key
+              when "comment"
+                current_row.comment = value
+              when 'tags'
+                current_row.tags = value.split(',')
+              else
+                if !@language_codes.include? key
+                  @language_codes << key
+                end
+                current_row.translations[key] = value
+              end
+              parsed = true
+            end
+          end
+
+          if !parsed
+            raise Twine::Error.new("Unable to parse line #{line_num} of #{path}: #{line}")
+          end
+        end
+
+        # Developer Language
+        dev_lang = @language_codes[0]
+        @language_codes.delete(dev_lang)
+        @language_codes.sort!
+        @language_codes.insert(0, dev_lang)
+      end
+    end
+
+    def write(path)
+      dev_lang = @language_codes[0]
+
+      File.open(path, 'w:UTF-8') do |f|
+        @sections.each do |section|
+          if f.pos > 0
+            f.puts ''
+          end
+
+          f.puts "[[#{section.name}]]"
+
+          section.rows.each do |row|
+            value = row.translations[dev_lang]
+            if value[0,1] == ' ' || value[-1,1] == ' ' || (value[0,1] == '`' && value[-1,1] == '`')
+              value = '`' + value + '`'
+            end
+
+            f.puts "\t[#{row.key}]"
+            f.puts "\t\t#{dev_lang} = #{value}"
+            if row.tags && row.tags.length > 0
+              tag_str = row.tags.join(',')
+              f.puts "\t\ttags = #{tag_str}"
+            end
+            if row.comment && row.comment.length > 0
+              f.puts "\t\tcomment = #{row.comment}"
+            end
+            @language_codes[1..-1].each do |lang|
+              value = row.translations[lang]
+              if value && value != row.translations[dev_lang]
+                if value[0,1] == ' ' || value[-1,1] == ' ' || (value[0,1] == '`' && value[-1,1] == '`')
+                  value = '`' + value + '`'
+                end
+                f.puts "\t\t#{lang} = #{value}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/twine/version.rb

@@ -0,0 +1,3 @@
+module Twine
+  VERSION = '0.1.0'
+end

twine

@@ -0,0 +1,3 @@
+#!/bin/sh
+BASEDIR=$(dirname $0)
+ruby -rubygems -I $BASEDIR/lib $BASEDIR/bin/twine $@

twine.gemspec

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift 'lib'
+require 'twine/version'
+
+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.homepage     = "https://github.com/mobiata/twine"
+  s.email        = "twine@mobiata.com"
+  s.authors      = [ "Sebastian Celis" ]
+  s.has_rdoc     = false
+
+  s.files        = %w( Gemfile README.md LICENSE )
+  s.files       += Dir.glob("lib/**/*")
+  s.files       += Dir.glob("bin/**/*")
+
+  s.add_runtime_dependency('rubyzip', "~> 0.9.5")
+
+  s.executables  = %w( twine )
+  s.description  = <<desc
+  Twine is a command line tool for managing your strings and their translations.
+  
+  It is geared toward Mac OS X, iOS, and Android developers.
+desc
+end