translatomatic 0.1.2 → 0.1.3

data/lib/translatomatic/converter.rb

@@ -1,268 +1,36 @@
-# The converter ties together functionality from translators,
-# resource files, and the database to convert files from one
-# language to another.
-class Translatomatic::Converter
-
-  # @return [Array<Translatomatic::Model::Text>] A list of translations saved to the database
-  attr_reader :db_translations
-
-  # Create a converter to translate files
-  #
-  # @param options [Hash<Symbol,Object>] converter and/or translator options.
-  def initialize(options = {})
-    @dry_run = options[:dry_run]
-    @listener = options[:listener]
-    @translators = Translatomatic::Translator.resolve(options[:translator], options)
-    raise t("converter.translator_required") if @translators.empty?
-    @translators.each { |i| i.listener = @listener } if @listener
-
-    # use database by default if we're connected to a database
-    use_db = options.include?(:use_database) ? options[:use_database] : true
-    @use_db = use_db && ActiveRecord::Base.connected?
-    log.debug(t("converter.database_disabled")) unless @use_db
+# Converts files from one format to another
+class Translatomatic::Converter
 
-    @db_translations = []
-    @translations = {}      # map of original text to Translation
+  def initialize(options = {})
+    @options = options
   end
-
-  # @return [Translatomatic::ConverterStats] Translation statistics
-  def stats
-    @stats ||= Translatomatic::ConverterStats.new(@translations)
-  end
-
-  # Translate properties of source_file to the target locale.
-  # Does not write changes to disk.
-  #
-  # @param file [String, Translatomatic::ResourceFile] File to translate
-  # @param to_locale [String] The target locale, e.g. "fr"
-  # @return [Translatomatic::ResourceFile] The translated resource file
-  def translate(file, to_locale)
-    file = resource_file(file)
-    to_locale = parse_locale(to_locale)
 
-    # do nothing if target language is the same as source language
-    return file if file.locale.language == to_locale.language
-
-    result = Translatomatic::TranslationResult.new(file, to_locale)
-
-    # translate using strings from the database first
-    each_translator(result) { translate_properties_with_db(result) }
-    # send remaining unknown strings to translator
-    each_translator(result) { translate_properties_with_translator(result) }
-
-    log.debug(t("converter.stats", from_db: stats.from_db,
-      from_translator: stats.from_translator,
-      untranslated: result.untranslated.length))
-    @listener.untranslated_texts(result.untranslated) if @listener
-
-    file.properties = result.properties
-    file.locale = to_locale
-    file
-  end
-
-  # Translates a resource file and writes results to a target resource file.
-  # The path of the target resource file is automatically determined.
-  #
-  # @param source [Translatomatic::ResourceFile] The source
-  # @param to_locale [String] The target locale, e.g. "fr"
-  # @return [Translatomatic::ResourceFile] The translated resource file
-  def translate_to_file(source, to_locale)
-    # Automatically determines the target filename based on target locale.
-    source = resource_file(source)
-    target = Translatomatic::ResourceFile.load(source.path)
-    target.path = source.locale_path(to_locale)
-
-    log.info(t("converter.translating", source: source,
-      source_locale: source.locale, target: target, target_locale: to_locale))
-    translate(target, to_locale)
-    unless @dry_run
-      target.path.parent.mkpath
-      target.save
-    end
-    target
-  end
-
-  private
-
-  include Translatomatic::Util
-  include Translatomatic::DefineOptions
-
-  define_options(
-    { name: :dry_run, type: :boolean, aliases: "-n",
-      desc: t("converter.dry_run")
-    },
-    { name: :use_database, type: :boolean, default: true,
-      desc: t("converter.use_database")
-    }
-  )
-
-  def each_translator(result)
-    @translators.each do |translator|
-      break if result.untranslated.empty?
-      @current_translator = translator
-      yield
-    end
+  # Convert a resource file from one format to another.
+  # @param source [String] Path to source file. File must exist
+  # @param target [String] Path to target file. File will be created
+  #   or overwritten if it already exists.
+  # @return [Translatomatic::ResourceFile] The converted file.
+  def convert(source, target)
+    source_path = Pathname.new(source.to_s)
+    target_path = Pathname.new(target.to_s)
+    raise t("file.not_found", file: source.to_s) unless source_path.file?
+    raise t("file.directory", file: target.to_s) if target_path.directory?
+
+    source_file = load_file(source_path)
+    target_file = load_file(target_path)
+
+    # copy properties from source file to target
+    target_file.properties = source_file.properties
+    target_file.save(target_path, @options)
+    target_file
   end
 
-  # Attempt to restore interpolated variable names in the translation.
-  # If variable names cannot be restored, sets the translation result to nil.
-  # @param result [Translatomatic::TranslationResult] translation result
-  # @param translation [Translatomatic::Translation] translation
-  # @return [void]
-  def restore_variables(result, translation)
-    file = result.file
-    return unless file.supports_variable_interpolation?
-
-    # find variables in the original string
-    variables = string_variables(translation.original, file.locale, file)
-    # find variables in the translated string
-    translated_variables = string_variables(translation.result, result.to_locale, file)
-
-    if variables.length == translated_variables.length
-      # we can restore variables. sort by largest offset first.
-      # not using translation() method as that adds to @translations hash.
-      conversions = variables.zip(translated_variables).collect {
-         |v1, v2| Translatomatic::Translation.new(v1, v2)
-      }
-      conversions.sort_by! { |t| -t.original.offset }
-      conversions.each do |conversion|
-        v1 = conversion.original
-        v2 = conversion.result
-        translation.result[v2.offset, v2.length] = v1.value
-      end
-    else
-      # unable to restore interpolated variable names
-      log.debug("#{@current_translator.name}: unable to restore variables: #{translation.result}")
-      translation.result = nil  # mark result as invalid
-    end
-  end
-
-  def string_variables(value, locale, file)
-    string(value, locale).substrings(file.variable_regex)
-  end
-
-  def resource_file(path)
-    if path.kind_of?(Translatomatic::ResourceFile::Base)
-      path
-    else
-      file = Translatomatic::ResourceFile.load(path)
-      raise t("converter.file_unsupported", file: path) unless file
-      file
-    end
-  end
-
-  # update result with translations from the database.
-  def translate_properties_with_db(result)
-    db_texts = []
-    unless database_disabled?
-      translations = []
-      untranslated = hashify(result.untranslated)
-      db_texts = find_database_translations(result, result.untranslated.to_a)
-      db_texts.each do |db_text|
-        from_text = db_text.from_text.value
-        if untranslated[from_text]
-          translation = translation(untranslated[from_text], db_text.value, true)
-          restore_variables(result, translation)
-          translations << translation
-        end
-      end
-
-      result.update_strings(translations)
-      @listener.translated_texts(db_texts) if @listener
-    end
-    db_texts
-  end
-
-  # update result with translations from the translator.
-  def translate_properties_with_translator(result)
-    untranslated = result.untranslated.to_a.select { |i| translatable?(i) }
-    translated = []
-    if !untranslated.empty? && !@dry_run
-      untranslated_strings = untranslated.collect { |i| i.to_s }
-      log.debug("translating: #{untranslated_strings}")
-      translated = @current_translator.translate(untranslated_strings,
-        result.from_locale, result.to_locale
-      )
+  private
 
-      # create list of translations, filtering out invalid translations
-      translations = []
-      untranslated.zip(translated).each do |from, to|
-        translation = translation(from, to, false)
-        restore_variables(result, translation)
-        translations << translation
-      end
-
-      result.update_strings(translations)
-      unless database_disabled?
-        save_database_translations(result, translations)
-      end
-    end
-    translated
+  def load_file(path)
+    file = Translatomatic::ResourceFile.load(path)
+    raise t("file.unsupported", file: path) unless file
+    file
   end
 
-  def translation(from, to, from_database = false)
-    translator = @current_translator.name
-    t = Translatomatic::Translation.new(from, to, translator, from_database)
-    @translations[from] = t
-    t
-  end
-
-  def database_disabled?
-    !@use_db
-  end
-
-  def parse_locale(locale)
-    Translatomatic::Locale.parse(locale)
-  end
-
-  def translatable?(string)
-    # don't translate numbers
-    !string.empty? && !string.match(/^[\d,]+$/)
-  end
-
-  def save_database_translations(result, translations)
-    ActiveRecord::Base.transaction do
-      from = db_locale(result.from_locale)
-      to = db_locale(result.to_locale)
-      translations.each do |translation|
-        next if translation.result.nil?  # skip invalid translations
-        save_database_translation(from, to, translation)
-      end
-    end
-  end
-
-  def save_database_translation(from_locale, to_locale, translation)
-    original_text = Translatomatic::Model::Text.find_or_create_by!(
-      locale: from_locale,
-      value: translation.original.to_s
-    )
-
-    text = Translatomatic::Model::Text.find_or_create_by!(
-      locale: to_locale,
-      value: translation.result.to_s,
-      from_text: original_text,
-      translator: @current_translator.name
-    )
-    @db_translations += [original_text, text]
-    text
-  end
-
-  def find_database_translations(result, untranslated)
-    from = db_locale(result.from_locale)
-    to = db_locale(result.to_locale)
-
-    Translatomatic::Model::Text.where({
-      locale: to,
-      translator: @current_translator.name,
-      from_texts_texts: {
-        locale_id: from,
-        # convert untranslated set to strings
-        value: untranslated.collect { |i| i.to_s }
-      }
-    }).joins(:from_text)
-  end
-
-  def db_locale(locale)
-    Translatomatic::Model::Locale.from_tag(locale)
-  end
-end
+end

data/lib/translatomatic/database.rb

@@ -1,143 +1,143 @@
-require 'active_record'
-
-# Database functions
-class Translatomatic::Database
-
-  class << self
-    # @param options [Hash<Symbol,Object>] Database options
-    # @return [boolean] True if we can connect to the database
-    def enabled?(options = {})
-      new(options).connect
-    end
-  end
-
-  def initialize(options = {})
-    @env = options[:database_env] || DEFAULT_ENV
-    @db_config = database_config(@env, options)
-    @env_config = @db_config
+require 'active_record'
+
+# Database functions
+class Translatomatic::Database
+
+  class << self
+    # @param options [Hash<Symbol,Object>] Database options
+    # @return [boolean] True if we can connect to the database
+    def enabled?(options = {})
+      new(options).connect
+    end
+  end
+
+  def initialize(options = {})
+    @env = options[:database_env] || DEFAULT_ENV
+    @db_config = database_config(@env, options)
+    @env_config = @db_config
     raise t("database.no_environment",
-      env: @env, file: db_config_path) unless @env_config[@env]
-    @env_config = @env_config[@env] || {}
-
-    ActiveRecord::Base.configurations = @db_config
-    ActiveRecord::Tasks::DatabaseTasks.env = @env
-    ActiveRecord::Tasks::DatabaseTasks.db_dir = DB_PATH
-    ActiveRecord::Tasks::DatabaseTasks.root = DB_PATH
-    ActiveRecord::Tasks::DatabaseTasks.database_configuration = @db_config
-    create unless exists?
-    migrate
-  end
-
-  # Connect to the database
-  # @return [boolean] True if the connection was established
-  def connect
-    begin
-      ActiveRecord::Base.establish_connection(@env_config)
-      true
-    rescue LoadError
-      false
-    end
-  end
-
-  # Disconnect from the database
-  # @return [void]
-  def disconnect
-    ActiveRecord::Base.remove_connection
-  end
-
-  # Test if the database exists
-  # @return [Boolean] true if the database exists
-  def exists?
-    begin
-      return true if sqlite_database_exists?
-      return false unless connect
-      ActiveRecord::Base.connection.tables
-    rescue
-      return false
-    end
-    true
-  end
-
-  # Run outstanding migrations against the database
-  # @return [void]
-  def migrate
-    return false unless connect
-    ActiveRecord::Migrator.migrate(MIGRATIONS_PATH)
-    ActiveRecord::Base.clear_cache!
+      env: @env, file: db_config_path) unless @env_config[@env]
+    @env_config = @env_config[@env] || {}
+
+    ActiveRecord::Base.configurations = @db_config
+    ActiveRecord::Tasks::DatabaseTasks.env = @env
+    ActiveRecord::Tasks::DatabaseTasks.db_dir = DB_PATH
+    ActiveRecord::Tasks::DatabaseTasks.root = DB_PATH
+    ActiveRecord::Tasks::DatabaseTasks.database_configuration = @db_config
+    create unless exists?
+    migrate
+  end
+
+  # Connect to the database
+  # @return [boolean] True if the connection was established
+  def connect
+    begin
+      ActiveRecord::Base.establish_connection(@env_config)
+      true
+    rescue LoadError
+      false
+    end
+  end
+
+  # Disconnect from the database
+  # @return [void]
+  def disconnect
+    ActiveRecord::Base.remove_connection
+  end
+
+  # Test if the database exists
+  # @return [Boolean] true if the database exists
+  def exists?
+    begin
+      return true if sqlite_database_exists?
+      return false unless connect
+      ActiveRecord::Base.connection.tables
+    rescue
+      return false
+    end
+    true
+  end
+
+  # Run outstanding migrations against the database
+  # @return [void]
+  def migrate
+    return false unless connect
+    ActiveRecord::Migrator.migrate(MIGRATIONS_PATH)
+    ActiveRecord::Base.clear_cache!
     log.debug t("database.migrated")
-  end
-
-  # Create the database
-  # @return [boolean] True if the database was created
-  def create
-    begin
-      ActiveRecord::Tasks::DatabaseTasks.create(@env_config)
-      log.debug t("database.created")
-      true
+  end
+
+  # Create the database
+  # @return [boolean] True if the database was created
+  def create
+    begin
+      ActiveRecord::Tasks::DatabaseTasks.create(@env_config)
+      log.debug t("database.created")
+      true
     rescue LoadError => e
       log.debug t("database.could_not_create")
-      log.error e.message
-      false
-    end
-  end
-
-  # Drop the database
-  # @return [void]
-  def drop
-    disconnect
-    ActiveRecord::Tasks::DatabaseTasks.drop(@env_config)
-    log.debug t("database.deleted")
-  end
-
+      log.error e.message
+      false
+    end
+  end
+
+  # Drop the database
+  # @return [void]
+  def drop
+    disconnect
+    ActiveRecord::Tasks::DatabaseTasks.drop(@env_config)
+    log.debug t("database.deleted")
+  end
+
   private
 
   include Translatomatic::Util
   include Translatomatic::DefineOptions
-
-  def sqlite_database_exists?
-    @env_config['adapter'] == 'sqlite3' && File.exist?(@env_config['database'])
-  end
-
-  def self.join_path(*parts)
-    File.realpath(File.join(*parts))
-  end
-
-  DB_PATH = join_path(File.dirname(__FILE__), "..", "..", "db")
-  INTERNAL_CONFIG = File.join(DB_PATH, "database.yml")
-  CUSTOM_CONFIG = File.join(Dir.home, ".translatomatic", "database.yml")
-  DEFAULT_CONFIG = File.exist?(CUSTOM_CONFIG) ? CUSTOM_CONFIG : INTERNAL_CONFIG
-  MIGRATIONS_PATH = File.join(DB_PATH, "migrate")
-  GEM_ROOT = join_path(File.dirname(__FILE__), "..", "..")
-  DEFAULT_ENV = "production"
-
-  define_options(
-    { name: :database_config, desc: t("database.config_file"),
-      default: DEFAULT_CONFIG },
+
+  def sqlite_database_exists?
+    @env_config['adapter'] == 'sqlite3' && File.exist?(@env_config['database'])
+  end
+
+  def self.join_path(*parts)
+    File.realpath(File.join(*parts))
+  end
+
+  DB_PATH = join_path(File.dirname(__FILE__), "..", "..", "db")
+  INTERNAL_CONFIG = File.join(DB_PATH, "database.yml")
+  CUSTOM_CONFIG = File.join(Dir.home, ".translatomatic", "database.yml")
+  DEFAULT_CONFIG = File.exist?(CUSTOM_CONFIG) ? CUSTOM_CONFIG : INTERNAL_CONFIG
+  MIGRATIONS_PATH = File.join(DB_PATH, "migrate")
+  GEM_ROOT = join_path(File.dirname(__FILE__), "..", "..")
+  DEFAULT_ENV = "production"
+
+  define_options(
+    { name: :database_config, desc: t("database.config_file"),
+      default: DEFAULT_CONFIG },
     { name: :database_env, desc: t("database.env"),
-      default: DEFAULT_ENV })
-
-  # return path to database config
-  def database_config_path(options)
-    if options[:database_env] == "test"
-      INTERNAL_CONFIG  # rspec
-    elsif options[:database_config]
-      return options[:database_config]
-    else
-      DEFAULT_CONFIG
-    end
-  end
-
-  # return database config as a hash
-  def database_config(env, options)
-    if options[:database_config].kind_of?(Hash)
-      return { env => options[:database_config] }
-    end
-
-    db_config_path = database_config_path(options)
-    dbconfig = File.read(db_config_path)
-    dbconfig.gsub!(/\$HOME/, Dir.home)
-    dbconfig.gsub!(/\$GEM_ROOT/, GEM_ROOT)
-    YAML::load(dbconfig) || {}
-  end
-
-end
+      default: DEFAULT_ENV })
+
+  # return path to database config
+  def database_config_path(options)
+    if options[:database_env] == "test"
+      INTERNAL_CONFIG  # rspec
+    elsif options[:database_config]
+      return options[:database_config]
+    else
+      DEFAULT_CONFIG
+    end
+  end
+
+  # return database config as a hash
+  def database_config(env, options)
+    if options[:database_config].kind_of?(Hash)
+      return { env => options[:database_config] }
+    end
+
+    db_config_path = database_config_path(options)
+    dbconfig = File.read(db_config_path)
+    dbconfig.gsub!(/\$HOME/, Dir.home)
+    dbconfig.gsub!(/\$GEM_ROOT/, GEM_ROOT)
+    YAML::load(dbconfig) || {}
+  end
+
+end

data/lib/translatomatic/define_options.rb

@@ -0,0 +1,22 @@
+module Translatomatic
+  # @!visibility private
+  module DefineOptions
+
+    # @!visibility private
+    module ClassMethods
+      attr_reader :options
+
+      private
+
+      def define_options(*options)
+        @options = options.collect { |i| Translatomatic::Option.new(i) }
+      end
+    end
+
+    private
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+  end
+end

data/lib/translatomatic/extractor/base.rb

@@ -1,16 +1,16 @@
-module Translatomatic::Extractor
-  # Base class for string extraction functionality
-  class Base
-
-    def initialize(path)
-      @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
-      @contents = @path.read
-    end
-
-    # @return [Array<String>] All strings found
-    def extract
-      @contents.scan(/\"(.*?[^\\])"|'(.*?[^\\])'/).flatten.compact
-    end
-
-  end
-end
+module Translatomatic::Extractor
+  # Base class for string extraction functionality
+  class Base
+
+    def initialize(path)
+      @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      @contents = @path.read
+    end
+
+    # @return [Array<String>] All strings found
+    def extract
+      @contents.scan(/\"(.*?[^\\])"|'(.*?[^\\])'/).flatten.compact
+    end
+
+  end
+end

data/lib/translatomatic/extractor/ruby.rb

@@ -1,6 +1,6 @@
-module Translatomatic::Extractor
-  # Class to extract strings from ruby code
-  class Ruby < Base
-
-  end # class
-end   # module
+module Translatomatic::Extractor
+  # Class to extract strings from ruby code
+  class Ruby < Base
+
+  end # class
+end   # module

data/lib/translatomatic/extractor.rb

@@ -1,5 +1,5 @@
-# Classes to extract strings from files
-module Translatomatic::Extractor; end
-
-require 'translatomatic/extractor/base'
-require 'translatomatic/extractor/ruby'
+# Classes to extract strings from files
+module Translatomatic::Extractor; end
+
+require 'translatomatic/extractor/base'
+require 'translatomatic/extractor/ruby'