uploadcare-ruby 2.1.2 → 3.0.3

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