sugarjar 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc16295007c8698083a182a521c68481b3cb421644def0115aa04286867dd1eb
-  data.tar.gz: c901d92e5d7d5287472f52cf56a83d29a5b1b4b0248232278b36e1706bc7117d
+  metadata.gz: c689945af0d2bfb7b38477d19da9f58503a15b7be931ab021c4a121a07e6198c
+  data.tar.gz: e5fb66f22db68dce1ef31199ea688ff768d753b5df65bc8479744c010d4072c3
 SHA512:
-  metadata.gz: 6d64d758a56feac59e5617544cdde17341c804a8831524c49222f6397e47e886ed16f42280d60584a5231d279410839bdacebda66827ae77bb115addb24f3b6d
-  data.tar.gz: e65b75d83d852906c713f00d6424a76897177f39eb1f2eaa0b5d17896b6d2fb288de3d1cf0946f5587f5674819a074782279ecdb26094c8038d221fcd7ceab0f
+  metadata.gz: 9979e5aa13fd2a176cc5a391b9aef8353c1ddb7e63392ab6291f1781c3a99c39f9e4415a3c8cf02720ed2e0c6683a470978ba4ded3be9f2bb993120980a34863
+  data.tar.gz: 81ba9f2079a9cc6a88e9052092795c722f9a48bd6f9d763ddc33dddd48fbde65049a16dca2ca66ad39d2a33f179d175a712d22517e6e8103a5089a8d26d9592d

data/README.md

@@ -123,34 +123,142 @@ to `git clone` under the hood.
 ## Work with stacked branches more easily
 
 It's important to break changes into reviewable chunks, but working with
-stacked branches can be confusing. Enter `binfo` - it gives you a view of your
-current branch all the way up to master. In this example imagine we have a
-branch structure like:
+stacked branches can be confusing. SugarJar provides several tools to make this
+easier.
 
-```text
-                      +- test2.1
-                     /
-master --- test --- test2 --- test3
+First, and foremost, is `feature` and `subfeature`. Regardless of stacking, the
+way to create a new feature bracnh with sugarjar is with `sj feature` (or `sj
+f` for short):
+
+```shell
+$ sj feature mynewthing
+Created feature branch mynewthing based on origin/main
 ```
 
-This is what `binfo` on test3 looks like:
+A "feature" in SugarJar parliance just means that the branch is always created
+from "most_main" - this is usually "upstream/main", but SJ will figure out
+which remote is the "upstream", even if it's "origin", and then will determine
+the primary branch ("main" or for older repos "master"). It's also smart enough
+to fetch that remote first to make sure you're working on the latest HEAD.
+
+When you want to create a stacked PR, you can create "subfeature", which, at
+its core is just a branch created from the current branch:
 
 ```shell
-$ sj binfo
-* e451865 (HEAD -> test3) test3
-* e545b41 (test2) test2
-* c808eae (test1) test1
-o 44cf9e2 (origin/master, origin/HEAD, master) Lint/gemspec cleanups
+$ sj subfeature dependentnewthing
+Created feature branch dependentnewthing based on mynewthing
 ```
 
-while `binfo` on test2.1 looks like:
+If you create branches like this then sugarjar can now make several things
+much easier:
 
-```shell
-$ sj binfo
-* 36d0136 (HEAD -> test2.1) test2.1
-* e545b41 (test2) test2
-* c808eae (test1) test1
-o 44cf9e2 (origin/master, origin/HEAD, master) Lint/gemspec cleanups
+* `sj up` will rebase intelligently
+* After an `sj bclean` of a branch earlier in the tree, `sj up` will update
+  the tracked branch to "most_main"
+
+There are two commands that will show you the state of your stacked branches:
+
+* `sj binfo` - shows the current branch and its ancestors up to your primary branch
+* `sj smartlist` (aka `sj sl`) - shows you the whole tree.
+
+To continue with the example above, my `smartlist` might look like:
+
+```text
+$ sj sl
+* 59c0522 (HEAD -> dependentnewthing) anothertest
+* 6ebaa28 (mynewthing) test
+o 7a0ffd0 (tag: v1.1.2, origin/main, origin/HEAD, main) Version bump (#160)
+```
+
+This is simple. Now lets make a different feature stack:
+
+```text
+$ sj feature anotherfeature
+Created feature branch anotherfeature based on origin/main
+# do stuff
+$ sj subfeature dependent2
+Created feature branch dependent2 based on anotherfeature
+# do stuff
+```
+
+The `smartlist` will now show us this tree, and it's a bit more interesting:
+
+```text
+$ sj sl
+* af6f143 (HEAD -> dependent2) morestuff
+* 028c7f4 (anotherfeature) stuff
+| * 59c0522 (dependentnewthing) anothertest
+| * 6ebaa28 (mynewthing) test
+|/
+o 7a0ffd0 (tag: v1.1.2, origin/main, origin/HEAD, main) Version bump (#160)
+```
+
+Now, what happens if I make a change to `mynewthing`?
+
+```text
+$ sj co mynewthing
+Switched to branch 'mynewthing'
+Your branch is ahead of 'origin/main' by 1 commit.
+  (use "git push" to publish your local commits)
+$ echo 'randomchange' >> README.md
+$ git commit -a -m change
+[mynewthing d33e082] change
+ 1 file changed, 1 insertion(+)
+$ sj sl
+* d33e082 (HEAD -> mynewthing) change
+| * af6f143 (dependent2) morestuff
+| * 028c7f4 (anotherfeature) stuff
+| | * 59c0522 (dependentnewthing) anothertest
+| |/
+|/|
+* | 6ebaa28 test
+|/
+o 7a0ffd0 (tag: v1.1.2, origin/main, origin/HEAD, main) Version bump (#160)
+```
+
+We can see here now that `dependentnewthing`, is based off a commit that _used_
+to be `mynewthing`, but `mynewthing` has moved. But SugarJar will handle this
+all correctly when we ask it to update the branch:
+
+```text
+$ sj co dependentnewthing
+Switched to branch 'dependentnewthing'
+Your branch and 'mynewthing' have diverged,
+and have 1 and 1 different commits each, respectively.
+  (use "git pull" if you want to integrate the remote branch with yours)
+$ sj up
+dependentnewthing rebased on mynewthing
+$ sj sl
+* 93ed585 (HEAD -> dependentnewthing) anothertest
+* d33e082 (mynewthing) change
+* 6ebaa28 test
+| * af6f143 (dependent2) morestuff
+| * 028c7f4 (anotherfeature) stuff
+|/
+o 7a0ffd0 (tag: v1.1.2, origin/main, origin/HEAD, main) Version bump (#160)
+```
+
+Now, lets say that `mynewthing` gets merged and we use `bclean` to clean it all
+up, what happens then?
+
+```text
+$ sj up
+The brach we were tracking is gone, resetting tracking to origin/main
+dependentnewthing rebased on origin/main
+```
+
+### Creating Stacked PRs with subfeatures
+
+When dependent branches are created with `subfeature`, when you create a PR,
+SugarJar will automatically set the 'base' of the PR to the parent branch. By
+default it'll prompt you about this, but you can set `pr_autostack` to `true`
+in your config to tell it to always do this (or `false` to never do this):
+
+```text
+$ sj spr
+Autofilling in PR from commit message
+It looks like this is a subfeature, would you like to base this PR on mynewthing? [y/n] y
+...
 ```
 
 ## Have a better lint/unittest experience!

data/bin/sj

@@ -91,6 +91,24 @@ parser = OptionParser.new do |opts|
     options['log_level'] = level
   end
 
+  opts.on(
+    '--[no-]pr-autofill',
+    'When creating a PR, auto fill the title & description from the top ' +
+    'commit if we are using "gh". [default: true]',
+  ) do |autofill|
+    options['pr_autofill'] = autofill
+  end
+
+  opts.on(
+    '--[no-]pr-autostack',
+    'When creating a PR, if this is a subfeature, should we make it a ' +
+    'PR on the PR for the parent feature. If not specified, we prompt ' +
+    'when this happens, when true always do this, when false never do ' +
+    'this. Only applicable when usiing "gh" and on branch-based PRs.',
+  ) do |autostack|
+    options['pr_autostack'] = autostack
+  end
+
   opts.on('--[no-]use-color', 'Enable color. [default: true]') do |color|
     options['color'] = color
   end
@@ -112,10 +130,10 @@ COMMANDS:
               Same as "amend" but without changing the message. Alias for
               "git commit --amend --no-edit".
 
-  bclean
-              If safe, delete the current branch. Unlike "git branch -d",
-              bclean can handle squash-merged branches. Think of it as
-              a smarter "git branch -d".
+  bclean [<branch>]
+              If safe, delete the current branch (or the specified branch).
+              Unlike "git branch -d", bclean can handle squash-merged branches.
+              Think of it as a smarter "git branch -d".
 
   bcleanall
               Walk all branches, and try to delete them if it's safe. See
@@ -127,7 +145,7 @@ COMMANDS:
   br
               Verbose branch list. An alias for "git branch -v".
 
-  feature
+  feature, f <branch_name>
               Create a "feature" branch. It's morally equivalent to
               "git checkout -b" except it defaults to creating it based on
               some form of 'master' instead of your current branch. In order
@@ -177,11 +195,17 @@ COMMANDS:
               A smart wrapper to "git push" that runs whatever is defined in
               "on_push" in .sugarjar.yml, and only pushes if they succeed.
 
+  subfeature, sf <feature>
+              An alias for 'sj feature <feature> <current_branch>'
+
   unit
               Run any unitests configured in .sugarjar.yaml.
 
-  up
-              Rebase the current branch on upstream/master or origin/master.
+  up [<branch>]
+              Rebase the current branch (or specified branch) intelligently.
+              In most causes this will check for a main (or master) branch on
+              upstream, then origin. If a branch explicitly tracks something
+              else, then that will be used, instead.
 
   upall
               Same as "up", but for all branches.

data/lib/sugarjar/commands.rb

@@ -23,6 +23,8 @@ class SugarJar
       @repo_config = SugarJar::RepoConfig.config
       SugarJar::Log.debug("Repoconfig: #{@repo_config}")
       @color = options['color']
+      @pr_autofill = options['pr_autofill']
+      @pr_autostack = options['pr_autostack']
       @feature_prefix = options['feature_prefix']
       @checks = {}
       @main_branch = nil
@@ -43,19 +45,31 @@ class SugarJar
       name = fprefix(name)
       die("#{name} already exists!") if all_local_branches.include?(name)
       base ||= most_main
-      base_pieces = base.split('/')
-      git('fetch', base_pieces[0]) if base_pieces.length > 1
+      # 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
 
     def bclean(name = nil)
       assert_in_repo
       name ||= current_branch
-      name = fprefix(name) unless all_local_branches.include?(name)
+      name = fprefix(name)
       if clean_branch(name)
         SugarJar::Log.info("#{name}: #{color('reaped', :green)}")
       else
@@ -100,7 +114,7 @@ class SugarJar
       # and then add any featureprefix, and if _that_ is a branch
       # name, replace the last arguement with that
       name = args.last
-      bname = fprefix(name) unless all_local_branches.include?(name)
+      bname = fprefix(name)
       if all_local_branches.include?(bname)
         SugarJar::Log.debug("Featurepefixing #{name} -> #{bname}")
         args[-1] = bname
@@ -133,11 +147,14 @@ class SugarJar
 
     alias sl smartlog
 
-    def up
+    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 = gitup
       if result['so'].error?
         backout = ''
@@ -156,6 +173,8 @@ class SugarJar
         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
 
@@ -302,6 +321,7 @@ class SugarJar
     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. ' +
@@ -309,9 +329,47 @@ class SugarJar
         )
         exit(1)
       end
+
       if gh?
+        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
+        if subfeature?(base)
+          if upstream != 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
+        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(' ')}")
-        system(which('gh'), 'pr', 'create', '--fill', *args)
+        system(which('gh'), 'pr', 'create', *args)
       else
         SugarJar::Log.trace("Running: hub pull-request #{args.join(' ')}")
         system(which('hub'), 'pull-request', *args)
@@ -341,7 +399,7 @@ class SugarJar
 
       src = "origin/#{current_branch}"
       fetch('origin')
-      diff = git('diff', src).stdout
+      diff = git('diff', "..#{src}").stdout
       return unless diff && !diff.empty?
 
       puts "Will merge the following suggestions:\n\n#{diff}"
@@ -369,6 +427,9 @@ class SugarJar
     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",
@@ -430,6 +491,10 @@ class SugarJar
       end
     end
 
+    def extract_repo(repo)
+      File.basename(repo, '.git')
+    end
+
     def forked_repo(repo, username)
       repo = if repo.start_with?('http', 'git@')
                File.basename(repo)
@@ -712,11 +777,15 @@ class SugarJar
     end
 
     def all_local_branches
-      branches = []
-      git('branch', '--format', '%(refname)').stdout.lines.each do |line|
-        branches << branch_from_ref(line.strip)
+      git(
+        'branch', '--format', '%(refname)'
+      ).stdout.lines.map do |line|
+        branch_from_ref(line.strip)
       end
-      branches
+    end
+
+    def all_remotes
+      git('remote').stdout.lines.map(&:strip)
     end
 
     def safe_to_clean(branch)
@@ -794,14 +863,28 @@ class SugarJar
       SugarJar::Log.debug('Fetching upstream')
       fetch_upstream
       curr = current_branch
-      base = tracked_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 upstream".',
+          "to do a 'git branch -u #{most_main}'.",
         )
       end
       SugarJar::Log.debug('Rebasing')
@@ -812,6 +895,12 @@ class SugarJar
       }
     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 rebase_in_progress?
       # for rebase without -i
       rebase_file = git('rev-parse', '--git-path', 'rebase-apply').stdout.strip
@@ -821,15 +910,22 @@ class SugarJar
       File.exist?(rebase_file) || File.exist?(rebase_merge_file)
     end
 
-    def tracked_branch
+    def tracked_branch(fallback: true)
+      branch = nil
       s = git_nofail(
         'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'
       )
       if s.error?
-        most_main
+        branch = fallback ? most_main : nil
+        SugarJar::Log.debug("No specific tracked branch, using #{branch}")
       else
-        s.stdout.strip
+        branch = s.stdout.strip
+        SugarJar::Log.debug(
+          "Using explicit tracked branch: #{branch}, use " +
+          '`git branch -u` to change',
+        )
       end
+      branch
     end
 
     def most_main
@@ -844,9 +940,7 @@ class SugarJar
     def upstream
       return @remote if @remote
 
-      s = git('remote')
-
-      remotes = s.stdout.lines.map(&:strip)
+      remotes = all_remotes
       SugarJar::Log.debug("remotes is #{remotes}")
       if remotes.empty?
         @remote = nil
@@ -862,6 +956,12 @@ class SugarJar
       @remote
     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 branch_from_ref(ref, type = :local)
       # local branches are refs/head/XXXX
       # remote branches are refs/remotes/<remote>/XXXX

data/lib/sugarjar/config.rb

@@ -9,6 +9,8 @@ class SugarJar
       'github_cli' => 'auto',
       'github_user' => ENV.fetch('USER'),
       'fallthru' => true,
+      'pr_autofill' => true,
+      'pr_autostack' => nil,
     }.freeze
 
     def self._find_ordered_files

data/lib/sugarjar/version.rb

@@ -1,3 +1,3 @@
 class SugarJar
-  VERSION = '1.1.1'.freeze
+  VERSION = '1.1.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sugarjar
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Phil Dibowitz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-13 00:00:00.000000000 Z
+date: 2025-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge