uploadcare-ruby 3.1.0.pre.rc1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b37d6357bdceca37eb0175201e52847b253c701771e3bed959e7e945e4b384b7
-  data.tar.gz: c70b33bed6660c649df6e93a5bb7e8b3cb5a4c79884a7c146086f0658da690a3
+  metadata.gz: '08303dd0379957a7780c58d562c2ddbf9ae42e02d8069e19404defb9d7455292'
+  data.tar.gz: d661a6c49bdcb5b5789b3e22dac0a0a439012f0a1bfc5a55b3cdc0c64094ef8b
 SHA512:
-  metadata.gz: 47b8ead48824c45759a89a62e170374afe3cc0e8a39690ba4851c04785ee52096769a4415fea2e7ecffb62a864a5fae5f6fb1e95bf450442141973b0412990e7
-  data.tar.gz: a7aa262e0982825592487187f99018f5276582dffbfa3ef412abc06a3c9d723906d64d2443c79c20eb0dce137ae1cec4384c40b54e692170915289c8191032b0
+  metadata.gz: b4b2c4f5342f48908731446e7ca2fa5aabef6568d99dede4ca46f3ed3df13993a156f70f84ac6a87d36799b2d589bc465814c7efeefcbfd6a3e459d3e378814f
+  data.tar.gz: 0ffba57715c58eeeabc2d2b44884e67d09a5ee41b916fd10248e46822d5b35d3dd5c24c450ec4961a03b5a6f01903a5867007248bd347b88ac3568d89104c592

data/.rubocop.yml

@@ -11,6 +11,7 @@ Style/HashTransformKeys:
   Exclude:
     - 'lib/uploadcare/entity/decorator/paginator.rb'
     - 'lib/uploadcare/client/conversion/video_conversion_client.rb'
+    - 'lib/uploadcare/entity/file.rb'
 
 Gemspec/RequiredRubyVersion:
   Exclude:

data/CHANGELOG.md

@@ -1,15 +1,10 @@
 # Changelog
 
-## 3.1.0-rc1 2021-08-11
+## 3.1.0 2021-09-21
 
-### 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
+- Added documents and videos conversion
+- Added new attributes to the Entity class (variations, video_info, source, rekognition_info)
+- Added an opportunity to add custom logic to large files uploading process
 
 ## 3.0.5 2021-04-15
 
@@ -23,7 +18,6 @@
 - 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

@@ -45,7 +45,7 @@ Note that `uploadcare-ruby` **3.x** is not backward compatible with
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'uploadcare-ruby'
+gem "uploadcare-ruby"
 ```
 
 And then execute:
@@ -67,8 +67,8 @@ settings can be seen in [`lib/uploadcare.rb`](lib/uploadcare.rb)
 
 ```ruby
 # your_config_initializer_file.rb
-Uploadcare.config.public_key = 'demopublickey'
-Uploadcare.config.secret_key = 'demoprivatekey'
+Uploadcare.config.public_key = "demopublickey"
+Uploadcare.config.secret_key = "demoprivatekey"
 ```
 
 ## Usage
@@ -116,21 +116,64 @@ Uploadcare supports multiple ways to upload files:
 
 ```ruby
 # Smart upload - detects type of passed object and picks appropriate upload method
-Uploadcare::Uploader.upload('https://placekitten.com/96/139')
+Uploadcare::Uploader.upload("https://placekitten.com/96/139")
 ```
 
 There are explicit ways to select upload type:
 
 ```ruby
-files = [File.open('1.jpg'), File.open('1.jpg']
+files = [File.open("1.jpg"), File.open("1.jpg"]
 Uploadcare::Uploader.upload_files(files)
 
-Uploadcare::Uploader.upload_from_url('https://placekitten.com/96/139')
+Uploadcare::Uploader.upload_from_url("https://placekitten.com/96/139")
+```
+It is possible to track progress of the upload-from-URL process. To do that, you should specify the `async` option and get a token:
+
+```ruby
+Uploadcare::Uploader.upload_from_url("https://placekitten.com/96/139", async: true)
+# => "c6e31082-6bdc-4cb3-bef5-14dd10574d72"
+```
+
+After the request for uploading-from-URL is sent, you can check the progress of the upload by sending the `get_upload_from_url_status` request:
+
+```ruby
+Uploadcare::Uploader.get_upload_from_url_status("1251ee66-3631-4416-a2fb-96ba59f5a515")
+# => Success({:size=>28511, :total=>28511, :done=>28511, :uuid=>"b829753b-6b64-4989-a167-ef15e4f3d190", :file_id=>"b859753b-zb64-4989-a167-ef15e4f3a190", :original_filename=>"video.ogg", :is_image=>false, :is_stored=>false, :image_info=>nil, :video_info=>nil, :is_ready=>true, :filename=>"video.ogg", :mime_type=>"audio/ogg", :status=>"success"})
+```
+
+In case of the `async` option is disabled, uploadcare-ruby tries to request the upload status several times (depending on the `max_request_tries` config param) and then returns uploaded file attributes.
 
+```ruby
 # multipart upload - can be useful for files bigger than 10 mb
-Uploadcare::Uploader.multipart_upload(File.open('big_file.bin'))
+Uploadcare::Uploader.multipart_upload(File.open("big_file.bin"), store: true)
 ```
 
+For the multipart upload you can pass a block to add some additional logic after each file chunk is uploaded.
+For example to track file uploading progress you can do something like this:
+
+```ruby
+file = File.open("big_file.bin")
+progress = 0
+Uploadcare::Uploader.multipart_upload(file, store: true) do |options|
+  progress += (100.0 / options[:links_count])
+  puts "PROGRESS = #{progress}"
+end
+```
+Output of the code above looks like:
+```console
+PROGRESS = 4.545454545454546
+PROGRESS = 9.090909090909092
+PROGRESS = 13.636363636363637
+...
+```
+Options available in a block:
+- **:chunk_size** - size of each chunk in bytes;
+- **:object** - file object which is going to be uploaded;
+- **:offset** - offset from the beginning of a File object in bytes;
+- **:link_id** - index of a link provided by Uploadcare API. Might be treated as index of a chunk;
+- **:links** - array of links for uploading file's chunks;
+- **:links_count** - count of the array of links.
+
 #### Uploading options
 
 You can override global [`:autostore`](#initialization) option for each upload request:
@@ -144,7 +187,7 @@ You can override global [`:autostore`](#initialization) option for each upload r
 Most methods are also available through `Uploadcare::Api` object:
 ```ruby
 # Same as Uploadcare::Uploader.upload
-Uploadcare::Api.upload('https://placekitten.com/96/139')
+Uploadcare::Api.upload("https://placekitten.com/96/139")
 ```
 
 Entities are representations of objects in Uploadcare cloud.
@@ -154,7 +197,7 @@ Entities are representations of objects in Uploadcare cloud.
 File entity contains its metadata.
 
 ```ruby
-@file = Uploadcare::File.file('FILE_ID_IN_YOUR_PROJECT')
+@file = Uploadcare::File.file("FILE_ID_IN_YOUR_PROJECT")
 {"datetime_removed"=>nil,
  "datetime_stored"=>"2020-01-16T15:03:15.315064Z",
  "datetime_uploaded"=>"2020-01-16T15:03:14.676902Z",
@@ -179,13 +222,53 @@ 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.copy # copies file, returns a new (copied) file metadata
 
 @file.store # stores file, returns updated metadata
 
 @file.delete #deletes file. Returns updated metadata
 ```
 
+The File object is also can be converted if it is a document or a video file. Imagine, you have a document file:
+
+```ruby
+@file = Uploadcare::File.file("FILE_ID_IN_YOUR_PROJECT")
+```
+
+To convert it to an another file, just do:
+
+```ruby
+@converted_file = @file.convert_document({ format: "png", page: "1" }, store: true)
+# => {
+#    "uuid"=>"<NEW_FILE_UUID>"}
+#    ...other file info...
+# }
+# OR
+# Failure({:"<FILE_UUID>/document/-/format/png/-/page/1/"=>"the target_format is not a supported 'to' format for this source file. <you_source_file_extension> -> png"})
+```
+
+Same works for video files:
+
+```ruby
+@converted_file = @file.convert_video(
+  {
+    format: "ogg",
+    quality: "best",
+    cut: { start_time: "0:0:0.1", length: "end" },
+    size: { resize_mode: "change_ratio", width: "600", height: "400" },
+    thumb: { N: 1, number: 2 }
+  },
+  store: true
+)
+# => {
+#    "uuid"=>"<NEW_FILE_UUID>"}
+#    ...other file info...
+# }
+# OR
+# Failure({:"<FILE_UUID>/video/-/size/600x400/preserve_ratio/-/quality/best/-/format/ogg/-/cut/0:0:0.1/end/-/thumbs~1/2/"=>"CDN Path error: Failed to parse remainder \"/preserve_ratio\" of \"size/600x400/preserve_ratio\""})
+```
+
+More about file conversion [here](#conversion).
 Metadata of deleted files is stored permanently.
 
 #### FileList
@@ -228,7 +311,7 @@ stored just for your convenience. That is why they are frozen.
 options = {
   limit: 10,
   stored: true,
-  ordering: '-datetime_uploaded',
+  ordering: "-datetime_uploaded",
   from: "2017-01-01T00:00:00",
 }
 @list = @api.file_list(options)
@@ -265,8 +348,8 @@ That's a requirement of our API.
 
 ```ruby
 # group can be created from an array of Uploadcare files (UUIDs)
-@file = '134dc30c-093e-4f48-a5b9-966fe9cb1d01'
-@file2 = '134dc30c-093e-4f48-a5b9-966fe9cb1d02'
+@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
@@ -293,9 +376,9 @@ 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(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.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
 ```
 
@@ -332,13 +415,14 @@ 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' },
+      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
+  ],
+  store: false
 )
 ```
 This method accepts options to set properties of an output file:
@@ -392,7 +476,8 @@ To convert multiple videos just add params as a hash for each video to the first
 Uploadcare::VideoConverter.convert(
   [
     { video_one_params }, { video_two_params }, ...
-  ], store: false
+  ],
+  store: false
 )
 ```
 
@@ -433,7 +518,7 @@ More examples and options can be found [here](https://uploadcare.com/docs/transf
 
 ##### 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/).
+Uploadcare allows converting documents to the following target formats: doc, docx, xls, xlsx, odt, ods, rtf, txt, pdf, 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:
@@ -443,9 +528,10 @@ Uploadcare::DocumentConverter.convert(
   [
     {
       uuid: "dc99200d-9bd6-4b43-bfa9-aa7bfaefca40",
-      format: 'pdf'
+      format: "pdf"
     }
-  ], store: false
+  ],
+  store: false
 )
 ```
 or create an image of a particular page (if using image format):
@@ -454,24 +540,20 @@ Uploadcare::DocumentConverter.convert(
   [
     {
       uuid: "a4b9db2f-1591-4f4c-8f68-94018924525d",
-      format: 'png',
+      format: "png",
       page: 1
     }
-  ], store: false
+  ],
+  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`.
+- **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`, `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
 {
@@ -498,7 +580,8 @@ To convert multiple documents just add params as a hash for each document to the
 Uploadcare::DocumentConverter.convert(
   [
     { doc_one_params }, { doc_two_params }, ...
-  ], store: false
+  ],
+  store: false
 )
 ```
 

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

@@ -10,42 +10,47 @@ module Uploadcare
       #
       # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#tag/Conversion
       class BaseConversionClient < RestClient
+        API_VERSION_HEADER_VALUE = 'application/vnd.uploadcare-v0.5+json'
+
         def headers
           {
-            'Content-type': 'application/json',
-            'Accept': 'application/vnd.uploadcare-v0.6+json',
+            'Content-Type': 'application/json',
+            'Accept': API_VERSION_HEADER_VALUE,
             'User-Agent': Uploadcare::Param::UserAgent.call
           }
         end
 
         private
 
+        def send_convert_request(arr, options, url_builder_class)
+          body = build_body_for_many(arr, options, url_builder_class)
+          post(uri: convert_uri, content: body)
+        end
+
         def success(response)
           body = response.body.to_s
-          result = extract_result(body)
-
-          Dry::Monads::Success(result)
+          extract_result(body)
         end
 
         def extract_result(response_body)
-          return nil if response_body.nil? || response_body.empty?
+          return if 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?
+          return Dry::Monads::Failure(errors) unless errors.nil? || errors.empty?
 
-          parsed_body
+          Dry::Monads::Success(parsed_body)
         end
 
         # Prepares body for convert_many method
         def build_body_for_many(arr, options, url_builder_class)
           {
-            "paths": arr.map do |params|
+            paths: arr.map do |params|
               url_builder_class.call(
                 **build_paths_body(params)
               )
             end,
-            "store": options[:store]
+            store: options[:store]
           }.compact.to_json
         end
       end

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

@@ -13,10 +13,9 @@ module Uploadcare
         def convert_many(
           arr,
           options = {},
-          url_builder_class = Uploadcare::Param::Conversion::Document::ProcessingJobUrlBuilder
+          url_builder_class = Param::Conversion::Document::ProcessingJobUrlBuilder
         )
-          body = build_body_for_many(arr, options, url_builder_class)
-          post(uri: '/convert/document/', content: body)
+          send_convert_request(arr, options, url_builder_class)
         end
 
         def get_conversion_status(token)
@@ -25,6 +24,10 @@ module Uploadcare
 
         private
 
+        def convert_uri
+          '/convert/document/'
+        end
+
         def build_paths_body(params)
           {
             uuid: params[:uuid],

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

@@ -12,12 +12,12 @@ module Uploadcare
       # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#operation/videoConvert
       class VideoConversionClient < BaseConversionClient
         def convert_many(
-          arr,
+          params,
           options = {},
-          url_builder_class = Uploadcare::Param::Conversion::Video::ProcessingJobUrlBuilder
+          url_builder_class = Param::Conversion::Video::ProcessingJobUrlBuilder
         )
-          body = build_body_for_many(arr, options, url_builder_class)
-          post(uri: '/convert/video/', content: body)
+          video_params = params.is_a?(Hash) ? [params] : params
+          send_convert_request(video_params, options, url_builder_class)
         end
 
         def get_conversion_status(token)
@@ -26,6 +26,10 @@ module Uploadcare
 
         private
 
+        def convert_uri
+          '/convert/video/'
+        end
+
         def build_paths_body(params)
           {
             uuid: params[:uuid],

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

@@ -16,12 +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|
-            client = self.class.new
             offset = link_id * CHUNK_SIZE
             chunk = IO.read(object, CHUNK_SIZE, offset)
-            client.send(: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
 
@@ -33,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,23 +13,23 @@ 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
 
@@ -37,24 +37,21 @@ module Uploadcare
       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)
-        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)
+      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/rest_client.rb

@@ -25,7 +25,7 @@ module Uploadcare
       # 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)
+                                                           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])
@@ -54,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
         }

data/lib/uploadcare/client/upload_client.rb

@@ -28,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,41 +63,25 @@ 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,
            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 = {
+      STORE_VALUES_MAP = {
         true => '1',
         false => '0'
       }.freeze
@@ -100,7 +92,7 @@ module Uploadcare
           options.merge(
             'pub_key' => Uploadcare.config.public_key,
             'source_url' => url,
-            'store' => STORE_VALUES[options[:store]]
+            'store' => STORE_VALUES_MAP[options[:store]]
           )
         )
       end

data/lib/uploadcare/client/webhook_client.rb

@@ -13,7 +13,7 @@ module Uploadcare
         body = {
           'target_url': options[:target_url],
           'event': options[:event] || 'file.uploaded',
-          'is_active': options[:is_active] || true
+          'is_active': options[:is_active].nil? ? true : options[:is_active]
         }.to_json
         post(uri: '/webhooks/', content: body)
       end

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/file.rb

@@ -13,7 +13,7 @@ module Uploadcare
                   :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
 
@@ -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,17 @@ module Uploadcare
       def remote_copy(target, **args)
         File.copy(uuid, target: target, **args)
       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/uploader.rb

@@ -18,7 +18,7 @@ module Uploadcare
       # @option options [Boolean] :store (false) whether to store file on servers.
       def self.upload(object, **options)
         if big_file?(object)
-          upload_big_file(object, **options)
+          multipart_upload(object, **options)
         elsif file?(object)
           upload_file(object, **options)
         elsif object.is_a?(Array)
@@ -43,8 +43,8 @@ module Uploadcare
       end
 
       # upload file of size above 10mb (involves multipart upload)
-      def self.upload_big_file(file, **_options)
-        response = MultipartUploaderClient.new.upload(file)
+      def self.multipart_upload(file, **options, &block)
+        response = MultipartUploaderClient.new.upload(file, **options, &block)
         Uploadcare::Entity::File.new(response.success)
       end
 
@@ -57,6 +57,12 @@ module Uploadcare
         response.success[:files].map { |file_data| Uploadcare::Entity::File.new(file_data) }
       end
 
+      # gets a status of upload from url
+      # @param url [String]
+      def self.get_upload_from_url_status(token)
+        UploaderClient.new.get_upload_from_url_status(token)
+      end
+
       class << self
         private
 

data/lib/uploadcare/ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Uploadcare
-  VERSION = '3.1.0-rc1'
+  VERSION = '3.1.0'
 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, Dmitrij Ivanchenko']
-  spec.email         = ['stepan.redka@railsmuffin.com', 'dmitrij.ivanchenko@gmail.com']
+  spec.authors       = ['Stepan Redka']
+  spec.email         = ['stepan.redka@railsmuffin.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.1.0.pre.rc1
+  version: 3.1.0
 platform: ruby
 authors:
-- Stepan Redka, Dmitrij Ivanchenko
+- Stepan Redka
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-08-11 00:00:00.000000000 Z
+date: 2021-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: api_struct
@@ -153,7 +153,6 @@ dependencies:
 description: Ruby wrapper for uploadcare API
 email:
 - stepan.redka@railsmuffin.com
-- dmitrij.ivanchenko@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -191,8 +190,10 @@ files:
 - lib/uploadcare/concern/error_handler.rb
 - lib/uploadcare/concern/throttle_handler.rb
 - lib/uploadcare/concern/upload_error_handler.rb
+- lib/uploadcare/entity/conversion/base_converter.rb
+- lib/uploadcare/entity/conversion/document_converter.rb
+- lib/uploadcare/entity/conversion/video_converter.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
@@ -200,7 +201,6 @@ 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
@@ -237,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: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper for uploadcare API

data/lib/uploadcare/entity/document_converter.rb

@@ -1,26 +0,0 @@
-# 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/video_converter.rb

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