uploadcare-ruby 3.0.5 → 3.2.0

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'client/conversion/base_conversion_client'
+require 'param/conversion/document/processing_job_url_builder'
+
+module Uploadcare
+  module Client
+    module Conversion
+      # This is client for document conversion
+      #
+      # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#operation/documentConvert
+      class DocumentConversionClient < BaseConversionClient
+        def convert_many(
+          arr,
+          options = {},
+          url_builder_class = Param::Conversion::Document::ProcessingJobUrlBuilder
+        )
+          send_convert_request(arr, options, url_builder_class)
+        end
+
+        def get_conversion_status(token)
+          get(uri: "/convert/document/status/#{token}/")
+        end
+
+        private
+
+        def convert_uri
+          '/convert/document/'
+        end
+
+        def build_paths_body(params)
+          {
+            uuid: params[:uuid],
+            format: params[:format],
+            page: params[:page]
+          }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# 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.6.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_list_client.rb

@@ -15,8 +15,8 @@ module Uploadcare
       # limit: (1..1000)
       # ordering: ["datetime_uploaded"|"-datetime_uploaded"|"size"|"-size"]
       # from: number of files skipped
-      def file_list(**options)
-        query = options.empty? ? '' : '?' + URI.encode_www_form(options)
+      def file_list(options = {})
+        query = options.empty? ? '' : "?#{URI.encode_www_form(options)}"
         get(uri: "/files/#{query}")
       end
 
@@ -25,7 +25,7 @@ module Uploadcare
       # uuids: Array
       def batch_store(uuids)
         body = uuids.to_json
-        put(uri: '/files/storage/', body: body)
+        put(uri: '/files/storage/', content: body)
       end
 
       alias request_delete delete
@@ -35,7 +35,7 @@ module Uploadcare
       # uuids: Array
       def batch_delete(uuids)
         body = uuids.to_json
-        request_delete(uri: '/files/storage/', body: body)
+        request_delete(uri: '/files/storage/', content: body)
       end
 
       alias store_files batch_store

data/lib/uploadcare/client/group_client.rb

@@ -14,7 +14,7 @@ module Uploadcare
         body_hash = group_body_hash(file_list, **options)
         body = HTTP::FormData::Multipart.new(body_hash)
         post(path: 'group/',
-             headers: { 'Content-type': body.content_type },
+             headers: { 'Content-Type': body.content_type },
              body: body)
       end
 

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'parallel'
+require 'api_struct'
 
 module Uploadcare
   module Client
@@ -15,11 +16,21 @@ module Uploadcare
         # 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 upload_chunks(object, links)
+        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)
-            upload_chunk(chunk, links[link_id])
+            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
 
@@ -31,12 +42,12 @@ module Uploadcare
           {}
         end
 
-        private
-
         def upload_chunk(chunk, link)
-          put(path: link, body: chunk, headers: { 'Content-type': 'application/octet-stream' })
+          put(path: link, body: chunk, headers: { 'Content-Type': 'application/octet-stream' })
         end
 
+        private
+
         def default_params
           {}
         end

data/lib/uploadcare/client/multipart_upload_client.rb

@@ -13,43 +13,45 @@ 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)
+      def upload(object, store: false, &block)
         response = upload_start(object, store: store)
         return response unless response.success[:parts] && response.success[:uuid]
 
         links = response.success[:parts]
         uuid = response.success[:uuid]
-        ChunksClient.new.upload_chunks(object, links)
+        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, store: false)
         body = HTTP::FormData::Multipart.new(
-          Param::Upload::UploadParamsGenerator.call(store).merge(multiupload_metadata(object))
+          Param::Upload::UploadParamsGenerator.call(store).merge(form_data_for(object))
         )
         post(path: 'multipart/start/',
-             headers: { 'Content-type': body.content_type },
+             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
+          {
+            UPLOADCARE_PUB_KEY: Uploadcare.config.public_key,
+            uuid: uuid
+          }
         )
-        post(path: 'multipart/complete/', body: body, headers: { 'Content-type': body.content_type })
+        post(path: 'multipart/complete/', body: body, headers: { 'Content-Type': body.content_type })
       end
 
       private
 
-      def multiupload_metadata(file)
-        file = HTTP::FormData::File.new(file)
+      def form_data_for(file)
+        form_data_file = super(file)
         {
-          filename: file.filename,
-          size: file.size,
-          content_type: file.content_type
+          filename: form_data_file.filename,
+          size: form_data_file.size,
+          content_type: form_data_file.content_type
         }
       end
 

data/lib/uploadcare/client/project_client.rb

@@ -1,12 +1,14 @@
 # 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 private key combination
+      # current project is determined by public and secret key combination
       # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Project
       def show
         get(uri: '/project/')

data/lib/uploadcare/client/rest_client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'rest_client'
+require 'api_struct'
 require 'uploadcare/concern/error_handler'
 require 'uploadcare/concern/throttle_handler'
 require 'param/authentication_header'
@@ -22,11 +23,11 @@ module Uploadcare
       # Send request with authentication header
       #
       # Handle throttling as well
-      def request(method: 'GET', uri:, **options)
+      def request(uri:, method: 'GET', **options)
         request_headers = Param::AuthenticationHeader.call(method: method.upcase, uri: uri,
-                                                           content_type: headers[:'Content-type'], **options)
+                                                           content_type: headers[:'Content-Type'], **options)
         handle_throttling do
-          send('api_struct_' + method.downcase, path: remove_trailing_slash(uri),
+          send("api_struct_#{method.downcase}", path: remove_trailing_slash(uri),
                                                 headers: request_headers, body: options[:content])
         end
       end
@@ -53,7 +54,7 @@ module Uploadcare
 
       def headers
         {
-          'Content-type': 'application/json',
+          'Content-Type': 'application/json',
           'Accept': 'application/vnd.uploadcare-v0.5+json',
           'User-Agent': Uploadcare::Param::UserAgent.call
         }
@@ -62,7 +63,7 @@ module Uploadcare
       private
 
       def remove_trailing_slash(str)
-        str.gsub(%r{^\/}, '')
+        str.gsub(%r{^/}, '')
       end
 
       def default_params

data/lib/uploadcare/client/rest_group_client.rb

@@ -14,8 +14,8 @@ module Uploadcare
 
       # return paginated list of groups
       # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/groupsList
-      def list(**options)
-        query = options.empty? ? '' : '?' + URI.encode_www_form(options)
+      def list(options = {})
+        query = options.empty? ? '' : "?#{URI.encode_www_form(options)}"
         get(uri: "/groups/#{query}")
       end
     end

data/lib/uploadcare/client/upload_client.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'api_struct'
 require 'param/user_agent'
 require 'uploadcare/concern/error_handler'
 require 'uploadcare/concern/throttle_handler'
@@ -27,6 +28,13 @@ module Uploadcare
 
       private
 
+      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)
+        options = { filename: filename, content_type: mime_type }.compact
+        HTTP::FormData::File.new(file, options)
+      end
+
       def default_params
         {}
       end

data/lib/uploadcare/client/uploader_client.rb

@@ -15,7 +15,7 @@ module Uploadcare
       def upload_many(arr, **options)
         body = upload_many_body(arr, **options)
         post(path: 'base/',
-             headers: { 'Content-type': body.content_type },
+             headers: { 'Content-Type': body.content_type },
              body: body)
       end
 
@@ -35,7 +35,7 @@ module Uploadcare
       # - async - returns upload token instead of upload data
       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)
+        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])
@@ -44,6 +44,14 @@ module Uploadcare
         Dry::Monads::Success(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
+
       private
 
       alias api_struct_post post
@@ -55,38 +63,38 @@ module Uploadcare
         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) do
-          response = get_status_response(token)
+          response = get_upload_from_url_status(token)
           raise RequestError if %w[progress waiting unknown].include?(response.success[:status])
 
           response
         end
       end
 
-      # Check upload status
-      #
-      # @see https://uploadcare.com/api-refs/upload-api/#operation/fromURLUploadStatus
-      def get_status_response(token)
-        query_params = { token: token }
-        get(path: 'from_url/status/', params: query_params)
-      end
-
       # Prepares body for upload_many method
       def upload_many_body(arr, **options)
         files_formdata = arr.map do |file|
           [HTTP::FormData::File.new(file).filename,
-           HTTP::FormData::File.new(file)]
-        end .to_h
+           form_data_for(file)]
+        end.to_h
         HTTP::FormData::Multipart.new(
           Param::Upload::UploadParamsGenerator.call(options[:store]).merge(files_formdata)
         )
       end
 
+      STORE_VALUES_MAP = {
+        true => '1',
+        false => '0'
+      }.freeze
+
       # Prepare upload_from_url initial request body
       def upload_from_url_body(url, **options)
-        HTTP::FormData::Multipart.new({
-          'pub_key': Uploadcare.config.public_key,
-          'source_url': url
-        }.merge(**options))
+        HTTP::FormData::Multipart.new(
+          options.merge(
+            'pub_key' => Uploadcare.config.public_key,
+            'source_url' => url,
+            'store' => STORE_VALUES_MAP[options[:store]]
+          )
+        )
       end
     end
   end

data/lib/uploadcare/client/webhook_client.rb

@@ -9,8 +9,14 @@ module Uploadcare
     class WebhookClient < RestClient
       # Create webhook
       # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#subscribe
-      def create(target_url, event: 'file.uploaded', is_active: true)
-        body = { 'target_url': target_url, 'event': event, 'is_active': is_active }.to_json
+      def create(options = {})
+        body = {
+          '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
+        ).to_json
         post(uri: '/webhooks/', content: body)
       end
 
@@ -22,14 +28,14 @@ module Uploadcare
 
       # Permanently deletes subscription
       # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#unsubscribe
-      def delete(name)
-        body = { 'name': name }.to_json
+      def delete(target_url)
+        body = { 'target_url': target_url }.to_json
         post(uri: '/webhooks/unsubscribe/', content: body)
       end
 
       # Updates webhook
       # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#subscribe-update
-      def update(id, **options)
+      def update(id, options = {})
         body = options.to_json
         post(uri: "/webhooks/#{id}/", content: body)
       end

data/lib/uploadcare/concern/error_handler.rb

@@ -14,9 +14,9 @@ module Uploadcare
       def failure(response)
         catch_upload_errors(response)
         parsed_response = JSON.parse(response.body.to_s)
-        raise RequestError, parsed_response['detail']
+        raise RequestError, parsed_response['detail'] || parsed_response.map { |k, v| "#{k}: #{v}" }.join('; ')
       rescue JSON::ParserError
-        raise RequestError, response.status
+        raise RequestError, response.body.to_s
       end
 
       # Extension of ApiStruct's wrap method

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+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
+      class BaseConverter < Entity
+        class << self
+          # Converts files
+          #
+          # @param doc_params [Array] of hashes with params or [Hash]
+          # @option options [Boolean] :store (false) whether to store file on servers.
+          def convert(params, options = {})
+            files_params = params.is_a?(Hash) ? [params] : params
+            conversion_client.new.convert_many(files_params, options)
+          end
+
+          # Returns a status of a conversion job
+          #
+          # @param token [Integer, String] token obtained from a server in convert method
+          def status(token)
+            conversion_client.new.get_conversion_status(token)
+          end
+
+          private
+
+          def conversion_client
+            clients[:base]
+          end
+        end
+      end
+    end
+  end
+  include Conversion
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'base_converter'
+
+module Uploadcare
+  module Entity
+    module Conversion
+      # This serializer lets a user convert uploaded documents
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/documentConvert
+      class DocumentConverter < BaseConverter
+        client_service Client::Conversion::DocumentConversionClient
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'base_converter'
+
+module Uploadcare
+  module Entity
+    module Conversion
+      # This serializer lets a user convert uploaded videos, and usually returns an array of results
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/videoConvert
+      class VideoConverter < BaseConverter
+        client_service Client::Conversion::VideoConversionClient
+      end
+    end
+  end
+end

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 = Hash[query.map { |k, v| [k.to_sym, v] }]
+          query = query.map { |k, v| [k.to_sym, v] }.to_h
           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 = Hash[query.map { |k, v| [k.to_sym, v] }]
+          query = query.map { |k, v| [k.to_sym, v] }.to_h
           self.class.list(**query)
         end
 
@@ -44,7 +44,7 @@ module Uploadcare
         #
         # It's possible to avoid loading objects on previous pages by offsetting them first
         def load
-          return if @entity[:next].nil? || @entity[:results].length == @entity[:total]
+          return self if @entity[:next].nil? || @entity[:results].length == @entity[:total]
 
           np = self
           until np.next.nil?
@@ -59,12 +59,10 @@ module Uploadcare
         # iterate through pages, starting with current one
         #
         # @yield [Block]
-        def each
+        def each(&block)
           current_page = self
           while current_page
-            current_page.results.each do |obj|
-              yield obj
-            end
+            current_page.results.each(&block)
             current_page = current_page.next_page
           end
         end

data/lib/uploadcare/entity/file.rb

@@ -9,16 +9,16 @@ module Uploadcare
       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
+                  :mime_type, :original_file_url, :original_filename, :size, :url, :uuid, :variations, :video_info,
+                  :source, :rekognition_info
 
       # gets file's uuid - even if it's only initialized with url
-      # @return [String]
+      # @returns [String]
       def uuid
         return @entity.uuid if @entity.uuid
 
         uuid = @entity.url.gsub('https://ucarecdn.com/', '')
-        uuid = uuid.gsub(%r{\/.*}, '')
-        uuid
+        uuid.gsub(%r{/.*}, '')
       end
 
       # loads file metadata, if it's initialized with url or uuid
@@ -26,6 +26,20 @@ module Uploadcare
         initialize(File.info(uuid).entity)
       end
 
+      # The method to convert a document file to another file
+      # gets (conversion) params [Hash], options (store: Boolean) [Hash], converter [Class]
+      # @returns [File]
+      def convert_document(params = {}, options = {}, converter = Conversion::DocumentConverter)
+        convert_file(params, converter, options)
+      end
+
+      # The method to convert a video file to another file
+      # gets (conversion) params [Hash], options (store: Boolean) [Hash], converter [Class]
+      # @returns [File]
+      def convert_video(params = {}, options = {}, converter = Conversion::VideoConverter)
+        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.
@@ -76,6 +90,28 @@ module Uploadcare
       def remote_copy(target, **args)
         File.copy(uuid, target: 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
+      def store
+        File.store(uuid)
+      end
+
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/deleteFile
+      def delete
+        File.delete(uuid)
+      end
+
+      private
+
+      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[:uuid] = uuid
+        result = converter.convert(params_with_symbolized_keys, options)
+        result.success? ? File.info(result.value![:result].first[:uuid]) : result
+      end
     end
   end
 end

data/lib/uploadcare/entity/file_list.rb

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

data/lib/uploadcare/entity/group.rb

@@ -28,8 +28,7 @@ module Uploadcare
         return @entity.id if @entity.id
 
         id = @entity.cdn_url.gsub('https://ucarecdn.com/', '')
-        id = id.gsub(%r{\/.*}, '')
-        id
+        id.gsub(%r{/.*}, '')
       end
 
       # loads group metadata, if it's initialized with url or id