sugarjar 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f79105e6ffa39ec2c1cdabd741fef41249e031ebe17d0cd5d0fbf4c3691ef4d7
-  data.tar.gz: 4a8fbf1f68268e9e0ffcee9dcbbd74d3e906ce3bb28aa278424f5959d377593b
+  metadata.gz: d0f9fa156720c59e1fc95f289273950176cad61ab82a67018d836a0ee878d81e
+  data.tar.gz: 6bec27c224878e6faee0e5801dec631e39db36170b759b6bf335a045cdda75a0
 SHA512:
-  metadata.gz: 3b910f580bf32c0dc88ba7c5504c2e2e14954ae599b29d4e6206aee050cea16b10c881ed44e511c3c86be7b019fc28248f844214e0c8a3f0c236a0718211b7c3
-  data.tar.gz: 5b3d5b5bf7c12ca23dec569b7a5f9161494349412fd5eba4f1572dfd0f37cc2f6c2036a7b799b0cb5861c4b18aeb80960a059a5baa3de3bea48656a4115116b5
+  metadata.gz: e4a5e2900d551ce1bb4bc8f9899e37dff28d6faaa7c9a46e96c140febb3e8b240465499e491054525aed0c470e8892af2f8d3d546f8c19925c070d283df45478
+  data.tar.gz: 979dce6e20a27fb94a11432fa5a39912693539de948f0a6278eb6662f68a6f62846e2d94667506094588592e99d5aba7fe57843e41771a55b128699a09595dce

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # SugarJar Changelog
 
+## 2.0.2 (2026-01-08)
+
+* Fix `branchclean` logic to properly compare with the target branch
+  (might have refused to clean branches that could be cleaned)
+* Add new commands to handle remote branch cleanup as well as rename
+  `bclean` (keeping backwards compatible aliases):
+   * `localbranchclean` / `lbclean` - local branch clean. aliased as
+     `bclean` for back-comat
+   * `localbranchcleanall` / `lbcleanall` - local all branch clean aliased
+     as `bcleanall` for back-compat
+   * `remotebranchclean` / `rbclean` - remote branch clean
+   * `remotebranchcleanall` / `rbcleanall` - remote all branch clean
+   * `globalbranchclean` / `gbclean` - local+remote branch clean
+   * `globalbranchcleanall` / `gbcleanall` - local+remote all branch clean
+* Added new `sync` command to aid syncing branches across multiple workstations,
+  see help for details.
+* Fix meta-ref handling which fixes crashes when using `smartlog` during rebases
+* Handle worktress gracefully when doing branch cleans
+* Make unittests work properly outside of git repos
+
 ## 2.0.1 (2025-05-12)
 
 * Fix gemspec to include new library files

data/README.md

@@ -30,6 +30,7 @@ Jump to what you're most interested in:
    * [Cleaning up your own history](#cleaning-up-your-own-history)
    * [Better feature branches](#better-feature-branches)
    * [Smartlog](#smartlog)
+   * [Sync work across workstations](#sync-work-across-workstations)
    * [Pulling in suggestions from the web](#pulling-in-suggestions-from-the-web)
    * [And more!](#and-more)
 * [Installation](#installation)
@@ -50,8 +51,10 @@ doesn't work. Git will tell you the branch isn't fully merged. You can, of
 course `git branch -D <branch>`, but that does no safety checks at all, it
 forces the deletion.
 
-Enter `sj bclean` - it determines if the contents of your branch has been merge
-and safely deletes if so.
+Enter `sj lbclean` - it determines if the contents of your branch has been merge
+and safely deletes if so. (Note: `lbclean` stands for "local branch clean", and
+is aliased to `bclean` for both backwards-compatibility and also since it's the
+most common branch-cleanup command).
 
 ![bclean screenshot](https://github.com/jaymzh/sugarjar/blob/main/images/bclean.png)
 
@@ -65,6 +68,17 @@ been merged:
 
 ![bcleanall screenshot](https://github.com/jaymzh/sugarjar/blob/main/images/bcleanall.png)
 
+There is also `sj rbclean` ("remote branch clean") (and `sj rbcleanall`) for
+cleanup of remote branches. *Note*: This cannot differentiate between
+PR/feature branches which have been merged and long-lived release branches that
+have been merged (e.g.  if '2.0-release' is a branch and has no commits not in
+main, it will be deleted).
+
+There is even `sj gbclean` ("global branch clean") (and `sj gbcleanall`) which will
+do both the local and remote cleaning.
+
+*NOTE*: Remote branch cleaning is still experimental, use with caution!
+
 ### Smarter clones and remotes
 
 There's a pattern to every new repo we want to contribute to. First we fork,
@@ -275,6 +289,21 @@ smartlog` or `sj sl` for short.
 
 ![smartlog screenshot](https://github.com/jaymzh/sugarjar/blob/main/images/smartlog.png)
 
+### Sync work across workstations
+
+If you work on multiple workstations, keeping your branches in-sync can be a
+pain. SugarJar provides `sync` to help with this.
+
+For example, if you do some work on feature `foo` on machine1 and push to
+`origin/foo` (intending to eventually merge to `upstream/main`), then on
+machine2, you pull that branch, do more work, which you also push to
+`origin/foo`, then on machine1, you can do `sj sync` to pull down the changes
+from `origin/foo`. If you have local changes, that are not already on
+`origin/foo`, those will be rebased on top of the changes from `origin/foo`.
+
+It's very similar to `sj up`, but instead of rebasing on top of the tracking
+branch, it rebases on top of the push target branch.
+
 ### Pulling in suggestions from the web
 
 When someone 'suggests' a change in the GitHub WebUI, once you choose to commit
@@ -314,7 +343,7 @@ directly from there.
 
 Sugarjar will read in both a system-level config file
 (`/etc/sugarjar/config.yaml`) and a user-level config file
-`~/.config/sugarjar/config.yaml`, if they exist. Anything in the user config
+(`~/.config/sugarjar/config.yaml`), if they exist. Anything in the user config
 will override the system config, and command-line options override both. The
 yaml file is a straight key-value pair of options without their '--'.
 
@@ -397,9 +426,9 @@ it on Windows, but I'll happily accept patches for Windows compatibility.
 
 **How do I get tab-completion?**
 
-If the package for your OS/distro didn't set it up manually, you should find
-that `sugarjar_completion.bash` is included in the package, and you can simply
-source that in your dotfiles, assuming you are using bash.
+If the package for your OS/distro didn't set it up automatically, you should
+find that `sugarjar_completion.bash` is included in the package, and you can
+simply source that in your dotfiles, assuming you are using bash.
 
 **What happens now that Sapling is released?**
 

data/bin/sj

@@ -118,15 +118,6 @@ COMMANDS:
               Same as "amend" but without changing the message. Alias for
               "git commit --amend --no-edit".
 
-  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
-              "bclean" for details.
-
   binfo
               Verbose information about the current branch.
 
@@ -157,14 +148,62 @@ COMMANDS:
               branches. Very convenient for keeping the branch behind a pull-
               request clean.
 
+  globalbranchclean, gbclean [<branch>] [<remote>]
+              WARNING: EXPERIMENTAL COMMAND.
+
+              Combination of "lbclean" and "rbclean". Cleans up
+              both local and remote branches safely. See those commands for
+              details.
+
+  globalbranchcleanall, gbcleanall [<remote>]
+              WARNING: EXPERIMENTAL COMMAND.
+
+              Safely clean all branches, both local and remote.  See "gbclean"
+              for details.
+
   lint
               Run any linters configured in .sugarjar.yaml.
 
+  localbranchclean, lbclean [<branch>]
+              If safe, delete the current branch (or the specified branch).
+              Unlike "git branch -d", lbclean can handle squash-merged branches.
+              Think of it as a smarter "git branch -d".
+
+              Aliased to 'bclean' for backwards compatibility.
+
+  localbranchcleanall, lbcleanall
+              Walk all branches, and try to delete them if it's safe. See
+              "lbclean" for details.
+
+              Aliased to 'bcleanall' for backwards compatibility.
+
   pullsuggestions, ps
               Pull any suggestions *that have been committed* in the GitHub UI.
               This will show the diff and prompt for confirmation before
               merging. Note that a fast-forward merge will be used.
 
+  remotebranchclean, rbclean [<branch>] [<remote>]
+              WARNING: EXPERIMENTAL COMMAND.
+
+              Similar to lbclean, except safely cleans up remote branches.
+              Unlike many git commands, <remote> comes after <branch> so
+              that you can specify a branch and the remote defaults to 'origin'.
+              This means you can do "sj rclean" to clean the remote branch with
+              the same name as the local one. Note that you probably want
+              "sclean", which will do both local and remote cleaning in one
+              command.
+
+              WARNING: This command cannot differentiate release branches
+              that are fully merged but still need to be kept around for future
+              work. So if main contains everything that 2.0-devel and 3.0-devel
+              has, then those branches will be deleted. Use with caution.
+
+  remotebranchcleanall, rbcleanall [<remote>]
+              WARNING: EXPERIMENTAL COMMAND.
+
+              Walk all remote branches, and try to delete them if it's safe. See
+              "rbclean" for details.
+
   smartclone, sclone
               A smart wrapper to "git clone" that handles forking and managing
               remotes for you.
@@ -190,6 +229,20 @@ COMMANDS:
   subfeature, sf <feature>
               An alias for 'sj feature <feature> <current_branch>'
 
+  sync
+              Similar to `up`, except instead of rebasing on a tracked branch
+              (usually `upstream` remote), rebases to wherever our remote push
+              target is (usually `origin` remote). Useful for syncing work
+              across different machines.
+
+              For example, if you do some work on feature `foo` on machine1 and
+              push to `origin/foo` (intending to eventually merge to
+              `upstream/main`), then on machine2, you pull that branch, do more
+              work, which you also push to `origin/foo`, then on machine1, you
+              can do `sj sync` to pull down the changes from `origin/foo`. If
+              you have local changes, that are not already on `origin/foo`,
+              those will be rebased on top of the changes from `origin/foo`.
+
   unit
               Run any unitests configured in .sugarjar.yaml.
 

data/lib/sugarjar/commands/bclean.rb

@@ -1,9 +1,17 @@
 class SugarJar
   class Commands
-    def bclean(name = nil)
+    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
@@ -13,15 +21,58 @@ class SugarJar
         )
       end
     end
+    alias localbranchclean lbclean
+    # backcompat
+    alias bclean lbclean
 
-    def bcleanall
+    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)}")
@@ -41,28 +92,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 +190,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 +205,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,9 +219,14 @@ 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
   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(

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,6 +39,7 @@ 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}")
@@ -62,5 +50,6 @@ class SugarJar
       end
       true
     end
+    # rubocop:enable Naming/PredicateMethod
   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. ' +

data/lib/sugarjar/commands/up.rb

@@ -53,15 +53,35 @@ class SugarJar
       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
+    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(
@@ -74,7 +94,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 ' +

data/lib/sugarjar/commands.rb

@@ -119,6 +119,23 @@ class SugarJar
       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
@@ -150,8 +167,10 @@ class SugarJar
       git(
         'branch', '--format', '%(refname)'
       ).stdout.lines.map do |line|
-        next if line.start_with?('(HEAD detached')
-
+        if line.start_with?('(')
+          SugarJar::Log.debug("Skipping meta-branch: #{line.strip}")
+          next
+        end
         branch_from_ref(line.strip)
       end
     end
@@ -188,11 +207,13 @@ class SugarJar
       all_local_branches.reject { |x| x == most_main }.include?(base)
     end
 
-    def tracked_branch(fallback: true)
-      branch = nil
+    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}")
@@ -307,6 +328,30 @@ class SugarJar
       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
@@ -314,6 +359,12 @@ class SugarJar
       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

data/lib/sugarjar/version.rb

@@ -1,3 +1,3 @@
 class SugarJar
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.0.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sugarjar
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Phil Dibowitz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-12 00:00:00.000000000 Z
+date: 2026-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge