filestack 2.6.7 → 2.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4383af939a3a456f04f1d2f659d0bdfc16ce5cde
-  data.tar.gz: 5f9af58956f96c75937565cbdf2ae26f0515173a
+SHA256:
+  metadata.gz: c8df62167708408191c6712610f423f11ca60cf7fc8efd6210c9c1c5ae675468
+  data.tar.gz: 9f1699ac9e3850e932e44a09883397b5ebea98546e5bca835de90526555086d0
 SHA512:
-  metadata.gz: 6315edb6cd53d8e099b6f5d2e0e5d0bb35a7a7e62c6def902be28c82026ea8017e2e7d71d2f142aec986e5fce2044c4fc97c9f3383fc18a107cb7c4b6cd99367
-  data.tar.gz: b22bd6ba8d89f302152068d9718e1fca439c462f1ee15ba56e130f3c2eab56a96564a27bca25b6524cecb34b5776628299c546f17ba4f55fcfdd598ef8c03751
+  metadata.gz: a5808e35c807e81789324f38f59385bc2a96cb539b22fb6c083b5f2ffe99e0a0eaf443e25d8b5ed9371838461791991c66d95e0db22c94dc6e848ebd386489e0
+  data.tar.gz: b24184548151630522ced35dda7c645e382f241fe276732f92c0fea16cb62ec906d5ed7618476546ebea864feab6f35de90f344387abc73c95455fddd5db3588

data/.travis.yml

@@ -9,6 +9,9 @@ rvm:
 before_install:
     - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
     - gem install bundler -v '< 2'
+    - sudo apt-get update -y
+    - sudo apt-get install -y shared-mime-info
+    - mkdir -p ./usr/share/mime/packages && cp -a /usr/share/mime/packages/freedesktop.org.xml ./usr/share/mime/packages/
 
 after_success:
   - coveralls

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Filestack-Ruby Changelog
 
+## 2.9.1 (March 26, 2021)
+- Update version of mimemagic gem to 0.3.9
+
+## 2.9.0 (March 25, 2021)
+- Update version of mimemagic gem to 0.3.8
+
+## 2.8.1 (October 1, 2020)
+- Add rescue and raises body message on upload
+
+## 2.8.0 (September 29, 2020)
+- Add IO object upload
+
+## 2.7.0 (September 28, 2020)
+- Add workflows
+
 ## 2.6.7 (August 4, 2020)
 - Add content disposition task
 

data/README.md

@@ -37,6 +37,19 @@ Or install it yourself as:
 
     $ gem install filestack
 
+## Dependencies
+
+We use the gem `mimemagic` which requires a copy of the Freedesktop.org shared-mime-info database.
+
+macOS users can install the database via Homebrew with `brew install shared-mime-info`.
+
+If you are unable to use a package manager, you can obtain a copy of the needed file by extracting it from the Debian package. This process will also work on a Windows machine.
+
+1. Download the package from https://packages.debian.org/sid/amd64/shared-mime-info/download
+2. Ensure the command line version of 7-Zip is installed
+3. `7z x -so shared-mime-info_2.0-1_amd64.deb data.tar | 7z e -sidata.tar "./usr/share/mime/packages/freedesktop.org.xml"`
+4. Place the file `freedesktop.org.xml` in an appropriate location, and then set the environment variable `FREEDESKTOP_MIME_TYPES_PATH` to that path. Once that has been done the gem should install successfully. Please note that the gem will depend upon the file remaining in that location at run time.
+
 ## Usage
 
 ### Import
@@ -44,47 +57,89 @@ Or install it yourself as:
 require 'filestack'
 ```
 Intialize the client using your API key, and security if you are using it.
+
 ```ruby
 client = FilestackClient.new('YOUR_API_KEY', security: security_object)
 ```
 ### Uploading
-Filestack uses multipart uploading by default, which is faster for larger files. This can be turned off by passing in ```multipart: false```. Multipart is disabled when uploading external URLs.
 ```ruby
-filelink = client.upload(filepath: '/path/to/file')
+filelink = client.upload(filepath: '/path/to/localfile')
 
-filelink = client.upload(filepath: '/path/to/file', multipart: false)
+# OR
+
+filelink = client.upload(external_url: 'http://domain.com/image.png')
 
 # OR
 
-filelink = client.upload(external_url: 'http://someurl.com')
+file = StringIO.new
+filelink = client.upload(io: file)
 ```
 
-To upload a local and an external file with query parameters:
+To upload a local, an IO object and an external file with following optional options:
+
 ```ruby
-filelink = client.upload(filepath: '/path/to/file', options: {mimetype: 'image/png'})
+options = {
+  filename: 'string',
+  location: 'string',
+  path: 'string',
+  container: 'string',
+  mimetype: 'string',
+  region: 'string',
+  workflows: ['workflow-id-1', 'workflow-id-2'],
+  upload_tags: {
+    key: 'value',
+    key2: 'value'
+  }
+}
 
-filelink = client.upload(external_url: 'http://someurl.com/image.png', options: {mimetype: 'image/jpeg'})
+filelink = client.upload(filepath: '/path/to/localfile', options: { mimetype: 'image/png', filename: 'custom_filename.png' })
+
+filelink = client.upload(external_url: 'http://domain.com/image.png', options: { mimetype: 'image/jpeg', filename: 'custom_filename.png' })
 ```
 
 To store file on `dropbox`, `azure`, `gcs` or `rackspace`, you must have the chosen provider configured in the developer portal to enable this feature. By default the file is stored on `s3`. You can add more details of the storage in `options`.
 
 ```ruby
-filelink = client.upload(filepath: '/path/to/file', storage: 'dropbox', options: {path: 'folder_name/'})
+filelink = client.upload(filepath: '/path/to/file', storage: 's3', options: { path: 'folder_name/', container: 'container_name', location: 's3', region: 'region_name' })
 
-filelink = client.upload(external_url: 'http://someurl.com/image.png', storage: 'dropbox', options: {path: 'folder_name/'})
+filelink = client.upload(external_url: 'http://someurl.com/image.png', options: { location: 'dropbox', path: 'folder_name' })
+```
+
+### Workflows
+Workflows allow you to wire up conditional logic and image processing to enforce business processes, automate ingest, and save valuable development time. In order to trigger the workflow job for each upload:
+
+```ruby
+filelink = client.upload(filepath: '/path/to/file', options: { workflows: ["workflow_id_1", "workflow_id_2"] })
+
+#OR
+
+filelink = client.upload(external_url: 'http://someurl.com/image.png', options: { workflows: ["workflow_id_1"] })
 ```
 
 ### Security
 If security is enabled on your account, or if you are using certain actions that require security (delete, overwrite and certain transformations), you will need to create a security object and pass it into the client on instantiation.
 
 ```ruby
-security = FilestackSecurity.new('YOUR_APP_SECRET', options: {call: %w[read store pick]})
+security = FilestackSecurity.new('YOUR_APP_SECRET', options: {call: %w[read store pick runWorkflow]})
 client = FilestackClient.new('YOUR_API_KEY', security: security)
 ```
 
 ### Using FilestackFilelinks
 FilestackFilelink objects are representation of a file handle. You can download, get raw file content, delete and overwrite file handles directly. Security is required for overwrite and delete methods.
 
+Initialize the filelink using the file handle, your API key, and security if required. The file handle is the string following the last slash `/` in the file URL.
+
+```ruby
+filelink = FilestackFilelink.new(handle, apikey: 'YOUR_API_KEY', security: security_object)
+```
+
+### Deletion
+You can delete a file by simply calling `delete` on the filelink.
+
+```ruby
+filelink.delete
+```
+
 ### Transformations
 Transforms can be initiated one of two ways. The first, by calling ```transform``` on a filelink:
 

data/VERSION

@@ -1 +1 @@
-2.6.7
+2.9.1

data/filestack-ruby.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "typhoeus", "~> 1.1"
   spec.add_dependency "parallel", "~> 1.11", ">= 1.11.2"
-  spec.add_dependency "mimemagic", "~> 0.3.2"
+  spec.add_dependency "mimemagic", "~> 0.3.9"
   spec.add_dependency "progress_bar"
 
   spec.add_development_dependency "bundler", "~> 1.7"

data/lib/filestack/config.rb

@@ -7,11 +7,6 @@ class FilestackConfig
   CDN_URL = 'https://cdn.filestackcontent.com'.freeze
   PROCESS_URL = 'https://process.filestackapi.com'.freeze
 
-  MULTIPART_START_URL = 'https://upload.filestackapi.com/multipart/start'.freeze
-  MULTIPART_UPLOAD_URL = 'https://upload.filestackapi.com/multipart/upload'.freeze
-  MULTIPART_COMMIT_URL = 'https://upload.filestackapi.com/multipart/commit'.freeze
-  MULTIPART_COMPLETE_URL = 'https://upload.filestackapi.com/multipart/complete'.freeze
-
   MULTIPART_PARAMS = %w[
     store_location store_region store_container
     store_path store_access
@@ -22,10 +17,30 @@ class FilestackConfig
   VERSION = Filestack::Ruby::VERSION
   HEADERS = {
     'User-Agent' => "filestack-ruby #{VERSION}",
-    'Filestack-Source' => "Ruby-#{VERSION}"
+    'Filestack-Source' => "Ruby-#{VERSION}",
+    'Content-Type' => "application/json",
+    'Accept-Encoding' => "application/json"
   }.freeze
 
+  DEFAULT_UPLOAD_MIMETYPE = 'application/octet-stream'
+
   INTELLIGENT_ERROR_MESSAGES = ['BACKEND_SERVER', 'BACKEND_NETWORK', 'S3_SERVER', 'S3_NETWORK']
+
+  def self.multipart_start_url
+    "https://upload.filestackapi.com/multipart/start"
+  end
+
+  def self.multipart_upload_url(base_url)
+    "https://#{base_url}/multipart/upload"
+  end
+
+  def self.multipart_commit_url(base_url)
+    "https://#{base_url}/multipart/commit"
+  end
+
+  def self.multipart_complete_url(base_url)
+    "https://#{base_url}/multipart/complete"
+  end
 end
 
 class TransformConfig

data/lib/filestack/models/filestack_client.rb

@@ -23,30 +23,25 @@ class FilestackClient
     @security = security
   end
 
-  # Upload a local file or external url
+  # Upload a local file, external url or IO object
   # @param [String]               filepath         The path of a local file
   # @param [String]               external_url     An external URL
-  # @param [Bool]                 multipart        Switch for miltipart
-  #                                                    (Default: true)
+  # @param [StringIO]             io               The IO object
   # @param [Hash]                 options          User-supplied upload options
+  # @param [Boolean]              intelligent      Upload file using Filestack Intelligent Ingestion
+  # @param [String]               storage          Default storage to be used for uploads
   #
   # return [Filestack::FilestackFilelink]
-  def upload(filepath: nil, external_url: nil, multipart: true, options: {}, storage: 's3', intelligent: false, timeout: 60)
-    if filepath && external_url
-      return 'You cannot upload a URL and file at the same time'
-    end
-    response = if filepath && multipart
-                 multipart_upload(@apikey, filepath, @security, options, timeout, storage, intelligent: intelligent)
+  def upload(filepath: nil, external_url: nil, io: nil, options: {}, intelligent: false, timeout: 60, storage: 'S3')
+    return 'You cannot upload a URL and file at the same time' if (filepath || io) && external_url
+
+    response = if external_url
+                send_upload(@apikey, external_url, @security, options)
                else
-                 send_upload(
-                   @apikey,
-                   filepath: filepath,
-                   external_url: external_url,
-                   options: options,
-                   security: @security,
-                   storage: storage
-                 )
+                return 'You cannot upload IO object and file at the same time' if io && filepath
+                multipart_upload(@apikey, filepath, io, @security, options, timeout, storage, intelligent)
                end
+
     FilestackFilelink.new(response['handle'], security: @security, apikey: @apikey)
   end
   # Transform an external URL

data/lib/filestack/ruby/version.rb

@@ -1,5 +1,5 @@
 module Filestack
   module Ruby
-    VERSION = '2.6.7'.freeze
+    VERSION = '2.9.1'.freeze
   end
 end

data/lib/filestack/utils/multipart_upload_utils.rb

@@ -13,24 +13,23 @@ include UploadUtils
 include IntelligentUtils
 # Includes all the utility functions for Filestack multipart uploads
 module MultipartUploadUtils
-  def get_file_info(file)
-    filename = File.basename(file)
+
+  def get_file_attributes(file, options = {})
+    filename = options[:filename] || File.basename(file)
+    mimetype = options[:mimetype] || MimeMagic.by_magic(File.open(file)) || FilestackConfig::DEFAULT_UPLOAD_MIMETYPE
     filesize = File.size(file)
-    mimetype = MimeMagic.by_magic(File.open(file))
-    if mimetype.nil?
-      mimetype = 'application/octet-stream'
-    end
+
     [filename, filesize, mimetype.to_s]
   end
 
-  def multipart_options(options)
-    [:region, :container, :path, :access].each do |key|
-      if options.has_key?(key)
-        options[:"store_#{key}"] = options[key]
-        options.delete(key)
-      end
-    end
-    return options
+  def get_io_attributes(io, options = {})
+    filename = options[:filename] || 'unnamed_file'
+    mimetype = options[:mimetype] || FilestackConfig::DEFAULT_UPLOAD_MIMETYPE
+
+    io.seek(0, IO::SEEK_END)
+    filesize = io.tell
+
+    [filename, filesize, mimetype.to_s]
   end
 
   # Send start response to multipart endpoint
@@ -41,8 +40,10 @@ module MultipartUploadUtils
   # @param [String]             mimetype      Mimetype of incoming file
   # @param [FilestackSecurity]  security      Security object with
   #                                           policy/signature
+  # @param [String]             storage        Default storage to be used for uploads
   # @param [Hash]               options       User-defined options for
   #                                           multipart uploads
+  # @param [Bool]               intelligent   Upload file using Filestack Intelligent Ingestion
   #
   # @return [Typhoeus::Response]
   def multipart_start(apikey, filename, filesize, mimetype, security, storage, options = {}, intelligent)
@@ -51,23 +52,21 @@ module MultipartUploadUtils
       filename: filename,
       mimetype: mimetype,
       size: filesize,
-      store_location: storage,
-      file: Tempfile.new(filename),
-      multipart: intelligent
+      store: { location: storage },
+      fii: intelligent
     }
 
-    options = multipart_options(options)
-    params = params.merge!(options) if options
+    params[:store].merge!(options) if options
 
     unless security.nil?
       params[:policy] = security.policy
       params[:signature] = security.signature
     end
 
-    response = Typhoeus.post(
-      FilestackConfig::MULTIPART_START_URL, body: params,
-                                            headers: FilestackConfig::HEADERS
-    )
+    response = Typhoeus.post(FilestackConfig.multipart_start_url,
+                             body: params.to_json,
+                             headers: FilestackConfig::HEADERS)
+
     if response.code == 200
       JSON.parse(response.body)
     else
@@ -79,22 +78,21 @@ module MultipartUploadUtils
   #
   # @param [String]             apikey         Filestack API key
   # @param [String]             filename       Name of incoming file
-  # @param [String]             filepath       Local path to file
   # @param [Int]                filesize       Size of incoming file
   # @param [Typhoeus::Response]  start_response Response body from
   #                                            multipart_start
+  # @param [String]             storage        Default storage to be used for uploads
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
   #
   # @return [Array]
-  def create_upload_jobs(apikey, filename, filepath, filesize, start_response, storage, options)
+  def create_upload_jobs(apikey, filename, filesize, start_response, storage, options)
     jobs = []
     part = 1
     seek_point = 0
     while seek_point < filesize
       part_info = {
-        seek: seek_point,
-        filepath: filepath,
+        seek_point: seek_point,
         filename: filename,
         apikey: apikey,
         part: part,
@@ -104,10 +102,10 @@ module MultipartUploadUtils
         upload_id: start_response['upload_id'],
         location_url: start_response['location_url'],
         start_response: start_response,
-        store_location: storage
+        store: { location: storage },
       }
-      options = multipart_options(options)
-      part_info = part_info.merge!(options) if options
+
+      part_info[:store].merge!(options) if options
 
       if seek_point + FilestackConfig::DEFAULT_CHUNK_SIZE > filesize
         size = filesize - (seek_point)
@@ -128,16 +126,17 @@ module MultipartUploadUtils
   # @param [Hash]               job            Hash of options needed
   #                                            to upload a chunk
   # @param [String]             apikey         Filestack API key
-  # @param [String]             location_url   Location url given back
+  # @param [String]             filepath       Location url given back
   #                                            from endpoint
-  # @param [String]             filepath       Local path to file
+  # @param [StringIO]           io             The IO object
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk(job, apikey, filepath, options)
-    file = File.open(filepath)
-    file.seek(job[:seek])
+  def upload_chunk(job, apikey, filepath, io, options, storage)
+    file = filepath ? File.open(filepath) : io
+    file.seek(job[:seek_point])
     chunk = file.read(FilestackConfig::DEFAULT_CHUNK_SIZE)
 
     md5 = Digest::MD5.new
@@ -150,14 +149,13 @@ module MultipartUploadUtils
       uri: job[:uri],
       region: job[:region],
       upload_id: job[:upload_id],
-      store_location: job[:store_location],
-      file: Tempfile.new(job[:filename])
+      store: { location: storage },
     }
     data = data.merge!(options) if options
-    fs_response = Typhoeus.post(
-      FilestackConfig::MULTIPART_UPLOAD_URL, body: data,
-                                             headers: FilestackConfig::HEADERS
-    ).body
+
+    fs_response = Typhoeus.post(FilestackConfig.multipart_upload_url(job[:location_url]),
+                                body: data.to_json,
+                                headers: FilestackConfig::HEADERS).body
     fs_response = JSON.parse(fs_response)
     Typhoeus.put(
       fs_response['url'], headers: fs_response['headers'], body: chunk
@@ -170,19 +168,20 @@ module MultipartUploadUtils
   # @param [String]             filepath       Local path to file
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
   #
   # @return [Array]                            Array of parts/etags strings
-  def run_uploads(jobs, apikey, filepath, options)
+  def run_uploads(jobs, apikey, filepath, io, options, storage)
     bar = ProgressBar.new(jobs.length)
     results = Parallel.map(jobs, in_threads: 4) do |job|
       response = upload_chunk(
-        job, apikey, filepath, options
+        job, apikey, filepath, io, options, storage
       )
       if response.code == 200
         bar.increment!
         part = job[:part]
         etag = response.headers[:etag]
-        "#{part}:#{etag}"
+        { part_number: part, etag: etag }
       end
     end
     results
@@ -202,6 +201,8 @@ module MultipartUploadUtils
   #                                             part numbers
   # @param [Hash]               options         User-defined options for
   #                                             multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
+  # @param [Boolean]            intelligent     Upload file using Filestack Intelligent Ingestion
   #
   # @return [Typhoeus::Response]
   def multipart_complete(apikey, filename, filesize, mimetype, start_response, parts_and_etags, options, storage, intelligent = false)
@@ -213,52 +214,53 @@ module MultipartUploadUtils
       filename: filename,
       size: filesize,
       mimetype: mimetype,
-      store_location: storage,
-      file: Tempfile.new(filename)
+      store: { location: storage },
     }
-    options = multipart_options(options)
-    data.merge!(options) if options
-    data.merge!(intelligent ? { multipart: intelligent } : { parts: parts_and_etags.join(';') })
+    data[:store].merge!(options) if options
+    data.merge!(intelligent ? { fii: intelligent } : { parts: parts_and_etags })
 
-    Typhoeus.post(
-      FilestackConfig::MULTIPART_COMPLETE_URL, body: data,
-                                               headers: FilestackConfig::HEADERS
-    )
+    Typhoeus.post(FilestackConfig.multipart_complete_url(start_response['location_url']),
+                  body: data.to_json,
+                  headers: FilestackConfig::HEADERS)
   end
 
   # Run entire multipart process through with file and options
   #
   # @param [String]             apikey          Filestack API key
   # @param [String]             filename        Name of incoming file
+  # @param [StringIO]           io              The IO object
   # @param [FilestackSecurity]  security        Security object with
   #                                             policy/signature
   # @param [Hash]               options         User-defined options for
   #                                             multipart uploads
+  # @param [String]             storage         Default storage to be used for uploads
+  # @param [Boolean]            intelligent     Upload file using Filestack Intelligent Ingestion
   #
   # @return [Hash]
-  def multipart_upload(apikey, filepath, security, options, timeout, storage, intelligent: false)
-    filename, filesize, mimetype = get_file_info(filepath)
+  def multipart_upload(apikey, filepath, io, security, options, timeout, storage, intelligent = false)
+    filename, filesize, mimetype = if filepath
+                                    get_file_attributes(filepath, options)
+                                   else
+                                    get_io_attributes(io, options)
+                                   end
+
     start_response = multipart_start(
       apikey, filename, filesize, mimetype, security, storage, options, intelligent
     )
 
-    unless start_response['upload_type'].nil?
-      intelligent_enabled = ((start_response['upload_type'].include? 'intelligent_ingestion')) && intelligent
-    end
-
     jobs = create_upload_jobs(
-      apikey, filename, filepath, filesize, start_response, storage, options
+      apikey, filename, filesize, start_response, storage, options
     )
 
-    if intelligent_enabled
+    if intelligent
       state = IntelligentState.new
-      run_intelligent_upload_flow(jobs, state)
+      run_intelligent_upload_flow(jobs, filepath, io, state, storage)
       response_complete = multipart_complete(
         apikey, filename, filesize, mimetype,
         start_response, nil, options, storage, intelligent
       )
     else
-      parts_and_etags = run_uploads(jobs, apikey, filepath, options)
+      parts_and_etags = run_uploads(jobs, apikey, filepath, io, options, storage)
       response_complete = multipart_complete(
         apikey, filename, filesize, mimetype,
         start_response, parts_and_etags, options, storage

data/lib/filestack/utils/utils.rb

@@ -62,41 +62,51 @@ module UploadUtils
     )
   end
 
+  def build_store_task(options = {})
+    return 'store' if options.nil? || options.empty?
+    tasks = []
+    options.each do |key, value|
+      value = case key
+              when :workflows
+                [value.join('","')]
+              when :path
+                "\"#{value}\""
+              else
+                value
+              end
+      tasks.push("#{key}:#{value.to_s.downcase}")
+    end
+    "store=#{tasks.join(',')}"
+  end
+
   # Uploads to v1 REST API (for external URLs or if multipart is turned off)
   #
   # @param [String]             apikey         Filestack API key
-  # @param [String]             filepath       Local path to file
   # @param [String]             external_url   External URL to be uploaded
   # @param [FilestackSecurity]  security       Security object with
   #                                            policy/signature
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
-  # @param [String]             storage        Storage destination
-  #                                            (s3, rackspace, etc)
   # @return [Hash]
-  def send_upload(apikey, filepath: nil, external_url: nil, security: nil, options: nil, storage: 'S3')
-    data = if filepath
-             { fileUpload: File.open(filepath) }
-           else
-             { url: external_url }
-           end
-
-    # adds any user-defined upload options to request payload
-    data = data.merge!(options) unless options.nil?
-    base = "#{FilestackConfig::API_URL}/store/#{storage}?key=#{apikey}"
+  def send_upload(apikey, external_url = nil, security = nil, options = nil)
+    base = "#{FilestackConfig::CDN_URL}/#{apikey}/#{build_store_task(options)}"
 
     if security
       policy = security.policy
       signature = security.signature
-      base = "#{base}&signature=#{signature}&policy=#{policy}"
+      base = "#{base}/security=s:#{signature},p:#{policy}"
     end
 
-    response = Typhoeus.post(base, body: data, headers: FilestackConfig::HEADERS)
+    response = Typhoeus.post("#{base}/#{external_url}", headers: FilestackConfig::HEADERS)
 
     if response.code == 200
-      response_body = JSON.parse(response.body)
-      handle = response_body['url'].split('/').last
-      return { 'handle' => handle }
+      begin
+        response_body = JSON.parse(response.body)
+        handle = response_body['url'].split('/').last
+        return { 'handle' => handle }
+      rescue
+        raise response.body
+      end
     end
     raise response.body
   end
@@ -193,7 +203,7 @@ module IntelligentUtils
   # @param [IntelligentState]    state     An IntelligentState object
   #
   # @return [Array]
-  def run_intelligent_upload_flow(jobs, state)
+  def run_intelligent_upload_flow(jobs, filepath, io, state, storage)
     bar = ProgressBar.new(jobs.length)
     generator = create_intelligent_generator(jobs)
     working_offset = FilestackConfig::DEFAULT_OFFSET_SIZE
@@ -201,7 +211,7 @@ module IntelligentUtils
       batch = get_generator_batch(generator)
       # run parts
       Parallel.map(batch, in_threads: 4) do |part|
-        state = run_intelligent_uploads(part, state)
+        state = run_intelligent_uploads(part, filepath, io, state, storage)
         # condition: a chunk has failed but we have not reached the maximum retries
         while bad_state(state)
           # condition: timeout to S3, requiring offset size to be changed
@@ -213,7 +223,7 @@ module IntelligentUtils
             sleep(state.backoff)
           end
           state.add_retry
-          state = run_intelligent_uploads(part, state)
+          state = run_intelligent_uploads(part, filepath, io, state, storage)
         end
         raise "Upload has failed. Please try again later." unless state.ok
         bar.increment!
@@ -269,14 +279,14 @@ module IntelligentUtils
   #                                             multipart_start
   #
   # @return [Dict]
-  def chunk_job(job, state, apikey, filename, filepath, filesize, start_response)
+  def chunk_job(job, state, apikey, filename, filesize, start_response, storage)
     offset = 0
-    seek_point = job[:seek]
+    seek_point = job[:seek_point]
     chunk_list = []
+
     while (offset < FilestackConfig::DEFAULT_CHUNK_SIZE) && (seek_point + offset) < filesize
       chunk_list.push(
-        seek: seek_point,
-        filepath: filepath,
+        seek_point: seek_point,
         filename: filename,
         apikey: apikey,
         part: job[:part],
@@ -285,7 +295,7 @@ module IntelligentUtils
         region: start_response['region'],
         upload_id: start_response['upload_id'],
         location_url: start_response['location_url'],
-        store_location: job[:store_location],
+        store: { location: storage },
         offset: offset
       )
       offset += state.offset
@@ -300,15 +310,14 @@ module IntelligentUtils
   # @param [IntelligentState]  state     An IntelligentState object
   #
   # @return [IntelligentState]
-  def run_intelligent_uploads(part, state)
+  def run_intelligent_uploads(part, filepath, io, state, storage)
     failed = false
     chunks = chunk_job(
-      part, state, part[:apikey], part[:filename], part[:filepath],
-      part[:filesize], part[:start_response]
+      part, state, part[:apikey], part[:filename], part[:filesize], part[:start_response], storage
     )
     Parallel.map(chunks, in_threads: 3) do |chunk|
       begin
-        upload_chunk_intelligently(chunk, state, part[:apikey], part[:filepath], part[:options])
+        upload_chunk_intelligently(chunk, state, part[:apikey], filepath, io, part[:options], storage)
       rescue => e
         state.error_type = e.message
         failed = true
@@ -322,6 +331,7 @@ module IntelligentUtils
     else
       state.ok = true
     end
+
     commit_params = {
       apikey: part[:apikey],
       uri: part[:uri],
@@ -329,12 +339,14 @@ module IntelligentUtils
       upload_id: part[:upload_id],
       size: part[:filesize],
       part: part[:part],
-      location_url: part[:location_url],
-      store_location: part[:store_location],
-      file: Tempfile.new(part[:filename])
+      location_url: part[:start_response]['location_url'],
+      store: { location: storage }
     }
-    response = Typhoeus.post(FilestackConfig::MULTIPART_COMMIT_URL, body: commit_params,
-                                                                   headers: FilestackConfig::HEADERS)
+
+    response = Typhoeus.post(FilestackConfig.multipart_commit_url(commit_params[:location_url]),
+                             body: commit_params.to_json,
+                             headers: FilestackConfig::HEADERS)
+
     if response.code == 200
       state.reset
     else
@@ -354,9 +366,10 @@ module IntelligentUtils
   #                                             multipart uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk_intelligently(job, state, apikey, filepath, options)
-    file = File.open(filepath)
-    file.seek(job[:seek] + job[:offset])
+  def upload_chunk_intelligently(job, state, apikey, filepath, io, options, storage)
+    file = filepath ? File.open(filepath) : io
+    file.seek(job[:seek_point] + job[:offset])
+
     chunk = file.read(state.offset)
     md5 = Digest::MD5.new
     md5 << chunk
@@ -368,17 +381,17 @@ module IntelligentUtils
       uri: job[:uri],
       region: job[:region],
       upload_id: job[:upload_id],
-      store_location: job[:store_location],
+      store: { location: storage },
       offset: job[:offset],
-      file: Tempfile.new(job[:filename]),
-      'multipart' => 'true'
+      fii: true
     }
 
     data = data.merge!(options) if options
-    fs_response = Typhoeus.post(
-      FilestackConfig::MULTIPART_UPLOAD_URL, body: data,
-                                             headers: FilestackConfig::HEADERS
-    )
+
+    fs_response = Typhoeus.post(FilestackConfig.multipart_upload_url(job[:location_url]),
+                                body: data.to_json,
+                                headers: FilestackConfig::HEADERS)
+
     # POST to multipart/upload
     begin
       unless fs_response.code == 200

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filestack
 version: !ruby/object:Gem::Version
-  version: 2.6.7
+  version: 2.9.1
 platform: ruby
 authors:
 - Filestack
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-04 00:00:00.000000000 Z
+date: 2021-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.3.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.3.9
 - !ruby/object:Gem::Dependency
   name: progress_bar
   requirement: !ruby/object:Gem::Requirement
@@ -201,7 +201,7 @@ homepage: https://github.com/filestack/filestack-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -216,9 +216,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Official Ruby SDK for the Filestack API
 test_files: []