fluid_cli 0.1.2

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

@@ -0,0 +1,150 @@
+# typed: true
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class CommandRegistry
+      #: type command_or_proc = singleton(CLI::Kit::BaseCommand) | ^() -> singleton(CLI::Kit::BaseCommand)
+
+      #: Hash[String, command_or_proc]
+      attr_reader :commands
+
+      #: Hash[String, String]
+      attr_reader :aliases
+
+      # @interface
+      module ContextualResolver
+        # @abstract
+        #: -> Array[String]
+        def command_names
+          raise(NotImplementedError)
+        end
+
+        # @abstract
+        #: -> Hash[String, String]
+        def aliases
+          raise(NotImplementedError)
+        end
+
+        # @abstract
+        #: (String) -> singleton(CLI::Kit::BaseCommand)
+        def command_class(_name)
+          raise(NotImplementedError)
+        end
+      end
+
+      module NullContextualResolver
+        extend ContextualResolver
+
+        class << self
+          # @override
+          #: -> Array[String]
+          def command_names
+            []
+          end
+
+          # @override
+          #: -> Hash[String, String]
+          def aliases
+            {}
+          end
+
+          # @override
+          #: (String _name) -> singleton(CLI::Kit::BaseCommand)
+          def command_class(_name)
+            raise(CLI::Kit::Abort, 'Cannot be called on the NullContextualResolver since command_names is empty')
+          end
+        end
+      end
+
+      #: (default: String, ?contextual_resolver: ContextualResolver) -> void
+      def initialize(default:, contextual_resolver: NullContextualResolver)
+        @commands = {}
+        @aliases  = {}
+        @default = default
+        @contextual_resolver = contextual_resolver
+      end
+
+      #: -> Hash[String, singleton(CLI::Kit::BaseCommand)]
+      def resolved_commands
+        @commands.each_with_object({}) do |(k, v), a|
+          a[k] = resolve_class(v)
+        end
+      end
+
+      #: (command_or_proc const, String name) -> void
+      def add(const, name)
+        commands[name] = const
+      end
+
+      #: (String? name) -> [singleton(CLI::Kit::BaseCommand)?, String]
+      def lookup_command(name)
+        name = @default if name.to_s.empty?
+        resolve_command(
+          name, #: as !nil
+        )
+      end
+
+      #: (String from, String to) -> void
+      def add_alias(from, to)
+        aliases[from] = to unless aliases[from]
+      end
+
+      #: -> Array[String]
+      def command_names
+        @contextual_resolver.command_names + commands.keys
+      end
+
+      #: (String name) -> bool
+      def exist?(name)
+        !resolve_command(name).first.nil?
+      end
+
+      private
+
+      #: (String name) -> String
+      def resolve_alias(name)
+        aliases[name] || @contextual_resolver.aliases.fetch(name, name)
+      end
+
+      #: (String name) -> [singleton(CLI::Kit::BaseCommand)?, String]
+      def resolve_command(name)
+        name = resolve_alias(name)
+        resolve_global_command(name) ||
+          resolve_contextual_command(name) ||
+          [nil, name]
+      end
+
+      #: (String name) -> [singleton(CLI::Kit::BaseCommand), String]?
+      def resolve_global_command(name)
+        klass = resolve_class(commands.fetch(name, nil))
+        return unless klass
+
+        [klass, name]
+      rescue NameError
+        nil
+      end
+
+      #: (String name) -> [singleton(CLI::Kit::BaseCommand), String]?
+      def resolve_contextual_command(name)
+        found = @contextual_resolver.command_names.include?(name)
+        return unless found
+
+        [@contextual_resolver.command_class(name), name]
+      end
+
+      #: (command_or_proc? class_or_proc) -> singleton(CLI::Kit::BaseCommand)?
+      def resolve_class(class_or_proc)
+        case class_or_proc
+        when nil
+          nil
+        when Proc
+          class_or_proc.call
+        else
+          class_or_proc
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# typed: true
+
+require 'cli/kit'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Config
+      XDG_CONFIG_HOME = 'XDG_CONFIG_HOME'
+
+      #: (tool_name: String) -> void
+      def initialize(tool_name:)
+        @tool_name = tool_name
+      end
+
+      # Returns the config corresponding to `name` from the config file
+      # `false` is returned if it doesn't exist
+      #
+      # #### Parameters
+      # `section` : the section of the config value you are looking for
+      # `name` : the name of the config value you are looking for
+      #
+      # #### Returns
+      # `value` : the value of the config variable (nil if none)
+      #
+      # #### Example Usage
+      # `config.get('name.of.config')`
+      #
+      #: (String section, String name, ?default: String?) -> String?
+      def get(section, name, default: nil)
+        all_configs.dig("[#{section}]", name) || default
+      end
+
+      # Coalesce and enforce the value of a config to a boolean
+      #: (String section, String name, ?default: bool?) -> bool?
+      def get_bool(section, name, default: false)
+        case get(section, name)
+        when 'true'
+          true
+        when 'false'
+          false
+        when nil
+          default
+        else
+          raise CLI::Kit::Abort, "Invalid config: #{section}.#{name} is expected to be true or false"
+        end
+      end
+
+      # Sets the config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are setting
+      # `name` : the name of the config you are setting
+      # `value` : the value of the config you are setting
+      #
+      # #### Example Usage
+      # `config.set('section', 'name.of.config', 'value')`
+      #
+      #: (String section, String name, (String | bool)? value) -> void
+      def set(section, name, value)
+        all_configs["[#{section}]"] ||= {}
+        section = all_configs["[#{section}]"] #: as !nil
+        case value
+        when nil
+          section.delete(name)
+        else
+          section[name] = value.to_s
+        end
+        write_config
+      end
+
+      # Unsets a config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are deleting
+      # `name` : the name of the config you are deleting
+      #
+      # #### Example Usage
+      # `config.unset('section', 'name.of.config')`
+      #
+      #: (String section, String name) -> void
+      def unset(section, name)
+        set(section, name, nil)
+      end
+
+      # Gets the hash for the entire section
+      #
+      # #### Parameters
+      # `section` : the section of the config you are getting
+      #
+      # #### Example Usage
+      # `config.get_section('section')`
+      #
+      #: (String section) -> Hash[String, String]
+      def get_section(section)
+        (all_configs["[#{section}]"] || {}).dup
+      end
+
+      #: -> String
+      def to_s
+        ini.to_s
+      end
+
+      # The path on disk at which the configuration is stored:
+      #   `$XDG_CONFIG_HOME/<toolname>/config`
+      # if ENV['XDG_CONFIG_HOME'] is not set, we default to ~/.config, e.g.:
+      #   ~/.config/tool/config
+      #
+      #: -> String
+      def file
+        config_home = ENV.fetch(XDG_CONFIG_HOME, '~/.config')
+        File.expand_path(File.join(@tool_name, 'config'), config_home)
+      end
+
+      private
+
+      #: -> Hash[String, Hash[String, String]]
+      def all_configs
+        ini.ini
+      end
+
+      #: -> CLI::Kit::Ini
+      def ini
+        @ini ||= CLI::Kit::Ini.new(file).tap(&:parse)
+      end
+
+      #: -> void
+      def write_config
+        all_configs.each do |section, sub_config|
+          all_configs.delete(section) if sub_config.empty?
+        end
+        FileUtils.mkdir_p(File.dirname(file))
+        File.write(file, to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Exception
+  # You'd think instance variables @bug and @silent would work here. They
+  # don't. I'm not sure why. If you, the reader, want to take some time to
+  # figure it out, go ahead and refactor to that.
+
+  #: -> bool
+  def bug?
+    true
+  end
+
+  #: -> bool
+  def silent?
+    false
+  end
+
+  #: (?bool bug) -> void
+  def bug!(bug = true)
+    singleton_class.define_method(:bug?) { bug }
+  end
+
+  #: (?bool silent) -> void
+  def silent!(silent = true)
+    singleton_class.define_method(:silent?) { silent }
+  end
+end

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

@@ -0,0 +1,166 @@
+# typed: true
+
+require 'cli/kit'
+require 'English'
+
+module CLI
+  module Kit
+    class ErrorHandler
+      #: type exception_reporter_or_proc = singleton(ExceptionReporter) | ^() -> singleton(ExceptionReporter)
+
+      #: ^(Exception arg0) -> Integer
+      attr_writer :override_exception_handler
+
+      #: (?log_file: String?, ?exception_reporter: exception_reporter_or_proc, ?tool_name: String?, ?dev_mode: bool) -> void
+      def initialize(log_file: nil, exception_reporter: NullExceptionReporter, tool_name: nil, dev_mode: false)
+        @log_file = log_file
+        @exception_reporter_or_proc = exception_reporter
+        @tool_name = tool_name
+        @dev_mode = dev_mode
+      end
+
+      # @abstract
+      class ExceptionReporter
+        class << self
+          # @abstract
+          #: (Exception?, ?String?) -> void
+          def report(exception, logs = nil)
+            raise(NotImplementedError)
+          end
+        end
+      end
+
+      class NullExceptionReporter < ExceptionReporter
+        class << self
+          # @override
+          #: (Exception? _exception, ?String? _logs) -> void
+          def report(_exception, _logs = nil)
+            nil
+          end
+        end
+      end
+
+      #: { -> void } -> Integer
+      def call(&block)
+        # @at_exit_exception is set if handle_abort decides to submit an error.
+        # $ERROR_INFO is set if we terminate because of a signal.
+        at_exit { report_exception(@at_exit_exception || $ERROR_INFO) }
+        triage_all_exceptions(&block)
+      end
+
+      #: (Exception? error) -> void
+      def report_exception(error)
+        if (notify_with = exception_for_submission(error))
+          logs = nil
+          if @log_file
+            logs = begin
+              File.read(@log_file)
+            rescue => e
+              "(#{e.class}: #{e.message})"
+            end
+          end
+          exception_reporter.report(notify_with, logs)
+        end
+      end
+
+      SIGNALS_THAT_ARENT_BUGS = [
+        'SIGTERM', 'SIGHUP', 'SIGINT',
+      ].freeze
+
+      private
+
+      # Run the program, handling any errors that occur.
+      #
+      # Errors are printed to stderr unless they're #silent?, and are reported
+      # to bugsnag (by setting @at_exit_exeption for our at_exit handler) if
+      # they're #bug?
+      #
+      # Returns an exit status for the program.
+      #: { -> void } -> Integer
+      def triage_all_exceptions(&block)
+        begin
+          block.call
+          CLI::Kit::EXIT_SUCCESS
+        rescue Interrupt => e # Ctrl-C
+          # transform message, prevent bugsnag
+          exc = e.exception('Interrupt')
+          CLI::Kit.raise(exc, bug: false)
+        rescue Errno::ENOSPC => e
+          # transform message, prevent bugsnag
+          message = if @tool_name
+            "Your disk is full - {{command:#{@tool_name}}} requires free space to operate"
+          else
+            'Your disk is full - free space is required to operate'
+          end
+          exc = e.exception(message)
+          CLI::Kit.raise(exc, bug: false)
+        end
+      # If SystemExit was raised, e.g. `exit()`, then
+      # return whatever status is attached to the exception
+      # object. The special exit statuses have already been
+      # handled below.
+      rescue SystemExit => e
+        e.status
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        @at_exit_exception = e if e.bug?
+
+        if (eh = @override_exception_handler)
+          return eh.call(e)
+        end
+
+        raise(e) if @dev_mode && e.bug?
+
+        stderr_puts(e.message) unless e.silent?
+        e.bug? ? CLI::Kit::EXIT_BUG : CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      end
+
+      #: (Exception? error) -> Exception?
+      def exception_for_submission(error)
+        # happens on normal non-error termination
+        return if error.nil?
+
+        return unless error.bug?
+
+        case error
+        when SignalException
+          SIGNALS_THAT_ARENT_BUGS.include?(error.message) ? nil : error
+        when SystemExit # "exit N" called
+          case error.status
+          when CLI::Kit::EXIT_SUCCESS # submit nothing if it was `exit 0`
+            nil
+          when CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+            # if it was `exit 30`, translate the exit code to 1, and submit
+            # nothing. 30 is used to signal normal failures that are not
+            # indicative of bugs. However, users should see it presented as 1.
+            exit(1)
+          else
+            # don't treat this as an exception, simply reraise.
+            # this is indicative of `exit` being called with a
+            # non-zero number, and the requested exit status
+            # needs to be maintained.
+            exit(error.status)
+          end
+        else
+          error
+        end
+      end
+
+      #: (String message) -> void
+      def stderr_puts(message)
+        $stderr.puts(CLI::UI.fmt("{{red:#{message}}}"))
+      rescue Errno::EPIPE, Errno::EIO
+        nil
+      end
+
+      #: -> singleton(ExceptionReporter)
+      def exception_reporter
+        case @exception_reporter_or_proc
+        when Proc
+          @exception_reporter_or_proc.call
+        else
+          @exception_reporter_or_proc
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# typed: true
+
+require 'cli/kit'
+require 'English'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Executor
+      #: (log_file: String) -> void
+      def initialize(log_file:)
+        FileUtils.mkpath(File.dirname(log_file))
+        @log_file = log_file
+      end
+
+      #: (singleton(CLI::Kit::BaseCommand) command, String command_name, Array[String] args) -> void
+      def call(command, command_name, args)
+        with_traps do
+          with_logging do |id|
+            command.call(args, command_name)
+          rescue => e
+            begin
+              $stderr.puts "This command ran with ID: #{id}"
+              $stderr.puts 'Please include this information in any issues/report along with relevant logs'
+            rescue SystemCallError
+              # Outputting to stderr is best-effort.  Avoid raising another error when outputting debug info so that
+              # we can detect and log the original error, which may even be the source of this error.
+              nil
+            end
+            raise e
+          end
+        end
+      end
+
+      private
+
+      #: [T] { (String id) -> T } -> T
+      def with_logging(&block)
+        CLI::UI.log_output_to(@log_file) do
+          CLI::UI::StdoutRouter.with_id(on_streams: [CLI::UI::StdoutRouter.duplicate_output_to].compact) do |id|
+            block.call(id)
+          end
+        end
+      end
+
+      #: [T] { -> T } -> T
+      def with_traps(&block)
+        twrap('QUIT', method(:quit_handler)) do
+          twrap('INFO', method(:info_handler), &block)
+        end
+      end
+
+      #: [T] (String signal, Method handler) { -> T } -> T
+      def twrap(signal, handler, &block)
+        return yield unless Signal.list.key?(signal)
+
+        begin
+          begin
+            prev_handler = trap(signal, handler)
+            installed = true
+          rescue ArgumentError
+            # If we couldn't install a signal handler because the signal is
+            # reserved, remember not to uninstall it later.
+            installed = false
+          end
+          yield
+        ensure
+          trap(signal, prev_handler) if installed
+        end
+      end
+
+      #: (untyped _sig) -> void
+      def quit_handler(_sig)
+        z = caller
+        CLI::UI.raw do
+          $stderr.puts('SIGQUIT: quit')
+          $stderr.puts(z)
+        end
+        exit(CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG)
+      end
+
+      #: (untyped _sig) -> void
+      def info_handler(_sig)
+        z = caller
+        CLI::UI.raw do
+          $stderr.puts('SIGINFO:')
+          $stderr.puts(z)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# typed: true
+
+require 'cli/kit'
+
+module CLI
+  module Kit
+    # INI is a language similar to JSON or YAML, but simplied
+    # The spec is here: https://en.wikipedia.org/wiki/INI_file
+    # This parser includes supports for 2 very basic uses
+    # - Sections
+    # - Key Value Pairs (within and outside of the sections)
+    #
+    # [global]
+    # key = val
+    #
+    # Nothing else is supported right now
+    # See the ini_test.rb file for more examples
+    #
+    class Ini
+      #: Hash[String, Hash[String, String]]
+      attr_accessor :ini
+
+      #: (?String? path, ?config: String?, ?default_section: String) -> void
+      def initialize(path = nil, config: nil, default_section: '[global]')
+        @config = if path && File.exist?(path)
+          File.readlines(path)
+        elsif config
+          config.lines
+        end
+        @ini = {}
+        @current_key = default_section
+      end
+
+      #: -> Hash[String, Hash[String, String]]
+      def parse
+        return @ini if @config.nil?
+
+        @config.each do |l|
+          l.strip!
+
+          if section_designator?(l)
+            @current_key = l
+          else
+            k, v = l.split('=', 2).map(&:strip)
+            set_val(k, v) if k && v
+          end
+        end
+
+        @ini
+      end
+
+      #: -> String
+      def git_format
+        to_ini(git_format: true)
+      end
+
+      #: -> String
+      def to_s
+        to_ini
+      end
+
+      private
+
+      #: (?git_format: bool) -> String
+      def to_ini(git_format: false)
+        optional_tab = git_format ? "\t" : ''
+        str = []
+        @ini.each do |section_designator, section|
+          str << '' unless str.empty? || git_format
+          str << section_designator
+          section.each do |k, v|
+            str << "#{optional_tab}#{k} = #{v}"
+          end
+        end
+        str.join("\n")
+      end
+
+      #: (String key, String val) -> void
+      def set_val(key, val)
+        current_key = @current_key
+        @ini[current_key] ||= {}
+        @ini[current_key][key] = val
+      end
+
+      #: (String k) -> bool
+      def section_designator?(k)
+        k.start_with?('[') && k.end_with?(']')
+      end
+    end
+  end
+end