fluid_cli 0.1.2

data/vendor/deps/cli-kit/lib/cli/kit/args/definition.rb

@@ -0,0 +1,286 @@
+# typed: true
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      class Definition
+        Error = Class.new(Args::Error)
+        ConflictingFlag = Class.new(Error)
+        InvalidFlag = Class.new(Error)
+        InvalidLookup = Class.new(Error)
+        InvalidPosition = Class.new(Error)
+
+        #: Array[Flag]
+        attr_reader :flags
+
+        #: Array[Option]
+        attr_reader :options
+
+        #: Array[Position]
+        attr_reader :positions
+
+        #: (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)
+          add_resolution(flag)
+          @flags << flag
+        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(
+            name: name, short: short, long: long, desc: desc, default: default,
+            required: required, multi: multi
+          )
+          add_resolution(option)
+          @options << option
+        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,
+            default: default, skip: skip
+          )
+          validate_order(position)
+          add_name_resolution(position)
+          @positions << position
+        end
+
+        #: -> void
+        def initialize
+          @flags = []
+          @options = []
+          @by_short = {}
+          @by_long = {}
+          @by_name = {}
+          @positions = []
+        end
+
+        module OptBase
+          #: Symbol
+          attr_reader :name
+
+          #: String?
+          attr_reader :desc
+        end
+
+        module OptValue
+          #: -> (String | Array[String])?
+          def default
+            if @default.is_a?(Proc)
+              @default.call
+            else
+              @default
+            end
+          end
+
+          #: -> bool
+          def dynamic_default?
+            @default.is_a?(Proc)
+          end
+
+          #: -> bool
+          def required?
+            @required
+          end
+
+          #: -> bool
+          def multi?
+            @multi
+          end
+
+          #: -> bool
+          def optional?
+            !required?
+          end
+        end
+
+        class Flag
+          include OptBase
+
+          #: String?
+          attr_reader :short
+
+          #: String?
+          attr_reader :long
+
+          #: -> String
+          def as_written_by_user
+            long ? "--#{long}" : "-#{short}"
+          end
+
+          #: (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')
+            end
+
+            @name = name
+            @short = short
+            @long = long
+            @desc = desc
+          end
+        end
+
+        class Position
+          include OptBase
+          include OptValue
+
+          #: (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')
+            end
+
+            @name = name
+            @desc = desc
+            @required = required
+            @multi = multi
+            @default = default
+            @skip = skip
+          end
+
+          #: (String arg) -> bool
+          def skip?(arg)
+            if @skip.nil?
+              false
+            elsif @skip.arity == 0
+              prc = @skip #: as ^() -> bool
+              prc.call
+            else
+              prc = @skip #: as ^(String) -> bool
+              prc.call(arg)
+            end
+          end
+        end
+
+        class Option < Flag
+          include OptValue
+
+          #: (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')
+            end
+
+            super(name: name, short: short, long: long, desc: desc)
+            @default = default
+            @required = required
+            @multi = multi
+          end
+        end
+
+        #: (Symbol name) -> Flag?
+        def lookup_flag(name)
+          flagopt = @by_name[name]
+          if flagopt.class == Flag
+            flagopt
+          end
+        end
+
+        #: (Symbol name) -> Option?
+        def lookup_option(name)
+          flagopt = @by_name[name]
+          if flagopt.class == Option
+            flagopt
+          end
+        end
+
+        #: (String name) -> (Flag | Option)?
+        def lookup_short(name)
+          raise(InvalidLookup, "invalid '-' prefix") if name.start_with?('-')
+
+          @by_short[name]
+        end
+
+        #: (String name) -> (Flag | Option)?
+        def lookup_long(name)
+          raise(InvalidLookup, "invalid '-' prefix") if name.start_with?('-')
+
+          @by_long[name]
+        end
+
+        #: (Symbol name) -> Position?
+        def lookup_position(name)
+          position = @by_name[name]
+          if position.class == Position
+            position
+          end
+        end
+
+        private
+
+        #: (Position position) -> void
+        def validate_order(position)
+          raise(InvalidPosition, 'Cannot have any more positional arguments after multi') if @positions.last&.multi?
+        end
+
+        #: (String short) -> String
+        def strip_short_prefix(short)
+          unless short.match?(/^-[^-]/)
+            raise(InvalidFlag, "Short flag '#{short}' does not start with '-'")
+          end
+          if short.size != 2
+            raise(InvalidFlag, 'Short flag must be a single character')
+          end
+
+          short.sub(/^-/, '')
+        end
+
+        #: (String long) -> String
+        def strip_long_prefix(long)
+          unless long.match?(/^--[^-]/)
+            raise(InvalidFlag, "Long flag '#{long}' does not start with '--'")
+          end
+
+          long.sub(/^--/, '')
+        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')
+          end
+
+          short = strip_short_prefix(short) if short
+          long = strip_long_prefix(long) if long
+
+          [short, long]
+        end
+
+        #: (Flag flagopt) -> void
+        def add_resolution(flagopt)
+          if flagopt.short
+            if (existing = @by_short[flagopt.short])
+              raise(ConflictingFlag, "Short flag '#{flagopt.short}' already defined by #{existing.name}")
+            end
+
+            @by_short[flagopt.short] = flagopt
+          end
+          if flagopt.long
+            if (existing = @by_long[flagopt.long])
+              raise(ConflictingFlag, "Long flag '#{flagopt.long}' already defined by #{existing.name}")
+            end
+
+            @by_long[flagopt.long] = flagopt
+          end
+          add_name_resolution(flagopt)
+        end
+
+        #: ((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}")
+          end
+
+          @by_name[arg.name] = arg
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/args/evaluation.rb

@@ -0,0 +1,215 @@
+# typed: true
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      class Evaluation
+        Error = Class.new(Args::Error)
+
+        class MissingRequiredOption < Error
+          #: (String name) -> void
+          def initialize(name)
+            super("missing required option `#{name}'")
+          end
+        end
+
+        class MissingRequiredPosition < Error
+          #: -> void
+          def initialize
+            super('more arguments required')
+          end
+        end
+
+        class TooManyPositions < Error
+          #: -> void
+          def initialize
+            super('too many arguments')
+          end
+        end
+
+        class FlagProxy
+          #: (Symbol sym) -> bool
+          def method_missing(sym)
+            flag = @evaluation.defn.lookup_flag(sym)
+            unless flag
+              raise NoMethodError, "undefined flag `#{sym}' for #{self}"
+            end
+
+            @evaluation.send(:lookup_flag, flag)
+          end
+
+          #: (Symbol sym, ?bool include_private) -> bool
+          def respond_to_missing?(sym, include_private = false)
+            !!@evaluation.defn.lookup_flag(sym)
+          end
+
+          #: (Evaluation evaluation) -> void
+          def initialize(evaluation)
+            @evaluation = evaluation
+          end
+        end
+
+        class OptionProxy
+          #: (Symbol sym) -> (String | Array[String])?
+          def method_missing(sym)
+            opt = @evaluation.defn.lookup_option(sym)
+            unless opt
+              raise NoMethodError, "undefined option `#{sym}' for #{self}"
+            end
+
+            @evaluation.send(:lookup_option, opt)
+          end
+
+          #: (Symbol sym, ?bool include_private) -> bool
+          def respond_to_missing?(sym, include_private = false)
+            !!@evaluation.defn.lookup_option(sym)
+          end
+
+          #: (Evaluation evaluation) -> void
+          def initialize(evaluation)
+            @evaluation = evaluation
+          end
+        end
+
+        class PositionProxy
+          #: (Symbol sym) -> (String | Array[String])?
+          def method_missing(sym)
+            position = @evaluation.defn.lookup_position(sym)
+            unless position
+              raise NoMethodError, "undefined position `#{sym}' for #{self}"
+            end
+
+            @evaluation.send(:lookup_position, position)
+          end
+
+          #: (Symbol sym, ?bool include_private) -> bool
+          def respond_to_missing?(sym, include_private = false)
+            !!@evaluation.defn.lookup_position(sym)
+          end
+
+          #: (Evaluation evaluation) -> void
+          def initialize(evaluation)
+            @evaluation = evaluation
+          end
+        end
+
+        #: -> FlagProxy
+        def flag
+          @flag_proxy ||= FlagProxy.new(self)
+        end
+
+        #: -> OptionProxy
+        def opt
+          @option_proxy ||= OptionProxy.new(self)
+        end
+
+        #: -> PositionProxy
+        def position
+          @position_proxy ||= PositionProxy.new(self)
+        end
+
+        #: Definition
+        attr_reader :defn
+
+        #: Array[Parser::Node]
+        attr_reader :parse
+
+        #: -> Array[String]
+        def unparsed
+          @unparsed ||= begin
+            nodes = parse.select { |node| node.is_a?(Parser::Node::Unparsed) } #: as Array[Parser::Node::Unparsed]
+            nodes.flat_map(&:value)
+          end
+        end
+
+        #: (Definition defn, Array[Parser::Node] parse) -> void
+        def initialize(defn, parse)
+          @defn = defn
+          @parse = parse
+          check_required_options!
+        end
+
+        #: -> void
+        def check_required_options!
+          @defn.options.each do |opt|
+            next unless opt.required?
+
+            node = @parse.detect do |node|
+              node.is_a?(Parser::Node::Option) && node.name.to_sym == opt.name
+            end
+            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
+
+        #: -> 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?(
+              args[args_i], #: as !nil
+            )
+
+            if position.multi?
+              @position_values[position.name] = args[args_i..]
+              args_i = args.size
+            else
+              @position_values[position.name] = args[args_i] #: as !nil
+              args_i += 1
+            end
+          end
+          raise(TooManyPositions) if args_i < args.size
+        end
+
+        #: (Definition::Flag flag) -> bool
+        def lookup_flag(flag)
+          if flag.short
+            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 = 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
+
+        #: (Definition::Option opt) -> (String | Array[String])?
+        def lookup_option(opt)
+          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)
+          end
+
+          opt.default
+        end
+
+        #: (Definition::Position position) -> (String | Array[String])?
+        def lookup_position(position)
+          @position_values.fetch(position.name) { position.multi? ? [] : position.default }
+        end
+
+        private
+
+        #: -> Array[String]
+        def args
+          @args ||= begin
+            nodes = parse.select { |node| node.is_a?(Parser::Node::Argument) } #: as Array[Parser::Node::Argument]
+            nodes.map(&:value)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/args/parser/node.rb

@@ -0,0 +1,128 @@
+# typed: true
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      class Parser
+        class Node
+          #: -> void
+          def initialize
+          end
+
+          #: (untyped other) -> bool
+          def ==(other)
+            self.class == other.class
+          end
+
+          class Option < Node
+            #: String
+            attr_reader :name
+
+            #: String
+            attr_reader :value
+
+            #: (String name, String value) -> void
+            def initialize(name, value)
+              @name = name
+              @value = value
+              super()
+            end
+            private_class_method(:new) # don't instantiate this class directly
+
+            #: -> String
+            def inspect
+              "#<#{self.class.name} #{@name}=#{@value}>"
+            end
+
+            #: (untyped other) -> bool
+            def ==(other)
+              !!(super(other) && @value == other.value && @name == other.name)
+            end
+          end
+
+          class LongOption < Option
+            public_class_method(:new)
+          end
+
+          class ShortOption < Option
+            public_class_method(:new)
+          end
+
+          class Flag < Node
+            #: String
+            attr_reader :value
+
+            #: (String value) -> void
+            def initialize(value)
+              @value = value
+              super()
+            end
+            private_class_method(:new) # don't instantiate this class directly
+
+            #: -> String
+            def inspect
+              "#<#{self.class.name} #{@value}>"
+            end
+
+            #: (untyped other) -> bool
+            def ==(other)
+              !!(super(other) && @value == other.value)
+            end
+          end
+
+          class LongFlag < Flag
+            public_class_method(:new)
+          end
+
+          class ShortFlag < Flag
+            public_class_method(:new)
+          end
+
+          class Argument < Node
+            #: String
+            attr_reader :value
+
+            #: (String value) -> void
+            def initialize(value)
+              @value = value
+              super()
+            end
+
+            #: -> String
+            def inspect
+              "#<#{self.class.name} #{@value}>"
+            end
+
+            #: (untyped other) -> bool
+            def ==(other)
+              !!(super(other) && @value == other.value)
+            end
+          end
+
+          class Unparsed < Node
+            #: Array[String]
+            attr_reader :value
+
+            #: (Array[String] value) -> void
+            def initialize(value)
+              @value = value
+              super()
+            end
+
+            #: -> String
+            def inspect
+              "#<#{self.class.name} #{@value.join(" ")}>"
+            end
+
+            #: (untyped other) -> bool
+            def ==(other)
+              !!(super(other) && @value == other.value)
+            end
+          end
+        end
+      end
+    end
+  end
+end