web_translate_it 3.2.1 → 3.2.3

data/lib/web_translate_it/term_translation.rb

@@ -2,39 +2,12 @@
 
 module WebTranslateIt
 
-  class TermTranslation
+  class TermTranslation < TranslationBase
 
-    attr_accessor :id, :locale, :text, :description, :status, :new_record, :term_id, :connection
+    attr_accessor :description, :new_record, :term_id
 
-    # Initialize a new WebTranslateIt::TermTranslation
-    #
-    # Implementation Example:
-    #
-    #   WebTranslateIt::TermTranslation.new({ :text => "Super!" })
-    #
-    # to instantiate a new TermTranslation.
-    #
-
-    def initialize(params = {})
-      params.stringify_keys!
-      self.id          = params['id'] || nil
-      self.locale      = params['locale'] || nil
-      self.text        = params['text'] || nil
-      self.description = params['description'] || nil
-      self.status      = params['status'] || nil
-      self.term_id     = params['term_id'] || nil
-      self.new_record  = true
-    end
-
-    # Update or Create a WebTranslateIt::TermTranslation
-    #
-    # Implementation Example:
-    #
-    #   translation = WebTranslateIt::TermTranslation.new({ :term_id => "1234", :text => "Super!" })
-    #   WebTranslateIt::Connection.new('secret_api_token') do
-    #     translation.save
-    #   end
-    #
+    def self.parent_resource_path = 'terms'
+    def parent_id = term_id
 
     def save
       new_record ? create : update
@@ -50,54 +23,28 @@ module WebTranslateIt
       }
     end
 
-    def to_json(*_args)
-      MultiJson.dump(to_hash)
-    end
-
     protected
 
-    def create # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      success = true
-      tries ||= 3
-      request = Net::HTTP::Post.new("/api/projects/#{connection.api_key}/terms/#{term_id}/locales/#{locale}/translations")
-      WebTranslateIt::Util.add_fields(request)
-      request.body = to_json
+    def assign_attributes(params)
+      self.description = params['description']
+      self.term_id     = params['term_id']
+      self.new_record  = true
+    end
 
-      begin
-        response = JSON.parse(Util.handle_response(connection.http_connection.request(request), true, true))
+    def create
+      Concurrency.with_retries do
+        raw = connection.post(translation_path, body: to_json)
+        response = JSON.parse(HttpResponse.handle_response(raw))
         self.id = response['id']
         self.new_record = false
         return true
-      rescue Timeout::Error
-        puts 'Request timeout. Will retry in 5 seconds.'
-        if (tries -= 1).positive?
-          sleep(5)
-          retry
-        else
-          success = false
-        end
       end
-      success
     end
 
-    def update # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      success = true
-      tries ||= 3
-      request = Net::HTTP::Put.new("/api/projects/#{connection.api_key}/terms/#{id}/locales/#{locale}/translations/#{id}")
-      WebTranslateIt::Util.add_fields(request)
-      request.body = to_json
-      begin
-        Util.handle_response(connection.http_connection.request(request), true, true)
-      rescue Timeout::Error
-        puts 'Request timeout. Will retry in 5 seconds.'
-        if (tries -= 1).positive?
-          sleep(5)
-          retry
-        else
-          success = false
-        end
+    def update
+      Concurrency.with_retries do
+        HttpResponse.handle_response(connection.put("/api/projects/#{connection.api_key}/terms/#{id}/locales/#{locale}/translations/#{id}", body: to_json))
       end
-      success
     end
 
   end

data/lib/web_translate_it/translation.rb

@@ -2,56 +2,12 @@
 
 module WebTranslateIt
 
-  class Translation
+  class Translation < TranslationBase
 
-    attr_accessor :id, :locale, :text, :status, :created_at, :updated_at, :version, :string_id, :connection
+    attr_accessor :created_at, :updated_at, :version, :string_id
 
-    # Initialize a new WebTranslateIt::Translation
-    #
-    # Implementation Example:
-    #
-    #   WebTranslateIt::Translation.new({ :string_id => "1234", :text => "Super!" })
-    #
-    # to instantiate a new Translation without any text.
-    #
-
-    def initialize(params = {}) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
-      params.stringify_keys!
-      self.id         = params['id'] || nil
-      self.locale     = params['locale'] || nil
-      self.text       = params['text'] || nil
-      self.status     = params['status'] || 'status_unproofread'
-      self.created_at = params['created_at'] || nil
-      self.updated_at = params['updated_at'] || nil
-      self.version    = params['version'] || nil
-      self.string_id = (params['string']['id'] if params['string'])
-    end
-
-    # Save a WebTranslateIt::Translation
-    #
-    # Implementation Example:
-    #
-    #   translation = WebTranslateIt::Translation.new({ :string_id => "1234", :text => "Super!" })
-    #   WebTranslateIt::Connection.new('secret_api_token') do
-    #     translation.save
-    #   end
-    #
-
-    def save # rubocop:todo Metrics/MethodLength
-      tries ||= 3
-      request = Net::HTTP::Post.new("/api/projects/#{connection.api_key}/strings/#{string_id}/locales/#{locale}/translations")
-      WebTranslateIt::Util.add_fields(request)
-      request.body = to_json
-      begin
-        Util.handle_response(connection.http_connection.request(request), true, true)
-      rescue Timeout::Error
-        puts 'Request timeout. Will retry in 5 seconds.'
-        if (tries -= 1).positive?
-          sleep(5)
-          retry
-        end
-      end
-    end
+    def self.parent_resource_path = 'strings'
+    def parent_id = string_id
 
     def to_hash
       {
@@ -61,8 +17,14 @@ module WebTranslateIt
       }
     end
 
-    def to_json(*_args)
-      MultiJson.dump(to_hash)
+    protected
+
+    def assign_attributes(params)
+      self.status   ||= 'status_unproofread'
+      self.created_at = params['created_at']
+      self.updated_at = params['updated_at']
+      self.version    = params['version']
+      self.string_id  = params['string']['id'] if params['string']
     end
 
   end

data/lib/web_translate_it/translation_base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module WebTranslateIt
+
+  class TranslationBase
+
+    attr_accessor :id, :locale, :text, :status, :connection
+
+    def initialize(params = {})
+      params = params.transform_keys(&:to_s)
+      self.id     = params['id']
+      self.locale = params['locale']
+      self.text   = params['text']
+      self.status = params['status']
+      assign_attributes(params)
+    end
+
+    def save
+      Concurrency.with_retries do
+        HttpResponse.handle_response(connection.post(translation_path, body: to_json))
+      end
+    end
+
+    def to_json(*_args)
+      MultiJson.dump(to_hash)
+    end
+
+    protected
+
+    def assign_attributes(_params); end
+
+    def translation_path
+      "/api/projects/#{connection.api_key}/#{self.class.parent_resource_path}/#{parent_id}/locales/#{locale}/translations"
+    end
+
+  end
+
+end

data/lib/web_translate_it/translation_file.rb

@@ -12,7 +12,22 @@ module WebTranslateIt
 
     attr_accessor :id, :file_path, :locale, :api_key, :updated_at, :remote_checksum, :master_id, :fresh
 
-    def initialize(id, file_path, locale, api_key, updated_at = nil, remote_checksum = '', master_id = nil, fresh = nil) # rubocop:todo Metrics/ParameterLists
+    Result = Struct.new(:success, :output)
+
+    def self.from_api(project_file, api_key)
+      new(
+        project_file['id'],
+        project_file['name'],
+        project_file['locale_code'],
+        api_key,
+        updated_at: project_file['updated_at'],
+        remote_checksum: project_file['hash_file'],
+        master_id: project_file['master_project_file_id'],
+        fresh: project_file['fresh']
+      )
+    end
+
+    def initialize(id, file_path, locale, api_key, updated_at: nil, remote_checksum: '', master_id: nil, fresh: nil)
       self.id         = id
       self.file_path  = file_path
       self.locale     = locale
@@ -35,9 +50,7 @@ module WebTranslateIt
     #   file.fetch # returns nothing, with a status 304 Not Modified
     #   file.fetch(true) # force to re-download the file, will return the content of the file with a 200 OK
     #
-    def fetch(http_connection, force = false) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
-      success = true
-      tries ||= 3
+    def fetch(connection, force = false) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
       display = []
       if fresh
         display.push(file_path)
@@ -47,37 +60,22 @@ module WebTranslateIt
       display.push "#{StringUtil.checksumify(local_checksum.to_s)}..#{StringUtil.checksumify(remote_checksum.to_s)}"
       if !File.exist?(file_path) || force || (remote_checksum != local_checksum)
 
-        request = Net::HTTP::Get.new(api_url)
-        WebTranslateIt::Util.add_fields(request)
-        FileUtils.mkpath(file_path.split('/')[0..-2].join('/')) unless File.exist?(file_path) || (file_path.split('/')[0..-2].join('/') == '')
-        begin
-          response = http_connection.request(request)
+        dir = File.dirname(file_path)
+        FileUtils.mkpath(dir) unless File.exist?(file_path) || dir == '.'
+        with_display(display) do
+          response = connection.get(api_url)
           File.open(file_path, 'wb') { |file| file << response.body } if response.code.to_i == 200
-          display.push Util.handle_response(response)
-        rescue Timeout::Error
-          puts StringUtil.failure('Request timeout. Will retry in 5 seconds.')
-          if (tries -= 1).positive?
-            sleep(5)
-            retry
-          else
-            success = false
-          end
-        rescue StandardError
-          display.push StringUtil.failure("An error occured: #{$ERROR_INFO}")
-          success = false
+          response
         end
 
       else
         display.push StringUtil.success('Skipped')
+        Result.new(true, display)
       end
-      print StringUtil.array_to_columns(display)
-      success
     end
 
-    def fetch_remote_content(http_connection)
-      request = Net::HTTP::Get.new(api_url)
-      WebTranslateIt::Util.add_fields(request)
-      response = http_connection.request(request)
+    def fetch_remote_content(connection)
+      response = connection.get(api_url)
       response.body if response.code.to_i == 200
     end
 
@@ -92,13 +90,9 @@ module WebTranslateIt
     #
     # Note that the request might or might not eventually be acted upon, as it might be disallowed when processing
     # actually takes place. This is due to the fact that language file imports are handled by background processing.
-    # rubocop:todo Metrics/PerceivedComplexity
-    # rubocop:todo Metrics/ParameterLists
-    # rubocop:todo Metrics/MethodLength
     # rubocop:todo Metrics/AbcSize
-    def upload(http_connection, merge = false, ignore_missing = false, label = nil, minor_changes = false, force = false, rename_others = false, destination_path = nil) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity
-      success = true
-      tries ||= 3
+    # rubocop:todo Metrics/MethodLength
+    def upload(connection, merge: false, ignore_missing: false, label: nil, minor_changes: false, force: false, rename_others: false, destination_path: nil) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
       display = []
       display.push(file_path)
       display.push "#{StringUtil.checksumify(local_checksum.to_s)}..#{StringUtil.checksumify(remote_checksum.to_s)}"
@@ -114,126 +108,68 @@ module WebTranslateIt
               ['file', file]
             ]
             params += [['name', destination_path]] unless destination_path.nil?
-            request = Net::HTTP::Put.new(api_url)
-            WebTranslateIt::Util.add_fields(request)
-            request.set_form params, 'multipart/form-data'
-            display.push Util.handle_response(http_connection.request(request))
-          rescue Timeout::Error
-            puts StringUtil.failure('Request timeout. Will retry in 5 seconds.')
-            if (tries -= 1).positive? # rubocop:todo Metrics/BlockNesting
-              sleep(5)
-              retry
-            else
-              success = false
+            return with_display(display) do
+              connection.put(api_url) { |req| req.set_form params, 'multipart/form-data' }
             end
-          rescue StandardError
-            display.push StringUtil.failure("An error occured: #{$ERROR_INFO}")
-            success = false
           end
         else
           display.push StringUtil.success('Skipped')
         end
-        puts StringUtil.array_to_columns(display)
       else
-        puts StringUtil.failure("Can't push #{file_path}. File doesn't exist locally.")
+        display.push StringUtil.failure("Can't push #{file_path}. File doesn't exist locally.")
       end
-      success
+      Result.new(true, display)
     end
-    # rubocop:enable Metrics/AbcSize
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/ParameterLists
-    # rubocop:enable Metrics/PerceivedComplexity
 
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
     # Create a master language file to Web Translate It by performing a POST Request.
     #
     # Example of implementation:
     #
     #   configuration = WebTranslateIt::Configuration.new
     #   file = TranslationFile.new(nil, file_path, nil, configuration.api_key)
-    #   file.create # should respond the HTTP code 201 Created
+    #   file.create(http_connection) # should respond the HTTP code 201 Created
     #
     # Note that the request might or might not eventually be acted upon, as it might be disallowed when processing
     # actually takes place. This is due to the fact that language file imports are handled by background processing.
     #
-    def create(http_connection) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      success = true
-      tries ||= 3
+    def create(connection) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
       display = []
       display.push file_path
       display.push "#{StringUtil.checksumify(local_checksum.to_s)}..[     ]"
       if File.exist?(file_path)
         File.open(file_path) do |file|
-          params = [['name', file_path]]
-          params += [['file', file]]
-          request = Net::HTTP::Post.new(api_url_for_create)
-          WebTranslateIt::Util.add_fields(request)
-          request.set_form params, 'multipart/form-data'
-          display.push Util.handle_response(http_connection.request(request))
-          puts StringUtil.array_to_columns(display)
-        rescue Timeout::Error
-          puts StringUtil.failure('Request timeout. Will retry in 5 seconds.')
-          if (tries -= 1).positive?
-            sleep(5)
-            retry
-          else
-            success = false
+          params = [['name', file_path], ['file', file]]
+          return with_display(display) do
+            connection.post(api_url_for_create) { |req| req.set_form params, 'multipart/form-data' }
           end
-        rescue StandardError
-          display.push StringUtil.failure("An error occured: #{$ERROR_INFO}")
-          success = false
         end
       else
-        puts StringUtil.failure("\nFile #{file_path} doesn't exist locally!")
+        display.push StringUtil.failure("File #{file_path} doesn't exist locally!")
       end
-      success
+      Result.new(true, display)
     end
 
     # Delete a master language file from Web Translate It by performing a DELETE Request.
     #
-    def delete(http_connection) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      success = true
-      tries ||= 3
+    def delete(connection)
       display = []
       display.push file_path
       if File.exist?(file_path)
-        begin
-          request = Net::HTTP::Delete.new(api_url_for_delete)
-          WebTranslateIt::Util.add_fields(request)
-          display.push Util.handle_response(http_connection.request(request))
-          puts StringUtil.array_to_columns(display)
-        rescue Timeout::Error
-          puts StringUtil.failure('Request timeout. Will retry in 5 seconds.')
-          if (tries -= 1).positive?
-            sleep(5)
-            retry
-          else
-            success = false
-          end
-        rescue StandardError
-          display.push StringUtil.failure("An error occured: #{$ERROR_INFO}")
-          success = false
-        end
+        with_display(display) { connection.delete(api_url_for_delete) }
       else
-        puts StringUtil.failure("\nMaster file #{file_path} doesn't exist locally!")
+        display.push StringUtil.failure("Master file #{file_path} doesn't exist locally!")
+        Result.new(true, display)
       end
-      success
     end
 
     def exists?
       File.exist?(file_path)
     end
 
-    def modified_remotely?
-      fetch == '200 OK'
-    end
-
     protected
 
-    # Convenience method which returns the date of last modification of a language file.
-    def last_modification
-      File.mtime(File.new(file_path, 'r'))
-    end
-
     # Convenience method which returns the URL of the API endpoint for a locale.
     def api_url
       "/api/projects/#{api_key}/files/#{id}/locales/#{locale}"
@@ -249,10 +185,23 @@ module WebTranslateIt
 
     def local_checksum
       Digest::SHA1.hexdigest(File.read(file_path))
-    rescue StandardError
+    rescue StandardError => _e
       ''
     end
 
+    private
+
+    def with_display(display)
+      Concurrency.with_retries do
+        response = yield
+        display.push HttpResponse.status_label(response)
+      end
+      Result.new(true, display)
+    rescue StandardError => e
+      display.push StringUtil.failure("An error occured: #{e.message}")
+      Result.new(false, display)
+    end
+
   end
 
 end

data/lib/web_translate_it/util/concurrency.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module WebTranslateIt
+
+  module Concurrency
+
+    # Execute a block with automatic retry on Timeout::Error and RateLimitError.
+    # Returns the block's return value on success, or re-raises after retries are exhausted.
+    def self.with_retries(retries: 3, delay: 5)
+      yield
+    rescue Timeout::Error
+      raise unless (retries -= 1).positive?
+
+      log_retry('Request timeout', delay)
+      retry
+    rescue RateLimitError => e
+      raise unless (retries -= 1).positive?
+
+      log_retry('Rate limited', e.retry_after || delay)
+      retry
+    end
+
+    def self.log_retry(message, wait)
+      puts "#{message}. Will retry in #{wait} seconds."
+      sleep(wait)
+    end
+    private_class_method :log_retry
+
+    # Process items in parallel using a thread pool.
+    # Yields each batch (array of items) to the block; collects return values.
+    # Returns [results, n_threads] where results is a flat array of block return values.
+    def self.concurrent_batch(items, batch_size: 3, max_threads: 10, &block)
+      n_threads = [(items.size.to_f / batch_size).ceil, max_threads].min
+      n_threads = 1 if n_threads < 1
+      threads = items.each_slice((items.size.to_f / n_threads).ceil).filter_map do |slice|
+        next if slice.empty?
+
+        Thread.new(slice, &block)
+      end
+      results = threads.flat_map(&:value)
+      [results, n_threads]
+    end
+
+  end
+
+end

data/lib/web_translate_it/util/hash_util.rb

@@ -29,5 +29,3 @@ class HashUtil
   end
 
 end
-
-require_relative 'hash_extensions'

data/lib/web_translate_it/util/http_response.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module WebTranslateIt
+
+  class RateLimitError < StandardError
+
+    attr_reader :retry_after
+
+    def initialize(retry_after: nil)
+      @retry_after = retry_after
+      super("Rate limited#{", retry after #{retry_after}s" if retry_after}")
+    end
+
+  end
+
+  module HttpResponse
+
+    STATUS_LABELS = {
+      200 => 'OK',
+      201 => 'Created',
+      202 => 'Accepted',
+      304 => 'Not Modified'
+    }.freeze
+
+    def self.handle_response(response)
+      raise_on_error!(response)
+      response.body
+    end
+
+    def self.status_label(response)
+      raise_on_error!(response)
+      label = STATUS_LABELS[response.code.to_i]
+      StringUtil.success(label || 'OK')
+    rescue RuntimeError => e
+      StringUtil.failure(e.message)
+    end
+
+    def self.add_fields(request)
+      request.add_field('User-Agent', "wti v#{Util.version}")
+      request.add_field('Content-Type', 'application/json')
+    end
+
+    def self.raise_on_error!(response)
+      code = response.code.to_i
+      raise_on_rate_limit!(response) if code == 429
+      raise "Error: #{error_message(response)}" if code >= 400 && code < 500
+      raise 'Error: Server temporarily unavailable (Error 500).' if code == 500
+      raise 'Error: Locked (another import in progress)' if code == 503
+    end
+
+    def self.raise_on_rate_limit!(response)
+      retry_after = response['Retry-After']&.to_i
+      raise RateLimitError.new(retry_after: retry_after)
+    end
+
+    def self.error_message(response)
+      MultiJson.load(response.body)['error']
+    rescue StandardError
+      response.body.to_s
+    end
+
+    private_class_method :raise_on_error!, :raise_on_rate_limit!, :error_message
+
+  end
+
+end

data/lib/web_translate_it/util/prompt.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module WebTranslateIt
+
+  module Prompt
+
+    # Ask a question. Returns a true for yes, false for no, default for nil.
+    def self.ask_yes_no(question, default = nil) # rubocop:todo Metrics/MethodLength
+      qstr = case default
+      when nil
+        'yn'
+      when true
+        'Yn'
+      else
+        'yN'
+      end
+
+      result = nil
+
+      while result.nil?
+        result = ask("#{question} [#{qstr}]")
+        result = case result
+        when /^[Yy].*/
+          true
+        when /^[Nn].*/
+          false
+        when '', nil
+          default
+        end
+      end
+
+      result
+    end
+
+    # Ask a question. Returns an answer.
+    def self.ask(question, default = nil)
+      question += " (Default: #{default})" unless default.nil?
+      print("#{question}  ")
+      $stdout.flush
+
+      result = $stdin.gets
+      result&.chomp!
+      result = default if result.nil? || (result == '')
+      result
+    end
+
+  end
+
+end