sugarjar 1.1.3 → 2.0.1

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,48 @@
+require_relative '../util'
+
+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
+
+      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,66 @@
+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
+
+      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
+
+      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
+
+    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
+  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

data/lib/sugarjar/commands/smartpullrequest.rb

@@ -0,0 +1,101 @@
+require_relative '../util'
+
+class SugarJar
+  class Commands
+    def smartpullrequest(*args)
+      assert_in_repo!
+      assert_common_main_branch!
+
+      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,103 @@
+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
+
+    private
+
+    def rebase
+      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}"
+        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