twine 0.9.1 → 0.10.0

data/lib/twine/formatters/gettext.rb

@@ -11,12 +11,8 @@ module Twine
         '.po'
       end
 
-      def can_handle_directory?(path)
-        Dir.entries(path).any? { |item| /^.+\.po$/.match(item) }
-      end
-
       def default_file_name
-        return 'strings.po'
+        'strings.po'
       end
 
       def determine_language_given_path(path)
@@ -64,7 +60,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 +74,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.translation_for_lang(@default_lang).nil?
       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.translation_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)

data/lib/twine/formatters/jquery.rb

@@ -9,12 +9,8 @@ module Twine
         '.json'
       end
 
-      def can_handle_directory?(path)
-        Dir.entries(path).any? { |item| /^.+\.json$/.match(item) }
-      end
-
       def default_file_name
-        return 'localize.json'
+        'localize.json'
       end
 
       def determine_language_given_path(path)
@@ -48,8 +44,9 @@ 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.delete_if &:empty?
         sections.join(",\n\n")
       end
 
@@ -57,11 +54,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

data/lib/twine/formatters/tizen.rb

@@ -33,7 +33,7 @@ module Twine
       end
 
       def default_file_name
-        return 'strings.xml'
+        'strings.xml'
       end
 
       def determine_language_given_path(path)
@@ -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

data/lib/twine/output_processor.rb

@@ -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.translation_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.translation_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

data/lib/twine/placeholders.rb

@@ -2,19 +2,24 @@ module Twine
   module Placeholders
     extend self
 
-    PLACEHOLDER_FLAGS_WIDTH_PRECISION_LENGTH = '([-+ 0#])?(\d+|\*)?(\.(\d+|\*))?(hh?|ll?|L|z|j|t)?'
+    # Note: the ` ` (single space) flag is NOT supported
+    PLACEHOLDER_FLAGS_WIDTH_PRECISION_LENGTH = '([-+0#])?(\d+|\*)?(\.(\d+|\*))?(hh?|ll?|L|z|j|t)?'
     PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH = '(\d+\$)?' + PLACEHOLDER_FLAGS_WIDTH_PRECISION_LENGTH
+    PLACEHOLDER_TYPES = '[diufFeEgGxXoscpaA]'
+
+    def convert_twine_string_placeholder(input)
+      # %@ -> %s
+      input.gsub(/(%#{PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH})@/, '\1s')
+    end
 
     # http://developer.android.com/guide/topics/resources/string-resource.html#FormattingAndStyling
     # http://stackoverflow.com/questions/4414389/android-xml-percent-symbol
     # https://github.com/mobiata/twine/pull/106
     def convert_placeholders_from_twine_to_android(input)
-      placeholder_types = '[diufFeEgGxXoscpaA]'
-
       # %@ -> %s
-      value = input.gsub(/(%#{PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH})@/, '\1s')
+      value = convert_twine_string_placeholder(input)
 
-      placeholder_syntax = PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH + placeholder_types
+      placeholder_syntax = PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH + PLACEHOLDER_TYPES
       placeholder_regex = /%#{placeholder_syntax}/
 
       number_of_placeholders = value.scan(placeholder_regex).size
@@ -29,7 +34,7 @@ module Twine
       return value if number_of_placeholders < 2
 
       # number placeholders
-      non_numbered_placeholder_regex = /%(#{PLACEHOLDER_FLAGS_WIDTH_PRECISION_LENGTH}#{placeholder_types})/
+      non_numbered_placeholder_regex = /%(#{PLACEHOLDER_FLAGS_WIDTH_PRECISION_LENGTH}#{PLACEHOLDER_TYPES})/
 
       number_of_non_numbered_placeholders = value.scan(non_numbered_placeholder_regex).size
 
@@ -50,5 +55,20 @@ module Twine
       # %s -> %@
       input.gsub(placeholder_regex, '\1@')
     end
+
+    # http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/mx/resources/IResourceManager.html#getString()
+    # http://soenkerohde.com/2008/07/flex-localization/comment-page-1/
+    def convert_placeholders_from_twine_to_flash(input)
+      value = convert_twine_string_placeholder(input)
+
+      placeholder_regex = /%#{PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH}#{PLACEHOLDER_TYPES}/
+      value.gsub(placeholder_regex).each_with_index do |match, index|
+        "{#{index}}"
+      end
+    end
+
+    def convert_placeholders_from_flash_to_twine(input)
+      input.gsub /\{\d+\}/, '%@'
+    end
   end
 end

data/lib/twine/runner.rb

@@ -8,42 +8,42 @@ 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'
-        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-loc-drop'
-        runner.generate_loc_drop
-      when 'consume-loc-drop'
-        runner.consume_loc_drop
-      when 'validate-strings-file'
-        runner.validate_strings_file
+      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-localization-archive'
+        runner.generate_localization_archive
+      when 'consume-localization-archive'
+        runner.consume_localization_archive
+      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]
+    def generate_localization_file
+      validate_twine_file if @options[:validate]
 
       lang = nil
       lang = @options[:languages][0] if @options[:languages]
@@ -51,13 +51,13 @@ 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)
+      IO.write(@options[:output_path], output, encoding: output_encoding)
     end
 
-    def generate_all_string_files
-      validate_strings_file if @options[:validate]
+    def generate_all_localization_files
+      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)
@@ -85,11 +85,11 @@ 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
 
-          IO.write(file_path, output, encoding: encoding)
+          IO.write(file_path, output, encoding: output_encoding)
         end
       else
         language_found = false
@@ -107,11 +107,11 @@ 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
 
-          IO.write(file_path, output, encoding: encoding)
+          IO.write(file_path, output, encoding: output_encoding)
         end
 
         unless language_found
@@ -121,38 +121,8 @@ module Twine
 
     end
 
-    def consume_string_file
-      lang = nil
-      if @options[:languages]
-        lang = @options[:languages][0]
-      end
-
-      read_string_file(@options[:input_path], lang)
-      output_path = @options[:output_path] || @options[:strings_file]
-      write_strings_data(output_path)
-    end
-
-    def consume_all_string_files
-      if !File.directory?(@options[:input_path])
-        raise Twine::Error.new("Directory does not exist: #{@options[:output_path]}")
-      end
-
-      Dir.glob(File.join(@options[:input_path], "**/*")) do |item|
-        if File.file?(item)
-          begin
-            read_string_file(item)
-          rescue Twine::Error => e
-            Twine::stderr.puts "#{e.message}"
-          end
-        end
-      end
-
-      output_path = @options[:output_path] || @options[:strings_file]
-      write_strings_data(output_path)
-    end
-
-    def generate_loc_drop
-      validate_strings_file if @options[:validate]
+    def generate_localization_archive
+      validate_twine_file if @options[:validate]
       
       require_rubyzip
 
@@ -165,7 +135,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)
@@ -173,11 +143,11 @@ 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
               
-              IO.write(temp_path, output, encoding: encoding)
+              IO.write(temp_path, output, encoding: output_encoding)
               zipfile.add(zip_path, temp_path)
             end
           end
@@ -185,7 +155,37 @@ module Twine
       end
     end
 
-    def consume_loc_drop
+    def consume_localization_file
+      lang = nil
+      if @options[:languages]
+        lang = @options[:languages][0]
+      end
+
+      read_localization_file(@options[:input_path], lang)
+      output_path = @options[:output_path] || @options[:twine_file]
+      write_twine_data(output_path)
+    end
+
+    def consume_all_localization_files
+      if !File.directory?(@options[:input_path])
+        raise Twine::Error.new("Directory does not exist: #{@options[:input_path]}")
+      end
+
+      Dir.glob(File.join(@options[:input_path], "**/*")) do |item|
+        if File.file?(item)
+          begin
+            read_localization_file(item)
+          rescue Twine::Error => e
+            Twine::stderr.puts "#{e.message}"
+          end
+        end
+      end
+
+      output_path = @options[:output_path] || @options[:twine_file]
+      write_twine_data(output_path)
+    end
+
+    def consume_localization_archive
       require_rubyzip
 
       if !File.file?(@options[:input_path])
@@ -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
@@ -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,26 +255,26 @@ 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
 
-    def encoding
-      @options[:output_encoding] || 'UTF-8'
+    def output_encoding
+      @options[:encoding] || 'UTF-8'
     end
 
     def require_rubyzip
       begin
         require 'zip'
       rescue LoadError
-        raise Twine::Error.new "You must run 'gem install rubyzip' in order to create or consume localization drops."
+        raise Twine::Error.new "You must run 'gem install rubyzip' in order to create or consume localization archives."
       end
     end
 
     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,21 +284,21 @@ 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
 
-    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
 
       formatter, lang = prepare_read_write(path, lang)
 
-      encoding = @options[:encoding] || Twine::Encoding.encoding_for_path(path)
+      external_encoding = @options[:encoding] || Twine::Encoding.encoding_for_path(path)
 
-      IO.open(IO.sysopen(path, 'rb'), 'rb', external_encoding: encoding, internal_encoding: 'UTF-8') do |io|
+      IO.open(IO.sysopen(path, 'rb'), 'rb', external_encoding: external_encoding, internal_encoding: 'UTF-8') do |io|
         io.read(2) if Twine::Encoding.has_bom?(path)
         formatter.read(io, lang)
       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