Public Git Hosting - egit/eclipse.git/blob - org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/commit/DiffDocument.java

1 /*******************************************************************************

5 * are made available under the terms of the Eclipse Public License 2.0

6 * which accompanies this distribution, and is available at

7 * https://www.eclipse.org/legal/epl-2.0/

9 * SPDX-License-Identifier: EPL-2.0

10 *******************************************************************************/

package org.eclipse.egit.ui.internal.commit;

13 import java.util.Arrays;

import java.util.regex.Pattern;

import org.eclipse.core.runtime.Assert;

import org.eclipse.egit.ui.internal.commit.DiffRegionFormatter.DiffRegion;

import org.eclipse.egit.ui.internal.commit.DiffRegionFormatter.FileDiffRegion;

import org.eclipse.egit.ui.internal.history.FileDiff;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.Document;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.IDocumentPartitioner;

import org.eclipse.jface.text.Region;

import org.eclipse.jface.text.TextUtilities;

import org.eclipse.jface.text.rules.FastPartitioner;

import org.eclipse.jface.text.rules.IPartitionTokenScanner;

import org.eclipse.jface.text.rules.IToken;

import org.eclipse.jface.text.rules.Token;

import org.eclipse.jgit.annotations.NonNull;

import org.eclipse.jgit.diff.DiffEntry;

import org.eclipse.jgit.lib.Repository;

34 /**

35 * A {@link Document} specialized for displaying unified diffs generated by a

36 * {@link DiffRegionFormatter}. Intended usage is to create a DiffDocument, let

37 * a DiffRegionFormatter generate into it, and then

38 * {@link #connect(DiffRegionFormatter) connect()} the formatter. This will

39 * partition the document into regions for file headlines, hunks, and added or

40 * removed lines.

41 */

42 public class DiffDocument extends Document {

        static final String HEADLINE_CONTENT_TYPE = "_egit_diff_headline"; //$NON-NLS-1$

        static final String HUNK_CONTENT_TYPE = "_egit_diff_hunk"; //$NON-NLS-1$

        static final String ADDED_CONTENT_TYPE = "_egit_diff_added"; //$NON-NLS-1$

        static final String REMOVED_CONTENT_TYPE = "_egit_diff_removed"; //$NON-NLS-1$

52 private DiffRegion[] regions;

54 private FileDiffRegion[] fileRegions;

56 private Pattern newPathPattern;

58 private Pattern oldPathPattern;

60 private FileDiff defaultFileDiff;

62 private int[] maximumLineNumbers;

64 /**

65 * Creates a new {@link DiffDocument}.

66 */

67 public DiffDocument() {

68 super();

69 }

71 /**

72 * Creates a new {@link DiffDocument} with initial text.

73 *

74 * @param text

75 * to set on the document

76 */

77 public DiffDocument(String text) {

78 super(text);

79 }

81 /**

82 * Sets up the document to use information from the given

83 * {@link DiffRegionFormatter} for partitioning the document into

84 * partitions for file headlines, hunk headers, and added or removed lines.

85 * It is assumed that the given formatter has been used to generate content

86 * into the document.

87 *

88 * @param formatter

89 * to obtain information from

90 */

91 public void connect(DiffRegionFormatter formatter) {

92 regions = formatter.getRegions();

93 fileRegions = formatter.getFileRegions();

                if (fileRegions == null || fileRegions.length == 0) {

95 FileDiff implicitFileDiff = defaultFileDiff;

                        if (implicitFileDiff != null) {

97 fileRegions = new FileDiffRegion[] {

                                                new FileDiffRegion(implicitFileDiff, 0, getLength()) };

99 }

100 }

101 newPathPattern = Pattern.compile(

                                Pattern.quote(formatter.getNewPrefix()) + "\\S+"); //$NON-NLS-1$

103 oldPathPattern = Pattern.compile(

                                Pattern.quote(formatter.getOldPrefix()) + "\\S+"); //$NON-NLS-1$

105 maximumLineNumbers = formatter.getMaximumLineNumbers();

106 // Connect a new partitioner.

107 IDocumentPartitioner partitioner = new FastPartitioner(

108 new DiffPartitionTokenScanner(),

109 new String[] { IDocument.DEFAULT_CONTENT_TYPE,

110 HEADLINE_CONTENT_TYPE, HUNK_CONTENT_TYPE,

111 ADDED_CONTENT_TYPE, REMOVED_CONTENT_TYPE });

112 IDocumentPartitioner oldPartitioner = getDocumentPartitioner();

                if (oldPartitioner != null) {

114 oldPartitioner.disconnect();

115 }

                partitioner.connect(this);

117 setDocumentPartitioner(partitioner);

118 }

119

120 /**

121 * Provide default settings about the {@link Repository} and

122 * {@link FileDiff}, to be used in the absence of explicit information from

123 * a connected {@link DiffRegionFormatter}. Useful if the document is

124 * used for only individual edits from a file.

125 *

126 * @param fileDiff

127 * to use if none set explicitly

128 */

        public void setDefault(@NonNull FileDiff fileDiff) {

130 defaultFileDiff = fileDiff;

131 }

132

133 DiffRegion[] getRegions() {

134 return regions;

135 }

136

137 FileDiffRegion[] getFileRegions() {

138 return fileRegions;

139 }

140

        int getMaximumLineNumber(@NonNull DiffEntry.Side side) {

                if (maximumLineNumbers == null) {

143 return DiffRegion.NO_LINE;

144 }

                if (DiffEntry.Side.OLD.equals(side)) {

146 return maximumLineNumbers[0];

147 }

148 return maximumLineNumbers[1];

149 }

150

        private int findRegionIndex(int offset) {

                DiffRegion key = new DiffRegion(offset, 0);

                return Arrays.binarySearch(regions, key, (a, b) -> {

                        if (!TextUtilities.overlaps(a, b)) {

                                return a.getOffset() - b.getOffset();

156 }

157 return 0;

158 });

159 }

160

161 DiffRegion findRegion(int offset) {

                int i = findRegionIndex(offset);

                return i >= 0 ? regions[i] : null;

164 }

165

166 FileDiffRegion findFileRegion(int offset) {

                Region key = new Region(offset, 0);

                int i = Arrays.binarySearch(fileRegions, key, (a, b) -> {

                        if (!TextUtilities.overlaps(a, b)) {

                                return a.getOffset() - b.getOffset();

171 }

172 return 0;

173 });

                return i >= 0 ? fileRegions[i] : null;

175 }

176

        int getLogicalLine(int physicalLine, @NonNull DiffEntry.Side side) {

178 int offset;

179 try {

180 offset = getLineOffset(physicalLine);

181 DiffRegion region = findRegion(offset);

                        if (region == null) {

183 return DiffRegion.NO_LINE;

184 }

                        int logicalStart = region.getLine(side);

                        if (logicalStart == DiffRegion.NO_LINE) {

187 return DiffRegion.NO_LINE;

188 }

                        int physicalStart = getLineOfOffset(region.getOffset());

190 return logicalStart + (physicalLine - physicalStart);

191 } catch (BadLocationException e) {

192 return DiffRegion.NO_LINE;

193 }

194 }

195

        Pattern getPathPattern(@NonNull DiffEntry.Side side) {

197 switch (side) {

198 case OLD:

199 return oldPathPattern;

200 default:

201 return newPathPattern;

202 }

203 }

204

205 private class DiffPartitionTokenScanner implements IPartitionTokenScanner {

206

                private final Token HEADLINE_TOKEN = new Token(HEADLINE_CONTENT_TYPE);

208

                private final Token HUNK_TOKEN = new Token(HUNK_CONTENT_TYPE);

210

                private final Token ADDED_TOKEN = new Token(ADDED_CONTENT_TYPE);

212

                private final Token DELETED_TOKEN = new Token(REMOVED_CONTENT_TYPE);

214

                private final Token OTHER_TOKEN = new Token(

216 IDocument.DEFAULT_CONTENT_TYPE);

217

218 private int currentOffset;

219

220 private int end;

221

222 private int tokenStart;

223

224 private int currIdx;

225

226 @Override

                public void setRange(IDocument document, int offset, int length) {

                        Assert.isLegal(document == DiffDocument.this);

229 currentOffset = offset;

230 end = offset + length;

231 tokenStart = -1;

232 }

233

234 @Override

235 public IToken nextToken() {

                        if (tokenStart < 0) {

237 currIdx = findRegionIndex(currentOffset);

                                if (currIdx < 0) {

239 currIdx = -(currIdx + 1);

240 }

241 }

242 tokenStart = currentOffset;

243 if (currentOffset < end) {

                                if (currIdx >= DiffDocument.this.regions.length) {

245 currentOffset = end;

246 return OTHER_TOKEN;

247 }

                                if (currentOffset < DiffDocument.this.regions[currIdx]

249 .getOffset()) {

                                        currentOffset = DiffDocument.this.regions[currIdx]

251 .getOffset();

252 return OTHER_TOKEN;

253 }

254 // We're in range[currIdx]. Typically at the beginning, but if

255 // called via setPartialRange, we may also be somewhere in the

256 // middle.

                                currentOffset += DiffDocument.this.regions[currIdx].getLength()

258 - (currentOffset

                                                                - DiffDocument.this.regions[currIdx]

260 .getOffset());

                                switch (DiffDocument.this.regions[currIdx++].getType()) {

262 case HEADLINE:

263 return HEADLINE_TOKEN;

264 case HUNK:

265 return HUNK_TOKEN;

266 case ADD:

267 return ADDED_TOKEN;

268 case REMOVE:

269 return DELETED_TOKEN;

270 default:

271 return OTHER_TOKEN;

272 }

273 }

274 return Token.EOF;

275 }

276

277 @Override

278 public int getTokenOffset() {

279 return tokenStart;

280 }

281

282 @Override

283 public int getTokenLength() {

284 return currentOffset - tokenStart;

285 }

286

287 @Override

                public void setPartialRange(IDocument document, int offset, int length,

289 String contentType, int partitionOffset) {

                        setRange(document, offset, length);

291 }

292

293 }

294 }