uploadcare-ruby 1.0.6 → 1.1.0

data/lib/uploadcare.rb

@@ -14,6 +14,7 @@ module Uploadcare
       static_url_base: 'https://ucarecdn.com',
       api_version: '0.3',
       cache_files: true,
+      auth_scheme: :secure
     }
 
   USER_AGENT = "uploadcare-ruby/#{Gem.ruby_version}/#{Uploadcare::VERSION}"

data/lib/uploadcare/api.rb

@@ -4,6 +4,7 @@ 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/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/resources/*.rb'].each {|file| require file }
 
@@ -11,7 +12,7 @@ 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

data/lib/uploadcare/resources/file.rb

@@ -5,7 +5,7 @@ module Uploadcare
     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
@@ -65,7 +65,7 @@ module Uploadcare
       def store
         data = @api.put "/files/#{uuid}/storage/"
         set_data data
-        self 
+        self
       end
 
       # nil is returning if there is no way to say for sure
@@ -95,6 +95,8 @@ module Uploadcare
       # 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
@@ -103,6 +105,28 @@ module Uploadcare
         @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
@@ -137,4 +161,4 @@ module Uploadcare
         end
     end
   end
-end
+end

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,16 @@
+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,21 +1,33 @@
 require 'faraday'
 require "faraday_middleware"
+
 module Uploadcare
   module Connections
     class ApiConnection < Faraday::Connection
+
       def initialize options
         super options[:api_url_base] do |frd|
-          frd.request :url_encoded
-          frd.use ::FaradayMiddleware::FollowRedirects, limit: 3
-          frd.adapter :net_http # actually, default adapter, just to be clear
-          frd.headers['Authorization'] = "Uploadcare.Simple #{options[:public_key]}:#{options[:private_key]}"
+          auth_strategy = Auth.strategy(options)
+
           frd.headers['Accept'] = "application/vnd.uploadcare-v#{options[:api_version]}+json"
           frd.headers['User-Agent'] = Uploadcare::user_agent(options)
 
-          frd.response :raise_error
-          frd.response :parse_json
+          # order of middleware matters!
+
+          # url_encoded 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 :url_encoded
+          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
+
     end
   end
-end
+end

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

@@ -12,8 +12,8 @@ module Uploadcare
           frd.adapter :net_http
           frd.headers['User-Agent'] = Uploadcare::user_agent(options)
 
-          frd.response :raise_error
-          frd.response :parse_json
+          frd.response :uploadcare_raise_error
+          frd.response :uploadcare_parse_json
         end
       end
     end

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

@@ -0,0 +1,24 @@
+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

@@ -30,4 +30,4 @@ module Uploadcare
   end
 end
 
-Faraday::Response.register_middleware :parse_json => Uploadcare::Connections::Response::ParseJson
+Faraday::Response.register_middleware :uploadcare_parse_json => Uploadcare::Connections::Response::ParseJson

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

@@ -7,7 +7,7 @@ module Uploadcare
         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)
@@ -18,4 +18,4 @@ module Uploadcare
   end
 end
 
-Faraday::Response.register_middleware :raise_error => Uploadcare::Connections::Response::RaiseError
+Faraday::Response.register_middleware :uploadcare_raise_error => Uploadcare::Connections::Response::RaiseError

data/lib/uploadcare/version.rb

@@ -1,3 +1,3 @@
 module Uploadcare
-  VERSION = "1.0.6"
+  VERSION = "1.1.0"
 end

data/spec/resources/file_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'uri'
 require 'socket'
+require 'securerandom'
 
 describe Uploadcare::Api::File do
   before :each do
@@ -111,12 +112,111 @@ describe Uploadcare::Api::File do
   end
 
 
-  def retry_if(error, retries=3, &block)
-    block.call
-  rescue error
-    raise if retries <= 0
-    sleep 0.2
-    retry_if(error, retries-1, &block)
+  describe '#internal_copy' do
+    describe 'integration' do
+      it 'creates an internal copy of the file' do
+        response = retry_if(Uploadcare::Error::RequestError::BadRequest){@file.internal_copy}
+
+        expect( response['type'] ).to eq 'file'
+        expect( response['result']['uuid'] ).not_to eq @file.uuid
+      end
+    end
+
+    describe 'params' do
+      let(:url_without_ops){ @api.file(SecureRandom.uuid).cdn_url }
+      let(:url_with_ops){ url_without_ops + "-/crop/5x5/center/" }
+      let(:file){ @api.file(url_with_ops) }
+
+      context 'if no params given' do
+        it 'requests server to create an unstored copy with operataions applied' do
+          expect(@api).to receive(:post)
+            .with('/files/', source: url_with_ops)
+
+          file.internal_copy
+        end
+      end
+
+      context 'if strip_operations: true given' do
+        it 'passes url without operations as a source for a copy' do
+          expect(@api).to receive(:post)
+            .with('/files/', source: url_without_ops)
+
+          file.internal_copy(strip_operations: true)
+        end
+      end
+
+      context 'if store: true given' do
+        it 'requests server to create a stored copy' do
+          expect(@api).to receive(:post)
+            .with('/files/', source: url_with_ops, store: true)
+
+          file.internal_copy(store: true)
+        end
+      end
+    end
   end
 
-end
+
+  describe '#external_copy' do
+    let(:target){ 'with-prefix' }
+
+    describe 'integration', :payed_feature do
+      it 'creates an external copy of the file' do
+        response = retry_if(Uploadcare::Error::RequestError::BadRequest) do
+                     @file.external_copy(target)
+                   end
+
+        expect( response['type'] ).to eq 'url'
+        expect( response['result'] ).to match(URI.regexp)
+      end
+    end
+
+    describe 'params' do
+      let(:url_without_ops){ @api.file(SecureRandom.uuid).cdn_url }
+      let(:url_with_ops){ url_without_ops + "-/resize/50x50/" }
+      let(:file){ @api.file(url_with_ops) }
+
+      context 'if only target is given' do
+        it 'requests server to create a private copy with default name and with operataions applied' do
+          expect(@api).to receive(:post)
+            .with('/files/', source: url_with_ops, target: target)
+
+          file.external_copy(target)
+        end
+      end
+
+      context 'if target is not given' do
+        it 'raises ArgumentError' do
+          expect{ file.external_copy }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'if strip_operations: true given' do
+        it 'passes url without operations as a source for a copy' do
+          expect(@api).to receive(:post)
+            .with('/files/', source: url_without_ops, target: target)
+
+          file.external_copy(target, strip_operations: true)
+        end
+      end
+
+      context 'if :make_public given' do
+        it 'requests server to create a copy with correspondent permissions' do
+          expect(@api).to receive(:post)
+            .with('/files/', source: url_with_ops, target: target, make_public: false)
+
+          file.external_copy(target, make_public: false)
+        end
+      end
+
+      context 'if :pattern given' do
+        it 'requests server to apply given pattern to name of a copy' do
+          expect(@api).to receive(:post)
+            .with('/files/', source: url_with_ops, target: target, pattern: 'test')
+
+          file.external_copy(target, pattern: 'test')
+        end
+      end
+    end
+  end
+end

data/spec/rest/api_connection_spec.rb

@@ -3,17 +3,66 @@ require 'uri'
 require 'socket'
 
 describe Uploadcare::Connections::ApiConnection do
-  before(:all) do
-    @settings = Uploadcare.default_settings
+  let(:settings){ Uploadcare.default_settings }
+
+  it 'is initializable with default settings' do
+    expect {described_class.new(settings)}.to_not raise_error
   end
 
-  it 'should initialize api connection' do
-    expect {Uploadcare::Connections::ApiConnection.new(@settings)}.to_not raise_error
+
+  describe 'default request headers' do
+    subject{ described_class.new(settings).headers }
+
+    it 'includes correct Accept header' do
+      expected = "application/vnd.uploadcare-v#{settings[:api_version]}+json"
+      expect(subject['Accept']).to eq expected
+    end
+
+    it 'includes correct User-Agent header' do
+      expected = Uploadcare::user_agent(settings)
+      expect(subject['User-Agent']).to eq expected
+    end
+  end
+
+
+  describe 'middleware' do
+    subject{ described_class.new(settings).builder.handlers }
+
+    it 'uses Request::Auth middleware' do
+      expect(subject).to include(Uploadcare::Connections::Request::Auth)
+    end
+
+    it 'uses Response::ParseJson middleware' do
+      expect(subject).to include(Uploadcare::Connections::Response::ParseJson)
+    end
+
+    it 'uses Response::RaiseError middleware' do
+      expect(subject).to include(Uploadcare::Connections::Response::RaiseError)
+    end
   end
 
-  it 'should use ParseJson and RaiseError middlewares' do
-    connection = Uploadcare::Connections::ApiConnection.new(@settings)
-    connection.builder.handlers.include?(Uploadcare::Connections::Response::ParseJson).should == true
-    connection.builder.handlers.include?(Uploadcare::Connections::Response::RaiseError).should == true
+
+  describe 'auth scheme' do
+    it 'uses simple auth when auth_scheme: :simple setting is provided' do
+      expect(Uploadcare::Connections::Auth::Simple).to receive(:new)
+      described_class.new(settings.merge(auth_scheme: :simple))
+    end
+
+    it 'uses secure auth when auth_scheme: :secure setting is provided' do
+      expect(Uploadcare::Connections::Auth::Secure).to receive(:new)
+      described_class.new(settings.merge(auth_scheme: :secure))
+    end
+
+    it 'raises KeyError when :auth_scheme options is not provided' do
+      expect{
+        described_class.new(settings.reject{|k,_| k == :auth_scheme})
+      }.to raise_error(KeyError)
+    end
+
+    it 'raises ArgumentError when provided :auth_scheme is unknown' do
+      expect{
+        described_class.new(settings.merge(auth_scheme: :unknown))
+      }.to raise_error(ArgumentError)
+    end
   end
-end
+end