uploadcare-ruby 2.1.2 → 3.0.3

data/lib/uploadcare/api/group_api.rb

@@ -1,38 +0,0 @@
-module Uploadcare
-  module GroupApi
-
-    def group uuid_or_cdn_url
-      group = Uploadcare::Api::Group.new self, uuid_or_cdn_url
-    end
-
-
-    def create_group ary
-      unless ary.kind_of?(Array)
-        raise ArgumentError.new "You should send and array of files or valid UUIDs"
-      else
-        if ary.select {|f| !!f.kind_of?(Uploadcare::Api::File) }.any?
-          files = Hash.new
-          ary.each_with_index do |file, i|
-            files["files[#{i}]"] = file.uuid
-          end
-        elsif ary.select {|f| !!f.kind_of?(String) }.any?
-          files = Hash.new
-          ary.each_with_index do |uuid, i|
-            files["files[#{i}]"] = uuid
-          end
-        else
-          raise ArgumentError.new "You should send and array of files or valid UUIDs"
-        end
-      end
-
-
-      data = {
-        pub_key: @options[:public_key],
-      }
-
-      data.merge! files
-      post = @upload_connection.send :post, "/group/", data
-      group = Uploadcare::Api::Group.new self, post.body["id"], post.body
-    end
-  end
-end

data/lib/uploadcare/api/group_list_api.rb

@@ -1,17 +0,0 @@
-module Uploadcare
-  module GroupListApi
-    # 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

data/lib/uploadcare/api/project_api.rb

@@ -1,9 +0,0 @@
-require "uri"
-
-module Uploadcare
-  module ProjectApi
-    def project
-      @project ||= Uploadcare::Api::Project.new self 
-    end
-  end
-end

data/lib/uploadcare/api/raw_api.rb

@@ -1,38 +0,0 @@
-require 'json'
-
-module Uploadcare
-  module RawApi
-    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
-      response.body
-    end
-    alias_method :api_request, :request
-
-    # request with GET verb
-    def get(path = '/files/', params = {})
-      request :get, path, params
-    end
-
-    # request with POST verb
-    def post(path = '/files/', params = {})
-      request :post, path, params
-    end
-
-    # request with PUT verb
-    def put(path = '/files/', params = {})
-      request :put, path, params
-    end
-
-    # request with DELETE verb
-    def delete(path = '/files/', params = {})
-      request :delete, path, params
-    end
-  end
-end

data/lib/uploadcare/api/uploading_api.rb

@@ -1,71 +0,0 @@
-require_relative 'uploading_api/upload_params'
-
-module Uploadcare
-  module UploadingApi
-    # 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, "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)
-
-      response = @upload_connection.post('/base/', data)
-
-      response.body.values.map! { |f| Uploadcare::Api::File.new(self, f) }
-    end
-
-    # Upload single file
-    def upload_file(file, options = {})
-      upload_files([file], options).first
-    end
-    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_status = poll_upload_result(token)
-      if upload_status['status'] == 'error'
-        raise ArgumentError.new(upload_status['error'])
-      end
-
-      Uploadcare::Api::File.new(self, upload_status['file_id'])
-    end
-    alias_method :upload_from_url, :upload_url
-
-    private
-
-    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 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

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

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

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

@@ -1,49 +0,0 @@
-module Uploadcare
-  module Validators
-
-    class GroupListOptionsValidator
-      SUPPORTED_KEYS = [:from, :ordering, :limit]
-
-      def initialize(options)
-        @options = options
-      end
-
-      def validate
-        check_for_unsupported_keys(@options)
-
-        validate_limit(@options[:limit])
-        validate_ordering(@options[:ordering])
-        validate_from(@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(ordering)
-        return if !ordering || ordering =~ /^-?datetime_created$/
-        error("Unknown value for :ordering option: #{ordering.inspect}")
-      end
-
-      def validate_from(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, "\
-          "#{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 error(message)
-        raise ArgumentError, message
-      end
-    end
-
-  end
-end

data/lib/uploadcare/errors/errors.rb

@@ -1,64 +0,0 @@
-module Uploadcare
-  class Error < ::StandardError
-
-    def self.define_error code, klass, message
-      class_eval <<-EOD
-        class #{klass} < self
-          def initialize( message = nil )
-            super( message || "HTTP #{code} - #{message}" )
-          end
-        end
-      EOD
-    end
-
-    def self.errors
-      @errors ||= {
-        400 => Uploadcare::Error::RequestError::BadRequest,
-        401 => Uploadcare::Error::RequestError::Unauthorized,
-        403 => Uploadcare::Error::RequestError::Forbidden,
-        404 => Uploadcare::Error::RequestError::NotFound,
-        406 => Uploadcare::Error::RequestError::NotAcceptable,
-        408 => Uploadcare::Error::RequestError::RequestTimeout,
-        422 => Uploadcare::Error::RequestError::UnprocessableEntity,
-        429 => Uploadcare::Error::RequestError::TooManyRequests,
-        500 => Uploadcare::Error::ServerError::InternalServerError,
-        502 => Uploadcare::Error::ServerError::BadGateway,
-        503 => Uploadcare::Error::ServerError::ServiceUnavailable,
-        504 => Uploadcare::Error::ServerError::GatewayTimeout,
-      }
-    end
-
-
-    # Overall service error so you could escape it no matter what code is return
-
-    # all 4xx error
-    class RequestError < self;
-      def initialize( message = nil )
-        super( message || "HTTP 4xx - a request error occured." )
-      end
-
-      define_error 400, "BadRequest", "the request cannot be fulfilled due to bad syntax."
-      define_error 401, "Unauthorized", "authentication is required and has failed or has not yet been provided."
-      define_error 403, "Forbidden", "the request was a valid request, but the server is refusing to respond to it."
-      define_error 404, "NotFound", "the requested resource could not be found."
-      define_error 406, "NotAcceptable", "the requested resource is only capable of generating content"
-      define_error 408, "RequestTimeout", "the server timed out waiting for the request."
-      define_error 422, "UnprocessableEntity", "the request was well-formed but was unable to be followed due to semantic errors."
-      define_error 429, "TooManyRequests", "too many requests in a given amount of time."
-    end
-
-    # all 5xx error
-    class ServerError < self;
-      def initialize( message = nil )
-        super( message || "HTTP 5xx - a server error occured." )
-      end
-
-      define_error 500, "InternalServerError", "some error occured on server."
-      define_error 502, "BadGateway", "received an invalid response from the upstream server."
-      define_error 503, "ServiceUnavailable", "the server is currently unavailable."
-      define_error 504, "GatewayTimeout", "the server did not receive a timely response from the upstream server."
-    end
-
-    # specific error
-  end
-end

data/lib/uploadcare/resources/file.rb

@@ -1,164 +0,0 @@
-require 'ostruct'
-
-module Uploadcare
-  class Api
-    class File < OpenStruct
-      def initialize api, uuid_or_cdn_url, data=nil
-        result = Uploadcare::Parser.parse_file_string uuid_or_cdn_url
-
-        file = {uuid: result.uuid, operations: result.operations}
-
-        @api = api
-
-        super file
-
-        set_data(data) if data
-      end
-
-      def cdn_url add_operations=false
-        if add_operations
-          cdn_url_with_operations
-        else
-          cdn_url_without_operations
-        end
-      end
-      alias_method :public_url, :cdn_url
-
-
-      def cdn_url_without_operations
-        @api.options[:static_url_base] + "/#{@table[:uuid]}/"
-      end
-      alias_method :public_url_without_operations, :cdn_url_without_operations
-
-
-      def cdn_url_with_operations
-        url = cdn_url_without_operations
-        unless operations.empty?
-          ops = operations.join("/-/")
-          url = url + "-/#{ops}/"
-        end
-        url
-      end
-      alias_method :public_url_with_operations, :cdn_url_with_operations
-
-
-      def load_data
-        load_data! unless is_loaded?
-        self
-      end
-      alias_method :load, :load_data
-
-      def load_data!
-        data = @api.get "/files/#{uuid}/"
-        set_data(data)
-
-        self
-      end
-      alias_method :load!, :load_data!
-
-      def is_loaded?
-        !send(:datetime_uploaded).nil?
-      end
-      alias_method :loaded?, :is_loaded?
-
-
-      def store
-        data = @api.put "/files/#{uuid}/storage/"
-        set_data data
-        self
-      end
-
-      # nil is returning if there is no way to say for sure
-      def is_stored?
-        return nil unless is_loaded?
-        !send(:datetime_stored).nil?
-      end
-      alias_method :stored?, :is_stored?
-
-
-      def delete
-        data = @api.delete "/files/#{uuid}/storage/"
-        set_data data
-        self
-      end
-
-      # nil is returning if there is no way to say for sure
-      def is_deleted?
-        return nil unless is_loaded?
-        !send(:datetime_removed).nil?
-      end
-      alias_method :deleted?, :is_deleted?
-      alias_method :removed?, :is_deleted?
-      alias_method :is_removed?, :is_deleted?
-
-
-      # copy file to target location
-      # note what file copied with operations
-      def copy with_operations=true, target=nil
-        warn "[DEPRECATION] `copy` is deprecated and will be removed in "\
-          "version 3.0. Please use `internal_copy` or `external_copy` instead."
-        data = Hash.new
-        data[:target] = target if target
-        data[:source] = self.cdn_url_with_operations if with_operations
-        data[:source] = self.cdn_url_without_operations unless with_operations
-
-        @api.post "/files/", data
-      end
-
-      # Create a copy of the file in a default storage
-      def internal_copy(options={})
-        data = {
-          source: cdn_url(!options.fetch(:strip_operations){ false }),
-          store: options.fetch(:store){ nil }
-        }.reject{|_,v| v.nil?}
-
-        @api.post "/files/", data
-      end
-
-      # Copy file to a custom storage
-      def external_copy(target, options={})
-        data = {
-          source: cdn_url(!options.fetch(:strip_operations){ false }),
-          target: target,
-          pattern: options.fetch(:pattern){ nil },
-          make_public: options.fetch(:make_public){ nil },
-        }.reject{|_,v| v.nil?}
-
-        @api.post "/files/", data
-      end
-
-
-      # Datetime methods
-      # practicly try and parse the string to date objects
-      ["original", "uploaded", "stored", "removed"].each do |dt|
-        define_method "datetime_#{dt}" do
-          date = @table["datetime_#{dt}".to_sym]
-          if date.is_a?(String)
-            begin
-              parsed = DateTime.parse(date)
-              self.send("datetime_#{dt}=", parsed)
-              parsed
-            rescue Exception => e
-              date
-            end
-          else
-            date
-          end
-        end
-      end
-      alias_method :datetime_deleted, :datetime_removed
-
-
-      private
-        def set_data data
-          if data.respond_to? :each
-            data.each do |key, value|
-              self.send "#{key}=", value
-            end
-          else
-            self.data = data
-          end
-        end
-    end
-  end
-end