uploadcare-ruby 1.2.2 → 3.0.5

data/lib/uploadcare/api/uploading_api.rb

@@ -1,110 +0,0 @@
-require "uri"
-require 'mime/types'
-
-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)
-
-      else
-        raise ArgumentError.new "you should give File object, array of files or valid url string"
-      end
-    end
-
-
-    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]}
-
-      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 }
-    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
-    end
-    
-    # create file is the same as uplaod file
-    alias_method :create_file, :upload_file
-
-
-    #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
-      end
-      
-      raise ArgumentError.new(response['error']) if response['status'] == 'error'
-      uuid = response['file_id']
-      Uploadcare::Api::File.new self, uuid
-    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 extract_mime_type file
-        types = MIME::Types.of(file.path)
-        types[0].content_type
-      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

data/lib/uploadcare/resources/file_list.rb

@@ -1,41 +0,0 @@
-require 'ostruct'
-
-module Uploadcare
-  class Api
-    class FileList < OpenStruct
-      def initialize api, data
-        @api = api
-
-        unless data["results"].nil?
-          data["results"].map! do |file| 
-            Uploadcare::Api::File.new @api, file["uuid"], file
-          end
-        end
-
-        super data
-      end
-
-      # Array-like behavior
-      def [] index
-        results[index] if defined?(:results)
-      end
-
-      def to_a
-        results if defined?(:results)
-      end
-
-      # List navigation
-      def next_page
-        @api.file_list(page+1) unless send(:next).nil?
-      end
-
-      def go_to index
-        @api.file_list(index) unless index > pages
-      end
-
-      def previous_page
-        @api.file_list(page-1) unless previous.nil?
-      end
-    end
-  end
-end

data/lib/uploadcare/resources/group.rb

@@ -1,115 +0,0 @@
-require 'ostruct'
-
-module Uploadcare
-  class Api
-    class Group < OpenStruct
-      def initialize api, uuid_or_cdn_url, data=nil
-        result = Uploadcare::Parser.parse_group_string(uuid_or_cdn_url) 
-
-        @api = api
-        group = {uuid: result.uuid, files_count: result.count}
-        super group
-
-        # if data is suplide - just pass it to builder.
-        set_data(data) if data
-      end
-
-      def cdn_url
-        @api.options[:static_url_base] + "/#{uuid}/"
-      end
-
-      def file_cdn_url index=0
-        raise ArgumentError.new "The index was given is greater than files count in group." if index + 1 > files_count
-        cdn_url + "nth/#{index}/"
-      end
-
-      # Loading logic
-      def is_loaded?
-        !send(:files).nil?
-      end
-      alias_method :loaded?, :is_loaded? 
-
-      def load_data
-        unless is_loaded?
-          load_data!
-        end
-        self
-      end
-      alias_method :load, :load_data
-
-      def load_data!
-        data = @api.get "/groups/#{uuid}/"
-        set_data data
-
-        self
-      end
-      alias_method :load!, :load_data!
-
-      # Store group (and all files in group)
-      def store
-        unless is_stored?
-          store!
-        end
-        self
-      end
-
-      def store!
-        data = @api.put "/groups/#{uuid}/storage/"
-        set_data(data)
-        self
-      end
-
-      def is_stored?
-        return nil unless is_loaded?
-        !send(:datetime_stored).nil?
-      end
-      alias_method :stored?, :is_stored?
-
-
-      ["created", "stored"].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
-
-
-      private
-        def set_data data
-          data = map_files(data) unless data["files"].nil?
-
-          if data.respond_to? (:each)
-            data.each do |k, v|
-              self.send "#{k}=", v
-            end
-          end
-
-          @is_loaded = true
-        end
-
-        # map files (hashes basicly) to
-        # actual File objects
-        def map_files data
-          data["files"].map! do |file|
-            unless file.nil?
-              Uploadcare::Api::File.new(@api, file["uuid"], file)
-            else
-              file
-            end
-          end
-
-          data
-        end
-    end
-  end
-end