class GitHubPullRequestSender {

    public Multimap<String, GitHubContentToProcess> forkRepositoriesFoundAndGetPathToDockerfiles(
            PagedSearchIterable<GHContent> contentsWithImage,
            GitForkBranch gitForkBranch) {
        log.info("Forking repositories...");
        Multimap<String, GitHubContentToProcess> pathToDockerfilesInParentRepo = HashMultimap.create();
        GHRepository parent;
        String parentRepoName;
        int totalContentsFound = 0;
        int contentsShouldFork = 0;
        for (GHContent ghContent : contentsWithImage) {
            /* Kohsuke's GitHub API library, when retrieving the forked repository, looks at the name of the parent to
             * retrieve. The issue with that is: GitHub, when forking two or more repositories with the same name,
             * automatically fixes the names to be unique (by appending "-#" to the end). Because of this edge case, we
             * cannot save the forks and iterate over the repositories; else, we end up missing/not updating the
             * repositories that were automatically fixed by GitHub. Instead, we save the names of the parent repos
             * in the map above, find the list of repositories under the authorized user, and iterate through that list.
             */
            totalContentsFound++;
            parent = ghContent.getOwner();
            parentRepoName = parent.getFullName();
            // Refresh the repo to ensure that the object has full details
            try {
                parent = dockerfileGitHubUtil.getRepo(parentRepoName);
                ShouldForkResult shouldForkResult = forkableRepoValidator.shouldFork(parent, ghContent, gitForkBranch);
                if (shouldForkResult.isForkable()) {
                    contentsShouldFork++;
                    // fork the parent if not already forked
                    ensureForkedAndAddToListForProcessing(pathToDockerfilesInParentRepo, parent, parentRepoName, ghContent);
                } else {
                    log.warn("Skipping {} because {}", parentRepoName, shouldForkResult.getReason());
                }
            } catch (IOException exception) {
                log.warn("Could not refresh details of {}", parentRepoName);
            }
        }

        log.info("Out of {} content search results processed, {} were deemed eligible for forking to yield {} repositories to fork.",
                totalContentsFound, contentsShouldFork, pathToDockerfilesInParentRepo.keys().size());
        log.info("Path to Dockerfiles in repos: {}", pathToDockerfilesInParentRepo);

        return pathToDockerfilesInParentRepo;
    }

    public  GitHubPullRequestSender(DockerfileGitHubUtil dockerfileGitHubUtil, ForkableRepoValidator forkableRepoValidator);

}