uploadcare-ruby 3.0.5 → 3.1.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e78e5ae5b01f3ca9834186dbd80f7498a1ebec2491740e4b4d5a0aa2845e34e5
-  data.tar.gz: 84a34cf0fdc9cda596cc54b1b60df014d4d4b3f3882e8f3dad7344ae230c7c2f
+  metadata.gz: b37d6357bdceca37eb0175201e52847b253c701771e3bed959e7e945e4b384b7
+  data.tar.gz: c70b33bed6660c649df6e93a5bb7e8b3cb5a4c79884a7c146086f0658da690a3
 SHA512:
-  metadata.gz: 1efbec0c9e65cf94a769c206490090244628dd16952db2218e7dae5f004ed8b29c9b02855e48d7048006f125c4f019c17c03f40df1dc0db1d2fbd3cdfebf5e75
-  data.tar.gz: aa3ac3a9e392c105d8be4d405323e645fe07406fe14bf9cc579b4dc3852a2853f15c2dc18d492831284f8cb6343a84f3ffb34f028b3d822d9cd5f738ecb67f17
+  metadata.gz: 47b8ead48824c45759a89a62e170374afe3cc0e8a39690ba4851c04785ee52096769a4415fea2e7ecffb62a864a5fae5f6fb1e95bf450442141973b0412990e7
+  data.tar.gz: a7aa262e0982825592487187f99018f5276582dffbfa3ef412abc06a3c9d723906d64d2443c79c20eb0dce137ae1cec4384c40b54e692170915289c8191032b0

data/.rubocop.yml

@@ -7,6 +7,15 @@ Metrics/LineLength:
 IneffectiveAccessModifier:
   Enabled: false
 
+Style/HashTransformKeys:
+  Exclude:
+    - 'lib/uploadcare/entity/decorator/paginator.rb'
+    - 'lib/uploadcare/client/conversion/video_conversion_client.rb'
+
+Gemspec/RequiredRubyVersion:
+  Exclude:
+    - 'uploadcare-ruby.gemspec'
+
 Metrics/BlockLength:
   Exclude:
     - 'bin/'
@@ -18,3 +27,6 @@ Metrics/MethodLength:
 
 Style/Documentation:
   Enabled: false
+
+Style/OptionalBooleanParameter:
+  AllowedMethods: ['create']

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 3.1.0-rc1 2021-08-11
+
+### Added
+- Add video conversion
+- Add document conversion
+- Add new attributes to Uploadcare::File (variations, video_info, source, rekognition_info)
+
+### Fixed
+
+- Fix the `uninitialized constant Uploadcare::Client::ApiStruct (NameError)` error
+
 ## 3.0.5 2021-04-15
 
 - Replace Travis-CI with Github Actions
@@ -12,6 +23,7 @@
 - Added CI
 
 ## 3.0.3-dev 2020-03-13
+
 - Added better pagination and iterators for GroupList & FileList
 
 ## 3.0.2-dev 2020-03-11

data/README.md

@@ -12,12 +12,24 @@
 [stack-img]: https://img.shields.io/badge/tech-stack-0690fa.svg?style=flat
 [stack]: https://stackshare.io/uploadcare/stacks/
 
-
 Uploadcare Ruby integration handles uploads and further operations with files by
 wrapping Upload and REST APIs.
 
 * [Installation](#installation)
 * [Usage](#usage)
+  * [Uploading files](#uploading-files)
+    * [Uploading and storing a single file](#uploading-and-storing-a-single-file)
+    * [Multiple ways to upload files](#multiple-ways-to-upload-files)
+    * [Uploading options](#uploading-options)
+  * [File management](#file-management)
+    * [File](#file)
+    * [FileList](#filelist)
+    * [Pagination](#pagination)
+    * [Group](#group)
+    * [GroupList](#grouplist)
+    * [Webhook](#webhook)
+    * [Project](#project)
+    * [Conversion](#conversion)
 * [Useful links](#useful-links)
 
 ## Requirements
@@ -25,7 +37,7 @@ wrapping Upload and REST APIs.
 
 ## Compatibility
 
-Note that `uploadcare-ruby` **3.x** is not backward compativble with 
+Note that `uploadcare-ruby` **3.x** is not backward compatible with
 **[2.x](https://github.com/uploadcare/uploadcare-ruby/tree/v2.x)**.
 
 ## Installation
@@ -65,7 +77,8 @@ This section contains practical usage examples. Please note, everything that
 follows gets way more clear once you've looked through our
 [docs](https://uploadcare.com/docs/?utm_source=github&utm_medium=referral&utm_campaign=uploadcare-ruby).
 
-### Uploading and storing a single file
+### Uploading files
+#### Uploading and storing a single file
 
 Using Uploadcare is simple, and here are the basics of handling files.
 
@@ -97,7 +110,7 @@ within a 24-hour period.
 # => #<Uploadcare::Api::File ...
 ```
 
-### Uploads
+#### Multiple ways to upload files
 
 Uploadcare supports multiple ways to upload files:
 
@@ -118,7 +131,7 @@ Uploadcare::Uploader.upload_from_url('https://placekitten.com/96/139')
 Uploadcare::Uploader.multipart_upload(File.open('big_file.bin'))
 ```
 
-### Upload options
+#### Uploading options
 
 You can override global [`:autostore`](#initialization) option for each upload request:
 
@@ -127,15 +140,13 @@ You can override global [`:autostore`](#initialization) option for each upload r
 @api.upload_from_url(url, store: :auto)
 ```
 
-### Api
+### File management
 Most methods are also available through `Uploadcare::Api` object:
 ```ruby
 # Same as Uploadcare::Uploader.upload
 Uploadcare::Api.upload('https://placekitten.com/96/139')
 ```
 
-### Entity object
-
 Entities are representations of objects in Uploadcare cloud.
 
 #### File
@@ -168,6 +179,8 @@ File entity contains its metadata.
   "https://api.uploadcare.com/files/FILE_ID_IN_YOUR_PROJECT/",
  "uuid"=>"8f64f313-e6b1-4731-96c0-6751f1e7a50a"}
 
+@file.store # copies file, returns a new (copied) file metadata
+
 @file.store # stores file, returns updated metadata
 
 @file.delete #deletes file. Returns updated metadata
@@ -226,7 +239,7 @@ To simply get all associated objects:
 @list.all # => returns Array of Files
 ```
 
-##### Pagination
+#### Pagination
 
 Initially, `FileList` is a paginated collection. It can be navigated using following methods:
 ```ruby
@@ -251,10 +264,15 @@ assigned UUID. Note, group UUIDs include a `~#{files_count}` part at the end.
 That's a requirement of our API.
 
 ```ruby
-# group can be created from an array of Uploadcare files
+# group can be created from an array of Uploadcare files (UUIDs)
+@file = '134dc30c-093e-4f48-a5b9-966fe9cb1d01'
+@file2 = '134dc30c-093e-4f48-a5b9-966fe9cb1d02'
 @files_ary = [@file, @file2]
 @files = Uploadcare::Uploader.upload @files_ary
 @group = Uploadcare::Group.create @files
+
+# group can be stored by group ID. It means that all files of a group will be stored on Uploadcare servers permanently
+Uploadcare::Group.store(group.id)
 ```
 
 #### GroupList
@@ -275,7 +293,10 @@ You can use webhooks to provide notifications about your uploads to target urls.
 This gem lets you create and manage webhooks.
 
 ```ruby
-Uploadcare::Webhook.create('example.com/listen', event: 'file.uploaded')
+Uploadcare::Webhook.create(target_url: 'https://example.com/listen', event: 'file.uploaded', is_active: true)
+Uploadcare::Webhook.update(<webhook_id>, target_url: 'https://newexample.com/listen/new', event: 'file.uploaded', is_active: true)
+Uploadcare::Webhook.delete('https://example.com/listen')
+Uploadcare::Webhook.list
 ```
 
 #### Project
@@ -297,6 +318,222 @@ object is also an Hashie::Mash, so every methods out of
 # [{"email": collaborator@gmail.com, "name": "Collaborator"}, {"email": collaborator@gmail.com, "name": "Collaborator"}]
 ```
 
+#### Conversion
+
+##### Video
+
+Uploadcare can encode video files from all popular formats, adjust their quality, format and dimensions, cut out a video fragment, and generate thumbnails via [REST API](https://uploadcare.com/api-refs/rest-api/v0.6.0/).
+
+After each video file upload you obtain a file identifier in UUID format.
+Then you can use this file identifier to convert your video in multiple ways:
+
+```ruby
+Uploadcare::VideoConverter.convert(
+  [
+    {
+      uuid: "dc99200d-9bd6-4b43-bfa9-aa7bfaefca40",
+      size: { resize_mode: 'change_ratio', width: '600', height: '400' },
+      quality: 'best',
+      format: 'ogg',
+      cut: { start_time: '0:0:0.0', length: '0:0:1.0' },
+      thumbs: { N: 2, number: 1 }
+    }
+  ], store: false
+)
+```
+This method accepts options to set properties of an output file:
+
+- **uuid** — the file UUID-identifier.
+- **size**:
+  - **resize_mode** - size operation to apply to a video file. Can be `preserve_ratio (default)`, `change_ratio`, `scale_crop` or `add_padding`.
+  - **width** - width for a converted video.
+  - **height** - height for a converted video.
+
+```
+  NOTE: you can choose to provide a single dimension (width OR height).
+        The value you specify for any of the dimensions should be a non-zero integer divisible by 4
+```
+
+- **quality** - sets the level of video quality that affects file sizes and hence loading times and volumes of generated traffic. Can be `normal (default)`, `better`, `best`, `lighter`, `lightest`.
+- **format** - format for a converted video. Can be `mp4 (default)`, `webm`, `ogg`.
+- **cut**:
+  - **start_time** - defines the starting point of a fragment to cut based on your input file timeline.
+  - **length** - defines the duration of that fragment.
+- **thumbs**:
+  - **N** - quantity of thumbnails for your video - non-zero integer ranging from 1 to 50; defaults to 1.
+  - **number** - zero-based index of a particular thumbnail in a created set, ranging from 1 to (N - 1).
+- **store** - a flag indicating if Uploadcare should store your transformed outputs.
+
+```ruby
+# Response
+{
+  :result => [
+    {
+      :original_source=>"dc99200d-9bd6-4b43-bfa9-aa7bfaefca40/video/-/size/600x400/change_ratio/-/quality/best/-/format/ogg/-/cut/0:0:0.0/0:0:1.0/-/thumbs~2/1/",
+      :token=>911933811,
+      :uuid=>"6f9b88bd-625c-4d60-bfde-145fa3813d95",
+      :thumbnails_group_uuid=>"cf34c5a1-8fcc-4db2-9ec5-62c389e84468~2"
+    }
+  ],
+  :problems=>{}
+}
+```
+Params in the response:
+- **result** - info related to your transformed output(-s):
+  - **original_source** - built path for a particular video with all the conversion operations and parameters.
+  - **token** - a processing job token that can be used to get a [job status](https://uploadcare.com/docs/transformations/video-encoding/#status) (see below).
+  - **uuid** - UUID of your processed video file.
+  - **thumbnails_group_uuid** - holds :uuid-thumb-group, a UUID of a [file group](https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/groupsList) with thumbnails for an output video, based on the thumbs [operation](https://uploadcare.com/docs/transformations/video-encoding/#operation-thumbs) parameters.
+- **problems** - problems related to your processing job, if any.
+
+To convert multiple videos just add params as a hash for each video to the first argument of the `Uploadcare::VideoConverter#convert` method:
+
+```ruby
+Uploadcare::VideoConverter.convert(
+  [
+    { video_one_params }, { video_two_params }, ...
+  ], store: false
+)
+```
+
+
+To check a status of a video processing job you can simply use appropriate method of `Uploadcare::VideoConverter`:
+
+```ruby
+token = 911933811
+Uploadcare::VideoConverter.status(token)
+```
+`token` here is a processing job token, obtained in a response of a convert video request.
+
+```ruby
+# Response
+{
+  :status => "finished",
+  :error => nil,
+  :result => {
+    :uuid => "dc99200d-9bd6-4b43-bfa9-aa7bfaefca40",
+    :thumbnails_group_uuid => "0f181f24-7551-42e5-bebc-14b15d9d3838~2"
+  }
+}
+```
+
+Params in the response:
+- **status** - processing job status, can have one of the following values:
+  - *pending* — video file is being prepared for conversion.
+  - *processing* — video file processing is in progress.
+  - *finished* — the processing is finished.
+  - *failed* — we failed to process the video, see error for details.
+  - *canceled* — video processing was canceled.
+- **error** - holds a processing error if we failed to handle your video.
+- **result** - repeats the contents of your processing output.
+- **thumbnails_group_uuid** - holds :uuid-thumb-group, a UUID of a file group with thumbnails for an output video, based on the thumbs operation parameters.
+- **uuid** - a UUID of your processed video file.
+
+More examples and options can be found [here](https://uploadcare.com/docs/transformations/video-encoding/#video-encoding)
+
+##### Document
+
+Uploadcare allows converting documents to the following target formats: DOC, DOCX, XLS, XLSX, ODT, ODS, RTF, TXT, PDF, JPG, ENHANCED JPG, PNG. Document Conversion works via our [REST API](https://uploadcare.com/api-refs/rest-api/v0.6.0/).
+
+After each document file upload you obtain a file identifier in UUID format.
+Then you can use this file identifier to convert your document to a new format:
+
+```ruby
+Uploadcare::DocumentConverter.convert(
+  [
+    {
+      uuid: "dc99200d-9bd6-4b43-bfa9-aa7bfaefca40",
+      format: 'pdf'
+    }
+  ], store: false
+)
+```
+or create an image of a particular page (if using image format):
+```ruby
+Uploadcare::DocumentConverter.convert(
+  [
+    {
+      uuid: "a4b9db2f-1591-4f4c-8f68-94018924525d",
+      format: 'png',
+      page: 1
+    }
+  ], store: false
+)
+```
+
+This method accepts options to set properties of an output file:
+
+- **uuid** — the file UUID-identifier.
+- **format** - defines the target format you want a source file converted to. The supported values are: `pdf (default)`, `doc`, `docx`, `xls`, `xlsx`, `odt`, `ods`, `rtf`, `txt`, `jpg`, `enhanced.jpg`, `png`. In case the format operation was not found, your input document will be converted to `pdf`.
+- **page** - a page number of a multi-paged document to either `jpg` or `png`. The method will not work for any other target formats.
+
+```
+  NOTE: Use an enhanced.jpg output format for PDF documents with inline fonts.
+        When converting multi-page documents to an image format (jpg or png), the output will be a zip archive with one image per page.
+```
+
+```ruby
+# Response
+{
+  :result => [
+    {
+      :original_source=>"a4b9db2f-1591-4f4c-8f68-94018924525d/document/-/format/png/-/page/1/",
+      :token=>21120220
+      :uuid=>"88fe5ada-90f1-422a-a233-3a0f3a7cf23c"
+    }
+  ],
+  :problems=>{}
+}
+```
+Params in the response:
+- **result** - info related to your transformed output(-s):
+  - **original_source** - source file identifier including a target format, if present.
+  - **token** - a processing job token that can be used to get a [job status](https://uploadcare.com/docs/transformations/document-conversion/#status) (see below).
+  - **uuid** - UUID of your processed document file.
+- **problems** - problems related to your processing job, if any.
+
+To convert multiple documents just add params as a hash for each document to the first argument of the `Uploadcare::DocumentConverter#convert` method:
+
+```ruby
+Uploadcare::DocumentConverter.convert(
+  [
+    { doc_one_params }, { doc_two_params }, ...
+  ], store: false
+)
+```
+
+To check a status of a document processing job you can simply use appropriate method of `Uploadcare::DocumentConverter`:
+
+```ruby
+token = 21120220
+Uploadcare::DocumentConverter.status(token)
+```
+`token` here is a processing job token, obtained in a response of a convert document request.
+
+```ruby
+# Response
+{
+  :status => "finished",
+  :error => nil,
+  :result => {
+    :uuid => "a4b9db2f-1591-4f4c-8f68-94018924525d"
+  }
+}
+```
+
+Params in the response:
+- **status** - processing job status, can have one of the following values:
+  - *pending* — document file is being prepared for conversion.
+  - *processing* — document file processing is in progress.
+  - *finished* — the processing is finished.
+  - *failed* — we failed to process the document, see error for details.
+  - *canceled* — document processing was canceled.
+- **error** - holds a processing error if we failed to handle your document.
+- **result** - repeats the contents of your processing output.
+- **uuid** - a UUID of your processed document file.
+
+More examples and options can be found [here](https://uploadcare.com/docs/transformations/document-conversion/#document-conversion)
+
 ## Useful links
 
 * [Development](https://github.com/uploadcare/uploadcare-ruby/blob/main/DEVELOPMENT.md)

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../rest_client'
+require 'exception/conversion_error'
+
+module Uploadcare
+  module Client
+    module Conversion
+      # This is a base client for conversion operations
+      #
+      # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#tag/Conversion
+      class BaseConversionClient < RestClient
+        def headers
+          {
+            'Content-type': 'application/json',
+            'Accept': 'application/vnd.uploadcare-v0.6+json',
+            'User-Agent': Uploadcare::Param::UserAgent.call
+          }
+        end
+
+        private
+
+        def success(response)
+          body = response.body.to_s
+          result = extract_result(body)
+
+          Dry::Monads::Success(result)
+        end
+
+        def extract_result(response_body)
+          return nil if response_body.nil? || response_body.empty?
+
+          parsed_body = JSON.parse(response_body, symbolize_names: true)
+          errors = parsed_body[:error] || parsed_body[:problems]
+          raise ConversionError, errors unless errors.nil? || errors.empty?
+
+          parsed_body
+        end
+
+        # Prepares body for convert_many method
+        def build_body_for_many(arr, options, url_builder_class)
+          {
+            "paths": arr.map do |params|
+              url_builder_class.call(
+                **build_paths_body(params)
+              )
+            end,
+            "store": options[:store]
+          }.compact.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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 = Uploadcare::Param::Conversion::Document::ProcessingJobUrlBuilder
+        )
+          body = build_body_for_many(arr, options, url_builder_class)
+          post(uri: '/convert/document/', content: body)
+        end
+
+        def get_conversion_status(token)
+          get(uri: "/convert/document/status/#{token}/")
+        end
+
+        private
+
+        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,42 @@
+# 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(
+          arr,
+          options = {},
+          url_builder_class = Uploadcare::Param::Conversion::Video::ProcessingJobUrlBuilder
+        )
+          body = build_body_for_many(arr, options, url_builder_class)
+          post(uri: '/convert/video/', content: body)
+        end
+
+        def get_conversion_status(token)
+          get(uri: "/convert/video/status/#{token}/")
+        end
+
+        private
+
+        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/multipart_upload/chunks_client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'parallel'
+require 'api_struct'
 
 module Uploadcare
   module Client
@@ -17,9 +18,10 @@ module Uploadcare
         # @param links [Array] of strings; by default list of Amazon storage urls
         def upload_chunks(object, links)
           Parallel.each(0...links.count, in_threads: Uploadcare.config.upload_threads) do |link_id|
+            client = self.class.new
             offset = link_id * CHUNK_SIZE
             chunk = IO.read(object, CHUNK_SIZE, offset)
-            upload_chunk(chunk, links[link_id])
+            client.send(:upload_chunk, chunk, links[link_id])
           end
         end
 

data/lib/uploadcare/client/multipart_upload_client.rb

@@ -36,8 +36,10 @@ module Uploadcare
       # 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 })
       end
@@ -45,7 +47,10 @@ module Uploadcare
       private
 
       def multiupload_metadata(file)
-        file = HTTP::FormData::File.new(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
+        file = HTTP::FormData::File.new(file, options)
         {
           filename: file.filename,
           size: file.size,

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)
         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
@@ -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'

data/lib/uploadcare/client/uploader_client.rb

@@ -74,19 +74,35 @@ module Uploadcare
       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
+        p Param::Upload::UploadParamsGenerator.call(options[:store]).merge(files_formdata)
         HTTP::FormData::Multipart.new(
           Param::Upload::UploadParamsGenerator.call(options[:store]).merge(files_formdata)
         )
       end
 
+      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
+
+      STORE_VALUES = {
+        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[options[:store]]
+          )
+        )
       end
     end
   end

data/lib/uploadcare/client/webhook_client.rb

@@ -9,8 +9,12 @@ 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] || true
+        }.to_json
         post(uri: '/webhooks/', content: body)
       end
 
@@ -22,14 +26,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/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
 
@@ -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/document_converter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Entity
+    # This serializer lets a user convert uploaded documents
+    # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#operation/documentConvert
+    class DocumentConverter < Entity
+      client_service Conversion::DocumentConversionClient
+      # Converts documents
+      #
+      # @param doc_params [Array] of hashes with params or [Hash]
+      # @option options [Boolean] :store (false) whether to store file on servers.
+      def self.convert(doc_params, **options)
+        params = doc_params.is_a?(Hash) ? [doc_params] : doc_params
+        Conversion::DocumentConversionClient.new.convert_many(params, **options)
+      end
+
+      # Returns a status of document conversion job
+      #
+      # @param token [Integer, String] token obtained from a server in convert method
+      def self.status(token)
+        Conversion::DocumentConversionClient.new.get_conversion_status(token)
+      end
+    end
+  end
+end

data/lib/uploadcare/entity/file.rb

@@ -9,7 +9,8 @@ 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]
@@ -17,8 +18,7 @@ module Uploadcare
         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

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

data/lib/uploadcare/entity/uploader.rb

@@ -52,6 +52,8 @@ module Uploadcare
       # @param url [String]
       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) }
       end
 

data/lib/uploadcare/entity/video_converter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Entity
+    # This serializer lets a user convert uploaded videos, and usually returns an array of results
+    # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#operation/videoConvert
+    class VideoConverter < Entity
+      client_service Conversion::VideoConversionClient
+      # Converts video files
+      #
+      # @param doc_params [Array] of hashes with params or [Hash]
+      # @option options [Boolean] :store (false) whether to store file on servers.
+      def self.convert(video_params, **options)
+        params = video_params.is_a?(Hash) ? [video_params] : video_params
+        Conversion::VideoConversionClient.new.convert_many(params, **options)
+      end
+
+      # Returns a status of video conversion job
+      #
+      # @param token [Integer, String] token obtained from a server in convert method
+      def self.status(token)
+        Conversion::VideoConversionClient.new.get_conversion_status(token)
+      end
+    end
+  end
+end

data/lib/uploadcare/exception/conversion_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Exception
+    # Standard error for invalid API conversion responses
+    class ConversionError < StandardError; end
+  end
+end

data/lib/uploadcare/exception/throttle_error.rb

@@ -5,8 +5,10 @@ module Uploadcare
     # Exception for throttled requests
     class ThrottleError < StandardError
       attr_reader :timeout
+
       # @param timeout [Float] Amount of seconds the request have been throttled for
       def initialize(timeout = 10.0)
+        super
         @timeout = timeout
       end
     end

data/lib/uploadcare/param/conversion/document/processing_job_url_builder.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Param
+    module Conversion
+      module Document
+        class ProcessingJobUrlBuilder
+          class << self
+            def call(uuid:, format: nil, page: nil)
+              [
+                uuid_part(uuid),
+                format_part(format),
+                page_part(page)
+              ].compact.join('-')
+            end
+
+            private
+
+            def uuid_part(uuid)
+              "#{uuid}/document/"
+            end
+
+            def format_part(format)
+              return if format.nil?
+
+              "/format/#{format}/"
+            end
+
+            def page_part(page)
+              return if page.nil?
+
+              "/page/#{page}/"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/uploadcare/param/conversion/video/processing_job_url_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Param
+    module Conversion
+      module Video
+        class ProcessingJobUrlBuilder
+          class << self
+            # rubocop:disable Metrics/ParameterLists
+            def call(uuid:, size: {}, quality: nil, format: nil, cut: {}, thumbs: {})
+              [
+                uuid_part(uuid),
+                size_part(size),
+                quality_part(quality),
+                format_part(format),
+                cut_part(cut),
+                thumbs_part(thumbs)
+              ].compact.join('-')
+            end
+            # rubocop:enable Metrics/ParameterLists
+
+            private
+
+            def uuid_part(uuid)
+              "#{uuid}/video/"
+            end
+
+            def size_part(size)
+              return if size.empty?
+
+              dimensions = "#{size[:width]}x#{size[:height]}" if size[:width] || size[:height]
+              resize_mode = (size[:resize_mode]).to_s
+              "/size/#{dimensions}/#{resize_mode}/".squeeze('/')
+            end
+
+            def quality_part(quality)
+              return if quality.nil?
+
+              "/quality/#{quality}/"
+            end
+
+            def format_part(format)
+              return if format.nil?
+
+              "/format/#{format}/"
+            end
+
+            def cut_part(cut)
+              return if cut.empty?
+
+              "/cut/#{cut[:start_time]}/#{cut[:length]}/"
+            end
+
+            def thumbs_part(thumbs)
+              return if thumbs.empty?
+
+              "/thumbs~#{thumbs[:N]}/#{thumbs[:number]}/".squeeze('/')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/uploadcare/param/user_agent.rb

@@ -12,7 +12,7 @@ module Uploadcare
       #   UploadcareRuby/3.0.0-dev/Pubkey_(Ruby/2.6.3;UploadcareRuby)
       def self.call
         framework_data = Uploadcare.config.framework_data || ''
-        framework_data_string = '; ' + Uploadcare.config.framework_data unless framework_data.empty?
+        framework_data_string = "; #{Uploadcare.config.framework_data}" unless framework_data.empty?
         public_key = Uploadcare.config.public_key
         "UploadcareRuby/#{VERSION}/#{public_key} (Ruby/#{RUBY_VERSION}#{framework_data_string})"
       end

data/lib/uploadcare/ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Uploadcare
-  VERSION = '3.0.5'
+  VERSION = '3.1.0-rc1'
 end

data/uploadcare-ruby.gemspec

@@ -7,8 +7,8 @@ require 'uploadcare/ruby/version'
 Gem::Specification.new do |spec|
   spec.name          = 'uploadcare-ruby'
   spec.version       = Uploadcare::VERSION
-  spec.authors       = ['Stepan Redka']
-  spec.email         = ['stepan.redka@railsmuffin.com']
+  spec.authors       = ['Stepan Redka, Dmitrij Ivanchenko']
+  spec.email         = ['stepan.redka@railsmuffin.com', 'dmitrij.ivanchenko@gmail.com']
 
   spec.summary       = 'Ruby wrapper for uploadcare API'
   spec.description   = spec.summary

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uploadcare-ruby
 version: !ruby/object:Gem::Version
-  version: 3.0.5
+  version: 3.1.0.pre.rc1
 platform: ruby
 authors:
-- Stepan Redka
+- Stepan Redka, Dmitrij Ivanchenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-15 00:00:00.000000000 Z
+date: 2021-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: api_struct
@@ -153,6 +153,7 @@ dependencies:
 description: Ruby wrapper for uploadcare API
 email:
 - stepan.redka@railsmuffin.com
+- dmitrij.ivanchenko@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -173,6 +174,9 @@ files:
 - bin/setup
 - lib/uploadcare.rb
 - lib/uploadcare/api/api.rb
+- lib/uploadcare/client/conversion/base_conversion_client.rb
+- lib/uploadcare/client/conversion/document_conversion_client.rb
+- lib/uploadcare/client/conversion/video_conversion_client.rb
 - lib/uploadcare/client/file_client.rb
 - lib/uploadcare/client/file_list_client.rb
 - lib/uploadcare/client/group_client.rb
@@ -188,6 +192,7 @@ files:
 - lib/uploadcare/concern/throttle_handler.rb
 - lib/uploadcare/concern/upload_error_handler.rb
 - lib/uploadcare/entity/decorator/paginator.rb
+- lib/uploadcare/entity/document_converter.rb
 - lib/uploadcare/entity/entity.rb
 - lib/uploadcare/entity/file.rb
 - lib/uploadcare/entity/file_list.rb
@@ -195,10 +200,14 @@ files:
 - lib/uploadcare/entity/group_list.rb
 - lib/uploadcare/entity/project.rb
 - lib/uploadcare/entity/uploader.rb
+- lib/uploadcare/entity/video_converter.rb
 - lib/uploadcare/entity/webhook.rb
+- lib/uploadcare/exception/conversion_error.rb
 - lib/uploadcare/exception/request_error.rb
 - lib/uploadcare/exception/throttle_error.rb
 - lib/uploadcare/param/authentication_header.rb
+- lib/uploadcare/param/conversion/document/processing_job_url_builder.rb
+- lib/uploadcare/param/conversion/video/processing_job_url_builder.rb
 - lib/uploadcare/param/param.rb
 - lib/uploadcare/param/secure_auth_header.rb
 - lib/uploadcare/param/simple_auth_header.rb
@@ -228,11 +237,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper for uploadcare API