Examples with Patch com.google.gerrit.entities.Patch used on opensource projects

Example 6 with Patch

use of com.google.gerrit.entities.Patch in project gerrit by GerritCodeReview.

the class RevisionDiffIT method rebaseHunksDirectlyTouchingHunksOfPatchSetsNotModifiedBetweenThemAreIdentified.

@Test
public void rebaseHunksDirectlyTouchingHunksOfPatchSetsNotModifiedBetweenThemAreIdentified() throws Exception {
    // Add to hunks in a patch set and remove them in a further patch set to allow rebasing.
    Function<String, String> contentModification = fileContent -> fileContent.replace("Line 1\n", "Line one\n").replace("Line 3\n", "Line three\n");
    addModifiedPatchSet(changeId, FILE_NAME, contentModification);
    String previousPatchSetId = gApi.changes().id(changeId).get().currentRevision;
    Function<String, String> reverseContentModification = fileContent -> fileContent.replace("Line one\n", "Line 1\n").replace("Line three\n", "Line 3\n");
    addModifiedPatchSet(changeId, FILE_NAME, reverseContentModification);
    String newFileContent = FILE_CONTENT.replace("Line 2\n", "Line two\n");
    ObjectId commit2 = addCommit(commit1, FILE_NAME, newFileContent);
    rebaseChangeOn(changeId, commit2);
    // Add the hunks again and modify another line so that we get a diff for the file.
    // (Files with only edits due to rebase are filtered out.)
    addModifiedPatchSet(changeId, FILE_NAME, contentModification.andThen(fileContent -> fileContent.replace("Line 10\n", "Line ten\n")));
    DiffInfo diffInfo = getDiffRequest(changeId, CURRENT, FILE_NAME).withBase(previousPatchSetId).get();
    assertThat(diffInfo).content().element(0).commonLines().isNotEmpty();
    assertThat(diffInfo).content().element(1).linesOfA().containsExactly("Line 2");
    assertThat(diffInfo).content().element(1).linesOfB().containsExactly("Line two");
    assertThat(diffInfo).content().element(1).isDueToRebase();
    assertThat(diffInfo).content().element(2).commonLines().isNotEmpty();
    assertThat(diffInfo).content().element(3).linesOfA().containsExactly("Line 10");
    assertThat(diffInfo).content().element(3).linesOfB().containsExactly("Line ten");
    assertThat(diffInfo).content().element(3).isNotDueToRebase();
    assertThat(diffInfo).content().element(4).commonLines().isNotEmpty();
    Map<String, FileInfo> changedFiles = gApi.changes().id(changeId).current().files(previousPatchSetId);
    assertThat(changedFiles.get(FILE_NAME)).linesInserted().isEqualTo(1);
    assertThat(changedFiles.get(FILE_NAME)).linesDeleted().isEqualTo(1);
}

Example 7 with Patch

use of com.google.gerrit.entities.Patch in project gerrit by GerritCodeReview.

the class FixReplacementInterpreter method toCommitModification.

/**
 * Transforms the given {@code FixReplacement}s into {@code TreeModification}s.
 *
 * @param repository the affected Git repository
 * @param projectState the affected project
 * @param patchSetCommitId the patch set which should be modified
 * @param fixReplacements the replacements which should be applied
 * @return a list of {@code TreeModification}s representing the given replacements
 * @throws ResourceNotFoundException if a file to which one of the replacements refers doesn't
 *     exist
 * @throws ResourceConflictException if the replacements can't be transformed into {@code
 *     TreeModification}s
 */
public CommitModification toCommitModification(Repository repository, ProjectState projectState, ObjectId patchSetCommitId, List<FixReplacement> fixReplacements) throws BadRequestException, ResourceNotFoundException, IOException, ResourceConflictException {
    requireNonNull(fixReplacements, "Fix replacements must not be null");
    Map<String, List<FixReplacement>> fixReplacementsPerFilePath = fixReplacements.stream().collect(groupingBy(fixReplacement -> fixReplacement.path));
    CommitModification.Builder modificationBuilder = CommitModification.builder();
    for (Map.Entry<String, List<FixReplacement>> entry : fixReplacementsPerFilePath.entrySet()) {
        if (Objects.equals(entry.getKey(), Patch.COMMIT_MSG)) {
            String newCommitMessage = getNewCommitMessage(repository, patchSetCommitId, entry.getValue());
            modificationBuilder.newCommitMessage(newCommitMessage);
        } else {
            TreeModification treeModification = toTreeModification(repository, projectState, patchSetCommitId, entry.getKey(), entry.getValue());
            modificationBuilder.addTreeModification(treeModification);
        }
    }
    return modificationBuilder.build();
}

Example 8 with Patch

use of com.google.gerrit.entities.Patch in project gerrit by GerritCodeReview.

the class SubmitWithStickyApprovalDiff method apply.

public String apply(ChangeNotes notes, CurrentUser currentUser) throws AuthException, IOException, PermissionBackendException, InvalidChangeOperationException {
    PatchSet currentPatchset = notes.getCurrentPatchSet();
    PatchSet.Id latestApprovedPatchsetId = getLatestApprovedPatchsetId(notes);
    if (latestApprovedPatchsetId.get() == currentPatchset.id().get()) {
        // If the latest approved patchset is the current patchset, no need to return anything.
        return "";
    }
    StringBuilder diff = new StringBuilder(String.format("\n\n%d is the latest approved patch-set.\n", latestApprovedPatchsetId.get()));
    Map<String, FileDiffOutput> modifiedFiles = listModifiedFiles(notes.getProjectName(), currentPatchset, notes.getPatchSets().get(latestApprovedPatchsetId));
    // To make the message a bit more concise, we skip the magic files.
    List<FileDiffOutput> modifiedFilesList = modifiedFiles.values().stream().filter(p -> !Patch.isMagic(p.newPath().orElse(""))).collect(Collectors.toList());
    if (modifiedFilesList.isEmpty()) {
        diff.append("No files were changed between the latest approved patch-set and the submitted one.\n");
        return diff.toString();
    }
    diff.append("The change was submitted with unreviewed changes in the following files:\n\n");
    TemporaryBuffer.Heap buffer = new TemporaryBuffer.Heap(Math.min(HEAP_EST_SIZE, DEFAULT_POST_SUBMIT_SIZE_LIMIT), DEFAULT_POST_SUBMIT_SIZE_LIMIT);
    try (Repository repository = repositoryManager.openRepository(notes.getProjectName());
        DiffFormatter formatter = new DiffFormatter(buffer)) {
        formatter.setRepository(repository);
        formatter.setDetectRenames(true);
        boolean isDiffTooLarge = false;
        List<String> formatterResult = null;
        try {
            formatter.format(modifiedFilesList.get(0).oldCommitId(), modifiedFilesList.get(0).newCommitId());
            // This returns the diff for all the files.
            formatterResult = Arrays.stream(RawParseUtils.decode(buffer.toByteArray()).split("\n")).collect(Collectors.toList());
        } catch (IOException e) {
            if (JGitText.get().inMemoryBufferLimitExceeded.equals(e.getMessage())) {
                isDiffTooLarge = true;
            } else {
                throw e;
            }
        }
        if (formatterResult != null) {
            int addedBytes = formatterResult.stream().mapToInt(String::length).sum();
            if (!CommentCumulativeSizeValidator.isEnoughSpace(notes, addedBytes, maxCumulativeSize)) {
                isDiffTooLarge = true;
            }
        }
        for (FileDiffOutput fileDiff : modifiedFilesList) {
            diff.append(getDiffForFile(notes, currentPatchset.id(), latestApprovedPatchsetId, fileDiff, currentUser, formatterResult, isDiffTooLarge));
        }
    }
    return diff.toString();
}