uploadcare-ruby 4.4.2 → 5.0.0.rc1

data/lib/uploadcare/client/conversion/video_conversion_client.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'client/conversion/base_conversion_client'
-require 'param/conversion/video/processing_job_url_builder'
-require 'exception/conversion_error'
-
-module Uploadcare
-  module Client
-    module Conversion
-      # This is client for video conversion
-      #
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/videoConvert
-      class VideoConversionClient < BaseConversionClient
-        def convert_many(
-          params,
-          options = {},
-          url_builder_class = Param::Conversion::Video::ProcessingJobUrlBuilder
-        )
-          video_params = params.is_a?(Hash) ? [params] : params
-          send_convert_request(video_params, options, url_builder_class)
-        end
-
-        def get_conversion_status(token)
-          get(uri: "/convert/video/status/#{token}/")
-        end
-
-        private
-
-        def convert_uri
-          '/convert/video/'
-        end
-
-        def build_paths_body(params)
-          {
-            uuid: params[:uuid],
-            quality: params[:quality],
-            format: params[:format],
-            size: params[:size],
-            cut: params[:cut],
-            thumbs: params[:thumbs]
-          }.compact
-        end
-      end
-    end
-  end
-end

data/lib/uploadcare/client/file_client.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rest_client'
-
-module Uploadcare
-  module Client
-    # API client for handling single files
-    # @see https://uploadcare.com/docs/api_reference/rest/accessing_files/
-    # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File
-    class FileClient < RestClient
-      # Gets list of files without pagination fields
-      def index
-        response = get(uri: '/files/')
-        response.fmap { |i| i[:results] }
-      end
-
-      # Acquire file info
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/fileInfo
-      def info(uuid, params = {})
-        get(uri: "/files/#{uuid}/", params: params)
-      end
-      alias file info
-
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/createLocalCopy
-      def local_copy(options = {})
-        body = options.compact.to_json
-        post(uri: '/files/local_copy/', content: body)
-      end
-
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/createRemoteCopy
-      def remote_copy(options = {})
-        body = options.compact.to_json
-        post(uri: '/files/remote_copy/', content: body)
-      end
-
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/deleteFileStorage
-      def delete(uuid)
-        request(method: 'DELETE', uri: "/files/#{uuid}/storage/")
-      end
-
-      # Store a single file, preventing it from being deleted in 2 weeks
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/storeFile
-      def store(uuid)
-        put(uri: "/files/#{uuid}/storage/")
-      end
-    end
-  end
-end

data/lib/uploadcare/client/file_list_client.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rest_client'
-
-module Uploadcare
-  module Client
-    # API client for handling file lists
-    class FileListClient < RestClient
-      # Returns a pagination json of files stored in project
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/filesList
-      #
-      # valid options:
-      # removed: [true|false]
-      # stored: [true|false]
-      # limit: (1..1000)
-      # ordering: ["datetime_uploaded"|"-datetime_uploaded"]
-      # from: number of files skipped
-      def file_list(options = {})
-        query = options.empty? ? '' : "?#{URI.encode_www_form(options)}"
-        get(uri: "/files/#{query}")
-      end
-
-      # Make a set of files "stored". This will prevent them from being deleted automatically
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/filesStoring
-      # uuids: Array
-      def batch_store(uuids)
-        body = uuids.to_json
-        put(uri: '/files/storage/', content: body)
-      end
-
-      alias request_delete delete
-
-      # Delete several files by list of uids
-      # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/filesDelete
-      # uuids: Array
-      def batch_delete(uuids)
-        body = uuids.to_json
-        request_delete(uri: '/files/storage/', content: body)
-      end
-
-      alias store_files batch_store
-      alias delete_files batch_delete
-      alias list file_list
-    end
-  end
-end

data/lib/uploadcare/client/file_metadata_client.rb

@@ -1,36 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'upload_client'
-
-module Uploadcare
-  module Client
-    # Groups serve a purpose of better organizing files in your Uploadcare projects.
-    # You can create one from a set of files by using their UUIDs.
-    # @see https://uploadcare.com/docs/api_reference/upload/groups/
-    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)
-        body = HTTP::FormData::Multipart.new(body_hash)
-        post(path: 'group/',
-             headers: { 'Content-Type': body.content_type },
-             body: body)
-      end
-
-      # 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 })
-      end
-
-      private
-
-      def file_params(file_ids)
-        ids = (0...file_ids.size).map { |i| "files[#{i}]" }
-        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)
-      end
-
-      # API accepts only list of ids, but some users may want to upload list of files
-      # @return [Array] of [String]
-      def parse_file_list(file_list)
-        file_list.map { |file| file.methods.include?(:uuid) ? file.uuid : file }
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'parallel'
-require 'dry/monads'
-require 'api_struct'
-
-module Uploadcare
-  module Client
-    module MultipartUpload
-      # This class splits file into chunks of set chunk_size
-      # and uploads them into cloud storage.
-      # Used for multipart uploads
-      # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload/paths/https:~1~1uploadcare.s3-accelerate.amazonaws.com~1%3C%3Cpresigned-url%3E/put
-      class ChunksClient < ApiStruct::Client
-        CHUNK_SIZE = 5_242_880
-
-        # In multiple threads, 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
-        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 = File.read(object, CHUNK_SIZE, offset)
-            new.upload_chunk(chunk, links[link_id])
-            next unless block_given?
-
-            yield(
-              chunk_size: CHUNK_SIZE,
-              object: object,
-              offset: offset,
-              link_id: link_id,
-              links: links,
-              links_count: links.count
-            )
-          end
-        end
-
-        def api_root
-          ''
-        end
-
-        def headers
-          {}
-        end
-
-        def upload_chunk(chunk, link)
-          put(path: link, body: chunk, headers: { 'Content-Type': 'application/octet-stream' })
-        end
-
-        private
-
-        def default_params
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/uploadcare/client/multipart_upload_client.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'client/multipart_upload/chunks_client'
-require_relative 'upload_client'
-
-module Uploadcare
-  module Client
-    # Client for multipart uploads
-    #
-    # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload
-    class MultipartUploaderClient < UploadClient
-      include MultipartUpload
-
-      # Upload a big file by splitting it into parts and sending those parts into assigned buckets
-      # object should be File
-      def upload(object, options = {}, &block)
-        response = upload_start(object, options)
-        return response unless response.success[:parts] && response.success[:uuid]
-
-        links = response.success[:parts]
-        uuid = response.success[:uuid]
-        ChunksClient.upload_chunks(object, links, &block)
-        upload_complete(uuid)
-      end
-
-      # Asks Uploadcare server to create a number of storage bin for uploads
-      def upload_start(object, options = {})
-        body = HTTP::FormData::Multipart.new(
-          Param::Upload::UploadParamsGenerator.call(options).merge(form_data_for(object))
-        )
-        post(path: 'multipart/start/',
-             headers: { 'Content-Type': body.content_type },
-             body: body)
-      end
-
-      # When every chunk is uploaded, ask Uploadcare server to finish the upload
-      def upload_complete(uuid)
-        body = HTTP::FormData::Multipart.new(
-          {
-            UPLOADCARE_PUB_KEY: Uploadcare.config.public_key,
-            uuid: uuid
-          }
-        )
-        post(path: 'multipart/complete/', body: body, headers: { 'Content-Type': body.content_type })
-      end
-
-      private
-
-      def form_data_for(file)
-        form_data_file = super
-        {
-          filename: form_data_file.filename,
-          size: form_data_file.size,
-          content_type: form_data_file.content_type
-        }
-      end
-
-      alias api_struct_post post
-      def post(**args)
-        handle_throttling { api_struct_post(**args) }
-      end
-    end
-  end
-end

data/lib/uploadcare/client/project_client.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rest_client'
-
-module Uploadcare
-  module Client
-    # API client for getting project info
-    # @see https://uploadcare.com/docs/api_reference/rest/handling_projects/
-    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.7.0/#tag/Project
-      def show
-        get(uri: '/project/')
-      end
-
-      alias project show
-    end
-  end
-end

data/lib/uploadcare/client/rest_client.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/monads'
-require 'api_struct'
-require 'uploadcare/concern/error_handler'
-require 'uploadcare/concern/throttle_handler'
-require 'param/authentication_header'
-
-module Uploadcare
-  module Client
-    # @abstract
-    # General client for signed REST requests
-    class RestClient < ApiStruct::Client
-      include Uploadcare::Concerns::ErrorHandler
-      include Uploadcare::Concerns::ThrottleHandler
-      include Exception
-
-      alias api_struct_delete delete
-      alias api_struct_get get
-      alias api_struct_post post
-      alias api_struct_put put
-
-      # Send request with authentication header
-      #
-      # Handle throttling as well
-      def request(uri:, method: 'GET', **options)
-        request_headers = Param::AuthenticationHeader.call(method: method.upcase, uri: uri,
-                                                           content_type: headers[:'Content-Type'], **options)
-        handle_throttling do
-          send("api_struct_#{method.downcase}",
-               path: remove_trailing_slash(uri),
-               headers: request_headers,
-               body: options[:content],
-               params: options[:params])
-        end
-      end
-
-      def get(options = {})
-        request(method: 'GET', **options)
-      end
-
-      def post(options = {})
-        request(method: 'POST', **options)
-      end
-
-      def put(options = {})
-        request(method: 'PUT', **options)
-      end
-
-      def delete(options = {})
-        request(method: 'DELETE', **options)
-      end
-
-      def api_root
-        Uploadcare.config.rest_api_root
-      end
-
-      def headers
-        {
-          'Content-Type': 'application/json',
-          Accept: 'application/vnd.uploadcare-v0.7+json',
-          'User-Agent': Uploadcare::Param::UserAgent.call
-        }
-      end
-
-      private
-
-      def remove_trailing_slash(str)
-        str.gsub(%r{^/}, '')
-      end
-
-      def default_params
-        {}
-      end
-    end
-  end
-end

data/lib/uploadcare/client/rest_group_client.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rest_client'
-
-module Uploadcare
-  module Client
-    # @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.7.0/#operation/storeFile
-      def store(uuid)
-        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::Result::Success.call(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.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,46 +0,0 @@
-# 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
-    # @abstract
-    #
-    # Headers and helper methods for clients working with upload API
-    # @see https://uploadcare.com/docs/api_reference/upload/
-    class UploadClient < ApiStruct::Client
-      include Concerns::ErrorHandler
-      include Concerns::ThrottleHandler
-      include Exception
-
-      def api_root
-        Uploadcare.config.upload_api_root
-      end
-
-      def headers
-        {
-          'User-Agent': Uploadcare::Param::UserAgent.call
-        }
-      end
-
-      private
-
-      def form_data_for(file)
-        filename = file.original_filename if file.respond_to?(:original_filename)
-        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
-
-      def default_params
-        {}
-      end
-    end
-  end
-end

data/lib/uploadcare/client/uploader_client.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'upload_client'
-require 'retries'
-require 'param/upload/upload_params_generator'
-require 'param/upload/signature_generator'
-
-module Uploadcare
-  module Client
-    # This is client for general uploads
-    #
-    # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload
-    class UploaderClient < UploadClient
-      # @see https://uploadcare.com/api-refs/upload-api/#operation/baseUpload
-
-      def upload_many(arr, options = {})
-        body = upload_many_body(arr, options)
-        post(path: 'base/',
-             headers: { 'Content-Type': body.content_type },
-             body: body)
-      end
-
-      # 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)
-      end
-
-      # Upload files from url
-      # @see https://uploadcare.com/api-refs/upload-api/#operation/fromURLUpload
-      # options:
-      # - check_URL_duplicates
-      # - filename
-      # - save_URL_duplicates
-      # - async - returns upload token instead of upload data
-      # - 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]
-
-        uploaded_response = poll_upload_response(token_response.success[:token])
-        return uploaded_response if uploaded_response.success[:status] == 'error'
-
-        Dry::Monads::Result::Success.call(files: [uploaded_response.success])
-      end
-
-      # Check upload status
-      #
-      # @see https://uploadcare.com/api-refs/upload-api/#operation/fromURLUploadStatus
-      def get_upload_from_url_status(token)
-        query_params = { token: token }
-        get(path: 'from_url/status/', params: query_params)
-      end
-
-      # Get information about an uploaded file
-      # Secret key not needed
-      #
-      # https://uploadcare.com/api-refs/upload-api/#tag/Upload/operation/fileUploadInfo
-      def file_info(uuid)
-        query_params = {
-          file_id: uuid,
-          pub_key: Uploadcare.config.public_key
-        }
-        get(path: 'info/', params: query_params)
-      end
-
-      private
-
-      alias api_struct_post post
-      def post(args = {})
-        handle_throttling { api_struct_post(**args) }
-      end
-
-      def poll_upload_response(token)
-        with_retries(max_tries: Uploadcare.config.max_request_tries,
-                     base_sleep_seconds: Uploadcare.config.base_request_sleep,
-                     max_sleep_seconds: Uploadcare.config.max_request_sleep,
-                     rescue: RetryError) do
-          response = get_upload_from_url_status(token)
-          handle_polling_response(response)
-        end
-      end
-
-      def handle_polling_response(response)
-        case response.success[:status]
-        when 'error'
-          raise RequestError, response.success[:error]
-        when 'progress', 'waiting', 'unknown'
-          raise RetryError, response.success[:error] || 'Upload is taking longer than expected. Try increasing the max_request_tries config if you know your file uploads will take more time.' # rubocop:disable Layout/LineLength
-        end
-
-        response
-      end
-
-      # Prepares body for upload_many method
-      def upload_many_body(arr, options = {})
-        files_formdata = arr.to_h do |file|
-          [HTTP::FormData::File.new(file).filename,
-           form_data_for(file)]
-        end
-        HTTP::FormData::Multipart.new(
-          Param::Upload::UploadParamsGenerator.call(options).merge(files_formdata)
-        )
-      end
-
-      # Prepare upload_from_url initial request body
-      def upload_from_url_body(url, options = {})
-        opts = {
-          'pub_key' => Uploadcare.config.public_key,
-          'source_url' => url,
-          'store' => store_value(options[:store])
-        }
-        opts.merge!(Param::Upload::SignatureGenerator.call) if Uploadcare.config.sign_uploads
-        HTTP::FormData::Multipart.new(options.merge(opts))
-      end
-
-      def store_value(store)
-        case store
-        when true, '1', 1 then '1'
-        when false, '0', 0 then '0'
-        else 'auto'
-        end
-      end
-    end
-  end
-end