cli-kit 5.1.0 → 5.2.0

data/lib/cli/kit/args/definition.rb

@@ -6,24 +6,22 @@ module CLI
   module Kit
     module Args
       class Definition
-        extend T::Sig
-
         Error = Class.new(Args::Error)
         ConflictingFlag = Class.new(Error)
         InvalidFlag = Class.new(Error)
         InvalidLookup = Class.new(Error)
         InvalidPosition = Class.new(Error)
 
-        sig { returns(T::Array[Flag]) }
+        #: Array[Flag]
         attr_reader :flags
 
-        sig { returns(T::Array[Option]) }
+        #: Array[Option]
         attr_reader :options
 
-        sig { returns(T::Array[Position]) }
+        #: Array[Position]
         attr_reader :positions
 
-        sig { params(name: Symbol, short: T.nilable(String), long: T.nilable(String), desc: T.nilable(String)).void }
+        #: (Symbol name, ?short: String?, ?long: String?, ?desc: String?) -> void
         def add_flag(name, short: nil, long: nil, desc: nil)
           short, long = strip_prefixes_and_validate(short, long)
           flag = Flag.new(name: name, short: short, long: long, desc: desc)
@@ -31,18 +29,7 @@ module CLI
           @flags << flag
         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),
-              T::Array[String], T.proc.returns(T::Array[String])
-            ),
-            required: T::Boolean, multi: T::Boolean
-          ).void
-        end
+        #: (Symbol name, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String | Array[String] | ^-> Array[String])?, ?required: bool, ?multi: bool) -> void
         def add_option(name, short: nil, long: nil, desc: nil, default: nil, required: false, multi: false)
           short, long = strip_prefixes_and_validate(short, long)
           option = Option.new(
@@ -53,20 +40,7 @@ module CLI
           @options << option
         end
 
-        sig do
-          params(
-            name: Symbol,
-            required: T::Boolean,
-            multi: T::Boolean,
-            desc: T.nilable(String),
-            default: T.any(NilClass, String, T.proc.returns(String)),
-            skip: T.any(
-              NilClass,
-              T.proc.returns(T::Boolean),
-              T.proc.params(arg0: String).returns(T::Boolean),
-            ),
-          ).void
-        end
+        #: (Symbol name, required: bool, multi: bool, ?desc: String?, ?default: (String | ^-> String)?, ?skip: (^-> bool | ^(String arg0) -> bool)?) -> void
         def add_position(name, required:, multi:, desc: nil, default: nil, skip: nil)
           position = Position.new(
             name: name, desc: desc, required: required, multi: multi,
@@ -77,7 +51,7 @@ module CLI
           @positions << position
         end
 
-        sig { void }
+        #: -> void
         def initialize
           @flags = []
           @options = []
@@ -88,19 +62,15 @@ module CLI
         end
 
         module OptBase
-          extend T::Sig
-
-          sig { returns(Symbol) }
+          #: Symbol
           attr_reader :name
 
-          sig { returns(T.nilable(String)) }
+          #: String?
           attr_reader :desc
         end
 
         module OptValue
-          extend T::Sig
-
-          sig { returns(T.any(NilClass, String, T::Array[String])) }
+          #: -> (String | Array[String])?
           def default
             if @default.is_a?(Proc)
               @default.call
@@ -109,43 +79,42 @@ module CLI
             end
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def dynamic_default?
             @default.is_a?(Proc)
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def required?
             @required
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def multi?
             @multi
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def optional?
             !required?
           end
         end
 
         class Flag
-          extend T::Sig
           include OptBase
 
-          sig { returns(T.nilable(String)) }
+          #: String?
           attr_reader :short
 
-          sig { returns(T.nilable(String)) }
+          #: String?
           attr_reader :long
 
-          sig { returns(String) }
+          #: -> String
           def as_written_by_user
             long ? "--#{long}" : "-#{short}"
           end
 
-          sig { params(name: Symbol, short: T.nilable(String), long: T.nilable(String), desc: T.nilable(String)).void }
+          #: (name: Symbol, ?short: String?, ?long: String?, ?desc: String?) -> void
           def initialize(name:, short: nil, long: nil, desc: nil)
             if long&.start_with?('-') || short&.start_with?('-')
               raise(ArgumentError, 'invalid - prefix')
@@ -159,24 +128,10 @@ module CLI
         end
 
         class Position
-          extend T::Sig
           include OptBase
           include OptValue
 
-          sig do
-            params(
-              name: Symbol,
-              desc: T.nilable(String),
-              required: T::Boolean,
-              multi: T::Boolean,
-              default: T.any(NilClass, String, T.proc.returns(String)),
-              skip: T.any(
-                NilClass,
-                T.proc.returns(T::Boolean),
-                T.proc.params(arg0: String).returns(T::Boolean),
-              ),
-            ).void
-          end
+          #: (name: Symbol, desc: String?, required: bool, multi: bool, ?default: (String | ^-> String)?, ?skip: (^-> bool | ^(String arg0) -> bool)?) -> void
           def initialize(name:, desc:, required:, multi:, default: nil, skip: nil)
             if multi && (default || required)
               raise(ArgumentError, 'multi-valued positions cannot have a default or required value')
@@ -190,34 +145,24 @@ module CLI
             @skip = skip
           end
 
-          sig { params(arg: String).returns(T::Boolean) }
+          #: (String arg) -> bool
           def skip?(arg)
             if @skip.nil?
               false
-            elsif T.must(@skip).arity == 0
-              T.cast(@skip, T.proc.returns(T::Boolean)).call
+            elsif @skip.arity == 0
+              prc = @skip #: as ^() -> bool
+              prc.call
             else
-              T.cast(@skip, T.proc.params(arg0: String).returns(T::Boolean)).call(arg)
+              prc = @skip #: as ^(String) -> bool
+              prc.call(arg)
             end
           end
         end
 
         class Option < Flag
-          extend T::Sig
           include OptValue
 
-          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),
-                T::Array[String], T.proc.returns(T::Array[String])
-              ),
-              required: T::Boolean, multi: T::Boolean
-            ).void
-          end
+          #: (name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String | Array[String] | ^-> Array[String])?, ?required: bool, ?multi: bool) -> void
           def initialize(name:, short: nil, long: nil, desc: nil, default: nil, required: false, multi: false)
             if multi && required
               raise(ArgumentError, 'multi-valued options cannot have a required value')
@@ -230,7 +175,7 @@ module CLI
           end
         end
 
-        sig { params(name: Symbol).returns(T.nilable(Flag)) }
+        #: (Symbol name) -> Flag?
         def lookup_flag(name)
           flagopt = @by_name[name]
           if flagopt.class == Flag
@@ -238,7 +183,7 @@ module CLI
           end
         end
 
-        sig { params(name: Symbol).returns(T.nilable(Option)) }
+        #: (Symbol name) -> Option?
         def lookup_option(name)
           flagopt = @by_name[name]
           if flagopt.class == Option
@@ -246,21 +191,21 @@ module CLI
           end
         end
 
-        sig { params(name: String).returns(T.any(Flag, Option, NilClass)) }
+        #: (String name) -> (Flag | Option)?
         def lookup_short(name)
           raise(InvalidLookup, "invalid '-' prefix") if name.start_with?('-')
 
           @by_short[name]
         end
 
-        sig { params(name: String).returns(T.any(Flag, Option, NilClass)) }
+        #: (String name) -> (Flag | Option)?
         def lookup_long(name)
           raise(InvalidLookup, "invalid '-' prefix") if name.start_with?('-')
 
           @by_long[name]
         end
 
-        sig { params(name: Symbol).returns(T.nilable(Position)) }
+        #: (Symbol name) -> Position?
         def lookup_position(name)
           position = @by_name[name]
           if position.class == Position
@@ -270,12 +215,12 @@ module CLI
 
         private
 
-        sig { params(position: Position).void }
+        #: (Position position) -> void
         def validate_order(position)
           raise(InvalidPosition, 'Cannot have any more positional arguments after multi') if @positions.last&.multi?
         end
 
-        sig { params(short: String).returns(String) }
+        #: (String short) -> String
         def strip_short_prefix(short)
           unless short.match?(/^-[^-]/)
             raise(InvalidFlag, "Short flag '#{short}' does not start with '-'")
@@ -287,7 +232,7 @@ module CLI
           short.sub(/^-/, '')
         end
 
-        sig { params(long: String).returns(String) }
+        #: (String long) -> String
         def strip_long_prefix(long)
           unless long.match?(/^--[^-]/)
             raise(InvalidFlag, "Long flag '#{long}' does not start with '--'")
@@ -296,10 +241,7 @@ module CLI
           long.sub(/^--/, '')
         end
 
-        sig do
-          params(short: T.nilable(String), long: T.nilable(String))
-            .returns([T.nilable(String), T.nilable(String)])
-        end
+        #: (String? short, String? long) -> [String?, String?]
         def strip_prefixes_and_validate(short, long)
           if short.nil? && long.nil?
             raise(Error, 'One or more of short and long must be specified')
@@ -311,7 +253,7 @@ module CLI
           [short, long]
         end
 
-        sig { params(flagopt: Flag).void }
+        #: (Flag flagopt) -> void
         def add_resolution(flagopt)
           if flagopt.short
             if (existing = @by_short[flagopt.short])
@@ -330,7 +272,7 @@ module CLI
           add_name_resolution(flagopt)
         end
 
-        sig { params(arg: T.any(Flag, Position)).void }
+        #: ((Flag | Position) arg) -> void
         def add_name_resolution(arg)
           if (existing = @by_name[arg.name])
             raise(ConflictingFlag, "Flag '#{arg.name}' already defined by #{existing.name}")

data/lib/cli/kit/args/evaluation.rb

@@ -6,38 +6,31 @@ module CLI
   module Kit
     module Args
       class Evaluation
-        extend T::Sig
-
         Error = Class.new(Args::Error)
 
         class MissingRequiredOption < Error
-          extend T::Sig
-          sig { params(name: String).void }
+          #: (String name) -> void
           def initialize(name)
             super("missing required option `#{name}'")
           end
         end
 
         class MissingRequiredPosition < Error
-          extend T::Sig
-          sig { void }
+          #: -> void
           def initialize
             super('more arguments required')
           end
         end
 
         class TooManyPositions < Error
-          extend T::Sig
-          sig { void }
+          #: -> void
           def initialize
             super('too many arguments')
           end
         end
 
         class FlagProxy
-          extend T::Sig
-
-          sig { params(sym: Symbol).returns(T::Boolean) }
+          #: (Symbol sym) -> bool
           def method_missing(sym)
             flag = @evaluation.defn.lookup_flag(sym)
             unless flag
@@ -47,21 +40,19 @@ module CLI
             @evaluation.send(:lookup_flag, flag)
           end
 
-          sig { params(sym: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+          #: (Symbol sym, ?bool include_private) -> bool
           def respond_to_missing?(sym, include_private = false)
             !!@evaluation.defn.lookup_flag(sym)
           end
 
-          sig { params(evaluation: Evaluation).void }
+          #: (Evaluation evaluation) -> void
           def initialize(evaluation)
             @evaluation = evaluation
           end
         end
 
         class OptionProxy
-          extend T::Sig
-
-          sig { params(sym: Symbol).returns(T.any(NilClass, String, T::Array[String])) }
+          #: (Symbol sym) -> (String | Array[String])?
           def method_missing(sym)
             opt = @evaluation.defn.lookup_option(sym)
             unless opt
@@ -71,21 +62,19 @@ module CLI
             @evaluation.send(:lookup_option, opt)
           end
 
-          sig { params(sym: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+          #: (Symbol sym, ?bool include_private) -> bool
           def respond_to_missing?(sym, include_private = false)
             !!@evaluation.defn.lookup_option(sym)
           end
 
-          sig { params(evaluation: Evaluation).void }
+          #: (Evaluation evaluation) -> void
           def initialize(evaluation)
             @evaluation = evaluation
           end
         end
 
         class PositionProxy
-          extend T::Sig
-
-          sig { params(sym: Symbol).returns(T.any(NilClass, String, T::Array[String])) }
+          #: (Symbol sym) -> (String | Array[String])?
           def method_missing(sym)
             position = @evaluation.defn.lookup_position(sym)
             unless position
@@ -95,57 +84,54 @@ module CLI
             @evaluation.send(:lookup_position, position)
           end
 
-          sig { params(sym: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+          #: (Symbol sym, ?bool include_private) -> bool
           def respond_to_missing?(sym, include_private = false)
             !!@evaluation.defn.lookup_position(sym)
           end
 
-          sig { params(evaluation: Evaluation).void }
+          #: (Evaluation evaluation) -> void
           def initialize(evaluation)
             @evaluation = evaluation
           end
         end
 
-        sig { returns(FlagProxy) }
+        #: -> FlagProxy
         def flag
           @flag_proxy ||= FlagProxy.new(self)
         end
 
-        sig { returns(OptionProxy) }
+        #: -> OptionProxy
         def opt
           @option_proxy ||= OptionProxy.new(self)
         end
 
-        sig { returns(PositionProxy) }
+        #: -> PositionProxy
         def position
           @position_proxy ||= PositionProxy.new(self)
         end
 
-        sig { returns(Definition) }
+        #: Definition
         attr_reader :defn
 
-        sig { returns(T::Array[Parser::Node]) }
+        #: Array[Parser::Node]
         attr_reader :parse
 
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def unparsed
           @unparsed ||= begin
-            nodes = T.cast(
-              parse.select { |node| node.is_a?(Parser::Node::Unparsed) },
-              T::Array[Parser::Node::Unparsed],
-            )
+            nodes = parse.select { |node| node.is_a?(Parser::Node::Unparsed) } #: as Array[Parser::Node::Unparsed]
             nodes.flat_map(&:value)
           end
         end
 
-        sig { params(defn: Definition, parse: T::Array[Parser::Node]).void }
+        #: (Definition defn, Array[Parser::Node] parse) -> void
         def initialize(defn, parse)
           @defn = defn
           @parse = parse
           check_required_options!
         end
 
-        sig { void }
+        #: -> void
         def check_required_options!
           @defn.options.each do |opt|
             next unless opt.required?
@@ -153,56 +139,54 @@ module CLI
             node = @parse.detect do |node|
               node.is_a?(Parser::Node::Option) && node.name.to_sym == opt.name
             end
-            if !node || T.cast(node, Parser::Node::Option).value.nil?
+            unless node
+              raise(MissingRequiredOption, opt.as_written_by_user)
+            end
+
+            node = node #: as Parser::Node::Option
+            if node.value.nil?
               raise(MissingRequiredOption, opt.as_written_by_user)
             end
           end
         end
 
-        sig { void }
+        #: -> void
         def resolve_positions!
           args_i = 0
           @position_values = Hash.new
           @defn.positions.each do |position|
             raise(MissingRequiredPosition) if position.required? && args_i >= args.size
-            next if args_i >= args.size || position.skip?(T.must(args[args_i]))
+            next if args_i >= args.size || position.skip?(
+              args[args_i], #: as !nil
+            )
 
             if position.multi?
               @position_values[position.name] = args[args_i..]
               args_i = args.size
             else
-              @position_values[position.name] = T.must(args[args_i])
+              @position_values[position.name] = args[args_i] #: as !nil
               args_i += 1
             end
           end
           raise(TooManyPositions) if args_i < args.size
         end
 
-        sig { params(flag: Definition::Flag).returns(T::Boolean) }
+        #: (Definition::Flag flag) -> bool
         def lookup_flag(flag)
           if flag.short
-            flags = T.cast(
-              parse.select { |node| node.is_a?(Parser::Node::ShortFlag) },
-              T::Array[Parser::Node::ShortFlag],
-            )
+            flags = parse.select { |node| node.is_a?(Parser::Node::ShortFlag) } #: as Array[Parser::Node::ShortFlag]
             return true if flags.any? { |node| node.value == flag.short }
           end
           if flag.long
-            flags = T.cast(
-              parse.select { |node| node.is_a?(Parser::Node::LongFlag) },
-              T::Array[Parser::Node::LongFlag],
-            )
+            flags = parse.select { |node| node.is_a?(Parser::Node::LongFlag) } #: as Array[Parser::Node::LongFlag]
             return true if flags.any? { |node| node.value == flag.long }
           end
           false
         end
 
-        sig { params(opt: Definition::Option).returns(T.any(NilClass, String, T::Array[String])) }
+        #: (Definition::Option opt) -> (String | Array[String])?
         def lookup_option(opt)
-          opts = T.cast(
-            parse.select { |node| node.is_a?(Parser::Node::ShortOption) || node.is_a?(Parser::Node::LongOption) },
-            T::Array[T.any(Parser::Node::ShortOption, Parser::Node::LongOption)],
-          )
+          opts = parse.select { |node| node.is_a?(Parser::Node::ShortOption) || node.is_a?(Parser::Node::LongOption) } #: as Array[Parser::Node::ShortOption | Parser::Node::LongOption]
           matches = opts.select { |node| (opt.short && node.name == opt.short) || (opt.long && node.name == opt.long) }
           if (last = matches.last)
             return (opt.multi? ? matches.map(&:value) : last.value)
@@ -211,20 +195,17 @@ module CLI
           opt.default
         end
 
-        sig { params(position: Definition::Position).returns(T.any(NilClass, String, T::Array[String])) }
+        #: (Definition::Position position) -> (String | Array[String])?
         def lookup_position(position)
           @position_values.fetch(position.name) { position.multi? ? [] : position.default }
         end
 
         private
 
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def args
           @args ||= begin
-            nodes = T.cast(
-              parse.select { |node| node.is_a?(Parser::Node::Argument) },
-              T::Array[Parser::Node::Argument],
-            )
+            nodes = parse.select { |node| node.is_a?(Parser::Node::Argument) } #: as Array[Parser::Node::Argument]
             nodes.map(&:value)
           end
         end