sugarjar 2.0.1 → 3.0.0

data/lib/sugarjar/commands/bclean.rb

@@ -1,9 +1,18 @@
 class SugarJar
   class Commands
-    def bclean(name = nil)
+    def lbclean(name = nil)
       assert_in_repo!
       name ||= current_branch
       name = fprefix(name)
+
+      should_skip, why = skip_branch_info(name)
+      if should_skip
+        msg = "#{name}: #{color('skipped', :yellow)}"
+        msg << " (#{why})" if why
+        SugarJar::Log.warn(msg)
+        return
+      end
+
       if clean_branch(name)
         SugarJar::Log.info("#{name}: #{color('reaped', :green)}")
       else
@@ -13,13 +22,57 @@ class SugarJar
         )
       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 bcleanall
+    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
+      worktree_branches
       all_local_branches.each do |branch|
-        if MAIN_BRANCHES.include?(branch)
-          SugarJar::Log.debug("Skipping #{branch}")
+        # skip_branch info will check for MAIN_BRANCHES, but we
+        # quietly skip them.
+        next if MAIN_BRANCHES.include?(branch)
+
+        should_skip, why = skip_branch_info(branch)
+        if should_skip
+          msg = "#{branch}: #{color('skipped', :yellow)}"
+          msg << " (#{why})" if why
+          SugarJar::Log.info(msg)
           next
         end
 
@@ -41,28 +94,87 @@ class SugarJar
         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
 
-    def clean_branch(name)
-      die("Cannot remove #{name} branch") if MAIN_BRANCHES.include?(name)
+    # 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
-      return false unless safe_to_clean(name)
+      fetch(remote_from_ref(name)) if type == :remote
+      return false unless safe_to_clean?(name)
 
       SugarJar::Log.debug('branch deemed safe to delete...')
-      checkout_main_branch
-      git('branch', '-D', name)
-      rebase
+      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)
+    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, branch
+        'cherry', '-v', tracked, branch
       ).stdout.lines.reject do |line|
         line.start_with?('-')
       end
@@ -80,10 +192,10 @@ class SugarJar
       # First we need a temp branch to work on
       tmpbranch = "_sugar_jar.#{Process.pid}"
 
-      git('checkout', '-b', tmpbranch, tracked_branch)
+      git('checkout', '-b', tmpbranch, tracked)
       s = git_nofail('merge', '--squash', branch)
       if s.error?
-        cleanup_tmp_branch(tmpbranch, branch)
+        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 ' +
@@ -95,7 +207,7 @@ class SugarJar
       s = git('diff', '--staged')
       out = s.stdout
       SugarJar::Log.debug("Squash-merged diff: #{out}")
-      cleanup_tmp_branch(tmpbranch, branch)
+      cleanup_tmp_branch(tmpbranch, branch, tracked)
       if out.empty?
         SugarJar::Log.debug(
           'After squash-merging, this branch appears safe to delete',
@@ -109,10 +221,28 @@ class SugarJar
       end
     end
 
-    def cleanup_tmp_branch(tmp, backto)
-      git('reset', '--hard', tracked_branch)
+    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
+
+    def skip_branch_info(name)
+      return true, 'main branch' if MAIN_BRANCHES.include?(name)
+
+      wt_branches = worktree_branches
+      rel_branches = release_branches
+
+      return true, 'worktree' if wt_branches.include?(name)
+
+      return true, 'release branch' if rel_branches.include?(name)
+
+      [false, nil]
+    end
   end
 end

data/lib/sugarjar/commands/checks.rb

@@ -4,6 +4,8 @@ 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(
@@ -20,12 +22,12 @@ class SugarJar
           exit(1)
         end
       end
-      exit(1) unless run_check('lint')
+      exit(1) unless run_check('lint', false)
     end
 
     def unit
       assert_in_repo!
-      exit(1) unless run_check('unit')
+      exit(1) unless run_check('unit', false)
     end
 
     def get_checks_from_command(type)
@@ -69,7 +71,13 @@ class SugarJar
       @checks[type]
     end
 
-    def run_check(type)
+    # autorun is true when we're running from push, and false when someone
+    # ran 'lint' or 'unit' directly
+    #
+    # In the case of a autorun, if a linter changes the code, we require
+    # either the user amend, or bail out. If it's a manual run, then we
+    # allow them to just go on.
+    def run_check(type, autorun)
       repo_root = SugarJar::Util.repo_root
       Dir.chdir repo_root do
         checks = get_checks(type)
@@ -79,6 +87,7 @@ class SugarJar
 
         checks.each do |check|
           SugarJar::Log.debug("Running #{type} #{check}")
+          skip_redo = false
 
           short = check.split.first
           if short.include?('/')
@@ -102,10 +111,15 @@ class SugarJar
             )
             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  > ",
-              )
+              options = [
+                '[q]uit and inspect',
+                '[a]mend the changes to the current commit and re-run',
+              ]
+              options << '[i]gnore the changes and keep going' unless autorun
+
+              msg = "\nWould you like to\n\t" + options.join("\n\t") + "\n  > "
+
+              $stdout.print(msg)
               ans = $stdin.gets.strip
               case ans
               when /^q/
@@ -116,9 +130,14 @@ class SugarJar
                 # break here, if we get out of this loop we 'redo', assuming
                 # the user chose this option
                 break
+              when /^i/
+                unless autorun
+                  skip_redo = true
+                  break
+                end
               end
             end
-            redo
+            redo unless skip_redo
           end
 
           if s.error?

data/lib/sugarjar/commands/debuginfo.rb

@@ -4,7 +4,7 @@ class SugarJar
   class Commands
     def debuginfo(*args)
       puts "sugarjar version #{SugarJar::VERSION}"
-      puts ghcli('version').stdout
+      puts forge('version').stdout
       puts git('version').stdout
 
       puts "Config: #{JSON.pretty_generate(args[0])}"

data/lib/sugarjar/commands/feature.rb

@@ -5,10 +5,32 @@ class SugarJar
       SugarJar::Log.debug("Feature: #{name}, #{base}")
       name = fprefix(name)
       die("#{name} already exists!") if all_local_branches.include?(name)
+      rel_branches = release_branches
       if base
-        fbase = fprefix(base)
-        base = fbase if all_local_branches.include?(fbase)
+        # If the user specified a base branch (sf mything base)
+        # we check if <base> is a release branch and if so, we make
+        # this track <upstream>/<base>
+        if rel_branches.include?(base)
+          newbase = "#{upstream}/#{base}"
+          SugarJar::Log.info(
+            "Base branch #{base} is a release branch, setting it to track " +
+            newbase,
+          )
+          base = newbase
+        else
+          fbase = fprefix(base)
+          base = fbase if all_local_branches.include?(fbase)
+        end
+      elsif rel_branches.include?(name)
+        # If the user did NOT specify a base *and* this new feature is
+        # a release branch, check it out tracking the upstream release
+        # branch instead of main
+        base = "#{upstream}/#{name}"
+        SugarJar::Log.info(
+          "Feature #{name} is a release branch, setting it to track #{base}",
+        )
       else
+        # otherwise, fallback to most-main
         base ||= most_main
       end
       # If our base is a local branch, don't try to parse it for a remote name
@@ -25,6 +47,7 @@ class SugarJar
     end
     alias f feature
 
+    # alias for "feature <current_branch>'
     def subfeature(name)
       assert_in_repo!
       SugarJar::Log.debug("Subfature: #{name}")

data/lib/sugarjar/commands/pullsuggestions.rb

@@ -4,24 +4,11 @@ class SugarJar
   class Commands
     def pullsuggestions
       assert_in_repo!
-
-      if dirty?
-        if @ignore_dirty
-          SugarJar::Log.warn(
-            'Your repo is dirty, but --ignore-dirty was specified, so ' +
-            'carrying on anyway.',
-          )
-        else
-          SugarJar::Log.error(
-            'Your repo is dirty, so I am not going to push. Please commit ' +
-            'or amend first.',
-          )
-          exit(1)
-        end
-      end
+      dirty_check!
 
       src = "origin/#{current_branch}"
       fetch('origin')
+
       diff = git('diff', "..#{src}").stdout
       return unless diff && !diff.empty?
 

data/lib/sugarjar/commands/push.rb

@@ -20,20 +20,7 @@ class SugarJar
         branch ||= current_branch
       end
 
-      if dirty?
-        if @ignore_dirty
-          SugarJar::Log.warn(
-            'Your repo is dirty, but --ignore-dirty was specified, so ' +
-            'carrying on anyway.',
-          )
-        else
-          SugarJar::Log.error(
-            'Your repo is dirty, so I am not going to push. Please commit ' +
-            'or amend first.',
-          )
-          exit(1)
-        end
-      end
+      dirty_check!
 
       unless run_prepush
         if @ignore_prerun_failure
@@ -52,15 +39,17 @@ class SugarJar
       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)
+        unless run_check(item, true)
           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

@@ -1,7 +1,7 @@
 class SugarJar
   class Commands
     def smartclone(repo, dir = nil, *)
-      reponame = File.basename(repo, '.git')
+      reponame = extract_repo(repo)
       dir ||= reponame
       org = extract_org(repo)
 
@@ -13,10 +13,15 @@ class SugarJar
       #
       # Unless the repo is in our own org and cannot be forked, then it
       # will fail.
-      if org == @ghuser
+      if org == @forge_user
         git('clone', canonicalize_repo(repo), dir, *)
       else
-        ghcli('repo', 'fork', '--clone', canonicalize_repo(repo), dir, *)
+        if @repo_forge == 'gitlab'
+          _gitlab_clone(org, repo, dir, *)
+        else
+          forge('repo', 'fork', '--clone', canonicalize_repo(repo), dir, *)
+        end
+
         # make the main branch track upstream
         Dir.chdir dir do
           git('branch', '-u', "upstream/#{main_branch}")
@@ -26,5 +31,44 @@ class SugarJar
       SugarJar::Log.info('Remotes "origin" and "upstream" configured.')
     end
     alias sclone smartclone
+
+    def _gitlab_clone(_org, repo, dir, *)
+      # The gitlab CLI is much less forgiving about already-forked
+      # repos, and it has no option to clone to a differently-named
+      # directory. So we have to special case it.
+
+      # glab requires a short-name for the fork command...
+      shortname = repo_shortname(repo)
+
+      # We call fork without --clone since --clone can't clone
+      # to another directory. Also, we must specify =false, or it
+      # will prompt
+      s = forge_nofail('repo', 'fork', shortname, '--clone=false')
+
+      # It fails with:
+      #    409 {message: [Project namespace name has already been taken,
+      #         Name has already been taken, Path has already been taken]}
+      #
+      # when there's already a fork... or if you happen to have a name
+      # collision. There's no way to tell, so we assume it means we've
+      # already forked.
+      if s.error?
+        if s.stderr.include?(' 409 ')
+          SugarJar::Log.debug('Forking failed, probably already forked')
+        else
+          s.error!
+        end
+      end
+
+      # Now we clone ourselves...
+      git('clone', canonicalize_repo(repo), dir, *)
+      Dir.chdir dir do
+        # and then configure remotes properly
+        git('remote', 'rename', 'origin', 'upstream')
+
+        fork_url = forked_repo(repo, @forge_user)
+        git('remote', 'add', 'origin', fork_url)
+      end
+    end
   end
 end

data/lib/sugarjar/commands/smartpullrequest.rb

@@ -6,6 +6,7 @@ class SugarJar
       assert_in_repo!
       assert_common_main_branch!
 
+      # does not use `dirty_check!` because we don't allow overriding here
       if dirty?
         SugarJar::Log.warn(
           'Your repo is dirty, so I am not going to create a pull request. ' +
@@ -59,10 +60,25 @@ class SugarJar
 
       # <org>:<branch> is the GH API syntax for:
       #   look for a branch of name <branch>, from a fork in owner <org>
-      args.unshift('--head', "#{push_org}:#{curr}")
-      SugarJar::Log.trace("Running: gh pr create #{args.join(' ')}")
-      gh = SugarJar::Util.which('gh')
-      system(gh, 'pr', 'create', *args)
+      if @repo_forge == 'github'
+        # On GitHub, the head is the org and the *BRANCH* name to use as
+        # the head branch...
+        args.unshift('--head', "#{push_org}:#{curr}")
+      else
+        # On GitLab, the head is the repo (org/repo) to use as the head
+        # _repo_, and then branch is configured seperately (with -s), but
+        # we don't need that since it defaults to the local branch name.
+        #
+        # Then we need --yes for it to not prompt us
+        args.unshift('--head', "#{push_org}/#{reponame}", '--yes')
+      end
+
+      bin = SugarJar::Util.which(_forge_cmd)
+      subcmd = _pr_cmd
+      SugarJar::Log.trace(
+        "Running: #{bin} #{subcmd} create #{args.join(' ')}",
+      )
+      system(bin, subcmd, 'create', *args)
     end
 
     alias spr smartpullrequest
@@ -70,6 +86,10 @@ class SugarJar
 
     private
 
+    def _pr_cmd
+      @repo_forge == 'gitlab' ? 'mr' : 'pr'
+    end
+
     def assert_common_main_branch!
       upstream_branch = main_remote_branch(upstream)
       unless main_branch == upstream_branch
@@ -86,7 +106,9 @@ class SugarJar
       return if upstream_branch == 'origin'
 
       origin_branch = main_remote_branch('origin')
-      return if origin_branch == upstream_branch
+      # NOTE: that on GL, forks don't fork any branches by default, even
+      # a main one, so if it's 'nil', then ignore.
+      return if origin_branch.nil? || origin_branch == upstream_branch
 
       die(
         "The main branch of your upstream (#{upstream_branch}) and your " +

data/lib/sugarjar/commands/up.rb

@@ -53,19 +53,71 @@ class SugarJar
       end
     end
 
+    def fsync
+      sync(:force => true)
+    end
+    alias forcesync fsync
+
+    def sync(force: false)
+      assert_in_repo!
+      dirty_check!
+
+      src = "origin/#{current_branch}"
+      fetch('origin')
+      want_reset = false
+      if force
+        SugarJar::Log.debug('Forcing reset instead of rebase at user request')
+        want_reset = true
+      end
+
+      unless force
+        s = git_nofail('merge-base', '--is-ancestor', 'HEAD', src)
+        # if this IS an ancestor, we can just force reset.
+        #
+        # otherwise, we attempt a rebase to not lose anything (unless
+        # force is set)
+        if s.error?
+          SugarJar::Log.debug(
+            "Choosing rebase sync since this isn't a direct ancestor",
+          )
+        else
+          SugarJar::Log.debug('Choosing reset sync since this is an ancestor')
+          want_reset = true
+        end
+      end
+
+      if want_reset
+        git('reset', '--hard', src)
+      else
+        rebase(src)
+        s = git_nofail('rev-parse', '--verify', 'REBASE_HEAD')
+        unless s.error?
+          SugarJar::Log.info(
+            'Rebase required input. You may continue the rebase from' +
+            ' here normally, or you may abort (`git rebase --abort`)' +
+            ' and instead to `sj fsync` to skip a rebase and force' +
+            ' reset to the remote branch.',
+          )
+          return
+        end
+      end
+      SugarJar::Log.info("Synced to #{src}.")
+    end
+
     private
 
-    def rebase
+    def rebase(base = nil)
+      skip_base_warning = !base.nil?
       SugarJar::Log.debug('Fetching upstream')
       fetch_upstream
       curr = current_branch
       # this isn't a hash, it's a named param, silly rubocop
       # rubocop:disable Style/HashSyntax
-      base = tracked_branch(fallback: false)
+      base ||= tracked_branch(fallback: false)
       # rubocop:enable Style/HashSyntax
       unless base
         SugarJar::Log.info(
-          'The brach we were tracking is gone, resetting tracking to ' +
+          'The branch we were tracking is gone, resetting tracking to ' +
           most_main,
         )
         git('branch', '-u', most_main)
@@ -74,7 +126,8 @@ class SugarJar
       # If this is a subfeature based on a local branch which has since
       # been deleted, 'tracked branch' will automatically return <most_main>
       # so we don't need any special handling for that
-      if !MAIN_BRANCHES.include?(curr) && base == "origin/#{curr}"
+      if !MAIN_BRANCHES.include?(curr) && base == "origin/#{curr}" &&
+         !skip_base_warning
         SugarJar::Log.warn(
           "This branch is tracking origin/#{curr}, which is probably your " +
           'downstream (where you push _to_) as opposed to your upstream ' +