uploadcare-ruby 3.3.2 → 4.3.0

data/lib/uploadcare/client/file_metadata_client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'rest_client'
+
+module Uploadcare
+  module Client
+    # API client for handling single metadata_files
+    # @see https://uploadcare.com/docs/file-metadata/
+    # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File-metadata
+    class FileMetadataClient < RestClient
+      # Get file's metadata keys and values
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/fileMetadata
+      def index(uuid)
+        get(uri: "/files/#{uuid}/metadata/")
+      end
+
+      # Get the value of a single metadata key.
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/fileMetadataKey
+      def show(uuid, key)
+        get(uri: "/files/#{uuid}/metadata/#{key}/")
+      end
+
+      # Update the value of a single metadata key. If the key does not exist, it will be created.
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/updateFileMetadataKey
+      def update(uuid, key, value)
+        put(uri: "/files/#{uuid}/metadata/#{key}/", content: value.to_json)
+      end
+
+      # Delete a file's metadata key.
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/deleteFileMetadataKey
+      def delete(uuid, key)
+        request(method: 'DELETE', uri: "/files/#{uuid}/metadata/#{key}/")
+      end
+    end
+  end
+end

data/lib/uploadcare/client/group_client.rb

@@ -10,8 +10,8 @@ module Uploadcare
     class GroupClient < UploadClient
       # Create files group from a set of files by using their UUIDs.
       # @see https://uploadcare.com/api-refs/upload-api/#operation/createFilesGroup
-      def create(file_list, **options)
-        body_hash = group_body_hash(file_list, **options)
+      def create(file_list, options = {})
+        body_hash = group_body_hash(file_list, options)
         body = HTTP::FormData::Multipart.new(body_hash)
         post(path: 'group/',
              headers: { 'Content-Type': body.content_type },
@@ -21,7 +21,7 @@ module Uploadcare
       # Get group info
       # @see https://uploadcare.com/api-refs/upload-api/#operation/filesGroupInfo
       def info(group_id)
-        get(path: 'group/info/', params: { 'pub_key': Uploadcare.config.public_key, 'group_id': group_id })
+        get(path: 'group/info/', params: { pub_key: Uploadcare.config.public_key, group_id: group_id })
       end
 
       private
@@ -31,8 +31,8 @@ module Uploadcare
         ids.zip(file_ids).to_h
       end
 
-      def group_body_hash(file_list, **options)
-        { pub_key: Uploadcare.config.public_key }.merge(file_params(parse_file_list(file_list))).merge(**options)
+      def group_body_hash(file_list, options = {})
+        { pub_key: Uploadcare.config.public_key }.merge(file_params(parse_file_list(file_list))).merge(options)
       end
 
       # API accepts only list of ids, but some users may want to upload list of files

data/lib/uploadcare/client/multipart_upload/chunks_client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'parallel'
+require 'dry/monads'
 require 'api_struct'
 
 module Uploadcare
@@ -19,7 +20,7 @@ module Uploadcare
         def self.upload_chunks(object, links)
           Parallel.each(0...links.count, in_threads: Uploadcare.config.upload_threads) do |link_id|
             offset = link_id * CHUNK_SIZE
-            chunk = IO.read(object, CHUNK_SIZE, offset)
+            chunk = File.read(object, CHUNK_SIZE, offset)
             new.upload_chunk(chunk, links[link_id])
             next unless block_given?
 

data/lib/uploadcare/client/multipart_upload_client.rb

@@ -13,8 +13,8 @@ module Uploadcare
 
       # Upload a big file by splitting it into parts and sending those parts into assigned buckets
       # object should be File
-      def upload(object, store: false, &block)
-        response = upload_start(object, store: store)
+      def upload(object, options = {}, &block)
+        response = upload_start(object, options)
         return response unless response.success[:parts] && response.success[:uuid]
 
         links = response.success[:parts]
@@ -24,9 +24,10 @@ module Uploadcare
       end
 
       # Asks Uploadcare server to create a number of storage bin for uploads
-      def upload_start(object, store: false)
+      def upload_start(object, options = {})
+        options.merge!(store: options[:store] || false)
         body = HTTP::FormData::Multipart.new(
-          Param::Upload::UploadParamsGenerator.call(store).merge(form_data_for(object))
+          Param::Upload::UploadParamsGenerator.call(options).merge(form_data_for(object))
         )
         post(path: 'multipart/start/',
              headers: { 'Content-Type': body.content_type },

data/lib/uploadcare/client/project_client.rb

@@ -9,7 +9,7 @@ module Uploadcare
     class ProjectClient < RestClient
       # get information about current project
       # current project is determined by public and secret key combination
-      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Project
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Project
       def show
         get(uri: '/project/')
       end

data/lib/uploadcare/client/rest_client.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'rest_client'
+require 'dry/monads'
 require 'api_struct'
 require 'uploadcare/concern/error_handler'
 require 'uploadcare/concern/throttle_handler'
@@ -32,19 +32,19 @@ module Uploadcare
         end
       end
 
-      def get(**options)
+      def get(options = {})
         request(method: 'GET', **options)
       end
 
-      def post(**options)
+      def post(options = {})
         request(method: 'POST', **options)
       end
 
-      def put(**options)
+      def put(options = {})
         request(method: 'PUT', **options)
       end
 
-      def delete(**options)
+      def delete(options = {})
         request(method: 'DELETE', **options)
       end
 
@@ -55,7 +55,7 @@ module Uploadcare
       def headers
         {
           'Content-Type': 'application/json',
-          'Accept': 'application/vnd.uploadcare-v0.5+json',
+          Accept: 'application/vnd.uploadcare-v0.7+json',
           'User-Agent': Uploadcare::Param::UserAgent.call
         }
       end

data/lib/uploadcare/client/rest_group_client.rb

@@ -4,20 +4,40 @@ require_relative 'rest_client'
 
 module Uploadcare
   module Client
-    # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Group/paths/~1groups~1%3Cuuid%3E~1storage~1/put
+    # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Group/paths/~1groups~1%3Cuuid%3E~1storage~1/put
     class RestGroupClient < RestClient
       # store all files in a group
-      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Group/paths/~1groups~1%3Cuuid%3E~1storage~1/put
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/storeFile
       def store(uuid)
-        put(uri: "/groups/#{uuid}/storage/")
+        files = info(uuid).success[:files].compact
+        client = ::Uploadcare::Client::FileClient.new
+        files.each_slice(Uploadcare.config.file_chunk_size) do |file_chunk|
+          file_chunk.each do |file|
+            client.store(file[:uuid])
+          end
+        end
+
+        Dry::Monads::Success(nil)
+      end
+
+      # Get a file group by its ID.
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/groupInfo
+      def info(uuid)
+        get(uri: "/groups/#{uuid}/")
       end
 
       # return paginated list of groups
-      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/groupsList
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/groupsList
       def list(options = {})
         query = options.empty? ? '' : "?#{URI.encode_www_form(options)}"
         get(uri: "/groups/#{query}")
       end
+
+      # Delete a file group by its ID.
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/deleteGroup
+      def delete(uuid)
+        request(method: 'DELETE', uri: "/groups/#{uuid}/")
+      end
     end
   end
 end

data/lib/uploadcare/client/upload_client.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require 'dry/monads'
 require 'api_struct'
 require 'param/user_agent'
 require 'uploadcare/concern/error_handler'
 require 'uploadcare/concern/throttle_handler'
+require 'mimemagic'
 
 module Uploadcare
   module Client
@@ -30,7 +32,8 @@ module Uploadcare
 
       def form_data_for(file)
         filename = file.original_filename if file.respond_to?(:original_filename)
-        mime_type = file.content_type if file.respond_to?(:content_type)
+        mime_type = MimeMagic.by_magic(file)&.type
+        mime_type = file.content_type if mime_type.nil? && file.respond_to?(:content_type)
         options = { filename: filename, content_type: mime_type }.compact
         HTTP::FormData::File.new(file, options)
       end

data/lib/uploadcare/client/uploader_client.rb

@@ -12,8 +12,8 @@ module Uploadcare
     class UploaderClient < UploadClient
       # @see https://uploadcare.com/api-refs/upload-api/#operation/baseUpload
 
-      def upload_many(arr, **options)
-        body = upload_many_body(arr, **options)
+      def upload_many(arr, options = {})
+        body = upload_many_body(arr, options)
         post(path: 'base/',
              headers: { 'Content-Type': body.content_type },
              body: body)
@@ -22,8 +22,8 @@ module Uploadcare
       # syntactic sugar for upload_many
       # There is actual upload method for one file, but it is redundant
 
-      def upload(file, **options)
-        upload_many([file], **options)
+      def upload(file, options = {})
+        upload_many([file], options)
       end
 
       # Upload files from url
@@ -33,8 +33,9 @@ module Uploadcare
       # - filename
       # - save_URL_duplicates
       # - async - returns upload token instead of upload data
-      def upload_from_url(url, **options)
-        body = upload_from_url_body(url, **options)
+      # - metadata - file metadata, hash
+      def upload_from_url(url, options = {})
+        body = upload_from_url_body(url, options)
         token_response = post(path: 'from_url/', headers: { 'Content-Type': body.content_type }, body: body)
         return token_response if options[:async]
 
@@ -55,7 +56,7 @@ module Uploadcare
       private
 
       alias api_struct_post post
-      def post(**args)
+      def post(args = {})
         handle_throttling { api_struct_post(**args) }
       end
 
@@ -71,13 +72,13 @@ module Uploadcare
       end
 
       # Prepares body for upload_many method
-      def upload_many_body(arr, **options)
-        files_formdata = arr.map do |file|
+      def upload_many_body(arr, options = {})
+        files_formdata = arr.to_h do |file|
           [HTTP::FormData::File.new(file).filename,
            form_data_for(file)]
-        end.to_h
+        end
         HTTP::FormData::Multipart.new(
-          Param::Upload::UploadParamsGenerator.call(options[:store]).merge(files_formdata)
+          Param::Upload::UploadParamsGenerator.call(options).merge(files_formdata)
         )
       end
 
@@ -87,7 +88,7 @@ module Uploadcare
       }.freeze
 
       # Prepare upload_from_url initial request body
-      def upload_from_url_body(url, **options)
+      def upload_from_url_body(url, options = {})
         HTTP::FormData::Multipart.new(
           options.merge(
             'pub_key' => Uploadcare.config.public_key,

data/lib/uploadcare/client/webhook_client.rb

@@ -5,17 +5,17 @@ require_relative 'rest_client'
 module Uploadcare
   module Client
     # client for webhook management
-    # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Webhook
+    # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Webhook
     class WebhookClient < RestClient
       # Create webhook
       # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#subscribe
       def create(options = {})
         body = {
-          'target_url': options[:target_url],
-          'event': options[:event] || 'file.uploaded',
-          'is_active': options[:is_active].nil? ? true : options[:is_active]
+          target_url: options[:target_url],
+          event: options[:event] || 'file.uploaded',
+          is_active: options[:is_active].nil? ? true : options[:is_active]
         }.merge(
-          { 'signing_secret': options[:signing_secret] }.compact
+          { signing_secret: options[:signing_secret] }.compact
         ).to_json
         post(uri: '/webhooks/', content: body)
       end
@@ -29,15 +29,15 @@ module Uploadcare
       # Permanently deletes subscription
       # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#unsubscribe
       def delete(target_url)
-        body = { 'target_url': target_url }.to_json
-        post(uri: '/webhooks/unsubscribe/', content: body)
+        body = { target_url: target_url }.to_json
+        request(method: 'DELETE', uri: '/webhooks/unsubscribe/', content: body)
       end
 
       # Updates webhook
       # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#subscribe-update
       def update(id, options = {})
         body = options.to_json
-        post(uri: "/webhooks/#{id}/", content: body)
+        put(uri: "/webhooks/#{id}/", content: body)
       end
 
       alias create_webhook create

data/lib/uploadcare/concern/error_handler.rb

@@ -36,7 +36,7 @@ module Uploadcare
 
       # Raise ThrottleError. Also, tells in error when server will be ready for next request
       def raise_throttling_error(response)
-        retry_after = response.headers['Retry-After'].to_i + 1 || 11
+        retry_after = (response.headers['Retry-After'].to_i + 1) || 11
         raise ThrottleError.new(retry_after), "Response throttled, retry #{retry_after} seconds later"
       end
 

data/lib/uploadcare/concern/upload_error_handler.rb

@@ -24,7 +24,7 @@ module Uploadcare
       def catch_throttling_error(response)
         return unless response.code == 429
 
-        retry_after = response.headers['Retry-After'].to_i + 1 || 11
+        retry_after = (response.headers['Retry-After'].to_i + 1) || 11
         raise ThrottleError.new(retry_after), "Response throttled, retry #{retry_after} seconds later"
       end
     end

data/lib/uploadcare/entity/addons.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Entity
+    # This serializer is responsible for addons handling
+    #
+    # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Add-Ons
+    class Addons < Entity
+      client_service AddonsClient
+
+      attr_entity :request_id, :status, :result
+    end
+  end
+end

data/lib/uploadcare/entity/conversion/base_converter.rb

@@ -4,7 +4,7 @@ module Uploadcare
   module Entity
     module Conversion
       # This serializer lets a user convert uploaded documents
-      # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#operation/documentConvert
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/documentConvert
       class BaseConverter < Entity
         class << self
           # Converts files

data/lib/uploadcare/entity/decorator/paginator.rb

@@ -26,7 +26,7 @@ module Uploadcare
           return unless url
 
           query = URI.decode_www_form(URI(url).query).to_h
-          query = query.map { |k, v| [k.to_sym, v] }.to_h
+          query = query.to_h { |k, v| [k.to_sym, v] }
           self.class.list(**query)
         end
 
@@ -36,7 +36,7 @@ module Uploadcare
           return unless url
 
           query = URI.decode_www_form(URI(url).query).to_h
-          query = query.map { |k, v| [k.to_sym, v] }.to_h
+          query = query.to_h { |k, v| [k.to_sym, v] }
           self.class.list(**query)
         end
 

data/lib/uploadcare/entity/file.rb

@@ -6,11 +6,14 @@ module Uploadcare
     #
     # @see https://uploadcare.com/docs/api_reference/rest/handling_projects/
     class File < Entity
+      RESPONSE_PARAMS = %i[
+        datetime_removed datetime_stored datetime_uploaded is_image is_ready mime_type original_file_url
+        original_filename size url uuid variations content_info metadata appdata source
+      ].freeze
+
       client_service FileClient
 
-      attr_entity :datetime_removed, :datetime_stored, :datetime_uploaded, :image_info, :is_image, :is_ready,
-                  :mime_type, :original_file_url, :original_filename, :size, :url, :uuid, :variations, :video_info,
-                  :source, :rekognition_info
+      attr_entity(*RESPONSE_PARAMS)
 
       # gets file's uuid - even if it's only initialized with url
       # @returns [String]
@@ -40,64 +43,43 @@ module Uploadcare
         convert_file(params, converter, options)
       end
 
-      # 'copy' method is used to copy original files or their modified versions to default storage.
-      #
-      # Source files MAY either be stored or just uploaded and MUST NOT be deleted.
-      #
-      # @param [String] source uuid or uploadcare link to file.
-      # @param [Hash] args
-      # @option args [Boolean] :store Whether to store the file
-      # @option args [Boolean] :strip_operations Copies file without transformations (if source has them)
-      # @option args [String] :target points to a target custom storage.
-      # @option args [Boolean] :make_public make files on custom storage available via public links.
-      # @option args [String] :pattern define file naming pattern for the custom storage scenario.
-      #
-      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/copyFile
-      def self.copy(source, **args)
-        response = FileClient.new.copy(source: source, **args).success[:result]
-        File.new(response)
-      end
-
       # Copies file to current project
       #
       # source can be UID or full CDN link
       #
-      # @see .copy
-      def self.local_copy(source, **args)
-        File.copy(source, **args)
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/createLocalCopy
+      def self.local_copy(source, args = {})
+        response = FileClient.new.local_copy(source: source, **args).success[:result]
+        File.new(response)
       end
 
       # copy file to different project
       #
       # source can be UID or full CDN link
       #
-      # @see .copy
-      def self.remote_copy(source, target, **args)
-        File.copy(source: source, target: target, **args)
-      end
-
-      # Instance version of #{copy}. Copies current file.
-      def copy(**args)
-        File.copy(uuid, **args)
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/createRemoteCopy
+      def self.remote_copy(source, target, args = {})
+        response = FileClient.new.remote_copy(source: source, target: target, **args).success[:result]
+        File.new(response)
       end
 
       # Instance version of {internal_copy}
-      def local_copy(**args)
+      def local_copy(args = {})
         File.local_copy(uuid, **args)
       end
 
       # Instance version of {external_copy}
-      def remote_copy(target, **args)
-        File.copy(uuid, target: target, **args)
+      def remote_copy(target, args = {})
+        File.remote_copy(uuid, target, **args)
       end
 
       # Store a single file, preventing it from being deleted in 2 weeks
-      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/storeFile
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/storeFile
       def store
         File.store(uuid)
       end
 
-      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/deleteFile
+      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/deleteFileStorage
       def delete
         File.delete(uuid)
       end
@@ -107,7 +89,7 @@ module Uploadcare
       def convert_file(params, converter, options = {})
         raise Uploadcare::Exception::ConversionError, 'The first argument must be a Hash' unless params.is_a?(Hash)
 
-        params_with_symbolized_keys = params.map { |k, v| [k.to_sym, v] }.to_h
+        params_with_symbolized_keys = params.to_h { |k, v| [k.to_sym, v] }
         params_with_symbolized_keys[:uuid] = uuid
         result = converter.convert(params_with_symbolized_keys, options)
         result.success? ? File.info(result.value![:result].first[:uuid]) : result

data/lib/uploadcare/entity/file_list.rb

@@ -2,6 +2,7 @@
 
 require 'uploadcare/entity/file'
 require 'uploadcare/entity/decorator/paginator'
+require 'dry/monads'
 require 'api_struct'
 
 module Uploadcare

data/lib/uploadcare/entity/file_metadata.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Entity
+    # This serializer is responsible for file metadata handling
+    #
+    # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File-metadata
+    class FileMetadata < Entity
+      client_service FileMetadataClient
+
+      class << self
+        def index(uuid)
+          ::Uploadcare::Client::FileMetadataClient.new.index(uuid).success
+        end
+
+        def show(uuid, key)
+          ::Uploadcare::Client::FileMetadataClient.new.show(uuid, key).success
+        end
+
+        def update(uuid, key, value)
+          ::Uploadcare::Client::FileMetadataClient.new.update(uuid, key, value).success
+        end
+
+        def delete(uuid, key)
+          ::Uploadcare::Client::FileMetadataClient.new.delete(uuid, key).success || '200 OK'
+        end
+      end
+    end
+  end
+end

data/lib/uploadcare/entity/group.rb

@@ -10,7 +10,7 @@ module Uploadcare
     #
     # @see https://uploadcare.com/docs/api_reference/upload/groups/
     class Group < Entity
-      client_service RestGroupClient, prefix: 'rest', only: :store
+      client_service RestGroupClient, prefix: 'rest', only: %i[store info delete]
       client_service GroupClient
 
       attr_entity :id, :datetime_created, :datetime_stored, :files_count, :cdn_url, :url
@@ -19,7 +19,16 @@ module Uploadcare
       # Remove these lines and bump api_struct version when this PR is accepted:
       # @see https://github.com/rubygarage/api_struct/pull/15
       def self.store(uuid)
-        rest_store(uuid)
+        rest_store(uuid).success || '200 OK'
+      end
+
+      # Get a file group by its ID.
+      def self.group_info(uuid)
+        rest_info(uuid)
+      end
+
+      def self.delete(uuid)
+        rest_delete(uuid).success || '200 OK'
       end
 
       # gets groups's id - even if it's only initialized with cdn_url

data/lib/uploadcare/entity/uploader.rb

@@ -16,42 +16,42 @@ module Uploadcare
       # @param object [Array], [String] or [File]
       # @param [Hash] options options for upload
       # @option options [Boolean] :store (false) whether to store file on servers.
-      def self.upload(object, **options)
+      def self.upload(object, options = {})
         if big_file?(object)
-          multipart_upload(object, **options)
+          multipart_upload(object, options)
         elsif file?(object)
-          upload_file(object, **options)
+          upload_file(object, options)
         elsif object.is_a?(Array)
-          upload_files(object, **options)
+          upload_files(object, options)
         elsif object.is_a?(String)
-          upload_from_url(object, **options)
+          upload_from_url(object, options)
         else
           raise ArgumentError, "Expected input to be a file/Array/URL, given: `#{object}`"
         end
       end
 
       # upload single file
-      def self.upload_file(file, **options)
-        response = UploaderClient.new.upload_many([file], **options)
+      def self.upload_file(file, options = {})
+        response = UploaderClient.new.upload_many([file], options)
         Uploadcare::Entity::File.info(response.success.to_a.flatten[-1])
       end
 
       # upload multiple files
-      def self.upload_files(arr, **options)
-        response = UploaderClient.new.upload_many(arr, **options)
+      def self.upload_files(arr, options = {})
+        response = UploaderClient.new.upload_many(arr, options)
         response.success.map { |pair| Uploadcare::Entity::File.new(uuid: pair[1], original_filename: pair[0]) }
       end
 
       # upload file of size above 10mb (involves multipart upload)
-      def self.multipart_upload(file, **options, &block)
-        response = MultipartUploaderClient.new.upload(file, **options, &block)
+      def self.multipart_upload(file, options = {}, &block)
+        response = MultipartUploaderClient.new.upload(file, options, &block)
         Uploadcare::Entity::File.new(response.success)
       end
 
       # upload files from url
       # @param url [String]
-      def self.upload_from_url(url, **options)
-        response = UploaderClient.new.upload_from_url(url, **options)
+      def self.upload_from_url(url, options = {})
+        response = UploaderClient.new.upload_from_url(url, options)
         return response.success[:token] unless response.success[:files]
 
         response.success[:files].map { |file_data| Uploadcare::Entity::File.new(file_data) }

data/lib/uploadcare/param/authentication_header.rb

@@ -10,10 +10,10 @@ module Uploadcare
     # This authentication method is more secure, but more tedious
     class AuthenticationHeader
       # @see https://uploadcare.com/docs/api_reference/rest/requests_auth/#auth-uploadcare
-      def self.call(**options)
+      def self.call(options = {})
         case Uploadcare.config.auth_type
         when 'Uploadcare'
-          SecureAuthHeader.call(**options)
+          SecureAuthHeader.call(options)
         when 'Uploadcare.Simple'
           SimpleAuthHeader.call
         else