uploadcare-ruby 1.2.2 → 2.0.0

data/lib/uploadcare.rb

@@ -2,36 +2,30 @@ require 'faraday'
 require 'json'
 require 'ostruct'
 
-require 'uploadcare/api'
-require 'uploadcare/version'
+require_relative 'uploadcare/api'
+require_relative 'uploadcare/version'
 
 module Uploadcare
   DEFAULT_SETTINGS = {
-      public_key: 'demopublickey',
-      private_key: 'demoprivatekey',
-      upload_url_base: 'https://upload.uploadcare.com',
-      api_url_base: 'https://api.uploadcare.com',
-      static_url_base: 'https://ucarecdn.com',
-      api_version: '0.3',
-      cache_files: true,
-      auth_scheme: :secure
-    }
+    public_key: 'demopublickey',
+    private_key: 'demoprivatekey',
+    upload_url_base: 'https://upload.uploadcare.com',
+    api_url_base: 'https://api.uploadcare.com',
+    static_url_base: 'https://ucarecdn.com',
+    api_version: '0.5',
+    cache_files: true,
+    autostore: :auto,
+    auth_scheme: :secure,
+  }
+
+  USER_AGENT = "uploadcare-ruby/#{Gem.ruby_version}/#{Uploadcare::VERSION}"
 
   def self.default_settings
     DEFAULT_SETTINGS
   end
 
   def self.user_agent(options={})
-    warn '[DEPRECATION] `Uploadcare::user_agent` method is deprecated and will be removed in version 3.0'
-    UserAgent.new.call(options)
-  end
-
-  def self.const_missing(name)
-    if name == :USER_AGENT
-      warn '[DEPRECATION] `Uploadcare::USER_AGENT` constant is deprecated and will be removed in version 3.0'
-      "uploadcare-ruby/#{Gem.ruby_version}/#{Uploadcare::VERSION}"
-    else
-      super
-    end
+    return options[:user_agent].to_s if options[:user_agent]
+    [USER_AGENT, options[:public_key]].join('/')
   end
 end

data/lib/uploadcare/api.rb

@@ -5,6 +5,7 @@ Dir[File.dirname(__FILE__) + '/errors/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/rest/middlewares/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/rest/connections/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/rest/auth/*.rb'].sort.each {|file| require file }
+Dir[File.dirname(__FILE__) + '/api/validators/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/api/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/resources/*.rb'].each {|file| require file }
 
@@ -20,5 +21,6 @@ module Uploadcare
     include Uploadcare::FileListApi
     include Uploadcare::GroupApi
     include Uploadcare::GroupListApi
+    include Uploadcare::FileStorageApi
   end
-end
+end

data/lib/uploadcare/api/file_list_api.rb

@@ -1,8 +1,19 @@
 module Uploadcare
   module FileListApi
-    def file_list page=1
-      data = get '/files/', {page: page}
-      list = Uploadcare::Api::FileList.new self, data
+    # Available options:
+    #
+    #   limit -- a number of objects retrieved per request. Default: 100
+    #   ordering -- sorting order of files in a list. Default: datetime_uploaded
+    #   from -- a starting point for filtering files.
+    #   stored -- true to include only stored files, false to exclude.
+    #   removed -- true to include only removed files, false to exclude. Default: false
+    #
+    # Documentation: http://uploadcare.com/documentation/rest/#file-files
+    def file_list options={}
+      Validators::FileListOptionsValidator.new(options).validate
+
+      data = get '/files/', options
+      Uploadcare::Api::FileList.new self, data, options
     end
   end
-end
+end

data/lib/uploadcare/api/file_storage_api.rb

@@ -0,0 +1,34 @@
+module Uploadcare
+  module FileStorageApi
+    MAX_BATCH_SIZE = 100
+    UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+
+    def store_files(objects)
+      if objects.size > MAX_BATCH_SIZE
+        raise ArgumentError, "Up to #{MAX_BATCH_SIZE} files are supported per request, #{objects.size} given"
+      end
+
+      put "/files/storage/", to_uuids(objects)
+    end
+
+    def delete_files(objects)
+      if objects.size > MAX_BATCH_SIZE
+        raise ArgumentError, "Up to #{MAX_BATCH_SIZE} files are supported per request, #{objects.size} given"
+      end
+
+      delete "/files/storage/", to_uuids(objects)
+    end
+
+    private
+
+    def to_uuids(objects)
+      objects.map do |object|
+        case object
+        when Uploadcare::Api::File then object.uuid
+        when UUID_REGEX then object
+        else raise(ArgumentError, "Unable to convert object to uuid: #{object}")
+        end
+      end
+    end
+  end
+end

data/lib/uploadcare/api/group_list_api.rb

@@ -1,8 +1,17 @@
 module Uploadcare
   module GroupListApi
-    def group_list from=nil, limit=nil
-      data = get '/groups/', {from: from, limit: limit}.reject{|_,v| v.nil?}
-      list = Uploadcare::Api::GroupList.new self, data
+    # Available options:
+    #
+    #   limit -- a number of objects retrieved per request. Default: 100
+    #   ordering -- sorting order of groups in a list. Default: datetime_creataed
+    #   from -- a starting point for filtering groups.
+    #
+    # Documentation: http://uploadcare.com/documentation/rest/#group-groups
+    def group_list options={}
+      Validators::GroupListOptionsValidator.new(options).validate
+
+      data = get '/groups/', options
+      list = Uploadcare::Api::GroupList.new self, data, options
     end
   end
-end
+end

data/lib/uploadcare/api/raw_api.rb

@@ -2,43 +2,37 @@ require 'json'
 
 module Uploadcare
   module RawApi
-
-    def initialize options={}
+    def initialize(options = {})
       @options = Uploadcare::default_settings.merge(options)
       @api_connection = Uploadcare::Connections::ApiConnection.new(@options)
       @upload_connection = Uploadcare::Connections::UploadConnection.new(@options)
     end
 
-
-    # basic request method 
-    def request method = :get, path = "/files/", params = {}
-      response = @api_connection.send method, path, params 
+    # basic request method
+    def request(method = :get, path = '/files/', params = {})
+      response = @api_connection.send method, path, params
       response.body
     end
     alias_method :api_request, :request
 
-
     # request with GET verb
-    def get path= "/files/", params={}
+    def get(path = '/files/', params = {})
       request :get, path, params
     end
 
-
     # request with POST verb
-    def post path= "/files/", params={}
-      request :post, path, params 
+    def post(path = '/files/', params = {})
+      request :post, path, params
     end
 
-
     # request with PUT verb
-    def put path= "/files/", params={}
+    def put(path = '/files/', params = {})
       request :put, path, params
     end
 
-
     # request with DELETE verb
-    def delete path= "/files/", params={}
+    def delete(path = '/files/', params = {})
       request :delete, path, params
     end
   end
-end
+end

data/lib/uploadcare/api/uploading_api.rb

@@ -1,110 +1,71 @@
-require "uri"
-require 'mime/types'
+require_relative 'uploading_api/upload_params'
 
 module Uploadcare
   module UploadingApi
-    # intelegent guess for file or url uploading
-    def upload object
-      # if object is file - uploading it as file
-      if object.kind_of?(File)
-        upload_file(object)
-
-      # if a string - try to upload as url
-      elsif object.kind_of?(String)
-        upload_url(object)
-
-      # array of files
-      elsif object.kind_of?(Array)
-        upload_files(object)
-
+    # intelegent guess for file or URL uploading
+    def upload(object, options = {})
+      case object
+      when File then upload_file(object, options)
+      when Array then upload_files(object, options)
+      # if object is a string, try to upload it as an URL
+      when String then upload_url(object, options)
       else
-        raise ArgumentError.new "you should give File object, array of files or valid url string"
+        raise ArgumentError, "Expected `object` to be an Uploadcare::Api::File, "\
+          "an Array or a valid URL string, received: `#{object}`"
       end
     end
 
+    # Upload multiple files
+    def upload_files(files, options = {})
+      data = upload_params(options).for_file_upload(files)
 
-    def upload_files files
-      raise ArgumentError.new "one or more of given files is not actually files" if files.select {|f| !f.kind_of?(File)}.any?
-
-      data = {UPLOADCARE_PUB_KEY: @options[:public_key]}
+      response = @upload_connection.post('/base/', data)
 
-      files.each_with_index do |file, i|
-        data["file[#{i}]"] = build_upload_io(file)
-      end
-
-      response = @upload_connection.send :post, '/base/', data
-      uuids = response.body
-
-      files = uuids.values.map! {|f| Uploadcare::Api::File.new self, f }
+      response.body.values.map! { |f| Uploadcare::Api::File.new(self, f) }
     end
 
-
-    # upload file to servise
-    def upload_file file
-      raise ArgumentError.new 'expecting File object' unless file.kind_of?(File)
-
-      response = @upload_connection.send :post, '/base/', {
-        UPLOADCARE_PUB_KEY: @options[:public_key],
-        file: build_upload_io(file)
-      }
-      
-      uuid = response.body["file"]
-
-      Uploadcare::Api::File.new self, uuid
+    # Upload single file
+    def upload_file(file, options = {})
+      upload_files([file], options).first
     end
-    
-    # create file is the same as uplaod file
     alias_method :create_file, :upload_file
 
+    # Upload from an URL
+    def upload_url(url, options = {})
+      params = upload_params(options).for_url_upload(url)
+      token = request_file_upload(params)
 
-    #upload from url
-    def upload_url url
-      uri = URI.parse(url)
-
-      raise ArgumentError.new 'invalid url was given' unless uri.kind_of?(URI::HTTP)
-      
-      token = get_token(url)
-
-      while !['success', 'error'].include?((response = get_status_response(token))['status'])
-        sleep 0.5
+      upload_status = poll_upload_result(token)
+      if upload_status['status'] == 'error'
+        raise ArgumentError.new(upload_status['error'])
       end
-      
-      raise ArgumentError.new(response['error']) if response['status'] == 'error'
-      uuid = response['file_id']
-      Uploadcare::Api::File.new self, uuid
+
+      Uploadcare::Api::File.new(self, upload_status['file_id'])
     end
     alias_method :upload_from_url, :upload_url
 
-
-
-
-    protected
-      # DEPRECATRED but still works
-      def upload_request method, path, params = {}
-        response = @upload_connection.send method, path, params
-      end
-
-      def build_upload_io file
-        Faraday::UploadIO.new file.path, extract_mime_type(file)
-      end
-
-
     private
-      def get_status_response token
-        response = @upload_connection.send :post, '/from_url/status/', {token: token}
-        response.body
-      end
-
 
-      def get_token url
-        response = @upload_connection.send :post, '/from_url/', { source_url: url, pub_key: @options[:public_key] }
-        token = response.body["token"]
-      end
+    def get_status_response(token)
+      response = @upload_connection.post('/from_url/status/', {token: token})
+      response.body
+    end
 
+    def request_file_upload(upload_params)
+      response = @upload_connection.post('/from_url/', upload_params)
+      token = response.body['token']
+    end
 
-      def extract_mime_type file
-        types = MIME::Types.of(file.path)
-        types[0].content_type
+    def poll_upload_result(token)
+      while true
+        response = get_status_response(token)
+        break(response) if ['success', 'error'].include?(response['status'])
+        sleep 0.5
       end
+    end
+
+    def upload_params(request_options)
+      UploadParams.new(@options, request_options)
+    end
   end
 end

data/lib/uploadcare/api/uploading_api/upload_params.rb

@@ -0,0 +1,72 @@
+require 'uri'
+require 'mime/types'
+
+module Uploadcare
+  module UploadingApi
+    class UploadParams
+      def initialize(global_options, request_options)
+        @global_options = global_options
+        @request_options = request_options
+      end
+
+      def for_url_upload(url)
+        {
+          source_url: parse_url(url),
+          pub_key: public_key,
+          store: store
+        }.reject { |k, v| v.nil? }
+      end
+
+      def for_file_upload(files)
+        {
+          UPLOADCARE_PUB_KEY: public_key,
+          UPLOADCARE_STORE: store
+        }.reject { |k, v| v.nil? }.merge(file_params(files))
+      end
+
+      private
+
+      attr_reader :global_options, :request_options
+
+      def public_key
+        global_options[:public_key]
+      end
+
+      def store
+        mapping = { true => 1, false => 0, auto: 'auto' }
+
+        global_value = global_options[:autostore]
+        per_request_value = request_options[:store]
+
+        mapping[per_request_value] || mapping[global_value]
+      end
+
+      def file_params(files)
+        Hash[files.map.with_index { |file, i| ["file[#{i}]", build_upload_io(file)] }]
+      end
+
+      def parse_url(url)
+        uri = URI.parse(url)
+
+        unless uri.is_a?(URI::HTTP) # will also be true for https
+          raise ArgumentError, 'invalid url was given'
+        end
+
+        uri
+      end
+
+      def build_upload_io(file)
+        unless file.is_a?(File)
+          raise ArgumentError, "expected File object, #{file} given"
+        end
+
+        Faraday::UploadIO.new file.path, extract_mime_type(file)
+      end
+
+      def extract_mime_type file
+        types = MIME::Types.of(file.path)
+        types[0].content_type
+      end
+    end
+  end
+end

data/lib/uploadcare/api/validators/file_list_options_validator.rb

@@ -0,0 +1,73 @@
+module Uploadcare
+  module Validators
+
+    class FileListOptionsValidator
+      SUPPORTED_KEYS = [:from, :ordering, :limit, :stored, :removed]
+
+      def initialize(options)
+        @options = options
+      end
+
+      def validate
+        check_for_unsupported_keys(@options)
+
+        validate_limit(@options[:limit])
+        validate_stored(@options[:stored])
+        validate_removed(@options[:removed])
+        validate_ordering_and_from(@options[:ordering], @options[:from])
+      end
+
+      private
+
+      def check_for_unsupported_keys(options)
+        unsupported_keys = options.keys.reject{|k,_| SUPPORTED_KEYS.include?(k)}
+        error("Unknown options: #{unsupported_keys}") if unsupported_keys.any?
+      end
+
+      def validate_ordering_and_from(ordering, from)
+        case ordering
+        when nil, /^-?datetime_uploaded$/
+          validate_from_as_date(from)
+        when /^-?size$/
+          validate_from_as_size(from)
+        else
+          error("Unknown value for :ordering option: #{ordering.inspect}")
+        end
+      end
+
+      def validate_from_as_date(from)
+        return if from.nil? || from.to_s =~ /^\d{4}-\d{2}-\d{2}T\d{2}.*/
+        error(":from value should be a DateTime or an iso8601 string when "\
+          "ordering is `datetime_uploaded` or `-datetime_uploaded`, "\
+          "#{from.inspect} given")
+      end
+
+      def validate_from_as_size(from)
+        return if from.nil? || (from.is_a?(Integer) && from >= 0)
+        error(":from value should be a positive integer when ordering is "\
+          "`size` or `-size`, #{from.inspect} given")
+      end
+
+      def validate_limit(limit)
+        return if limit.nil? || (limit.is_a?(Integer) && (1..1000).include?(limit))
+        error(":limit should be a positive integer from 1 to 1000, "\
+          "#{limit.inspect} given")
+      end
+
+      def validate_stored(stored)
+        return if [nil, true, false].include?(stored)
+        error(":stored can be true or false, #{stored.inspect} given")
+      end
+
+      def validate_removed(removed)
+        return if [nil, true, false].include?(removed)
+        error(":removed can be true or false, #{removed.inspect} given")
+      end
+
+      def error(message)
+        raise ArgumentError, message
+      end
+    end
+
+  end
+end