Refactor ProcessClipsAsync and ProcessSingleClipAsync to reduce method complexity

[Copilot]

Two methods in ProcessingClips.cs exceeded the 70-line recommended threshold: ProcessClipsAsync (91 lines) and ProcessSingleClipAsync (85 lines), making them difficult to read and maintain.

Changes

Applied EXTRACT FUNCTION refactoring to decompose both methods into focused, single-responsibility helpers:

ProcessClipsAsync (91 → 34 lines)

• InitializeProcessingTransaction() - Sentry setup
• ValidateProcessingInputs() - Input validation with early returns
• EnsureBackupDirectoryExists() - Backup directory initialization
• ProcessAllClipFiles() - File processing iteration
• FinalizeProcessingResult() - Result aggregation and completion
• HandleProcessingException() - Centralized error handling

ProcessSingleClipAsync (85 → 38 lines)

• ValidateFileExists() - File validation with early return
• CreateFileBackup() - Backup creation
• ReadFileData() - File I/O
• FindAndApplyPatches() - Pattern matching and patching logic
• WriteFileIfChanged() - Conditional file persistence
• HandleFileProcessingException() - Error handling

Example

Before:

public async Task<ProcessingResult> ProcessClipsAsync(...)
{
    // 91 lines of initialization, validation, processing, and error handling
}

After:

public async Task<ProcessingResult> ProcessClipsAsync(...)
{
    var transaction = SentrySdk.GetSpan() ?? SentrySdk.StartTransaction("process-clips", "process");
    var result = new ProcessingResult();

    try
    {
        InitializeProcessingTransaction(transaction, clipFilePaths, blockedResources, mode, caseInsensitive);
        if (!ValidateProcessingInputs(clipFilePaths, blockedResources, transaction)) return result;
        EnsureBackupDirectoryExists(transaction);
        
        result.TotalFiles = clipFilePaths.Count;
        await ProcessAllClipFiles(clipFilePaths, blockedResources, mode, placeholder, caseInsensitive, result, transaction);
        FinalizeProcessingResult(result, transaction);
        
        return result;
    }
    catch (Exception ex)
    {
        HandleProcessingException(ex, clipFilePaths, blockedResources, result, transaction);
        return result;
    }
}

All existing functionality, Sentry instrumentation, and event handlers preserved. CodeQL scan clean.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>[T_DEBT] clip2load-repository/ProcessingClips.cs - ProcessClipsAsync + ProcessSingleClipAsync</issue_title>
<issue_description># Where?
You have 2 functions that exceed the threshold.

• ProcessClipsAsync (LoC = 91 lines)
• ProcessSingleClipAsync (LoC = 85 lines)

Why does this problem occur?

Overly long functions make the code harder to read. The recommended maximum function length for the C# language is 70 lines of code. Severity: Brain Method - Complex Method - Long Method.

How to fix it?

We recommend to be careful here -- just splitting long functions don't necessarily make the code easier to read. Instead, look for natural chunks inside the functions that expresses a specific task or concern. Often, such concerns are indicated by a Code Comment followed by an if-statement. Use the EXTRACT FUNCTION refactoring to encapsulate that concern.</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes [T_DEBT] clip2load-repository/ProcessingClips.cs - ProcessClipsAsync + ProcessSingleClipAsync #2

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.