semaphore_client 2.3.1 → 2.4.0

data/lib/semaphore_client/api/project.rb

@@ -5,116 +5,85 @@ 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 create_for_org(org_id, params)
-        create_for_org!(org_id, params)
-      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 list_for_team(team_id, query = nil)
-        list_for_team!(team_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
+      def list_for_org!(org_id, params = nil, options = {})
+        path = "/orgs/#{org_id}/projects"
 
-      def attach_to_team(project_id, team_id)
-        attach_to_team!(project_id, team_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::Project.load(e) }
       end
 
-      def detach_from_team(project_id, team_id)
-        detach_from_team!(project_id, team_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def list_for_shared_config(shared_config_id, query = nil)
-        list_for_shared_config!(shared_config_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+
+      def create_for_org(org_id, params = nil, options = {})
+        create_for_org!(org_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def list_for_org!(org_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
+      def create_for_org!(org_id, params = nil, options = {})
+        path = "/orgs/#{org_id}/projects"
+        response = @http_client.post(path, params, options)
 
-        response = @http_client.get([:orgs, org_id, :projects, query_string].compact)
+        SemaphoreClient::Model::Project.load(response.body)
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        content.map do |entity|
-          SemaphoreClient::Model::Project.load(entity)
-        end
+      def list_for_team(team_id, params = nil, options = {})
+        list_for_team!(team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def create_for_org!(org_id, params)
-        response = @http_client.post([:orgs, org_id, :projects], params.to_json)
-
-        assert_response_status(response, 200)
+      def list_for_team!(team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/projects"
 
-        content = JSON.parse(response.body)
-
-        SemaphoreClient::Model::Project.load(content)
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::Project.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, :projects, query_string].compact)
 
-        assert_response_status(response, 200)
+      def attach_to_team(project_id, team_id, params = nil, options = {})
+        attach_to_team!(project_id, team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
+      end
 
-        content = JSON.parse(response.body)
+      def attach_to_team!(project_id, team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/projects/#{project_id}"
 
-        content.map do |entity|
-          SemaphoreClient::Model::Project.load(entity)
-        end
+        @http_client.post(path, params, options)
       end
 
-      def attach_to_team!(project_id, team_id)
-        response = @http_client.post([:teams, team_id, :projects, project_id])
 
-        assert_response_status(response, 204)
+
+      def detach_from_team(project_id, team_id, params = nil, options = {})
+        detach_from_team!(project_id, team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def detach_from_team!(project_id, team_id)
-        response = @http_client.delete([:teams, team_id, :projects, project_id])
+      def detach_from_team!(project_id, team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/projects/#{project_id}"
 
-        assert_response_status(response, 204)
+        @http_client.delete(path, params, options)
       end
 
-      def list_for_shared_config!(shared_config_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
 
-        response = @http_client.get([:shared_configs, shared_config_id, :projects, query_string].compact)
 
-        assert_response_status(response, 200)
+      def list_for_shared_config(shared_config_id, params = nil, options = {})
+        list_for_shared_config!(shared_config_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
+      end
 
-        content = JSON.parse(response.body)
+      def list_for_shared_config!(shared_config_id, params = nil, options = {})
+        path = "/shared_configs/#{shared_config_id}/projects"
 
-        content.map do |entity|
-          SemaphoreClient::Model::Project.load(entity)
-        end
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::Project.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/api/shared_config.rb

@@ -5,179 +5,152 @@ 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 create_for_org(org_id, params)
-        create_for_org!(org_id, params)
-      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 list_for_team(team_id, query = nil)
-        list_for_team!(team_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
+      def list_for_org!(org_id, params = nil, options = {})
+        path = "/orgs/#{org_id}/shared_configs"
 
-      def attach_to_team(shared_config_id, team_id)
-        attach_to_team!(shared_config_id, team_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::SharedConfig.load(e) }
       end
 
-      def detach_from_team(shared_config_id, team_id)
-        detach_from_team!(shared_config_id, team_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def list_for_project(project_id, query = nil)
-        list_for_project!(project_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def attach_to_project(shared_config_id, project_id)
-        attach_to_project!(shared_config_id, project_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+      def create_for_org(org_id, params = nil, options = {})
+        create_for_org!(org_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def detach_from_project(shared_config_id, project_id)
-        detach_from_project!(shared_config_id, project_id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
+      def create_for_org!(org_id, params = nil, options = {})
+        path = "/orgs/#{org_id}/shared_configs"
+        response = @http_client.post(path, params, options)
 
-      def get(id)
-        get!(id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+        SemaphoreClient::Model::SharedConfig.load(response.body)
       end
 
-      def delete(id)
-        delete!(id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def update(id, params)
-        update!(id, params)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+
+      def list_for_team(team_id, params = nil, options = {})
+        list_for_team!(team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def list_for_org!(org_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
+      def list_for_team!(team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/shared_configs"
 
-        response = @http_client.get([:orgs, org_id, :shared_configs, query_string].compact)
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::SharedConfig.load(e) }
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        content.map do |entity|
-          SemaphoreClient::Model::SharedConfig.load(entity)
-        end
+      def attach_to_team(shared_config_id, team_id, params = nil, options = {})
+        attach_to_team!(shared_config_id, team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def create_for_org!(org_id, params)
-        response = @http_client.post([:orgs, org_id, :shared_configs], params.to_json)
+      def attach_to_team!(shared_config_id, team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/shared_configs/#{shared_config_id}"
+
+        @http_client.post(path, params, options)
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        SemaphoreClient::Model::SharedConfig.load(content)
+      def detach_from_team(shared_config_id, team_id, params = nil, options = {})
+        detach_from_team!(shared_config_id, team_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def list_for_team!(team_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
+      def detach_from_team!(shared_config_id, team_id, params = nil, options = {})
+        path = "/teams/#{team_id}/shared_configs/#{shared_config_id}"
 
-        response = @http_client.get([:teams, team_id, :shared_configs, query_string].compact)
+        @http_client.delete(path, params, options)
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        content.map do |entity|
-          SemaphoreClient::Model::SharedConfig.load(entity)
-        end
+      def list_for_project(project_id, params = nil, options = {})
+        list_for_project!(project_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def attach_to_team!(shared_config_id, team_id)
-        response = @http_client.post([:teams, team_id, :shared_configs, shared_config_id])
+      def list_for_project!(project_id, params = nil, options = {})
+        path = "/projects/#{project_id}/shared_configs"
 
-        assert_response_status(response, 204)
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::SharedConfig.load(e) }
       end
 
-      def detach_from_team!(shared_config_id, team_id)
-        response = @http_client.delete([:teams, team_id, :shared_configs, shared_config_id])
 
-        assert_response_status(response, 204)
+
+      def attach_to_project(shared_config_id, project_id, params = nil, options = {})
+        attach_to_project!(shared_config_id, project_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def list_for_project!(project_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
+      def attach_to_project!(shared_config_id, project_id, params = nil, options = {})
+        path = "/projects/#{project_id}/shared_configs/#{shared_config_id}"
 
-        response = @http_client.get([:projects, project_id, :shared_configs, query_string].compact)
+        @http_client.post(path, params, options)
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        content.map do |entity|
-          SemaphoreClient::Model::SharedConfig.load(entity)
-        end
+      def detach_from_project(shared_config_id, project_id, params = nil, options = {})
+        detach_from_project!(shared_config_id, project_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def attach_to_project!(shared_config_id, project_id)
-        response = @http_client.post([:projects, project_id, :shared_configs, shared_config_id])
+      def detach_from_project!(shared_config_id, project_id, params = nil, options = {})
+        path = "/projects/#{project_id}/shared_configs/#{shared_config_id}"
 
-        assert_response_status(response, 204)
+        @http_client.delete(path, params, options)
       end
 
-      def detach_from_project!(shared_config_id, project_id)
-        response = @http_client.delete([:projects, project_id, :shared_configs, shared_config_id])
 
-        assert_response_status(response, 204)
+
+      def get(id, params = nil, options = {})
+        get!(id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def get!(id)
-        response = @http_client.get([:shared_configs, id])
+      def get!(id, params = nil, options = {})
+        path = "/shared_configs/#{id}"
+        response = @http_client.get(path, params = {})
+
+        SemaphoreClient::Model::SharedConfig.load(response.body)
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        SemaphoreClient::Model::SharedConfig.load(content)
+      def delete(id, params = nil, options = {})
+        delete!(id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def delete!(id)
-        response = @http_client.delete([:shared_configs, id])
+      def delete!(id, params = nil, options = {})
+        path = "/shared_configs/#{id}"
 
-        assert_response_status(response, 200)
+        @http_client.delete(path, params)
       end
 
-      def update!(id, params)
-        response = @http_client.patch([:shared_configs, id], params.to_json)
-
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        SemaphoreClient::Model::SharedConfig.load(content)
+      def update(id, params = nil, options = {})
+        update!(id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      private
-
-      def assert_response_status(response, expected_status)
-        return if response.status == expected_status
+      def update!(id, params = nil, options = {})
+        path = "/shared_configs/#{id}"
+        response = @http_client.patch(path, params)
 
-        raise SemaphoreClient::Exceptions::RequestFailed, response.status
+        SemaphoreClient::Model::SharedConfig.load(response.body)
       end
+
+
     end
   end
 end

data/lib/semaphore_client/api/team.rb

@@ -5,135 +5,100 @@ 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 create_for_org(org_id, params)
-        create_for_org!(org_id, params)
-      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 get(id)
-        get!(id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
+      def list_for_org!(org_id, params = nil, options = {})
+        path = "/orgs/#{org_id}/teams"
 
-      def delete(id)
-        delete!(id)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::Team.load(e) }
       end
 
-      def update(id, params)
-        update!(id, params)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def list_for_project(project_id, query = nil)
-        list_for_project!(project_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
-      end
 
-      def list_for_shared_config(shared_config_id, query = nil)
-        list_for_shared_config!(shared_config_id, query)
-      rescue SemaphoreClient::Exceptions::RequestFailed
+      def create_for_org(org_id, params = nil, options = {})
+        create_for_org!(org_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def list_for_org!(org_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
+      def create_for_org!(org_id, params = nil, options = {})
+        path = "/orgs/#{org_id}/teams"
+        response = @http_client.post(path, params, options)
 
-        response = @http_client.get([:orgs, org_id, :teams, query_string].compact)
+        SemaphoreClient::Model::Team.load(response.body)
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        content.map do |entity|
-          SemaphoreClient::Model::Team.load(entity)
-        end
+      def get(id, params = nil, options = {})
+        get!(id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def create_for_org!(org_id, params)
-        response = @http_client.post([:orgs, org_id, :teams], params.to_json)
-
-        assert_response_status(response, 200)
-
-        content = JSON.parse(response.body)
+      def get!(id, params = nil, options = {})
+        path = "/teams/#{id}"
+        response = @http_client.get(path, params = {})
 
-        SemaphoreClient::Model::Team.load(content)
+        SemaphoreClient::Model::Team.load(response.body)
       end
 
-      def get!(id)
-        response = @http_client.get([:teams, id])
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
-
-        SemaphoreClient::Model::Team.load(content)
+      def delete(id, params = nil, options = {})
+        delete!(id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def delete!(id)
-        response = @http_client.delete([:teams, id])
+      def delete!(id, params = nil, options = {})
+        path = "/teams/#{id}"
 
-        assert_response_status(response, 200)
+        @http_client.delete(path, params)
       end
 
-      def update!(id, params)
-        response = @http_client.patch([:teams, id], params.to_json)
-
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        SemaphoreClient::Model::Team.load(content)
+      def update(id, params = nil, options = {})
+        update!(id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def list_for_project!(project_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
+      def update!(id, params = nil, options = {})
+        path = "/teams/#{id}"
+        response = @http_client.patch(path, params)
 
-        response = @http_client.get([:projects, project_id, :teams, query_string].compact)
+        SemaphoreClient::Model::Team.load(response.body)
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        content.map do |entity|
-          SemaphoreClient::Model::Team.load(entity)
-        end
+      def list_for_project(project_id, params = nil, options = {})
+        list_for_project!(project_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      def list_for_shared_config!(shared_config_id, query = nil)
-        query_string =
-          unless query.nil? || query.empty?
-            "?" + query.map { |key, value| "#{key}=#{value}" }.join("&")
-          end
+      def list_for_project!(project_id, params = nil, options = {})
+        path = "/projects/#{project_id}/teams"
 
-        response = @http_client.get([:shared_configs, shared_config_id, :teams, query_string].compact)
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::Team.load(e) }
+      end
 
-        assert_response_status(response, 200)
 
-        content = JSON.parse(response.body)
 
-        content.map do |entity|
-          SemaphoreClient::Model::Team.load(entity)
-        end
+      def list_for_shared_config(shared_config_id, params = nil, options = {})
+        list_for_shared_config!(shared_config_id, params, options)
+      rescue SemaphoreClient::Exceptions::ResponseError
       end
 
-      private
+      def list_for_shared_config!(shared_config_id, params = nil, options = {})
+        path = "/shared_configs/#{shared_config_id}/teams"
 
-      def assert_response_status(response, expected_status)
-        return if response.status == expected_status
-
-        raise SemaphoreClient::Exceptions::RequestFailed, response.status
+        @http_client.get(path, params, options = {}).body.map { |e| SemaphoreClient::Model::Team.load(e) }
       end
+
+
     end
   end
 end