gitflash 0.3.0 → 0.5.0

data/lib/gitflash/commands/delete.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Deletes local branches given as arguments or picked from a menu.
+    # Uses `git branch -d` (merged branches only) unless --force is given.
+    # The result lists each deleted branch with its last commit, so it can be recreated.
+    class Delete < Base
+      PROTECTED_NAMES = %w[main master].freeze
+
+      def call(*names)
+        branches = repo.branches
+        candidates = branches.reject { |branch| protected?(branch) }.map(&:name)
+
+        names = pick(candidates) if names.empty?
+        return 0 if names.nil?
+
+        validate!(names.uniq, branches)
+        delete(names.uniq, branches.to_h { |branch| [branch.name, branch.sha] })
+      end
+
+      private
+
+      # Branches picked from the menu, or nil after telling the user there is nothing to delete
+      def pick(candidates)
+        require_interactive!('Pass the branches to delete: gitflash delete BRANCH...')
+        return report_nothing('No branches available to delete') if candidates.empty?
+
+        names = ui.multi_select('Select branches to delete', candidates)
+        names.empty? ? report_nothing('No branches selected') : names
+      end
+
+      def force?
+        options[:force] ? true : false
+      end
+
+      def protected?(branch)
+        branch.current? || branch.default? || PROTECTED_NAMES.include?(branch.name)
+      end
+
+      def validate!(names, branches)
+        by_name = branches.to_h { |branch| [branch.name, branch] }
+        unknown = names.reject { |name| by_name.key?(name) }
+        usage_error!('unknown_branch', "Unknown branch: #{unknown.join(', ')}") if unknown.any?
+
+        refused = names.select { |name| protected?(by_name[name]) }
+        return if refused.empty?
+
+        usage_error!('protected_branch',
+                     "Refusing to delete protected branches: #{refused.join(', ')} " \
+                     '(current, default, main and master are protected)')
+      end
+
+      def delete(names, shas)
+        plan = { branches: names, force: force? }
+        return planned(plan, "Would delete:\n#{bullets(names)}") if ui.dry_run?
+        return cancelled(plan) unless ui.confirm?(summary(names), plan: plan)
+
+        outcomes = names.map { |name| [name, repo.delete_branch(name, force: force?)] }
+        report_results(plan, outcomes, shas)
+      end
+
+      def summary(names)
+        mode = force? ? 'even if they have unmerged changes' : 'if they are fully merged'
+        "You are about to delete the following branches #{mode}:\n\n#{bullets(names)}"
+      end
+
+      def bullets(names)
+        names.map { |name| "* #{name}" }.join("\n")
+      end
+
+      def report_nothing(text)
+        ui.report(status: 'noop', result: { deleted: [], failed: [] }, text: text)
+        nil
+      end
+
+      def report_results(plan, outcomes, shas)
+        deleted, failed = outcomes.partition { |_name, result| result.success? }
+        result = {
+          deleted: deleted.map { |name, _result| { branch: name, sha: shas[name] } },
+          failed: failed.map { |name, result| { branch: name, error: result.output } }
+        }
+        ui.report(status: failed.empty? ? 'done' : 'failed', plan: plan, result: result,
+                  error: failure(failed, outcomes), text: results_text(result))
+      end
+
+      def failure(failed, outcomes)
+        return nil if failed.empty?
+
+        message = "#{failed.size} of #{outcomes.size} branches were not deleted"
+        { code: 'git_failed', message: message, exit_code: 1 }
+      end
+
+      def force_hint?(result)
+        result[:failed].any? && !force?
+      end
+
+      def results_text(result)
+        lines = result[:deleted].map { |row| "Deleted branch #{row[:branch]} (was #{row[:sha]})" }
+        lines += result[:failed].map { |row| "Not deleted #{row[:branch]}: #{row[:error]}" }
+        lines << 'Use --force to delete branches with unmerged changes.' if force_hint?(result)
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/gitflash/commands/reset.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Resets the current branch to a commit given as an argument or picked from a menu.
+    # Default mode is mixed; --soft and --hard are supported. Only --hard asks for confirmation.
+    # The result includes the previous HEAD, so the reset can be reverted.
+    class Reset < Base
+      HARD_RESET_WARNING = 'You are about to reset your branch and lose all your current changes'
+
+      def call(ref = nil)
+        mode = reset_mode
+
+        if ref.nil?
+          require_interactive!('Pass the commit to reset to: gitflash reset COMMIT')
+          commits = repo.commits
+          return report_single_commit if commits.size < 2
+
+          ref = ui.select('Select a commit to reset to', commits.to_h { |c| [c.label, c.sha] })
+        end
+
+        reset(ref, mode)
+      end
+
+      private
+
+      def reset_mode
+        if options[:soft] && options[:hard]
+          usage_error!('invalid_options', 'Use either --soft or --hard, not both')
+        end
+
+        return 'hard' if options[:hard]
+
+        options[:soft] ? 'soft' : 'mixed'
+      end
+
+      def reset(ref, mode)
+        commit = repo.resolve_commit(ref)
+        usage_error!('unknown_commit', "Unknown commit '#{ref}'") if commit.nil?
+
+        plan = { commit: commit, mode: mode }
+        text = "reset to #{commit[0, 7]} (#{mode})"
+        return planned(plan, "Would #{text}") if ui.dry_run?
+        return cancelled(plan) unless confirmed?(plan)
+
+        execute(plan, text)
+      end
+
+      def execute(plan, text)
+        previous = repo.resolve_commit('HEAD')
+        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)
+      end
+
+      def confirmed?(plan)
+        plan[:mode] != 'hard' || ui.confirm?(HARD_RESET_WARNING, plan: plan)
+      end
+
+      def report_single_commit
+        ui.report(status: 'noop', result: nil, text: 'You only have one commit!')
+      end
+    end
+  end
+end

data/lib/gitflash/commit.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Gitflash
+  # A commit as reported by `git log`
+  Commit = Data.define(:sha, :subject, :author, :committed_at) do
+    # Parses one line produced with Repo::COMMIT_FORMAT
+    def self.parse(line)
+      sha, subject, author, date = line.split(Repo::SEPARATOR, 4)
+      new(sha: sha, subject: subject.to_s, author: author, committed_at: Time.iso8601(date))
+    end
+
+    def label
+      "#{sha} - #{subject}"
+    end
+
+    def to_h
+      super.merge(committed_at: committed_at.iso8601)
+    end
+  end
+end

data/lib/gitflash/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module Gitflash
@@ -20,7 +22,7 @@ module Gitflash
         keys = data.keys.map(&:to_sym)
         Struct.new(*keys).new(*data.values).tap do |st|
           keys.each do |method|
-            st.send("#{method}=".to_sym, transform_to_struct(st.send(method)))
+            st.public_send("#{method}=", transform_to_struct(st.public_send(method)))
           end
         end
       end

data/lib/gitflash/confirmation_required.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Gitflash
+  # Raised when a destructive command runs without a terminal and without --yes.
+  # Carries the plan so the caller can review it and re-run with --yes.
+  class ConfirmationRequired < Error
+    def initialize(message = nil, plan: nil)
+      super(message, code: 'confirmation_required', plan: plan)
+    end
+
+    def exit_code
+      2
+    end
+
+    def status
+      'confirmation_required'
+    end
+  end
+end

data/lib/gitflash/error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Gitflash
+  # Base class for errors reported to the user.
+  # `code` is a stable machine-readable identifier; `plan` is the planned change, if any.
+  class Error < StandardError
+    attr_reader :code, :plan
+
+    def initialize(message = nil, code: 'failed', plan: nil)
+      super(message)
+      @code = code
+      @plan = plan
+    end
+
+    def exit_code
+      1
+    end
+
+    def status
+      'error'
+    end
+  end
+end

data/lib/gitflash/git/bash_command.rb

@@ -1,15 +1,26 @@
 # frozen_string_literal: true
 
+require 'open3'
+
 module Gitflash
   module Git
     class BashCommand
       class << self
-        def exec(command)
-          `#{command}`
+        # Runs a command without a shell and returns its stdout.
+        # Raises CommandError when the command exits with a non-zero status.
+        def exec(*args)
+          stdout, stderr, success = capture(*args)
+          raise CommandError, "#{args.join(' ')} failed: #{stderr.strip}" unless success
+
+          stdout
         end
 
-        def system_exec(*args)
-          system(*args)
+        # Runs a command without a shell and returns [stdout, stderr, success].
+        def capture(*args)
+          stdout, stderr, status = Open3.capture3(*args)
+          [stdout, stderr, status.success?]
+        rescue SystemCallError => e
+          raise CommandError, "#{args.join(' ')} failed: #{e.message}"
         end
       end
     end

data/lib/gitflash/git/command_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Git
+    class CommandError < Gitflash::Error
+      def initialize(message = nil, code: 'git_failed', plan: nil)
+        super
+      end
+    end
+  end
+end

data/lib/gitflash/prompt.rb

@@ -23,12 +23,12 @@ module Gitflash
       super(message, collection, default_select_options(options))
     end
 
-    def proceed_with_warning(message, &block)
+    def proceed_with_warning(message)
       raise ArgumentError, 'A block is required for this method' unless block_given?
 
       warn(message)
       answer = yes?('Do you want to proceed?')
-      answer ? block.call : 'Exited'
+      answer ? yield : 'Exited'
     end
 
     private

data/lib/gitflash/repo.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Gitflash
+  # Reads and changes the git repository in the current working directory.
+  # All git access goes through this class; it never prompts or prints.
+  class Repo
+    SEPARATOR = "\x1f"
+    BRANCH_FORMAT = %w[
+      refname:short objectname:short HEAD upstream:short upstream:track,nobracket
+      committerdate:iso-strict authorname subject
+    ].map { |field| "%(#{field})" }.join('%1f')
+    COMMIT_FORMAT = %w[%h %s %an %cI].join('%x1f')
+    COMMITS_LIMIT = 100
+    FALLBACK_DEFAULT_BRANCHES = %w[main master].freeze
+
+    def initialize(bash: Git::BashCommand)
+      @bash = bash
+    end
+
+    def ensure_work_tree!
+      inside = @bash.exec('git', 'rev-parse', '--is-inside-work-tree').strip == 'true'
+      raise Error.new('Not a git repository', code: 'not_a_repository') unless inside
+    rescue Git::CommandError
+      raise Error.new('Not a git repository', code: 'not_a_repository')
+    end
+
+    # Local branches. With `merged_status: true` each branch also reports whether it is
+    # merged into the default branch (one extra git call).
+    def branches(merged_status: false)
+      merged_names = merged_status ? merged_branch_names : nil
+      branch_lines.map do |line|
+        Branch.parse(line, default_branch: default_branch, merged_names: merged_names)
+      end
+    end
+
+    def current_branch
+      branches.find(&:current?)&.name
+    end
+
+    # The branch that origin/HEAD points to, else main or master when present locally
+    def default_branch
+      return @default_branch if defined?(@default_branch)
+
+      @default_branch = default_ref&.delete_prefix('origin/')
+    end
+
+    # Commits of the current branch, newest first. Empty for a branch without commits.
+    def commits(limit: COMMITS_LIMIT)
+      @bash.exec('git', 'log', "--max-count=#{limit}", "--format=#{COMMIT_FORMAT}")
+           .each_line(chomp: true).reject(&:empty?).map { |line| Commit.parse(line) }
+    rescue Git::CommandError
+      []
+    end
+
+    # Full sha of a commit reference, or nil when it does not name a commit
+    def resolve_commit(ref)
+      stdout, _stderr, success = @bash.capture('git', 'rev-parse', '--verify', '--quiet',
+                                               "#{ref}^{commit}")
+      success ? stdout.strip : nil
+    end
+
+    def checkout(branch)
+      run('git', 'checkout', branch, '--')
+    end
+
+    def delete_branch(branch, force: false)
+      run('git', 'branch', force ? '-D' : '-d', branch)
+    end
+
+    def reset(commit, mode:)
+      run('git', 'reset', "--#{mode}", commit, '--')
+    end
+
+    private
+
+    def branch_lines
+      @branch_lines ||= @bash.exec('git', 'for-each-ref', "--format=#{BRANCH_FORMAT}",
+                                   'refs/heads/')
+                             .each_line(chomp: true).reject(&:empty?)
+    end
+
+    # Ref used to check merge status: origin/HEAD's target, else a local main/master
+    def default_ref
+      return @default_ref if defined?(@default_ref)
+
+      @default_ref = remote_default_ref || local_default_branch
+    end
+
+    def remote_default_ref
+      ref = @bash.exec('git', 'symbolic-ref', '--quiet', '--short',
+                       'refs/remotes/origin/HEAD').strip
+      ref.empty? ? nil : ref
+    rescue Git::CommandError
+      nil
+    end
+
+    def local_default_branch
+      names = branch_lines.map { |line| line.split(SEPARATOR, 2).first }
+      FALLBACK_DEFAULT_BRANCHES.find { |name| names.include?(name) }
+    end
+
+    def merged_branch_names
+      return nil unless default_ref
+
+      @bash.exec('git', 'for-each-ref', "--merged=#{default_ref}", '--format=%(refname:short)',
+                 'refs/heads/')
+           .each_line(chomp: true).to_set
+    end
+
+    def run(*)
+      stdout, stderr, success = @bash.capture(*)
+      Result.new(success: success,
+                 output: [stdout, stderr].map(&:strip).reject(&:empty?).join("\n"))
+    end
+  end
+end

data/lib/gitflash/result.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Gitflash
+  # Outcome of a git command that changes the repository
+  Result = Data.define(:success, :output) do
+    alias_method :success?, :success
+  end
+end

data/lib/gitflash/ui.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gitflash
+  # Everything the user sees: human text or JSON, menus and confirmations.
+  # Menus and confirmations are only shown in a terminal and never in JSON mode.
+  #
+  # JSON output always uses the same envelope (see schema/v1.json):
+  #   { schema, command, ok, status, dry_run, plan?, result?, error? }
+  class Ui
+    JSON_SCHEMA_VERSION = 1
+    OK_STATUSES = %w[done planned noop cancelled].freeze
+
+    def initialize(command:, json: false, yes: false, dry_run: false)
+      @command = command
+      @json = json
+      @yes = yes
+      @dry_run = dry_run
+    end
+
+    def json?
+      @json
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    def interactive?
+      !json? && $stdin.tty?
+    end
+
+    # Reports the outcome of a command and returns its exit status.
+    # `status` is one of done, planned, noop, cancelled or failed.
+    def report(status:, text:, plan: nil, result: nil, error: nil)
+      if json?
+        document = envelope(status: status, plan: plan, result: result, error: error)
+        $stdout.puts JSON.generate(document)
+      else
+        $stdout.puts text
+      end
+      OK_STATUSES.include?(status) ? 0 : 1
+    end
+
+    def error(error)
+      if json?
+        details = { code: error.code, message: error.message, exit_code: error.exit_code }
+        $stdout.puts JSON.generate(envelope(status: error.status, plan: error.plan, error: details))
+      else
+        warn error.message
+      end
+    end
+
+    def select(message, choices, **)
+      prompt.select(message, choices, **)
+    end
+
+    def multi_select(message, choices, **)
+      prompt.multi_select(message, choices, **)
+    end
+
+    # True when the action may proceed: --yes was given or the user confirmed in a terminal.
+    # Raises ConfirmationRequired, carrying the plan, when nobody can confirm.
+    def confirm?(summary, plan:)
+      return true if @yes
+
+      message = "#{summary}\nRe-run with --yes to confirm."
+      raise ConfirmationRequired.new(message, plan: plan) unless interactive?
+
+      prompt.proceed_with_warning(summary) { true } == true
+    end
+
+    private
+
+    def envelope(status:, plan: nil, result: nil, error: nil)
+      {
+        schema: JSON_SCHEMA_VERSION,
+        command: @command,
+        ok: OK_STATUSES.include?(status),
+        status: status,
+        dry_run: dry_run?,
+        plan: plan,
+        result: result,
+        error: error
+      }.compact
+    end
+
+    def prompt
+      @prompt ||= Prompt.create
+    end
+  end
+end

data/lib/gitflash/usage_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Gitflash
+  # Raised for invalid arguments or when input is needed but no terminal is available
+  class UsageError < Error
+    def initialize(message = nil, code: 'invalid_usage', plan: nil)
+      super
+    end
+
+    def exit_code
+      2
+    end
+  end
+end

data/lib/gitflash/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gitflash
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end