blob: 62471acde8b379efba0ce20ad30455b0911dd9fe [file] [log] [blame]
// Copyright (C) 2016 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.gerrit.server.mail.send;
import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.gerrit.server.util.AttentionSetUtil.additionsOnly;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ListMultimap;
import com.google.common.flogger.FluentLogger;
import com.google.gerrit.common.Nullable;
import com.google.gerrit.entities.Account;
import com.google.gerrit.entities.Address;
import com.google.gerrit.entities.AttentionSetUpdate;
import com.google.gerrit.entities.BranchNameKey;
import com.google.gerrit.entities.Change;
import com.google.gerrit.entities.ChangeSizeBucket;
import com.google.gerrit.entities.NotifyConfig.NotifyType;
import com.google.gerrit.entities.Patch;
import com.google.gerrit.entities.PatchSet;
import com.google.gerrit.entities.PatchSetInfo;
import com.google.gerrit.entities.Project;
import com.google.gerrit.exceptions.EmailException;
import com.google.gerrit.exceptions.StorageException;
import com.google.gerrit.extensions.api.changes.NotifyHandling;
import com.google.gerrit.extensions.api.changes.RecipientType;
import com.google.gerrit.extensions.client.GeneralPreferencesInfo.EmailStrategy;
import com.google.gerrit.extensions.restapi.AuthException;
import com.google.gerrit.mail.MailHeader;
import com.google.gerrit.server.StarredChangesUtil;
import com.google.gerrit.server.account.AccountState;
import com.google.gerrit.server.mail.send.ProjectWatch.Watchers;
import com.google.gerrit.server.mail.send.ProjectWatch.Watchers.WatcherList;
import com.google.gerrit.server.notedb.ReviewerStateInternal;
import com.google.gerrit.server.patch.DiffNotAvailableException;
import com.google.gerrit.server.patch.DiffOptions;
import com.google.gerrit.server.patch.FilePathAdapter;
import com.google.gerrit.server.patch.PatchSetInfoNotAvailableException;
import com.google.gerrit.server.patch.filediff.FileDiffOutput;
import com.google.gerrit.server.permissions.ChangePermission;
import com.google.gerrit.server.permissions.GlobalPermission;
import com.google.gerrit.server.permissions.PermissionBackendException;
import com.google.gerrit.server.project.ProjectState;
import com.google.gerrit.server.query.change.ChangeData;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.MessageFormat;
import java.time.Instant;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.stream.Collectors;
import org.apache.http.client.utils.URIBuilder;
import org.apache.james.mime4j.dom.field.FieldName;
import org.eclipse.jgit.diff.DiffFormatter;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.util.RawParseUtils;
import org.eclipse.jgit.util.TemporaryBuffer;
/** Sends an email to one or more interested parties. */
public abstract class ChangeEmail extends OutgoingEmail {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
protected static ChangeData newChangeData(
EmailArguments ea, Project.NameKey project, Change.Id id) {
return ea.changeDataFactory.create(project, id);
}
protected static ChangeData newChangeData(
EmailArguments ea, Project.NameKey project, Change.Id id, ObjectId metaId) {
return ea.changeDataFactory.create(ea.changeNotesFactory.createChecked(project, id, metaId));
}
private final Set<Account.Id> currentAttentionSet;
protected final Change change;
protected final ChangeData changeData;
protected ListMultimap<Account.Id, String> stars;
protected PatchSet patchSet;
protected PatchSetInfo patchSetInfo;
protected String changeMessage;
protected Instant timestamp;
protected BranchNameKey branch;
protected ProjectState projectState;
private Set<Account.Id> authors;
private boolean emailOnlyAuthors;
protected boolean emailOnlyAttentionSetIfEnabled;
// Watchers ignore attention set rules.
protected Set<Account.Id> watcherAccounts = new HashSet<>();
// Watcher can only be an email if it's specified in notify section of ProjectConfig.
protected Set<Address> watcherEmails = new HashSet<>();
protected ChangeEmail(EmailArguments args, String messageClass, ChangeData changeData) {
super(args, messageClass);
this.changeData = changeData;
change = changeData.change();
emailOnlyAuthors = false;
emailOnlyAttentionSetIfEnabled = true;
currentAttentionSet = getAttentionSet();
branch = changeData.change().getDest();
}
@Override
public void setFrom(Account.Id id) {
super.setFrom(id);
// Is the from user in an email squelching group?
try {
args.permissionBackend.absentUser(id).check(GlobalPermission.EMAIL_REVIEWERS);
} catch (AuthException | PermissionBackendException e) {
emailOnlyAuthors = true;
}
}
public void setPatchSet(PatchSet ps) {
patchSet = ps;
}
public void setPatchSet(PatchSet ps, PatchSetInfo psi) {
patchSet = ps;
patchSetInfo = psi;
}
public void setChangeMessage(String cm, Instant t) {
changeMessage = cm;
timestamp = t;
}
/** Format the message body by calling {@link #appendText(String)}. */
@Override
protected void format() throws EmailException {
if (useHtml()) {
appendHtml(soyHtmlTemplate("ChangeHeaderHtml"));
}
appendText(textTemplate("ChangeHeader"));
formatChange();
appendText(textTemplate("ChangeFooter"));
if (useHtml()) {
appendHtml(soyHtmlTemplate("ChangeFooterHtml"));
}
formatFooter();
}
/** Format the message body by calling {@link #appendText(String)}. */
protected abstract void formatChange() throws EmailException;
/**
* Format the message footer by calling {@link #appendText(String)}.
*
* @throws EmailException if an error occurred.
*/
protected void formatFooter() throws EmailException {}
/** Setup the message headers and envelope (TO, CC, BCC). */
@Override
protected void init() throws EmailException {
if (args.projectCache != null) {
projectState = args.projectCache.get(change.getProject()).orElse(null);
} else {
projectState = null;
}
if (patchSet == null) {
try {
patchSet = changeData.currentPatchSet();
} catch (StorageException err) {
patchSet = null;
}
}
if (patchSet != null) {
setHeader(MailHeader.PATCH_SET.fieldName(), patchSet.number() + "");
if (patchSetInfo == null) {
try {
patchSetInfo = args.patchSetInfoFactory.get(changeData.notes(), patchSet.id());
} catch (PatchSetInfoNotAvailableException | StorageException err) {
patchSetInfo = null;
}
}
}
try {
stars = changeData.stars();
} catch (StorageException e) {
throw new EmailException("Failed to load stars for change " + change.getChangeId(), e);
}
super.init();
BranchEmailUtils.setListIdHeader(this, branch);
if (timestamp != null) {
setHeader(FieldName.DATE, timestamp);
}
setChangeSubjectHeader();
setHeader(MailHeader.CHANGE_ID.fieldName(), "" + change.getKey().get());
setHeader(MailHeader.CHANGE_NUMBER.fieldName(), "" + change.getChangeId());
setHeader(MailHeader.PROJECT.fieldName(), "" + change.getProject());
setChangeUrlHeader();
setCommitIdHeader();
if (notify.handling().equals(NotifyHandling.OWNER_REVIEWERS)
|| notify.handling().equals(NotifyHandling.ALL)) {
try {
changeData.reviewersByEmail().byState(ReviewerStateInternal.CC).stream()
.forEach(address -> addByEmail(RecipientType.CC, address));
changeData.reviewersByEmail().byState(ReviewerStateInternal.REVIEWER).stream()
.forEach(address -> addByEmail(RecipientType.CC, address));
} catch (StorageException e) {
throw new EmailException("Failed to add unregistered CCs " + change.getChangeId(), e);
}
}
}
private void setChangeUrlHeader() {
final String u = getChangeUrl();
if (u != null) {
setHeader(MailHeader.CHANGE_URL.fieldName(), "<" + u + ">");
}
}
private void setCommitIdHeader() {
if (patchSet != null) {
setHeader(MailHeader.COMMIT.fieldName(), patchSet.commitId().name());
}
}
private void setChangeSubjectHeader() {
setHeader(FieldName.SUBJECT, textTemplate("ChangeSubject"));
}
private int getInsertionsCount() {
return listModifiedFiles().entrySet().stream()
.filter(e -> !Patch.COMMIT_MSG.equals(e.getKey()))
.map(Map.Entry::getValue)
.map(FileDiffOutput::insertions)
.reduce(0, Integer::sum);
}
private int getDeletionsCount() {
return listModifiedFiles().values().stream()
.map(FileDiffOutput::deletions)
.reduce(0, Integer::sum);
}
/**
* Get a link to the change; null if the server doesn't know its own address or if the address is
* malformed. The link will contain a usp parameter set to "email" to inform the frontend on
* clickthroughs where the link came from.
*/
@Nullable
public String getChangeUrl() {
Optional<String> changeUrl =
args.urlFormatter.get().getChangeViewUrl(change.getProject(), change.getId());
if (!changeUrl.isPresent()) return null;
try {
URI uri = new URIBuilder(changeUrl.get()).addParameter("usp", "email").build();
return uri.toString();
} catch (URISyntaxException e) {
return null;
}
}
public String getChangeMessageThreadId() {
return "<gerrit."
+ change.getCreatedOn().toEpochMilli()
+ "."
+ change.getKey().get()
+ "@"
+ getGerritHost()
+ ">";
}
/** Get the text of the "cover letter". */
public String getCoverLetter() {
if (changeMessage != null) {
return changeMessage.trim();
}
return "";
}
/** Create the change message and the affected file list. */
public String getChangeDetail() {
try {
StringBuilder detail = new StringBuilder();
if (patchSetInfo != null) {
detail.append(patchSetInfo.getMessage().trim()).append("\n");
} else {
detail.append(change.getSubject().trim()).append("\n");
}
if (patchSet != null) {
detail.append("---\n");
// Sort files by name.
TreeMap<String, FileDiffOutput> modifiedFiles = new TreeMap<>(listModifiedFiles());
for (FileDiffOutput fileDiff : modifiedFiles.values()) {
if (fileDiff.newPath().isPresent() && Patch.isMagic(fileDiff.newPath().get())) {
continue;
}
detail
.append(fileDiff.changeType().getCode())
.append(" ")
.append(
FilePathAdapter.getNewPath(
fileDiff.oldPath(), fileDiff.newPath(), fileDiff.changeType()))
.append("\n");
}
detail.append(
MessageFormat.format(
"" //
+ "{0,choice,0#0 files|1#1 file|1<{0} files} changed, " //
+ "{1,choice,0#0 insertions|1#1 insertion|1<{1} insertions}(+), " //
+ "{2,choice,0#0 deletions|1#1 deletion|1<{2} deletions}(-)" //
+ "\n",
modifiedFiles.size() - 1, // -1 to account for the commit message
getInsertionsCount(),
getDeletionsCount()));
detail.append("\n");
}
return detail.toString();
} catch (Exception err) {
logger.atWarning().withCause(err).log("Cannot format change detail");
return "";
}
}
/** Get the patch list corresponding to patch set patchSetId of this change. */
protected Map<String, FileDiffOutput> listModifiedFiles(int patchSetId) {
try {
PatchSet ps;
if (patchSetId == patchSet.number()) {
ps = patchSet;
} else {
ps = args.patchSetUtil.get(changeData.notes(), PatchSet.id(change.getId(), patchSetId));
}
return args.diffOperations.listModifiedFilesAgainstParent(
change.getProject(), ps.commitId(), /* parentNum= */ 0, DiffOptions.DEFAULTS);
} catch (StorageException | DiffNotAvailableException e) {
logger.atSevere().withCause(e).log("Failed to get modified files");
return new HashMap<>();
}
}
/** Get the patch list corresponding to this patch set. */
protected Map<String, FileDiffOutput> listModifiedFiles() {
if (patchSet != null) {
try {
return args.diffOperations.listModifiedFilesAgainstParent(
change.getProject(), patchSet.commitId(), /* parentNum= */ 0, DiffOptions.DEFAULTS);
} catch (DiffNotAvailableException e) {
logger.atSevere().withCause(e).log("Failed to get modified files");
}
} else {
logger.atSevere().log("no patchSet specified");
}
return new HashMap<>();
}
/** Get the project entity the change is in; null if its been deleted. */
protected ProjectState getProjectState() {
return projectState;
}
/** TO or CC all vested parties (change owner, patch set uploader, author). */
protected void addAuthors(RecipientType rt) {
for (Account.Id id : getAuthors()) {
addByAccountId(rt, id);
}
}
/** BCC any user who has starred this change. */
protected void bccStarredBy() {
if (!NotifyHandling.ALL.equals(notify.handling())) {
return;
}
for (Map.Entry<Account.Id, Collection<String>> e : stars.asMap().entrySet()) {
if (e.getValue().contains(StarredChangesUtil.DEFAULT_LABEL)) {
super.addByAccountId(RecipientType.BCC, e.getKey());
}
}
}
/** Include users and groups that want notification of events. */
protected void includeWatchers(NotifyType type) {
includeWatchers(type, true);
}
/** Include users and groups that want notification of events. */
protected void includeWatchers(NotifyType type, boolean includeWatchersFromNotifyConfig) {
try {
Watchers matching = getWatchers(type, includeWatchersFromNotifyConfig);
addWatchers(RecipientType.TO, matching.to);
addWatchers(RecipientType.CC, matching.cc);
addWatchers(RecipientType.BCC, matching.bcc);
} catch (StorageException err) {
// Just don't CC everyone. Better to send a partial message to those
// we already have queued up then to fail deliver entirely to people
// who have a lower interest in the change.
logger.atWarning().withCause(err).log("Cannot BCC watchers for %s", type);
}
}
/** Add users or email addresses to the TO, CC, or BCC list. */
private void addWatchers(RecipientType type, WatcherList watcherList) {
watcherAccounts.addAll(watcherList.accounts);
for (Account.Id user : watcherList.accounts) {
addByAccountId(type, user);
}
watcherEmails.addAll(watcherList.emails);
for (Address addr : watcherList.emails) {
addByEmail(type, addr);
}
}
private final Watchers getWatchers(NotifyType type, boolean includeWatchersFromNotifyConfig) {
if (!NotifyHandling.ALL.equals(notify.handling())) {
return new Watchers();
}
ProjectWatch watch = new ProjectWatch(args, branch.project(), projectState, changeData);
return watch.getWatchers(type, includeWatchersFromNotifyConfig);
}
/** Any user who has published comments on this change. */
protected void ccAllApprovals() {
if (!NotifyHandling.ALL.equals(notify.handling())
&& !NotifyHandling.OWNER_REVIEWERS.equals(notify.handling())) {
return;
}
try {
for (Account.Id id : changeData.reviewers().all()) {
addByAccountId(RecipientType.CC, id);
}
} catch (StorageException err) {
logger.atWarning().withCause(err).log("Cannot CC users that reviewed updated change");
}
}
/** Users who were added as reviewers to this change. */
protected void ccExistingReviewers() {
if (!NotifyHandling.ALL.equals(notify.handling())
&& !NotifyHandling.OWNER_REVIEWERS.equals(notify.handling())) {
return;
}
try {
for (Account.Id id : changeData.reviewers().byState(ReviewerStateInternal.REVIEWER)) {
addByAccountId(RecipientType.CC, id);
}
} catch (StorageException err) {
logger.atWarning().withCause(err).log("Cannot CC users that commented on updated change");
}
}
@Override
protected boolean isRecipientAllowed(Address addr) throws PermissionBackendException {
if (!projectState.statePermitsRead()) {
return false;
}
if (emailOnlyAuthors) {
return false;
}
// If the email is a watcher email, skip permission check. An email can only be a watcher if
// it is specified in notify section of ProjectConfig, so we trust that the recipient is
// allowed.
if (watcherEmails.contains(addr)) {
return true;
}
return args.permissionBackend
.user(args.anonymousUser.get())
.change(changeData)
.test(ChangePermission.READ);
}
@Override
protected boolean isRecipientAllowed(Account.Id to) throws PermissionBackendException {
if (!projectState.statePermitsRead()) {
return false;
}
if (emailOnlyAuthors && !getAuthors().contains(to)) {
return false;
}
// Watchers ignore AttentionSet rules.
if (!watcherAccounts.contains(to)) {
Optional<AccountState> accountState = args.accountCache.get(to);
if (emailOnlyAttentionSetIfEnabled
&& accountState.isPresent()
&& accountState.get().generalPreferences().getEmailStrategy()
== EmailStrategy.ATTENTION_SET_ONLY
&& !currentAttentionSet.contains(to)) {
return false;
}
}
return args.permissionBackend.absentUser(to).change(changeData).test(ChangePermission.READ);
}
/** Lazily finds all users who are authors of any part of this change. */
protected Set<Account.Id> getAuthors() {
if (this.authors != null) {
return this.authors;
}
Set<Account.Id> authors = new HashSet<>();
switch (notify.handling()) {
case NONE:
break;
case ALL:
default:
if (patchSet != null) {
authors.add(patchSet.uploader());
}
if (patchSetInfo != null) {
if (patchSetInfo.getAuthor().getAccount() != null) {
authors.add(patchSetInfo.getAuthor().getAccount());
}
if (patchSetInfo.getCommitter().getAccount() != null) {
authors.add(patchSetInfo.getCommitter().getAccount());
}
}
// $FALL-THROUGH$
case OWNER_REVIEWERS:
case OWNER:
authors.add(change.getOwner());
break;
}
return this.authors = authors;
}
@Override
protected void setupSoyContext() {
super.setupSoyContext();
BranchEmailUtils.addBranchData(this, args, branch);
soyContext.put("changeId", change.getKey().get());
soyContext.put("coverLetter", getCoverLetter());
soyContext.put("fromName", getNameFor(fromId));
soyContext.put("fromEmail", getNameEmailFor(fromId));
soyContext.put("diffLines", getDiffTemplateData(getUnifiedDiff()));
soyContextEmailData.put("unifiedDiff", getUnifiedDiff());
soyContextEmailData.put("changeDetail", getChangeDetail());
soyContextEmailData.put("changeUrl", getChangeUrl());
soyContextEmailData.put("includeDiff", getIncludeDiff());
Map<String, String> changeData = new HashMap<>();
String subject = change.getSubject();
String originalSubject = change.getOriginalSubject();
changeData.put("subject", subject);
changeData.put("originalSubject", originalSubject);
changeData.put("shortSubject", shortenSubject(subject));
changeData.put("shortOriginalSubject", shortenSubject(originalSubject));
changeData.put("ownerName", getNameFor(change.getOwner()));
changeData.put("ownerEmail", getNameEmailFor(change.getOwner()));
changeData.put("changeNumber", Integer.toString(change.getChangeId()));
changeData.put(
"sizeBucket",
ChangeSizeBucket.getChangeSizeBucket(getInsertionsCount() + getDeletionsCount()));
soyContext.put("change", changeData);
Map<String, Object> patchSetData = new HashMap<>();
patchSetData.put("patchSetId", patchSet.number());
patchSetData.put("refName", patchSet.refName());
soyContext.put("patchSet", patchSetData);
Map<String, Object> patchSetInfoData = new HashMap<>();
patchSetInfoData.put("authorName", patchSetInfo.getAuthor().getName());
patchSetInfoData.put("authorEmail", patchSetInfo.getAuthor().getEmail());
soyContext.put("patchSetInfo", patchSetInfoData);
footers.add(MailHeader.CHANGE_ID.withDelimiter() + change.getKey().get());
footers.add(MailHeader.CHANGE_NUMBER.withDelimiter() + change.getChangeId());
footers.add(MailHeader.PATCH_SET.withDelimiter() + patchSet.number());
footers.add(MailHeader.OWNER.withDelimiter() + getNameEmailFor(change.getOwner()));
for (String reviewer : getEmailsByState(ReviewerStateInternal.REVIEWER)) {
footers.add(MailHeader.REVIEWER.withDelimiter() + reviewer);
}
for (String reviewer : getEmailsByState(ReviewerStateInternal.CC)) {
footers.add(MailHeader.CC.withDelimiter() + reviewer);
}
for (Account.Id attentionUser : currentAttentionSet) {
footers.add(MailHeader.ATTENTION.withDelimiter() + getNameEmailFor(attentionUser));
}
if (!currentAttentionSet.isEmpty()) {
// We need names rather than account ids / emails to make it user readable.
soyContext.put(
"attentionSet",
currentAttentionSet.stream().map(this::getNameFor).sorted().collect(toImmutableList()));
}
}
/**
* A shortened subject is the subject limited to 72 characters, with an ellipsis if it exceeds
* that limit.
*/
private static String shortenSubject(String subject) {
if (subject.length() < 73) {
return subject;
}
return subject.substring(0, 69) + "...";
}
private Set<String> getEmailsByState(ReviewerStateInternal state) {
Set<String> reviewers = new TreeSet<>();
try {
for (Account.Id who : changeData.reviewers().byState(state)) {
reviewers.add(getNameEmailFor(who));
}
} catch (StorageException e) {
logger.atWarning().withCause(e).log("Cannot get change reviewers");
}
return reviewers;
}
private Set<Account.Id> getAttentionSet() {
Set<Account.Id> attentionSet = new TreeSet<>();
try {
attentionSet =
additionsOnly(changeData.attentionSet()).stream()
.map(AttentionSetUpdate::account)
.collect(Collectors.toSet());
} catch (StorageException e) {
logger.atWarning().withCause(e).log("Cannot get change attention set");
}
return attentionSet;
}
public boolean getIncludeDiff() {
return args.settings.includeDiff;
}
private static final int HEAP_EST_SIZE = 32 * 1024;
/** Show patch set as unified difference. */
public String getUnifiedDiff() {
Map<String, FileDiffOutput> modifiedFiles;
modifiedFiles = listModifiedFiles();
if (modifiedFiles.isEmpty()) {
// Octopus merges are not well supported for diff output by Gerrit.
// Currently these always have a null oldId in the PatchList.
return "[Empty change (potentially Octopus merge); cannot be formatted as a diff.]\n";
}
int maxSize = args.settings.maximumDiffSize;
TemporaryBuffer.Heap buf = new TemporaryBuffer.Heap(Math.min(HEAP_EST_SIZE, maxSize), maxSize);
try (DiffFormatter fmt = new DiffFormatter(buf)) {
try (Repository git = args.server.openRepository(change.getProject())) {
try {
ObjectId oldId = modifiedFiles.values().iterator().next().oldCommitId();
ObjectId newId = modifiedFiles.values().iterator().next().newCommitId();
if (oldId.equals(ObjectId.zeroId())) {
// DiffOperations returns ObjectId.zeroId if newCommit is a root commit, i.e. has no
// parents.
oldId = null;
}
fmt.setRepository(git);
fmt.setDetectRenames(true);
fmt.format(oldId, newId);
return RawParseUtils.decode(buf.toByteArray());
} catch (IOException e) {
if (JGitText.get().inMemoryBufferLimitExceeded.equals(e.getMessage())) {
return "";
}
logger.atSevere().withCause(e).log("Cannot format patch");
return "";
}
} catch (IOException e) {
logger.atSevere().withCause(e).log("Cannot open repository to format patch");
return "";
}
}
}
/**
* Generate a list of maps representing each line of the unified diff. The line maps will have a
* 'type' key which maps to one of 'common', 'add' or 'remove' and a 'text' key which maps to the
* line's content.
*
* @param sourceDiff the unified diff that we're converting to the map.
* @return map of 'type' to a line's content.
*/
protected static ImmutableList<ImmutableMap<String, String>> getDiffTemplateData(
String sourceDiff) {
ImmutableList.Builder<ImmutableMap<String, String>> result = ImmutableList.builder();
Splitter lineSplitter = Splitter.on(System.getProperty("line.separator"));
for (String diffLine : lineSplitter.split(sourceDiff)) {
ImmutableMap.Builder<String, String> lineData = ImmutableMap.builder();
lineData.put("text", diffLine);
// Skip empty lines and lines that look like diff headers.
if (diffLine.isEmpty() || diffLine.startsWith("---") || diffLine.startsWith("+++")) {
lineData.put("type", "common");
} else {
switch (diffLine.charAt(0)) {
case '+':
lineData.put("type", "add");
break;
case '-':
lineData.put("type", "remove");
break;
default:
lineData.put("type", "common");
break;
}
}
result.add(lineData.build());
}
return result.build();
}
}