yury-twine 0.9.1

data/lib/twine/formatters/apple.rb

@@ -0,0 +1,328 @@
+require 'Nokogiri'
+
+module Twine
+  module Formatters
+    class Apple < Abstract
+      def format_name
+        'apple'
+      end
+
+      def extension
+        '.strings'
+      end
+
+      def can_handle_directory?(path)
+        Dir.entries(path).any? { |item| /^.+\.lproj$/.match(item) }
+      end
+
+      def can_handle_file?(path)
+        path_arr = path.split(File::SEPARATOR)
+        file_name = path_arr[path_arr.length - 1]
+        return file_name == default_file_name || file_name == default_plural_file_name
+      end
+
+      def default_file_name
+        return 'Localizable.strings'
+      end
+
+      def default_plural_file_name
+        return 'Localizable.stringsdict'
+      end
+
+      def determine_language_given_path(path)
+        path_arr = path.split(File::SEPARATOR)
+        path_arr.each do |segment|
+          match = /^(.+)\.lproj$/.match(segment)
+          if match
+            if match[1] != "Base"
+              return match[1]
+            else
+              return 'en'
+            end
+          end
+        end
+
+        return
+      end
+
+      def output_path_for_language(lang)
+        if lang == 'en'
+          "Base.lproj"
+        else
+          "#{lang}.lproj"
+        end
+      end
+
+      def read(io, lang)
+        uncategorized_section = nil
+        if !section_exists('Uncategorized')
+          uncategorized_section = TwineSection.new('Uncategorized')
+          @twine_file.sections.insert(0, uncategorized_section)
+        else
+          uncategorized_section = get_section('Uncategorized')
+        end
+        last_comment = nil
+        while line = io.gets
+          # matches a `key = "value"` line, where key may be quoted or unquoted. The former may also contain escaped characters
+          match = /^\s*((?:"(?:[^"\\]|\\.)+")|(?:[^"\s=]+))\s*=\s*"((?:[^"\\]|\\.)*)"/.match(line)
+          if match
+            key = match[1]
+            key = key[1..-2] if key[0] == '"' and key[-1] == '"'
+            key.gsub!('\\"', '"')
+            value = match[2]
+            value.gsub!('\\"', '"')
+            value.gsub!('%s', '%@')
+            value.gsub!('$s', '$@')
+            set_translation_for_key(uncategorized_section, key, lang, value)
+            if last_comment
+              set_comment_for_key(key, last_comment)
+            end
+          end
+
+          match = /\/\* (.*) \*\//.match(line)
+          if match
+            last_comment = match[1]
+          else
+            last_comment = nil
+          end
+        end
+
+        # Handle plural files
+        if (!File.file?(plural_input_file_for_lang(lang)))
+          return
+        end
+
+        doc = File.open(plural_input_file_for_lang(lang)) { |f| Nokogiri::XML(f) }
+        comment = nil
+        key = nil
+        value = nil
+
+        top_level_dict = doc.css("dict").first
+        whole_dicts = top_level_dict.xpath("./dict")
+        plural_keys = top_level_dict.xpath("./key")
+
+        for i in 0 ... whole_dicts.size do
+          current_dict = whole_dicts[i]
+          comment = current_dict.css("string").first.content
+          key = plural_keys[i].content.to_s
+
+          nested_dict = current_dict.xpath("./dict")
+          nested_dict_keys = nested_dict.xpath("./key")
+          nested_dict_strings = nested_dict.xpath("./string")
+
+          section = nil
+          if !section_exists(key)
+            section = TwineSection.new(key)
+            @twine_file.sections.insert(@twine_file.sections.size - 1, section)
+          else
+            section = get_section(key)
+          end
+
+          for j in 0 ... nested_dict_keys.children.size do
+            cur_xml_key = nested_dict_keys.children[j]
+            if !cur_xml_key.content.include? "NSString"
+              modified_key = key + "__" + cur_xml_key.content.to_s
+
+              set_translation_for_key(section, modified_key, lang, nested_dict_strings[j].content.to_s)
+              set_ios_comment_for_key(modified_key, comment)
+            end
+          end
+        end
+      end
+
+      def plural_input_file_for_lang(lang)
+        path = @options[:input_path]
+        if path.include?(output_path_for_language(lang))
+          if path.include?(default_file_name)
+            path.sub(default_file_name, default_plural_file_name)
+          else
+            path + "/" + default_plural_file_name
+          end
+        else
+          path + output_path_for_language(lang) + "/" + default_plural_file_name
+        end
+      end
+
+      def plural_output_file_for_lang(lang)
+        path = @options[:output_path]
+        if path.include?(output_path_for_language(lang))
+          if path.include?(default_file_name)
+            path.sub(default_file_name, default_plural_file_name)
+          else
+            path + "/" + default_plural_file_name
+          end
+        else
+          path + output_path_for_language(lang) + "/" + default_plural_file_name
+        end
+      end
+
+      def format_sections(twine_file, lang)
+        first_plural = true
+        out_file = File.open(plural_output_file_for_lang(lang), "w")
+
+        sections = Array.new(twine_file.sections.size)
+        for i in 0 ... twine_file.sections.size
+          section = twine_file.sections[i]
+          if section.is_uncategorized
+            sections[i] = format_section(section, lang)
+          else
+            if first_plural
+              first_plural = false
+              out_file.puts(format_header_stringsdict)
+            end
+            format_section_plural(section, lang, out_file)
+          end
+        end
+        out_file.puts(format_footer_stringsdict)
+        out_file.close
+        sections.compact.join("\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
+
+          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
+          end
+        end
+      end
+
+      def format_section_plural(section, lang, out_file)
+        plural_key = section.name
+        main_file_contains_key = main_localizable_file_contains_key(plural_key)
+
+        for i in 0 ... section.definitions.size
+          definition = section.definitions[i]
+          value = definition.translation_for_lang_or_nil(lang, @twine_file.language_codes[0])
+          ios_localized_format_key = definition.ios_comment
+
+          if ios_localized_format_key == nil
+            puts "[" + plural_key + "]"
+
+            if main_file_contains_key
+              puts "Needs matching key in Localizable.strings"
+            else
+              puts  "This is an Android-only plural"
+            end
+            return
+          end
+
+          if i == 0 && main_file_contains_key
+            out_file.puts(format_plural_start(plural_key, ios_localized_format_key.to_s))
+          end
+
+          if value != nil && main_file_contains_key
+            out_file.puts(format_plural_key_value(definition.key, format_value_plural(value.dup)))
+          end
+        end
+
+        if main_file_contains_key
+          out_file.puts(format_plural_section_end)
+        end
+      end
+
+      def main_localizable_file_contains_key(key)
+        @twine_file.sections.each do |section|
+          if section.is_uncategorized
+            section.definitions.each do |definition|
+              if definition.key == key
+                return true
+              end
+            end
+            return false
+          end
+        end
+        # Should never reach here
+        return false
+      end
+
+      ########### PLURALS START ###########
+
+      def format_header_stringsdict
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
+        "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n" +
+        "<plist version=\"1.0\">\n" +
+        "    <dict>\n"
+      end
+
+      def format_plural_start(section_name, comment)
+        comment_parts = comment.split("@")
+
+        # TODO: Should this be hardcoded or using Nokogiri somehow?
+        "        <key>#{section_name}</key>\n" +
+        "        <dict>\n" +
+        "            <key>NSStringLocalizedFormatKey</key>\n" +
+        "            <string>#{comment}</string>\n" +
+        "            <key>#{comment_parts[1]}</key>\n" +
+        "            <dict>\n" +
+        "                <key>NSStringFormatSpecTypeKey</key>\n" +
+        "                <string>NSStringPluralRuleType</string>\n" +
+        "                <key>NSStringFormatValueTypeKey</key>\n" +
+        "                <string>d</string>\n"
+      end
+
+      def format_plural_key_value(plural_key, plural_string)
+        plural_key_parts = plural_key.rpartition(/.__/)
+        # TODO: Nokogiri?
+        "                <key>#{plural_key_parts[plural_key_parts.length - 1]}</key>\n" +
+        "                <string>#{plural_string}</string>\n"
+      end
+
+      def format_plural_section_end
+        # TODO: Nokogiri?
+        "            </dict>\n" +
+        "        </dict>\n"
+      end
+
+      def format_footer_stringsdict
+        # TODO: Nokogiri?
+        "    </dict>\n" +
+        "</plist>"
+      end
+
+      ########### PLURALS END ###########
+
+      def format_header(lang)
+        "/**\n * Apple Strings File\n * Generated by Twine #{Twine::VERSION}\n * Language: #{lang}\n */"
+      end
+
+      def format_section_header(section)
+        "/********** #{section.name} **********/\n"
+      end
+
+      def key_value_pattern
+        "\"%{key}\" = \"%{value}\";\n"
+      end
+
+      def format_comment(definition, lang)
+        "/* #{definition.comment.gsub('*/', '* /')} */\n" if definition.comment
+      end
+
+      def format_key(key)
+        escape_quotes(key)
+      end
+
+      def format_value(value)
+        text = escape_quotes(value)
+        text.gsub("b>", "strong>")
+      end
+
+      def format_value_plural(value)
+        text = escape_quotes(value)
+        text.gsub("b>", "strong&gt;").gsub("<", "&lt;")
+      end
+    end
+  end
+end
+
+Twine::Formatters.formatters << Twine::Formatters::Apple.new

data/lib/twine/output_processor.rb

@@ -0,0 +1,57 @@
+module Twine
+  module Processors
+
+    class OutputProcessor
+      def initialize(twine_file, options)
+        @twine_file = twine_file
+        @options = options
+      end
+
+      def default_language
+        @options[:developer_language] || @twine_file.language_codes[0]
+      end
+
+      def fallback_languages(language)
+        fallback_mapping = {
+          'zh-TW' => 'zh-Hant' # if we don't have a zh-TW translation, try zh-Hant before en
+        }
+
+        [fallback_mapping[language], default_language].flatten.compact
+      end
+
+      def process(language)
+        result = TwineFile.new
+
+        result.language_codes.concat @twine_file.language_codes
+        @twine_file.sections.each do |section|
+          new_section = TwineSection.new section.name
+
+          section.definitions.each do |definition|
+            next unless definition.matches_tags?(@options[:tags], @options[:untagged])
+
+            value = definition.translation_for_lang(language)
+
+            next if value && @options[:include] == :untranslated
+
+            if value.nil? && @options[:include] != :translated
+              value = definition.translation_for_lang(fallback_languages(language))
+            end
+
+            next unless value
+
+            new_definition = definition.dup
+            new_definition.translations[language] = value
+
+            new_section.definitions << new_definition
+            result.definitions_by_key[new_definition.key] = new_definition
+          end
+
+          result.sections << new_section
+        end
+
+        return result
+      end
+    end
+
+  end
+end

data/lib/twine/placeholders.rb

@@ -0,0 +1,54 @@
+module Twine
+  module Placeholders
+    extend self
+
+    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
+
+    # 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')
+
+      placeholder_syntax = PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH + placeholder_types
+      placeholder_regex = /%#{placeholder_syntax}/
+
+      number_of_placeholders = value.scan(placeholder_regex).size
+
+      return value if number_of_placeholders == 0
+
+      # got placeholders -> need to double single percent signs
+      # % -> %% (but %% -> %%, %d -> %d)
+      single_percent_regex = /([^%])(%)(?!(%|#{placeholder_syntax}))/
+      value.gsub! single_percent_regex, '\1%%'
+
+      return value if number_of_placeholders < 2
+
+      # number placeholders
+      non_numbered_placeholder_regex = /%(#{PLACEHOLDER_FLAGS_WIDTH_PRECISION_LENGTH}#{placeholder_types})/
+
+      number_of_non_numbered_placeholders = value.scan(non_numbered_placeholder_regex).size
+
+      return value if number_of_non_numbered_placeholders == 0
+
+      raise Twine::Error.new("The value \"#{input}\" contains numbered and non-numbered placeholders") if number_of_placeholders != number_of_non_numbered_placeholders
+
+      # %d -> %$1d
+      index = 0
+      value.gsub!(non_numbered_placeholder_regex) { "%#{index += 1}$#{$1}" }
+
+      value
+    end
+
+    def convert_placeholders_from_android_to_twine(input)
+      placeholder_regex = /(%#{PLACEHOLDER_PARAMETER_FLAGS_WIDTH_PRECISION_LENGTH})s/
+
+      # %s -> %@
+      input.gsub(placeholder_regex, '\1@')
+    end
+  end
+end

data/lib/twine/plugin.rb

@@ -0,0 +1,62 @@
+require 'safe_yaml/load'
+
+SafeYAML::OPTIONS[:suppress_warnings] = true
+
+module Twine
+  class Plugin
+    attr_reader :debug, :config
+
+    def initialize
+      @debug = false
+      require_gems
+    end
+
+    ###
+    # require gems from the yaml config.
+    #
+    # gems: [twine-plugin1, twine-2]
+    #
+    # also works with single gem
+    #
+    # gems: twine-plugin1
+    #
+    def require_gems
+      # ./twine.yml    # current working directory
+      # ~/.twine       # home directory
+      # /etc/twine.yml # etc
+      cwd_config  = join_path Dir.pwd, 'twine.yml'
+      home_config = join_path Dir.home, '.twine'
+      etc_config  = '/etc/twine.yml'
+
+      config_order = [cwd_config, home_config, etc_config]
+
+      puts "Config order: #{config_order}" if debug
+
+      config_order.each do |config_file|
+        next unless valid_file config_file
+        puts "Loading: #{config_file}" if debug
+        @config = SafeYAML.load_file config_file
+        puts "Config yaml: #{config}" if debug
+        break
+      end
+
+      return unless config
+
+      # wrap gems in an array. if nil then array will be empty
+      Kernel.Array(config['gems']).each do |gem_path|
+        puts "Requiring: #{gem_path}" if debug
+        require gem_path
+      end
+    end
+
+    private
+
+    def valid_file path
+      File.exist?(path) && File.readable?(path) && !File.directory?(path)
+    end
+
+    def join_path *paths
+      File.expand_path File.join *paths
+    end
+  end
+end