rails-worktrees 0.3.0 → 0.5.0

data/lib/rails/worktrees/command.rb

@@ -10,6 +10,10 @@ module Rails
     # Creates or attaches worktrees for the current repository.
     # rubocop:disable Metrics/ClassLength
     class Command
+      REMOVE_SUBCOMMANDS = %w[remove delete].freeze
+      DOCTOR_SUBCOMMAND = 'doctor'.freeze
+      UPDATE_SUBCOMMAND = 'update'.freeze
+
       include GitOperations
       include EnvironmentSupport
       include NamePicking
@@ -24,18 +28,14 @@ module Rails
         @env = env
         @cwd = cwd
         @configuration = configuration
-        @dry_run = @argv.first == '--dry-run'
-        @argv.shift if dry_run?
+        extract_flags!
       end
 
       def run
-        return usage_error if dry_run? && @argv.first&.start_with?('-')
-
         meta_command_result = handle_meta_command
         return meta_command_result unless meta_command_result.nil?
-        return usage_error if @argv.length > 1
 
-        execute_worktree_command
+        execute_requested_command
       rescue Error => e
         @stderr.puts("Error: #{e.message}")
         1
@@ -45,6 +45,50 @@ module Rails
 
       def dry_run? = @dry_run
 
+      def force? = @force
+
+      def extract_flags!
+        @dry_run = extract_flag!('--dry-run')
+        @force = extract_flag!('--force')
+      end
+
+      def extract_flag!(flag)
+        extracted = false
+        @argv.reject! do |arg|
+          next false unless arg == flag
+
+          extracted = true
+          true
+        end
+        extracted
+      end
+
+      def remove_subcommand?
+        REMOVE_SUBCOMMANDS.include?(@argv.first)
+      end
+
+      def prune_subcommand?
+        @argv.first == 'prune'
+      end
+
+      def doctor_subcommand?
+        @argv.first == DOCTOR_SUBCOMMAND
+      end
+
+      def update_subcommand?
+        @argv.first == UPDATE_SUBCOMMAND
+      end
+
+      def execute_requested_command
+        return execute_doctor_command if doctor_subcommand?
+        return execute_update_command if update_subcommand?
+        return execute_remove_command if remove_subcommand?
+        return execute_prune_command if prune_subcommand?
+        return usage_error if @argv.length > 1 || force?
+
+        execute_worktree_command
+      end
+
       def execute_worktree_command
         require_git_repo
         announce_dry_run if dry_run?
@@ -61,16 +105,155 @@ module Rails
         finish(context)
       end
 
-      def resolve_worktree_context(explicit_worktree_name: nil)
-        repo_root = git_capture('rev-parse', '--show-toplevel').strip
-        project_name = File.basename(repo_root)
-        workspaces = resolve_workspaces(repo_root, project_name)
+      def execute_remove_command
+        require_git_repo
+        announce_dry_run if dry_run?
+        validate_remove_args!
+
+        context = resolve_worktree_context(explicit_worktree_name: @argv.fetch(1))
+        removal_status = removal_status_for(context)
+
+        ensure_removable!(context, **removal_status)
+        return complete_remove_dry_run(context, **removal_status) if dry_run?
+
+        perform_remove(context, **removal_status)
+      end
+
+      def validate_remove_args!
+        raise Error, "Usage: wt #{@argv.first} [--dry-run] [--force] <worktree-name>" unless @argv.length == 2
+      end
+
+      def removal_status_for(context)
+        {
+          worktree_exists: File.exist?(context[:target_dir]),
+          branch_exists: branch_exists_locally?(context[:branch_name])
+        }
+      end
+
+      def perform_remove(context, worktree_exists:, branch_exists:)
+        remove_target_path(context[:target_dir]) if worktree_exists
+        delete_local_branch(context[:branch_name], force: force?) if branch_exists
+
+        success("Removed '#{context[:worktree_name]}'")
+        print_context_summary(context, env_values: nil)
+        0
+      end
+
+      def execute_prune_command
+        require_git_repo
+        announce_dry_run if dry_run?
+        validate_prune_args!
+
+        candidates = prune_candidates
+        return complete_prune_noop if candidates.empty?
+
+        prepare_prune(candidates)
+        return complete_prune_dry_run(candidates) if dry_run?
+
+        perform_prune(candidates)
+
+        success("Pruned #{candidates.length} worktree#{'s' unless candidates.length == 1}")
+        0
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def execute_doctor_command
+        validate_doctor_args!
+
+        unless git_success?('rev-parse', '--is-inside-work-tree')
+          checks = [doctor_check(category: :git, status: :warning,
+                                 headline: 'Run wt doctor from inside a Git repository.')]
+          print_doctor_report(checks)
+          return 1
+        end
+
+        repository = resolve_repository_context
+        checks = project_maintenance_report(repository[:current_root]).checks + doctor_worktree_checks(repository)
+        print_doctor_report(checks)
+
+        checks.any? { |check| check.fixable? || check.warning? } ? 1 : 0
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def execute_update_command
+        require_git_repo
+        validate_update_args!
+        announce_dry_run if dry_run?
+
+        current_root = resolve_repository_context[:current_root]
+        report = project_maintenance_report(current_root)
+        updated_count = 0
+        identical_count = 0
+        skipped_count = 0
+
+        report.checks.each do |check|
+          if check.fixable?
+            apply_maintenance_check(check, current_root: current_root)
+            updated_count += 1
+          elsif check.ok?
+            identical_count += 1
+            info(check.headline)
+          else
+            skipped_count += 1
+            warning(check.headline)
+            check.messages.each { |message| info(message) }
+          end
+        end
+
+        complete_update(updated_count:, identical_count:, skipped_count:)
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def validate_prune_args!
+        raise Error, 'Usage: wt prune' unless @argv.length == 1
+        raise Error, 'The --force flag is only supported with wt remove.' if force?
+      end
+
+      def validate_doctor_args!
+        raise Error, 'Usage: wt doctor' unless @argv.length == 1
+        raise Error, 'wt doctor does not support --dry-run.' if dry_run?
+        raise Error, 'The --force flag is only supported with wt remove.' if force?
+      end
+
+      def validate_update_args!
+        raise Error, 'Usage: wt update [--dry-run]' unless @argv.length == 1
+        raise Error, 'The --force flag is only supported with wt remove.' if force?
+      end
+
+      def announce_prune_candidates(candidates)
+        info("Found #{candidates.length} merged worktree#{'s' unless candidates.length == 1} created by wt:")
+      end
+
+      def prepare_prune(candidates)
+        announce_prune_candidates(candidates)
+        print_prune_candidates(candidates)
+        confirm_or_abort!(prune_confirmation_prompt(candidates.length))
+      end
+
+      def prune_confirmation_prompt(count)
+        branches = count == 1 ? 'its local branch' : 'their local branches'
+        "Delete #{count} merged worktree#{'s' unless count == 1} and #{branches}?"
+      end
+
+      def perform_prune(candidates)
+        candidates.each do |context|
+          remove_target_path(context[:target_dir])
+          delete_local_branch(context[:branch_name], force: false)
+        end
+      end
+
+      def resolve_worktree_context(explicit_worktree_name: nil, repository: nil)
+        repository ||= resolve_repository_context
+        project_name = repository[:project_name]
+        workspaces = repository[:workspaces]
         worktree_name = resolved_worktree_name(project_name, workspaces, explicit_worktree_name)
 
-        { project_name: project_name, workspaces_root: workspaces[:root], worktree_name: worktree_name,
-          uses_default_workspace_root: workspaces[:uses_default_root],
+        repository.merge(
+          worktree_name: worktree_name,
           branch_name: branch_name_for(worktree_name),
-          target_dir: target_dir_for(project_name, worktree_name, workspaces) }
+          target_dir: target_dir_for(project_name, worktree_name, workspaces)
+        )
       end
 
       def resolved_worktree_name(project_name, workspaces, explicit_worktree_name)
@@ -133,16 +316,244 @@ module Rails
         confirm_or_abort!("Target path '#{target_dir}' already exists. Remove it and recreate the worktree?")
         return info("Would remove existing target path '#{target_dir}'") if dry_run?
 
-        if registered_worktree_path?(target_dir)
-          remove_registered_worktree(target_dir)
-        else
-          FileUtils.rm_rf(target_dir)
-        end
+        remove_target_path(target_dir)
       end
 
       def branch_name_for(worktree_name)
         "#{@configuration.branch_prefix}/#{worktree_name}"
       end
+
+      def ensure_removable!(context, worktree_exists:, branch_exists:)
+        ensure_remove_target_exists!(context, worktree_exists: worktree_exists, branch_exists: branch_exists)
+        ensure_not_removing_protected_checkout!(context)
+        ensure_branch_not_checked_out_here!(context)
+        ensure_branch_not_checked_out_elsewhere!(context)
+        ensure_local_branch_removable!(context[:branch_name], force: force?) if branch_exists
+      end
+
+      def ensure_remove_target_exists!(context, worktree_exists:, branch_exists:)
+        return if worktree_exists || branch_exists
+
+        raise Error, "No worktree or local branch found for '#{context[:worktree_name]}'."
+      end
+
+      def ensure_not_removing_protected_checkout!(context)
+        target_path = canonical_path(context[:target_dir])
+        raise Error, 'Cannot remove the main checkout.' if target_path == canonical_path(context[:primary_root])
+
+        return unless target_path == canonical_path(context[:current_root])
+
+        raise Error,
+              'Cannot remove the current worktree from inside itself. ' \
+              'Run this command from the main checkout or another worktree.'
+      end
+
+      def ensure_branch_not_checked_out_here!(context)
+        return unless current_checkout_branch == context[:branch_name]
+
+        raise Error,
+              "Branch '#{context[:branch_name]}' is checked out in the current worktree. " \
+              'Run this command from the main checkout or another worktree.'
+      end
+
+      def ensure_branch_not_checked_out_elsewhere!(context)
+        target_path = canonical_path(context[:target_dir])
+        unexpected_paths = worktree_entries_for_branch(context[:branch_name])
+                           .map { |entry| entry[:path] }
+                           .reject { |path| path == target_path }
+        return if unexpected_paths.empty?
+
+        raise Error,
+              "Branch '#{context[:branch_name]}' is checked out in another worktree at '#{unexpected_paths.first}'."
+      end
+
+      def prune_candidates
+        repository = resolve_repository_context
+
+        worktree_entries.filter_map do |entry|
+          prune_candidate_for(entry, repository)
+        end
+      end
+
+      def prune_candidate_for(entry, repository)
+        branch_name = entry[:branch_name]
+        return unless prunable_worktree_entry?(entry, branch_name, repository)
+
+        context = resolve_worktree_context(
+          explicit_worktree_name: worktree_name_for_branch(branch_name),
+          repository: repository
+        )
+        return unless prune_target_matches_entry?(entry, context)
+
+        context
+      end
+
+      def prunable_worktree_entry?(entry, branch_name, repository)
+        wt_managed_branch?(branch_name) &&
+          !protected_prune_path?(entry[:path], repository) &&
+          !branch_checked_out_elsewhere_for_prune?(branch_name, entry[:path]) &&
+          branch_exists_locally?(branch_name) &&
+          branch_merged_into_default?(branch_name)
+      end
+
+      def branch_checked_out_elsewhere_for_prune?(branch_name, target_path)
+        worktree_entries_for_branch(branch_name).any? { |other| other[:path] != target_path }
+      end
+
+      def prune_target_matches_entry?(entry, context)
+        entry[:path] == canonical_path(context[:target_dir])
+      end
+
+      def protected_prune_path?(path, repository)
+        path == repository[:primary_root] || path == repository[:current_root]
+      end
+
+      def wt_managed_branch?(branch_name)
+        branch_name&.start_with?("#{@configuration.branch_prefix}/")
+      end
+
+      def worktree_name_for_branch(branch_name)
+        branch_name.delete_prefix("#{@configuration.branch_prefix}/")
+      end
+
+      def project_maintenance_report(root)
+        ::Rails::Worktrees::ProjectMaintenance.new(root: root).call
+      end
+
+      def doctor_worktree_checks(repository)
+        [
+          doctor_check(
+            category: :git,
+            status: :ok,
+            headline: "Git repository detected at #{repository[:current_root]}."
+          ),
+          default_branch_doctor_check,
+          stale_worktree_doctor_check
+        ]
+      end
+
+      def default_branch_doctor_check
+        doctor_check(
+          category: :git,
+          status: :ok,
+          headline: "origin default branch resolves to '#{resolve_default_branch}'."
+        )
+      rescue Error => e
+        doctor_check(category: :git, status: :warning, headline: e.message)
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def stale_worktree_doctor_check
+        stale_paths = worktree_entries.reject { |entry| File.directory?(entry[:path]) }
+        if stale_paths.empty?
+          doctor_check(category: :worktree, status: :ok, headline: 'No stale registered worktree paths found.')
+        else
+          doctor_check(
+            category: :worktree,
+            status: :warning,
+            headline: "Found #{stale_paths.length} stale registered worktree " \
+                      "path#{'s' unless stale_paths.length == 1}.",
+            messages: stale_paths.map { |entry| entry[:path] }
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def doctor_check(category:, status:, headline:, messages: [])
+        ::Rails::Worktrees::ProjectMaintenance::Check.new(
+          identifier: nil,
+          category: category,
+          status: status,
+          headline: headline,
+          messages: messages,
+          relative_path: nil,
+          updated_content: nil,
+          make_executable: false,
+          apply_messages: []
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Metrics/AbcSize
+      def apply_maintenance_check(check, current_root:)
+        if dry_run?
+          info("Would update #{check.relative_path}")
+          Array(check.apply_messages).each { |message| info(message) }
+          return
+        end
+
+        path = maintenance_destination_path(check.relative_path, current_root)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, check.updated_content)
+        FileUtils.chmod(0o755, path) if check.make_executable
+
+        Array(check.apply_messages).each { |message| info(message) }
+      end
+
+      def maintenance_destination_path(relative_path, current_root)
+        root_path = File.realpath(current_root)
+        path = File.expand_path(relative_path, root_path)
+        assert_within_root!(path, root_path, "Refusing to write outside of repository root: #{path}")
+        parent_path = nearest_existing_parent(File.dirname(path))
+        assert_parent_within_root!(parent_path, root_path, path)
+        assert_not_symlink!(path)
+        path
+      end
+
+      def assert_within_root!(path, root_path, message)
+        raise Error, message unless within_root?(path, root_path)
+      end
+
+      def assert_parent_within_root!(parent_path, root_path, path)
+        assert_within_root!(
+          parent_path,
+          root_path,
+          "Refusing to write through symlinked directory outside repository root: #{path}"
+        )
+      end
+
+      def assert_not_symlink!(path)
+        raise Error, "Refusing to overwrite symlinked path: #{path}" if File.symlink?(path)
+      end
+
+      def within_root?(path, root_path)
+        path == root_path || path.start_with?("#{root_path}#{File::SEPARATOR}")
+      end
+
+      def nearest_existing_parent(path)
+        candidate = path
+        until File.exist?(candidate)
+          parent = File.dirname(candidate)
+          return candidate if parent == candidate
+
+          candidate = parent
+        end
+
+        File.realpath(candidate)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/MethodLength
+      def complete_update(updated_count:, identical_count:, skipped_count:)
+        if dry_run?
+          success('Dry run complete')
+          info("Would update #{updated_count} file#{'s' unless updated_count == 1}.")
+          info('No changes were made.')
+          return 0
+        end
+
+        success('Update complete')
+        info(
+          [
+            "updated: #{updated_count}",
+            "already up to date: #{identical_count}",
+            "skipped: #{skipped_count}"
+          ].join(', ')
+        )
+        0
+      end
+      # rubocop:enable Metrics/MethodLength
     end
     # rubocop:enable Metrics/ClassLength
   end

data/lib/rails/worktrees/initializer_updater.rb

@@ -0,0 +1,148 @@
+require 'erb'
+
+module Rails
+  module Worktrees
+    # Safely updates the generated initializer to use the current gem-loading guard.
+    # rubocop:disable Metrics/ClassLength
+    class InitializerUpdater
+      Result = Struct.new(:content, :changed, :status, :messages) do
+        def changed?
+          changed
+        end
+      end
+
+      TEMPLATE_PATH = File.expand_path('../../generators/rails/worktrees/templates/rails_worktrees.rb.tt', __dir__)
+      CURRENT_GUARD_LINES = [
+        "if Gem.loaded_specs.key?('rails-worktrees') &&",
+        '    defined?(Rails::Worktrees) &&',
+        '    Rails::Worktrees.respond_to?(:configure)'
+      ].freeze
+      KNOWN_GUARD_FRAGMENTS = [
+        "Gem.loaded_specs.key?('rails-worktrees')",
+        'defined?(Rails::Worktrees)',
+        'Rails::Worktrees.respond_to?(:configure)'
+      ].freeze
+      CONFIGURE_CALL = 'Rails::Worktrees.configure do |config|'.freeze
+      LEGACY_GUARD = /\Aif defined\?\(Rails::Worktrees\)\n(?<body>.*)\nend\z/m
+
+      def self.default_content = new(content: '').send(:render_default_template)
+
+      def initialize(content:) = @content = content
+
+      def call
+        return identical_result if current_guard_present?
+        return updated_result(self.class.default_content) if blank_content?
+
+        body = wrapped_body
+        return skip_result unless body
+
+        updated_result(rebuild_content(body))
+      end
+
+      private
+
+      def identical_result
+        Result.new(
+          @content,
+          false,
+          :identical,
+          ['config/initializers/rails_worktrees.rb already uses the current safety guard.']
+        )
+      end
+
+      def updated_result(content)
+        Result.new(
+          content,
+          content != @content,
+          :updated,
+          ['Updated config/initializers/rails_worktrees.rb to use the current safety guard.']
+        )
+      end
+
+      def skip_result
+        Result.new(
+          @content,
+          false,
+          :skip,
+          ['config/initializers/rails_worktrees.rb is too custom to update automatically; review it manually.']
+        )
+      end
+
+      def blank_content? = @content.to_s.strip.empty?
+
+      def current_guard_present?
+        !extract_known_guard_body(@content.to_s.strip.lines, required_guard_lines: CURRENT_GUARD_LINES).nil?
+      end
+
+      def wrapped_body = extract_existing_body&.then { |body| normalize_body(body) }
+
+      def extract_existing_body
+        stripped = @content.to_s.strip
+        return if stripped.empty?
+
+        return Regexp.last_match[:body] if stripped.match(LEGACY_GUARD)
+
+        body = extract_known_guard_body(stripped.lines)
+        return body if body
+
+        body = extract_plain_configure_body(stripped.lines)
+        return body if body
+
+        nil
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def extract_known_guard_body(lines, required_guard_lines: nil)
+        return if lines.empty? || lines.last.strip != 'end'
+
+        configure_index = lines.index { |line| line.strip == CONFIGURE_CALL }
+        return unless configure_index
+
+        guard_lines = lines[0...configure_index].reject { |line| line.strip.empty? }.map(&:rstrip)
+        return unless guard_lines.all? { |line| known_guard_line?(line) }
+        return if required_guard_lines && guard_lines != required_guard_lines
+
+        lines[configure_index...-1].join.rstrip
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def extract_plain_configure_body(lines)
+        return unless lines.first&.strip == CONFIGURE_CALL && lines.last&.strip == 'end'
+
+        lines.join.rstrip
+      end
+
+      def known_guard_line?(line)
+        stripped = line.strip
+        return true if stripped.empty?
+
+        normalized = stripped.delete_suffix('&&').strip.sub(/\Aif\s+/, '')
+        KNOWN_GUARD_FRAGMENTS.include?(normalized)
+      end
+
+      def normalize_body(body)
+        body_lines = body.rstrip.lines
+        return '' if body_lines.empty?
+
+        return body.rstrip if body_lines.first.start_with?('  ')
+
+        body_lines.map { |line| line.strip.empty? ? line : "  #{line}" }.join.rstrip
+      end
+
+      def rebuild_content(body)
+        content = [CURRENT_GUARD_LINES.join("\n"), body, 'end'].join("\n")
+        @content.end_with?("\n") || @content.empty? ? "#{content}\n" : content
+      end
+
+      def render_default_template
+        ERB.new(File.read(TEMPLATE_PATH), trim_mode: '-').result(template_context.instance_eval { binding })
+      end
+
+      def template_context
+        Struct.new(:options, :conductor_workspace_root).new({ 'conductor' => false },
+                                                            "File.expand_path('~/Sites/conductor/workspaces')")
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end