gitflash 0.5.1 → 0.7.0.beta1

data/lib/gitflash/commands/pick_outcome.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # How `pick` and its --continue / --skip / --abort report a git cherry-pick run: done, or
+    # stopped on conflicts (status `failed`, error code `conflict`) with what is left to do.
+    module PickOutcome
+      private
+
+      def cherry_pick
+        @cherry_pick ||= CherryPick.new
+      end
+
+      # `requested` are the commits the user asked for, in order; `snapshot` reverts the start
+      def outcome(plan, result, requested, snapshot)
+        return finished(plan, requested, snapshot) if result.success? && !cherry_pick.in_progress?
+        return conflict(plan, result, requested, snapshot) if cherry_pick.in_progress?
+
+        git_error!('cherry-pick', result)
+      end
+
+      def finished(plan, requested, snapshot)
+        head = repo.resolve_commit('HEAD')
+        text = "Applied #{requested.size} commit(s), now at #{head[0, 7]}"
+        ui.report(status: 'done', plan: plan, result: { applied: requested, head: head },
+                  undo: snapshot, text: text)
+      end
+
+      def conflict(plan, result, requested, snapshot)
+        progress = cherry_pick.progress
+        text = conflict_text(progress, result)
+        details = { applied: requested - progress.remaining - [progress.current],
+                    current: progress.current, conflicted: progress.conflicted,
+                    remaining: progress.remaining }
+        ui.report(status: 'failed', plan: plan, result: details, undo: snapshot, text: text,
+                  error: { code: 'conflict', exit_code: 1, message: text })
+      end
+
+      def conflict_text(progress, result)
+        files = progress.conflicted.map { |file| "* #{file}" }.join("\n")
+        "Stopped on conflicts in:\n#{files}\n#{result.output}\n" \
+          'Resolve them and stage the files, then run `gitflash pick --continue`; ' \
+          'or `gitflash pick --skip` / `gitflash pick --abort`.'
+      end
+
+      def current_branch_names
+        branch = repo.current_branch
+        branch ? [branch] : []
+      end
+    end
+  end
+end

data/lib/gitflash/commands/removal_report.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Reports the outcome of removing worktrees: one row per worktree with its own snapshot and
+    # undo command, failures with their reason. Used by `wt remove` and `wt clean`.
+    module RemovalReport
+      # What happened to one worktree; `snapshot` is nil when it was not removed
+      Removal = Data.define(:worktree, :result, :snapshot)
+
+      private
+
+      # Ignored files are never saved by snapshots, so `undo` cannot bring them back
+      def ignored_warning(plan)
+        rows = plan[:worktrees].select { |row| row[:ignored_count].positive? }
+        return '' if rows.empty?
+
+        lines = rows.map { |row| ignored_line(row) }
+        "\n\nIgnored files are not saved by snapshots and will be lost for good:\n" \
+          "#{lines.join("\n")}"
+      end
+
+      def ignored_line(row)
+        "* #{row[:path]}: #{row[:ignored_count]} (#{row[:ignored].join(', ')})"
+      end
+
+      def report_results(plan, outcomes)
+        removed, failed = outcomes.partition { |outcome| outcome.result.success? }
+        result = { removed: removed.map { |outcome| removed_row(outcome) },
+                   failed: failed.map { |outcome| failed_row(outcome) } }
+        ui.report(status: failed.empty? ? 'done' : 'failed', plan: plan, result: result,
+                  error: failure(failed, outcomes), text: results_text(result),
+                  undo: single_undo(removed))
+      end
+
+      # `undo` in the envelope only when one worktree was removed; each row has its own
+      def single_undo(removed)
+        removed.first.snapshot if removed.size == 1
+      end
+
+      def failed_row(outcome)
+        { path: outcome.worktree.path, error: outcome.result.output }
+      end
+
+      def removed_row(outcome)
+        worktree = outcome.worktree
+        { path: worktree.path, branch: worktree.branch, head: worktree.head,
+          snapshot: outcome.snapshot.id, undo: "gitflash undo #{outcome.snapshot.id}" }
+      end
+
+      def failure(failed, outcomes)
+        return nil if failed.empty?
+
+        { code: 'git_failed', exit_code: 1,
+          message: "#{failed.size} of #{outcomes.size} worktrees were not removed" }
+      end
+
+      def results_text(result)
+        lines = result[:removed].map { |row| "Removed #{row[:path]} (undo: #{row[:undo]})" }
+        lines += result[:failed].map { |row| "Not removed #{row[:path]}: #{row[:error]}" }
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/gitflash/commands/reset.rb

@@ -48,11 +48,17 @@ module Gitflash
 
       def execute(plan, text)
         previous = repo.resolve_commit('HEAD')
+        snapshot = snapshot_before(plan)
         result = repo.reset(plan[:commit], mode: plan[:mode])
         git_error!('reset', result) unless result.success?
 
         ui.report(status: 'done', plan: plan, result: plan.merge(previous_commit: previous),
-                  text: text.capitalize)
+                  undo: snapshot, text: text.capitalize)
+      end
+
+      def snapshot_before(plan)
+        take_snapshot("gitflash reset --#{plan[:mode]} #{plan[:commit][0, 7]}",
+                      scope: %w[branches head worktree], branches: [repo.current_branch].compact)
       end
 
       def confirmed?(plan)

data/lib/gitflash/commands/snapshot_create.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Saves the current state on request, for example before a risky step
+    class SnapshotCreate < Base
+      def call
+        snapshot = take_snapshot(options[:message] || 'gitflash snapshot', scope: scope)
+        ui.report(status: 'done', result: { snapshot: snapshot.to_h }, undo: snapshot,
+                  text: text(snapshot))
+      end
+
+      private
+
+      def scope
+        scope = options[:scope] || Snapshots::SCOPES
+        invalid = scope - Snapshots::SCOPES
+        usage_error!('invalid_options', "Unknown scope: #{invalid.join(', ')}") if invalid.any?
+        scope
+      end
+
+      def text(snapshot)
+        text = "Saved snapshot #{snapshot.id}"
+        return text if snapshot.skipped_files.empty?
+
+        "#{text}\nSkipped large untracked files: #{snapshot.skipped_files.join(', ')}"
+      end
+    end
+  end
+end

data/lib/gitflash/commands/snapshot_list.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Lists snapshots, newest first
+    class SnapshotList < Base
+      def call
+        list = snapshots.list
+        text = list.empty? ? 'No snapshots' : list.map { |snapshot| row(snapshot) }.join("\n")
+        ui.report(status: 'done', result: { snapshots: list.map(&:to_h) }, text: text)
+      end
+
+      private
+
+      def row(snapshot)
+        "#{snapshot.id}  #{snapshot.scope.join(',').ljust(28)}  #{snapshot.reason}"
+      end
+    end
+  end
+end

data/lib/gitflash/commands/undo.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Restores a snapshot (the latest one by default). The current state is saved first,
+    # so an undo can itself be undone.
+    class Undo < Base
+      def call(id = nil)
+        snapshot = find(id)
+        return no_snapshots unless snapshot
+
+        restore = build_restore(snapshot)
+        plan = restore.plan.merge(snapshot: snapshot.id)
+        return nothing_to_undo(plan) if restore.empty?
+
+        restore!(snapshot, restore, plan)
+      end
+
+      private
+
+      def find(id)
+        return snapshots.list.first if id.nil?
+
+        snapshots.find(id) || usage_error!('unknown_snapshot', "Unknown snapshot '#{id}'")
+      end
+
+      # A snapshot of a worktree that is gone is restored by adding the worktree again
+      def build_restore(snapshot)
+        return WorktreeRevival.new(snapshot, repo: repo) if removed_worktree?(snapshot)
+
+        check_worktree!(snapshot)
+        Restore.new(snapshot)
+      end
+
+      # The snapshot was taken in a worktree whose directory no longer exists
+      def removed_worktree?(snapshot)
+        (snapshot.scope?('head') || snapshot.scope?('worktree')) &&
+          snapshot.worktree_path != repo.toplevel && !File.exist?(snapshot.worktree_path)
+      end
+
+      # Branches are shared between worktrees; HEAD and files belong to one worktree
+      def check_worktree!(snapshot)
+        return unless snapshot.scope?('head') || snapshot.scope?('worktree')
+        return if snapshot.worktree_path == repo.toplevel
+
+        usage_error!('wrong_worktree', "Snapshot #{snapshot.id} was taken in " \
+                                       "#{snapshot.worktree_path}; run gitflash undo there")
+      end
+
+      def restore!(snapshot, restore, plan)
+        text = "snapshot #{snapshot.id}:\n#{describe(plan)}"
+        return planned(plan, "Would restore #{text}") if ui.dry_run?
+        return cancelled(plan) unless ui.confirm?(summary(snapshot, plan), plan: plan)
+
+        apply(snapshot, restore, plan)
+      end
+
+      def apply(snapshot, restore, plan)
+        before = snapshots.create(reason: "before undo #{snapshot.id}", scope: restore.scope,
+                                  branches: snapshot.branches.keys)
+        failure = restore.apply
+        raise_failure(failure, before, plan) if failure
+
+        report_done(snapshot, plan, before)
+      end
+
+      def report_done(snapshot, plan, before)
+        ui.report(status: 'done', plan: plan, result: { snapshot: snapshot.id }, undo: before,
+                  text: "Restored snapshot #{snapshot.id}:\n#{describe(plan)}")
+      end
+
+      def raise_failure(failure, before, plan)
+        message = "gitflash undo failed:\n#{failure.output}\n" \
+                  "The state before this undo is saved as snapshot #{before.id}." \
+                  "#{revival_hint(plan)}"
+        raise Error.new(message, code: 'git_failed', plan: plan)
+      end
+
+      # That snapshot cannot take the added worktree away again
+      def revival_hint(plan)
+        return '' unless plan[:recreate_worktree]
+
+        "\nThe worktree #{plan[:recreate_worktree]} was added again and may be partly restored; " \
+          "remove it with: gitflash wt remove #{plan[:recreate_worktree]} --force"
+      end
+
+      def no_snapshots
+        ui.report(status: 'noop', result: { snapshot: nil }, text: 'No snapshots to undo')
+      end
+
+      def nothing_to_undo(plan)
+        text = "Nothing to undo: the repository already matches snapshot #{plan[:snapshot]}"
+        ui.report(status: 'noop', plan: plan, result: { snapshot: plan[:snapshot] }, text: text)
+      end
+
+      def summary(snapshot, plan)
+        "You are about to restore snapshot #{snapshot.id} " \
+          "(#{snapshot.reason}, #{snapshot.created_at}):\n#{describe(plan)}"
+      end
+
+      def describe(plan)
+        lines = plan[:branches].map { |change| branch_line(change) }
+        lines << "* add worktree #{plan[:recreate_worktree]} again" if plan[:recreate_worktree]
+        lines << head_line(plan[:head]) if plan[:head] && !plan[:recreate_worktree]
+        (lines + file_lines(plan)).join("\n")
+      end
+
+      def file_lines(plan)
+        lines = []
+        lines << '* restore tracked, staged and untracked files' if plan[:worktree]
+        lines << "* restore #{plan[:stashes].size} stash entries" if plan[:stashes].any?
+        lines
+      end
+
+      def branch_line(change)
+        target = change[:to][0, 7]
+        return "* recreate #{change[:branch]} at #{target}" unless change[:from]
+
+        "* move #{change[:branch]} back to #{target}"
+      end
+
+      def head_line(head)
+        "* switch HEAD from #{short(head[:from])} to #{short(head[:to])}"
+      end
+
+      def short(ref)
+        ref.to_s.match?(/\A\h{40}\z/) ? ref[0, 7] : ref.to_s
+      end
+    end
+  end
+end

data/lib/gitflash/commands/worktree_add.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Adds a worktree for an existing, remote or new branch. Additive, so it needs no
+    # confirmation and no snapshot. A branch created here is marked as agent work.
+    class WorktreeAdd < Base
+      def call(branch = nil)
+        validate_name!(branch)
+        worktrees = Worktrees.new(repo: repo)
+        source = worktrees.source_for(branch)
+        check_options!(source)
+        check_free!(worktrees, branch, source)
+
+        plan = build_plan(branch, source)
+        if ui.dry_run?
+          return planned(plan,
+                         "Would add worktree #{plan[:path]} on #{branch} (#{source})")
+        end
+
+        add(worktrees, plan)
+      end
+
+      private
+
+      def validate_name!(branch)
+        usage_error!('invalid_usage', 'Pass the branch: gitflash wt add BRANCH') if branch.nil?
+        valid = !branch.start_with?('-') && ref_format_ok?(branch)
+        usage_error!('invalid_usage', "Invalid branch name '#{branch}'") unless valid
+      end
+
+      def ref_format_ok?(branch)
+        _stdout, _stderr, success = Git::BashCommand.capture('git', 'check-ref-format', '--branch',
+                                                             branch)
+        success
+      end
+
+      def check_options!(source)
+        return unless options[:from] && source != :new
+
+        usage_error!('invalid_options', '--from only applies to a new branch, but the branch ' \
+                                        "already exists (#{source})")
+      end
+
+      def check_free!(worktrees, branch, source)
+        return unless source == :existing
+
+        holder = worktrees.list.find { |worktree| worktree.branch == branch }
+        return unless holder
+
+        usage_error!('invalid_usage', "Branch #{branch} is already checked out at #{holder.path}")
+      end
+
+      def build_plan(branch, source)
+        path = target_path(branch)
+        if File.exist?(path) && !(File.directory?(path) && Dir.empty?(path))
+          usage_error!('invalid_usage', "#{path} already exists and is not an empty directory")
+        end
+
+        { branch: branch, path: path, source: source.to_s, from: options[:from],
+          owner: source == :existing ? nil : owner }
+      end
+
+      def target_path(branch)
+        return File.expand_path(options[:path]) if options[:path]
+
+        config.worktree_path(root: repo.main_root, branch: branch)
+      end
+
+      def owner
+        value = options[:owner] || 'agent'
+        return value if Ownership::OWNERS.include?(value)
+
+        usage_error!('invalid_options', "Unknown owner '#{value}' (use agent or human)")
+      end
+
+      def add(worktrees, plan)
+        source = plan[:source].to_sym
+        result = worktrees.add(plan[:path], branch: plan[:branch], source: source,
+                                            start: plan[:from])
+        git_error!('worktree add', result) unless result.success?
+
+        Ownership.new.mark(plan[:branch], plan[:owner]) if plan[:owner]
+        report(plan)
+      end
+
+      def report(plan)
+        ui.report(status: 'done', plan: plan, result: outcome(plan),
+                  text: "Added worktree #{plan[:path]} on #{plan[:branch]}")
+      end
+
+      def outcome(plan)
+        head = Git::BashCommand.exec('git', '-C', plan[:path], 'rev-parse', 'HEAD').strip
+        plan.slice(:branch, :path, :source, :owner).merge(head: head)
+      end
+    end
+  end
+end

data/lib/gitflash/commands/worktree_clean.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Removes the worktrees whose branch is no longer needed (same criteria as `clean`).
+    # Main, current, locked and dirty worktrees are skipped with the reason unless --force
+    # allows locked and dirty ones; the main checkout and the current worktree never go.
+    # Removal, snapshots and undo work as in `wt remove`. Branches are kept: run `gitflash clean`
+    # afterwards to delete them. Worktrees with a missing directory belong to `wt prune`.
+    class WorktreeClean < WorktreeRemove
+      include CleanCriteria
+
+      def call
+        chosen, @skipped = select
+        @reasons = chosen.to_h { |candidate| [candidate.item.path, candidate.reasons] }
+        return nothing_to_clean if chosen.empty?
+
+        remove(chosen.map(&:item))
+      end
+
+      private
+
+      def select
+        Cleanup.worktrees(worktrees.list, branches: repo.branches(merged_status: true),
+                                          rules: rules, protection: Protection.new(config: config),
+                                          blocker: ->(worktree) { blocker(worktree) })
+      end
+
+      def blocker(worktree)
+        worktree.removal_blocker(force: force?, current: current?(worktree))
+      end
+
+      def build_plan(chosen)
+        super.merge(skipped: @skipped)
+      end
+
+      def plan_row(worktree)
+        super.merge(reasons: @reasons[worktree.path])
+      end
+
+      def nothing_to_clean
+        plan = { worktrees: [], force: force?, skipped: @skipped }
+        text = (['Nothing to clean'] + @skipped.map { |row| "Kept #{row[:path]}: #{row[:reason]}" })
+        ui.report(status: 'noop', plan: plan, result: { removed: [], failed: [] },
+                  text: text.join("\n"))
+      end
+    end
+  end
+end

data/lib/gitflash/commands/worktree_command.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Shared lookup for the `worktree` commands that act on one worktree
+    class WorktreeCommand < Base
+      private
+
+      def worktrees
+        @worktrees ||= Worktrees.new(repo: repo)
+      end
+
+      # The worktree named by a path or a branch; raises `unknown_worktree` when none matches
+      def find!(target, list = worktrees.list)
+        path = File.expand_path(target)
+        list.find { |worktree| worktree.path == path || worktree.branch == target } ||
+          usage_error!('unknown_worktree', "Unknown worktree: #{target}")
+      end
+
+      def refuse_main!(worktree, action)
+        return unless worktree.main?
+
+        usage_error!('protected_worktree',
+                     "#{worktree.path} is the main checkout; cannot #{action}")
+      end
+    end
+  end
+end

data/lib/gitflash/commands/worktree_list.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Lists the worktrees of the repository
+    class WorktreeList < Base
+      def call
+        worktrees = Worktrees.new(repo: repo).list
+        ui.report(status: 'done', result: { worktrees: worktrees.map(&:to_h) },
+                  text: table(worktrees))
+      end
+
+      private
+
+      def table(worktrees)
+        width = worktrees.map { |worktree| worktree.path.length }.max
+        worktrees.map { |worktree| row(worktree, width) }.join("\n")
+      end
+
+      def row(worktree, width)
+        [worktree.path.ljust(width), worktree.branch || "(detached #{worktree.head.to_s[0, 7]})",
+         flags(worktree)].join('  ').rstrip
+      end
+
+      def flags(worktree)
+        labels = state_labels(worktree) + position_labels(worktree)
+        labels.select { |_label, shown| shown }.map(&:first).join(', ')
+      end
+
+      def state_labels(worktree)
+        [['main', worktree.main?], ['agent', worktree.owner == 'agent'],
+         ['dirty', worktree.dirty?], ['dirty state unknown', unknown_dirty?(worktree)],
+         ['locked', worktree.locked?], ['missing', worktree.missing?],
+         ['merged', worktree.merged && worktree.branch != repo.default_branch]]
+      end
+
+      # git status failed in a directory that exists; JSON keeps `dirty: null`
+      def unknown_dirty?(worktree)
+        worktree.dirty.nil? && !worktree.missing? && !worktree.bare
+      end
+
+      def position_labels(worktree)
+        [["ahead #{worktree.ahead}", worktree.ahead.to_i.positive?],
+         ["behind #{worktree.behind}", worktree.behind.to_i.positive?]]
+      end
+    end
+  end
+end

data/lib/gitflash/commands/worktree_lock.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Locks or unlocks a worktree, so `prune`, `remove` and `clean` leave it alone.
+    # Needs no confirmation: the change is reversed by the opposite command.
+    class WorktreeLock < WorktreeCommand
+      def call(target = nil)
+        unless target
+          usage_error!('invalid_usage',
+                       "Pass the worktree: gitflash wt #{verb} WORKTREE")
+        end
+        worktree = find!(target)
+        refuse_main!(worktree, verb)
+        return noop(worktree) if worktree.locked? == lock?
+        return planned(plan(worktree), "Would #{verb} #{worktree.path}") if ui.dry_run?
+
+        change(worktree)
+      end
+
+      private
+
+      def lock? = true
+
+      def verb = lock? ? 'lock' : 'unlock'
+
+      def plan(worktree)
+        { path: worktree.path, reason: (options[:reason] if lock?) }.compact
+      end
+
+      def change(worktree)
+        result = git_change(worktree)
+        git_error!("worktree #{verb}", result) unless result.success?
+
+        report('done', worktree, "#{verb.capitalize}ed #{worktree.path}")
+      end
+
+      def git_change(worktree)
+        return worktrees.unlock(worktree.path) unless lock?
+
+        worktrees.lock(worktree.path, reason: options[:reason])
+      end
+
+      def noop(worktree)
+        report('noop', worktree, "#{worktree.path} is #{lock? ? 'already locked' : 'not locked'}")
+      end
+
+      def report(status, worktree, text)
+        ui.report(status: status, plan: plan(worktree), text: text,
+                  result: plan(worktree).merge(locked: lock?))
+      end
+    end
+  end
+end

data/lib/gitflash/commands/worktree_move.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Moves a worktree to another directory. Refuses the main checkout, the current worktree
+    # (its directory would disappear under the caller) and locked worktrees unless --force.
+    # Needs no confirmation: moving it back reverses it.
+    class WorktreeMove < WorktreeCommand
+      def call(target = nil, destination = nil)
+        unless target && destination
+          usage_error!('invalid_usage',
+                       'Pass the worktree and its new path')
+        end
+        worktree = find!(target)
+        check!(worktree)
+        plan = { from: worktree.path, to: File.expand_path(destination), force: force? }
+        return planned(plan, "Would move #{plan[:from]} to #{plan[:to]}") if ui.dry_run?
+
+        move(plan)
+      end
+
+      private
+
+      def force?
+        options[:force] ? true : false
+      end
+
+      def check!(worktree)
+        refuse_main!(worktree, 'move')
+        if worktree.path == repo.toplevel
+          usage_error!('protected_worktree', "#{worktree.path} is the current worktree")
+        end
+        return unless worktree.locked? && !force?
+
+        usage_error!('protected_worktree', "#{worktree.path} is locked (use --force)")
+      end
+
+      def move(plan)
+        result = worktrees.move(plan[:from], plan[:to], force: plan[:force])
+        git_error!('worktree move', result) unless result.success?
+
+        ui.report(status: 'done', plan: plan, result: plan.slice(:from, :to),
+                  text: "Moved #{plan[:from]} to #{plan[:to]}")
+      end
+    end
+  end
+end