sugarjar 2.0.0.beta.1 → 2.0.2

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,233 @@
+class SugarJar
+  class Commands
+    def lbclean(name = nil)
+      assert_in_repo!
+      name ||= current_branch
+      name = fprefix(name)
+
+      wt_branches = worktree_branches
+
+      if wt_branches.include?(name)
+        SugarJar::Log.warn("#{name}: #{color('skipped', :yellow)} (worktree)")
+        return
+      end
+
+      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
+    alias localbranchclean lbclean
+    # backcompat
+    alias bclean lbclean
+
+    def rbclean(name = nil, remote = nil)
+      assert_in_repo!
+      name ||= current_branch
+      name = fprefix(name)
+      remote ||= 'origin'
+
+      ref = "refs/remotes/#{remote}/#{name}"
+      if git_nofail('show-ref', '--quiet', ref).error?
+        SugarJar::Log.warn("Remote branch #{name} on #{remote} does not exist.")
+        return
+      end
+
+      if clean_branch(ref, :remote)
+        SugarJar::Log.info("#{ref}: #{color('reaped', :green)}")
+      else
+        die(
+          "#{color("Cannot clean #{ref}", :red)}! there are unmerged " +
+          "commits; use 'git push #{remote} -d #{name}' to forcefully delete " +
+          ' it.',
+        )
+      end
+    end
+    alias remotebranchclean rbclean
+
+    def gbclean(name = nil, remote = nil)
+      assert_in_repo!
+      name ||= current_branch
+      remote ||= 'origin'
+      lbclean(name)
+      rbclean(name, remote)
+    end
+    alias globalbranchclean gbclean
+
+    def lbcleanall
+      assert_in_repo!
+      curr = current_branch
+      wt_branches = worktree_branches
+      all_local_branches.each do |branch|
+        if MAIN_BRANCHES.include?(branch)
+          SugarJar::Log.debug("Skipping #{branch}")
+          next
+        end
+        if wt_branches.include?(branch)
+          SugarJar::Log.info(
+            "#{branch}: #{color('skipped', :yellow)} (worktree)",
+          )
+          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
+    alias localbranchcleanall lbcleanall
+    # backcomat
+    alias bcleanall lbcleanall
+
+    def rbcleanall(remote = nil)
+      assert_in_repo!
+      curr = current_branch
+      remote ||= 'origin'
+      all_remote_branches(remote).each do |branch|
+        if (MAIN_BRANCHES + ['HEAD']).include?(branch)
+          SugarJar::Log.debug("Skipping #{branch}")
+          next
+        end
+
+        ref = "refs/remotes/#{remote}/#{branch}"
+        if clean_branch(ref, :remote)
+          SugarJar::Log.info("#{ref}: #{color('reaped', :green)}")
+        else
+          SugarJar::Log.info("#{ref}: 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
+    alias remotebranchcleanall rbcleanall
+
+    def gbcleanall(remote = nil)
+      assert_in_repo!
+      bcleanall
+      rcleanall(remote)
+    end
+    alias globalbranchcleanall gbcleanall
+
+    private
+
+    # rubocop:disable Naming/PredicateMethod
+    def clean_branch(name, type = :local)
+      undeleteable = MAIN_BRANCHES.dup
+      undeleteable << 'HEAD' if type == :remote
+      die("Cannot remove #{name} branch") if undeleteable.include?(name)
+      SugarJar::Log.debug('Fetch relevant remote...')
+      fetch_upstream
+      fetch(remote_from_ref(name)) if type == :remote
+      return false unless safe_to_clean?(name)
+
+      SugarJar::Log.debug('branch deemed safe to delete...')
+      if type == :remote
+        remote = remote_from_ref(name)
+        branch = branch_from_ref(name, :remote)
+        git('push', remote, '--delete', branch)
+      else
+        checkout_main_branch
+        git('branch', '-D', name)
+        rebase
+      end
+      true
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    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.
+      SugarJar::Log.debug("Checking if branch #{branch} is safe to delete...")
+      if branch.start_with?('refs/remotes/')
+        remote = remote_from_ref(branch)
+        tracked = main_remote_branch(remote)
+      else
+        tracked = tracked_branch(branch)
+      end
+      out = git(
+        'cherry', '-v', tracked, 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)
+      s = git_nofail('merge', '--squash', branch)
+      if s.error?
+        cleanup_tmp_branch(tmpbranch, branch, tracked)
+        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, tracked)
+      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, tracked = nil)
+      tracked ||= tracked_branch
+      # Reset any changes on our temp branch from various merge attempts
+      # so we're in a state we know we can 'checkout' away from.
+      git('reset', '--hard', tracked)
+      # checkout whatever branch we were on before
+      git('checkout', backto)
+      # delete our temp branch
+      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,141 @@
+require_relative '../util'
+
+class SugarJar
+  class Commands
+    def lint
+      assert_in_repo!
+
+      # does not use dirty_check! as we want a custom message
+      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

data/lib/sugarjar/commands/feature.rb

@@ -0,0 +1,35 @@
+class SugarJar
+  class Commands
+    def feature(name, base = nil)
+      assert_in_repo!
+      SugarJar::Log.debug("Feature: #{name}, #{base}")
+      name = fprefix(name)
+      die("#{name} already exists!") if all_local_branches.include?(name)
+      if base
+        fbase = fprefix(base)
+        base = fbase if all_local_branches.include?(fbase)
+      else
+        base ||= most_main
+      end
+      # If our base is a local branch, don't try to parse it for a remote name
+      unless all_local_branches.include?(base)
+        base_pieces = base.split('/')
+        git('fetch', base_pieces[0]) if base_pieces.length > 1
+      end
+      git('checkout', '-b', name, base)
+      git('branch', '-u', base)
+      SugarJar::Log.info(
+        "Created feature branch #{color(name, :green)} based on " +
+        color(base, :green),
+      )
+    end
+    alias f feature
+
+    def subfeature(name)
+      assert_in_repo!
+      SugarJar::Log.debug("Subfature: #{name}")
+      feature(name, current_branch)
+    end
+    alias sf subfeature
+  end
+end

data/lib/sugarjar/commands/pullsuggestions.rb

@@ -0,0 +1,35 @@
+require_relative '../util'
+
+class SugarJar
+  class Commands
+    def pullsuggestions
+      assert_in_repo!
+      dirty_check!
+
+      src = "origin/#{current_branch}"
+      fetch('origin')
+
+      diff = git('diff', "..#{src}").stdout
+      return unless diff && !diff.empty?
+
+      puts "Will merge the following suggestions:\n\n#{diff}"
+
+      loop do
+        $stdout.print("\nAre you sure? [y/n] ")
+        ans = $stdin.gets.strip
+        case ans
+        when /^[Yy]$/
+          git = SugarJar::Util.which('git')
+          system(git, 'merge', '--ff', "origin/#{current_branch}")
+          break
+        when /^[Nn]$/, /^[Qq](uit)?/
+          puts 'Not merging at user request...'
+          break
+        else
+          puts "Didn't understand '#{ans}'."
+        end
+      end
+    end
+    alias ps pullsuggestions
+  end
+end

data/lib/sugarjar/commands/push.rb

@@ -0,0 +1,55 @@
+class SugarJar
+  class Commands
+    def smartpush(remote = nil, branch = nil)
+      assert_in_repo!
+      _smartpush(remote, branch, false)
+    end
+    alias spush smartpush
+
+    def forcepush(remote = nil, branch = nil)
+      assert_in_repo!
+      _smartpush(remote, branch, true)
+    end
+    alias fpush forcepush
+
+    private
+
+    def _smartpush(remote, branch, force)
+      unless remote && branch
+        remote ||= 'origin'
+        branch ||= current_branch
+      end
+
+      dirty_check!
+
+      unless run_prepush
+        if @ignore_prerun_failure
+          SugarJar::Log.warn(
+            'Pre-push checks failed, but --ignore-prerun-failure was ' +
+            'specified, so carrying on anyway',
+          )
+        else
+          SugarJar::Log.error('Pre-push checks failed. Not pushing.')
+          exit(1)
+        end
+      end
+
+      args = ['push', remote, branch]
+      args << '--force-with-lease' if force
+      puts git(*args).stderr
+    end
+
+    # rubocop:disable Naming/PredicateMethod
+    def run_prepush
+      @repo_config['on_push']&.each do |item|
+        SugarJar::Log.debug("Running on_push check type #{item}")
+        unless run_check(item)
+          SugarJar::Log.info("[prepush]: #{item} #{color('failed', :red)}.")
+          return false
+        end
+      end
+      true
+    end
+    # rubocop:enable Naming/PredicateMethod
+  end
+end

data/lib/sugarjar/commands/smartclone.rb

@@ -0,0 +1,30 @@
+class SugarJar
+  class Commands
+    def smartclone(repo, dir = nil, *)
+      reponame = File.basename(repo, '.git')
+      dir ||= reponame
+      org = extract_org(repo)
+
+      SugarJar::Log.info("Cloning #{reponame}...")
+
+      # GH's 'fork' command (with the --clone arg) will fork, if necessary,
+      # then clone, and then setup the remotes with the appropriate names. So
+      # we just let it do all the work for us and return.
+      #
+      # Unless the repo is in our own org and cannot be forked, then it
+      # will fail.
+      if org == @ghuser
+        git('clone', canonicalize_repo(repo), dir, *)
+      else
+        ghcli('repo', 'fork', '--clone', canonicalize_repo(repo), dir, *)
+        # make the main branch track upstream
+        Dir.chdir dir do
+          git('branch', '-u', "upstream/#{main_branch}")
+        end
+      end
+
+      SugarJar::Log.info('Remotes "origin" and "upstream" configured.')
+    end
+    alias sclone smartclone
+  end
+end