gorails 0.1.2 → 0.1.3

data/vendor/deps/cli-kit/lib/cli/kit/opts.rb

@@ -0,0 +1,284 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class Opts
+      extend T::Sig
+
+      module Mixin
+        extend T::Sig
+        include Kernel
+
+        module MixinClassMethods
+          extend T::Sig
+
+          sig { params(included_module: Module).void }
+          def include(included_module)
+            super
+            return unless included_module.is_a?(MixinClassMethods)
+
+            included_module.tracked_methods.each { |m| track_method(m) }
+          end
+
+          # No signature - Sorbet uses method_added internally, so can't verify it
+          def method_added(method_name) # rubocop:disable Sorbet/EnforceSignatures
+            super
+            track_method(method_name)
+          end
+
+          sig { params(method_name: Symbol).void }
+          def track_method(method_name)
+            @tracked_methods ||= []
+            @tracked_methods << method_name unless @tracked_methods.include?(method_name)
+          end
+
+          sig { returns(T::Array[Symbol]) }
+          def tracked_methods
+            @tracked_methods || []
+          end
+        end
+
+        sig { params(klass: Module).void }
+        def self.included(klass)
+          klass.extend(MixinClassMethods)
+        end
+
+        sig do
+          params(
+            name: Symbol,
+            short: T.nilable(String),
+            long: T.nilable(String),
+            desc: T.nilable(String),
+            default: T.any(NilClass, String, T.proc.returns(String)),
+          ).returns(T.nilable(String))
+        end
+        def option(name: infer_name, short: nil, long: nil, desc: nil, default: nil)
+          unless default.nil?
+            raise(ArgumentError, 'declare options with non-nil defaults using `option!` instead of `option`')
+          end
+
+          case @obj
+          when Args::Definition
+            @obj.add_option(
+              name, short: short, long: long, desc: desc, default: default,
+            )
+            '(result unavailable)'
+          when Args::Evaluation
+            @obj.opt.send(name)
+          end
+        end
+
+        sig do
+          params(
+            name: Symbol,
+            short: T.nilable(String),
+            long: T.nilable(String),
+            desc: T.nilable(String),
+            default: T.any(NilClass, String, T.proc.returns(String)),
+          ).returns(String)
+        end
+        def option!(name: infer_name, short: nil, long: nil, desc: nil, default: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_option(
+              name, short: short, long: long, desc: desc, default: default,
+            )
+            '(result unavailable)'
+          when Args::Evaluation
+            @obj.opt.send(name)
+          end
+        end
+
+        sig do
+          params(
+            name: Symbol,
+            short: T.nilable(String),
+            long: T.nilable(String),
+            desc: T.nilable(String),
+          ).returns(T::Array[String])
+        end
+        def multi_option(name: infer_name, short: nil, long: nil, desc: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_option(
+              name, short: short, long: long, desc: desc, multi: true,
+            )
+            ['(result unavailable)']
+          when Args::Evaluation
+            @obj.opt.send(name)
+          end
+        end
+
+        sig do
+          params(
+            name: Symbol,
+            short: T.nilable(String),
+            long: T.nilable(String),
+            desc: T.nilable(String),
+          ).returns(T::Boolean)
+        end
+        def flag(name: infer_name, short: nil, long: nil, desc: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_flag(name, short: short, long: long, desc: desc)
+            false
+          when Args::Evaluation
+            @obj.flag.send(name)
+          end
+        end
+
+        sig { params(name: Symbol, desc: T.nilable(String)).returns(String) }
+        def position!(name: infer_name, desc: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_position(name, desc: desc, required: true, multiple: false)
+            '(result unavailable)'
+          when Args::Evaluation
+            @obj.position.send(name)
+          end
+        end
+
+        sig { params(name: Symbol, desc: T.nilable(String)).returns(T.nilable(String)) }
+        def position(name: infer_name, desc: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_position(name, desc: desc, required: false, multiple: false)
+            '(result unavailable)'
+          when Args::Evaluation
+            @obj.position.send(name)
+          end
+        end
+
+        sig { params(name: Symbol, desc: T.nilable(String)).returns(T::Array[String]) }
+        def rest(name: infer_name, desc: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_position(name, desc: desc, required: false, multiple: true)
+            ['(result unavailable)']
+          when Args::Evaluation
+            @obj.position.send(name)
+          end
+        end
+
+        private
+
+        sig { returns(Symbol) }
+        def infer_name
+          to_skip = 1
+          Kernel.caller_locations&.each do |loc|
+            next if loc.path =~ /sorbet-runtime/
+
+            if to_skip > 0
+              to_skip -= 1
+              next
+            end
+            return(T.must(loc.label&.to_sym))
+          end
+          raise(ArgumentError, 'could not infer name')
+        end
+      end
+      include(Mixin)
+
+      DEFAULT_OPTIONS = [:helpflag]
+
+      sig { returns(T::Boolean) }
+      def helpflag
+        flag(name: :help, short: '-h', long: '--help', desc: 'Show this help message')
+      end
+
+      sig { params(obj: T.any(Args::Definition, Args::Evaluation)).void }
+      def initialize(obj)
+        @obj = obj
+      end
+
+      sig { returns(T::Array[String]) }
+      def unparsed
+        obj = assert_result!
+        obj.unparsed
+      end
+
+      sig do
+        params(
+          block: T.nilable(
+            T.proc.params(arg0: Symbol, arg1: T.nilable(String)).void,
+          ),
+        ).returns(T.untyped)
+      end
+      def each_option(&block)
+        return(enum_for(:each_option)) unless block_given?
+
+        obj = assert_result!
+        obj.defn.options.each do |opt|
+          name = opt.name
+          value = obj.opt.send(name)
+          yield(name, value)
+        end
+      end
+
+      sig do
+        params(
+          block: T.nilable(
+            T.proc.params(arg0: Symbol, arg1: T::Boolean).void,
+          ),
+        ).returns(T.untyped)
+      end
+      def each_flag(&block)
+        return(enum_for(:each_flag)) unless block_given?
+
+        obj = assert_result!
+        obj.defn.flags.each do |flag|
+          name = flag.name
+          value = obj.flag.send(name)
+          yield(name, value)
+        end
+      end
+
+      sig { params(name: String).returns(T.nilable(T.any(String, T::Boolean))) }
+      def [](name)
+        obj = assert_result!
+        if obj.opt.respond_to?(name)
+          obj.opt.send(name)
+        elsif obj.flag.respond_to?(name)
+          obj.flag.send(name)
+        end
+      end
+
+      sig { params(name: String).returns(T.nilable(String)) }
+      def lookup_option(name)
+        obj = assert_result!
+        obj.opt.send(name)
+      rescue NoMethodError
+        # TODO: should we raise a KeyError?
+        nil
+      end
+
+      sig { params(name: String).returns(T::Boolean) }
+      def lookup_flag(name)
+        obj = assert_result!
+        obj.flag.send(name)
+      rescue NoMethodError
+        false
+      end
+
+      sig { returns(Args::Evaluation) }
+      def assert_result!
+        raise(NotImplementedError, 'not implemented') if @obj.is_a?(Args::Definition)
+
+        @obj
+      end
+
+      sig { void }
+      def install_to_definition
+        raise('not a Definition') unless @obj.is_a?(Args::Definition)
+
+        T.cast(self.class, Mixin::MixinClassMethods).tracked_methods.each do |m|
+          send(m)
+        end
+        DEFAULT_OPTIONS.each do |m|
+          send(m)
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/resolver.rb

@@ -0,0 +1,67 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class Resolver
+      extend T::Sig
+
+      sig { params(tool_name: String, command_registry: CLI::Kit::CommandRegistry).void }
+      def initialize(tool_name:, command_registry:)
+        @tool_name = tool_name
+        @command_registry = command_registry
+      end
+
+      sig { params(args: T::Array[String]).returns([T.class_of(CLI::Kit::BaseCommand), String, T::Array[String]]) }
+      def call(args)
+        args = args.dup
+        command_name = args.shift
+
+        command, resolved_name = @command_registry.lookup_command(command_name)
+
+        if command.nil?
+          command_not_found(command_name)
+          raise CLI::Kit::AbortSilent # Already output message
+        end
+
+        [command, resolved_name, args]
+      end
+
+      private
+
+      sig { params(name: T.nilable(String)).void }
+      def command_not_found(name)
+        CLI::UI::Frame.open('Command not found', color: :red, timing: false) do
+          $stderr.puts(CLI::UI.fmt("{{command:#{@tool_name} #{name}}} was not found"))
+        end
+
+        cmds = commands_and_aliases
+        if cmds.all? { |cmd| cmd.is_a?(String) }
+          possible_matches = cmds.min_by(2) do |cmd|
+            CLI::Kit::Levenshtein.distance(cmd, name)
+          end
+
+          # We don't want to match against any possible command
+          # so reject anything that is too far away
+          possible_matches.reject! do |possible_match|
+            CLI::Kit::Levenshtein.distance(possible_match, name) > 3
+          end
+
+          # If we have any matches left, tell the user
+          if possible_matches.any?
+            CLI::UI::Frame.open('{{bold:Did you mean?}}', timing: false, color: :blue) do
+              possible_matches.each do |possible_match|
+                $stderr.puts CLI::UI.fmt("{{command:#{@tool_name} #{possible_match}}}")
+              end
+            end
+          end
+        end
+      end
+
+      sig { returns(T::Array[String]) }
+      def commands_and_aliases
+        @command_registry.command_names + @command_registry.aliases.keys
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/sorbet_runtime_stub.rb

@@ -0,0 +1,142 @@
+# typed: ignore
+# frozen_string_literal: true
+
+module T
+  class << self
+    def absurd(value); end
+    def all(type_a, type_b, *types); end
+    def any(type_a, type_b, *types); end
+    def attached_class; end
+    def class_of(klass); end
+    def enum(values); end
+    def nilable(type); end
+    def noreturn; end
+    def self_type; end
+    def type_alias(type = nil, &_blk); end
+    def type_parameter(name); end
+    def untyped; end
+
+    def assert_type!(value, _type, _checked: true)
+      value
+    end
+
+    def cast(value, _type, _checked: true)
+      value
+    end
+
+    def let(value, _type, _checked: true)
+      value
+    end
+
+    def must(arg, _msg = nil)
+      arg
+    end
+
+    def proc
+      T::Proc.new
+    end
+
+    def reveal_type(value)
+      value
+    end
+
+    def unsafe(value)
+      value
+    end
+  end
+
+  module Sig
+    def sig(arg0 = nil, &blk); end
+  end
+
+  module Helpers
+    def abstract!; end
+    def interface!; end
+    def final!; end
+    def sealed!; end
+    def mixes_in_class_methods(mod); end
+  end
+
+  module Generic
+    include(T::Helpers)
+
+    def type_parameters(*params); end
+    def type_member(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
+    def type_template(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
+
+    def [](*types)
+      self
+    end
+  end
+
+  module Array
+    def self.[](type); end
+  end
+
+  Boolean = Object.new.freeze
+
+  module Configuration
+    def self.call_validation_error_handler(signature, opts); end
+    def self.call_validation_error_handler=(value); end
+    def self.default_checked_level=(default_checked_level); end
+    def self.enable_checking_for_sigs_marked_checked_tests; end
+    def self.enable_final_checks_on_hooks; end
+    def self.enable_legacy_t_enum_migration_mode; end
+    def self.reset_final_checks_on_hooks; end
+    def self.hard_assert_handler(str, extra); end
+    def self.hard_assert_handler=(value); end
+    def self.inline_type_error_handler(error); end
+    def self.inline_type_error_handler=(value); end
+    def self.log_info_handler(str, extra); end
+    def self.log_info_handler=(value); end
+    def self.scalar_types; end
+    def self.scalar_types=(values); end
+    # rubocop:disable Naming/InclusiveLanguage
+    def self.sealed_violation_whitelist; end
+    def self.sealed_violation_whitelist=(sealed_violation_whitelist); end
+    # rubocop:enable Naming/InclusiveLanguage
+    def self.sig_builder_error_handler=(value); end
+    def self.sig_validation_error_handler(error, opts); end
+    def self.sig_validation_error_handler=(value); end
+    def self.soft_assert_handler(str, extra); end
+    def self.soft_assert_handler=(value); end
+  end
+
+  module Enumerable
+    def self.[](type); end
+  end
+
+  module Enumerator
+    def self.[](type); end
+  end
+
+  module Hash
+    def self.[](keys, values); end
+  end
+
+  class Proc
+    def bind(*_)
+      self
+    end
+
+    def params(*_param)
+      self
+    end
+
+    def void
+      self
+    end
+
+    def returns(_type)
+      self
+    end
+  end
+
+  module Range
+    def self.[](type); end
+  end
+
+  module Set
+    def self.[](type); end
+  end
+end