gini-api 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e0a78fff7ea84fe5f7124e103861964da618830
-  data.tar.gz: 5b381a2a131e6e117f94628b37f45e8b521c3b38
+  metadata.gz: 48a332c434967ccd2d8906da4f64f7a8a27346b3
+  data.tar.gz: a3143decf245e1ef61800716558726431d9601e3
 SHA512:
-  metadata.gz: 94f60834223b3afdedee4ef203416b48869029eb1a61b077466026866589ed2cd95226bbeb6d9c3db13ac42dff16594227fb553483c4f2825e8d6407da221e5f
-  data.tar.gz: 4afccb044306250c91d10b8e3cc64947f10aeada8cc72a6df41499ed67f294aaba60003c7e97ae0f1efe8a6e3d3fd6bfb145c976768c863c4d7a6f29f6906b9f
+  metadata.gz: 33f11fa2e20aefb5e51e68fa495445c1b5da7eb6f46612ef4ed3dcbc513d071753bd2241b0e8220c9b217cbfbbf141931927a17827c3813c1f359eb54741cee2
+  data.tar.gz: 9819589db65cde5ddb460ac6e75887d1adf976be5bffc58707b5daf413b5999e4234e7d951d8615e02d5a0b07f219b37eba9346b13f47bb23763b9c81d8bf82c

data/README.md

@@ -5,7 +5,7 @@
 [![Build Status](https://travis-ci.org/gini/gini-api-ruby.png)](https://travis-ci.org/gini/gini-api-ruby)
 [![Code Climate](https://codeclimate.com/github/gini/gini-api-ruby.png)](https://codeclimate.com/github/gini/gini-api-ruby)
 [![Coverage Status](https://coveralls.io/repos/gini/gini-api-ruby/badge.png)](https://coveralls.io/r/gini/gini-api-ruby)
-[![Gem Version](https://badge.fury.io/rb/gini-api-ruby.png)](http://badge.fury.io/rb/gini-api-ruby)
+[![Gem Version](https://badge.fury.io/rb/gini-api.png)](http://badge.fury.io/rb/gini-api)
 
 ## Resources
 
@@ -42,10 +42,10 @@ api = Gini::Api::Client.new(
 )
 
 # auth_code (has been extracted outside of gini-api-ruby)
-api.login('1234567890')
+api.login(auth_code: '1234567890')
 
 # username/password
-api.login('user@example.com', 'password')
+api.login(username: 'me@example.com', password: 'secret')
 ```
 
 ### Upload
@@ -68,7 +68,7 @@ list.total
 # => 15
 list.documents
 # => [Gini::Api::Document, Gini::Api::Document, ...]
-list.each do { |doc| puts doc.id }
+list.each { |doc| puts doc.id }
 # => 1234567890-abc, 0987654321-cba, ...
 ```
 
@@ -97,7 +97,7 @@ search.total
 # => 5
 search.documents
 # => [Gini::Api::Document, Gini::Api::Document, ...]
-search.each do { |doc| puts doc.id }
+search.each { |doc| puts doc.id }
 # => 1234567890-abc, 0987654321-cba, ...
 ```
 
@@ -176,7 +176,7 @@ rescue Gini::Api::OAuthError => e
 end
 ```
 
-Please keep in mind that the amount of availabe instance variables differs depending on the error situation. For details please refer to the [Gini::Api::Error class](Gini/Api/Error.html).
+Please keep in mind that the amount of availabe instance variables differs depending on the error situation. For details please refer to the ```Gini::Api::Error``` class.
 
 ## Developers
 

data/gini-api.gemspec

@@ -4,17 +4,9 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'gini-api/version'
 
-gem_version = Gini::Api::BASE_VERSION.dup
-
-if ENV.has_key?('BUILD_NUMBER')
-  gem_version << ".#{ENV['BUILD_NUMBER']}"
-else
-  gem_version = Gini::Api::VERSION
-end
-
 Gem::Specification.new do |spec|
   spec.name          = 'gini-api'
-  spec.version       = gem_version
+  spec.version       = Gini::Api::VERSION
   spec.authors       = ['Daniel Kerwin']
   spec.email         = ['tech@gini.net']
   spec.description   = %q{Ruby client to interact with the Gini API.}

data/lib/gini-api/client.rb

@@ -61,14 +61,6 @@ module Gini
         # Sanitize api_uri
         @api_uri.sub!(/(\/)+$/, '')
 
-        # Create upload connection
-        @upload_connection = Faraday.new(url: @api_uri) do |builder|
-          builder.use(Faraday::Request::Multipart)
-          builder.use(Faraday::Request::UrlEncoded)
-          builder.request(:retry, 3)
-          builder.adapter(Faraday.default_adapter)
-        end
-
         # Register parser (json+xml) based on API version
         register_parser
 
@@ -135,7 +127,7 @@ module Gini
         }.merge(options)
 
         timeout(@processing_timeout) do
-          @token.send(verb.to_sym, @api_uri + URI.parse(resource).path, opts)
+          @token.send(verb.to_sym, resource_to_location(resource).to_s , opts)
         end
       rescue OAuth2::Error => e
         raise Gini::Api::RequestError.new(
@@ -160,49 +152,26 @@ module Gini
       #   doc = api.upload('/tmp/myfile.pdf') { |d| puts "Progress: #{d.progress}" }
       #
       def upload(file, &block)
-        @log.info("Uploading #{file}")
-
-        duration = {}
+        duration = Hash.new(0)
 
         # Document upload
-        duration[:upload] = Benchmark.realtime do
-          @response = @upload_connection.post do |req|
-            req.options[:timeout] = @upload_timeout
-            req.url 'documents/'
-            req.headers['Content-Type']  = 'multipart/form-data'
-            req.headers['Authorization'] = "Bearer #{@token.token}"
-            req.headers.merge!(version_header)
-            req.body = { file: Faraday::UploadIO.new(file, 'application/octet-stream') }
-          end
-        end
+        duration[:upload], response = upload_document(file)
 
         # Start polling (0.5s) when document has been uploaded successfully
-        if @response.status == 201
-          location = @response.headers['location']
-          doc = Gini::Api::Document.new(self, location)
-          begin
-            timeout(@processing_timeout) do
-              duration[:processing] = Benchmark.realtime do
-                doc.poll(&block)
-              end
-            end
-          rescue Timeout::Error => e
-            ex = Gini::Api::ProcessingError.new(e.message)
-            ex.docid = doc.id
-            raise ex
-          end
+        if response.status == 201
+          doc = Gini::Api::Document.new(self, response.headers['location'])
+          duration[:processing] = poll_document(doc, &block)
+
+          duration[:total] = duration.values.inject(:+)
+          doc.duration = duration
+
+          doc
         else
-          raise Gini::Api::UploadError.new(
-            "Document upload failed with HTTP code #{@response.status}",
-            @response
+          fail Gini::Api::UploadError.new(
+            "Document upload failed with HTTP code #{response.status}",
+            response
           )
         end
-
-        # Combine duration values and update doc object
-        duration[:total] = duration[:upload] + duration[:processing]
-        doc.duration = duration
-
-        doc
       end
 
       # Delete document
@@ -279,6 +248,80 @@ module Gini
         end
         Gini::Api::DocumentSet.new(self, response.parsed)
       end
+
+      private
+
+      # Helper to covert resource to a valid location.
+      #
+      # @param [String] resource URI to be converted
+      #
+      # @return [URI::HTTPS] URI::HTTPS object create from resource
+      #
+      def resource_to_location(resource)
+        parsed_resource = URI.parse(resource)
+        @api_host ||= URI.parse(@api_uri).host
+
+        URI::HTTPS.build(
+          host:  @api_host,
+          path:  parsed_resource.path,
+          query: parsed_resource.query
+        )
+      end
+
+      # Poll document and duration
+      #
+      # @param [Gini::Api::Document] doc Document instance to poll
+      #
+      # @return [Integer] Processing duration
+      #
+      def poll_document(doc, &block)
+        duration = 0
+        timeout(@processing_timeout) do
+          duration = Benchmark.realtime do
+            doc.poll(&block)
+          end
+        end
+        duration
+      rescue Timeout::Error => e
+        ex = Gini::Api::ProcessingError.new(e.message)
+        ex.docid = doc.id
+        raise ex
+      end
+
+      # Setup API upload connection
+      #
+      # @return [Faraday] Faraday object to use in upload
+      #
+      def upload_connection
+        @upload_connection ||= Faraday.new(url: @api_uri) do |builder|
+          builder.use(Faraday::Request::Multipart)
+          builder.use(Faraday::Request::UrlEncoded)
+          builder.request(:retry, 3)
+          builder.adapter(Faraday.default_adapter)
+        end
+      end
+
+      # Helper to upload document
+      #
+      # @param [String] file location of document to be uploaded
+      #
+      # @return [Faraday::Response] Response object from upload
+      #
+      def upload_document(file)
+        response = nil
+        duration = Benchmark.realtime do
+          response = upload_connection.post do |req|
+            req.options[:timeout] = @upload_timeout
+            req.url 'documents/'
+            req.headers['Content-Type']  = 'multipart/form-data'
+            req.headers['Authorization'] = "Bearer #{@token.token}"
+            req.headers.merge!(version_header)
+            req.body = { file: Faraday::UploadIO.new(file, 'application/octet-stream') }
+          end
+        end
+
+        return duration, response
+      end
     end
   end
 end

data/lib/gini-api/oauth.rb

@@ -37,7 +37,15 @@ module Gini
           if opts.key?(:auth_code) && !opts[:auth_code].empty?
             opts[:auth_code]
           else
-            login_with_credentials(api, client, opts[:username], opts[:password])
+            # Generate CSRF token to verify the response
+            csrf_token = SecureRandom.hex
+            location  = login_with_credentials(
+                          api,
+                          client,
+                          csrf_token,
+                          opts[:username],
+                          opts[:password])
+            extract_auth_code(location, csrf_token)
           end
 
         # Exchange code for a real token.
@@ -71,102 +79,130 @@ module Gini
         end
       end
 
-      # Login with username/password
+      # Destroy token
       #
-      # @param [Gini::Api::Client] api API object
-      # @param [OAuth2::Client] client OAuth2 client object
-      # @param [String] username API username
-      # @param [String] password API password
+      def destroy
+        @token.refresh_token && @token.refresh!
+        response = token.delete("/accessToken/#{@token.token}")
+        unless response.status == 204
+          fail_with_oauth_error(
+            "Failed to destroy token /accessToken/#{@token.token} "\
+            "(code=#{response.status})",
+            response
+          )
+        end
+      rescue OAuth2::Error => e
+        fail_with_oauth_error(
+          "Failed to destroy token (code=#{e.response.status})",
+          e.response
+        )
+      end
+
+      private
+
+      # Helper method to fail with Gini::Api::OAuthError
       #
-      # @return [String] Collected authorization code
+      # @param [String] msg Exception message
+      # @param [OAuth2::Response] response Response object
       #
-      def login_with_credentials(api, client, username, password)
-        # Generate CSRF token to verify the response
-        csrf_token = SecureRandom.hex
-
-        # Build authentication URI
-        auth_uri = client.auth_code.authorize_url(
-          redirect_uri: api.oauth_redirect,
-          state: csrf_token
+      def fail_with_oauth_error(msg, response = nil)
+        raise Gini::Api::OAuthError.new(
+          msg,
+          response
         )
+      end
 
-        begin
-          # Accquire auth code
-          response = client.request(
-            :post,
-            auth_uri,
-            body: { username: username, password: password }
-          )
-          unless response.status == 303
-            raise Gini::Api::OAuthError.new(
-              "API login failed (code=#{response.status})",
-              response
-            )
-          end
-        rescue OAuth2::Error => e
-          raise Gini::Api::OAuthError.new(
-            "Failed to acquire auth_code (code=#{e.response.status})",
-            e.response
-          )
-        end
-
-        # Parse the location header from the response and fill hash
-        # query_params ({'code' => '123abc', 'state' => 'supersecret'})
-        begin
-          q = URI.parse(response.headers['location']).query
-          query_params = Hash[*q.split(/\=|\&/)]
-        rescue => e
-          raise Gini::Api::OAuthError.new("Failed to parse location header: #{e.message}")
-        end
+      # Extract auth_code from URI
+      #
+      # @param [String] location Location URI containing the auth_code
+      # @param [String] csrf_token CSRF token to verify request
+      #
+      # @return [String] Collected authorization code
+      #
+      def extract_auth_code(location, csrf_token)
+        query_params = parse_location(location)
 
         unless query_params['state'] == csrf_token
-          raise Gini::Api::OAuthError.new(
+          fail_with_oauth_error(
             "CSRF token mismatch detected (should=#{csrf_token}, "\
             "is=#{query_params['state']})"
           )
         end
 
         unless query_params.key?('code') && !query_params['code'].empty?
-          raise Gini::Api::OAuthError.new(
-            "Failed to extract code from location #{response.headers['location']}"
+          fail_with_oauth_error(
+            "Failed to extract code from location #{location}"
           )
         end
 
         query_params['code']
       end
 
-      # Exchange auth_code for a real token
+      # Parse auth_code and state from URI
+      #
+      # @param [String] location Location URI with auth_code and state
+      #
+      # @return [Hash] Hash with auth_code and state
+      #
+      def parse_location(location)
+        # Parse the location header from the response and return hash
+        # {'code' => '123abc', 'state' => 'supersecret'}
+        q = URI.parse(location).query
+        Hash[*q.split(/\=|\&/)]
+      rescue => e
+        fail_with_oauth_error("Failed to parse location header: #{e.message}")
+      end
+
+      # Login with username/password
       #
       # @param [Gini::Api::Client] api API object
       # @param [OAuth2::Client] client OAuth2 client object
-      # @param [String] auth_code authorization code
+      # @param [String] csrf_token CSRF token to verify request
+      # @param [String] username API username
+      # @param [String] password API password
       #
-      # @return [OAuth2::AccessToken] AccessToken object
+      # @return [String] Location header
       #
-      def exchange_code_for_token(api, client, auth_code)
-        client.auth_code.get_token(auth_code, redirect_uri: api.oauth_redirect)
+      def login_with_credentials(api, client, csrf_token, username, password)
+        # Build authentication URI
+        auth_uri = client.auth_code.authorize_url(
+          redirect_uri: api.oauth_redirect,
+          state: csrf_token
+        )
+
+        # Accquire auth code
+        response = client.request(
+          :post,
+          auth_uri,
+          body: { username: username, password: password }
+        )
+        unless response.status == 303
+          fail_with_oauth_error(
+            "API login failed (code=#{response.status})",
+            response
+          )
+        end
+        response.headers['location']
       rescue OAuth2::Error => e
-        raise Gini::Api::OAuthError.new(
-          "Failed to exchange auth_code for token (code=#{e.response.status})",
+        fail_with_oauth_error(
+          "Failed to acquire auth_code (code=#{e.response.status})",
           e.response
         )
       end
 
-      # Destroy token
+      # Exchange auth_code for a real token
       #
-      def destroy
-        @token.refresh_token && @token.refresh!
-        response = token.delete("/accessToken/#{@token.token}")
-        unless response.status == 204
-          raise Gini::Api::OAuthError.new(
-            "Failed to destroy token /accessToken/#{@token.token} "\
-            "(code=#{response.status})",
-            response
-          )
-        end
+      # @param [Gini::Api::Client] api API object
+      # @param [OAuth2::Client] client OAuth2 client object
+      # @param [String] auth_code authorization code
+      #
+      # @return [OAuth2::AccessToken] AccessToken object
+      #
+      def exchange_code_for_token(api, client, auth_code)
+        client.auth_code.get_token(auth_code, redirect_uri: api.oauth_redirect)
       rescue OAuth2::Error => e
-        raise Gini::Api::OAuthError.new(
-          "Failed to destroy token (code=#{e.response.status})",
+        fail_with_oauth_error(
+          "Failed to exchange auth_code for token (code=#{e.response.status})",
           e.response
         )
       end

data/lib/gini-api/version.rb

@@ -1,9 +1,5 @@
 module Gini
   module Api
-    # Base version for semantic versioning
-    BASE_VERSION = '0.9'
-
-    # Version string
-    VERSION = "#{BASE_VERSION}.2"
+    VERSION = "0.9.3"
   end
 end

data/spec/gini-api/oauth_spec.rb

@@ -62,8 +62,6 @@ describe Gini::Api::OAuth do
         )
       end
 
-      it { should respond_to(:login_with_credentials) }
-      it { should respond_to(:exchange_code_for_token) }
       it { should respond_to(:destroy) }
 
       it 'does set token' do

data/spec/integration/api_spec.rb

@@ -28,10 +28,14 @@ describe 'Gini::Api integration test' do
 
   context 'OAuth' do
 
-    it '#login sets token' do
+    before do
       @api.login(username: @user, password: @pass)
+    end
+
+    it '#login sets token' do
       expect(@api.token.token).to match(/\w+-\w+/)
       expect(@api.token.expired?).to be_false
+      @api.logout
     end
 
     it '#logout destroys token' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gini-api
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - Daniel Kerwin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-17 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oauth2