fluid_cli 0.1.2

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

@@ -0,0 +1,92 @@
+# typed: true
+
+# Copyright (c) 2014-2016 Yuki Nishijima
+
+# MIT License
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Levenshtein
+      
+
+      # This code is based directly on the Text gem implementation
+      # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
+      #
+      # Returns a value representing the "cost" of transforming str1 into str2
+      #: (String str1, String str2) -> Integer
+      def distance(str1, str2)
+        n = str1.length
+        m = str2.length
+        return m if n.zero?
+        return n if m.zero?
+
+        d = (0..m).to_a
+        x = 0
+
+        # to avoid duplicating an enumerable object, create it outside of the loop
+        str2_codepoints = str2.codepoints
+
+        str1.each_codepoint.with_index(1) do |char1, i|
+          j = 0
+          while j < m
+            cost = char1 == str2_codepoints[j] ? 0 : 1
+            a = d[j] #: as !nil
+            b = d[j + 1] #: as !nil
+            x = min3(
+              b + 1,
+              i + 1, # deletion
+              a + cost, # substitution
+            )
+            d[j] = i
+            i = x
+
+            j += 1
+          end
+          d[m] = x
+        end
+
+        x
+      end
+      module_function :distance
+
+      private
+
+      # detects the minimum value out of three arguments. This method is
+      # faster than `[a, b, c].min` and puts less GC pressure.
+      # See https://github.com/yuki24/did_you_mean/pull/1 for a performance
+      # benchmark.
+      #: (Integer a, Integer b, Integer c) -> Integer
+      def min3(a, b, c)
+        if a < b && a < c
+          a
+        elsif b < c
+          b
+        else
+          c
+        end
+      end
+      module_function :min3
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# typed: true
+
+require 'cli/kit'
+require 'logger'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Logger
+      MAX_LOG_SIZE = 5 * 1024 * 1000 # 5MB
+      MAX_NUM_LOGS = 10
+
+      # Constructor for CLI::Kit::Logger
+      #
+      # @param debug_log_file [String] path to the file where debug logs should be stored
+      #: (debug_log_file: String, ?env_debug_name: String) -> void
+      def initialize(debug_log_file:, env_debug_name: 'DEBUG')
+        FileUtils.mkpath(File.dirname(debug_log_file))
+        @debug_logger = ::Logger.new(debug_log_file, MAX_NUM_LOGS, MAX_LOG_SIZE)
+        @env_debug_name = env_debug_name
+      end
+
+      # Functionally equivalent to Logger#info
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      #: (String msg, ?debug: bool) -> void
+      def info(msg, debug: true)
+        $stdout.puts CLI::UI.fmt(msg)
+        @debug_logger.info(format_debug(msg)) if debug
+      end
+
+      # Functionally equivalent to Logger#warn
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      #: (String msg, ?debug: bool) -> void
+      def warn(msg, debug: true)
+        $stdout.puts CLI::UI.fmt("{{yellow:#{msg}}}")
+        @debug_logger.warn(format_debug(msg)) if debug
+      end
+
+      # Functionally equivalent to Logger#error
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      #: (String msg, ?debug: bool) -> void
+      def error(msg, debug: true)
+        $stderr.puts CLI::UI.fmt("{{red:#{msg}}}")
+        @debug_logger.error(format_debug(msg)) if debug
+      end
+
+      # Functionally equivalent to Logger#fatal
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      #: (String msg, ?debug: bool) -> void
+      def fatal(msg, debug: true)
+        $stderr.puts CLI::UI.fmt("{{red:{{bold:Fatal:}} #{msg}}}")
+        @debug_logger.fatal(format_debug(msg)) if debug
+      end
+
+      # Similar to Logger#debug, however will not output to STDOUT unless DEBUG env var is set
+      # Logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      #: (String msg) -> void
+      def debug(msg)
+        $stdout.puts CLI::UI.fmt(msg) if debug?
+        @debug_logger.debug(format_debug(msg))
+      end
+
+      private
+
+      #: (String msg) -> String
+      def format_debug(msg)
+        msg = CLI::UI.fmt(msg)
+        return msg unless CLI::UI::StdoutRouter.current_id
+
+        "[#{CLI::UI::StdoutRouter.current_id&.fetch(:id, nil)}] #{msg}"
+      end
+
+      #: -> bool
+      def debug?
+        val = ENV[@env_debug_name]
+        !!val && val != '0' && val != ''
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+# typed: true
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class Opts
+      module Mixin
+        include Kernel
+
+        module MixinClassMethods
+          #: (Module included_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
+
+          #: (Symbol method_name) -> void
+          def track_method(method_name)
+            @tracked_methods ||= []
+            @tracked_methods << method_name unless @tracked_methods.include?(method_name)
+          end
+
+          #: -> Array[Symbol]
+          def tracked_methods
+            @tracked_methods || []
+          end
+        end
+
+        class << self
+          #: (Module klass) -> void
+          def included(klass)
+            klass.extend(MixinClassMethods)
+          end
+        end
+
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String)?) -> String?
+        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
+
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String)?) -> String
+        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
+
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (Array[String] | ^-> Array[String])) -> Array[String]
+        def multi_option(name: infer_name, short: nil, long: nil, desc: nil, default: [])
+          case @obj
+          when Args::Definition
+            @obj.add_option(
+              name, short: short, long: long, desc: desc, default: default, multi: true
+            )
+            ['(result unavailable)']
+          when Args::Evaluation
+            @obj.opt.send(name)
+          end
+        end
+
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?) -> bool
+        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
+
+        #: (?name: Symbol, ?desc: String?) -> String
+        def position!(name: infer_name, desc: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_position(name, desc: desc, required: true, multi: false)
+            '(result unavailable)'
+          when Args::Evaluation
+            @obj.position.send(name)
+          end
+        end
+
+        #: (?name: Symbol, ?desc: String?, ?default: (String | ^-> String)?, ?skip: (^-> bool | ^(String arg0) -> bool)?) -> String?
+        def position(name: infer_name, desc: nil, default: nil, skip: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_position(name, desc: desc, required: false, multi: false, default: default, skip: skip)
+            '(result unavailable)'
+          when Args::Evaluation
+            @obj.position.send(name)
+          end
+        end
+
+        #: (?name: Symbol, ?desc: String?) -> Array[String]
+        def rest(name: infer_name, desc: nil)
+          case @obj
+          when Args::Definition
+            @obj.add_position(name, desc: desc, required: false, multi: true)
+            ['(result unavailable)']
+          when Args::Evaluation
+            @obj.position.send(name)
+          end
+        end
+
+        private
+
+        #: (String? label) -> Symbol?
+        def symbolize(label)
+          return if label.nil?
+
+          label.split('#').last&.to_sym
+        end
+
+        #: -> 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 symbolize(loc.label) #: as !nil
+          end
+          raise(ArgumentError, 'could not infer name')
+        end
+      end
+      include(Mixin)
+
+      DEFAULT_OPTIONS = [:helpflag]
+
+      #: -> bool
+      def helpflag
+        flag(name: :help, short: '-h', long: '--help', desc: 'Show this help message')
+      end
+
+      #: -> Array[String]
+      def unparsed
+        obj = assert_result!
+        obj.unparsed
+      end
+
+      #: ?{ (Symbol arg0, String? arg1) -> void } -> untyped
+      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
+
+      #: ?{ (Symbol arg0, bool arg1) -> void } -> untyped
+      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
+
+      #: (String name) -> (String | bool)?
+      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
+
+      #: (String name) -> String?
+      def lookup_option(name)
+        obj = assert_result!
+        obj.opt.send(name)
+      rescue NoMethodError
+        # TODO: should we raise a KeyError?
+        nil
+      end
+
+      #: (String name) -> bool
+      def lookup_flag(name)
+        obj = assert_result!
+        obj.flag.send(name)
+      rescue NoMethodError
+        false
+      end
+
+      #: -> Args::Evaluation
+      def assert_result!
+        raise(NotImplementedError, 'not implemented') if @obj.is_a?(Args::Definition)
+
+        @obj
+      end
+
+      #: (Args::Definition defn) -> void
+      def define!(defn)
+        @obj = defn
+        klass = self.class #: as Mixin::MixinClassMethods
+        klass.tracked_methods.each do |m|
+          send(m)
+        end
+        DEFAULT_OPTIONS.each do |m|
+          send(m)
+        end
+      end
+
+      #: (Args::Evaluation ev) -> void
+      def evaluate!(ev)
+        @obj = ev
+        ev.resolve_positions!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# typed: true
+
+module CLI
+  module Kit
+    module ParseArgs
+      # because sorbet type-checking takes the pedantic route that module doesn't include Kernel, therefore
+      # this is necessary (even tho it's ~probably fine~)
+      include Kernel
+
+      # untyped is used in two places. The interpretation of dynamic values from the provided `opts`
+      # and the resulting args[:opts] is pretty broad. There seems to be minimal value in expressing a
+      # tighter subset of untyped.
+
+      #: ((Array | String) args, Hash[Symbol, Array[untyped]] opts_defn) -> Hash[Symbol, untyped]
+      def parse_args(args, opts_defn)
+        start_opts, parser_config = opts_defn.reduce([{}, []]) do |(ini, pcfg), (n, cfg)|
+          (vals, desc, short, klass) = cfg
+          (init_val, def_val) = Array(vals)
+
+          [
+            init_val.nil? ? ini : ini.merge(n => init_val),
+            pcfg + [[n, short, desc, def_val, klass]],
+          ]
+        end
+
+        require('optparse')
+
+        acc_opts = {}
+        prsr = OptionParser.new do |opt_p|
+          parser_config.each do |(n, short, desc, def_val, klass)|
+            (_, mark) = short.split(' ')
+            long = "--#{n.to_s.tr("_", "-")}" + (mark.nil? ? '' : " #{mark}")
+            opt_args = klass.nil? ? [short, long, desc] : [short, long, klass, desc]
+
+            unsafe_opt_p = opt_p #: as untyped
+            unsafe_opt_p.on(*opt_args) do |v|
+              acc_opts[n] = if acc_opts.key?(n)
+                Array(acc_opts[n]) + Array(v || def_val)
+              else
+                v || def_val
+              end
+            end
+          end
+        end
+
+        arg_v = (args.is_a?(Array) ? args : args.strip.split(/\s+/)).map(&:strip)
+        sub = prsr.parse(arg_v)
+
+        { opts: start_opts.merge(acc_opts) }.tap do |a|
+          a[:sub] = sub if sub
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# typed: true
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class Resolver
+      #: (tool_name: String, command_registry: CLI::Kit::CommandRegistry) -> void
+      def initialize(tool_name:, command_registry:)
+        @tool_name = tool_name
+        @command_registry = command_registry
+      end
+
+      #: (Array[String] args) -> [singleton(CLI::Kit::BaseCommand), String, 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
+
+      #: (String? name) -> 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
+
+      #: -> Array[String]
+      def commands_and_aliases
+        @command_registry.command_names + @command_registry.aliases.keys
+      end
+    end
+  end
+end