geet 0.27.2 → 0.27.3

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.2'
+  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
 

data/spec/integration/create_issue_spec.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-require_relative '../../lib/geet/git/repository'
-require_relative '../../lib/geet/services/create_issue'
+require_relative "../../lib/geet/git/repository"
+require_relative "../../lib/geet/services/create_issue"
 
 describe Geet::Services::CreateIssue do
   let(:git_client) { Geet::Utils::GitClient.new }
   let(:repository) { Geet::Git::Repository.new(warnings: false, git_client: git_client) }
   let(:upstream_repository) { Geet::Git::Repository.new(upstream: true, git_client: git_client) }
 
-  context 'with labels, assignees and milestones' do
-    it 'should create an issue' do
-      allow(git_client).to receive(:remote).with(no_args).and_return('git@github.com:donaldduck/testrepo_f')
+  context "with labels, assignees and milestones" do
+    it "should create an issue" do
+      allow(git_client).to receive(:remote).with(no_args).and_return("git@github.com:donaldduck/testrepo_f")
 
       expected_output = <<~STR
         Finding labels...
@@ -27,27 +27,27 @@ describe Geet::Services::CreateIssue do
 
       actual_output = StringIO.new
 
-      actual_created_issue = VCR.use_cassette('create_issue') do
+      actual_created_issue = VCR.use_cassette("create_issue") do
         described_class.new(repository, out: actual_output).execute(
-          'Title', 'Description',
-          labels: 'bug,invalid', milestone: '0.0.1', assignees: 'donaldduck,donald-fr',
+          "Title", "Description",
+          labels: "bug,invalid", milestone: "0.0.1", assignees: "donaldduck,donald-fr",
         )
       end
 
       expect(actual_output.string).to eql(expected_output)
 
       expect(actual_created_issue.number).to eql(2)
-      expect(actual_created_issue.title).to eql('Title')
-      expect(actual_created_issue.link).to eql('https://github.com/donaldduck/testrepo_f/issues/2')
+      expect(actual_created_issue.title).to eql("Title")
+      expect(actual_created_issue.link).to eql("https://github.com/donaldduck/testrepo_f/issues/2")
     end
   end
 
-  context 'without write permissions' do
-    context 'without labels, assignees and milestones' do
-      it 'should create an upstream issue' do
-        allow(git_client).to receive(:current_branch).and_return('mybranch')
-        allow(git_client).to receive(:remote).with(no_args).and_return('git@github.com:donaldduck/testrepo')
-        allow(git_client).to receive(:remote).with(name: 'upstream').and_return('git@github.com:momcorp/therepo')
+  context "without write permissions" do
+    context "without labels, assignees and milestones" do
+      it "should create an upstream issue" do
+        allow(git_client).to receive(:current_branch).and_return("mybranch")
+        allow(git_client).to receive(:remote).with(no_args).and_return("git@github.com:donaldduck/testrepo")
+        allow(git_client).to receive(:remote).with(name: "upstream").and_return("git@github.com:momcorp/therepo")
 
         expected_output = <<~STR
           Creating the issue...
@@ -56,15 +56,15 @@ describe Geet::Services::CreateIssue do
 
         actual_output = StringIO.new
 
-        actual_created_issue = VCR.use_cassette('create_issue_upstream') do
-          described_class.new(upstream_repository, out: actual_output).execute('Title', 'Description')
+        actual_created_issue = VCR.use_cassette("create_issue_upstream") do
+          described_class.new(upstream_repository, out: actual_output).execute("Title", "Description")
         end
 
         expect(actual_output.string).to eql(expected_output)
 
         expect(actual_created_issue.number).to eql(42)
-        expect(actual_created_issue.title).to eql('Title')
-        expect(actual_created_issue.link).to eql('https://github.com/momcorp/therepo/issues/42')
+        expect(actual_created_issue.title).to eql("Title")
+        expect(actual_created_issue.link).to eql("https://github.com/momcorp/therepo/issues/42")
       end
     end
   end