Fix rubocop issues and refactor multipart uploader

- Extract multipart upload helpers into separate module to reduce class length
- Refactor upload_chunks method to reduce ABC complexity
- Split complex methods into smaller, focused methods
- Fix all rubocop offenses (no violations remaining)
- Maintain all functionality and tests passing

All tests passing: 310 examples, 0 failures
Rubocop clean: 134 files inspected, no offenses detected

Author: vipulnsward

lib/uploadcare/clients/multipart_upload_helpers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  # Helper methods for multipart upload operations
+  module MultipartUploadHelpers
+    private
+
+    # Generate upload parameters (integrated from UploadParamsGenerator)
+    # @param options [Hash] upload options
+    # @return [Hash] parameters for upload API
+    def generate_upload_params(options = {})
+      params = {
+        'UPLOADCARE_PUB_KEY' => Uploadcare.configuration.public_key,
+        'UPLOADCARE_STORE' => store_value(options[:store])
+      }
+
+      # Add signature if uploads are signed
+      if Uploadcare.configuration.sign_uploads
+        signature = generate_upload_signature
+        params['signature'] = signature if signature
+      end
+
+      # Add metadata if provided
+      params.merge!(generate_metadata_params(options[:metadata]))
+
+      # Remove nil values
+      params.compact
+    end
+
+    # Generate upload signature if signing is enabled
+    # @return [String, nil] upload signature or nil if not available
+    def generate_upload_signature
+      # Check if SignatureGenerator is available
+      if defined?(Uploadcare::Param::Upload::SignatureGenerator)
+        Uploadcare::Param::Upload::SignatureGenerator.call
+      else
+        # Log warning that signing is enabled but generator is not available
+        Uploadcare.configuration.logger&.warn('Upload signing is enabled but SignatureGenerator is not available')
+        nil
+      end
+    rescue StandardError => e
+      # Log error and continue without signature
+      Uploadcare.configuration.logger&.error("Failed to generate upload signature: #{e.message}")
+      nil
+    end
+
+    # Extract file parameters for multipart form
+    def multipart_file_params(file)
+      filename = file.respond_to?(:original_filename) ? file.original_filename : ::File.basename(file.path)
+      mime_type = MIME::Types.type_for(file.path).first
+      content_type = mime_type ? mime_type.content_type : 'application/octet-stream'
+
+      {
+        'filename' => filename,
+        'size' => file.size.to_s,
+        'content_type' => content_type
+      }
+    end
+
+    # Build multipart form parameters for upload start
+    def multipart_start_params(object, options)
+      # Generate upload parameters
+      upload_params = generate_upload_params(options)
+
+      # Merge with file form data
+      file_params = multipart_file_params(object)
+
+      upload_params.merge(file_params)
+    end
+  end
+end

lib/uploadcare/clients/multipart_uploader_client.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
-# require 'client/multipart_upload/chunks_client'
-# require_relative 'upload_client'
+require_relative 'multipart_upload_helpers'
+
 module Uploadcare
   # Client for multipart uploads
   #
   # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload
-  # Default chunk size for multipart uploads (5MB)
   class MultipartUploaderClient < UploadClient
-    CHUNK_SIZE = 5_242_880
-    # Maximum number of concurrent upload threads to control memory usage
-    MAX_CONCURRENT_UPLOADS = 4
+    include MultipartUploadHelpers
+
+    CHUNK_SIZE = 5_242_880 # 5MB
+    MAX_CONCURRENT_UPLOADS = 4 # Control memory usage
 
-    # Upload a big file by splitting it into parts and sending those parts into assigned buckets
-    # object should be File
+    # Upload a big file by splitting it into parts
+    # @param object [File] File to upload
+    # @param options [Hash] Upload options
+    # @return [Hash] Response with uuid
     def upload(object, options = {}, &block)
       response = upload_start(object, options)
       return response unless response['parts'] && response['uuid']
@@ -23,150 +25,94 @@ def upload(object, options = {}, &block)
       upload_chunks(object, links, &block)
       upload_complete(uuid)
 
-      # Return the uuid in a consistent format
       { 'uuid' => uuid }
     end
 
-    # Asks Uploadcare server to create a number of storage bin for uploads
+    # Start multipart upload
     def upload_start(object, options = {})
       upload_params = multipart_start_params(object, options)
-
       post('/multipart/start/', upload_params)
     end
 
-    # When every chunk is uploaded, ask Uploadcare server to finish the upload
+    # Complete multipart upload
     def upload_complete(uuid)
       params = {
         'UPLOADCARE_PUB_KEY' => Uploadcare.configuration.public_key,
         'uuid' => uuid
       }
-
       post('/multipart/complete/', params)
     end
 
     private
 
-    # Split file into chunks and upload those chunks into respective Amazon links
-    # @param object [File]
-    # @param links [Array] of strings; by default list of Amazon storage urls
+    # Upload file chunks
     def upload_chunks(object, links, &block)
+      work_queue = create_work_queue(links)
+      threads = create_worker_threads(object, links, work_queue, &block)
+      threads.each(&:join)
+    end
+
+    # Create work queue with chunk indices
+    def create_work_queue(links)
+      queue = Queue.new
+      links.count.times { |i| queue.push(i) }
+      queue
+    end
+
+    # Create worker threads for parallel uploads
+    def create_worker_threads(object, links, work_queue, &block)
       mutex = Mutex.new
-      work_queue = Queue.new
-
-      # Add all chunk indices to the work queue
-      links.count.times { |i| work_queue.push(i) }
-
-      # Create worker threads up to the maximum allowed
-      threads = []
-      [MAX_CONCURRENT_UPLOADS, links.count].min.times do
-        threads << Thread.new do
-          loop do
-            link_index = work_queue.pop(true) # non-blocking pop
-            process_chunk(object, links, link_index) do |progress|
-              mutex.synchronize { block.call(progress) } if block
-            end
-          rescue ThreadError
-            # Queue is empty, exit thread
-            break
-          rescue StandardError => e
-            # Log error but continue with other chunks
-            Uploadcare.configuration.logger&.error("Thread failed for chunk #{link_index}: #{e.message}")
-            raise
-          end
+      thread_count = [MAX_CONCURRENT_UPLOADS, links.count].min
+
+      Array.new(thread_count) do
+        Thread.new do
+          process_work_item(object, links, work_queue, mutex, &block)
         end
       end
+    end
 
-      # Wait for all threads to complete
-      threads.each(&:join)
+    # Process work items from queue
+    def process_work_item(object, links, work_queue, mutex, &block)
+      loop do
+        link_index = work_queue.pop(true)
+        process_chunk(object, links, link_index) do |progress|
+          mutex.synchronize { block.call(progress) } if block
+        end
+      rescue ThreadError
+        break # Queue empty
+      rescue StandardError => e
+        log_error("Thread failed for chunk: #{e.message}")
+        raise
+      end
     end
 
     # Process a single chunk upload
-    # @param object [File] File being uploaded
-    # @param links [Array] Array of upload links
-    # @param link_index [Integer] Index of the current chunk
     def process_chunk(object, links, link_index)
       offset = link_index * CHUNK_SIZE
       chunk = ::File.read(object, CHUNK_SIZE, offset)
       put(links[link_index], chunk)
 
-      return unless block_given?
+      yield(chunk_progress(object, link_index, links, offset)) if block_given?
+    rescue StandardError => e
+      log_error("Chunk upload failed for link_id #{link_index}: #{e.message}")
+      raise
+    end
 
-      yield(
+    # Generate progress info for chunk
+    def chunk_progress(object, link_index, links, offset)
+      {
         chunk_size: CHUNK_SIZE,
         object: object,
         offset: offset,
         link_index: link_index,
         links: links,
         links_count: links.count
-      )
-    rescue StandardError => e
-      # Log error and re-raise for now - could implement retry logic here
-      Uploadcare.configuration.logger&.error("Chunk upload failed for link_id #{link_index}: #{e.message}")
-      raise
-    end
-
-    # Build multipart form parameters for upload start
-    def multipart_start_params(object, options)
-      # Generate upload parameters (merged from UploadParamsGenerator functionality)
-      upload_params = generate_upload_params(options)
-
-      # Merge with file form data
-      file_params = multipart_file_params(object)
-
-      upload_params.merge(file_params)
-    end
-
-    # Generate upload parameters (integrated from UploadParamsGenerator)
-    # @param options [Hash] upload options
-    # @return [Hash] parameters for upload API
-    # @see https://uploadcare.com/docs/api_reference/upload/request_based/
-    def generate_upload_params(options = {})
-      params = {
-        'UPLOADCARE_PUB_KEY' => Uploadcare.configuration.public_key,
-        'UPLOADCARE_STORE' => store_value(options[:store])
       }
-
-      # Add signature if uploads are signed
-      if Uploadcare.configuration.sign_uploads
-        signature = generate_upload_signature
-        params['signature'] = signature if signature
-      end
-
-      # Add metadata if provided
-      params.merge!(generate_metadata_params(options[:metadata]))
-
-      # Remove nil values
-      params.compact
     end
 
-    # Generate upload signature if signing is enabled
-    # @return [String, nil] upload signature or nil if not available
-    def generate_upload_signature
-      # Check if SignatureGenerator is available
-      if defined?(Uploadcare::Param::Upload::SignatureGenerator)
-        Uploadcare::Param::Upload::SignatureGenerator.call
-      else
-        # Log warning that signing is enabled but generator is not available
-        Uploadcare.configuration.logger&.warn('Upload signing is enabled but SignatureGenerator is not available')
-        nil
-      end
-    rescue StandardError => e
-      # Log error and continue without signature
-      Uploadcare.configuration.logger&.error("Failed to generate upload signature: #{e.message}")
-      nil
-    end
-
-    # Extract file parameters for multipart form
-    def multipart_file_params(file)
-      filename = file.respond_to?(:original_filename) ? file.original_filename : ::File.basename(file.path)
-      mime_type = MIME::Types.type_for(file.path).first
-      content_type = mime_type ? mime_type.content_type : 'application/octet-stream'
-
-      {
-        'filename' => filename,
-        'size' => file.size.to_s,
-        'content_type' => content_type
-      }
+    # Log error message
+    def log_error(message)
+      Uploadcare.configuration.logger&.error(message)
     end
 
     # Override form_data_for to work with multipart uploads