geet 0.27.1 → 0.27.3

data/lib/geet/utils/attributes_selection_manager.rb

@@ -23,7 +23,7 @@ module Geet
 
       # Initialize the instance, and starts the background threads.
       #
-      sig { params(repository: T.untyped, out: T.any(IO, StringIO)).void }
+      sig { params(repository: Geet::Git::Repository, out: T.any(IO, StringIO)).void }
       def initialize(repository, out: $stdout)
         @repository = repository
         @out = out
@@ -34,13 +34,14 @@ module Geet
       #
       sig {
         params(
-          repository_call: T.untyped,
-          description: T.untyped,
-          pattern: T.untyped,
-          selection_type: T.untyped,
-          name_method: T.untyped,
-          pre_selection_hook: T.nilable(T.proc.params(all_reviewers: T::Array[T.untyped]).void)
-        ).void
+          repository_call: Symbol,
+          description: String,
+          pattern: T.nilable(String),
+          selection_type: Symbol,
+          name_method: T.nilable(Symbol),
+          pre_selection_hook: T.nilable(T.proc.params(entries: T::Array[T.anything]).returns(T::Array[T.anything]))
+        )
+        .void
       }
       def add_attribute(repository_call, description, pattern, selection_type, name_method: nil, &pre_selection_hook)
         raise "Unrecognized selection type #{selection_type.inspect}" if ![SELECTION_SINGLE, SELECTION_MULTIPLE].include?(selection_type)
@@ -52,7 +53,7 @@ module Geet
 
       # Select and return the attributes, in the same order they've been added.
       #
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[T.anything]) }
       def select_attributes
         @selections_data.map do |finder_thread, description, pattern, selection_type, name_method, pre_selection_hook|
           entries = finder_thread.value
@@ -70,6 +71,7 @@ module Geet
 
       private
 
+      sig { params(repository_call: Symbol).returns(Thread) }
       def find_attribute_entries(repository_call)
         @out.puts "Finding #{repository_call}..."
 
@@ -86,6 +88,15 @@ module Geet
       #
       #   select_entry('milestone', all_milestones, '0.1.0', :title)
       #
+      sig {
+        params(
+          entry_type: String,
+          entries: T::Array[T.anything],
+          pattern: String,
+          name_method: T.nilable(Symbol)
+        )
+        .returns(T.nilable(T.anything))
+      }
       def select_entry(entry_type, entries, pattern, name_method)
         case pattern
         when MANUAL_LIST_SELECTION_FLAG
@@ -101,13 +112,22 @@ module Geet
       #
       #   select_entries('reviewer', all_collaborators, 'donaldduck', nil)
       #
+      sig {
+        params(
+          entry_type: String,
+          entries: T::Array[T.anything],
+          pattern: T.any(String, T::Array[String]),
+          name_method: T.nilable(Symbol)
+        )
+        .returns(T::Array[T.anything])
+      }
       def select_entries(entry_type, entries, pattern, name_method)
         # Support both formats Array and String.
         # It seems that at some point, SimpleScripting started splitting arrays automatically, so until
         # the code is adjusted accordingly, this accommodates both the CLI and the test suite.
         # Tracked here: https://github.com/saveriomiroddi/geet/issues/171.
         #
-        pattern = pattern.join(',') if pattern.is_a?(Array)
+        pattern = pattern.join(",") if pattern.is_a?(Array)
 
         case pattern
         when MANUAL_LIST_SELECTION_FLAG

data/lib/geet/utils/git_client.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
-require 'English'
-require 'shellwords'
+require "English"
+require "shellwords"
 
 module Geet
   module Utils
@@ -13,8 +13,8 @@ module Geet
 
       include Geet::Helpers::OsHelper
 
-      ORIGIN_NAME = 'origin'
-      UPSTREAM_NAME = 'upstream'
+      ORIGIN_NAME = "origin"
+      UPSTREAM_NAME = "upstream"
 
       # Simplified, but good enough, pattern.
       #
@@ -38,11 +38,11 @@ module Geet
 
       REMOTE_BRANCH_REGEX = %r{\A[^/]+/(.+)\Z}
 
-      MAIN_BRANCH_CONFIG_ENTRY = 'custom.development-branch'
+      MAIN_BRANCH_CONFIG_ENTRY = "custom.development-branch"
 
       CLEAN_TREE_MESSAGE_REGEX = /^nothing to commit, working tree clean$/
 
-      sig { params(location: T.untyped ).void }
+      sig { params(location: T.nilable(String)).void }
       def initialize(location: nil)
         @location = location
       end
@@ -54,40 +54,49 @@ module Geet
       # Return the commit SHAs between :head and :upstream, excluding the already applied commits
       # (which start with `-`)
       #
-      # - upstream: String; pass :main_branch to use the main branch
-      # - head:     String (optional); pass :main_branch to use the main branch
-      #
+      sig {
+        params(
+          upstream: T.any(String, Symbol),       # pass :main_branch to use the main branch
+          head: T.nilable(T.any(String, Symbol)) # pass :main_branch to use the main branch
+        )
+        .returns(T::Array[String])
+      }
       def cherry(upstream, head: nil)
         upstream = main_branch if upstream == :main_branch
         head = main_branch if head == :main_branch
 
-        git_params = [upstream, head].compact.map(&:shellescape)
+        git_params = [upstream, head].compact.map { |param| param.to_s.shellescape }
 
         raw_commits = execute_git_command("cherry #{git_params.join(' ')}")
 
-        raw_commits.split("\n").grep(/^\+/).map { |line| line[3..-1] }
+        raw_commits.split("\n").grep(/^\+/).map { |line| T.must(line[3..-1]) }
       end
 
+      sig { returns(String) }
       def current_branch
         branch = execute_git_command("rev-parse --abbrev-ref HEAD")
 
-        raise "Couldn't find current branch" if branch == 'HEAD'
+        raise "Couldn't find current branch" if branch == "HEAD"
 
         branch
       end
 
       # This API doesn't reveal if the remote branch is gone.
       #
-      # qualify: (false) include the remote if true, don't otherwise
-      #
       # return: nil, if the remote branch is not configured.
       #
+      sig {
+        params(
+          qualify: T::Boolean # include the remote if true, don't otherwise
+        )
+        .returns(T.nilable(String))
+      }
       def remote_branch(qualify: false)
         head_symbolic_ref = execute_git_command("symbolic-ref -q HEAD")
 
         raw_remote_branch = execute_git_command("for-each-ref --format='%(upstream:short)' #{head_symbolic_ref.shellescape}").strip
 
-        if raw_remote_branch != ''
+        if raw_remote_branch != ""
           if qualify
             raw_remote_branch
           else
@@ -106,6 +115,7 @@ module Geet
       #     ## add_milestone_closing...origin/add_milestone_closing [gone]
       #      M spec/integration/merge_pr_spec.rb
       #
+      sig { returns(T::Boolean) }
       def remote_branch_gone?
         git_command = "status -b --porcelain"
         status_output = execute_git_command(git_command)
@@ -122,12 +132,13 @@ module Geet
 
       # See https://saveriomiroddi.github.io/Conveniently-Handling-non-master-development-default-branches-in-git-hub
       #
+      sig { returns(String) }
       def main_branch
         branch_name = execute_git_command("config --get #{MAIN_BRANCH_CONFIG_ENTRY}", allow_error: true)
 
         if branch_name.empty?
           full_branch_name = execute_git_command("rev-parse --abbrev-ref #{ORIGIN_NAME}/HEAD")
-          full_branch_name.split('/').last
+          T.must(full_branch_name.split("/").last)
         else
           branch_name
         end
@@ -135,18 +146,21 @@ module Geet
 
       # List of different commits between local and corresponding remote branch.
       #
+      sig { returns(String) }
       def remote_branch_diff_commits
-        remote_branch = remote_branch(qualify: true)
+        remote_branch = T.must(remote_branch(qualify: true))
 
         execute_git_command("rev-list #{remote_branch.shellescape}..HEAD")
       end
 
+      sig { returns(String) }
       def remote_branch_diff
-        remote_branch = remote_branch(qualify: true)
+        remote_branch = T.must(remote_branch(qualify: true))
 
         execute_git_command("diff #{remote_branch.shellescape}")
       end
 
+      sig { returns(T::Boolean) }
       def working_tree_clean?
         git_message = execute_git_command("status")
 
@@ -159,6 +173,7 @@ module Geet
 
       # Show the description ("<subject>\n\n<body>") for the given git object.
       #
+      sig { params(object: String).returns(String) }
       def show_description(object)
         execute_git_command("show --quiet --format='%s\n\n%b' #{object.shellescape}")
       end
@@ -170,26 +185,35 @@ module Geet
       # Return the components of the remote, according to REMOTE_URL_REGEX; doesn't include the full
       # match.
       #
+      sig {
+        params(
+          name: T.nilable(String) # remote name
+        )
+        .returns(T::Array[T.nilable(String)])
+      }
       def remote_components(name: nil)
-        remote.match(REMOTE_URL_REGEX)[1..]
+        T.must(remote.match(REMOTE_URL_REGEX))[1..]
       end
 
       # Example: `donaldduck/geet`
       #
+      sig { params(upstream: T::Boolean).returns(String) }
       def path(upstream: false)
         remote_name_option = upstream ? {name: UPSTREAM_NAME} : {}
 
-        remote(**remote_name_option)[REMOTE_URL_REGEX, 4]
+        T.must(remote(**remote_name_option)[REMOTE_URL_REGEX, 4])
       end
 
+      sig { returns(String) }
       def owner
-        path.split('/')[0]
+        T.must(path.split("/")[0])
       end
 
+      sig { returns(String) }
       def provider_domain
         # We assume that it's not possible to have origin and upstream on different providers.
 
-        domain = remote()[REMOTE_URL_REGEX, 2]
+        domain = T.must(remote()[REMOTE_URL_REGEX, 2])
 
         raise "Can't identify domain in the provider domain string: #{domain}" if domain !~ /\w+\.\w+/
 
@@ -201,9 +225,12 @@ module Geet
       #
       # The result is in the format `git@github.com:donaldduck/geet.git`
       #
-      # options
-      #   :name:           remote name; if unspecified, the default remote is used.
-      #
+      sig {
+        params(
+          name: T.nilable(String) # remote name; if unspecified, the default remote is used
+        )
+        .returns(String)
+      }
       def remote(name: nil)
         remote_url = execute_git_command("ls-remote --get-url #{name}")
 
@@ -219,6 +246,7 @@ module Geet
       # Doesn't sanity check for the remote url format; this action is for querying
       # purposes, any any action that needs to work with the remote, uses #remote.
       #
+      sig { params(name: T.nilable(String)).returns(T::Boolean) }
       def remote_defined?(name)
         remote_url = execute_git_command("ls-remote --get-url #{name}")
 
@@ -231,22 +259,30 @@ module Geet
       # OPERATION APIS
       ##########################################################################
 
+      sig { params(branch: String).returns(String) }
       def checkout(branch)
         execute_git_command("checkout #{branch.shellescape}")
       end
 
+      sig { params(branch: String, force: T::Boolean).returns(String) }
       def delete_branch(branch, force:)
         force_option = "--force" if force
 
         execute_git_command("branch --delete #{force_option} #{branch.shellescape}")
       end
 
+      sig { returns(String) }
       def rebase
         execute_git_command("rebase")
       end
 
-      # remote_branch: create an upstream branch.
-      #
+      sig {
+        params(
+          remote_branch: T.nilable(String), # create an upstream branch
+          force: T::Boolean
+        )
+        .returns(String)
+      }
       def push(remote_branch: nil, force: false)
         remote_branch_option = "-u #{ORIGIN_NAME} #{remote_branch.shellescape}" if remote_branch
 
@@ -255,10 +291,12 @@ module Geet
 
       # Performs pruning.
       #
+      sig { returns(String) }
       def fetch
         execute_git_command("fetch --prune")
       end
 
+      sig { params(name: String, url: String).returns(String) }
       def add_remote(name, url)
         execute_git_command("remote add #{name.shellescape} #{url}")
       end
@@ -272,14 +310,17 @@ module Geet
       # If executing a git command without calling this API, don't forget to split `gitdir_option`
       # and use it!
       #
-      # options (passed to :execute_command):
-      # - allow_error
-      # - (others)
-      #
+      sig {
+        params(
+          command: String,
+          options: T.untyped # passed to :execute_command (e.g., allow_error)
+        )
+        .returns(String)
+      }
       def execute_git_command(command, **options)
         gitdir_option = "-C #{@location.shellescape}" if @location
 
-        execute_command("git #{gitdir_option} #{command}", **options)
+        T.must(execute_command("git #{gitdir_option} #{command}", **options))
       end
     end
   end

data/lib/geet/utils/manual_list_selection.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 # typed: strict
 
-require 'tty-prompt'
+require "tty-prompt"
 
 module Geet
   module Utils
     class ManualListSelection
       extend T::Sig
 
-      NO_SELECTION_KEY = '(none)'
+      NO_SELECTION_KEY = "(none)"
 
       PAGER_SIZE = 16
 
@@ -54,27 +54,34 @@ module Geet
 
         check_entries(entries, entry_type)
 
-        entries = create_entries_map(entries, name_method)
+        entries_map = create_entries_map(entries, name_method)
 
-        show_prompt(:multi_select, entry_type, entries)
+        T.cast(show_prompt(:multi_select, entry_type, entries_map), T::Array[T.type_parameter(:T)])
       end
 
       private
 
-      sig { params(entries: T::Array[T.untyped], entry_type: String).void }
+      sig {
+        type_parameters(:T).params(
+          entries: T::Array[T.type_parameter(:T)],
+          entry_type: String
+        )
+        .void
+      }
       def check_entries(entries, entry_type)
         raise "No #{entry_type} provided!" if entries.empty?
       end
 
       sig {
-        params(
-          entries: T::Array[T.untyped],
+        type_parameters(:T).params(
+          entries: T::Array[T.type_parameter(:T)],
           name_method: T.nilable(Symbol)
-        ).returns(T::Hash[String, T.untyped])
+        )
+        .returns(T::Hash[String, T.type_parameter(:T)])
       }
       def create_entries_map(entries, name_method)
         entries.each_with_object({}) do |entry, current_map|
-          key = name_method ? entry.send(name_method) : entry
+          key = name_method ? T.unsafe(entry).send(name_method) : entry
           current_map[key] = entry
         end
       end
@@ -101,9 +108,14 @@ module Geet
         ::TTY::Prompt.new.send(invocation_method, prompt_title, entries, filter: true, per_page: PAGER_SIZE)
       end
 
-      sig { params(entry: T.untyped).returns(T::Boolean) }
+      sig {
+        params(
+          entry: T.anything
+        )
+        .returns(T::Boolean)
+      }
       def no_selection?(entry)
-        entry == NO_SELECTION_KEY
+        T.unsafe(entry) == NO_SELECTION_KEY
       end
     end
   end

data/lib/geet/utils/string_matching_selection.rb

@@ -6,16 +6,24 @@ module Geet
     class StringMatchingSelection
       extend T::Sig
 
-      sig { params(entry_type: String, entries: T::Array[T.untyped], pattern: String, name_method: T.nilable(Symbol)).returns(T.untyped) }
+      sig {
+        type_parameters(:T).params(
+          entry_type: String,
+          entries: T::Array[T.type_parameter(:T)],
+          pattern: String,
+          name_method: T.nilable(Symbol)
+        )
+        .returns(T.type_parameter(:T))
+      }
       def select_entry(entry_type, entries, pattern, name_method: nil)
         entries_found = entries.select do |entry|
-          entry = entry.send(name_method) if name_method
-          entry.downcase == pattern.downcase
+          compared_entry = name_method ? T.unsafe(entry).send(name_method) : entry
+          T.unsafe(compared_entry).downcase == pattern.downcase
         end
 
         case entries_found.size
         when 1
-          entries_found.first
+          T.must(entries_found.first)
         when 0
           raise "No entry found for #{entry_type} pattern: #{pattern.inspect}"
         else
@@ -23,9 +31,17 @@ module Geet
         end
       end
 
-      sig { params(entry_type: String, entries: T::Array[T.untyped], raw_patterns: String, name_method: T.nilable(Symbol)).returns(T::Array[T.untyped]) }
+      sig {
+        type_parameters(:T).params(
+          entry_type: String,
+          entries: T::Array[T.type_parameter(:T)],
+          raw_patterns: String,
+          name_method: T.nilable(Symbol)
+        )
+        .returns(T::Array[T.type_parameter(:T)])
+      }
       def select_entries(entry_type, entries, raw_patterns, name_method: nil)
-        patterns = raw_patterns.split(',')
+        patterns = raw_patterns.split(",")
 
         patterns.map do |pattern|
           # Haha.

data/lib/geet/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
-  VERSION = '0.27.1'
+  VERSION = "0.27.3"
 end

data/lib/geet.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'sorbet-runtime'
-require 'zeitwerk'
+require "sorbet-runtime"
+require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect("pr" => "PR")

data/spec/integration/comment_pr_spec.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-require_relative '../../lib/geet/git/repository'
-require_relative '../../lib/geet/services/comment_pr'
+require_relative "../../lib/geet/git/repository"
+require_relative "../../lib/geet/services/comment_pr"
 
 describe Geet::Services::CommentPr do
   let(:git_client) { Geet::Utils::GitClient.new }
   let(:repository) { Geet::Git::Repository.new(git_client: git_client) }
-  let(:owner) { 'donaldduck' }
-  let(:branch) { 'mybranch' }
-  let(:comment) { 'this is a programmatically added comment' }
+  let(:owner) { "donaldduck" }
+  let(:branch) { "mybranch" }
+  let(:comment) { "this is a programmatically added comment" }
 
-  context 'with github.com' do
-    let(:repository_name) { 'testrepo_upstream' }
+  context "with github.com" do
+    let(:repository_name) { "testrepo_upstream" }
 
-    it 'should add a comment to the PR for the current branch' do
+    it "should add a comment to the PR for the current branch" do
       allow(git_client).to receive(:current_branch).and_return(branch)
       allow(git_client).to receive(:remote).with(no_args).and_return("git@github.com:#{owner}/#{repository_name}")
 
@@ -27,7 +27,7 @@ describe Geet::Services::CommentPr do
       actual_output = StringIO.new
       service_instance = described_class.new(repository, out: actual_output, git_client: git_client)
 
-      service_result = VCR.use_cassette('github_com/comment_pr') do
+      service_result = VCR.use_cassette("github_com/comment_pr") do
         service_instance.execute(comment)
       end
 

data/spec/integration/create_gist_spec.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'tmpdir'
+require "spec_helper"
+require "tmpdir"
 
-require_relative '../../lib/geet/git/repository'
-require_relative '../../lib/geet/services/create_gist'
+require_relative "../../lib/geet/git/repository"
+require_relative "../../lib/geet/services/create_gist"
 
 describe Geet::Services::CreateGist do
-  let(:temp_filename) { File.join(Dir.tmpdir, 'geet_gist_test.md') }
-  let(:temp_file) { File.open(temp_filename, 'w') { |file| file << 'testcontent' } }
+  let(:temp_filename) { File.join(Dir.tmpdir, "geet_gist_test.md") }
+  let(:temp_file) { File.open(temp_filename, "w") { |file| file << "testcontent" } }
 
-  it 'should create a public gist' do
+  it "should create a public gist" do
     expected_output = <<~STR
       Creating a public gist...
       Gist address: https://gist.github.com/b01dface
@@ -18,16 +18,16 @@ describe Geet::Services::CreateGist do
 
     actual_output = StringIO.new
 
-    VCR.use_cassette('create_gist_public') do
+    VCR.use_cassette("create_gist_public") do
       described_class.new(out: actual_output).execute(
-        temp_file.path, description: 'testdescription', publik: true
+        temp_file.path, description: "testdescription", publik: true
       )
     end
 
     expect(actual_output.string).to eql(expected_output)
   end
 
-  it 'should create a private gist' do
+  it "should create a private gist" do
     expected_output = <<~STR
       Creating a private gist...
       Gist address: https://gist.github.com/deadbeef
@@ -35,9 +35,9 @@ describe Geet::Services::CreateGist do
 
     actual_output = StringIO.new
 
-    VCR.use_cassette('create_gist_private') do
+    VCR.use_cassette("create_gist_private") do
       described_class.new(out: actual_output).execute(
-        temp_file.path, description: 'testdescription'
+        temp_file.path, description: "testdescription"
       )
     end