semaphore_client 2.3.1 → 2.4.0

data/lib/semaphore_client/api/user.rb

@@ -5,101 +5,71 @@ class SemaphoreClient
         @http_client = http_client
       end
 
-      def list_for_org(org_id, query = nil)
-        list_for_org!(org_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def list_for_team(team_id, query = nil)
-        list_for_team!(team_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+      def list_for_org(org_id, params = nil, options = {})
+        list_for_org!(org_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def attach_to_team(user_id, team_id)
-        attach_to_team!(user_id, team_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
+      def list_for_org!(org_id, params = nil, options = {})
+        path = "/orgs/#{org_id}/users"
 
-      def detach_from_team(user_id, team_id)
-        detach_from_team!(user_id, team_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::User.load(e) }
       end
 
-      def list_for_project(project_id, query = nil)
-        list_for_project!(project_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def list_for_org!(org_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
 
-        response = @http_client.get([:orgs, org_id, :users, query_string].compact)
-
-        assert_response_status(response, 200)
+      def list_for_team(team_id, params = nil, options = {})
+        list_for_team!(team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
+      end
 
-        content = JSON.parse(response.body)
+      def list_for_team!(team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/users"
 
-        content.map do |entity|
-          SemaphoreClient::Model::User.load(entity)
-        end
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::User.load(e) }
       end
 
-      def list_for_team!(team_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
 
-        response = @http_client.get([:teams, team_id, :users, query_string].compact)
 
-        assert_response_status(response, 200)
+      def attach_to_team(user_id, team_id, params = nil, options = {})
+        attach_to_team!(user_id, team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
+      end
 
-        content = JSON.parse(response.body)
+      def attach_to_team!(user_id, team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/users/#{user_id}"
 
-        content.map do |entity|
-          SemaphoreClient::Model::User.load(entity)
-        end
+        @http_client.post(path, params, options)
       end
 
-      def attach_to_team!(user_id, team_id)
-        response = @http_client.post([:teams, team_id, :users, user_id])
 
-        assert_response_status(response, 204)
+
+      def detach_from_team(user_id, team_id, params = nil, options = {})
+        detach_from_team!(user_id, team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def detach_from_team!(user_id, team_id)
-        response = @http_client.delete([:teams, team_id, :users, user_id])
+      def detach_from_team!(user_id, team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/users/#{user_id}"
 
-        assert_response_status(response, 204)
+        @http_client.delete(path, params, options)
       end
 
-      def list_for_project!(project_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
 
-        response = @http_client.get([:projects, project_id, :users, query_string].compact)
 
-        assert_response_status(response, 200)
+      def list_for_project(project_id, params = nil, options = {})
+        list_for_project!(project_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
+      end
 
-        content = JSON.parse(response.body)
+      def list_for_project!(project_id, params = nil, options = {})
+        path = "/projects/#{project_id}/users"
 
-        content.map do |entity|
-          SemaphoreClient::Model::User.load(entity)
-        end
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::User.load(e) }
       end
 
-      private
 
-      def assert_response_status(response, expected_status)
-        return if response.status == expected_status
-
-        raise SemaphoreClient::Exceptions::RequestFailed, response.status
-      end
     end
   end
 end

data/lib/semaphore_client/exceptions.rb

@@ -1,6 +1,38 @@
 class SemaphoreClient
   class Exceptions
-    class AttributeNotAvailable < StandardError; end
-    class RequestFailed < StandardError; end
+    class Base < StandardError; end
+
+    class AttributeNotAvailable < Base; end
+
+    class ResponseError < Base
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+
+        super(env[:message])
+      end
+    end
+
+    # 400
+    class BadRequest < ResponseError; end
+
+    # 401
+    class Unauthorized < ResponseError; end
+
+    # 404
+    class NotFound < ResponseError; end
+
+    # 405
+    class NotAllowed < ResponseError; end
+
+    # 409
+    class Conflict < ResponseError; end
+
+    # 422
+    class UnprocessableEntity < ResponseError; end
+
+    # 500+
+    class ServerError < ResponseError; end
   end
 end

data/lib/semaphore_client/http_client.rb

@@ -1,87 +1,107 @@
 class SemaphoreClient
+
   class HttpClient
-    class RouteNotSupported < StandardError; end
 
-    def initialize(auth_token, api_url, api_version, verbose, logger)
+    class ResponseErrorMiddleware < Faraday::Middleware
+      def call(env)
+        @app.call(env).on_complete do |env|
+          case env[:status]
+          when 401
+            raise SemaphoreClient::Exceptions::Unauthorized, env
+          when 404
+            raise SemaphoreClient::Exceptions::NotFound, env
+          when 405
+            raise SemaphoreClient::Exceptions::NotAllowed, env
+          when 409
+            raise SemaphoreClient::Exceptions::Conflict, env
+          when 422
+            raise SemaphoreClient::Exceptions::UnprocessableEntity, env
+          when 400...500
+            raise SemaphoreClient::Exceptions::BadRequest, env
+          when 500...600
+            raise SemaphoreClient::Exceptions::ServerError, env
+          end
+        end
+      end
+    end
+
+    def initialize(auth_token, api_url, api_version, verbose, logger, auto_paginate)
       @auth_token = auth_token
       @api_url = api_url
       @api_version = api_version
       @verbose = verbose
       @logger = logger
+      @auto_paginate = auto_paginate
     end
 
-    def get(route_elements)
-      route = route(route_elements)
+    def get(path, params = nil, options = {})
+      api_call(:get, path, params, options)
+    end
 
-      trace("GET", route) do
-        connection.get(route)
-      end
+    def post(path, params = nil, options = {})
+      api_call(:post, path, params, options)
     end
 
-    def post(route_elements, content = nil)
-      route = route(route_elements)
+    def patch(path, params = nil, options = {})
+      api_call(:patch, path, params, options)
+    end
 
-      if content
-        trace("POST", route, content) do
-          connection.post(route, content)
-        end
-      else
-        trace("POST", route) do
-          connection.post(route)
-        end
-      end
+    def delete(path, params = nil, options = {})
+      api_call(:delete, path, params, options)
     end
 
-    def patch(route_elements, content = nil)
-      route = route(route_elements)
+    private
 
-      if content
-        trace("PATCH", route, content) do
-          connection.patch(route, content)
-        end
-      else
-        trace("PATCH", route) do
-          connection.patch(route)
+    def api_call(method, path, params = nil, options = {})
+      response = connection.public_send(method, "/#{@api_version}/#{path}", params)
+
+      if auto_paginate?(options)
+        links = parse_links(response)
+
+        if links[:next]
+          # recursivly follow the :next link
+          next_response = api_call(method, links[:next], params, options)
+
+          # append the rest to the body of the original request
+          response.body.concat(next_response.body)
         end
       end
+
+      response
     end
 
-    def delete(route_elements)
-      route = route(route_elements)
+    def auto_paginate?(options)
+      # first check the options, then the global settings
+      options.key?(:auto_paginate) ? options[:auto_paginate] : @auto_paginate
+    end
 
-      trace("DELETE", route) do
-        connection.delete(route)
+    def parse_links(response)
+      links = ( response.headers["Link"] || "" ).split(', ').map do |link|
+        href, name = link.match(/<(.*?)>; rel="(\w+)"/).captures
+
+        [name.to_sym, href.gsub("#{@api_url}/v2", "")]
       end
-    end
 
-    private
+      Hash[*links.flatten]
+    end
 
-    def trace(method, path, content = nil)
-      if @verbose == true
-        id = SecureRandom.hex
-        started_at = Time.now.to_f
+    def connection
+      @connection ||= Faraday.new(:url => @api_url, :headers => headers) do |conn|
+        conn.request :json
+        conn.response :json
 
-        @logger.info "#{id} #{method} #{path} body: #{content.inspect}"
-        response = yield
+        if @verbose
+          conn.response :logger, @logger, :headers => false, :bodies => true
+        end
 
-        finished_at = Time.now.to_f
-        @logger.info "#{id} #{response.status} duration: #{finished_at - started_at}s body: #{response.body}"
+        conn.use SemaphoreClient::HttpClient::ResponseErrorMiddleware
 
-        response
-      else
-        yield
+        conn.adapter Faraday.default_adapter
       end
     end
 
-    def route(route_elements)
-      ["", @api_version, *route_elements].compact.join("/")
-    end
-
-    def connection
-      @connection ||= Faraday.new(
-        :url => @api_url,
-        :headers => { "Authorization" => "Token #{@auth_token}" }
-      )
+    def headers
+      { "Authorization" => "Token #{@auth_token}" }
     end
   end
 end

data/lib/semaphore_client/version.rb

@@ -1,3 +1,3 @@
 class SemaphoreClient
-  VERSION = "2.3.1"
+  VERSION = "2.4.0"
 end

data/semaphore_client.gemspec

@@ -20,7 +20,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "faraday"
+  spec.add_dependency "faraday", "~> 0.13.1"
+  spec.add_dependency "faraday_middleware", "~> 0.12.2"
+
   spec.add_development_dependency "byebug"
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: semaphore_client
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Jovan Ivanović
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-25 00:00:00.000000000 Z
+date: 2017-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.13.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -137,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Client for Semaphore's API.