translatomatic 0.1.1 → 0.1.2

data/lib/translatomatic/cli/main.rb

@@ -0,0 +1,112 @@
+# Command line interface to translatomatic
+module Translatomatic::CLI
+  # Main command line interface
+  class Main < Base
+
+    begin
+      config = Translatomatic::Config.instance
+      I18n.default_locale = config.default_locale
+    end
+
+    package_name "Translatomatic"
+    map %W[-v --version] => :version
+    map %W[-L --list] => :translators
+
+    desc "translate", t("cli.translate.subcommand")
+    subcommand "translate", Translate
+
+    desc "database", t("cli.database.subcommand")
+    subcommand "database", Database
+
+    desc "config", t("cli.config.subcommand")
+    subcommand "config", Config
+
+    desc "display file [key...]", t("cli.display_values")
+    thor_options(self, Translatomatic::CLI::CommonOptions)
+    method_option :locales, type: :string, desc: t("cli.locales_to_display")
+    method_option :sentences, type: :boolean, desc: t("cli.display_sentences")
+    # Display values from a resource bundle
+    # @param file [String] Path to resource file
+    # @param keys [Array<String>] Optional list of locales
+    # @return [void]
+    def display(file, *keys)
+      run do
+        source = Translatomatic::ResourceFile.load(file)
+        keys = source.properties.keys if keys.empty?
+        display_keys(source, keys)
+
+        # TODO: if locales not specified, determine the list of locales from
+        # all the files in the resource bundle.
+        locales = parse_list(options[:locales])
+        locales << Translatomatic::Locale.default.to_s if locales.empty?
+        locales.each do |tag|
+          locale = locale(tag)
+          next if locale == source.locale
+          display_properties(source, keys, locale)
+        end
+      end
+    end
+
+    desc "strings file [file...]", t("cli.extract_strings")
+    thor_options(self, Translatomatic::CLI::CommonOptions)
+    # Extract strings from non-resource files
+    # @param files [Array<String>] List of paths to files
+    # @return [void]
+    def strings(*files)
+      run do
+        strings = []
+        files.each do |file|
+          extractor = Translatomatic::Extractor::Base.new(file)
+          strings << extractor.extract
+        end
+        puts strings.join("\n")
+      end
+    end
+
+    desc "services", t("cli.list_backends")
+    thor_options(self, Translatomatic::CLI::CommonOptions)
+    # List available translator services
+    # @return [void]
+    def services
+      run { puts Translatomatic::Translator.list }
+    end
+
+    desc 'version', t("cli.display_version")
+    thor_options(self, Translatomatic::CLI::CommonOptions)
+    # Display version number
+    # @return [void]
+    def version
+      puts "Translatomatic v#{Translatomatic::VERSION}"
+    end
+
+    private
+
+    def display_properties(source, keys, locale)
+      path = source.locale_path(locale)
+      if path.exist?
+        resource = Translatomatic::ResourceFile.load(path)
+        display_keys(resource, keys)
+      end
+    end
+
+    def display_keys(source, keys)
+      puts t("cli.file_source", file: source)
+      rows = []
+      keys.each do |key|
+        value = source.get(key)
+        rows << [key + ":", value]
+      end
+      print_table(rows, indent: 2)
+
+      if options[:sentences]
+        puts t("cli.sentences")
+        source.sentences.each do |sentence|
+          puts "- " + sentence.to_s
+        end
+      end
+
+      puts
+    end
+
+  end # class
+end   # module

data/lib/translatomatic/cli/translate.rb

@@ -0,0 +1,146 @@
+# Command line interface to translatomatic
+module Translatomatic::CLI
+  # Translation functions for the command line interface
+  class Translate < Base
+
+    define_options(
+      { name: :translator, type: :array, aliases: "-t",
+        desc: t("converter.translator"), enum: Translatomatic::Translator.names
+      },
+      { name: :source_locale, desc: t("cli.source_locale") },
+      { name: :share, desc: t("cli.share"), default: false },
+      { name: :target_locales, desc: t("cli.target_locales"),
+        type: :array, hidden: true },
+      )
+
+    desc "string text locale...", t("cli.translate.string")
+    thor_options(self, Translatomatic::CLI::CommonOptions)
+    thor_options(self, Translatomatic::CLI::Translate)
+    thor_options(self, Translatomatic::Translator.modules)
+    # Translate a string to target locales
+    # @param text [String] String to translate
+    # @param locales [Array<String>] List of target locales
+    # @return [void]
+    def string(text, *locales)
+      run do
+        setup_translation(locales)
+
+        puts "(%s) %s" % [@source_locale, text]
+        @translators.each do |translator|
+          puts t("cli.using_translator", name: translator.name)
+          @target_locales.each do |target_locale|
+            result = translator.translate([text], @source_locale, target_locale)
+            puts "  -> (%s) %s" % [target_locale, result]
+          end
+          puts
+        end
+
+        finish_log
+      end
+    end
+
+    desc "file filename locale...", t("cli.translate.file")
+    thor_options(self, Translatomatic::CLI::CommonOptions)
+    thor_options(self, Translatomatic::CLI::Translate)
+    thor_options(self, Translatomatic::Converter)
+    thor_options(self, Translatomatic::Database)
+    thor_options(self, Translatomatic::Translator.modules)
+    # Translate files to target locales
+    # @param file [String] Resource file to translate
+    # @param locales [Array<String>] List of target locales
+    # @return [void]
+    def file(file, *locales)
+      run do
+        setup_translation(locales)
+
+        # load source file
+        raise t("cli.file_not_found", file: file) unless File.exist?(file)
+        source = Translatomatic::ResourceFile.load(file, @source_locale)
+        raise t("cli.file_unsupported", file: file) unless source
+
+        # set up database
+        Translatomatic::Database.new(options)
+
+        log.debug(t("cli.locales_properties", locales: locales, properties: source.properties.length))
+
+        # set up converter
+        translation_count = calculate_translation_count(source, @target_locales)
+        converter_options = options.merge(
+          translator: @translators,
+          listener: progress_updater(translation_count)
+        )
+        converter = Translatomatic::Converter.new(converter_options)
+
+        # convert source to locale(s) and write files
+        @target_locales.each do |i|
+          to_locale = locale(i)
+          next if to_locale.language == source.locale.language
+          converter.translate_to_file(source, to_locale)
+        end
+
+        log.info converter.stats
+        finish_log
+
+        share_translations(converter) if cli_option(:share)
+      end
+    end
+
+    private
+
+    def setup_translation(locales)
+      log.info(t("cli.dry_run")) if cli_option(:dry_run)
+
+      @target_locales = parse_list(locales, cli_option(:target_locales))
+      @source_locale = determine_source_locale
+      raise t("cli.locales_required") if @target_locales.empty?
+      conf.logger.level = Logger::DEBUG if cli_option(:debug)
+
+      # resolve translators
+      @translators = Translatomatic::Translator.resolve(
+        cli_option(:translator), options
+      )
+    end
+
+    def determine_source_locale
+      cli_option(:source_locale) || conf.default_locale
+    end
+
+    def calculate_translation_count(source, locales)
+      source.sentences.length * locales.length
+    end
+
+    def share_translations(converter)
+      return if converter.db_translations.empty?
+
+      tmx = Translatomatic::TMX::Document.from_texts(converter.db_translations)
+      available = Translatomatic::Translator.available(options)
+      available.each do |translator|
+        if translator.respond_to?(:upload)
+          log.info(t("cli.uploading_tmx", name: translator.name))
+          translator.upload(tmx)
+        end
+      end
+
+      ActiveRecord::Base.transaction do
+        converter.db_translations.each do |text|
+          text.update(shared: true) if text.is_translated?
+        end
+      end
+    end
+
+    # create a progress bar and progress updater
+    def progress_updater(translation_count)
+      return nil unless cli_option(:wank)
+      # set up progress bar
+      progressbar = ProgressBar.create(
+        title: t("cli.translating"),
+        format: "%t: |%B| %E ",
+        autofinish: false,
+        total: translation_count
+      )
+      conf.logger.progressbar = progressbar
+      Translatomatic::ProgressUpdater.new(progressbar)
+    end
+
+  end # class
+end   # module

data/lib/translatomatic/cli.rb

@@ -1,216 +1,8 @@
-require "thor"
-
-class Translatomatic::CLI < Thor
-  include Translatomatic::Util
-
-  package_name "Translatomatic"
-  map %W[-v --version] => :version
-  map %W[-L --list] => :translators
-
-  desc "translate file locale...", "Translate files to target locales"
-  method_option :translator, enum: Translatomatic::Translator.names
-  method_option :source_locale, desc: "The locale of the source file"
-  method_option :debug, type: :boolean, desc: "Enable debugging output"
-  method_option :wank, type: :boolean, default: true, desc: "Enable Progress bar"
-  method_option :share, type: :boolean, default: false, desc:
-    "Share translations with translators that support upload"
-  Translatomatic::Converter.options.each do |option|
-    method_option option.name, option.to_hash
-  end
-  Translatomatic::Database.options.each do |option|
-    method_option option.name, option.to_hash
-  end
-  Translatomatic::Translator.modules.each do |mod|
-    mod.options.each do |option|
-      method_option option.name, option.to_hash
-    end
-  end
-  def translate(file, *locales)
-    run do
-      log.info("Dry run: files will not be translated or written") if options[:dry_run]
-      raise "One or more locales required" if locales.empty?
-
-      config.logger.level = Logger::DEBUG if options[:debug]
-
-      # load source file
-      raise "File not found: #{file}" unless File.exist?(file)
-      source = Translatomatic::ResourceFile.load(file, options[:source_locale])
-      raise "Unsupported file type #{file}" unless source
-
-      # set up database
-      Translatomatic::Database.new(options)
-
-      # select translator
-      translator = select_translator(options)
-      log.info("Using translator #{translator.name}")
-      log.debug("Locales: #{locales}, Properties: #{source.properties.length}")
-
-      # set up converter
-      translation_count = calculate_translation_count(source, locales)
-      converter_options = options.merge(
-        translator: translator, listener: progress_updater(translation_count)
-      )
-      converter = Translatomatic::Converter.new(converter_options)
-
-      # convert source to locale(s)
-      locales.each { |i| converter.translate(source, i) }
-
-      log.info converter.stats
-      config.logger.finish
-
-      share_translations(converter) if options[:share]
-    end
-  end
-
-  desc "display file [key...]", "Display values from a resource bundle"
-  method_option :locales, type: :string, desc: "Locales to display"
-  method_option :sentences, type: :boolean, desc: "Display sentences"
-  def display(file, *keys)
-    run do
-      source = Translatomatic::ResourceFile.load(file)
-      keys = source.properties.keys if keys.empty?
-      display_keys(source, keys)
-
-      # TODO: if locales not specified, determine the list of locales from
-      # all the files in the resource bundle.
-      locales = (options[:locales] || "").split(',').flatten.compact
-      locales << Translatomatic::Locale.default.to_s if locales.empty?
-      locales.each do |locale|
-        display_properties(source, locale)
-      end
-    end
-  end
-
-  desc "strings file [file...]", "Extract strings from non-resource files"
-  def strings(*files)
-    run do
-      strings = []
-      files.each do |file|
-        extractor = Translatomatic::Extractor::Base.new(file)
-        strings << extractor.extract
-      end
-      puts strings.join("\n")
-    end
-  end
-
-  desc "list", "List available translation backends"
-  def list
-    run { puts Translatomatic::Translator.list }
-  end
-
-  desc 'version', 'Display version'
-  def version
-    puts "Translatomatic version #{Translatomatic::VERSION}"
-  end
-
-  private
-
-  def calculate_translation_count(source, locales)
-    source.sentences.length * locales.length
-  end
-
-  def share_translations(converter)
-    return if converter.db_translations.empty?
-
-    tmx = Translatomatic::TMX::Document.from_texts(converter.db_translations)
-    available = Translatomatic::Translator.available(options)
-    available.each do |translator|
-      if translator.respond_to?(:upload)
-        log.debug("Uploading tmx to #{translator.name}")
-        translator.upload(tmx)
-      end
-    end
-
-    ActiveRecord::Base.transaction do
-      converter.db_translations.each do |text|
-        text.update(shared: true) if text.is_translated?
-      end
-    end
-  end
-
-  # create a progress bar and progress updater
-  def progress_updater(translation_count)
-    return nil unless options[:wank]
-    # set up progress bar
-    progressbar = ProgressBar.create(
-      title: "Translating",
-      format: "%t: |%B| %E ",
-      autofinish: false,
-      total: translation_count
-    )
-    config.logger.progressbar = progressbar
-    Translatomatic::ProgressUpdater.new(progressbar)
-  end
-
-  # run the give code block, display exceptions.
-  # return true if the code ran without exceptions
-  def run
-    begin
-      yield
-      true
-    rescue Interrupt
-      puts "\nAborted"
-      false
-    rescue Exception => e
-      log.error(e.message)
-      log.debug(e.backtrace.join("\n"))
-      false
-    end
-  end
-
-  def display_properties(source, locale)
-    path = source.locale_path(locale)
-    if path.exist?
-      resource = Translatomatic::ResourceFile.load(path)
-      display_keys(resource, keys)
-    end
-  end
-
-  def display_keys(source, keys)
-    puts "File: #{source}"
-    table = []
-    keys.each do |key|
-      value = source.get(key)
-      table << [key + ":", value]
-    end
-    print_table(table, indent: 2)
-
-    if options[:sentences]
-      puts "Sentences:"
-      source.sentences.each do |sentence|
-        puts "- " + sentence.to_s
-      end
-    end
-
-    puts
-  end
-
-  def config
-    Translatomatic::Config.instance
-  end
-
-  def select_translator(options)
-    # use options translator if specified
-    if options[:translator]
-      klass = Translatomatic::Translator.find(options[:translator])
-      return klass.new(options)
-    end
-
-    # find all available translators that work with the given options
-    available = Translatomatic::Translator.available(options)
-    if available.empty?
-      raise "No translators configured. Use the translators command to see options"
-    end
-
-    return available[0] if available.length == 1
-
-    # prompt user for which translator to use
-    say("Multiple translators available:")
-    available.each_with_index { |mod, i| say(" #{i + 1}) #{mod.name}") }
-    loop do
-      idx = ask("Select translator (1-#{available.length}): ")
-      idx = idx.to_i
-      return available[idx - 1] if (1..available.length).include?(idx)
-    end
-  end
-end
+module Translatomatic::CLI; end
+
+require 'translatomatic/cli/common_options'
+require 'translatomatic/cli/base'
+require 'translatomatic/cli/translate'
+require 'translatomatic/cli/database'
+require 'translatomatic/cli/config'
+require 'translatomatic/cli/main'

data/lib/translatomatic/config.rb

@@ -1,12 +1,155 @@
 require 'singleton'
+
+# Translatomatic configuration
 class Translatomatic::Config
   include Singleton
+  include Translatomatic::Util
 
+  # @return [Logger] The logger instance
   attr_accessor :logger
 
+  # @return [String] The default locale
+  attr_accessor :default_locale
+
+  # Change a configuration setting
+  # @param key [String] configuration key
+  # @param value [String] new value for the configuration
+  # @return [String] the new value
+  def set(key, value)
+    key = check_valid_key(key)
+    @settings[key] = value
+    save
+  end
+
+  # Get a configuration setting
+  # @param key [String] configuration key
+  # @return [String] configuration value
+  def get(key)
+    key = check_valid_key(key)
+    option = option(key)
+    env_name = option.name.to_s.upcase
+    if @settings.include?(key)
+      cast(@settings[key], option.type)
+    elsif option.use_env && ENV.include?(env_name)
+      cast(ENV[env_name], option.type)
+    else
+      option.default
+    end
+  end
+
+  # Remove a configuration setting
+  # @param key [String] configuration key to remove
+  # @return [void]
+  def remove(key)
+    key = check_valid_key(key)
+    @settings.delete(key)
+    save
+  end
+
+  # Test if configuration includes the given key
+  # @param key [String] configuration key
+  # @return [boolean] true if the configuration key is set
+  def include?(key)
+    key = check_valid_key(key)
+    @settings.include?(key)
+  end
+
+  # @return [Hash<String,String>] configuration settings
+  def settings
+    @settings.dup
+  end
+
+  # Save configuration settings
+  def save
+    FileUtils.mkdir_p(File.dirname(@settings_path))
+    File.open(@settings_path, "w") { |f| f.puts @settings.to_yaml }
+  end
+
+  # Load configuration from the config file
+  def load
+    @settings = YAML.load_file(@settings_path) if File.exist?(@settings_path)
+    @settings ||= {}
+    @settings.delete_if { |i| !valid_key?(i) }
+    @settings
+  end
+
+  # @return [Array<Translatomatic::Option] all available options
+  def self.options
+    self.config_options.values
+  end
+
   private
 
+  SETTINGS_PATH = File.join(Dir.home, ".translatomatic", "config.yml")
+
+  # @return [Hash<String,Translatomatic::Option>] options
+  def self.config_options
+    @config_options ||= begin
+      # create mapping from option name to option object
+      map = {}
+      sources = [
+        Translatomatic::CLI::CommonOptions,
+        Translatomatic::CLI::Translate,
+        Translatomatic::Translator.modules,
+        Translatomatic::Database,
+        Translatomatic::Converter
+      ]
+      sources.each do |source|
+        source_options = Translatomatic::Option.options_from_object(source)
+        source_options.each do |sopt|
+          optname = sopt.name.to_s
+          raise "#{optname} already defined" if map.include?(optname)
+          map[optname] = sopt
+        end
+      end
+      map
+    end
+  end
+
+  def cast(value, type)
+    case type
+    when :boolean
+      return true if ["true", "t", "yes", "on"].include?(value)
+      return false if ["false", "f", "no", "off"].include?(value)
+      return value ? true : false
+    when :string
+      return value.nil? ? value : value.to_s
+    when :array
+      unless value.nil?
+        value = [value] unless value.kind_of?(Array)
+        value = value.collect { |i| i.split(/[, ]/) }.flatten.compact
+      end
+    end
+    value
+  end
+
+  def option(key)
+    self.class.config_options[key.to_s]
+  end
+
+  def check_valid_key(key)
+    key = key.to_s
+    raise t("config.invalid_key", key: key) unless valid_key?(key)
+    key
+  end
+
+  def valid_key?(key)
+    self.class.config_options.include?(key.to_s)
+  end
+
+  # override settings path, used for testing
+  def settings_path=(path)
+    @settings = {}
+    @settings_path = path
+    load
+  end
+
   def initialize
     @logger = Translatomatic::Logger.new
+    lang = (ENV['LANG'] || '').split(/\./)[0]
+    @default_locale = Translatomatic::Locale.parse(lang).language || "en"
+    @settings_path = SETTINGS_PATH
+    load
   end
+
 end