uploadcare-ruby 2.1.1 → 3.1.0.pre.rc1

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

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