Extract bootstrap/framework code from dev

Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    dev-kit (0.1.0)
-      dev-ui (>= 0.1.0)
+    cli-kit (2.0.0)
+      cli-ui (>= 1.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -11,7 +11,7 @@ GEM
     ast (2.3.0)
     builder (3.2.3)
     byebug (9.0.6)
-    dev-ui (0.1.0)
+    cli-ui (1.0.0)
     metaclass (0.0.4)
     method_source (0.8.2)
     minitest (5.10.2)
@@ -45,7 +45,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.15)
   byebug
-  dev-kit!
+  cli-kit!
   method_source
   minitest (>= 5.0.0)
   minitest-reporters

lib/cli/kit.rb

@@ -2,6 +2,57 @@
 
 module CLI
   module Kit
-    autoload :System, 'cli/kit/system'
+    class << self
+      attr_accessor :tool_name
+    end
+
+    autoload :BaseCommand,     'cli/kit/base_command'
+    autoload :CommandRegistry, 'cli/kit/command_registry'
+    autoload :Config,          'cli/kit/config'
+    autoload :EntryPoint,      'cli/kit/entry_point'
+    autoload :Ini,             'cli/kit/ini'
+    autoload :Levenshtein,     'cli/kit/levenshtein'
+    autoload :ReportErrors,    'cli/kit/report_errors'
+    autoload :System,          'cli/kit/system'
+
+    EXIT_FAILURE_BUT_NOT_BUG = 30
+    EXIT_BUG                 = 1
+    EXIT_SUCCESS             = 0
+
+    # Abort, Bug, AbortSilent, and BugSilent are four ways of immediately bailing
+    # on command-line execution when an unrecoverable error occurs.
+    #
+    # Note that these don't inherit from StandardError, and so are not caught by
+    # a bare `rescue => e`.
+    #
+    # * Abort prints its message in red and exits 1;
+    # * Bug additionally submits the exception to Bugsnag;
+    # * AbortSilent and BugSilent do the same as above, but do not print
+    #     messages before exiting.
+    #
+    # Treat these like panic() in Go:
+    #   * Don't rescue them. Use a different Exception class if you plan to recover;
+    #   * Provide a useful message, since it will be presented in brief to the
+    #       user, and will be useful for debugging.
+    #   * Avoid using it if it does actually make sense to recover from an error.
+    #
+    # Additionally:
+    #   * Do not subclass these.
+    #   * Only use AbortSilent or BugSilent if you prefer to print a more
+    #       contextualized error than Abort or Bug would present to the user.
+    #   * In general, don't attach a message to AbortSilent or BugSilent.
+    #   * Never raise GenericAbort directly.
+    #   * Think carefully about whether Abort or Bug is more appropriate. Is this
+    #       a bug in the tool? Or is it just user error, transient network
+    #       failure, etc.?
+    #   * One case where it's ok to rescue these outside of EntryPoint (or tests):
+    #       1. rescue Abort or Bug
+    #       2. Print a contextualized error message
+    #       3. Re-raise AbortSilent or BugSilent respectively.
+    GenericAbort = Class.new(Exception)
+    Abort        = Class.new(GenericAbort)
+    Bug          = Class.new(GenericAbort)
+    BugSilent    = Class.new(GenericAbort)
+    AbortSilent  = Class.new(GenericAbort)
   end
 end

lib/cli/kit/base_command.rb

@@ -0,0 +1,43 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class BaseCommand
+      def self.defined?
+        true
+      end
+
+      def self.statsd_increment(metric, **kwargs)
+        nil
+      end
+
+      def self.statsd_time(metric, **kwargs)
+        yield
+      end
+
+      def self.call(args, command_name)
+        cmd = new
+        stats_tags = ["task:#{cmd.class}"]
+        stats_tags << "subcommand:#{args.first}" if args && args.first && cmd.has_subcommands?
+        begin
+          statsd_increment("cli.command.invoked", tags: stats_tags)
+          statsd_time("cli.command.time", tags: stats_tags) do
+            cmd.call(args, command_name)
+          end
+          statsd_increment("cli.command.success", tags: stats_tags)
+        rescue => e
+          statsd_increment("cli.command.exception", tags: stats_tags + ["exception:#{e.class}"])
+          raise e
+        end
+      end
+
+      def call(args, command_name)
+        raise NotImplementedError
+      end
+
+      def has_subcommands?
+        false
+      end
+    end
+  end
+end

lib/cli/kit/command_registry.rb

@@ -0,0 +1,79 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module CommandRegistry
+      attr_accessor :commands, :aliases
+      class << self
+        attr_accessor :registry_target
+      end
+
+      def resolve_contextual_command
+        nil
+      end
+
+      def contextual_aliases
+        {}
+      end
+
+      def contextual_command_class(_name)
+        raise NotImplementedError
+      end
+
+      def self.extended(base)
+        raise "multiple registries unsupported" if self.registry_target
+        self.registry_target = base
+        base.commands = {}
+        base.aliases = {}
+      end
+
+      def register(const, name, path)
+        autoload(const, path)
+        commands[name] = const
+      end
+
+      def lookup_command(name)
+        return default_command if name.to_s == ""
+        resolve_command(name)
+      end
+
+      def register_alias(from, to)
+        aliases[from] = to unless aliases[from]
+      end
+
+      def resolve_command(name)
+        resolve_global_command(name) || \
+          resolve_contextual_command(name) || \
+          [nil, resolve_alias(name)]
+      end
+
+      def resolve_alias(name)
+        aliases[name] || contextual_aliases.fetch(name, name)
+      end
+
+      def resolve_global_command(name)
+        name = aliases.fetch(name, name)
+        command_class = const_get(commands.fetch(name, ""))
+        return nil unless command_class.defined?
+        [command_class, name]
+      rescue NameError
+        nil
+      end
+
+      def resolve_contextual_command(name)
+        name = resolve_alias(name)
+        found = contextual_command_names.include?(name)
+        return nil unless found
+        [contextual_command_class(name), name]
+      end
+
+      def command_names
+        contextual_command_names + commands.keys
+      end
+
+      def exist?(name)
+        !resolve_command(name).first.nil?
+      end
+    end
+  end
+end

lib/cli/kit/config.rb

@@ -0,0 +1,102 @@
+require 'cli/kit'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Config
+      XDG_CONFIG_HOME = 'XDG_CONFIG_HOME'
+
+      # 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 (false if none)
+      #
+      # #### Example Usage
+      # `config.get('name.of.config')`
+      #
+      def get(section, name = nil)
+        section, name = section.split('.', 2) if name.nil?
+        # TODO: Remove this and all global configs
+        return get("global", section) if name.nil?
+        all_configs.dig("[#{section}]", name) || false
+      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')`
+      #
+      def set(section, name = nil, value)
+        section, name = section.split('.', 2) if name.nil?
+        # TODO: Remove this and all global configs
+        return set("global", section, value) if name.nil?
+        all_configs["[#{section}]"] ||= {}
+        all_configs["[#{section}]"][name] = value.nil? ? nil : value.to_s
+        write_config
+      end
+
+      def get_section(section)
+        (all_configs["[#{section}]"] || {}).dup
+      end
+
+      # Returns a path from config in expanded form
+      # e.g. shopify corresponds to ~/src/shopify, but is expanded to /Users/name/src/shopify
+      #
+      # #### Example Usage
+      # `config.get_path('srcpath', 'shopify')`
+      #
+      # #### Returns
+      # `path` : the expanded path to the corrsponding value
+      #
+      def get_path(section, name = nil)
+        v = get(section, name)
+        false == v ? v : File.expand_path(v)
+      end
+
+      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
+      #
+      def file
+        config_home = ENV.fetch(XDG_CONFIG_HOME, '~/.config')
+        File.expand_path(File.join(CLI::Kit.tool_name, 'config'), config_home)
+      end
+
+      private
+
+      def all_configs
+        ini.ini
+      end
+
+      def ini
+        @ini ||= CLI::Kit::Ini
+          .new(file, default_section: "[global]", convert_types: false)
+          .tap(&:parse)
+      end
+
+      def write_config
+        all_configs.each do |section, sub_config|
+          all_configs[section] = sub_config.reject { |_, value| value.nil? }
+          all_configs.delete(section) if all_configs[section].empty?
+        end
+        FileUtils.mkdir_p(File.dirname(file))
+        File.write(file, to_s)
+      end
+    end
+  end
+end