geet 0.26.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d83c8506d30f9b5d55cc466860fb8aa0c1b4e2efc0abf644ad9546da9948b514
-  data.tar.gz: db74f000152d9a001c4980515c3a152f605d34c076a26417081a6eb4622009bb
+  metadata.gz: 930e360b5ecee4ddf7ef77018c0e1288dc5dbcd0fea306cc99ebc862954989bd
+  data.tar.gz: e3a3d4d6f3cfacffe95c1701677e4a95f8ba3825dbbf03b9f11dfa6e2e8987cf
 SHA512:
-  metadata.gz: 5ec6c24fee6db9577c34464e7f92a86be70059b7acb0407883f223f10913235df7b0da2b319fce45af90faed5ae6779c932db54d01ef7856b56f36c90a1e20de
-  data.tar.gz: 9aa500830eab7372364f903f71b64694481b516087c0425a63b3ba6451b8b52e8c81c92fea49741173ce21028fb8999ff0cd65035b589d066c0ea4df57cc632e
+  metadata.gz: d2be595720c7e1288d256931cf4c27e91b5cdfe76641a9a2c87b73060567f363cfbb427dfaea7a2a3f492770710755f3f9f11b9af531f688671f5356f67b0d07
+  data.tar.gz: 4c6d651f84651a75434260dc6d743f06204130d65245d6f27ea8a72831789b3e023d7b8f74138e64fccf2a944f991bef5b8b475703bdcfd29a6170ed07314b80

data/Gemfile

@@ -13,6 +13,7 @@ end
 
 group :test do
   gem 'rspec', '~> 3.13.0'
+  gem 'rspec-sorbet'
   gem 'vcr', '~> 6.4.0'
   gem 'webmock', '~> 3.1.1'
 end

data/geet.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.2.0'
   s.authors     = ['Saverio Miroddi']
-  s.date        = '2026-01-14'
+  s.date        = '2026-01-15'
   s.email       = ['saverio.pub2@gmail.com']
   s.homepage    = 'https://github.com/saveriomiroddi/geet'
   s.summary     = 'Commandline interface for performing SCM host operations, eg. create a PR on GitHub'

data/lib/geet/git/repository.rb

@@ -53,7 +53,7 @@ module Geet
       end
 
       def issues(assignee: nil, milestone: nil)
-        attempt_provider_call(:Issue, :list, api_interface, assignee: assignee, milestone: milestone)
+        attempt_provider_call(:Issue, :list, api_interface, assignee:, milestone:)
       end
 
       def create_milestone(title)
@@ -76,7 +76,7 @@ module Geet
       end
 
       def prs(owner: nil, head: nil, milestone: nil)
-        attempt_provider_call(:PR, :list, api_interface, owner: owner, head: head, milestone: milestone)
+        attempt_provider_call(:PR, :list, api_interface, owner:, head:, milestone:)
       end
 
       # Returns the RemoteRepository instance.

data/lib/geet/github/abstract_issue.rb

@@ -1,12 +1,30 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
     # For clarity, in this class we keep only the identical logic between the subclasses, but
     # other methods could be moved in here at some complexity cost.
     class AbstractIssue
-      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 {
+        overridable.params(
+          number: Integer,
+          api_interface: Geet::Github::ApiInterface,
+          title: String,
+          link: String
+        ).void
+      }
       def initialize(number, api_interface, title, link)
         @number = number
         @api_interface = api_interface
@@ -19,6 +37,16 @@ module Geet
       # This works both for Issues and PRs, however, when the `/pulls` API (path) is used, additional
       # information is provided (e.g. `head`).
       #
+      sig {
+        overridable.params(
+          api_interface: Geet::Github::ApiInterface,
+          milestone: T.nilable(Geet::Github::Milestone),
+          assignee: T.nilable(Geet::Github::User),
+          type_filter:
+            T.nilable(
+              T.proc.params(issue_data: T::Hash[String, T.untyped]).returns(T::Boolean)
+            )
+        ).returns(T::Array[Geet::Github::AbstractIssue]) }
       def self.list(api_interface, milestone: nil, assignee: nil, &type_filter)
         api_path = 'issues'
 
@@ -26,12 +54,12 @@ module Geet
         request_params[:milestone] = milestone.number if milestone
         request_params[:assignee] = assignee.username if assignee
 
-        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]])
 
         abstract_issues_list = response.map do |issue_data|
-          number = issue_data.fetch('number')
-          title = issue_data.fetch('title')
-          link = issue_data.fetch('html_url')
+          number = T.cast(issue_data.fetch('number'), Integer)
+          title = T.cast(issue_data.fetch('title'), String)
+          link = T.cast(issue_data.fetch('html_url'), String)
 
           new(number, api_interface, title, link) if type_filter.nil? || type_filter.call(issue_data)
         end
@@ -39,9 +67,7 @@ module Geet
         abstract_issues_list.compact
       end
 
-      # params:
-      #   users:   String, or Array of strings.
-      #
+      sig { params(users: T.any(String, T::Array[String])).void }
       def assign_users(users)
         api_path = "issues/#{@number}/assignees"
         request_data = { assignees: Array(users) }
@@ -49,17 +75,16 @@ module Geet
         @api_interface.send_request(api_path, data: request_data)
       end
 
-      # labels: array of strings.
-      #
+      sig { params(labels: T::Array[String]).void }
       def add_labels(labels)
         api_path = "issues/#{@number}/labels"
-        request_data = labels
 
-        @api_interface.send_request(api_path, data: request_data)
+        @api_interface.send_request(api_path, data: labels)
       end
 
       # See https://developer.github.com/v3/issues/comments/#create-a-comment
       #
+      sig { params(comment: String).void }
       def comment(comment)
         api_path = "issues/#{@number}/comments"
         request_data = { body: comment }
@@ -69,6 +94,7 @@ module Geet
 
       # See https://developer.github.com/v3/issues/#edit-an-issue
       #
+      sig { params(milestone: Integer).void }
       def edit(milestone:)
         request_data = { milestone: milestone }
         api_path = "issues/#{@number}"

data/lib/geet/github/api_interface.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require 'uri'
 require 'net/http'
@@ -7,21 +8,32 @@ require 'json'
 module Geet
   module Github
     class ApiInterface
-      API_AUTH_USER = '' # We don't need the login, as the API key uniquely identifies the user
-      API_BASE_URL = 'https://api.github.com'
-      GRAPHQL_API_URL = 'https://api.github.com/graphql'
+      extend T::Sig
 
+      API_AUTH_USER = T.let('', String) # We don't need the login, as the API key uniquely identifies the user
+      API_BASE_URL = T.let('https://api.github.com', String)
+      GRAPHQL_API_URL = T.let('https://api.github.com/graphql', String)
+
+      sig { returns(T.nilable(String)) }
       attr_reader :repository_path
 
       # repo_path: optional for operations that don't require a repository, eg. gist creation.
       # upstream:  boolean; makes sense only when :repo_path is set.
       #
+      sig {
+        params(
+          api_token: String,
+          repo_path: T.nilable(String),
+          upstream: T.nilable(T::Boolean)
+        ).void
+      }
       def initialize(api_token, repo_path: nil, upstream: nil)
-        @api_token = api_token
-        @repository_path = repo_path
-        @upstream = upstream
+        @api_token = T.let(api_token, String)
+        @repository_path = T.let(repo_path, T.nilable(String))
+        @upstream = T.let(upstream, T.nilable(T::Boolean))
       end
 
+      sig { returns(T.nilable(T::Boolean)) }
       def upstream?
         @upstream
       end
@@ -45,24 +57,33 @@ module Geet
       #                 :get and :post are automatically inferred by the present of :data; the other
       #                 cases must be specified.
       #
+      sig {
+        params(
+          api_path: String,
+          params: T.nilable(T::Hash[Symbol, T.untyped]),
+          data: T.nilable(T.any(T::Hash[Symbol, T.untyped], T::Array[T.untyped])),
+          multipage: T::Boolean,
+          http_method: T.nilable(Symbol)
+        ).returns(T.any(T::Hash[String, T.untyped], T::Array[T::Hash[String, T.untyped]], NilClass))
+      }
       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 = []
+        parsed_responses = T.let([], T::Array[T::Hash[String, T.untyped]])
 
         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
+          parsed_response = T.unsafe(JSON.parse(T.must(response.body))) if response.body
 
           if error?(response)
-            error_message = decode_and_format_error(parsed_response)
+            error_message = decode_and_format_error(T.cast(parsed_response, T::Hash[String, T.untyped]))
             raise Geet::Shared::HttpError.new(error_message, response.code)
           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)
 
@@ -78,6 +99,12 @@ module Geet
       #   :query:       GraphQL query string
       #   :variables:   (Hash) GraphQL variables
       #
+      sig {
+        params(
+          query: String,
+          variables: T::Hash[Symbol, T.untyped]
+        ).returns(T::Hash[String, T.untyped])
+      }
       def send_graphql_request(query, variables: {})
         uri = URI(GRAPHQL_API_URL)
 
@@ -90,24 +117,32 @@ module Geet
 
           response = http.request(request)
 
-          parsed_response = JSON.parse(response.body) if response.body
+          parsed_response = T.let(nil, T.nilable(T::Hash[String, T.untyped]))
+          if response.body
+            parsed_response = T.cast(T.unsafe(JSON.parse(response.body)), T::Hash[String, T.untyped])
+          end
 
           if error?(response)
-            error_message = decode_and_format_error(parsed_response)
+            error_message = decode_and_format_error(T.must(parsed_response))
             raise Geet::Shared::HttpError.new(error_message, response.code)
           end
 
           if parsed_response&.key?('errors')
-            error_messages = parsed_response['errors'].map { |err| err['message'] }.join(', ')
+            error_messages = T.cast(parsed_response['errors'], T::Array[T::Hash[String, T.untyped]]).map { |err| T.cast(err['message'], String) }.join(', ')
             raise Geet::Shared::HttpError.new("GraphQL errors: #{error_messages}", response.code)
           end
 
-          parsed_response&.fetch('data')
+          T.cast(T.must(parsed_response).fetch('data'), T::Hash[String, T.untyped])
         end
       end
 
       private
 
+      sig {
+        params(
+          api_path: String
+        ).returns(String)
+      }
       def api_url(api_path)
         url = API_BASE_URL
 
@@ -119,6 +154,14 @@ module Geet
         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)
@@ -134,16 +177,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)
         message = parsed_response['message']
 
@@ -166,6 +225,11 @@ module Geet
         message
       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'])
@@ -175,6 +239,12 @@ module Geet
         link_header[0][/<(\S+)>; rel="next"/, 1]
       end
 
+      sig {
+        params(
+          http_method: T.nilable(Symbol),
+          data: T.nilable(T.any(T::Hash[Symbol, T.untyped], T::Array[T.untyped]))
+        ).returns(T.class_of(Net::HTTPRequest))
+      }
       def find_http_class(http_method, data)
         http_method ||= data ? :post : :get
 

data/lib/geet/github/branch.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
     class Branch
+      extend T::Sig
+
       # See https://developer.github.com/v3/git/refs/#delete-a-reference
       #
-      def self.delete(name, api_interface, **)
+      sig { params(name: String, api_interface: Geet::Github::ApiInterface).void }
+      def self.delete(name, api_interface)
         api_path = "git/refs/heads/#{name}"
 
         api_interface.send_request(api_path, http_method: :delete)

data/lib/geet/github/gist.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require_relative 'abstract_issue'
 require_relative '../github/gist'
@@ -6,29 +7,52 @@ require_relative '../github/gist'
 module Geet
   module Github
     class Gist
+      extend T::Sig
+
+      sig {
+        params(
+          filename: String,
+          content: String,
+          api_interface: Geet::Github::ApiInterface,
+          description: T.nilable(String),
+          publik: T::Boolean
+        ).returns(Geet::Github::Gist)
+      }
       def self.create(filename, content, api_interface, description: nil, publik: false)
         api_path = '/gists'
 
         request_data = prepare_request_data(filename, content, description, publik)
 
-        response = api_interface.send_request(api_path, data: request_data)
+        response = T.cast(api_interface.send_request(api_path, data: T.unsafe(request_data)), T::Hash[String, T.untyped])
 
-        id = response.fetch('id')
+        id = T.cast(response.fetch('id'), String)
 
         new(id)
       end
 
+      sig { params(id: String).void }
       def initialize(id)
         @id = id
       end
 
+      sig { returns(String) }
       def link
         "https://gist.github.com/#{@id}"
       end
 
       class << self
+        extend T::Sig
+
         private
 
+        sig {
+          params(
+            filename: String,
+            content: String,
+            description: T.nilable(String),
+            publik: T::Boolean
+          ).returns(T::Hash[String, T.untyped])
+        }
         def prepare_request_data(filename, content, description, publik)
           request_data = {
             'public' => publik,

data/lib/geet/github/issue.rb

@@ -1,20 +1,46 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
     class Issue < Geet::Github::AbstractIssue
-      def self.create(title, description, api_interface, **)
+      extend T::Sig
+
+      sig {
+        params(
+          title: String,
+          description: String,
+          api_interface: Geet::Github::ApiInterface,
+        ).returns(Geet::Github::Issue)
+      }
+      def self.create(title, description, api_interface)
         api_path = 'issues'
-        request_data = { title: title, body: description }
+        request_data = { title:, body: description }
 
-        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]
+        )
 
-        issue_number, title, link = response.fetch_values('number', 'title', 'html_url')
+        issue_number = T.cast(response.fetch('number'), Integer)
+        title = T.cast(response.fetch('title'), String)
+        link = T.cast(response.fetch('html_url'), String)
 
         new(issue_number, api_interface, title, link)
       end
 
-      def self.list(api_interface, assignee: nil, milestone: nil)
+      sig {
+        override.params(
+          api_interface: Geet::Github::ApiInterface,
+          assignee: T.nilable(Geet::Github::User),
+          milestone: T.nilable(Geet::Github::Milestone),
+          type_filter:
+            T.nilable(
+              T.proc.params(issue_data: T::Hash[String, T.untyped]).returns(T::Boolean)
+            )
+        ).returns(T::Array[Geet::Github::AbstractIssue])
+      }
+      def self.list(api_interface, assignee: nil, milestone: nil, &type_filter)
         super do |issue_data|
           !issue_data.key?('pull_request')
         end

data/lib/geet/github/label.rb

@@ -1,32 +1,56 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
     class Label
-      attr_reader :name, :color
+      extend T::Sig
 
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(String) }
+      attr_reader :color
+
+      sig {
+        params(
+          name: String,
+          color: String
+        ).void
+      }
       def initialize(name, color)
         @name = name
         @color = color
       end
 
-      # Returns a flat list of names in string form.
-      def self.list(api_interface, **)
+      sig {
+        params(
+          api_interface: Geet::Github::ApiInterface
+        ).returns(T::Array[Geet::Github::Label])
+      }
+      def self.list(api_interface)
         api_path = 'labels'
-        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 do |label_entry|
-          name = label_entry.fetch('name')
-          color = label_entry.fetch('color')
+          name = T.cast(label_entry.fetch('name'), String)
+          color = T.cast(label_entry.fetch('color'), String)
 
           new(name, color)
         end
       end
 
       # See https://developer.github.com/v3/issues/labels/#create-a-label
-      def self.create(name, color, api_interface, **)
+      sig {
+        params(
+          name: String,
+          color: String,
+          api_interface: Geet::Github::ApiInterface
+        ).returns(Geet::Github::Label)
+      }
+      def self.create(name, color, api_interface)
         api_path = 'labels'
-        request_data = { name: name, color: color }
+        request_data = { name:, color: }
 
         api_interface.send_request(api_path, data: request_data)
 

data/lib/geet/github/milestone.rb

@@ -1,18 +1,38 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Github
     class Milestone
-      attr_reader :number, :title, :due_on
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :number
+
+      sig { returns(String) }
+      attr_reader :title
+
+      sig { returns(T.nilable(Date)) }
+      attr_reader :due_on
 
       STATE_CLOSED = 'closed'
 
       class << self
+        extend T::Sig
+
         private
 
         include Helpers::JsonHelper
       end
 
+      sig {
+        params(
+          number: Integer,
+          title: String,
+          due_on: T.nilable(Date),
+          api_interface: Geet::Github::ApiInterface
+        ).void
+      }
       def initialize(number, title, due_on, api_interface)
         @number = number
         @title = title
@@ -22,14 +42,23 @@ module Geet
       end
 
       # See https://developer.github.com/v3/issues/milestones/#create-a-milestone
-      def self.create(title, api_interface, **)
+      sig {
+        params(
+          title: String,
+          api_interface: Geet::Github::ApiInterface
+        ).returns(Geet::Github::Milestone)
+      }
+      def self.create(title, api_interface)
         api_path = 'milestones'
         request_data = { title: title }
 
-        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 = response.fetch('number')
-        title = response.fetch('title')
+        number = T.cast(response.fetch('number'), Integer)
+        title = T.cast(response.fetch('title'), String)
         due_on = nil
 
         new(number, title, due_on, api_interface)
@@ -37,15 +66,25 @@ module Geet
 
       # See https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository
       #
-      def self.list(api_interface, **)
+      sig {
+        params(
+          api_interface: Geet::Github::ApiInterface
+        ).returns(T::Array[Geet::Github::Milestone])
+      }
+      def self.list(api_interface)
         api_path = 'milestones'
 
-        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 do |milestone_data|
-          number = milestone_data.fetch('number')
-          title = milestone_data.fetch('title')
-          due_on = parse_iso_8601_timestamp(milestone_data.fetch('due_on'))
+          number = T.cast(milestone_data.fetch('number'), Integer)
+          title = T.cast(milestone_data.fetch('title'), String)
+          due_on = parse_iso_8601_timestamp(
+            T.cast(milestone_data.fetch('due_on'), T.nilable(String))
+          )
 
           new(number, title, due_on, api_interface)
         end
@@ -55,7 +94,13 @@ module Geet
       #
       # This is a convenience method; the underlying operation is a generic update.
       #
-      def self.close(number, api_interface, **)
+      sig {
+        params(
+          number: Integer,
+          api_interface: Geet::Github::ApiInterface
+        ).void
+      }
+      def self.close(number, api_interface)
         api_path = "milestones/#{number}"
         request_data = { state: STATE_CLOSED }