geet 0.22.0 → 0.24.0

data/lib/geet/shared/selection.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Shared
     module Selection
-      MANUAL_LIST_SELECTION_FLAG = '-'.freeze
+      MANUAL_LIST_SELECTION_FLAG = '-'
       # Don't select anything; return the null value.
-      SKIP_LIST_SELECTION_FLAG = ''.freeze
+      SKIP_LIST_SELECTION_FLAG = ''
 
       SELECTION_SINGLE = :single
       SELECTION_MULTIPLE = :multiple

data/lib/geet/utils/attributes_selection_manager.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
-
-require_relative 'manual_list_selection'
-require_relative 'string_matching_selection'
-require_relative '../shared/selection'
+# typed: true
 
 module Geet
   module Utils
@@ -14,6 +11,8 @@ module Geet
     # multiple attributes are required (typically, three).
     #
     class AttributesSelectionManager
+      extend T::Sig
+
       include Geet::Shared::Selection
 
       # Workaround for VCR not supporting multithreading; see https://github.com/vcr/vcr/issues/200.
@@ -24,6 +23,7 @@ module Geet
 
       # Initialize the instance, and starts the background threads.
       #
+      sig { params(repository: T.untyped, out: T.any(IO, StringIO)).void }
       def initialize(repository, out: $stdout)
         @repository = repository
         @out = out
@@ -32,6 +32,16 @@ module Geet
 
       # selection_type: SELECTION_SINGLE or SELECTION_MULTIPLE
       #
+      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
+      }
       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)
 
@@ -42,6 +52,7 @@ module Geet
 
       # Select and return the attributes, in the same order they've been added.
       #
+      sig { returns(T.untyped) }
       def select_attributes
         @selections_data.map do |finder_thread, description, pattern, selection_type, name_method, pre_selection_hook|
           entries = finder_thread.value

data/lib/geet/utils/git_client.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
+# typed: true
 
 require 'English'
 require 'shellwords'
-require_relative '../helpers/os_helper'
 
 module Geet
   module Utils
     # Represents the git program interface; used for performing git operations.
     #
     class GitClient
+      extend T::Sig
+
       include Geet::Helpers::OsHelper
 
       ORIGIN_NAME = 'origin'
@@ -40,6 +42,7 @@ module Geet
 
       CLEAN_TREE_MESSAGE_REGEX = /^nothing to commit, working tree clean$/
 
+      sig { params(location: T.untyped ).void }
       def initialize(location: nil)
         @location = location
       end

data/lib/geet/utils/manual_list_selection.rb

@@ -1,27 +1,28 @@
 # frozen_string_literal: true
+# typed: strict
 
 require 'tty-prompt'
 
 module Geet
   module Utils
     class ManualListSelection
+      extend T::Sig
+
       NO_SELECTION_KEY = '(none)'
 
       PAGER_SIZE = 16
 
       # Shows a prompt for selecting an entry from a list.
       #
-      # Returns nil, without showing the prompt, if there are no entries.
-      #
-      # entry_type:      description of the entries type.
-      # entries:         array of objects; if they're not strings, must also pass :name_method.
-      #                  this value must not be empty.
-      # name_method:     required when non-string objects are passed as entries; its invocation on
-      #                  each object must return a string, which is used as key.
-      #
-      # returns: the selected entry. if the null entry (NO_SELECTION_KEY) is selected, nil is
-      #          returned.
-      #
+      sig {
+        type_parameters(:T).params(
+          entry_type: String,                        # description of the entries type.
+          entries: T::Array[T.type_parameter(:T)],   # array of objects; if they're not strings, must also pass :name_method.
+          name_method: T.nilable(Symbol)             # required when non-string objects are passed as entries; its invocation
+                                                     # on each object must return a string, which is used as key.
+        ).returns(T.nilable(T.type_parameter(:T)))   # selected entry. nil is returned if the null entry (NO_SELECTION_KEY) is
+                                                     # selected, or if there are no entries.
+      }
       def select_entry(entry_type, entries, name_method: nil)
         return nil if entries.empty?
 
@@ -37,12 +38,17 @@ module Geet
 
       # Shows a prompt for selecting an entry from a list.
       #
-      # Returns an empty array, without showing the prompt, if there are no entries.
-      #
       # See #select_entry for the parameters.
       #
       # returns: array of entries.
       #
+      sig {
+        type_parameters(:T).params(
+          entry_type: String,
+          entries: T::Array[T.type_parameter(:T)],
+          name_method: T.nilable(Symbol)
+        ).returns(T::Array[T.type_parameter(:T)])   # empty array, without showing the prompt, if there are no entries.
+      }
       def select_entries(entry_type, entries, name_method: nil)
         return [] if entries.empty?
 
@@ -55,10 +61,17 @@ module Geet
 
       private
 
+      sig { params(entries: T::Array[T.untyped], 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],
+          name_method: T.nilable(Symbol)
+        ).returns(T::Hash[String, T.untyped])
+      }
       def create_entries_map(entries, name_method)
         entries.each_with_object({}) do |entry, current_map|
           key = name_method ? entry.send(name_method) : entry
@@ -66,17 +79,29 @@ module Geet
         end
       end
 
+      sig {
+        type_parameters(:T).params(entries: T::Hash[String, T.type_parameter(:T)]
+        ).returns(T::Hash[String, T.type_parameter(:T)])
+      }
       def add_no_selection_entry(entries)
         {NO_SELECTION_KEY => nil}.merge(entries)
       end
 
+      sig {
+        type_parameters(:T).params(
+          invocation_method: Symbol,
+          entry_type: String,
+          entries: T::Hash[String, T.type_parameter(:T)]
+        ).returns(T.type_parameter(:T))
+      }
       def show_prompt(invocation_method, entry_type, entries)
         # Arguably inexact phrasing for avoiding language complexities.
         prompt_title = "Please select the #{entry_type}(s):"
 
-        TTY::Prompt.new.send(invocation_method, prompt_title, entries, filter: true, per_page: PAGER_SIZE)
+        ::TTY::Prompt.new.send(invocation_method, prompt_title, entries, filter: true, per_page: PAGER_SIZE)
       end
 
+      sig { params(entry: T.untyped).returns(T::Boolean) }
       def no_selection?(entry)
         entry == NO_SELECTION_KEY
       end

data/lib/geet/utils/string_matching_selection.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
+# typed: strict
 
 module Geet
   module Utils
     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) }
       def select_entry(entry_type, entries, pattern, name_method: nil)
         entries_found = entries.select do |entry|
           entry = entry.send(name_method) if name_method
@@ -19,6 +23,7 @@ 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]) }
       def select_entries(entry_type, entries, raw_patterns, name_method: nil)
         patterns = raw_patterns.split(',')
 

data/lib/geet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geet
-  VERSION = '0.22.0'
+  VERSION = '0.24.0'
 end

data/lib/geet.rb

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

data/sorbet/config

@@ -0,0 +1,7 @@
+--disable-watchman
+--suppress-payload-superclass-redefinition-for=Reline::ANSI
+--dir=.
+--ignore=spec
+# Without a Bundler lockfile, we need to ignore gems vendored in CI, to avoid typechecking gem sources
+# that may clash with those in the repo.
+--ignore=vendor/bundle

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end

data/sorbet/rbi/annotations/webmock.rbi

@@ -0,0 +1,9 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class Minitest::Test
+  include WebMock::API
+end

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true