yury-twine 0.9.1

data/lib/twine/encoding.rb

@@ -0,0 +1,22 @@
+module Twine
+  module Encoding
+
+    def self.bom(path)
+      first_bytes = IO.binread(path, 2)
+      return nil unless first_bytes
+      first_bytes = first_bytes.codepoints.map.to_a
+      return 'UTF-16BE' if first_bytes == [0xFE, 0xFF]
+      return 'UTF-16LE' if first_bytes == [0xFF, 0xFE]
+    rescue EOFError
+      return nil
+    end
+
+    def self.has_bom?(path)
+      !bom(path).nil?
+    end
+
+    def self.encoding_for_path(path)
+      bom(path) || 'UTF-8'      
+    end
+  end
+end

data/lib/twine/formatters.rb

@@ -0,0 +1,20 @@
+module Twine
+  module Formatters
+    @formatters = []
+
+    class << self
+      attr_reader :formatters
+
+      ###
+      # registers a new formatter
+      #
+      # formatter_class - the class of the formatter to register
+      #
+      # returns array of active formatters
+      #
+      def register_formatter formatter_class
+        @formatters << formatter_class.new
+      end
+    end
+  end
+end

data/lib/twine/formatters/abstract.rb

@@ -0,0 +1,187 @@
+require 'fileutils'
+
+module Twine
+  module Formatters
+    class Abstract
+      attr_accessor :twine_file
+      attr_accessor :options
+
+      def initialize
+        @twine_file = TwineFile.new
+        @options = {}
+      end
+
+      def format_name
+        raise NotImplementedError.new("You must implement format_name in your formatter class.")
+      end
+
+      def extension
+        raise NotImplementedError.new("You must implement extension in your formatter class.")
+      end
+
+      def can_handle_directory?(path)
+        raise NotImplementedError.new("You must implement can_handle_directory? in your formatter class.")
+      end
+
+      def can_handle_file?(path)
+        raise NotImplementedError.new("You must implement can_handle_file? in your formatter class.")
+      end
+
+      def default_file_name
+        raise NotImplementedError.new("You must implement default_file_name in your formatter class.")
+      end
+
+      def set_translation_for_key(current_section, key, lang, value)
+        value = value.gsub("\n", "\\n")
+
+        if @twine_file.definitions_by_key.include?(key)
+          definition = @twine_file.definitions_by_key[key]
+          reference = @twine_file.definitions_by_key[definition.reference_key] if definition.reference_key
+
+          if !reference or value != reference.translations[lang]
+            definition.translations[lang] = value
+          end
+        elsif @options[:consume_all]
+          Twine::stderr.puts "Adding new definition '#{key}' to twine file."
+          current_definition = TwineDefinition.new(key)
+          current_section.definitions << current_definition
+
+          if @options[:tags] && @options[:tags].length > 0
+            current_definition.tags = @options[:tags]
+          end
+
+          @twine_file.definitions_by_key[key] = current_definition
+          @twine_file.definitions_by_key[key].translations[lang] = value
+        else
+          Twine::stderr.puts "Warning: '#{key}' not found in twine file."
+        end
+        if !@twine_file.language_codes.include?(lang)
+          @twine_file.add_language_code(lang)
+        end
+      end
+
+      def set_comment_for_key(key, comment)
+        return unless @options[:consume_comments]
+
+        if @twine_file.definitions_by_key.include?(key)
+          definition = @twine_file.definitions_by_key[key]
+
+          reference = @twine_file.definitions_by_key[definition.reference_key] if definition.reference_key
+
+          if !reference or comment != reference.raw_comment
+            definition.comment = comment
+          end
+        end
+      end
+
+      def set_ios_comment_for_key(key, comment)
+        if @twine_file.definitions_by_key.include?(key)
+          definition = @twine_file.definitions_by_key[key]
+
+          reference = @twine_file.definitions_by_key[definition.reference_key] if definition.reference_key
+
+          if !reference or ios_comment != reference.raw_ios_comment
+            definition.ios_comment = comment
+          end
+        end
+      end
+
+      def determine_language_given_path(path)
+        raise NotImplementedError.new("You must implement determine_language_given_path in your formatter class.")
+      end
+
+      def output_path_for_language(lang)
+        lang
+      end
+
+      def read(io, lang)
+        raise NotImplementedError.new("You must implement read in your formatter class.")
+      end
+
+      def format_file(lang)
+        output_processor = Processors::OutputProcessor.new(@twine_file, @options)
+        processed_twine_file = output_processor.process(lang)
+
+        return nil if processed_twine_file.definitions_by_key.empty?
+
+        header = format_header(lang)
+        result = ""
+        result += header + "\n" if header
+        result += format_sections(processed_twine_file, lang)
+      end
+
+      def format_header(lang)
+      end
+
+      def format_sections(twine_file, lang)
+        sections = twine_file.sections.map { |section| format_section(section, lang) }
+        sections.compact.join("\n")
+      end
+
+      def format_section_header(section)
+      end
+
+      def should_include_definition(definition, lang)
+        return !definition.translation_for_lang(lang).nil?
+      end
+
+      def format_section(section, lang)
+        definitions = section.definitions.select { |definition| should_include_definition(definition, lang) }
+        return if definitions.empty?
+
+        result = ""
+
+        if section.name && section.name.length > 0
+          section_header = format_section_header(section)
+          result += "\n#{section_header}" if section_header
+        end
+
+        definitions.map! { |definition| format_definition(definition, lang) }
+        definitions.compact! # remove nil definitions
+        definitions.map! { |definition| "\n#{definition}" }  # prepend newline
+        result += definitions.join
+      end
+
+      def format_definition(definition, lang)
+        [format_comment(definition, lang), format_key_value(definition, lang)].compact.join
+      end
+
+      def format_comment(definition, lang)
+      end
+
+      def format_key_value(definition, lang)
+        value = definition.translation_for_lang(lang)
+        key_value_pattern % { key: format_key(definition.key.dup), value: format_value(value.dup) }
+      end
+
+      def key_value_pattern
+        raise NotImplementedError.new("You must implement key_value_pattern in your formatter class.")
+      end
+
+      def format_key(key)
+        key
+      end
+
+      def format_value(value)
+        value
+      end
+
+      def escape_quotes(text)
+        text.gsub('"', "\\\"")
+      end
+
+      def section_exists(section_name)
+        @twine_file.sections.find { |s| s.name == section_name }
+      end
+
+      def get_section(name)
+        @twine_file.sections.each do |s|
+          if s.name == name
+            return s
+          end
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/twine/formatters/android.rb

@@ -0,0 +1,254 @@
+# encoding: utf-8
+require 'cgi'
+require 'rexml/document'
+
+module Twine
+  module Formatters
+    class Android < Abstract
+      include Twine::Placeholders
+
+      LANG_MAPPINGS = Hash[
+        'zh-rCN' => 'zh-Hans',
+        'zh-rHK' => 'zh-Hant',
+        'en-rGB' => 'en-UK',
+        'in' => 'id',
+        'nb' => 'no'
+        # TODO: spanish
+      ]
+
+      def format_name
+        'android'
+      end
+
+      def extension
+        '.xml'
+      end
+
+      def can_handle_directory?(path)
+        Dir.entries(path).any? { |item| /^values.*$/.match(item) }
+      end
+
+      def can_handle_file?(path)
+        path_arr = path.split(File::SEPARATOR)
+        return path_arr[path_arr.length - 1] == default_file_name
+      end
+
+      def default_file_name
+        return 'strings.xml'
+      end
+
+      def determine_language_given_path(path)
+        path_arr = path.split(File::SEPARATOR)
+        path_arr.each do |segment|
+          if segment == 'values'
+            return 'en'
+          else
+            # The language is defined by a two-letter ISO 639-1 language code, optionally followed by a two letter ISO 3166-1-alpha-2 region code (preceded by lowercase "r").
+            # see http://developer.android.com/guide/topics/resources/providing-resources.html#AlternativeResources
+            match = /^values-([a-z]{2}(-r[a-z]{2})?)$/i.match(segment)
+            if match
+              lang = match[1]
+              lang = LANG_MAPPINGS.fetch(lang, lang)
+              lang.sub!('-r', '-')
+              return lang
+            end
+          end
+        end
+
+        return
+      end
+
+      def output_path_for_language(lang)
+        if lang == 'en'
+          "values"
+        else
+          "values-" + (LANG_MAPPINGS.key(lang) || lang)
+        end
+      end
+
+      def set_translation_for_key(section, key, lang, value)
+        value = CGI.unescapeHTML(value)
+        value.gsub!('\\\'', '\'')
+        value.gsub!('\\"', '"')
+        value = convert_placeholders_from_android_to_twine(value)
+        value.gsub!('\@', '@')
+        value.gsub!(/(\\u0020)*|(\\u0020)*\z/) { |spaces| ' ' * (spaces.length / 6) }
+        super(section, key, lang, value)
+      end
+
+      def read(io, lang)
+        document = REXML::Document.new io, :compress_whitespace => %w{ string }
+
+        comment = nil
+        document.root.children.each do |child|
+          if child.is_a? REXML::Comment
+            content = child.string.strip
+            comment = content if content.length > 0 and not content.start_with?("SECTION:")
+
+          elsif child.is_a? REXML::Element
+
+            if child.attributes['translatable']
+              next
+            end
+
+            section = nil
+            if child.name == 'plurals'
+              key = child.attributes['name']
+
+              if !section_exists(key)
+                section = TwineSection.new(key)
+                @twine_file.sections.insert(@twine_file.sections.size - 1, section)
+              else
+                section = get_section(key)
+              end
+
+              child.each do |item|
+                if item.is_a? REXML::Element
+                  plural_key = key + '__' + item.attributes['quantity']
+                  set_translation_for_key(section, plural_key, lang, item.text)
+                end
+              end
+            elsif child.name == 'string'
+
+              if !section_exists('Uncategorized')
+                section = TwineSection.new('Uncategorized')
+                @twine_file.sections.insert(0, section)
+              else
+                section = get_section('Uncategorized')
+              end
+
+              key = child.attributes['name']
+
+              set_translation_for_key(section, key, lang, child.text)
+              set_comment_for_key(key, comment) if comment
+
+              comment = nil
+            end
+          end
+        end
+      end
+
+      def format_header(lang)
+        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!-- Android Strings File -->\n<!-- Generated by Twine #{Twine::VERSION} -->\n<!-- Language: #{lang} -->"
+      end
+
+      def format_sections(twine_file, lang)
+        result = '<resources>'
+
+        result += super + "\n"
+
+        result += "</resources>\n"
+      end
+
+      def format_section(section, lang)
+        definitions = section.definitions.select { |definition| should_include_definition(definition, lang) }
+        return if definitions.empty?
+
+        result = ""
+
+        if section.name && section.name.length > 0
+          section_header = format_section_header(section)
+          result += "\n#{section_header}" if section_header
+
+          # DEAL WITH PLURALS HERE
+          if section.is_uncategorized
+            definitions.map! { |definition| format_definition(definition, lang) }
+            definitions.compact! # remove nil definitions
+            definitions.map! { |definition| "\n#{definition}" }  # prepend newline
+            result += definitions.join
+          else
+            result +=  plurals_start_key_value_pattern % { key:section.name }
+
+            definitions.map! { |definition| format_plural(definition, lang) }
+            definitions.compact! # remove nil definitions
+            definitions.map! { |definition| "\n#{definition}" }  # prepend newline
+            result += definitions.join
+
+            result += plurals_end_key_value_pattern
+          end
+        end
+      end
+
+      def format_section_header(section)
+        "    <!-- SECTION: #{section.name} -->"
+      end
+
+      def format_comment(definition, lang)
+        "    <!-- #{definition.comment.gsub('--', '—')} -->\n" if definition.comment
+      end
+
+      def key_value_pattern
+        "    <string name=\"%{key}\">%{value}</string>"
+      end
+
+      def format_plural(definition, lang)
+        [format_comment(definition, lang), format_key_value_plural_item(definition, lang)].compact.join
+      end
+
+      def format_key_value_plural_item(definition, lang)
+        value = definition.translation_for_lang(lang)
+        plurals_item_key_value_pattern(format_key(definition.key.dup), format_value(value.dup))
+      end
+
+      def plurals_start_key_value_pattern
+        "\n    <plurals name=\"%{key}\">"
+      end
+
+      def plurals_item_key_value_pattern(key, value)
+        partitions = key.rpartition(/.__/)
+        "        <item quantity=\"" + partitions[partitions.length - 1] + "\">" + value + "</item>"
+      end
+
+      def plurals_end_key_value_pattern
+        "\n    </plurals>"
+      end
+
+      def escape_value(value)
+        # escape double and single quotes, & signs and tags
+        value = escape_quotes(value)
+        value.gsub!("'", "\\\\'")
+        value.gsub!(/&/, '&amp;')
+        value.gsub!('<', '&lt;')
+
+        # 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, '\@')
+
+        value.gsub('strong>', 'b>')
+      end
+
+      # see http://developer.android.com/guide/topics/resources/string-resource.html#FormattingAndStyling
+      # however unescaped HTML markup like in "Welcome to <b>Android</b>!" is stripped when retrieved with getString() (http://stackoverflow.com/questions/9891996/)
+      def format_value(value)
+        value = value.dup
+
+        # capture xliff tags and replace them with a placeholder
+        xliff_tags = []
+        value.gsub! /<xliff:g.+?<\/xliff:g>/ do
+          xliff_tags << $&
+          'TWINE_XLIFF_TAG_PLACEHOLDER'
+        end
+
+        # escape everything outside xliff tags
+        value = escape_value(value)
+
+        # put xliff tags back into place
+        xliff_tags.each do |xliff_tag|
+          # escape content of xliff tags
+          xliff_tag.gsub! /(<xliff:g.*?>)(.*)(<\/xliff:g>)/ do "#{$1}#{escape_value($2)}#{$3}" end
+          value.sub! 'TWINE_XLIFF_TAG_PLACEHOLDER', xliff_tag
+        end
+
+        # convert placeholders (e.g. %@ -> %s)
+        value = convert_placeholders_from_twine_to_android(value)
+
+        # replace beginning and end spaces with \u0020. Otherwise Android strips them.
+        value.gsub(/\A *| *\z/) { |spaces| '\u0020' * spaces.length }
+        value.gsub('%#s', '%#@')
+      end
+
+    end
+  end
+end
+
+Twine::Formatters.formatters << Twine::Formatters::Android.new