translatomatic 0.1.0 → 0.1.1

data/lib/translatomatic/converter.rb

@@ -1,157 +1,221 @@
-class Translatomatic::Converter
-  include Translatomatic::Util
-
-  class << self
-    attr_reader :options
-    private
-    include Translatomatic::DefineOptions
-  end
-
-  define_options(
-    { name: :translator, type: :string, aliases: "-t",
-      desc: "The translator implementation",
-      enum: Translatomatic::Translator.names },
-    { name: :dry_run, type: :boolean, aliases: "-n", desc:
-      "Print actions without performing translations or writing files" }
-  )
-
-  # @return [Translatomatic::ConverterStats] translation statistics
+class Translatomatic::Converter
+
+  class << self
+    attr_reader :options
+    private
+    include Translatomatic::DefineOptions
+  end
+
+  define_options(
+    { name: :translator, type: :string, aliases: "-t",
+      desc: "Translator implementation to use",
+      enum: Translatomatic::Translator.names },
+    { name: :dry_run, type: :boolean, aliases: "-n", desc:
+      "Print actions without performing translations or writing files" },
+    { name: :use_database, type: :boolean, default: true, desc:
+      "Store and retrieve translations in the database" }
+  )
+
+  # @return [Translatomatic::ConverterStats] translation statistics
   attr_reader :stats
 
-  # Create a converter to translate files
-  #
-  # @param options A hash of converter and/or translator options.
-  def initialize(options = {})
-    @dry_run = options[:dry_run]
-    @translator = options[:translator]
-    if @translator.kind_of?(String) || @translator.kind_of?(Symbol)
-      klass = Translatomatic::Translator.find(@translator)
-      @translator = klass.new(options)
-    end
-    raise "translator required" unless @translator
-    @from_db = 0
+  # @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 A hash of converter and/or translator options.
+  def initialize(options = {})
+    @dry_run = options[:dry_run]
+    @translator = options[:translator]
+    @listener = options[: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("database is disabled") unless @use_db
+    if @translator && !@translator.respond_to?(:translate)
+      klass = Translatomatic::Translator.find(@translator)
+      @translator = klass.new(options)
+    end
+    raise "translator required" unless @translator
+    @translator.listener = @listener if @listener
+    @from_db = 0
     @from_translator = 0
-  end
-
-  # @return [Translatomatic::ConverterStats] Translation statistics
-  def stats
-    Translatomatic::ConverterStats.new(@from_db, @from_translator)
-  end
-
-  # Translate contents of source_file to the target locale.
-  # Automatically determines the target filename based on target locale.
-  #
-  # @param [String, Translatomatic::ResourceFile] source_file File to translate
-  # @param [String] to_locale The target locale, e.g. "fr"
-  # @return [Translatomatic::ResourceFile] The translated resource file
-  def translate(source_file, to_locale)
-    if source_file.kind_of?(Translatomatic::ResourceFile::Base)
-      source = source_file
-    else
-      source = Translatomatic::ResourceFile.load(source_file)
-      raise "unsupported file type #{source_file}" unless source
+    @db_translations = []
+  end
+
+  # @return [Translatomatic::ConverterStats] Translation statistics
+  def stats
+    Translatomatic::ConverterStats.new(@from_db, @from_translator)
+  end
+
+  # Translate contents of source_file to the target locale.
+  # Automatically determines the target filename based on target locale.
+  #
+  # @param [String, Translatomatic::ResourceFile] source_file File to translate
+  # @param [String] to_locale The target locale, e.g. "fr"
+  # @return [Translatomatic::ResourceFile] The translated resource file
+  def translate(source_file, to_locale)
+    if source_file.kind_of?(Translatomatic::ResourceFile::Base)
+      source = source_file
+    else
+      source = Translatomatic::ResourceFile.load(source_file)
+      raise "unsupported file type #{source_file}" unless source
+    end
+
+    to_locale = parse_locale(to_locale)
+    target = Translatomatic::ResourceFile.load(source.path)
+    target.path = source.locale_path(to_locale)
+    target.locale = to_locale
+    translate_to_target(source, target)
+  end
+
+  # Translates a resource file and writes results to a target resource file
+  #
+  # @param source [Translatomatic::ResourceFile] The source
+  # @param target [Translatomatic::ResourceFile] The file to write
+  # @return [Translatomatic::ResourceFile] The translated resource file
+  def translate_to_target(source, target)
+    # perform translation
+    log.info("translating #{source} to #{target}")
+    properties = translate_properties(source.properties, source.locale, target.locale)
+    target.properties = properties
+    unless @dry_run
+      target.path.parent.mkpath
+      target.save
+    end
+    target
+  end
+
+  # Translate values in the hash of properties.
+  # Uses existing translations from the database if available.
+  #
+  # @param [Hash] properties Text to translate
+  # @param [String, Locale] from_locale The locale of the given properties
+  # @param [String, Locale] to_locale The target locale for translations
+  # @return [Hash] Translated properties
+  def translate_properties(properties, from_locale, to_locale)
+    from_locale = parse_locale(from_locale)
+    to_locale = parse_locale(to_locale)
+
+    # sanity check
+    return properties if from_locale.language == to_locale.language
+
+    result = Translatomatic::TranslationResult.new(properties,
+      from_locale, to_locale)
+
+    # translate using strings from the database first
+    db_texts = translate_properties_with_db(result)
+
+    # send remaining unknown strings to translator
+    tr_texts = translate_properties_with_translator(result)
+
+    log.debug("translations from db: %d translator: %d untranslated: %d" %
+      [db_texts.length, tr_texts.length, result.untranslated.length])
+    @listener.untranslated_texts(result.untranslated) if @listener
+
+    result.properties
+  end
+
+  private
+
+  include Translatomatic::Util
+
+  # update result with translations from the database.
+  # returns a list of text records from the database.
+  def translate_properties_with_db(result)
+    db_texts = []
+    unless database_disabled?
+      untranslated = result.untranslated.to_a
+      db_texts = find_database_translations(result, untranslated)
+
+      # find strings in untranslated that were matched in the database
+      original_map = {}  # map of original text to translated text from db
+      db_texts.each do |db_text|
+        original_map[db_text.from_text.value] = db_text
+      end
+      matched = untranslated.select { |i| original_map[i.value] }
+      db_texts = db_texts.collect { |i| i.value }
+      result.update_strings(matched, db_texts)
+      @from_db += db_texts.length
+      @listener.translated_texts(db_texts) if @listener
     end
-
-    to_locale = parse_locale(to_locale)
-    target = Translatomatic::ResourceFile.load(source.path)
-    target.path = source.locale_path(to_locale)
-    target.locale = to_locale
-    translate_to_target(source, target)
-  end
-
-  # Translates a resource file and writes results to a target resource file
-  #
-  # @param source [Translatomatic::ResourceFile] The source
-  # @param target [Translatomatic::ResourceFile] The file to write
-  # @return [Translatomatic::ResourceFile] The translated resource file
-  def translate_to_target(source, target)
-    # perform translation
-    log.info "translating #{source} to #{target}"
-    properties = translate_properties(source.properties, source.locale, target.locale)
-    target.properties = properties
-    target.save unless @dry_run
-    target
+    db_texts
   end
 
-  # Translate values in the hash of properties.
-  # Uses existing translations from the database if available.
-  #
-  # @param [Hash] properties Text to translate
-  # @param [String, Locale] from_locale The locale of the given properties
-  # @param [String, Locale] to_locale The target locale for translations
-  # @return [Hash] Translated properties
-  def translate_properties(properties, from_locale, to_locale)
-    from_locale = parse_locale(from_locale)
-    to_locale = parse_locale(to_locale)
-
-    # sanity check
-    return properties if from_locale.language == to_locale.language
-
-    result = Translatomatic::TranslationResult.new(properties,
-      from_locale, to_locale)
-
-    # find translations in database first
-    texts = find_database_translations(result)
-    result.update_db_strings(texts)
-    @from_db += texts.length
-
-    # send remaining unknown strings to translator
-    # (copy untranslated set from result)
+  # update result with translations from the translator.
+  # returns a list of strings from the translator.
+  def translate_properties_with_translator(result)
     untranslated = result.untranslated.to_a.select { |i| translatable?(i) }
+    translated = []
     @from_translator += untranslated.length
     if !untranslated.empty? && !@dry_run
-      translated = @translator.translate(untranslated, from_locale, to_locale)
+      translated = @translator.translate(untranslated.collect { |i| i.to_s },
+        result.from_locale, result.to_locale)
       result.update_strings(untranslated, translated)
-      save_database_translations(result, untranslated, translated)
-    end
-
-    log.debug("translations from db: %d translator: %d untranslated: %d" %
-      [texts.length, untranslated.length, result.untranslated.length])
-    result.properties
-  end
-
-  private
-
-  def translatable?(string)
-    # don't translate numbers
-    !string.empty? && !string.match(/^[\d,]+$/)
-  end
-
-  def save_database_translations(result, untranslated, translated)
-    ActiveRecord::Base.transaction do
-      from = db_locale(result.from_locale)
-      to = db_locale(result.to_locale)
-      untranslated.zip(translated).each do |t1, t2|
-        save_database_translation(from, to, t1, t2)
+      unless database_disabled?
+        save_database_translations(result, untranslated, translated)
       end
     end
+    translated
   end
 
-  def save_database_translation(from_locale, to_locale, t1, t2)
-    original_text = Translatomatic::Model::Text.find_or_create_by!(
-      locale: from_locale,
-      value: t1
-    )
-
-    Translatomatic::Model::Text.find_or_create_by!(
-      locale: to_locale,
-      value: t2,
-      from_text: original_text,
-      translator: @translator.class.name.demodulize
-    )
-  end
-
-  def find_database_translations(result)
-    from = db_locale(result.from_locale)
-    to = db_locale(result.to_locale)
-
-    Translatomatic::Model::Text.where({
-      locale: to,
-      from_texts_texts: { locale_id: from, value: result.untranslated.to_a }
-    }).joins(:from_text)
-  end
-
-  def db_locale(locale)
-    Translatomatic::Model::Locale.from_tag(locale)
+  def database_disabled?
+    !@use_db
   end
-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, untranslated, translated)
+    ActiveRecord::Base.transaction do
+      from = db_locale(result.from_locale)
+      to = db_locale(result.to_locale)
+      untranslated.zip(translated).each do |t1, t2|
+        save_database_translation(from, to, t1, t2)
+      end
+    end
+  end
+
+  def save_database_translation(from_locale, to_locale, t1, t2)
+    original_text = Translatomatic::Model::Text.find_or_create_by!(
+      locale: from_locale,
+      value: t1.to_s
+    )
+
+    text = Translatomatic::Model::Text.find_or_create_by!(
+      locale: to_locale,
+      value: t2.to_s,
+      from_text: original_text,
+      translator: @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)
+
+    # convert untranslated set to strings
+    Translatomatic::Model::Text.where({
+      locale: to,
+      from_texts_texts: {
+        locale_id: from,
+        value: untranslated.collect { |i| i.to_s }
+      }
+    }).joins(:from_text)
+  end
+
+  def db_locale(locale)
+    Translatomatic::Model::Locale.from_tag(locale)
+  end
+end

data/lib/translatomatic/converter_stats.rb

@@ -1,27 +1,27 @@
-# Translation statistics
-class Translatomatic::ConverterStats
-
-  # @return [Number] The total number of strings translated.
-  attr_reader :translations
-
-  # @return [Number] The number of translations that came from the database.
-  attr_reader :from_db
-
-  # @return [Number] The number of translations that came from the translator.
-  attr_reader :from_translator
-
-  def initialize(from_db, from_translator)
-    @translations = from_db + from_translator
-    @from_db = from_db
-    @from_translator = from_translator
-  end
-
-  def +(other)
-    self.class.new(@from_db + other.from_db, @from_translator + other.from_translator)
-  end
-
-  def to_s
-    "Total translations: #{@translations} " +
-      "(#{@from_db} from database, #{@from_translator} from translator)"
-  end
-end
+# Translation statistics
+class Translatomatic::ConverterStats
+
+  # @return [Number] The total number of strings translated.
+  attr_reader :translations
+
+  # @return [Number] The number of translations that came from the database.
+  attr_reader :from_db
+
+  # @return [Number] The number of translations that came from the translator.
+  attr_reader :from_translator
+
+  def initialize(from_db, from_translator)
+    @translations = from_db + from_translator
+    @from_db = from_db
+    @from_translator = from_translator
+  end
+
+  def +(other)
+    self.class.new(@from_db + other.from_db, @from_translator + other.from_translator)
+  end
+
+  def to_s
+    "Total translations: #{@translations} " +
+      "(#{@from_db} from database, #{@from_translator} from translator)"
+  end
+end

data/lib/translatomatic/database.rb

@@ -1,105 +1,145 @@
-require 'active_record'
-
-class Translatomatic::Database
-
-  include Translatomatic::Util
-
-  class << self
-    attr_reader :options
-    private
-    include Translatomatic::DefineOptions
-  end
-
-  def initialize(options = {})
-    db_config_path = db_config_path(options)
-    dbconfig = File.read(db_config_path)
-    dbconfig.gsub!(/\$HOME/, Dir.home)
-    dbconfig.gsub!(/\$GEM_ROOT/, GEM_ROOT)
+require 'active_record'
+
+class Translatomatic::Database
+
+  include Translatomatic::Util
+
+  class << self
+    attr_reader :options
+
+    # @param [Hash<Symbol,Object>] options Database options
+    # @return True if we can connect to the database
+    def enabled?(options = {})
+      new(options).connect
+    end
+
+    private
+
+    include Translatomatic::DefineOptions
+  end
+
+  def initialize(options = {})
     @env = options[:database_env] || DEFAULT_ENV
-    @db_config = YAML::load(dbconfig) || {}
-    @env_config = @db_config
-    raise "no environment '#{@env}' in #{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 [void]
-  def connect
-    ActiveRecord::Base.establish_connection(@env_config)
-  end
+    @db_config = database_config(@env, options)
+    @env_config = @db_config
+    raise "no environment '#{@env}' in #{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 "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 "Database created."
+      true
+    rescue LoadError => e
+      log.debug "Database could not be created: " + e.message
+      false
+    end
+  end
+
+  # Drop the database
+  # @return [void]
+  def drop
+    disconnect
+    ActiveRecord::Tasks::DatabaseTasks.drop(@env_config)
+    log.debug "Database deleted."
+  end
+
+  private
+
+  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, description: "Database config file",
+      default: DEFAULT_CONFIG },
+    { name: :database_env, description: "Database environment",
+      default: DEFAULT_ENV })
 
-  # Disconnect from the database
-  # @return [void]
-  def disconnect
-    ActiveRecord::Base.remove_connection
+  # 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
 
-  # Test if the database exists
-  # @return [Boolean] true if the database exists
-  def exists?
-    begin
-      connect
-      ActiveRecord::Base.connection.tables
-    rescue
-      return false
+  # return database config as a hash
+  def database_config(env, options)
+    if options[:database_config].kind_of?(Hash)
+      return { env => options[:database_config] }
     end
-    true
-  end
-
-  # Run outstanding migrations against the database
-  # @return [void]
-  def migrate
-    connect
-    ActiveRecord::Migrator.migrate(MIGRATIONS_PATH)
-    ActiveRecord::Base.clear_cache!
-    log.debug "Database migrated."
-  end
-
-  # Create the database
-  # @return [void]
-  def create
-    ActiveRecord::Tasks::DatabaseTasks.create(@env_config)
-    log.debug "Database created."
-  end
-
-  # Drop the database
-  # @return [void]
-  def drop
-    disconnect
-    ActiveRecord::Tasks::DatabaseTasks.drop(@env_config)
-    log.debug "Database deleted."
-  end
-
-  private
-
-  DB_PATH = File.join(File.dirname(__FILE__), "..", "..", "db")
-  INTERNAL_DB_CONFIG = File.join(DB_PATH, "database.yml")
-  CUSTOM_DB_CONFIG = File.join(Dir.home, ".translatomatic", "database.yml")
-  DEFAULT_DB_CONFIG = File.exist?(CUSTOM_DB_CONFIG) ? CUSTOM_DB_CONFIG : INTERNAL_DB_CONFIG
-  MIGRATIONS_PATH = File.join(DB_PATH, "migrate")
-  GEM_ROOT = File.join(File.dirname(__FILE__), "..", "..")
-  DEFAULT_ENV = "production"
 
-  define_options(
-    { name: :database_config, description: "Database config file",
-      default: DEFAULT_DB_CONFIG },
-    { name: :database_env, description: "Database environment",
-      default: DEFAULT_ENV })
-
-  def db_config_path(options)
-    if options[:database_env] == "test"
-      INTERNAL_DB_CONFIG  # rspec
-    elsif options[:database_config]
-      return options[:database_config]
-    else
-      DEFAULT_DB_CONFIG
-    end
-  end
-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