uploadcare-ruby 2.1.2 → 3.1.0

data/lib/uploadcare/rest/auth/auth.rb

@@ -1,31 +0,0 @@
-module Uploadcare
-  module Connections
-    module Auth
-
-      def self.strategy(options)
-        auth_scheme = options.fetch(:auth_scheme)
-
-        unless [:simple, :secure].include?(auth_scheme)
-          raise ArgumentError, "Unknown auth_scheme: '#{auth_scheme}'"
-        end
-
-        klass = const_get(auth_scheme.capitalize)
-        klass.new(options)
-      end
-
-      class Base
-        attr_reader :public_key, :private_key
-
-        def initialize(options)
-          @public_key = options.fetch(:public_key)
-          @private_key = options.fetch(:private_key)
-        end
-
-        def apply(env)
-          raise NotImplementedError
-        end
-      end
-
-    end
-  end
-end

data/lib/uploadcare/rest/auth/secure.rb

@@ -1,43 +0,0 @@
-require 'time'
-
-module Uploadcare
-  module Connections
-    module Auth
-      class Secure < Base
-
-        def apply(env)
-          date = Time.now.utc
-          headers(env, date).each{|k, v| env.request_headers[k] = v}
-          env
-        end
-
-        private
-
-        def headers(env, date)
-          {
-            "Date" => date.rfc2822,
-            "Authorization" => "Uploadcare #{public_key}:#{signature(env, date)}"
-          }
-        end
-
-        def signature(env, date)
-          sign_string = sign_string(env, date)
-          digest = OpenSSL::Digest.new('sha1')
-
-          OpenSSL::HMAC.hexdigest(digest, private_key, sign_string)
-        end
-
-        def sign_string(env, date)
-          verb = env.method.upcase.to_s
-          uri = env.url.request_uri
-          date_header = date.rfc2822
-          content_type = env.request_headers['Content-Type']
-          content_md5 = OpenSSL::Digest.new('md5').hexdigest(env.body || "")
-
-          [verb, content_md5, content_type, date_header, uri].join("\n")
-        end
-
-      end
-    end
-  end
-end

data/lib/uploadcare/rest/auth/simple.rb

@@ -1,16 +0,0 @@
-module Uploadcare
-  module Connections
-    module Auth
-      class Simple < Base
-
-        def apply(env)
-          auth_string = "Uploadcare.Simple #{public_key}:#{private_key}"
-          env.request_headers['Authorization'] = auth_string
-
-          env
-        end
-
-      end
-    end
-  end
-end

data/lib/uploadcare/rest/connections/api_connection.rb

@@ -1,53 +0,0 @@
-require 'faraday'
-require "faraday_middleware"
-
-module Uploadcare
-  module Connections
-    class ApiConnection < Faraday::Connection
-
-      def initialize options
-        super options[:api_url_base] do |frd|
-          auth_strategy = Auth.strategy(options)
-
-          frd.headers['Accept'] = "application/vnd.uploadcare-v#{options[:api_version]}+json"
-          frd.headers['User-Agent'] = UserAgent.new.call(options)
-
-          # order of middleware matters!
-
-          # :json middleware changes request body and thus should be before
-          # uploadcare_auth which uses it to sign requests when secure auth
-          # strategy is being used
-          frd.request :json
-          frd.request :uploadcare_auth, auth_strategy
-
-          frd.response :uploadcare_raise_error
-          frd.response :follow_redirects, limit: 3, callback: lambda{|old, env| auth_strategy.apply(env) }
-          frd.response :uploadcare_parse_json
-
-          frd.adapter :net_http # actually, default adapter, just to be clear
-        end
-      end
-
-      # NOTE: Faraday doesn't support body in DELETE requests, but
-      # Uploadcare API v0.5 requires clients to send array of UUIDs with
-      # `DELETE /files/storage/` requests.
-      #
-      # This is on override of the original Faraday::Connection#delete method.
-      #
-      # As for now, there are no DELETE requests in Uploadcare REST API
-      # which require params to be sent as URI params, so for simplicity
-      # this method send all params in a body.
-      def delete(url = nil, params = nil, headers = nil)
-        run_request(:delete, url, nil, headers) { |request|
-          # Original line from Faraday::Connection#delete method
-          # request.params.update(params) if params
-
-          # Monkey patch
-          request.body = params if params
-
-          yield(request) if block_given?
-        }
-      end
-    end
-  end
-end

data/lib/uploadcare/rest/connections/upload_connection.rb

@@ -1,22 +0,0 @@
-require "faraday"
-
-module Uploadcare
-  module Connections
-    class UploadConnection < Faraday::Connection
-      def initialize options
-        ca_path = '/etc/ssl/certs' if File.exists?('/etc/ssl/certs')
-
-        super ssl: { ca_path: ca_path }, url: options[:upload_url_base] do |frd|
-          frd.request :multipart
-          frd.request :url_encoded
-          frd.headers['User-Agent'] = UserAgent.new.call(options)
-
-          frd.response :uploadcare_raise_error
-          frd.response :uploadcare_parse_json
-
-          frd.adapter :net_http
-        end
-      end
-    end
-  end
-end

data/lib/uploadcare/rest/middlewares/auth_middleware.rb

@@ -1,24 +0,0 @@
-require 'faraday'
-
-module Uploadcare
-  module Connections
-    module Request
-      class Auth < Faraday::Middleware
-        attr_reader :auth_strategy
-
-        def initialize(app=nil, auth_strategy)
-          @auth_strategy = auth_strategy
-          super(app)
-        end
-
-        def call(env)
-          auth_strategy.apply(env)
-          @app.call(env)
-        end
-
-      end
-    end
-  end
-end
-
-Faraday::Request.register_middleware uploadcare_auth: Uploadcare::Connections::Request::Auth

data/lib/uploadcare/rest/middlewares/parse_json_middleware.rb

@@ -1,33 +0,0 @@
-require 'faraday'
-require 'json'
-
-module Uploadcare
-  module Connections
-    module Response
-      class ParseJson < Faraday::Response::Middleware
-        WHITESPACE_REGEX = /\A^\s*$\z/
-
-        ERROR_CODES = [400, 401, 403, 404, 406, 408, 422, 429, 500, 502, 503, 504]
-
-        def parse(body)
-          case body
-          when WHITESPACE_REGEX, nil
-            nil
-          else
-            JSON.parse(body)
-          end
-        end
-
-        def on_complete(response)
-          response[:body] = parse(response[:body]) if respond_to?(:parse) && !ERROR_CODES.include?(response[:status])
-        end
-
-        def unparsable_status_codes
-          [204, 301, 302, 304]
-        end
-      end
-    end
-  end
-end
-
-Faraday::Response.register_middleware :uploadcare_parse_json => Uploadcare::Connections::Response::ParseJson

data/lib/uploadcare/rest/middlewares/raise_error_middleware.rb

@@ -1,21 +0,0 @@
-require 'faraday'
-
-module Uploadcare
-  module Connections
-    module Response
-      class RaiseError < Faraday::Response::Middleware
-        def on_complete(response)
-          @error_codes = Uploadcare::Error.errors.keys
-          @status = response[:status]
-
-          if @error_codes.include?(@status)
-            error = Uploadcare::Error.errors[@status].new
-            fail(error)
-          end
-        end
-      end
-    end
-  end
-end
-
-Faraday::Response.register_middleware :uploadcare_raise_error => Uploadcare::Connections::Response::RaiseError

data/lib/uploadcare/utils/parser.rb

@@ -1,71 +0,0 @@
-require 'ostruct'
-
-module Uploadcare
-  module Parser
-
-    META_URL = /
-        (?<uuid>[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12} # base uuid
-        ~?(?<count>\d+)?) # optional count
-        (?:\/-\/(?<operations>.*?))?\/?$ # optional operations
-      /ix
-
-    def self.parse_file_string string
-      result = Uploadcare::Parser.parse(string)
-
-      unless result.is_a?(Uploadcare::Parser::File)
-        msg = "invalid CDN URL or UUID was given for file: #{uuid_or_cdn_url}."
-        if result.is_a?(Uploadcare::Parser::Group)
-          msg = msg + "\n Group UUID was given. Try call @api.group if it is what you intended."
-        end
-        raise msg
-      end
-
-      result
-    end
-
-
-    def self.parse_group_string string
-      result = Uploadcare::Parser.parse(string)
-
-      unless result.is_a?(Uploadcare::Parser::Group)
-        msg = "invalid CDN URL or UUID was given for group: #{uuid_or_cdn_url}."
-        if result.is_a?(Uploadcare::Parser::File)
-          msg = msg + "\n File UUID was given. Try call @api.file if it is what you intended."
-        end
-        raise msg
-      end
-
-      result
-    end
-
-    def self.parse string
-      matched = META_URL.match(string)
-
-      # just a simple hash - easy to pass next
-      captured = Hash[ matched.names.zip( matched.captures ) ]
-
-      # raise an error if no uuid was given in the sting
-      raise "Invalid UUID or url was given" if captured["uuid"].nil?
-
-      # operations sring to array of operations
-      if captured["operations"]
-        captured["operations"] = captured["operations"].split("/-/")
-      else
-        captured["operations"] = []
-      end
-
-      # if count was given - it is a group
-      if captured["count"]
-        obj = Group.new captured
-      else
-        obj = File.new captured
-      end
-    end
-
-    class File < OpenStruct
-    end
-
-    class Group < OpenStruct
-    end
-  end
-end

data/lib/uploadcare/utils/user_agent.rb

@@ -1,44 +0,0 @@
-module Uploadcare
-  # Determines User-Agent string either taking it from settings or building
-  # in accordance with common Uploadcare format
-  #
-  class UserAgent
-    # @param options [Hash]
-    # @option options [String] :user_agent (nil)
-    # @option options [String] :public_key (nil)
-    # @option options [String] :user_agent_environment (nil)
-    # @return [String]
-    #
-    def call(options)
-      return options[:user_agent].to_s if options[:user_agent]
-
-      user_agent_string(
-        options.fetch(:public_key, nil),
-        options.fetch(:user_agent_environment, {})
-      )
-    end
-
-    private
-
-    def user_agent_string(public_key, extensions)
-      format(
-        '%<library>s/%<pubkey>s (%<environment>s)',
-        library: versioned('UploadcareRuby', Uploadcare::VERSION),
-        pubkey: public_key,
-        environment: environment_string(extensions)
-      )
-    end
-
-    def environment_string(extensions)
-      [
-        versioned('Ruby', Gem.ruby_version),
-        versioned(extensions[:framework_name], extensions[:framework_version]),
-        versioned(extensions[:extension_name], extensions[:extension_version])
-      ].compact.join('; ')
-    end
-
-    def versioned(name, version = nil)
-      name ? [name, version].compact.join('/') : nil
-    end
-  end
-end

data/lib/uploadcare/version.rb

@@ -1,3 +0,0 @@
-module Uploadcare
-  VERSION = '2.1.2'.freeze
-end

data/spec/api/file_list_api_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::FileListApi do
-  let(:api){ API }
-  subject{ api.file_list(limit: 1) }
-
-  before(:each){ allow(api).to receive(:get){ {'results' => []} } }
-
-  it 'returns a file list' do
-    expect( subject ).to be_a(Uploadcare::Api::FileList)
-  end
-
-  it 'stores options in a file list object' do
-    expect( subject.options ).to eq({limit: 1})
-  end
-
-  describe 'validation' do
-    it 'passes validation when no options given' do
-      expect{ api.file_list }.not_to raise_error
-    end
-
-    it "validates that options don't have unsupported keys" do
-      expect{ api.file_list(unknown: 1) }.to raise_error(ArgumentError)
-    end
-
-    it 'validates that :limit is an integer from 1 to 1000' do
-      expect{ api.file_list(limit: 1) }.not_to raise_error
-      expect{ api.file_list(limit: 395) }.not_to raise_error
-      expect{ api.file_list(limit: 1000) }.not_to raise_error
-
-      expect{ api.file_list(limit: 1.0) }.to raise_error(ArgumentError)
-      expect{ api.file_list(limit: -1) }.to raise_error(ArgumentError)
-      expect{ api.file_list(limit: 0) }.to raise_error(ArgumentError)
-      expect{ api.file_list(limit: 1001) }.to raise_error(ArgumentError)
-      expect{ api.file_list(limit: false) }.to raise_error(ArgumentError)
-    end
-
-    it 'validates that :stored is a boolean' do
-      expect{ api.file_list(stored: true) }.not_to raise_error
-      expect{ api.file_list(stored: false) }.not_to raise_error
-
-      expect{ api.file_list(stored: 'yes') }.to raise_error(ArgumentError)
-    end
-
-    it 'validates that :removed is a boolean' do
-      expect{ api.file_list(removed: true) }.not_to raise_error
-      expect{ api.file_list(removed: false) }.not_to raise_error
-
-      expect{ api.file_list(removed: 'yes') }.to raise_error(ArgumentError)
-    end
-
-    valid_ordering = %w{size -size datetime_uploaded -datetime_uploaded}
-    it "validates that :ordering is in [#{valid_ordering.join(', ')}]" do
-      valid_ordering.each do |valid_value|
-        expect{ api.file_list(ordering: valid_value) }.not_to raise_error
-      end
-
-      expect{ api.file_list(ordering: 'yes') }.to raise_error(ArgumentError)
-    end
-
-    describe 'from' do
-      context 'when ordering is "size" or "-size"' do
-        let(:opts){ {ordering: ['size', '-size'].sample} }
-
-        it 'validates that :from is a non-negative integer' do
-          valid = [0, 100500]
-          valid.each do |value|
-            expect{ api.file_list(opts.merge(from: value)) }.not_to raise_error
-          end
-
-          invalid = [-1, 200.0, "string", false]
-          invalid.each do |value|
-            expect{ api.file_list(opts.merge(from: value)) }.to raise_error(ArgumentError)
-          end
-        end
-      end
-
-      context 'when ordering is "datetime_uploaded", "-datetime_uploaded" or nil' do
-        let(:opts){ {ordering: ['datetime_uploaded', '-datetime_uploaded', nil].sample} }
-
-        it 'validates that :from.to_s is a iso8601 string' do
-          valid = [DateTime.now, DateTime.now.iso8601, "2017-01-01T15"]
-          valid.each do |value|
-            expect{ api.file_list(opts.merge(from: value)) }.not_to raise_error
-          end
-
-          invalid = [Date.today, Time.now, DateTime.now.rfc2822, "2017-01-01", 123, false]
-          invalid.each do |value|
-            expect{ api.file_list(opts.merge(from: value)) }.to raise_error(ArgumentError)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/api/file_storage_api_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::FileStorageApi do
-  let(:api){ API }
-  let(:file){ api.file_list(limit: 1).first || api.upload(IMAGE_URL) }
-
-  shared_examples 'batch action on files' do
-    let(:uuids) { ["dc2c175d-a3b5-4435-b4f4-fae77bbe5597", "cea319aa-6e17-4172-8722-8dd7c459a523"] }
-    let(:files) { uuids.map { |uuid| Uploadcare::Api::File.new(api, uuid) } }
-    let(:api_endpoint) { "/files/storage/" }
-
-    it 'accepts array of uuids' do
-      expect(api).to receive(http_method)
-      expect { subject.call(uuids) }.not_to raise_error
-    end
-
-    it 'accepts enumerable containing Uploadcare::Api::File objects' do
-      expect(api).to receive(http_method)
-      expect { subject.call(files) }.not_to raise_error
-    end
-
-    it 'converts Uploadcare::Api::File-s to uuids' do
-      expect(api).to receive(http_method).with(api_endpoint, uuids)
-      subject.call(files)
-    end
-
-    context 'when input contains something other than UUIDs or Uploadcare::Api::File-s' do
-      it 'raises ArgumentError' do
-        ['not-an-uuid', nil, 1].each do |wrong_input_value|
-          expect { subject.call([wrong_input_value]) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-
-    it 'raises ArgumentError if input size is grater then max batch size' do
-      stub_const("Uploadcare::FileStorageApi::MAX_BATCH_SIZE", 1)
-      expect { subject.call(uuids) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#store_files' do
-    let(:http_method) { :put }
-    subject { ->(objects) { api.store_files(objects) } }
-
-    it_behaves_like 'batch action on files'
-
-    describe 'integration test' do
-      before { file.tap { |f| wait_until_ready(f) }.delete if file.stored? }
-      subject(:store_files) { -> { api.store_files([file]) } }
-
-      it 'stores files with given uuids' do
-        is_expected.to change { file.load!.stored? }.from(false).to(true)
-      end
-
-      it 'returns the API response' do
-        expect(store_files.call).to include(
-          "status" => "ok",
-          "problems" => {},
-          "result" => [be_a(Hash)]
-        )
-      end
-    end
-  end
-
-  describe '#delete_files' do
-    let(:http_method) { :delete }
-    subject { ->(objects) { api.delete_files(objects) } }
-
-    it_behaves_like 'batch action on files'
-
-    describe 'integration test' do
-      before { file.store if file.deleted? }
-      subject(:delete_files) { -> { api.delete_files([file]) } }
-
-      it 'deletes files with given uuids' do
-        is_expected.to change { file.load!.deleted? }.from(false).to(true)
-      end
-
-      it 'returns the API response' do
-        expect(delete_files.call).to include(
-          "status" => "ok",
-          "problems" => {},
-          "result" => [be_a(Hash)]
-        )
-      end
-    end
-  end
-end

data/spec/api/group_list_api_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe Uploadcare::GroupListApi do
-  let(:api){ API }
-  subject{ api.group_list(limit: 1) }
-
-  before(:each){ allow(api).to receive(:get){ {'results' => []} } }
-
-  it 'returns a group list' do
-    expect( subject ).to be_a(Uploadcare::Api::GroupList)
-  end
-
-  it 'stores options in a group list object' do
-    expect( subject.options ).to eq({limit: 1})
-  end
-
-  describe 'validation' do
-    it 'passes validation when no options given' do
-      expect{ api.group_list }.not_to raise_error
-    end
-
-    it "validates that options don't have unsupported keys" do
-      expect{ api.group_list(unknown: 1) }.to raise_error(ArgumentError)
-    end
-
-    it 'validates that :limit is an integer from 1 to 1000' do
-      [1, 359, 1000].each do |v|
-        expect{ api.group_list(limit: v) }.not_to raise_error
-      end
-
-      [1.0, -1, 0, 1001, false].each do |v|
-        expect{ api.group_list(limit: v) }.to raise_error(ArgumentError)
-      end
-    end
-
-    valid_ordering = %w{datetime_created -datetime_created}
-    it "validates that :ordering is in [#{valid_ordering.join(', ')}]" do
-      valid_ordering.each do |valid_value|
-        expect{ api.group_list(ordering: valid_value) }.not_to raise_error
-      end
-
-      expect{ api.group_list(ordering: 'yes') }.to raise_error(ArgumentError)
-    end
-
-    describe 'from' do
-      it 'validates that :from.to_s is a iso8601 string' do
-        valid = [DateTime.now, DateTime.now.iso8601, "2017-01-01T15"]
-        valid.each do |value|
-          expect{ api.group_list(from: value) }.not_to raise_error
-        end
-
-        invalid = [Date.today, Time.now, DateTime.now.rfc2822, "2017-01-01", 123, false]
-        invalid.each do |value|
-          expect{ api.group_list(from: value) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-end

data/spec/api/raw_api_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'uri'
-require 'socket'
-
-describe Uploadcare::Api do
-  subject(:api) { Uploadcare::Api.new(CONFIG) }
-
-  it "should initialize api" do
-    is_expected.to be_an_instance_of(Uploadcare::Api)
-  end
-
-  it 'should respond to request methods' do
-    is_expected.to respond_to :request
-    is_expected.to respond_to :get
-    is_expected.to respond_to :post
-    is_expected.to respond_to :put
-    is_expected.to respond_to :delete
-  end
-
-  context 'when performing requests' do
-    subject(:request) { api.request }
-
-    it { is_expected.to be_a Hash }
-  end
-end