sugarjar 3.0.1 → 4.0.0

data/lib/sugarjar/commands.rb

@@ -6,14 +6,16 @@ require_relative 'commands/branch'
 require_relative 'commands/checks'
 require_relative 'commands/debuginfo'
 require_relative 'commands/feature'
+require_relative 'commands/modernize_config'
 require_relative 'commands/pullsuggestions'
 require_relative 'commands/push'
 require_relative 'commands/smartclone'
 require_relative 'commands/smartpullrequest'
 require_relative 'commands/up'
+require_relative 'forge'
+require_relative 'git'
 require_relative 'log'
 require_relative 'repoconfig'
-require_relative 'util'
 require_relative 'version'
 
 class SugarJar
@@ -25,39 +27,21 @@ class SugarJar
 
     def initialize(options)
       SugarJar::Log.debug("Commands.initialize options: #{options}")
-      @ignore_dirty = options['ignore_dirty']
-      @ignore_prerun_failure = options['ignore_prerun_failure']
+      @config = options
       @repo_config = SugarJar::RepoConfig.config
       SugarJar::Log.debug("Repoconfig: #{@repo_config}")
-      @color = options['color']
-      @pr_autofill = options['pr_autofill']
-      @pr_autostack = options['pr_autostack']
-      @feature_prefix = options['feature_prefix']
-      @use_forks = options['use_forks']
-      @fork_name = options['fork_name']
+
       @checks = {}
       @main_branch = nil
       @main_remote_branches = {}
-      # This is CONFIGURED host, which may be null, as opposed
-      # to the method forge_host which will always return something
-      @_forge_host = @repo_config['forge_host'] || options['forge_host']
-      @repo_forge = @repo_config['forge_type'] || options['forge_type'] ||
-                    _determine_forge_type
-
-      unless @repo_forge.nil?
-        cmd = _forge_cmd
-        unless SugarJar::Util.which_nofail(cmd)
-          die("No '#{cmd}' found, please install it'")
-        end
-      end
+      @host_config = nil
 
-      user_option = "#{@repo_forge}_user"
-      @forge_user = @repo_config[user_option] || options[user_option]
-
-      # Tell the cli where to talk to, if not default
-      if @_forge_host
-        ENV['GH_HOST'] = @_forge_host
-        ENV['GL_HOST'] = @_forge_host
+      if SugarJar::Git.in_repo?
+        @host_config = gen_host_config
+        if @host_config['forge_type']
+          # initialize instance var here so checks run...
+          forge
+        end
       end
 
       return if options['no_change']
@@ -67,34 +51,72 @@ class SugarJar
 
     private
 
+    def forge
+      return @forge if @forge
+      unless @host_config['forge_type']
+        raise 'Attempted to create Forge object before forge-type known!'
+      end
+
+      @forge = SugarJar::Forge.new(
+        @host_config['forge_type'], @host_config['forge_host']
+      )
+    end
+
+    def gen_host_config(host = nil)
+      host ||= _determine_forge_host
+      _config_for_host(host) || {}
+    end
+
+    def _config_for_host(host)
+      SugarJar::Log.debug("config_for_host called for #{host}")
+      r = @config.dig('host_configs', 'default').dup || {}
+      r.merge!(@config.dig('host_configs', host) || {})
+      r['forge_host'] = host
+      # if people specified a forge_type, honor it
+      r['forge_type'] ||= _determine_forge_type(host)
+
+      # there are a few things we allow the CLI to override
+      r.merge!(@config['_cli_overrides'] || {})
+
+      SugarJar::Log.debug("Determined config for host: #{r}")
+      r
+    end
+
     def forked_repo(repo, username)
+      host = @host_config&.dig('forge_host') || extract_host(repo) ||
+             @config['default_forge_host']
+      raise 'Cannot determine host' unless host
+
       repo = extract_repo(repo)
-      "git@#{forge_host}:#{username}/#{repo}.git"
+
+      "git@#{host}:#{username}/#{repo}.git"
     end
 
     # gh utils will default to https, but we should always default to SSH
     # unless otherwise specified since https will cause prompting.
     def canonicalize_repo(repo)
       # if they fully-qualified it, we're good
-      return repo if repo.start_with?('http', 'git@')
+      return repo if repo.start_with?('http', 'git@', 'ssh://')
 
+      host = @host_config&.dig('forge_host') || extract_host(repo) ||
+             @config['default_forge_host']
       # otherwise, it's a shortname
-      cr = "git@#{forge_host}:#{repo}.git"
+      cr = "git@#{host}:#{repo}.git"
       SugarJar::Log.debug("canonicalized #{repo} to #{cr}")
       cr
     end
 
-    def forge_host
-      # if one is specifically configured, use that
-      return @_forge_host if @_forge_host
+    def _determine_forge_host
+      # DO NOT USE in the general case - ONLY for filling in @host_config
+      # (doesn't consult host_config). Use @host_config['forge_host']
+      # in general.
 
-      # otherwise, if we're in a repo, use the hostname of the remote
-      if SugarJar::Util.in_repo?
+      # if we're in a repo, use the hostname of the remote
+      if SugarJar::Git.in_repo?
         url = remote_url_map.values.first
         return extract_host(url)
       end
-
-      @repo_forge == 'gitlab' ? 'gitlab.com' : 'github.com'
+      @config['default_forge_host']
     end
 
     def repo_shortname(repo)
@@ -107,7 +129,7 @@ class SugarJar
     end
 
     def set_commit_template
-      unless SugarJar::Util.in_repo?
+      unless SugarJar::Git.in_repo?
         SugarJar::Log.debug('Skipping set_commit_template: not in repo')
         return
       end
@@ -115,7 +137,10 @@ class SugarJar
       realpath = if @repo_config['commit_template'].start_with?('/')
                    @repo_config['commit_template']
                  else
-                   "#{Util.repo_root}/#{@repo_config['commit_template']}"
+                   File.join(
+                     SugarJar::Git.repo_root,
+                     @repo_config['commit_template'],
+                   )
                  end
       unless File.exist?(realpath)
         die(
@@ -148,7 +173,7 @@ class SugarJar
     end
 
     def assert_in_repo!
-      return if SugarJar::Util.in_repo?
+      return if SugarJar::Git.in_repo?
 
       die('sugarjar must be run from inside a git repo')
     end
@@ -156,7 +181,7 @@ class SugarJar
     def dirty_check!
       return unless dirty?
 
-      if @ignore_dirty
+      if @config['ignore_dirty']
         SugarJar::Log.warn(
           'Your repo is dirty, but --ignore-dirty was specified, so ' +
           'carrying on anyway.',
@@ -171,7 +196,11 @@ class SugarJar
     end
 
     def determine_main_branch(branches)
-      branches.include?('master') ? 'master' : 'main'
+      if branches.include?('main')
+        'main'
+      elsif branches.include?('master')
+        'master'
+      end
     end
 
     def main_branch
@@ -301,8 +330,14 @@ class SugarJar
       extract_org(url)
     end
 
+    def repo_name
+      # Take the url of the most-upstream remote, then pull the repo
+      # name from that
+      extract_repo(remote_url_map[upstream])
+    end
+
     def color(string, *colors)
-      if @color
+      if @config['color']
         pastel.decorate(string, *colors)
       else
         string
@@ -316,17 +351,13 @@ class SugarJar
       end
     end
 
-    def forge_cli_avail?
-      !!SugarJar::Util.which_nofail(_forge_cmd)
-    end
-
     def fprefix(name)
-      return name unless @feature_prefix
+      return name unless @host_config['feature_prefix']
 
-      return name if name.start_with?(@feature_prefix)
+      return name if name.start_with?(@host_config['feature_prefix'])
       return name if all_local_branches.include?(name)
 
-      newname = "#{@feature_prefix}#{name}"
+      newname = "#{@host_config['feature_prefix']}#{name}"
       SugarJar::Log.debug(
         "Munging feature name: #{name} -> #{newname} due to feature prefix",
       )
@@ -338,8 +369,8 @@ class SugarJar
       s.error?
     end
 
-    def repo_name
-      SugarJar::Util.repo_root.split('/').last
+    def repo_dir_name
+      SugarJar::Git.repo_root.split('/').last
     end
 
     def extract_org(repo)
@@ -360,6 +391,8 @@ class SugarJar
     def extract_host(repo)
       if repo.start_with?('git@')
         repo.split(':').first.split('@').last
+      elsif repo.start_with?('ssh://')
+        repo.split('/')[2].split('@').last
       elsif repo.start_with?('http')
         repo.split('/')[2]
       end
@@ -381,7 +414,7 @@ class SugarJar
     end
 
     def worktrees
-      root = SugarJar::Util.repo_root
+      root = SugarJar::Git.repo_root
       s = git('worktree', 'list', '--porcelain')
       s.error!
       worktrees = {}
@@ -412,41 +445,33 @@ class SugarJar
     end
 
     def git(*)
-      SugarJar::Util.git(*, :color => @color)
+      SugarJar::Git.run(*, :color => @config['color'])
     end
 
     def git_nofail(*)
-      SugarJar::Util.git_nofail(*, :color => @color)
-    end
+      SugarJar::Git.run_nofail(*, :color => @config['color'])
+    end
+
+    def _determine_forge_type(host = nil)
+      if host
+        case host
+        when /gitlab/
+          return 'gitlab'
+        when /github/
+          return 'github'
+        when /forgejo|codeberg/
+          return 'forgejo'
+        end
+      end
 
-    def _determine_forge_type
-      if SugarJar::Util.in_repo?
+      if SugarJar::Git.in_repo?
         gl = remote_url_map.values.any? { |x| x.include?('gitlab') }
         return gl ? 'gitlab' : 'github'
       end
 
-      # if all else fails, guess GH
-      'github'
-    end
-
-    def _forge_cmd
-      @repo_forge == 'gitlab' ? 'glab' : 'gh'
-    end
-
-    def forge(*)
-      if @repo_forge == 'gitlab'
-        SugarJar::Util.glcli(*)
-      else
-        SugarJar::Util.ghcli(*)
-      end
-    end
-
-    def forge_nofail(*)
-      if @repo_forge == 'gitlab'
-        SugarJar::Util.glcli_nofail(*)
-      else
-        SugarJar::Util.ghcli_nofail(*)
-      end
+      # in smartclone mode, when creating the object, we will in fact
+      # be unable to determine this, that's expacted
+      SugarJar::Log.debug('Unable to determine forge_type!')
     end
   end
 end

data/lib/sugarjar/config.rb

@@ -1,25 +1,52 @@
 require 'yaml'
 require_relative 'log'
+require 'deep_merge'
 
 class SugarJar
   # This parses SugarJar configs (not to be confused with repoconfigs).
   # This is stuff like log level, github-user, etc.
   class Config
     DEFAULTS = {
-      'github_user' => ENV.fetch('USER'),
-      'gitlab_user' => ENV.fetch('USER'),
+      'default_forge_host' => nil,
       'pr_autofill' => true,
       'pr_autostack' => nil,
       'color' => true,
-      'use_forks' => true,
       'ignore_deprecated_options' => [],
+      'host_configs' => {
+        'default' => {
+          'user' => ENV.fetch('USER'),
+          'use_forks' => true,
+        },
+      },
+    }.freeze
+
+    # things we have a command-line option for, but doesn't make sense
+    # in a config file.
+    EXTRA_CONFIGS = %w{fork_name force_forge_type}.freeze
+
+    TOP_LEVEL_CONFIGS = (DEFAULTS.keys + EXTRA_CONFIGS).freeze
+
+    DEPRECATED_OPTIONS = %w{
+      fallthru
+      gh_cli
+      github_user
+      gitlab_user
+      github_host
+      gitlab_host
     }.freeze
 
     def self._find_ordered_files
+      real_files = []
       [
-        '/etc/sugarjar/config.yaml',
-        "#{Dir.home}/.config/sugarjar/config.yaml",
-      ].select { |f| File.exist?(f) }
+        '/etc/sugarjar',
+        "#{Dir.home}/.config/sugarjar",
+      ].each do |dir|
+        %w{yaml yml}.each do |ext|
+          f = File.join(dir, "config.#{ext}")
+          real_files << f if File.exist?(f)
+        end
+      end
+      real_files
     end
 
     def self.config
@@ -28,21 +55,34 @@ class SugarJar
       _find_ordered_files.each do |f|
         SugarJar::Log.debug("Loading config #{f}")
         data = YAML.safe_load_file(f)
+        next unless data
+
         warn_on_deprecated_configs(data, f)
-        if data['github_host']
-          data['forge_host'] = data['github_host'] if data['forge_host'].nil?
-          data.delete('github_host')
-        end
-        # an empty file is a `nil` which you can't merge
-        c.merge!(YAML.safe_load_file(f)) if data
+        data = data.slice(*TOP_LEVEL_CONFIGS)
+        c.deep_merge!(data)
         SugarJar::Log.debug("Modified config: #{c}")
       end
       c
     end
 
     def self.warn_on_deprecated_configs(data, fname)
+      # if it doesn't have host_configs **and** it has one of the
+      # previous user options, that were effectively required before
+      # and have now moved to host_configs, then we treat it as an
+      # old config
+      if %w{github_user gitlab_user}.any? { |useropt| data.key?(useropt) } &&
+         !data['host_configs']
+        SugarJar::Log.warn(
+          "#{fname} appears to be an old-style config.\nIt likely will " +
+          'not result in the behavior you want. You should run' +
+          "\n\n\tsj modernizeconfig #{fname}\n\n" +
+          "To automatically convert it.\n",
+        )
+        return
+      end
+
       ignore_deprecated_options = data['ignore_deprecated_options'] || []
-      %w{fallthru gh_cli}.each do |opt|
+      DEPRECATED_OPTIONS.each do |opt|
         next unless data.key?(opt)
 
         if ignore_deprecated_options.include?(opt)
@@ -57,29 +97,6 @@ class SugarJar
           'suppress this warning with `ignore_deprecated_options`.',
         )
       end
-
-      # github_host has special handling
-      return unless data['github_host']
-
-      if ignore_deprecated_options.include?('github_host')
-        SugarJar::Log.debug(
-          "#{fname}: Deprecated option `github_host` found, but not " +
-          'warning due to `ignore_deprecated_options` in that file.',
-        )
-      elsif data.key?('forge_host')
-        SugarJar::Log.warn(
-          "#{fname}: Deprecated option `github_host` found. " +
-          'Ignoring in favor of newer `force_host` option. You can ' +
-          'suppress this warning with `ignore_deprecated_options`.',
-        )
-      else
-        SugarJar::Log.warn(
-          "#{fname}: Deprecated option `github_host` found. " +
-          'Treating it as if it was `forge_host` for now. Please update ' +
-          'your config file to use this new option. You can suppress ' +
-          'this warning with `ignore_deprecated_options`.',
-        )
-      end
     end
   end
 end

data/lib/sugarjar/forge.rb

@@ -0,0 +1,98 @@
+require 'mixlib/shellout'
+require_relative 'util'
+require_relative 'log'
+
+class SugarJar
+  class Forge
+    attr_reader :type
+
+    CMD_MAP = {
+      'github' => 'gh',
+      'gitlab' => 'glab',
+      'forgejo' => 'fj',
+    }.freeze
+
+    def initialize(type, host)
+      @type = type
+      @host = host
+      assert_cli_avail!
+    end
+
+    def cmd
+      @cmd ||= CMD_MAP[@type]
+    end
+
+    def all_versions
+      CMD_MAP.values.map do |cli|
+        bin = SugarJar::Util.which_nofail(cli)
+        _forge_nofail(cli, 'version').stdout if bin
+      end.compact
+    end
+
+    def run_nofail(*)
+      _forge_nofail(cmd, *)
+    end
+
+    def run(*)
+      s = _forge_nofail(cmd, *)
+      s.error!
+      s
+    end
+
+    def run_with_system(*args)
+      SugarJar::Log.trace("Running: #{cmd} #{args.join(' ')}")
+      system(cmd, *args)
+    end
+
+    private
+
+    def _forge_nofail(cli, *args)
+      SugarJar::Log.trace("Running: #{cli} #{args.join(' ')}")
+      bin = SugarJar::Util.which_nofail(cli)
+      s = Mixlib::ShellOut.new([bin] + args).run_command
+      if s.error? && ["#{cli} auth", 'Unauthorized'].any? do |err|
+        s.stderr.include?(err)
+      end
+        SugarJar::Log.info(
+          "#{cli} was run but no gitlab token exists. Will run " +
+          "'#{cli} auth login' to force\n#{cli} to authenticate...",
+        )
+        args = if cli == 'fj'
+                 [bin, '-H', @host, 'auth', 'login']
+               else
+                 [bin, 'auth', 'login', '-p', 'ssh']
+               end
+        unless system(*args)
+          SugarJar::Log.fatal(
+            "That failed, I will bail out. #{cli} needs to get a " +
+            "token. Try running '#{cli} auth login' (will list info about " +
+            'your account) and try this again when that works.',
+          )
+          exit(1)
+        end
+
+        if cli == 'fj'
+          fj = Mixlib::ShellOut.new([bin, 'auth', 'list']).run_command
+          unless fj.stdout.include?(@host)
+            SugarJar::Log.fatal(
+              'Logging in for you failed - this usually means you need to ' +
+              'create a token manually - the instructions should have been ' +
+              'printed above. Setup the token and then try again.',
+            )
+            exit(1)
+          end
+        end
+      end
+      s
+    end
+
+    def assert_cli_avail!
+      return if SugarJar::Util.which_nofail(cmd)
+
+      SugarJar::Log.error(
+        "Forge CLI #{cmd} is unavailable, please install",
+      )
+      exit 1
+    end
+  end
+end

data/lib/sugarjar/git.rb

@@ -0,0 +1,29 @@
+require_relative 'util'
+
+class SugarJar
+  module Git
+    def self.run_nofail(*args, color: true)
+      if %w{diff log grep branch}.include?(args[0]) &&
+         args.none? { |x| x.include?('color') }
+        args << (color ? '--color' : '--no-color')
+      end
+      SugarJar::Log.trace("Running: git #{args.join(' ')}")
+      Mixlib::ShellOut.new([SugarJar::Util.which('git')] + args).run_command
+    end
+
+    def self.run(*, color: true)
+      s = run_nofail(*, :color => color)
+      s.error!
+      s
+    end
+
+    def self.in_repo?
+      s = run_nofail('rev-parse', '--is-inside-work-tree')
+      !s.error? && s.stdout.strip == 'true'
+    end
+
+    def self.repo_root
+      run('rev-parse', '--show-toplevel').stdout.strip
+    end
+  end
+end