sugarjar 1.1.3 → 2.0.1

data/bin/sj

@@ -13,7 +13,8 @@ SugarJar::Log.level = Logger::INFO
 
 # Don't put defaults here, put them in SugarJar::Config - otherwise
 # these defaults overwrite whatever is in config files.
-options = { 'color' => true }
+options = {}
+
 # If ENV['SUGARJAR_DEBUG'] is set, it overrides the config file,
 # but not the command line options, so set that one here. Also
 # start the logger at that level, in case we are debugging option loading
@@ -21,6 +22,7 @@ options = { 'color' => true }
 if ENV['SUGARJAR_LOGLEVEL']
   options['log_level'] = SugarJar::Log.level = ENV['SUGARJAR_LOGLEVEL'].to_sym
 end
+
 parser = OptionParser.new do |opts|
   opts.banner = 'Usage: sj <command> [<args>] [<options>]'
 
@@ -29,24 +31,10 @@ parser = OptionParser.new do |opts|
   opts.separator ''
   opts.separator 'OPTIONS:'
 
-  opts.on('--[no-]fallthru', 'Fall-thru to git. [default: true]') do |fallthru|
-    options['fallthru'] = fallthru
-  end
-
   opts.on('--feature-prefix', 'Prefix to use for feature branches') do |prefix|
     options['feature_prefix'] = prefix
   end
 
-  opts.on(
-    '--github-cli CLI',
-    %w{gh cli},
-    'Github CLI to use ("gh" or "hub" or "auto"). Auto (the default) will ' +
-    'prefer "gh" if it is available but will fall back to "hub." ' +
-    '[default: "auto"]',
-  ) do |cli|
-    options['github_cli'] = cli
-  end
-
   opts.on(
     '--github-host HOST',
     'The host for "hub". Note that we will set this in the local repo ' +
@@ -109,7 +97,7 @@ parser = OptionParser.new do |opts|
     options['pr_autostack'] = autostack
   end
 
-  opts.on('--[no-]use-color', 'Enable color. [default: true]') do |color|
+  opts.on('--[no-]color', 'Enable color. [default: true]') do |color|
     options['color'] = color
   end
 
@@ -119,7 +107,7 @@ parser = OptionParser.new do |opts|
   end
 
   # rubocop:disable Layout/HeredocIndentation
-  opts.separator <<COMMANDS
+  opts.separator <<COMMANDTEXT
 
 COMMANDS:
   amend
@@ -145,6 +133,10 @@ COMMANDS:
   br
               Verbose branch list. An alias for "git branch -v".
 
+  debuginfo
+              Prints out a bunch of version and config information useful for
+              including in bug reports.
+
   feature, f <branch_name>
               Create a "feature" branch. It's morally equivalent to
               "git checkout -b" except it defaults to creating it based on
@@ -209,99 +201,66 @@ COMMANDS:
 
   upall
               Same as "up", but for all branches.
-
-  version
-              Print the version of sugarjar, and then run 'hub version'
-              to show the hub and git versions.
-
-Be sure to checkout Sapling (https://sapling-scm.com/)! SugarJar was written as
-a stop-gap to get Sapling features before it was open-sourced, and as such
-Sapling may serve your needs even better.
-COMMANDS
+COMMANDTEXT
 
   # rubocop:enable Layout/HeredocIndentation
 end
 
-# we make a copy of these because we will assign back to the ARGV
-# we parse later. We also need a pristine copy in case we want to
-# run git as we were called.
-argv_copy = ARGV.dup
-
-# We don't have options yet, but we need an instance of SJ in order
-# to list public methods. We will recreate it
-sj = SugarJar::Commands.new(options.merge({ 'no_change' => true }))
 extra_opts = []
+argv_copy = ARGV.dup
 
-# as with above, this can't go into 'options', until after we parse
-# the command line args
-config = SugarJar::Config.config
-
-valid_commands = sj.public_methods - Object.public_methods
-possible_valid_command = ARGV.any? do |arg|
-  valid_commands.include?(arg.to_s.to_sym)
-end
-
-# if we're configured to fall thru and the subcommand isn't one
-# we recognize, don't parse the options as they may be different
-# than git's. For example `git config -l` - we error because we
-# require an arguement to `-l`.
-if config['fallthru'] && !possible_valid_command
-  SugarJar::Log.debug(
-    'Skipping option parsing: fall-thru is set and we do not recognize ' +
-    'any subcommands',
-  )
-else
+# We want to allow people to pass in extra args to be passed to commands (like
+# `amend`), but OptionParser doesn't easily allow this. So we loop over it,
+# catching exceptions.
+
+begin
+  # HOWEVER, anytime it throws an exception, for some reason, it clears
+  # out all of ARGV, or whatever you passed to as ARGV.
+  #
+  # This not only prevents further parsing, but also means we lose
+  # any non-option arguements (like the subcommand!)
+  #
+  # So we save a copy, and if we throw an exception, save the option that
+  # caused it, remove that option from our copy, and then re-populate argv
+  # with what's left.
+  #
+  # By doing this we not only get to parse all the options properly and
+  # save unknown ones, but non-option arguements, which OptionParser
+  # normally leaves in ARGV stay in ARGV.
+  saved_argv = argv_copy.dup
+  parser.parse!(argv_copy)
+rescue OptionParser::InvalidOption => e
+  SugarJar::Log.debug("Saving unknown argument #{e.args}")
+  extra_opts += e.args
+
+  # e.args is an array, but it's only ever one arguement per exception
+  saved_argv.delete(e.args.first)
+  argv_copy = saved_argv.dup
   SugarJar::Log.debug(
-    'We MIGHT have a valid command... parse-command line options',
+    "Continuing option parsing with remaining ARGV: #{argv_copy}",
   )
-  # We want to allow people to pass in extra args to be passed to
-  # git commands, but OptionParser doesn't easily allow this. So we
-  # loop over it, catching exceptions.
-  begin
-    # HOWEVER, anytime it throws an exception, for some reason, it clears
-    # out all of ARGV, or whatever you passed to as ARGV.
-    #
-    # This not only prevents further parsing, but also means we lose
-    # any non-option arguements (like the subcommand!)
-    #
-    # So we save a copy, and if we throw an exception, save the option that
-    # caused it, remove that option from our copy, and then re-populate argv
-    # with what's left.
-    #
-    # By doing this we not only get to parse all the options properly and
-    # save unknown ones, but non-option arguements, which OptionParser
-    # normally leaves in ARGV stay in ARGV.
-    saved_argv = argv_copy.dup
-    parser.parse!(argv_copy)
-  rescue OptionParser::InvalidOption => e
-    SugarJar::Log.debug("Saving unknown argument #{e.args}")
-    extra_opts += e.args
-
-    # e.args is an array, but it's only ever one arguement per exception
-    saved_argv.delete(e.args.first)
-    argv_copy = saved_argv.dup
-    SugarJar::Log.debug(
-      "Continuing option parsing with remaining ARGV: #{argv_copy}",
-    )
-    retry
-  end
+  retry
 end
 
-subcommand = argv_copy.reject { |x| x.start_with?('-') }.first
+options = SugarJar::Config.config.merge(options)
+SugarJar::Log.level = options['log_level'].to_sym if options['log_level']
 
+subcommand = argv_copy.reject { |x| x.start_with?('-') }.first
 if ARGV.empty? || !subcommand
   puts parser
   exit
 end
 
-options = config.merge(options)
+SugarJar::Log.debug("Final config: #{options}")
 
-# Recreate SJ with all of our options
-SugarJar::Log.level = options['log_level'].to_sym if options['log_level']
 sj = SugarJar::Commands.new(options)
-
+valid_commands = sj.public_methods - Object.public_methods
 is_valid_command = valid_commands.include?(subcommand.to_sym)
-argv_copy.delete(subcommand)
+# We can't do .delete(subcommand) because someone could, for example
+# have a branch called 'co' and then do 'sj co co' - which will then
+# remove _all_ instances of 'co'. So find the first instance and remove
+# that.
+argv_copy.delete_at(argv_copy.find_index(subcommand))
 SugarJar::Log.debug("subcommand is #{subcommand}")
 
 # Extra options we got, plus any left over arguements are what we
@@ -309,25 +268,20 @@ SugarJar::Log.debug("subcommand is #{subcommand}")
 extra_opts += argv_copy
 SugarJar::Log.debug("extra unknown options: #{extra_opts}")
 
-if subcommand == 'help'
+case subcommand
+when 'help'
   puts parser
   exit
+when 'debuginfo'
+  extra_opts = [options]
 end
 
-if is_valid_command
-  SugarJar::Log.debug(
-    "running #{subcommand}; extra opts: #{extra_opts.join(', ')}",
-  )
-  sj.send(subcommand.to_sym, *extra_opts)
-elsif options['fallthru']
-  SugarJar::Log.debug("Falling thru to: hub #{ARGV.join(' ')}")
-  if options['github_cli'] == 'hub'
-    exec('hub', *ARGV)
-  else
-    # If we're using 'gh', it doesn't have 'git fall thru' support, so
-    # we pass thru directly to 'git'
-    exec('git', *ARGV)
-  end
-else
-  SugarJar::Log.error("No such subcommand: #{subcommand}")
+unless is_valid_command
+  SugarJar::Log.fatal("No such subcommand: #{subcommand}")
+  exit 1
 end
+
+SugarJar::Log.debug(
+  "running #{subcommand}; extra opts: #{extra_opts.join(', ')}",
+)
+sj.send(subcommand.to_sym, *extra_opts)

data/examples/sample_config.yaml

@@ -0,0 +1,24 @@
+# This is a sample SugarJar config
+#
+# SugarJar will look for this config in:
+#
+# - /etc/sugarjar/config.yaml
+# - ~/.config/sugarjar/config.yaml
+#
+# The latter will overwrite anything in the former.
+#
+
+# NOTE: This file does NOT document ALL options since any command-line option
+# to SugarJar is a valid configuration in this file, so see `sj help` for full
+# details.
+
+# Autofill in my PRs from my commit message (default: true)
+pr_autofile: true
+
+# Auto stack PRs when subfeatures are detected (default is `nil`, which prompts,
+# but use `true` or `false` to force an option without prompting)
+pr_autostack: true
+
+# Don't warn about deprecated config file options if they are in this
+# list
+ignore_deprecated_options: [ 'gh_cli' ]

data/examples/sample_repoconfig.yaml

@@ -0,0 +1,77 @@
+# This is a sample `repoconfig` for SugarJar
+#
+# Configs should be named `.sugarjar.yaml` and placed in the root
+# of your repository.
+#
+
+# `include_from` is a meta config wich will read from an additional
+# configuration file and merge anything from the file onto whatever is in the
+# primary file. This is helpful to have a repo configuration that applies to
+# all/most developers, but allow individual developers to add to over overwrite
+# specific configurations for themselves. If the file does not exist, this
+# configuration is ignored.
+
+include_from: .sugarjar_local.yaml
+
+# `overwrite_from` is a meta config which works much like `include_from`,
+# except that if the file is found, everything else in this configuration file
+# will be ignored and the configuration will be entirely read from the
+# referenced file.  If the file does not exist, this configuration is ignored.
+
+overwrite_from: .sugarjar_local_overwrite.yaml
+
+# `lint` is a list of scripts to run when `sj lint` is executed (or, if
+# configured, to run on `sj spush`/`sj fpush` - see `on_push` below).
+# Regardless of where `sj` is run from, these scripts will be run from the root
+# of the repo. If a slash is detected in the first 'word' of the command, it
+# is assumed it is a relative path and `sj` will check that the file exists.
+
+lint:
+  - scripts/run_rubocop.sh
+  - scripts/run_mdl.sh
+
+# `unit` is a list of scripts to run when `sj unit` is executed (or, if
+# configured to run on `sj spush`/`sj fpush`- see `on_push` below).  Regardless
+# of where `sj` is run from, these scripts will be run from the root of the
+# repo. If a slash is detected in the first 'word' of the command, it is
+# assumed it is a relative path and `sj` will check that the file exists.
+
+unit:
+  - bundle exec rspec
+  - scripts/run_tests.sh
+
+# `lint_list_cmd` is like `lint`, except it's a command to run which will
+# determine the proper lints to run and return them, one per line. This is
+# useful, for example, when you want to only run lints relevant to the changed
+# files.
+
+lint_list_cmd: scripts/determine_linters.sh
+
+# `unit_list_cmd` is like `unit`, except it's a command to run which will
+# determine the proper units to run and return them, one per line. This is
+# useful, for example, when you want to only run tests relevant to the changed
+# files.
+
+unit_list_cmd: scripts/determine_tests.sh
+
+# `on_push` determines what checks should be run when pushing a repo. Valid
+# options are `lint` and/or `unit` (or nothing, of course).
+
+on_push: [lint] # or [lint, unit]
+
+# `commit_template` points to a file to set the git `commit.template` config
+# to. This is really useful for ensuring that everyone has the same
+# template configured.
+
+commit_template: .git_commit_template.txt
+
+# `github_user` is the user to use when talking to GitHub. Overrides any such
+# setting in the regular SugarJar config. Most useful when in the
+# `include_from` file.
+
+github_user: myuser
+
+# `github_host` is the GitHub host to use when talking to GitHub (for hosted
+# GHE). See `github_user`.
+
+github_host: github.sample.com

data/lib/sugarjar/commands/amend.rb

@@ -0,0 +1,17 @@
+require_relative '../util'
+
+class SugarJar
+  class Commands
+    def amend(*)
+      assert_in_repo!
+      # This cannot use shellout since we need a full terminal for the editor
+      exit(system(SugarJar::Util.which('git'), 'commit', '--amend', *))
+    end
+
+    def qamend(*)
+      assert_in_repo!
+      SugarJar::Log.info(git('commit', '--amend', '--no-edit', *).stdout)
+    end
+    alias amendq qamend
+  end
+end

data/lib/sugarjar/commands/bclean.rb

@@ -0,0 +1,118 @@
+class SugarJar
+  class Commands
+    def bclean(name = nil)
+      assert_in_repo!
+      name ||= current_branch
+      name = fprefix(name)
+      if clean_branch(name)
+        SugarJar::Log.info("#{name}: #{color('reaped', :green)}")
+      else
+        die(
+          "#{color("Cannot clean #{name}", :red)}! there are unmerged " +
+          "commits; use 'git branch -D #{name}' to forcefully delete it.",
+        )
+      end
+    end
+
+    def bcleanall
+      assert_in_repo!
+      curr = current_branch
+      all_local_branches.each do |branch|
+        if MAIN_BRANCHES.include?(branch)
+          SugarJar::Log.debug("Skipping #{branch}")
+          next
+        end
+
+        if clean_branch(branch)
+          SugarJar::Log.info("#{branch}: #{color('reaped', :green)}")
+        else
+          SugarJar::Log.info("#{branch}: skipped")
+          SugarJar::Log.debug(
+            "There are unmerged commits; use 'git branch -D #{branch}' to " +
+            'forcefully delete it)',
+          )
+        end
+      end
+
+      # Return to the branch we were on, or main
+      if all_local_branches.include?(curr)
+        git('checkout', curr)
+      else
+        checkout_main_branch
+      end
+    end
+
+    private
+
+    def clean_branch(name)
+      die("Cannot remove #{name} branch") if MAIN_BRANCHES.include?(name)
+      SugarJar::Log.debug('Fetch relevant remote...')
+      fetch_upstream
+      return false unless safe_to_clean(name)
+
+      SugarJar::Log.debug('branch deemed safe to delete...')
+      checkout_main_branch
+      git('branch', '-D', name)
+      rebase
+      true
+    end
+
+    def safe_to_clean(branch)
+      # cherry -v will output 1 line per commit on the target branch
+      # prefixed by a - or + - anything with a - can be dropped, anything
+      # else cannot.
+      out = git(
+        'cherry', '-v', tracked_branch, branch
+      ).stdout.lines.reject do |line|
+        line.start_with?('-')
+      end
+      if out.empty?
+        SugarJar::Log.debug(
+          "cherry-pick shows branch #{branch} obviously safe to delete",
+        )
+        return true
+      end
+
+      # if the "easy" check didn't work, it's probably because there
+      # was a squash-merge. To check for that we make our own squash
+      # merge to upstream/main and see if that has any delta
+
+      # First we need a temp branch to work on
+      tmpbranch = "_sugar_jar.#{Process.pid}"
+
+      git('checkout', '-b', tmpbranch, tracked_branch)
+      s = git_nofail('merge', '--squash', branch)
+      if s.error?
+        cleanup_tmp_branch(tmpbranch, branch)
+        SugarJar::Log.debug(
+          'Failed to merge changes into current main. This means we could ' +
+          'not figure out if this is merged or not. Check manually and use ' +
+          "'git branch -D #{branch}' if it is safe to do so.",
+        )
+        return false
+      end
+
+      s = git('diff', '--staged')
+      out = s.stdout
+      SugarJar::Log.debug("Squash-merged diff: #{out}")
+      cleanup_tmp_branch(tmpbranch, branch)
+      if out.empty?
+        SugarJar::Log.debug(
+          'After squash-merging, this branch appears safe to delete',
+        )
+        true
+      else
+        SugarJar::Log.debug(
+          'After squash-merging, this branch is NOT fully merged to main',
+        )
+        false
+      end
+    end
+
+    def cleanup_tmp_branch(tmp, backto)
+      git('reset', '--hard', tracked_branch)
+      git('checkout', backto)
+      git('branch', '-D', tmp)
+    end
+  end
+end

data/lib/sugarjar/commands/branch.rb

@@ -0,0 +1,42 @@
+class SugarJar
+  class Commands
+    def checkout(*args)
+      assert_in_repo!
+      # Pop the last arguement, which is _probably_ a branch name
+      # and then add any featureprefix, and if _that_ is a branch
+      # name, replace the last arguement with that
+      name = args.last
+      bname = fprefix(name)
+      if all_local_branches.include?(bname)
+        SugarJar::Log.debug("Featurepefixing #{name} -> #{bname}")
+        args[-1] = bname
+      end
+      s = git('checkout', *args)
+      SugarJar::Log.info(s.stderr + s.stdout.chomp)
+    end
+    alias co checkout
+
+    def br
+      assert_in_repo!
+      SugarJar::Log.info(git('branch', '-v').stdout.chomp)
+    end
+
+    def binfo
+      assert_in_repo!
+      SugarJar::Log.info(git(
+        'log', '--graph', '--oneline', '--decorate', '--boundary',
+        "#{tracked_branch}.."
+      ).stdout.chomp)
+    end
+
+    # binfo for all branches
+    def smartlog
+      assert_in_repo!
+      SugarJar::Log.info(git(
+        'log', '--graph', '--oneline', '--decorate', '--boundary',
+        '--branches', "#{most_main}.."
+      ).stdout.chomp)
+    end
+    alias sl smartlog
+  end
+end

data/lib/sugarjar/commands/checks.rb

@@ -0,0 +1,139 @@
+require_relative '../util'
+
+class SugarJar
+  class Commands
+    def lint
+      assert_in_repo!
+      if dirty?
+        if @ignore_dirty
+          SugarJar::Log.warn(
+            'Your repo is dirty, but --ignore-dirty was specified, so ' +
+            'carrying on anyway. If the linter autocorrects, the displayed ' +
+            'diff will be misleading',
+          )
+        else
+          SugarJar::Log.error(
+            'Your repo is dirty, but --ignore-dirty was not specified. ' +
+            'Refusing to run lint. This is to ensure that if the linter ' +
+            'autocorrects, we can show the correct diff.',
+          )
+          exit(1)
+        end
+      end
+      exit(1) unless run_check('lint')
+    end
+
+    def unit
+      assert_in_repo!
+      exit(1) unless run_check('unit')
+    end
+
+    def get_checks_from_command(type)
+      return nil unless @repo_config["#{type}_list_cmd"]
+
+      cmd = @repo_config["#{type}_list_cmd"]
+      short = cmd.split.first
+      unless File.exist?(short)
+        SugarJar::Log.error(
+          "Configured #{type}_list_cmd #{short} does not exist!",
+        )
+        return false
+      end
+      s = Mixlib::ShellOut.new(cmd).run_command
+      if s.error?
+        SugarJar::Log.error(
+          "#{type}_list_cmd (#{cmd}) failed: #{s.format_for_exception}",
+        )
+        return false
+      end
+      s.stdout.split("\n")
+    end
+
+    # determine if we're using the _list_cmd and if so run it to get the
+    # checks, or just use the directly-defined check, and cache it
+    def get_checks(type)
+      return @checks[type] if @checks[type]
+
+      ret = get_checks_from_command(type)
+      if ret
+        SugarJar::Log.debug("Found #{type}s: #{ret}")
+        @checks[type] = ret
+      # if it's explicitly false, we failed to run the command
+      elsif ret == false
+        @checks[type] = false
+      # otherwise, we move on (basically: it's nil, there was no _list_cmd)
+      else
+        SugarJar::Log.debug("[#{type}]: using listed linters: #{ret}")
+        @checks[type] = @repo_config[type] || []
+      end
+      @checks[type]
+    end
+
+    def run_check(type)
+      repo_root = SugarJar::Util.repo_root
+      Dir.chdir repo_root do
+        checks = get_checks(type)
+        # if we failed to determine the checks, the the checks have effectively
+        # failed
+        return false unless checks
+
+        checks.each do |check|
+          SugarJar::Log.debug("Running #{type} #{check}")
+
+          short = check.split.first
+          if short.include?('/')
+            short = File.join(repo_root, short) unless short.start_with?('/')
+            unless File.exist?(short)
+              SugarJar::Log.error("Configured #{type} #{short} does not exist!")
+            end
+          elsif !SugarJar::Util.which_nofail(short)
+            SugarJar::Log.error("Configured #{type} #{short} does not exist!")
+            return false
+          end
+          s = Mixlib::ShellOut.new(check).run_command
+
+          # Linters auto-correct, lets handle that gracefully
+          if type == 'lint' && dirty?
+            SugarJar::Log.info(
+              "[#{type}] #{short}: #{color('Corrected', :yellow)}",
+            )
+            SugarJar::Log.warn(
+              "The linter modified the repo. Here's the diff:\n",
+            )
+            puts git('diff').stdout
+            loop do
+              $stdout.print(
+                "\nWould you like to\n\t[q]uit and inspect\n\t[a]mend the " +
+                "changes to the current commit and re-run\n  > ",
+              )
+              ans = $stdin.gets.strip
+              case ans
+              when /^q/
+                SugarJar::Log.info('Exiting at user request.')
+                exit(1)
+              when /^a/
+                qamend('-a')
+                # break here, if we get out of this loop we 'redo', assuming
+                # the user chose this option
+                break
+              end
+            end
+            redo
+          end
+
+          if s.error?
+            SugarJar::Log.info(
+              "[#{type}] #{short} #{color('failed', :red)}, output follows " +
+              "(see debug for more)\n#{s.stdout}",
+            )
+            SugarJar::Log.debug(s.format_for_exception)
+            return false
+          end
+          SugarJar::Log.info(
+            "[#{type}] #{short}: #{color('OK', :green)}",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sugarjar/commands/debuginfo.rb

@@ -0,0 +1,16 @@
+require 'json'
+
+class SugarJar
+  class Commands
+    def debuginfo(*args)
+      puts "sugarjar version #{SugarJar::VERSION}"
+      puts ghcli('version').stdout
+      puts git('version').stdout
+
+      puts "Config: #{JSON.pretty_generate(args[0])}"
+      return unless @repo_config
+
+      puts "Repo config: #{JSON.pretty_generate(@repo_config)}"
+    end
+  end
+end