translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/cli/database.rb

@@ -1,29 +1,91 @@
-module Translatomatic::CLI
-  # Database functions for the command line interface
-  class Database < Base
-
-    desc "search string [locale]", t("cli.database.search")
-    thor_options(self, Translatomatic::CLI::CommonOptions)
-    thor_options(self, Translatomatic::Database)
-    # Search database for the given string
-    # @param string [String] String to search for
-    # @param locale [String] Optional locale, by default search all locales
-    # @return [void]
-    def search(string, locale = nil)
-      Translatomatic::Database.new(options)
-      texts = Translatomatic::Model::Text.where('value LIKE ?', "%#{string}%")
-      if locale
-        db_locale = Translatomatic::Model::Locale.from_tag(locale)
-        texts = texts.where(locale: db_locale)
+module Translatomatic
+  module CLI
+    # Database functions for the command line interface
+    class Database < Base
+      desc 'search string [locale]', t('cli.database.search')
+      thor_options(self, Translatomatic::CLI::CommonOptions)
+      thor_options(self, Translatomatic::Database)
+      # Search database for the given string
+      # @param string [String] String to search for
+      # @param locale [String] Optional locale, by default search all locales
+      # @return [void]
+      def search(string, locale = nil)
+        run do
+          db = Translatomatic::Database.new(options)
+
+          # find all matching texts
+          texts = db.text.where('value LIKE ?', "%#{string}%")
+          if locale
+            db_locale = db.locale.from_tag(locale)
+            texts = texts.where(locale: db_locale)
+          end
+
+          # get all the associated original texts
+          original_texts = texts.where(from_text_id: nil)
+          from_ids = texts.where('from_text_id IS NOT NULL')
+                          .select(:from_text_id).collect(&:from_text_id)
+          original2 = db.text.where('id IN (?)', from_ids)
+          original_texts += original2
+
+          original_texts.uniq.each do |text|
+            value = highlight(text.value, string)
+            puts
+            puts format('id:%<id>d (%<locale>s) %<value>s',
+                        id: text.id, locale: text.locale, value: value)
+            rows = []
+            text.translations.each do |t|
+              rows << ['  -> ', t.provider, "(#{t.locale})",
+                      highlight(t.value, string)]
+            end
+            print_table(rows)
+          end
+        end
       end
-      texts.find_each do |text|
-        puts "(%s) %s" % [text.locale, text.value]
-        text.translations.each do |translation|
-          puts "  -> (%s) %s" % [translation.locale, translation.value]
+
+      desc 'delete text_id', t('cli.database.delete_text')
+      thor_options(self, Translatomatic::CLI::CommonOptions)
+      thor_options(self, Translatomatic::Database)
+      # Delete a text and its translations from the database
+      # @param text_id [Number] id of text to delete
+      # @return [void]
+      def delete(text_id)
+        run do
+          db = Translatomatic::Database.new(options)
+          text = db.text.find(text_id)
+          raise t('cli.database.text_not_found', id: text_id) unless text
+          text.destroy
+        end
+      end
+
+      desc 'drop', t('cli.database.drop')
+      thor_options(self, Translatomatic::CLI::CommonOptions)
+      thor_options(self, Translatomatic::Database)
+      # Drop the database
+      def drop
+        run { Translatomatic::Database.new(options).drop }
+      end
+
+      desc 'info', t('cli.database.info')
+      thor_options(self, Translatomatic::CLI::CommonOptions)
+      thor_options(self, Translatomatic::Database)
+      # Show information about the database
+      def info
+        run do
+          db = Translatomatic::Database.new(options)
+          puts t('cli.database.text_count', count: db.text.count)
+          texts_by_locale = db.text.group(:locale).count
+          texts_by_locale.each do |locale, count|
+            puts format('  (%<locale>s) %<count>d',
+                        locale: locale.to_s, count: count)
+          end
         end
-        puts
       end
-    end
 
+      private
+
+      def highlight(text, highlighted)
+        text.gsub(highlighted) { |i| rainbow.wrap(i).bright.inverse }
+      end
+    end
   end
 end

data/lib/translatomatic/cli/main.rb

@@ -1,125 +1,179 @@
 # Command line interface to translatomatic
-module Translatomatic::CLI
-  # Main command line interface
-  class Main < Base
-
-    default_task :translate
-
-    begin
-      I18n.default_locale = Translatomatic.config.default_locale
-    end
+module Translatomatic
+  module CLI
+    # Main command line interface
+    class Main < Base
+      package_name 'Translatomatic'
+      map %w[-v --version] => :version
+      map %w[-L --list] => :providers
+
+      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 :target_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 = nil, *keys)
+        run do
+          source_files = parse_list(file, conf.get(:source_files))
+          locales = conf.get(:target_locales, for_file: file)
+          source_files.each do |path|
+            raise t('file.not_found', file: path) unless File.exist?(path)
+            source = Translatomatic::ResourceFile.load(path)
+            display_properties(source, keys)
+            locales.each do |locale|
+              path = source.locale_path(locale)
+              next if path == source.path || !path.exist?
+              resource = Translatomatic::ResourceFile.load(path)
+              display_properties(resource, keys)
+            end
+          end
+        end
+      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)
+      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
-    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
+      desc 'convert source target', t('cli.convert')
+      # Convert a resource file from one format to another
+      # @param source [String] An existing resource file
+      # @param target [String] The name of a target resource file
+      # @return [void]
+      def convert(source, target)
+        run do
+          converter = Translatomatic::Converter.new
+          converter.convert(source, target)
         end
-        puts strings.join("\n")
       end
-    end
 
-    desc "convert source target", t("cli.convert")
-    # Convert a resource file from one format to another
-    # @param source [String] An existing resource file
-    # @param target [String] The name of a target resource file
-    # @return [void]
-    def convert(source, target)
-      run do
-        converter = Translatomatic::Converter.new
-        converter.convert(source, target)
+      desc 'providers', t('cli.providers')
+      thor_options(self, Translatomatic::CLI::CommonOptions)
+      # List available translation providers
+      # @return [void]
+      def providers
+        run { display_providers }
       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
 
-    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
 
-    private
+      # @return [String] A description of all providers and options
+      def display_providers
+        puts t('provider.options') + "\n\n"
+        display_provider_options
+        puts
 
-    def display_properties(source, keys, locale)
-      path = source.locale_path(locale)
-      if path.exist?
-        resource = Translatomatic::ResourceFile.load(path)
-        display_keys(resource, keys)
+        puts t('provider.status') + "\n\n"
+        display_provider_status
+        puts
       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]
+      def display_provider_options
+        rows = []
+        Translatomatic::Provider.types.each do |klass|
+          rows += provider_option_rows(klass)
+        end
+        headers = %i[name option description env]
+        heading = headers.collect { |i| t("cli.provider.#{i}") }
+        print_table(add_table_heading(rows, heading), indent: 2)
       end
-      print_table(rows, indent: 2)
 
-      if options[:sentences]
-        puts t("cli.sentences")
-        source.sentences.each do |sentence|
-          puts "- " + sentence.to_s
+      def provider_option_rows(klass)
+        name = klass.name.demodulize
+        opts = klass.options || []
+        opts.collect { |i| provider_option_row(name, i) }
+      end
+
+      def provider_option_row(name, opt)
+        args = []
+        args << name
+        args << '--' + opt.name.to_s.tr('_', '-')
+        args << opt.description
+        args << opt.env_name ? "ENV[#{opt.env_name}]" : ''
+        args
+      end
+
+      def display_provider_status
+        types = Translatomatic::Provider.types
+        available = available_providers
+        rows = types.sort_by { |i| available[i.name] ? 0 : 1 }.map do |klass|
+          provider_status_row(klass, available)
         end
+        headers = %i[name available]
+        heading = headers.collect { |i| t("cli.provider.#{i}") }
+        print_table(add_table_heading(rows, heading), indent: 2)
       end
 
-      puts
-    end
+      def available_providers
+        config_all = Translatomatic.config.all
+        available = {}
+        configured = Translatomatic::Provider.available(config_all)
+        configured.each { |i| available[i.class.name] = true }
+        available
+      end
+
+      def provider_status_row(klass, available)
+        name = klass.name.demodulize
+        avail = available[klass.name] ? 'yes' : 'no'
+        args = []
+        args << name
+        args << t('cli.provider.available_' + avail)
+        args << Translatomatic::Provider.get_error(name)
+        args
+      end
 
-  end # class
-end   # module
+      def display_properties(source, keys)
+        puts t('cli.file_source', file: source)
+        rows = []
+        keys = source.properties.keys if keys.empty?
+        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
+  end
+end

data/lib/translatomatic/cli/thor.rb

@@ -0,0 +1,29 @@
+module Translatomatic
+  module CLI
+    # @private
+    module ThorPatch
+      # disable --no booleans
+      # @private
+      module NoNo
+        def usage(padding = 0)
+          sample = usage_banner
+          sample = "[#{sample}]".dup unless required?
+
+          if aliases.empty?
+            (' ' * padding) << sample
+          else
+            "#{aliases.join(', ')}, #{sample}"
+          end
+        end
+
+        def usage_banner
+          if banner && !banner.to_s.empty?
+            "#{switch_name}=#{banner}".dup
+          else
+            switch_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/translatomatic/cli/translate.rb

@@ -1,181 +1,158 @@
 require 'ruby-progressbar'
 
-# Command line interface to translatomatic
-module Translatomatic::CLI
-  # Translation functions for the command line interface
-  class Translate < Base
-
-    default_task :file
-
-    define_options(
-      { name: :translator, type: :array, aliases: "-t",
-        desc: t("cli.translate.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
-      },
-      { name: :source_files, desc: t("cli.source_files"),
-        type: :array
-      },
-      )
-
-    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, can also be set
-    #   with the --target-locales option
-    # @return [void]
-    def string(text, *locales)
-      run do
-        setup_translation
-        determine_target_locales(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]
+module Translatomatic
+  module CLI
+    # Translation functions for the command line interface
+    class Translate < Base
+      default_task :file
+
+      define_option :provider, type: :array, aliases: '-t',
+                               desc: t('cli.translate.provider'),
+                               enum: Translatomatic::Provider.names
+      define_option :source_locale, desc: t('cli.source_locale')
+      define_option :target_locales, desc: t('cli.target_locales'),
+                                     type: :array
+      define_option :source_files, desc: t('cli.source_files'),
+                                   type: :path_array
+      define_option :share, desc: t('cli.translate.share'), default: false
+
+      desc 'string text locale...', t('cli.translate.string')
+      thor_options(self, Translatomatic::CLI::CommonOptions)
+      thor_options(self, Translatomatic::CLI::Translate)
+      thor_options(self, Translatomatic::Provider.types)
+      # Translate a string to target locales
+      # @param text [String] String to translate
+      # @param locales [Array<String>] List of target locales, can also be set
+      #   with the --target-locales option
+      # @return [void]
+      def string(text, *locales)
+        run do
+          all_conf = conf.all
+          source_locale = conf.get(:source_locale) || Locale.default.to_s
+          target_locales = determine_target_locales(locales)
+          providers = Provider.resolve(conf.get(:provider), all_conf)
+
+          template = '(%<locale>s) %<text>s'
+          puts format(template, locale: source_locale, text: text)
+          providers.each do |provider|
+            puts t('cli.translate.using_provider', name: provider.name)
+            target_locales.each do |l|
+              translations = provider.translate([text], source_locale, l)
+              translations.each do |translation|
+                puts format('  -> ' + template, locale: l, text: translation)
+              end
+            end
+            puts
           end
-          puts
-        end
 
-        finish_log
+          finish_log
+        end
       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::FileTranslator)
-    thor_options(self, Translatomatic::Database)
-    thor_options(self, Translatomatic::Translator.modules)
-    # Translate files to target locales
-    # @param file [String] Resource file to translate, can also be set
-    #   with the --source-files option.
-    # @param locales [Array<String>] List of target locales, can also be set
-    #   with the --target-locales option
-    # @return [void]
-    def file(file = nil, *locales)
-      run do
-        setup_translation
-        determine_target_locales(locales)
-
-        # check source file(s) exist and they can be loaded
-        source_files = parse_list(cli_option(:source_files), file)
-        source_files.each do |source_file|
-          path = source_path(source_file)
-          raise t("file.not_found", file: path) unless File.exist?(path)
-          source = Translatomatic::ResourceFile.load(path, @source_locale)
-          raise t("file.unsupported", file: path) unless source
+      desc 'file filename locale...', t('cli.translate.file')
+      thor_options(self, Translatomatic::CLI::CommonOptions)
+      thor_options(self, Translatomatic::CLI::Translate)
+      thor_options(self, Translatomatic::FileTranslator)
+      thor_options(self, Translatomatic::Database)
+      thor_options(self, Translatomatic::Provider.types)
+      thor_options(self, Translatomatic::ResourceFile.types)
+      # Translate files to target locales
+      # @param file [String] Resource file to translate, can also be set
+      #   with the --source-files option.
+      # @param locales [Array<String>] List of target locales, can also be set
+      #   with the --target-locales option
+      # @return [void]
+      def file(file = nil, *locales)
+        run do
+          # set up database and progress updater
+          Translatomatic::Database.new(conf.all)
+          stats = Translation::Stats.new
+
+          # translate the files
+          source_files = load_source_files(file)
+          listener = progress_updater(source_files, locales)
+          source_files.each do |source|
+            stats += translate_file(source, locales, listener)
+          end
+          log.info stats
+          finish_log
         end
+      end
 
-        # set up database
-        Translatomatic::Database.new(options)
+      private
 
-        # set up file translatiln
-        translation_count = calculate_translation_count(source_files, @target_locales)
-        ft_options = options.merge(
-          translator: @translators,
-          listener: progress_updater(translation_count)
-        )
+      def translate_file(source, locales, listener)
+        file_opts = conf.all(for_file: source.path)
+        target_locales = determine_target_locales(locales, source)
+        ft_options = file_opts.merge(listener: listener)
         ft = Translatomatic::FileTranslator.new(ft_options)
-
-        source_files.each do |path|
-          # read source file
-          source = Translatomatic::ResourceFile.load(path, @source_locale)
-
-          # 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
-            ft.translate_to_file(source, to_locale)
-          end
+        stats = Translation::Stats.new
+
+        target_locales.each do |target_locale|
+          log.info(t('cli.translate.translating_file',
+                     source: source, source_locale: source.locale,
+                     target_locale: target_locale))
+          ft.translate_to_file(source, target_locale)
+          stats += ft.translator.stats
         end
-
-        log.info ft.stats
-        finish_log
-
-        share_translations(ft) if cli_option(:share)
+        stats
       end
-    end
-
-    private
-
-    def setup_translation
-      @source_locale = determine_source_locale
-      # resolve translators
-      @translators = Translatomatic::Translator.resolve(
-        cli_option(:translator), options
-      )
-    end
-
-    def determine_target_locales(locales)
-      @target_locales = parse_list(locales, cli_option(:target_locales))
-      raise t("cli.locales_required") if @target_locales.empty?
-    end
 
-    def determine_source_locale
-      cli_option(:source_locale) || conf.default_locale
-    end
-
-    def calculate_translation_count(source_files, locales)
-      count = 0
-      source_files.each do |file|
-        source = Translatomatic::ResourceFile.load(file, @source_locale)
-        count += source.sentences.length * locales.length
+      # load the source file(s)
+      def load_source_files(file)
+        source_files = []
+        files = parse_list(file, conf.get(:source_files))
+        files.each do |path|
+          raise t('file.not_found', file: path) unless File.exist?(path)
+          source = resource_file(path)
+          raise t('file.unsupported', file: path) unless source
+          source_files << source
+        end
+        source_files
       end
-      count
-    end
 
-    def share_translations(ft)
-      return if ft.db_translations.empty?
+      def resource_file(path)
+        Translatomatic::ResourceFile.load(path, conf.all(for_file: path))
+      end
 
-      tmx = Translatomatic::TMX::Document.from_texts(ft.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
+      # use list given on command line in preference to configuration
+      def determine_target_locales(locales, source = nil)
+        source_path = source ? source.path : nil
+        config_locales = conf.get(:target_locales, for_file: source_path)
+        target_locales = parse_list(locales, config_locales)
+        raise t('cli.locales_required') if target_locales.empty?
+        target_locales
       end
 
-      ActiveRecord::Base.transaction do
-        ft.db_translations.each do |text|
-          text.update(shared: true) if text.is_translated?
+      def total_translations(source_files, locales)
+        total = 0
+        source_files.each do |source|
+          property_values = source.properties.values
+          texts = property_values.collect { |i| build_text(i, source.locale) }
+          providers = resolve_providers(source).length
+          to_locales = determine_target_locales(locales, source).length
+          total += TextCollection.new(texts).count * providers * to_locales
         end
+        total
       end
-    end
 
-    # convert the given path to an absolute path if necessary, relative
-    # to project root.
-    def source_path(path)
-      if path.start_with?("~/")
-        # replace ~/ with home directory
-        path = path.sub(/\A~\//, Dir.home + "/")
+      def resolve_providers(source)
+        Provider.resolve(conf.get(:provider, for_file: source.path), conf.all)
       end
-      File.absolute_path(path, conf.project_path)
-    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)
+      # create a progress bar and progress updater
+      def progress_updater(source_files, locales)
+        return nil if conf.get(:no_wank)
+        # set up progress bar
+        progressbar = ProgressBar.create(
+          title: t('cli.translate.translating'),
+          format: '%t: |%B| %p%% ',
+          autofinish: false,
+          total: total_translations(source_files, locales)
+        )
+        log.progressbar = progressbar if log.respond_to?(:progressbar=)
+        Translatomatic::ProgressUpdater.new(progressbar)
+      end
     end
-
-  end # class
-end   # module
+  end
+end