translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/logger.rb

@@ -1,36 +1,51 @@
-# Logging
-class Translatomatic::Logger
-
-  # @return [ProgressBar] A progress bar
-  attr_accessor :progressbar
-
-  # @return [Translatomatic::Logger] create a new logger instance
-  def initialize
-    @logger = Logger.new(STDOUT)
-    @logger.level = ENV['DEBUG'] ? Logger::DEBUG : Logger::INFO
-    @logger.formatter = proc do |severity, datetime, progname, msg|
-      "#{msg}\n"
+require 'logger'
+
+module Translatomatic
+  # Logging
+  class Logger
+    # @return [ProgressBar] A progress bar
+    attr_accessor :progressbar
+
+    # @return [Translatomatic::Logger] create a new logger instance
+    def initialize
+      @logger = ::Logger.new(STDOUT)
+      @logger.level = ENV['DEBUG'] ? ::Logger::DEBUG : ::Logger::INFO
+      @logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{msg}\n"
+      end
     end
-  end
 
-  # Called at the end of translatomatic to clear the progress bar.
-  def finish
-    @finished ||= begin
-      @progressbar.finish if @progressbar
-      true
+    # Called at the end of translatomatic to clear the progress bar.
+    def finish
+      @finished ||= begin
+        @progressbar.finish if @progressbar
+        true
+      end
     end
-  end
 
-  private
+    private
 
-  def method_missing(name, *args)
-    handle_logger_method(name, args) if @logger.respond_to?(name)
-  end
+    def respond_to_missing?(name, include_private = false)
+      @logger.respond_to?(name, include_private) || super
+    end
 
-  def handle_logger_method(name, args)
-    @progressbar.clear if @progressbar
-    @logger.send(name, *args)
-    @progressbar.refresh(force: true) if @progressbar && !@progressbar.stopped?
-  end
+    def method_missing(name, *args)
+      if @logger.respond_to?(name)
+        handle_logger_method(name, args)
+      else
+        super
+      end
+    end
+
+    def handle_logger_method(name, args)
+      @progressbar.clear if @progressbar
+      @logger.send(name, *args)
+      refresh_progress_bar
+    end
 
+    def refresh_progress_bar
+      return unless @progressbar && !@progressbar.stopped?
+      @progressbar.refresh(force: true)
+    end
+  end
 end

data/lib/translatomatic/metadata.rb

@@ -0,0 +1,58 @@
+module Translatomatic
+  # Parses tm.context comments in resource files
+  class Metadata
+    attr_reader :context
+
+    def initialize
+      reset
+    end
+
+    # Find associated context(s) for a property.
+    # Contexts are defined using tm.context comments in resource files.
+    # @return [Array<String>] Context for the given key
+    def get_context(key)
+      @context[key]
+    end
+
+    # Clear all metadata
+    def reset
+      @context = {}
+      @current_context = nil
+    end
+
+    # Assign current metadata to the given key
+    # @param key [String] name of the key
+    def assign_key(key, options = {})
+      if @current_context.present?
+        @context[key] = @current_context
+        @current_context = nil unless options[:keep_context]
+      end
+    end
+
+    # Clear the current context
+    def clear_context
+      @current_context = nil
+    end
+
+    # Add to the current context
+    # @param context [String] A context string
+    def add_context(context)
+      return unless context.present?
+      @current_context ||= []
+      @current_context << context.strip
+    end
+
+    # Parse comment text and extract metadata
+    # @return [Array] parsed context data
+    def parse_comment(comment)
+      return nil if comment.blank?
+      contexts = comment.scan(/tm\.context:\s*(.*)/)
+      result = []
+      contexts.each do |i|
+        add_context(i[0])
+        result << i[0]
+      end
+      result
+    end
+  end
+end

data/lib/translatomatic/model.rb

@@ -1,5 +1,7 @@
-# Contains classes that interface to records in the translatomatic database
-module Translatomatic::Model; end
+module Translatomatic
+  # Active record model classes
+  module Model; end
+end
 
 require 'translatomatic/model/locale'
 require 'translatomatic/model/text'

data/lib/translatomatic/model/locale.rb

@@ -3,22 +3,22 @@ module Translatomatic
     # Locale database record.
     # Used to store translations in the database.
     class Locale < ActiveRecord::Base
-      has_many :texts, class_name: "Translatomatic::Model::Text"
+      has_many :texts, class_name: 'Translatomatic::Model::Text'
       validates_presence_of :language
-      validates_uniqueness_of :language, scope: [:script, :region]
+      validates_uniqueness_of :language, scope: %i[script region]
 
       # Create a locale record from an I18n::Locale::Tag object or string
       # @return [Translatomatic::Model::Locale] Locale record
       def self.from_tag(tag)
         tag = Translatomatic::Locale.parse(tag)
-        find_or_create_by!({
+        find_or_create_by!(
           language: tag.language, script: tag.script, region: tag.region
-        })
+        )
       end
 
       # @return [String] Locale as string
       def to_s
-        [language, script, region].compact.join("-")
+        [language, script, region].compact.join('-')
       end
     end
   end

data/lib/translatomatic/model/text.rb

@@ -3,15 +3,15 @@ module Translatomatic
     # Text database record.
     # Used to store translations in the database.
     class Text < ActiveRecord::Base
-      belongs_to :locale, class_name: "Translatomatic::Model::Locale"
-      belongs_to :from_text, class_name: "Translatomatic::Model::Text"
-      has_many :translations, class_name: "Translatomatic::Model::Text",
-        foreign_key: :from_text_id, dependent: :delete_all
+      belongs_to :locale, class_name: 'Translatomatic::Model::Locale'
+      belongs_to :from_text, class_name: 'Translatomatic::Model::Text'
+      has_many :translations, class_name: 'Translatomatic::Model::Text',
+                              foreign_key: :from_text_id, dependent: :delete_all
 
       validates_presence_of :value
       validates_presence_of :locale
 
-      def is_translated?
+      def translated?
         !from_text_id.nil?
       end
     end

data/lib/translatomatic/option.rb

@@ -28,58 +28,81 @@ module Translatomatic
     # @return [boolean] True if this option can only be set on the command line
     attr_reader :command_line_only
 
-    # @return [boolean] True if this option can only be set in user context
-    attr_reader :user_context_only
+    # @return [boolean] True if this option can only be set in the
+    #   user configuration file
+    attr_reader :user_location_only
 
     # Create a new option
-    # @param data [Hash<Symbol,Object>] Attributes as above
+    # @param attributes [Hash<Symbol,Object>] Attributes as above
     # @return [Translatomatic::Option] A new option instance
-    def initialize(data = {})
-      @name = data[:name]
-      @required = data[:required]
-      @description = data[:desc]
-      @use_env = data[:use_env]
-      @hidden = data[:hidden]
-      @type = data[:type] || :string
-      @default = data[:default]
-      @aliases = data[:aliases]
-      @enum = data[:enum]
-      @user_context_only = data[:user_context_only]
-      @command_line_only = data[:command_line_only]
-      @env_name = data[:env_name] || (@use_env ? @name.to_s.upcase : nil)
+    def initialize(attributes = {})
+      attributes.each do |k, v|
+        raise "unrecognised attribute #{k}" unless constructor_option?(k)
+        instance_variable_set("@#{k}", v)
+      end
+      @description = @desc
+      @type ||= :string
+      raise "invalid type: #{@type}" unless VALID_TYPES.include?(@type)
+      @env_name ||= @use_env && @name ? @name.to_s.upcase : nil
+      @user_location_only = true if @name.to_s =~ /api_key/
     end
 
+    # Return sconfiguration for a thor command line option
+    # @return [Hash] Thor configuration
     def to_thor
-      # use internal ',' splitting for array types on command line
-      type = @type == :array ? :string : @type
-
-      { name: @name,
+      {
         required: @required,
-        type: type,
+        type: thor_type,
         desc: @description,
         default: @default,
         aliases: @aliases,
-        enum: @enum ? @enum.collect { |i| i.to_s } : nil
+        banner: @type == :boolean ? nil : type_name,
+        enum: @enum ? @enum.collect(&:to_s) : nil
       }
     end
 
+    # Translate the type of this option
+    # @return [String] The translated type
+    def type_name
+      t("config.types.#{type}")
+    end
+
     # Retrieve all options from an object or list of objects.
     # @param object [#options,Array<#options>] Options source
     # @return [Array<Translatomatic::Option>] options
     def self.options_from_object(object)
-      options = []
-      if object.respond_to?(:options)
-        options += options_from_object(object.options)
-      elsif object.kind_of?(Array)
-        object.each do |item|
-          if item.kind_of?(Translatomatic::Option)
-            options << item
-          elsif item.respond_to?(:options)
-            options += options_from_object(item.options)
-          end
-        end
+      if object.is_a?(Translatomatic::Option)
+        [object]
+      elsif object.respond_to?(:options)
+        options_from_object(object.options)
+      elsif object.is_a?(Array)
+        object.collect { |i| options_from_object(i) }.flatten
+      else
+        []
+      end
+    end
+
+    private
+
+    include Util
+
+    CONSTRUCTOR_OPTIONS = %i[name required desc use_env hidden type default
+                             aliases enum user_location_only
+                             command_line_only env_name].freeze
+    VALID_TYPES = %i[array path_array string path boolean numeric].freeze
+
+    def constructor_option?(key)
+      CONSTRUCTOR_OPTIONS.include?(key)
+    end
+
+    def thor_type
+      case @type
+      when :array, :path_array, :string, :path
+        # use internal ',' splitting for array types on command line
+        :string
+      else
+        @type
       end
-      options
     end
   end
 end

data/lib/translatomatic/path_utils.rb

@@ -0,0 +1,126 @@
+module Translatomatic
+  # Utilities for locales and paths
+  module PathUtils
+    # Find a new path representing the given path with a new locale
+    # @param path [Pathname] The current path
+    # @param target_locale [String] The target locale
+    # @return [Pathname] The new path for the given locale
+    def modify_path_locale(path, target_locale, preferred_separator = '.')
+      basename = basename_stripped(path)
+
+      extlist = extension_list(path)
+      if extlist.length >= 2 && (loc_idx = find_extension_locale(extlist))
+        # extension(s) contains locale, replace it
+        extlist[loc_idx] = target_locale.to_s
+        filename = basename + '.' + extlist.join('.')
+        path.dirname + filename
+      elsif valid_locale?(basename)
+        # basename is a locale name, replace it
+        path.dirname + (target_locale.to_s + path.extname)
+      elsif basename.match(/_([-\w]+)\Z/) &&
+            valid_locale?(Regexp.last_match(1))
+        # basename contains locale, e.g. basename_$locale.ext
+        add_basename_locale(path, target_locale, '_') # retain _
+      elsif valid_locale?(path.parent.basename(path.parent.extname)) ||
+            path.parent.basename.to_s == 'Base.lproj'
+        # parent directory contains locale, e.g. strings/en-US/text.resw
+        # or project/en.lproj/Strings.strings
+        path.parent.parent + (target_locale.to_s +
+          path.parent.extname) + path.basename
+      elsif path.to_s =~ %r{\bres/values([-\w]+)?/.+$}
+        # android strings
+        filename = path.basename
+        path.parent.parent + ('values-' + target_locale.to_s) + filename
+      else
+        # default behaviour, add locale after separator in basename
+        add_basename_locale(path, target_locale, preferred_separator)
+      end
+    end
+
+    # detect locale from path
+    def detect_path_locale(path)
+      return nil unless path
+      tag = nil
+      basename = path.sub_ext('').basename.to_s
+      directory = path.dirname.basename.to_s
+      extlist = extension_list(path)
+
+      if basename.match(/_([-\w]{2,})$/) &&
+         valid_locale?(Regexp.last_match(1))
+        # locale after underscore in filename
+        tag = Regexp.last_match(1)
+      elsif directory =~ /^([-\w]+)\.lproj$/
+        # xcode localized strings
+        tag = Regexp.last_match(1)
+      elsif extlist.length >= 2 && (loc_idx = find_extension_locale(extlist))
+        # multiple parts to extension, e.g. index.html.en
+        tag = extlist[loc_idx]
+      elsif valid_locale?(basename)
+        # try to match on entire basename
+        # (support for rails en.yml)
+        tag = basename
+      elsif valid_locale?(path.parent.basename)
+        # try to match on parent directory, e.g. strings/en-US/text.resw
+        tag = path.parent.basename
+      elsif path.parent.basename.to_s.match(/-([-\w]+)/) &&
+            valid_locale?(Regexp.last_match(1))
+        # try to match on trailing part of parent directory,
+        # e.g. res/values-en/strings.xml
+        tag = Regexp.last_match(1)
+      end
+
+      tag ? Translatomatic::Locale.parse(tag, true) : nil
+    end
+
+    private
+
+    def read_contents(path)
+      Translatomatic::Slurp.read(path.to_s)
+    end
+
+    # ext_sub() only removes the last extension
+    def basename_stripped(path)
+      filename = path.basename.to_s
+      filename.sub!(/\..*$/, '')
+      filename
+    end
+
+    def relative_path(path)
+      if path.relative?
+        path
+      else
+        path.relative_path_from(Pathname.pwd)
+      end
+    end
+
+    # for index.html.de, returns ['html', 'de']
+    def extension_list(path)
+      filename = path.basename.to_s
+      idx = filename.index('.')
+      if idx && idx < filename.length - 1
+        filename[idx + 1..-1].split('.')
+      else
+        []
+      end
+    end
+
+    def add_basename_locale(path, target_locale, preferred_separator = '.')
+      # remove any underscore and trailing text from basename
+      deunderscored = basename_stripped(path).sub(/_.*?\Z/, '')
+      # add #{preferred_separator}locale.ext
+      filename = deunderscored + preferred_separator +
+                 target_locale.to_s + path.extname
+      path.dirname + filename
+    end
+
+    # test if the list of strings contains a valid locale
+    # return the index to the locale, or nil if no locales found
+    def find_extension_locale(extlist)
+      extlist.find_index { |i| valid_locale?(i) }
+    end
+
+    def valid_locale?(tag)
+      Translatomatic::Locale.new(tag).valid?
+    end
+  end
+end

data/lib/translatomatic/progress_updater.rb

@@ -1,19 +1,16 @@
-# implements Converter listener
-class Translatomatic::ProgressUpdater
-  # Create a new progress updater
-  # @param progressbar [Progressbar] A ruby-progressbar object
-  def initialize(progressbar)
-    @progressbar = progressbar
-  end
-
-  # @return [Number] the number of translated strings
-  def translated_texts(texts)
-    @progressbar.progress += texts.length
-  end
+module Translatomatic
+  # Class to update the progress bar for the CLI
+  class ProgressUpdater
+    # Create a new progress updater
+    # @param progressbar [Progressbar] A ruby-progressbar object
+    def initialize(progressbar)
+      @progressbar = progressbar
+    end
 
-  # @return [Number] the number of untranslated strings
-  def untranslated_texts(texts)
-    @progressbar.total -= texts.length
+    # @param count [Number] Update progress
+    # @return [Number] The total number of processed items.
+    def update_progress(count)
+      @progressbar.progress += count
+    end
   end
-
 end