Fix RuboCop offenses in VCR scrubber and parallel upload

CI was failing because RuboCop runs as part of rake.

- Refactor RestClient signature body computation to reduce complexity
- Extract parallel upload worker to satisfy Metrics/BlockLength
- Clean up VCR scrubber regexes and multi-account spec naming

Author: vipulnsward

lib/uploadcare/clients/rest_client.rb

@@ -144,25 +144,21 @@ def build_request_uri(path, params, method)
   end
 
   def prepare_headers(req, method, uri, params, headers)
-    # For authentication, we need to know the body content for signature generation
-    body_content = if method == HTTP_GET
-                     ''
-                   else
-                     if params.nil? || (params.respond_to?(:empty?) && params.empty?)
-                       ''
-                     elsif params.is_a?(String)
-                       params
-                     else
-                       params.to_json
-                     end
-                   end
-
+    body_content = body_content_for_signature(method, params)
     content_type = headers['Content-Type'] || authenticator.default_headers['Content-Type']
     auth_headers = authenticator.headers(method, uri, body_content, content_type)
     req.headers.merge!(auth_headers)
     req.headers.merge!(headers)
   end
 
+  def body_content_for_signature(method, params)
+    return '' if method == HTTP_GET
+    return '' if params.nil? || (params.respond_to?(:empty?) && params.empty?)
+    return params if params.is_a?(String)
+
+    params.to_json
+  end
+
   def prepare_body_or_params(req, method, params)
     if method == HTTP_GET
       req.params.update(params) unless params.nil? || params.empty?

lib/uploadcare/clients/upload_client.rb

@@ -621,7 +621,7 @@ def upload_parts_sequential(file, presigned_urls, part_size, &block)
   # @api private
   def upload_parts_parallel(file, presigned_urls, part_size, threads, &block)
     total_size = file.respond_to?(:size) ? file.size : ::File.size(file.path)
-    uploaded = 0
+    uploaded = { value: 0 }
     mutex = Mutex.new
     queue = Queue.new
 
@@ -630,47 +630,52 @@ def upload_parts_parallel(file, presigned_urls, part_size, threads, &block)
 
     errors = []
     file_path = file.path
+    total_parts = presigned_urls.length
 
     workers = threads.times.map do
       Thread.new do
-        worker_file = ::File.open(file_path, 'rb')
-        begin
-          loop do
-            job = begin
-              queue.pop
-            rescue ThreadError
-              break
-            end
-            break if job.nil?
-
-            presigned_url, index = job
-            offset = index * part_size
-            break if offset >= total_size
-
-            worker_file.seek(offset)
-            part_data = worker_file.read(part_size)
-            break if part_data.nil? || part_data.empty?
-
-            Uploadcare::Result.unwrap(multipart_upload_part(presigned_url: presigned_url, part_data: part_data))
-
-            mutex.synchronize do
-              uploaded += part_data.bytesize
-              block&.call({ uploaded: uploaded, total: total_size, part: index + 1,
-                            total_parts: presigned_urls.length })
-            end
-          end
-        rescue StandardError => e
-          mutex.synchronize { errors << e }
-        ensure
-          worker_file.close
-        end
+        run_parallel_worker(queue, file_path, part_size, total_size, total_parts, mutex, uploaded, errors, &block)
       end
     end
 
     workers.each(&:join)
     raise errors.first if errors.any?
   end
 
+  def run_parallel_worker(queue, file_path, part_size, total_size, total_parts, mutex, uploaded, errors, &block)
+    worker_file = ::File.open(file_path, 'rb')
+    begin
+      loop do
+        job = begin
+          queue.pop
+        rescue ThreadError
+          break
+        end
+        break if job.nil?
+
+        presigned_url, index = job
+        offset = index * part_size
+        break if offset >= total_size
+
+        worker_file.seek(offset)
+        part_data = worker_file.read(part_size)
+        break if part_data.nil? || part_data.empty?
+
+        Uploadcare::Result.unwrap(multipart_upload_part(presigned_url: presigned_url, part_data: part_data))
+
+        mutex.synchronize do
+          uploaded[:value] += part_data.bytesize
+          block&.call({ uploaded: uploaded[:value], total: total_size, part: index + 1,
+                        total_parts: total_parts })
+        end
+      end
+    rescue StandardError => e
+      mutex.synchronize { errors << e }
+    ensure
+      worker_file.close
+    end
+  end
+
   def success_response?(response)
     response.status >= 200 && response.status < 300
   end

spec/support/vcr.rb

@@ -20,23 +20,25 @@
     end
 
     if (auth = i.request.headers['Authorization']&.first)
-      auth = auth.gsub(/\AUploadcare\\.Simple\\s+[^:\\s]+:[^\\s]+\\z/, 'Uploadcare.Simple <uploadcare_public_key>:<uploadcare_secret_key>')
-      auth = auth.gsub(/\AUploadcare\\s+[^:\\s]+:[^\\s]+\\z/, 'Uploadcare <uploadcare_public_key>:<uploadcare_rest_signature>')
+      auth = auth.gsub(/\AUploadcare\.Simple\s+[^:\s]+:[^\s]+\z/,
+                       'Uploadcare.Simple <uploadcare_public_key>:<uploadcare_secret_key>')
+      auth = auth.gsub(/\AUploadcare\s+[^:\s]+:[^\s]+\z/,
+                       'Uploadcare <uploadcare_public_key>:<uploadcare_rest_signature>')
       i.request.headers['Authorization'] = [auth]
     end
 
-    if i.request.uri
-      i.request.uri = i.request.uri.gsub(/([?&]token=)[^&]+/, '\\1<uploadcare_upload_token>')
-    end
+    i.request.uri = i.request.uri.gsub(/([?&]token=)[^&]+/, '\1<uploadcare_upload_token>') if i.request.uri
 
     if i.request.body
-      i.request.body = i.request.body.gsub(/(\"token\"\\s*:\\s*\")[^\"]+(\"\\s*(?:\\x7D|\\x5D))/, '\\1<uploadcare_upload_token>\\2')
-      i.request.body = i.request.body.gsub(/(name=\"signature\"\\r\\n\\r\\n)[^\\r\\n]+/, '\\1<uploadcare_signature>')
-      i.request.body = i.request.body.gsub(/(name=\"expire\"\\r\\n\\r\\n)[^\\r\\n]+/, '\\1<uploadcare_expire>')
+      i.request.body = i.request.body.gsub(/("token"\s*:\s*")[^"]+("\s*(?:\x7D|\x5D))/,
+                                           '\1<uploadcare_upload_token>\2')
+      i.request.body = i.request.body.gsub(/(name="signature"\r\n\r\n)[^\r\n]+/, '\1<uploadcare_signature>')
+      i.request.body = i.request.body.gsub(/(name="expire"\r\n\r\n)[^\r\n]+/, '\1<uploadcare_expire>')
     end
 
     if i.response.body.is_a?(String)
-      i.response.body = i.response.body.gsub(/(\"token\"\\s*:\\s*\")[^\"]+(\"\\s*(?:\\x7D|\\x5D))/, '\\1<uploadcare_upload_token>\\2')
+      i.response.body = i.response.body.gsub(/("token"\s*:\s*")[^"]+("\s*(?:\x7D|\x5D))/,
+                                             '\1<uploadcare_upload_token>\2')
     end
   end
   config.configure_rspec_metadata!

spec/uploadcare/multi_account_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe 'Multi-account configuration' do
-  let(:config1) do
+  let(:account_one_config) do
     Uploadcare::Configuration.new(
       public_key: 'public_key1',
       secret_key: 'secret_key1',
@@ -12,7 +12,7 @@
     )
   end
 
-  let(:config2) do
+  let(:account_two_config) do
     Uploadcare::Configuration.new(
       public_key: 'public_key2',
       secret_key: 'secret_key2',
@@ -22,38 +22,38 @@
   end
 
   it 'generates different CDN bases per Configuration instance' do
-    base1 = config1.cdn_base.call
-    base2 = config2.cdn_base.call
+    base1 = account_one_config.cdn_base.call
+    base2 = account_two_config.cdn_base.call
 
     expect(base1).not_to eq(base2)
     expect(base1).to match(%r{\Ahttps://[0-9a-z]{10}\.ucarecd\.net/\z})
     expect(base2).to match(%r{\Ahttps://[0-9a-z]{10}\.ucarecd\.net/\z})
   end
 
   it 'uses the instance config when building resource CDN URLs' do
-    file1 = Uploadcare::File.new({ uuid: 'uuid-1' }, config1)
-    file2 = Uploadcare::File.new({ uuid: 'uuid-2' }, config2)
+    file1 = Uploadcare::File.new({ uuid: 'uuid-1' }, account_one_config)
+    file2 = Uploadcare::File.new({ uuid: 'uuid-2' }, account_two_config)
 
-    expect(file1.cdn_url).to start_with(config1.cdn_base.call)
-    expect(file2.cdn_url).to start_with(config2.cdn_base.call)
-    expect(file1.cdn_url).not_to start_with(config2.cdn_base.call)
-    expect(file2.cdn_url).not_to start_with(config1.cdn_base.call)
+    expect(file1.cdn_url).to start_with(account_one_config.cdn_base.call)
+    expect(file2.cdn_url).to start_with(account_two_config.cdn_base.call)
+    expect(file1.cdn_url).not_to start_with(account_two_config.cdn_base.call)
+    expect(file2.cdn_url).not_to start_with(account_one_config.cdn_base.call)
   end
 
   it 'generates secure auth headers using the client config' do
-    config1.auth_type = 'Uploadcare'
-    config2.auth_type = 'Uploadcare'
+    account_one_config.auth_type = 'Uploadcare'
+    account_two_config.auth_type = 'Uploadcare'
 
-    auth1 = Uploadcare::Authenticator.new(config: config1)
-    auth2 = Uploadcare::Authenticator.new(config: config2)
+    auth1 = Uploadcare::Authenticator.new(config: account_one_config)
+    auth2 = Uploadcare::Authenticator.new(config: account_two_config)
 
     allow(Time).to receive(:now).and_return(Time.at(0))
 
     h1 = auth1.headers('GET', '/files/', '')
     h2 = auth2.headers('GET', '/files/', '')
 
-    expect(h1['Authorization']).to start_with("Uploadcare #{config1.public_key}:")
-    expect(h2['Authorization']).to start_with("Uploadcare #{config2.public_key}:")
+    expect(h1['Authorization']).to start_with("Uploadcare #{account_one_config.public_key}:")
+    expect(h2['Authorization']).to start_with("Uploadcare #{account_two_config.public_key}:")
     expect(h1['Authorization']).not_to eq(h2['Authorization'])
   end
 end