fix: resolve resource leaks in GHService.getDiffStats()

Extract JGit operations to DiffStatsCalculator with proper
try-with-resources to ensure ObjectReader, DiffFormatter,
and RevWalk instances are always closed.

Fixes:
- ObjectReader leaked in dryRun code path
- DiffFormatter never closed in any path
- RevWalk instances never closed in committed path

Fixes #1660

Author: Fikri-20

plugin-modernizer-core/src/main/java/io/jenkins/tools/pluginmodernizer/core/github/DiffStatsCalculator.java

@@ -0,0 +1,145 @@
+package io.jenkins.tools.pluginmodernizer.core.github;
+
+import io.jenkins.tools.pluginmodernizer.core.config.Settings;
+import io.jenkins.tools.pluginmodernizer.core.model.DiffStats;
+import io.jenkins.tools.pluginmodernizer.core.model.Plugin;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.List;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.diff.DiffEntry;
+import org.eclipse.jgit.diff.DiffFormatter;
+import org.eclipse.jgit.diff.Edit;
+import org.eclipse.jgit.diff.EditList;
+import org.eclipse.jgit.diff.RawTextComparator;
+import org.eclipse.jgit.dircache.DirCacheIterator;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectReader;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.treewalk.CanonicalTreeParser;
+import org.eclipse.jgit.treewalk.FileTreeIterator;
+import org.eclipse.jgit.treewalk.WorkingTreeIterator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DiffStatsCalculator {
+
+    private static final Logger LOG = LoggerFactory.getLogger(DiffStatsCalculator.class);
+
+    public DiffStats calculate(Plugin plugin, boolean dryRun) throws IOException, GitAPIException {
+        Path gitDirPath = Settings.DEFAULT_CACHE_PATH
+                .resolve(plugin.getName())
+                .resolve("sources")
+                .resolve(".git")
+                .normalize();
+        File gitDir = gitDirPath.toFile();
+
+        try (Repository repository = new FileRepositoryBuilder()
+                        .setGitDir(gitDir)
+                        .readEnvironment()
+                        .findGitDir()
+                        .build();
+                Git git = new Git(repository)) {
+
+            return calculateDiff(repository, git, plugin, dryRun);
+        }
+    }
+
+    private DiffStats calculateDiff(Repository repository, Git git, Plugin plugin, boolean dryRun)
+            throws IOException, GitAPIException {
+        int additions = 0;
+        int deletions = 0;
+        int changedFiles = 0;
+
+        try (ObjectReader reader = repository.newObjectReader();
+                DiffFormatter formatter = new DiffFormatter(new ByteArrayOutputStream())) {
+            formatter.setRepository(repository);
+            formatter.setDiffComparator(RawTextComparator.DEFAULT);
+            formatter.setDetectRenames(true);
+
+            if (dryRun) {
+                return calculateUnstagedDiff(repository, git, reader, formatter);
+            } else {
+                return calculateCommittedDiff(repository, git, plugin, reader, formatter);
+            }
+        }
+    }
+
+    private DiffStats calculateUnstagedDiff(
+            Repository repository, Git git, ObjectReader reader, DiffFormatter formatter)
+            throws IOException, GitAPIException {
+        int additions = 0;
+        int deletions = 0;
+        int changedFiles = 0;
+
+        DirCacheIterator indexTree = new DirCacheIterator(repository.readDirCache());
+        FileTreeIterator workingTree = new FileTreeIterator(repository);
+
+        List<DiffEntry> unstagedDiffs = git.diff()
+                .setOldTree(indexTree)
+                .setNewTree(workingTree)
+                .setShowNameAndStatusOnly(false)
+                .call();
+
+        for (DiffEntry diff : unstagedDiffs) {
+            try {
+                EditList edits = formatter.toFileHeader(diff).toEditList();
+                for (Edit edit : edits) {
+                    additions += edit.getEndB() - edit.getBeginB();
+                    deletions += edit.getEndA() - edit.getBeginA();
+                }
+                changedFiles++;
+            } catch (org.eclipse.jgit.errors.MissingObjectException e) {
+                LOG.warn("Skipping diff for {}: {}", diff.getNewPath(), e.getMessage());
+            }
+        }
+
+        return new DiffStats(additions, deletions, changedFiles);
+    }
+
+    private DiffStats calculateCommittedDiff(
+            Repository repository, Git git, Plugin plugin, ObjectReader reader, DiffFormatter formatter)
+            throws IOException, GitAPIException {
+        int additions = 0;
+        int deletions = 0;
+        int changedFiles = 0;
+
+        ObjectId head = repository.resolve("HEAD");
+        String defaultBranchName = plugin.getRemoteRepository(null).getDefaultBranch();
+        ObjectId defaultBranch = repository.resolve("refs/heads/" + defaultBranchName);
+
+        if (defaultBranch == null) {
+            throw new IOException("Could not resolve default branch.");
+        }
+
+        try (RevWalk oldWalk = new RevWalk(repository);
+                RevWalk newWalk = new RevWalk(repository)) {
+            CanonicalTreeParser oldTree = new CanonicalTreeParser();
+            CanonicalTreeParser newTree = new CanonicalTreeParser();
+            oldTree.reset(reader, oldWalk.parseTree(defaultBranch));
+            newTree.reset(reader, newWalk.parseTree(head));
+
+            List<DiffEntry> committedDiffs = git.diff()
+                    .setOldTree(oldTree)
+                    .setNewTree(newTree)
+                    .setShowNameAndStatusOnly(false)
+                    .call();
+
+            for (DiffEntry diff : committedDiffs) {
+                EditList edits = formatter.toFileHeader(diff).toEditList();
+                for (Edit edit : edits) {
+                    additions += edit.getEndB() - edit.getBeginB();
+                    deletions += edit.getEndA() - edit.getBeginA();
+                }
+                changedFiles++;
+            }
+        }
+
+        return new DiffStats(additions, deletions, changedFiles);
+    }
+}