uploadcare-ruby 2.1.2 → 3.1.0

data/Rakefile

@@ -1,8 +1,8 @@
-#!/usr/bin/env rake
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-require 'coveralls/rake/task'
 
-task :default => :spec
-RSpec::Core::RakeTask.new
-Coveralls::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'uploadcare/ruby'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/uploadcare/api/api.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Gem.find_files('client/**/*.rb').each { |path| require path }
+Gem.find_files('entity/**/*.rb').each { |path| require path }
+
+module Uploadcare
+  # End-user interface
+  #
+  # It delegates methods to other classes:
+  # * To class methods of Entity objects
+  # * To instance methods of Client objects
+  # @see Uploadcare::Entity
+  # @see Uploadcare::Client
+  class Api
+    extend Forwardable
+    include Entity
+
+    def_delegator File, :file
+    def_delegators FileList, :file_list, :store_files, :delete_files
+    def_delegators Group, :group
+    def_delegators Project, :project
+    def_delegators Uploader, :upload, :upload_files, :upload_url
+    def_delegators Webhook, :create_webhook, :list_webhooks, :delete_webhook, :update_webhook
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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
+        API_VERSION_HEADER_VALUE = 'application/vnd.uploadcare-v0.5+json'
+
+        def headers
+          {
+            '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
+          extract_result(body)
+        end
+
+        def extract_result(response_body)
+          return if response_body.empty?
+
+          parsed_body = JSON.parse(response_body, symbolize_names: true)
+          errors = parsed_body[:error] || parsed_body[:problems]
+          return Dry::Monads::Failure(errors) unless errors.nil? || errors.empty?
+
+          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|
+              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,41 @@
+# frozen_string_literal: true
+
+require 'client/conversion/base_conversion_client'
+require 'param/conversion/document/processing_job_url_builder'
+
+module Uploadcare
+  module Client
+    module Conversion
+      # This is client for document conversion
+      #
+      # @see https://uploadcare.com/api-refs/rest-api/v0.6.0/#operation/documentConvert
+      class DocumentConversionClient < BaseConversionClient
+        def convert_many(
+          arr,
+          options = {},
+          url_builder_class = Param::Conversion::Document::ProcessingJobUrlBuilder
+        )
+          send_convert_request(arr, options, url_builder_class)
+        end
+
+        def get_conversion_status(token)
+          get(uri: "/convert/document/status/#{token}/")
+        end
+
+        private
+
+        def convert_uri
+          '/convert/document/'
+        end
+
+        def build_paths_body(params)
+          {
+            uuid: params[:uuid],
+            format: params[:format],
+            page: params[:page]
+          }.compact
+        end
+      end
+    end
+  end
+end

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

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

data/lib/uploadcare/client/file_client.rb

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

data/lib/uploadcare/client/file_list_client.rb

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

data/lib/uploadcare/client/group_client.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'upload_client'
+
+module Uploadcare
+  module Client
+    # Groups serve a purpose of better organizing files in your Uploadcare projects.
+    # You can create one from a set of files by using their UUIDs.
+    # @see https://uploadcare.com/docs/api_reference/upload/groups/
+    class GroupClient < UploadClient
+      # Create files group from a set of files by using their UUIDs.
+      # @see https://uploadcare.com/api-refs/upload-api/#operation/createFilesGroup
+      def create(file_list, **options)
+        body_hash = group_body_hash(file_list, **options)
+        body = HTTP::FormData::Multipart.new(body_hash)
+        post(path: 'group/',
+             headers: { 'Content-Type': body.content_type },
+             body: body)
+      end
+
+      # Get group info
+      # @see https://uploadcare.com/api-refs/upload-api/#operation/filesGroupInfo
+      def info(group_id)
+        get(path: 'group/info/', params: { 'pub_key': Uploadcare.config.public_key, 'group_id': group_id })
+      end
+
+      private
+
+      def file_params(file_ids)
+        ids = (0...file_ids.size).map { |i| "files[#{i}]" }
+        ids.zip(file_ids).to_h
+      end
+
+      def group_body_hash(file_list, **options)
+        { pub_key: Uploadcare.config.public_key }.merge(file_params(parse_file_list(file_list))).merge(**options)
+      end
+
+      # API accepts only list of ids, but some users may want to upload list of files
+      # @return [Array] of [String]
+      def parse_file_list(file_list)
+        file_list.map { |file| file.methods.include?(:uuid) ? file.uuid : file }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'parallel'
+require 'api_struct'
+
+module Uploadcare
+  module Client
+    module MultipartUpload
+      # This class splits file into chunks of set chunk_size
+      # and uploads them into cloud storage.
+      # Used for multipart uploads
+      # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload/paths/https:~1~1uploadcare.s3-accelerate.amazonaws.com~1%3C%3Cpresigned-url%3E/put
+      class ChunksClient < ApiStruct::Client
+        CHUNK_SIZE = 5_242_880
+
+        # In multiple threads, split file into chunks and upload those chunks into respective Amazon links
+        # @param object [File]
+        # @param links [Array] of strings; by default list of Amazon storage urls
+        def self.upload_chunks(object, links)
+          Parallel.each(0...links.count, in_threads: Uploadcare.config.upload_threads) do |link_id|
+            offset = link_id * CHUNK_SIZE
+            chunk = IO.read(object, CHUNK_SIZE, offset)
+            new.upload_chunk(chunk, links[link_id])
+            next unless block_given?
+
+            yield(
+              chunk_size: CHUNK_SIZE,
+              object: object,
+              offset: offset,
+              link_id: link_id,
+              links: links,
+              links_count: links.count
+            )
+          end
+        end
+
+        def api_root
+          ''
+        end
+
+        def headers
+          {}
+        end
+
+        def upload_chunk(chunk, link)
+          put(path: link, body: chunk, headers: { 'Content-Type': 'application/octet-stream' })
+        end
+
+        private
+
+        def default_params
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/uploadcare/client/multipart_upload_client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'client/multipart_upload/chunks_client'
+require_relative 'upload_client'
+
+module Uploadcare
+  module Client
+    # Client for multipart uploads
+    #
+    # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload
+    class MultipartUploaderClient < UploadClient
+      include MultipartUpload
+
+      # Upload a big file by splitting it into parts and sending those parts into assigned buckets
+      # object should be File
+      def upload(object, 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.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(form_data_for(object))
+        )
+        post(path: 'multipart/start/',
+             headers: { 'Content-Type': body.content_type },
+             body: body)
+      end
+
+      # When every chunk is uploaded, ask Uploadcare server to finish the upload
+      def upload_complete(uuid)
+        body = HTTP::FormData::Multipart.new(
+          {
+            UPLOADCARE_PUB_KEY: Uploadcare.config.public_key,
+            uuid: uuid
+          }
+        )
+        post(path: 'multipart/complete/', body: body, headers: { 'Content-Type': body.content_type })
+      end
+
+      private
+
+      def form_data_for(file)
+        form_data_file = super(file)
+        {
+          filename: form_data_file.filename,
+          size: form_data_file.size,
+          content_type: form_data_file.content_type
+        }
+      end
+
+      alias api_struct_post post
+      def post(**args)
+        handle_throttling { api_struct_post(**args) }
+      end
+    end
+  end
+end

data/lib/uploadcare/client/project_client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Client
+    # API client for getting project info
+    # @see https://uploadcare.com/docs/api_reference/rest/handling_projects/
+    class ProjectClient < RestClient
+      # get information about current project
+      # current project is determined by public and private key combination
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Project
+      def show
+        get(uri: '/project/')
+      end
+
+      alias project show
+    end
+  end
+end

data/lib/uploadcare/client/rest_client.rb

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

data/lib/uploadcare/client/rest_group_client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'rest_client'
+
+module Uploadcare
+  module Client
+    # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Group/paths/~1groups~1%3Cuuid%3E~1storage~1/put
+    class RestGroupClient < RestClient
+      # store all files in a group
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Group/paths/~1groups~1%3Cuuid%3E~1storage~1/put
+      def store(uuid)
+        put(uri: "/groups/#{uuid}/storage/")
+      end
+
+      # 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)}"
+        get(uri: "/groups/#{query}")
+      end
+    end
+  end
+end

data/lib/uploadcare/client/upload_client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'api_struct'
+require 'param/user_agent'
+require 'uploadcare/concern/error_handler'
+require 'uploadcare/concern/throttle_handler'
+
+module Uploadcare
+  module Client
+    # @abstract
+    #
+    # Headers and helper methods for clients working with upload API
+    # @see https://uploadcare.com/docs/api_reference/upload/
+    class UploadClient < ApiStruct::Client
+      include Concerns::ErrorHandler
+      include Concerns::ThrottleHandler
+      include Exception
+
+      def api_root
+        Uploadcare.config.upload_api_root
+      end
+
+      def headers
+        {
+          'User-Agent': Uploadcare::Param::UserAgent.call
+        }
+      end
+
+      private
+
+      def form_data_for(file)
+        filename = file.original_filename if file.respond_to?(:original_filename)
+        mime_type = 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
+    end
+  end
+end