sugarjar 2.0.0.beta.1 → 2.0.2

data/lib/sugarjar/commands/smartpullrequest.rb

@@ -0,0 +1,102 @@
+require_relative '../util'
+
+class SugarJar
+  class Commands
+    def smartpullrequest(*args)
+      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. ' +
+          'You should commit or amend and push it to your remote first.',
+        )
+        exit(1)
+      end
+
+      user_specified_base = args.include?('-B') || args.include?('--base')
+
+      curr = current_branch
+      base = tracked_branch
+      if @pr_autofill
+        SugarJar::Log.info('Autofilling in PR from commit message')
+        num_commits = git(
+          'rev-list', '--count', curr, "^#{base}"
+        ).stdout.strip.to_i
+        if num_commits > 1
+          args.unshift('--fill-first')
+        else
+          args.unshift('--fill')
+        end
+      end
+      unless user_specified_base
+        if subfeature?(base)
+          if upstream_org != push_org
+            SugarJar::Log.warn(
+              'Unfortunately you cannot based one PR on another PR when' +
+              " using fork-based PRs. We will base this on #{most_main}." +
+              ' This just means the PR "Changes" tab will show changes for' +
+              ' the full stack until those other PRs are merged and this PR' +
+              ' PR is rebased.',
+            )
+          # nil is prompt, true is always, false is never
+          elsif @pr_autostack.nil?
+            $stdout.print(
+              'It looks like this is a subfeature, would you like to base ' +
+              "this PR on #{base}? [y/n] ",
+            )
+            ans = $stdin.gets.strip
+            args.unshift('--base', base) if %w{Y y}.include?(ans)
+          elsif @pr_autostack
+            args.unshift('--base', base)
+          end
+        elsif base.include?('/') && base != most_main
+          # If our base is a remote branch, then use that as the
+          # base branch of the PR
+          args.unshift('--base', base.split('/').last)
+        end
+      end
+
+      # <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)
+    end
+
+    alias spr smartpullrequest
+    alias smartpr smartpullrequest
+
+    private
+
+    def assert_common_main_branch!
+      upstream_branch = main_remote_branch(upstream)
+      unless main_branch == upstream_branch
+        die(
+          "The local main branch is '#{main_branch}', but the main branch " +
+          "of the #{upstream} remote is '#{upstream_branch}'. You probably " +
+          "want to rename your local branch by doing:\n\t" +
+          "git branch -m #{main_branch} #{upstream_branch}\n\t" +
+          "git fetch #{upstream}\n\t" +
+          "git branch -u #{upstream}/#{upstream_branch} #{upstream_branch}\n" +
+          "\tgit remote set-head #{upstream} -a",
+        )
+      end
+      return if upstream_branch == 'origin'
+
+      origin_branch = main_remote_branch('origin')
+      return if origin_branch == upstream_branch
+
+      die(
+        "The main branch of your upstream (#{upstream_branch}) and your " +
+        "fork/origin (#{origin_branch}) are not the same. You should go " +
+        "to https://#{@ghhost || 'github.com'}/#{@ghuser}/#{repo_name}/" +
+        'branches/ and rename the \'default\' branch to ' +
+        "'#{upstream_branch}'. It will then give you some commands to " +
+        'run to update this clone.',
+      )
+    end
+  end
+end

data/lib/sugarjar/commands/up.rb

@@ -0,0 +1,124 @@
+class SugarJar
+  class Commands
+    def up(branch = nil)
+      assert_in_repo!
+      branch ||= current_branch
+      branch = fprefix(branch)
+      # get a copy of our current branch, if rebase fails, we won't
+      # be able to determine it without backing out
+      curr = current_branch
+      git('checkout', branch)
+      result = rebase
+      if result['so'].error?
+        backout = ''
+        if rebase_in_progress?
+          backout = ' You can get out of this with a `git rebase --abort`.'
+        end
+
+        die(
+          "#{color(curr, :red)}: Failed to rebase on " +
+          "#{result['base']}. Leaving the repo as-is.#{backout} " +
+          'Output from failed rebase is: ' +
+          "\nSTDOUT:\n#{result['so'].stdout.lines.map { |x| "\t#{x}" }.join}" +
+          "\nSTDERR:\n#{result['so'].stderr.lines.map { |x| "\t#{x}" }.join}",
+        )
+      else
+        SugarJar::Log.info(
+          "#{color(current_branch, :green)} rebased on #{result['base']}",
+        )
+        # go back to where we were if we rebased a different branch
+        git('checkout', curr) if branch != curr
+      end
+    end
+
+    def upall
+      assert_in_repo!
+      all_local_branches.each do |branch|
+        next if MAIN_BRANCHES.include?(branch)
+
+        git('checkout', branch)
+        result = rebase
+        if result['so'].error?
+          SugarJar::Log.error(
+            "#{color(branch, :red)} failed rebase. Reverting attempt and " +
+            'moving to next branch. Try `sj up` manually on that branch.',
+          )
+          git('rebase', '--abort') if rebase_in_progress?
+        else
+          SugarJar::Log.info(
+            "#{color(branch, :green)} rebased on " +
+            color(result['base'], :green).to_s,
+          )
+        end
+      end
+    end
+
+    def sync
+      assert_in_repo!
+      dirty_check!
+
+      src = "origin/#{current_branch}"
+      fetch('origin')
+      s = git_nofail('merge-base', '--is-ancestor', 'HEAD', src)
+      if s.error?
+        SugarJar::Log.debug(
+          "Choosing rebase sync since this isn't a direct ancestor",
+        )
+        rebase(src)
+      else
+        SugarJar::Log.debug('Choosing reset sync since this is an ancestor')
+        git('reset', '--hard', src)
+      end
+      SugarJar::Log.info("Synced to #{src}.")
+    end
+
+    private
+
+    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)
+      # rubocop:enable Style/HashSyntax
+      unless base
+        SugarJar::Log.info(
+          'The brach we were tracking is gone, resetting tracking to ' +
+          most_main,
+        )
+        git('branch', '-u', most_main)
+        base = most_main
+      end
+      # 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}" &&
+         !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 ' +
+          '(where you pull _from_). This means that "sj up" is probably ' +
+          'rebasing on the wrong thing and doing nothing. You probably want ' +
+          "to do a 'git branch -u #{most_main}'.",
+        )
+      end
+      SugarJar::Log.debug('Rebasing')
+      s = git_nofail('rebase', base)
+      {
+        'so' => s,
+        'base' => base,
+      }
+    end
+
+    def rebase_in_progress?
+      # for rebase without -i
+      rebase_file = git('rev-parse', '--git-path', 'rebase-apply').stdout.strip
+      # for rebase -i
+      rebase_merge_file = git('rev-parse', '--git-path', 'rebase-merge').
+                          stdout.strip
+      File.exist?(rebase_file) || File.exist?(rebase_merge_file)
+    end
+  end
+end

data/lib/sugarjar/commands.rb

@@ -1,9 +1,5 @@
 require 'mixlib/shellout'
 
-require_relative 'util'
-require_relative 'repoconfig'
-require_relative 'log'
-require_relative 'version'
 require_relative 'commands/amend'
 require_relative 'commands/bclean'
 require_relative 'commands/branch'
@@ -15,6 +11,10 @@ require_relative 'commands/push'
 require_relative 'commands/smartclone'
 require_relative 'commands/smartpullrequest'
 require_relative 'commands/up'
+require_relative 'log'
+require_relative 'repoconfig'
+require_relative 'util'
+require_relative 'version'
 
 class SugarJar
   # This is the workhorse of SugarJar. Short of #initialize, all other public
@@ -49,6 +49,336 @@ class SugarJar
       set_commit_template if @repo_config['commit_template']
     end
 
-    include SugarJar::Util
+    private
+
+    def forked_repo(repo, username)
+      repo = if repo.start_with?('http', 'git@')
+               File.basename(repo)
+             else
+               "#{File.basename(repo)}.git"
+             end
+      "git@#{@ghhost || 'github.com'}:#{username}/#{repo}"
+    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@')
+
+      # otherwise, ti's a shortname
+      cr = "git@#{@ghhost || 'github.com'}:#{repo}.git"
+      SugarJar::Log.debug("canonicalized #{repo} to #{cr}")
+      cr
+    end
+
+    def set_commit_template
+      unless SugarJar::Util.in_repo?
+        SugarJar::Log.debug('Skipping set_commit_template: not in repo')
+        return
+      end
+
+      realpath = if @repo_config['commit_template'].start_with?('/')
+                   @repo_config['commit_template']
+                 else
+                   "#{Util.repo_root}/#{@repo_config['commit_template']}"
+                 end
+      unless File.exist?(realpath)
+        die(
+          "Repo config specifies #{@repo_config['commit_template']} as the " +
+          'commit template, but that file does not exist.',
+        )
+      end
+
+      s = git_nofail('config', '--local', 'commit.template')
+      unless s.error?
+        current = s.stdout.strip
+        if current == @repo_config['commit_template']
+          SugarJar::Log.debug('Commit template already set correctly')
+          return
+        else
+          SugarJar::Log.warn(
+            "Updating repo-specific commit template from #{current} " +
+            "to #{@repo_config['commit_template']}",
+          )
+        end
+      end
+
+      SugarJar::Log.debug(
+        'Setting repo-specific commit template to ' +
+        "#{@repo_config['commit_template']} per sugarjar repo config.",
+      )
+      git(
+        'config', '--local', 'commit.template', @repo_config['commit_template']
+      )
+    end
+
+    def assert_in_repo!
+      return if SugarJar::Util.in_repo?
+
+      die('sugarjar must be run from inside a git repo')
+    end
+
+    def dirty_check!
+      return unless 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 refusing to continue. Please commit ' +
+          'or amend first (or use --ignore-dirty to override).',
+        )
+        exit(1)
+      end
+    end
+
+    def determine_main_branch(branches)
+      branches.include?('main') ? 'main' : 'master'
+    end
+
+    def main_branch
+      @main_branch = determine_main_branch(all_local_branches)
+    end
+
+    def main_remote_branch(remote)
+      @main_remote_branches[remote] ||=
+        determine_main_branch(all_remote_branches(remote))
+    end
+
+    def checkout_main_branch
+      git('checkout', main_branch)
+    end
+
+    def all_remote_branches(remote = 'origin')
+      branches = []
+      git('branch', '-r', '--format', '%(refname)').stdout.lines.each do |line|
+        next unless line.start_with?("refs/remotes/#{remote}/")
+
+        branches << branch_from_ref(line.strip, :remote)
+      end
+      branches
+    end
+
+    def all_local_branches
+      git(
+        'branch', '--format', '%(refname)'
+      ).stdout.lines.map do |line|
+        if line.start_with?('(')
+          SugarJar::Log.debug("Skipping meta-branch: #{line.strip}")
+          next
+        end
+        branch_from_ref(line.strip)
+      end
+    end
+
+    def all_remotes
+      git('remote').stdout.lines.map(&:strip)
+    end
+
+    def remote_url_map
+      m = {}
+      git('remote', '-v').stdout.each_line do |line|
+        name, url, = line.split
+        m[name] = url
+      end
+      m
+    end
+
+    def current_branch
+      branch_from_ref(git('symbolic-ref', 'HEAD').stdout.strip)
+    end
+
+    def fetch_upstream
+      us = upstream
+      fetch(us) if us
+    end
+
+    def fetch(remote)
+      git('fetch', remote)
+    end
+
+    # determine if this branch is based on another local branch (i.e. is a
+    # subfeature). Used to figure out of we should stack the PR
+    def subfeature?(base)
+      all_local_branches.reject { |x| x == most_main }.include?(base)
+    end
+
+    def tracked_branch(branch = nil, fallback: true)
+      curr = current_branch
+      git('checkout', branch) if branch && branch != curr
+      s = git_nofail(
+        'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'
+      )
+      git('checkout', curr) if branch && branch != curr
+      if s.error?
+        branch = fallback ? most_main : nil
+        SugarJar::Log.debug("No specific tracked branch, using #{branch}")
+      else
+        branch = s.stdout.strip
+        SugarJar::Log.debug(
+          "Using explicit tracked branch: #{branch}, use " +
+          '`git branch -u` to change',
+        )
+      end
+      branch
+    end
+
+    def most_main
+      us = upstream
+      if us
+        "#{us}/#{main_branch}"
+      else
+        main_branch
+      end
+    end
+
+    def upstream
+      return @remote if @remote
+
+      remotes = all_remotes
+      SugarJar::Log.debug("remotes is #{remotes}")
+      if remotes.empty?
+        @remote = nil
+      elsif remotes.length == 1
+        @remote = remotes[0]
+      elsif remotes.include?('upstream')
+        @remote = 'upstream'
+      elsif remotes.include?('origin')
+        @remote = 'origin'
+      else
+        raise 'Could not determine "upstream" remote to use...'
+      end
+      @remote
+    end
+
+    def upstream_org
+      us = upstream
+      remotes = remote_url_map
+      extract_org(remotes[us])
+    end
+
+    # Whatever org we push to, regardless of if this is a fork or not
+    def push_org
+      url = git('remote', 'get-url', 'origin').stdout.strip
+      extract_org(url)
+    end
+
+    def color(string, *colors)
+      if @color
+        pastel.decorate(string, *colors)
+      else
+        string
+      end
+    end
+
+    def pastel
+      @pastel ||= begin
+        require 'pastel'
+        Pastel.new
+      end
+    end
+
+    def gh_avail?
+      !!SugarJar::Util.which_nofail('gh')
+    end
+
+    def fprefix(name)
+      return name unless @feature_prefix
+
+      return name if name.start_with?(@feature_prefix)
+      return name if all_local_branches.include?(name)
+
+      newname = "#{@feature_prefix}#{name}"
+      SugarJar::Log.debug(
+        "Munging feature name: #{name} -> #{newname} due to feature prefix",
+      )
+      newname
+    end
+
+    def dirty?
+      s = git_nofail('diff', '--quiet')
+      s.error?
+    end
+
+    def repo_name
+      SugarJar::Util.repo_root.split('/').last
+    end
+
+    def extract_org(repo)
+      if repo.start_with?('http')
+        File.basename(File.dirname(repo))
+      elsif repo.start_with?('git@')
+        repo.split(':')[1].split('/')[0]
+      else
+        # assume they passed in a ghcli-friendly name
+        repo.split('/').first
+      end
+    end
+
+    def extract_repo(repo)
+      File.basename(repo, '.git')
+    end
+
+    def die(msg)
+      SugarJar::Log.fatal(msg)
+      exit(1)
+    end
+
+    def worktree_branches
+      worktrees.values.map do |wt|
+        branch_from_ref(wt['branch'])
+      end
+    end
+
+    def worktrees
+      root = SugarJar::Util.repo_root
+      s = git('worktree', 'list', '--porcelain')
+      s.error!
+      worktrees = {}
+      # each entry is separated by a double newline
+      s.stdout.split("\n\n").each do |entry|
+        # then each key/val is split by a new line with the key and
+        # the value themselves split by a whitespace
+        tree = entry.split("\n").to_h(&:split)
+        # Skip the one
+        next if tree['worktree'] == root
+
+        worktrees[tree['worktree']] = tree
+      end
+      worktrees
+    end
+
+    def branch_from_ref(ref, type = :local)
+      # local branches are refs/head/XXXX
+      # remote branches are refs/remotes/<remote>/XXXX
+      base = type == :local ? 2 : 3
+      ref.split('/')[base..].join('/')
+    end
+
+    def remote_from_ref(ref)
+      return nil unless ref.start_with?('refs/remotes/')
+
+      ref.split('/')[2]
+    end
+
+    def git(*)
+      SugarJar::Util.git(*, :color => @color)
+    end
+
+    def git_nofail(*)
+      SugarJar::Util.git_nofail(*, :color => @color)
+    end
+
+    def ghcli(*)
+      SugarJar::Util.ghcli(*)
+    end
+
+    def ghcli_nofail(*)
+      SugarJar::Util.ghcli_nofail(*)
+    end
   end
 end

data/lib/sugarjar/repoconfig.rb

@@ -7,12 +7,10 @@ class SugarJar
   # This parses SugarJar repoconfigs (not to be confused with configs).
   # This is lint/unit/on_push configs.
   class RepoConfig
-    extend SugarJar::Util
-
     CONFIG_NAME = '.sugarjar.yaml'.freeze
 
     def self.repo_config_path(config)
-      ::File.join(repo_root, config)
+      ::File.join(SugarJar::Util.repo_root, config)
     end
 
     def self.hash_from_file(config_file)
@@ -27,7 +25,7 @@ class SugarJar
 
     def self.config(config = CONFIG_NAME)
       data = {}
-      unless in_repo
+      unless SugarJar::Util.in_repo?
         SugarJar::Log.debug('Not in repo, skipping repoconfig load')
         return data
       end