geet 0.25.0 → 0.27.0

data/lib/geet/github/pr.rb

@@ -1,10 +1,23 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
     class PR < AbstractIssue
+      extend T::Sig
+
+      sig { returns(T.nilable(String)) }
       attr_reader :node_id
 
+      sig {
+        override.params(
+          number: Integer,
+          api_interface: Geet::Github::ApiInterface,
+          title: String,
+          link: String,
+          node_id: T.nilable(String)
+        ).void
+      }
       def initialize(number, api_interface, title, link, node_id: nil)
         super(number, api_interface, title, link)
         @node_id = node_id
@@ -12,6 +25,16 @@ module Geet
 
       # See https://developer.github.com/v3/pulls/#create-a-pull-request
       #
+      sig {
+        params(
+          title: String,
+          description: String,
+          head: String,
+          api_interface: Geet::Github::ApiInterface,
+          base: String,
+          draft: T::Boolean
+        ).returns(Geet::Github::PR)
+      }
       def self.create(title, description, head, api_interface, base, draft: false)
         api_path = 'pulls'
 
@@ -20,19 +43,34 @@ module Geet
           head = "#{authenticated_user}:#{head}"
         end
 
-        request_data = { title: title, body: description, head: head, base: base, draft: draft }
+        request_data = { title:, body: description, head:, base:, draft: }
 
-        response = api_interface.send_request(api_path, data: request_data)
+        response = T.cast(api_interface.send_request(api_path, data: request_data), T::Hash[String, T.untyped])
 
-        number, title, link = response.fetch_values('number', 'title', 'html_url')
-        node_id = response['node_id']
+        number = T.cast(response.fetch('number'), Integer)
+        title = T.cast(response.fetch('title'), String)
+        link = T.cast(response.fetch('html_url'), String)
+        node_id = T.cast(response['node_id'], T.nilable(String))
 
         new(number, api_interface, title, link, node_id:)
       end
 
       # See https://developer.github.com/v3/pulls/#list-pull-requests
       #
-      def self.list(api_interface, milestone: nil, assignee: nil, owner: nil, head: nil)
+      sig {
+        override.params(
+          api_interface: Geet::Github::ApiInterface,
+          milestone: T.nilable(Geet::Github::Milestone),
+          assignee: T.nilable(Geet::Github::User),
+          owner: T.nilable(String),
+          head: T.nilable(String),
+          type_filter:
+            T.nilable(
+              T.proc.params(issue_data: T::Hash[String, T.untyped]).returns(T::Boolean)
+            )
+        ).returns(T::Array[Geet::Github::PR])
+      }
+      def self.list(api_interface, milestone: nil, assignee: nil, owner: nil, head: nil, &type_filter)
         check_list_params!(milestone, assignee, head)
 
         if head
@@ -44,7 +82,10 @@ module Geet
           # For upstream pulls, the owner is the authenticated user, otherwise, the repository owner.
           #
           response = if api_interface.upstream?
-            unfiltered_response = api_interface.send_request(api_path, multipage: true)
+            unfiltered_response = T.cast(
+              api_interface.send_request(api_path, multipage: true),
+              T::Array[T::Hash[String, T.untyped]]
+            )
 
             # VERY weird. From the docs, it's not clear if the user/org is required in the `head` parameter,
             # but:
@@ -54,29 +95,44 @@ module Geet
             #
             # For this reason, we can't use that param, and have to filter manually.
             #
-            unfiltered_response.select { |pr_data| pr_data.fetch('head').fetch('label') == "#{owner}:#{head}" }
+            unfiltered_response.select do |pr_data|
+              pr_head = T.cast(pr_data.fetch('head'), T::Hash[String, T.untyped])
+              label = T.cast(pr_head.fetch('label'), String)
+
+              label == "#{owner}:#{head}"
+            end
           else
             request_params = { head: "#{owner}:#{head}" }
 
-            api_interface.send_request(api_path, params: request_params, multipage: true)
+            T.cast(
+              api_interface.send_request(api_path, params: request_params, multipage: true),
+              T::Array[T::Hash[String, T.untyped]]
+            )
           end
 
           response.map do |pr_data|
-            number = pr_data.fetch('number')
-            title = pr_data.fetch('title')
-            link = pr_data.fetch('html_url')
+            number = T.cast(pr_data.fetch('number'), Integer)
+            title = T.cast(pr_data.fetch('title'), String)
+            link = T.cast(pr_data.fetch('html_url'), String)
 
             new(number, api_interface, title, link)
           end
         else
-          super(api_interface, milestone: milestone, assignee: assignee) do |issue_data|
+          result = super(api_interface, milestone:, assignee:) do |issue_data|
             issue_data.key?('pull_request')
           end
+
+          T.cast(result, T::Array[Geet::Github::PR])
         end
       end
 
       # See https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button
       #
+      sig {
+        params(
+          merge_method: T.nilable(String)
+        ).void
+      }
       def merge(merge_method: nil)
         api_path = "pulls/#{number}/merge"
         request_data = { merge_method: } if merge_method
@@ -84,38 +140,104 @@ module Geet
         @api_interface.send_request(api_path, http_method: :put, data: request_data)
       end
 
+      sig {
+        params(
+          reviewers: T::Array[String]
+        ).void
+      }
       def request_review(reviewers)
         api_path = "pulls/#{number}/requested_reviewers"
-        request_data = { reviewers: reviewers }
+        request_data = { reviewers: }
 
         @api_interface.send_request(api_path, data: request_data)
       end
 
-      # Enable auto-merge for this PR using the repository's default merge method.
+      # Enable auto-merge for this PR using an available merge method.
+      # Queries the repository to find allowed merge methods and uses the first available one
+      # (see method comment below for the priority).
       # See https://docs.github.com/en/graphql/reference/mutations#enablepullrequestautomerge
       #
+      sig { returns(String) }
       def enable_automerge
+        merge_method = fetch_available_merge_method
+
         query = <<~GRAPHQL
-          mutation($pullRequestId: ID!) {
-            enablePullRequestAutoMerge(input: {pullRequestId: $pullRequestId}) {
+          mutation($pullRequestId: ID!, $mergeMethod: PullRequestMergeMethod!) {
+            enablePullRequestAutoMerge(input: {pullRequestId: $pullRequestId, mergeMethod: $mergeMethod}) {
               pullRequest {
                 id
                 autoMergeRequest {
                   enabledAt
+                  mergeMethod
                 }
               }
             }
           }
         GRAPHQL
 
-        variables = { pullRequestId: @node_id }
+        variables = { pullRequestId: @node_id, mergeMethod: merge_method }
 
         @api_interface.send_graphql_request(query, variables:)
+
+        merge_method
+      end
+
+      private
+
+      # Query the repository to find the first available merge method.
+      # Priority:
+      # - If there is one commit and squash merge is supported: SQUASH
+      # - Otherwise, if merge commit is supported: MERGE
+      # - Otherwise: SQUASH > REBASE
+      #
+      sig { returns(String) }
+      def fetch_available_merge_method
+        query = <<~GRAPHQL
+          query($owner: String!, $name: String!, $number: Int!) {
+            repository(owner: $owner, name: $name) {
+              mergeCommitAllowed
+              squashMergeAllowed
+              rebaseMergeAllowed
+              pullRequest(number: $number) {
+                commits {
+                  totalCount
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        owner, name = T.must(@api_interface.repository_path).split('/')
+
+        response = @api_interface.send_graphql_request(query, variables: {owner:, name:, number:})
+        repo_data = response['repository'].transform_keys(&:to_sym)
+        commit_count = repo_data[:pullRequest]['commits']['totalCount']
+
+        if commit_count == 1 && repo_data[:squashMergeAllowed]
+          'SQUASH'
+        elsif repo_data[:mergeCommitAllowed]
+          'MERGE'
+        elsif repo_data[:squashMergeAllowed]
+          'SQUASH'
+        elsif repo_data[:rebaseMergeAllowed]
+          'REBASE'
+        else
+          raise 'No merge methods are allowed on this repository'
+        end
       end
 
       class << self
+        extend T::Sig
+
         private
 
+        sig {
+          params(
+            milestone: T.nilable(Geet::Github::Milestone),
+            assignee: T.nilable(Geet::Github::User),
+            head: T.nilable(String)
+          ).void
+        }
         def check_list_params!(milestone, assignee, head)
           if (milestone || assignee) && head
             raise "Head can't be specified with milestone or assignee!"

data/lib/geet/github/remote_repository.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
@@ -10,10 +11,19 @@ module Geet
     # duplication. All in all, for simplicity, the latter design is chosen, but is subject to redesign.
     #
     class RemoteRepository
+      extend T::Sig
+
       # Nil if the repository is not a fork.
       #
+      sig { returns(T.nilable(String)) }
       attr_reader :parent_path
 
+      sig {
+        params(
+          api_interface: Geet::Github::ApiInterface,
+          parent_path: T.nilable(String)
+        ).void
+      }
       def initialize(api_interface, parent_path: nil)
         @api_interface = api_interface
         @parent_path = parent_path
@@ -23,14 +33,20 @@ module Geet
       #
       # https://docs.github.com/en/rest/reference/repos#get-a-repository
       #
+      sig {
+        params(
+          api_interface: Geet::Github::ApiInterface
+        ).returns(Geet::Github::RemoteRepository)
+      }
       def self.find(api_interface)
         api_path = "/repos/#{api_interface.repository_path}"
 
-        response = api_interface.send_request(api_path)
+        response = T.cast(api_interface.send_request(api_path), T::Hash[String, T.untyped])
 
-        parent_path = response['parent']&.fetch("full_name")
+        parent_hash = T.cast(response['parent'], T.nilable(T::Hash[String, T.untyped]))
+        parent_path = T.cast(parent_hash&.fetch("full_name)"), T.nilable(String))
 
-        self.new(api_interface, parent_path: parent_path)
+        new(api_interface, parent_path:)
       end
     end # module RemoteRepository
   end # module GitHub

data/lib/geet/github/user.rb

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
     class User
+      extend T::Sig
       include Geet::Shared::RepoPermissions
 
+      sig { returns(String) }
       attr_reader :username
 
+      sig {
+        params(
+          username: String,
+          api_interface: Geet::Github::ApiInterface
+        ).void
+      }
       def initialize(username, api_interface)
         @username = username
         @api_interface = api_interface
@@ -14,6 +23,11 @@ module Geet
 
       # See #repo_permission.
       #
+      sig {
+        params(
+          permission: String
+        ).returns(T::Boolean)
+      }
       def has_permission?(permission)
         user_permission = self.class.repo_permission(@api_interface)
 
@@ -22,6 +36,7 @@ module Geet
 
       # See https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator
       #
+      sig { returns(T::Boolean) }
       def is_collaborator?
         api_path = "collaborators/#{@username}"
 
@@ -42,32 +57,50 @@ module Geet
 
       # See https://developer.github.com/v3/users/#get-the-authenticated-user
       #
-      def self.authenticated(api_interface, **_)
+      sig {
+        params(
+          api_interface: Geet::Github::ApiInterface
+        ).returns(Geet::Github::User)
+      }
+      def self.authenticated(api_interface)
         api_path = '/user'
 
-        response = api_interface.send_request(api_path)
+        response = T.cast(api_interface.send_request(api_path), T::Hash[String, T.untyped])
 
-        new(response.fetch('login'), api_interface)
+        login = T.cast(response.fetch('login'), String)
+
+        new(login, api_interface)
       end
 
-      # Returns an array of User instances
-      #
-      def self.list_collaborators(api_interface, **)
+      sig {
+        params(
+          api_interface: Geet::Github::ApiInterface
+        ).returns(T::Array[Geet::Github::User])
+      }
+      def self.list_collaborators(api_interface)
         api_path = 'collaborators'
-        response = api_interface.send_request(api_path, multipage: true)
+        response = T.cast(api_interface.send_request(api_path, multipage: true), T::Array[T::Hash[String, T.untyped]])
 
-        response.map { |user_entry| new(user_entry.fetch('login'), api_interface) }
+        response.map do |user_entry|
+          login = T.cast(user_entry.fetch('login'), String)
+          new(login, api_interface)
+        end
       end
 
       # See https://developer.github.com/v3/repos/collaborators/#review-a-users-permission-level
       #
+      sig {
+        params(
+          api_interface: Geet::Github::ApiInterface
+        ).returns(String)
+      }
       def self.repo_permission(api_interface)
         username = authenticated(api_interface).username
         api_path = "collaborators/#{username}/permission"
 
-        response = api_interface.send_request(api_path)
+        response = T.cast(api_interface.send_request(api_path), T::Hash[String, T.untyped])
 
-        permission = response.fetch('permission')
+        permission = T.cast(response.fetch('permission'), String)
 
         check_permission!(permission)
 
@@ -75,12 +108,15 @@ module Geet
       end
 
       class << self
+        extend T::Sig
+
         private
 
         # Future-proofing.
         #
+        sig { params(permission: String).void }
         def check_permission!(permission)
-          raise "Unexpected permission #{permission.inspect}!" if !self::ALL_PERMISSIONS.include?(permission)
+          raise "Unexpected permission #{permission.inspect}!" if !Geet::Shared::RepoPermissions::ALL_PERMISSIONS.include?(permission)
         end
       end
     end

data/lib/geet/gitlab/api_interface.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require 'cgi'
 require 'uri'
@@ -8,64 +9,86 @@ require 'json'
 module Geet
   module Gitlab
     class ApiInterface
+      extend T::Sig
+
       API_BASE_URL = 'https://gitlab.com/api/v4'
 
+      sig { returns(T.nilable(String)) }
       attr_reader :repository_path
 
       # repo_path: "path/namespace"; required for the current GitLab operations.
       # upstream:  boolean; required for the current GitLab operations.
       #
+      sig {
+        params(
+          api_token: String,
+          repo_path: String,
+          upstream: T::Boolean
+        ).void
+      }
       def initialize(api_token, repo_path:, upstream:)
         @api_token = api_token
         @path_with_namespace = repo_path
         @upstream = upstream
+        @repository_path = T.let(nil, T.nilable(String))
       end
 
+      sig { returns(T::Boolean) }
       def upstream?
         @upstream
       end
 
+      sig {
+        params(
+          encoded: T::Boolean
+        ).returns(String)
+      }
       def path_with_namespace(encoded: false)
         encoded ? CGI.escape(@path_with_namespace) : @path_with_namespace
       end
 
       # Send a request.
       #
-      # Returns the parsed response, or an Array, in case of multipage.
-      # Where no body is present in the response, nil is returned.
-      #
-      # params:
-      #   :api_path:    api path, will be appended to the API URL.
-      #                 for root path, prepend a `/`:
-      #                 - use `/gists` for `https://api.github.com/gists`
-      #                 when owner/project/repos is included, don't prepend `/`:
-      #                 - use `issues` for `https://api.github.com/myowner/myproject/repos/issues`
-      #   :params:      (Hash)
-      #   :data:        (Hash) if present, will generate a POST request, otherwise, a GET
-      #   :multipage:   set true for paged Github responses (eg. issues); it will make the method
-      #                 return an array, with the concatenated (parsed) responses
-      #   :http_method: symbol format of the method (:get, :patch, :post, :put and :delete)
-      #                 :get and :post are automatically inferred by the present of :data; the other
-      #                 cases must be specified.
-      #
+      sig {
+        params(
+          # Appended to the API URL.
+          # for root path, prepend a `/`:
+          # - use `/gists` for `https://api.github.com/gists`
+          # when owner/project/repos is included, don't prepend `/`:
+          # - use `issues` for `https://api.github.com/myowner/myproject/repos/issues`
+          api_path: String,
+          params: T.nilable(T::Hash[Symbol, T.untyped]),
+          # If present, will generate a POST request, otherwise, a GET
+          data: T.nilable(T.any(T::Hash[Symbol, T.untyped], T::Array[T.untyped])),
+          # Set true for paged Github responses (eg. issues); it will make the method
+          multipage: T::Boolean,
+          # Method (:get, :patch, :post, :put and :delete)
+          # :get and :post are automatically inferred by the presence of :data; the other cases must be specified.
+          http_method: T.nilable(Symbol)
+        # Returns the parsed response, or an Array, in case of multipage.
+        # Where no body is present in the response, nil is returned.
+        ).returns(T.nilable(T.any(T::Hash[String, T.untyped], T::Array[T::Hash[String, T.untyped]])))
+      }
       def send_request(api_path, params: nil, data: nil, multipage: false, http_method: nil)
-        address = api_url(api_path)
+        address = T.let(api_url(api_path), T.nilable(String))
         # filled only on :multipage
         parsed_responses = []
 
         loop do
-          response = send_http_request(address, params: params, data: data, http_method: http_method)
+          response = send_http_request(T.must(address), params:, data:, http_method:)
 
-          parsed_response = JSON.parse(response.body) if response.body
+          if response_body = response.body
+            parsed_response = JSON.parse(response_body)
+          end
 
           if error?(response)
-            formatted_error = decode_and_format_error(parsed_response)
+            formatted_error = decode_and_format_error(T.cast(parsed_response, T::Hash[String, T.untyped]))
             raise(formatted_error)
           end
 
           return parsed_response if !multipage
 
-          parsed_responses.concat(parsed_response)
+          parsed_responses.concat(T.cast(parsed_response, T::Array[T::Hash[String, T.untyped]]))
 
           address = link_next_page(response.to_hash)
 
@@ -79,10 +102,23 @@ module Geet
 
       private
 
+      sig {
+        params(
+          api_path: String
+        ).returns(String)
+      }
       def api_url(api_path)
         "#{API_BASE_URL}/#{api_path}"
       end
 
+      sig {
+        params(
+          address: String,
+          params: T.nilable(T::Hash[Symbol, T.untyped]),
+          data: T.nilable(T.any(T::Hash[Symbol, T.untyped], T::Array[T.untyped])),
+          http_method: T.nilable(Symbol)
+        ).returns(Net::HTTPResponse)
+      }
       def send_http_request(address, params: nil, data: nil, http_method: nil)
         uri = encode_uri(address, params)
         http_class = find_http_class(http_method, data)
@@ -97,16 +133,32 @@ module Geet
         end
       end
 
+      sig {
+        params(
+          address: String,
+          params: T.nilable(T::Hash[Symbol, T.untyped])
+        ).returns(URI::Generic)
+      }
       def encode_uri(address, params)
         address += '?' + URI.encode_www_form(params) if params
 
         URI(address)
       end
 
+      sig {
+        params(
+          response: Net::HTTPResponse
+        ).returns(T::Boolean)
+      }
       def error?(response)
         !response.code.start_with?('2')
       end
 
+      sig {
+        params(
+          parsed_response: T::Hash[String, T.untyped]
+        ).returns(String)
+      }
       def decode_and_format_error(parsed_response)
         if parsed_response.key?('error')
           parsed_response.fetch('error')
@@ -117,6 +169,11 @@ module Geet
         end
       end
 
+      sig {
+        params(
+          response_headers: T::Hash[String, T.untyped]
+        ).returns(T.nilable(String))
+      }
       def link_next_page(response_headers)
         # An array (or nil) is returned.
         link_header = Array(response_headers['link'])
@@ -126,6 +183,12 @@ module Geet
         link_header[0][/<(\S+)>; rel="next"/, 1]
       end
 
+      sig {
+        params(
+          http_method: T.nilable(Symbol),
+          data: T.nilable(Object)
+        ).returns(T.class_of(Net::HTTPRequest))
+      }
       def find_http_class(http_method, data)
         http_method ||= data ? :post : :get
 

data/lib/geet/gitlab/issue.rb

@@ -1,10 +1,27 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Gitlab
     class Issue
-      attr_reader :number, :title, :link
+      extend T::Sig
 
+      sig { returns(Integer) }
+      attr_reader :number
+
+      sig { returns(String) }
+      attr_reader :title
+
+      sig { returns(String) }
+      attr_reader :link
+
+      sig {
+        params(
+          number: Integer,
+          title: String,
+          link: String
+        ).void
+      }
       def initialize(number, title, link)
         @number = number
         @title = title
@@ -13,6 +30,13 @@ module Geet
 
       # See https://docs.gitlab.com/ee/api/issues.html#list-issues
       #
+      sig {
+        params(
+          api_interface: ApiInterface,
+          assignee: T.nilable(User),
+          milestone: T.nilable(Milestone)
+        ).returns(T::Array[Issue])
+      }
       def self.list(api_interface, assignee: nil, milestone: nil)
         api_path = "projects/#{api_interface.path_with_namespace(encoded: true)}/issues"
 
@@ -20,12 +44,15 @@ module Geet
         request_params[:assignee_id] = assignee.id if assignee
         request_params[:milestone] = milestone.title if milestone
 
-        response = api_interface.send_request(api_path, params: request_params, multipage: true)
+        response = T.cast(
+          api_interface.send_request(api_path, params: request_params, multipage: true),
+          T::Array[T::Hash[String, T.untyped]]
+        )
 
         response.map do |issue_data, result|
-          number = issue_data.fetch('iid')
-          title = issue_data.fetch('title')
-          link = issue_data.fetch('web_url')
+          number = T.cast(issue_data.fetch('iid'), Integer)
+          title = T.cast(issue_data.fetch('title'), String)
+          link = T.cast(issue_data.fetch('web_url'), String)
 
           new(number, title, link)
         end