uploadcare-ruby 2.1.2 → 3.1.0

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/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/api.rb

@@ -1,26 +0,0 @@
-require 'json'
-require 'ostruct'
-Dir[File.dirname(__FILE__) + '/utils/*.rb'].each {|file| require file }
-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 }
-
-
-module Uploadcare
-  class Api
-    attr_reader :options
-
-    include Uploadcare::RawApi
-    include Uploadcare::UploadingApi
-    include Uploadcare::FileApi
-    include Uploadcare::ProjectApi
-    include Uploadcare::FileListApi
-    include Uploadcare::GroupApi
-    include Uploadcare::GroupListApi
-    include Uploadcare::FileStorageApi
-  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,14 +0,0 @@
-require 'ostruct'
-require_relative 'resource_list'
-
-module Uploadcare
-  class Api
-    class FileList < ResourceList
-      private
-
-      def to_resource(api, file_data)
-        Uploadcare::Api::File.new(api, file_data['uuid'], file_data)
-      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

data/lib/uploadcare/resources/group_list.rb

@@ -1,14 +0,0 @@
-require 'ostruct'
-require_relative 'resource_list'
-
-module Uploadcare
-  class Api
-    class GroupList < ResourceList
-      private
-
-      def to_resource(api, group_data)
-        Uploadcare::Api::Group.new api, group_data["id"], group_data
-      end
-    end
-  end
-end

data/lib/uploadcare/resources/project.rb

@@ -1,13 +0,0 @@
-require 'ostruct'
-
-module Uploadcare
-  class Api
-    class Project < OpenStruct
-      def initialize api
-        @api = api
-        data = @api.get "/project/"
-        super data
-      end
-    end
-  end
-end

data/lib/uploadcare/resources/resource_list.rb

@@ -1,83 +0,0 @@
-require 'ostruct'
-
-module Uploadcare
-  class Api
-    class ResourceList
-      include Enumerable
-
-      extend Forwardable
-      def_delegator :@data, :meta
-      def_delegator :@data, :objects
-
-      attr_reader :options
-
-      def initialize(api, data, options)
-        @api = api
-        @data = build_data(data)
-        @options = options.dup.freeze
-      end
-
-      def [](index)
-        first(index + 1).last
-      end
-
-      def each
-        return enum_for(:each) unless block_given?
-
-        resource_enumerator.each { |object| yield object }
-
-        self
-      end
-
-      def total
-        meta['total']
-      end
-
-      def loaded
-        objects.size
-      end
-
-      def fully_loaded?
-        meta['next'].nil?
-      end
-
-      private
-
-      attr_reader :api
-
-      def build_data(data_hash)
-        OpenStruct.new(
-          meta: data_hash.reject{|k, _| k == 'results'}.freeze,
-          objects: data_hash['results'].map{|object| to_resource(api, object)}
-        )
-      end
-
-      def get_next_page
-        return nil if fully_loaded?
-
-        next_page = build_data(api.get(@data.meta['next']))
-
-        @data = OpenStruct.new(
-          meta: next_page.meta,
-          objects: objects + next_page.objects
-        )
-
-        next_page
-      end
-
-      def to_resource(*args)
-        raise NotImplementedError, 'You must define this method in a child class'
-      end
-
-      def resource_enumerator
-        Enumerator.new do |yielder|
-          objects.each { |obj| yielder << obj }
-
-          while next_page = get_next_page do
-            next_page.objects.each { |obj| yielder << obj }
-          end
-        end
-      end
-    end
-  end
-end