Mercurial > hg4j
annotate test/org/tmatesoft/hg/test/TestBlame.java @ 626:5afc7eedb3dd v1.1rc1
@since, TODOs. Tests: add 1 sec to deal with fs timestamp granularity on linux
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Tue, 21 May 2013 19:30:12 +0200 |
parents | b4948b159ab1 |
children | 6526d8adbc0f |
rev | line source |
---|---|
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
2 * Copyright (c) 2013 TMate Software Ltd |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.test; |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
19 import static org.junit.Assert.assertEquals; |
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
20 import static org.junit.Assert.assertTrue; |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
21 import static org.tmatesoft.hg.core.HgIterateDirection.NewToOld; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
22 import static org.tmatesoft.hg.core.HgIterateDirection.OldToNew; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
23 import static org.tmatesoft.hg.repo.HgRepository.NO_REVISION; |
548
ab21ac7dd833
Line-by-line annotation API and support code in place
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
546
diff
changeset
|
24 import static org.tmatesoft.hg.repo.HgRepository.TIP; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
25 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
26 import java.io.ByteArrayOutputStream; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
27 import java.io.File; |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
28 import java.io.IOException; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
29 import java.io.OutputStream; |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
30 import java.io.PrintStream; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
31 import java.util.ArrayList; |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
32 import java.util.Arrays; |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
33 import java.util.LinkedHashSet; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
34 import java.util.LinkedList; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
35 import java.util.List; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
36 import java.util.ListIterator; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
37 import java.util.regex.Matcher; |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
38 import java.util.regex.Pattern; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
39 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
40 import org.junit.Assert; |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
41 import org.junit.Rule; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
42 import org.junit.Test; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
43 import org.tmatesoft.hg.core.HgAnnotateCommand; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
44 import org.tmatesoft.hg.core.HgAnnotateCommand.LineInfo; |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
45 import org.tmatesoft.hg.core.HgCallbackTargetException; |
552
45751456b471
Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
549
diff
changeset
|
46 import org.tmatesoft.hg.core.HgIterateDirection; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
47 import org.tmatesoft.hg.core.HgRepoFacade; |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
48 import org.tmatesoft.hg.core.Nodeid; |
555
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
49 import org.tmatesoft.hg.internal.FileAnnotation; |
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
50 import org.tmatesoft.hg.internal.FileAnnotation.LineDescriptor; |
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
51 import org.tmatesoft.hg.internal.FileAnnotation.LineInspector; |
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
52 import org.tmatesoft.hg.internal.IntVector; |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
53 import org.tmatesoft.hg.repo.HgBlameInspector; |
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
54 import org.tmatesoft.hg.repo.HgBlameInspector.BlockData; |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
55 import org.tmatesoft.hg.repo.HgChangelog; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
56 import org.tmatesoft.hg.repo.HgDataFile; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
57 import org.tmatesoft.hg.repo.HgLookup; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
58 import org.tmatesoft.hg.repo.HgRepository; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
59 import org.tmatesoft.hg.util.Path; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
61 /** |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
62 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
63 * @author Artem Tikhomirov |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
64 * @author TMate Software Ltd. |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
65 */ |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
66 public class TestBlame { |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
67 |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
68 @Rule |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
69 public ErrorCollectorExt errorCollector = new ErrorCollectorExt(); |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
70 |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
71 |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
72 @Test |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
73 public void testSingleParentBlame() throws Exception { |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
74 HgRepository repo = new HgLookup().detectFromWorkingDir(); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
75 final String fname = "src/org/tmatesoft/hg/internal/PatchGenerator.java"; |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
76 final int checkChangeset = repo.getChangelog().getRevisionIndex(Nodeid.fromAscii("946b131962521f9199e1fedbdc2487d3aaef5e46")); // 539 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
77 HgDataFile df = repo.getFileNode(fname); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
78 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
79 df.annotateSingleRevision(checkChangeset, new DiffOutInspector(new PrintStream(bos))); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
80 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
81 ExecHelper eh = new ExecHelper(gp, null); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
82 eh.run("hg", "diff", "-c", String.valueOf(checkChangeset), "-U", "0", fname); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
83 // |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
84 String[] apiResult = splitLines(bos.toString()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
85 String[] expected = splitLines(gp.result()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
86 Assert.assertArrayEquals(expected, apiResult); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
87 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
88 |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
89 @Test |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
90 public void testFileLineAnnotate1() throws Exception { |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
91 HgRepository repo = new HgLookup().detectFromWorkingDir(); |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
92 final String fname = "src/org/tmatesoft/hg/internal/PatchGenerator.java"; |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
93 HgDataFile df = repo.getFileNode(fname); |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
94 AnnotateRunner ar = new AnnotateRunner(df.getPath(), null); |
548
ab21ac7dd833
Line-by-line annotation API and support code in place
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
546
diff
changeset
|
95 |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
96 final HgChangelog clog = repo.getChangelog(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
97 final int[] toTest = new int[] { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
98 clog.getRevisionIndex(Nodeid.fromAscii("946b131962521f9199e1fedbdc2487d3aaef5e46")), // 539 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
99 clog.getRevisionIndex(Nodeid.fromAscii("1e95f48d9886abe79b9711ab371bc877ca5e773e")), // 541 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
100 /*, TIP */}; |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
101 for (int cs : toTest) { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
102 ar.run(cs, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
103 FileAnnotateInspector fa = new FileAnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
104 FileAnnotation.annotate(df, cs, fa); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
105 doAnnotateLineCheck(cs, ar.getLines(), Arrays.asList(fa.lineRevisions), Arrays.asList(fa.lines)); |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
106 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
107 } |
548
ab21ac7dd833
Line-by-line annotation API and support code in place
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
546
diff
changeset
|
108 |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
109 @Test |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
110 public void testFileLineAnnotate2() throws Exception { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
111 HgRepository repo = Configuration.get().find("test-annotate"); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
112 HgDataFile df = repo.getFileNode("file1"); |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
113 AnnotateRunner ar = new AnnotateRunner(df.getPath(), repo.getWorkingDir()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
114 |
558
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
115 for (int cs : new int[] { 4, 6 /*, 8 see below*/, TIP}) { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
116 ar.run(cs, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
117 FileAnnotateInspector fa = new FileAnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
118 FileAnnotation.annotate(df, cs, fa); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
119 doAnnotateLineCheck(cs, ar.getLines(), Arrays.asList(fa.lineRevisions), Arrays.asList(fa.lines)); |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
120 } |
558
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
121 /*`hg annotate -r 8` and HgBlameFacility give different result |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
122 * for "r0, line 5" line, which was deleted in rev2 and restored back in |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
123 * rev4 (both in default branch), while branch with r3 and r6 kept the line intact. |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
124 * HgBlame reports rev4 for the line, `hg annotate` gives original, rev0. |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
125 * However `hg annotate -r 4` shows rev4 for the line, too. The aforementioned rev0 for |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
126 * the merge rev8 results from the iteration order and is implementation specific |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
127 * (i.e. one can't tell which one is right). Mercurial walks from parents to children, |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
128 * and traces equal lines, wile HgBlameFacility walks from child to parents and records |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
129 * changes (additions). Seems it processes branch with rev3 and rev6 first |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
130 * (printout in context.py, annotate and annotate.pair reveals that), and the line 0_5 |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
131 * comes as unchanged through this branch, and later processing rev2 and rev4 doesn't |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
132 * change that. |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
133 */ |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
134 } |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
135 |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
136 @Test |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
137 public void testComplexHistoryAnnotate() throws Exception { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
138 HgRepository repo = Configuration.get().find("test-annotate"); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
139 HgDataFile df = repo.getFileNode("file1"); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
140 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
141 DiffOutInspector dump = new DiffOutInspector(new PrintStream(bos)); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
142 df.annotate(TIP, dump, HgIterateDirection.OldToNew); |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
143 LinkedList<String> apiResult = new LinkedList<String>(Arrays.asList(splitLines(bos.toString()))); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
144 |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
145 /* |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
146 * FIXME this is an ugly hack to deal with the way `hg diff -c <mergeRev>` describes the change |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
147 * and our merge handling approach. For merged revision m, and lines changed both in p1 and p2 |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
148 * we report lines from p2 as pure additions, regardless of intersecting p1 changes (which |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
149 * are reported as deletions, if no sufficient changed lines in m found) |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
150 * So, here we try to combine deletion that follows a change (based on identical insertionPoint) |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
151 * into a single change |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
152 * To fix, need to find better approach to find out reference info (i.e. `hg diff -c` is flawed in this case, |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
153 * as it uses first parent only). |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
154 */ |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
155 Pattern fix = Pattern.compile("@@ -(\\d+),(\\d+) \\+(\\d+),(\\d+) @@"); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
156 int v1, v2, v3, v4; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
157 v1 = v2 = v3 = v4 = -1; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
158 for (ListIterator<String> it = apiResult.listIterator(); it.hasNext();) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
159 String n = it.next(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
160 Matcher m = fix.matcher(n); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
161 if (m.find()) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
162 int d1 = Integer.parseInt(m.group(1)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
163 int d2 = Integer.parseInt(m.group(2)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
164 int d3 = Integer.parseInt(m.group(3)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
165 int d4 = Integer.parseInt(m.group(4)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
166 if (v1 == d1 && d4 == 0) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
167 it.previous(); // shift to current element |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
168 it.previous(); // to real previous |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
169 it.remove(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
170 it.next(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
171 it.set(String.format("@@ -%d,%d +%d,%d @@", v1, v2+d2, v3, v4)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
172 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
173 v1 = d1; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
174 v2 = d2; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
175 v3 = d3; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
176 v4 = d4; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
177 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
178 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
179 |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
180 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
181 ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
182 for (int cs : dump.getReportedTargetRevisions()) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
183 gp.reset(); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
184 eh.run("hg", "diff", "-c", String.valueOf(cs), "-U", "0", df.getPath().toString()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
185 for (String expected : splitLines(gp.result())) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
186 if (!apiResult.remove(expected)) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
187 errorCollector.fail(String.format("Expected diff output '%s' for changes in revision %d", expected, cs)); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
188 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
189 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
190 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
191 errorCollector.assertTrue(String.format("Annotate API reported excessive diff: %s ", apiResult.toString()), apiResult.isEmpty()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
192 } |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
193 |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
194 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
195 @Test |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
196 public void testPartialHistoryFollow() throws Exception { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
197 HgRepository repo = Configuration.get().find("test-annotate2"); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
198 HgDataFile df = repo.getFileNode("file1b.txt"); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
199 // rev3: file1 -> file1a, rev7: file1a -> file1b, tip: rev10 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
200 DiffOutInspector insp = new DiffOutInspector(new PrintStream(new OutputStream() { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
201 @Override |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
202 public void write(int b) throws IOException { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
203 // NULL OutputStream |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
204 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
205 })); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
206 // rev6 changes rev4, rev4 changes rev3. Plus, anything changed |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
207 // earlier than rev2 shall be reported as new from change3 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
208 int[] change_2_8_new2old = new int[] {4, 6, 3, 4, -1, 3}; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
209 int[] change_2_8_old2new = new int[] {-1, 3, 3, 4, 4, 6 }; |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
210 df.annotate(2, 8, insp, NewToOld); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
211 Assert.assertArrayEquals(change_2_8_new2old, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
212 insp.reset(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
213 df.annotate(2, 8, insp, OldToNew); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
214 Assert.assertArrayEquals(change_2_8_old2new, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
215 // same as 2 to 8, with addition of rev9 changes rev7 (rev6 to rev7 didn't change content, only name) |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
216 int[] change_3_9_new2old = new int[] {7, 9, 4, 6, 3, 4, -1, 3 }; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
217 int[] change_3_9_old2new = new int[] {-1, 3, 3, 4, 4, 6, 7, 9 }; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
218 insp.reset(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
219 df.annotate(3, 9, insp, NewToOld); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
220 Assert.assertArrayEquals(change_3_9_new2old, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
221 insp.reset(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
222 df.annotate(3, 9, insp, OldToNew); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
223 Assert.assertArrayEquals(change_3_9_old2new, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
224 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
225 |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
226 @Test |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
227 public void testAnnotateCmdFollowNoFollow() throws Exception { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
228 HgRepoFacade hgRepoFacade = new HgRepoFacade(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
229 HgRepository repo = Configuration.get().find("test-annotate2"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
230 hgRepoFacade.init(repo); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
231 HgAnnotateCommand cmd = hgRepoFacade.createAnnotateCommand(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
232 final Path fname = Path.create("file1b.txt"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
233 final int changeset = TIP; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
234 AnnotateInspector ai = new AnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
235 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
236 cmd.changeset(changeset); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
237 // follow |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
238 cmd.file(fname); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
239 cmd.execute(ai); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
240 AnnotateRunner ar = new AnnotateRunner(fname, repo.getWorkingDir()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
241 ar.run(changeset, true); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
242 doAnnotateLineCheck(changeset, ar.getLines(), ai.changesets, ai.lines); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
243 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
244 // no follow |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
245 cmd.file(fname, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
246 ai = new AnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
247 cmd.execute(ai); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
248 ar.run(changeset, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
249 doAnnotateLineCheck(changeset, ar.getLines(), ai.changesets, ai.lines); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
250 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
251 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
252 private void doAnnotateLineCheck(int cs, String[] hgAnnotateLines, List<Integer> cmdChangesets, List<String> cmdLines) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
253 assertTrue("[sanity]", hgAnnotateLines.length > 0); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
254 assertEquals("Number of lines reported by native annotate and our impl", hgAnnotateLines.length, cmdLines.size()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
255 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
256 for (int i = 0; i < cmdChangesets.size(); i++) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
257 int hgAnnotateRevIndex = Integer.parseInt(hgAnnotateLines[i].substring(0, hgAnnotateLines[i].indexOf(':')).trim()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
258 errorCollector.assertEquals(String.format("Revision mismatch for line %d (annotating rev: %d)", i+1, cs), hgAnnotateRevIndex, cmdChangesets.get(i)); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
259 String hgAnnotateLine = hgAnnotateLines[i].substring(hgAnnotateLines[i].indexOf(':') + 1); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
260 String apiLine = cmdLines.get(i).trim(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
261 errorCollector.assertEquals(hgAnnotateLine.trim(), apiLine); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
262 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
263 } |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
264 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
265 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
266 @Test |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
267 public void testDiffTwoRevisions() throws Exception { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
268 HgRepository repo = Configuration.get().find("test-annotate"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
269 HgDataFile df = repo.getFileNode("file1"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
270 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
271 ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
272 int[] toTest = { 3, 4, 5 }; // p1 ancestry line, p2 ancestry line, not in ancestry line |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
273 for (int cs : toTest) { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
274 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
275 df.diff(cs, 8, new DiffOutInspector(new PrintStream(bos))); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
276 eh.run("hg", "diff", "-r", String.valueOf(cs), "-r", "8", "-U", "0", df.getPath().toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
277 // |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
278 String[] apiResult = splitLines(bos.toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
279 String[] expected = splitLines(gp.result()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
280 Assert.assertArrayEquals(expected, apiResult); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
281 gp.reset(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
282 } |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
283 } |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
284 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
285 /** |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
286 * Make sure boundary values are ok (down to BlameHelper#prepare and FileHistory) |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
287 */ |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
288 @Test |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
289 public void testAnnotateFirstFileRev() throws Exception { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
290 HgRepository repo = Configuration.get().find("test-annotate"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
291 HgDataFile df = repo.getFileNode("file1"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
292 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
293 ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
294 eh.run("hg", "diff", "-c", "0", "-U", "0", df.getPath().toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
295 // |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
296 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
297 df.annotateSingleRevision(0, new DiffOutInspector(new PrintStream(bos))); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
298 // |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
299 String[] apiResult = splitLines(bos.toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
300 String[] expected = splitLines(gp.result()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
301 Assert.assertArrayEquals(expected, apiResult); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
302 } |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
303 |
624
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
603
diff
changeset
|
304 // TODO HgWorkingCopyStatusCollector (and HgStatusCollector), with their ancestors (rev 59/69) have examples |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
305 // of *incorrect* assignment of common lines (like "}") - our impl doesn't process common lines in any special way |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
306 // while original diff lib does. Would be nice to behave as close to original, as possible. |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
307 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
308 private static String[] splitLines(CharSequence seq) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
309 int lineCount = 0; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
310 for (int i = 0, x = seq.length(); i < x; i++) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
311 if (seq.charAt(i) == '\n') { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
312 lineCount++; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
313 } |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
314 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
315 if (seq.length() > 0 && seq.charAt(seq.length()-1) != '\n') { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
316 lineCount++; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
317 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
318 String[] rv = new String[lineCount]; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
319 int lineStart = 0, lineEnd = 0, ix = 0; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
320 do { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
321 while (lineEnd < seq.length() && seq.charAt(lineEnd) != '\n') lineEnd++; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
322 if (lineEnd == lineStart) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
323 continue; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
324 } |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
325 CharSequence line = seq.subSequence(lineStart, lineEnd); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
326 rv[ix++] = line.toString(); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
327 lineStart = ++lineEnd; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
328 } while (lineStart < seq.length()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
329 assert ix == lineCount; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
330 return rv; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
331 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
332 |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
333 |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
334 private void ccc() throws Throwable { |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
335 HgRepository repo = new HgLookup().detect("/home/artem/hg/hgtest-annotate-merge/"); |
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
336 HgDataFile df = repo.getFileNode("file.txt"); |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
337 DiffOutInspector dump = new DiffOutInspector(System.out); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
338 dump.needRevisions(true); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
339 df.annotate(8, dump, HgIterateDirection.NewToOld); |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
340 // af.annotateSingleRevision(df, 113, dump); |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
341 // System.out.println(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
342 // af.annotate(df, TIP, new LineDumpInspector(true), HgIterateDirection.NewToOld); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
343 // System.out.println(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
344 // af.annotate(df, TIP, new LineDumpInspector(false), HgIterateDirection.NewToOld); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
345 // System.out.println(); |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
346 /* |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
347 OutputParser.Stub op = new OutputParser.Stub(); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
348 eh = new ExecHelper(op, repo.getWorkingDir()); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
349 for (int cs : new int[] { 24, 46, 49, 52, 59, 62, 64, TIP}) { |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
350 doLineAnnotateTest(df, cs, op); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
351 } |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
352 errorCollector.verify(); |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
353 */ |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
354 FileAnnotateInspector fa = new FileAnnotateInspector(); |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
355 FileAnnotation.annotate(df, 8, fa); |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
356 for (int i = 0; i < fa.lineRevisions.length; i++) { |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
357 System.out.printf("%d: %s", fa.lineRevisions[i], fa.line(i) == null ? "null\n" : fa.line(i)); |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
358 } |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
359 } |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
360 |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
361 public static void main(String[] args) throws Throwable { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
362 TestBlame tt = new TestBlame(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
363 tt.ccc(); |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
364 } |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
365 |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
366 private static class DiffOutInspector implements HgBlameInspector { |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
367 private final PrintStream out; |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
368 private boolean dumpRevs; |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
369 private IntVector reportedRevisionPairs = new IntVector(); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
370 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
371 DiffOutInspector(PrintStream ps) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
372 out = ps; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
373 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
374 |
554
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
375 // Note, true makes output incompatible with 'hg diff' |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
376 public void needRevisions(boolean dumpRevs) { |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
377 this.dumpRevs = dumpRevs; |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
378 } |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
379 |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
380 private void printRevs(Block b) { |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
381 if (dumpRevs) { |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
382 out.printf("[%3d -> %3d] ", b.originChangesetIndex(), b.targetChangesetIndex()); |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
383 } |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
384 reportedRevisionPairs.add(b.originChangesetIndex(), b.targetChangesetIndex()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
385 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
386 |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
387 int[] getReportedTargetRevisions() { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
388 LinkedHashSet<Integer> rv = new LinkedHashSet<Integer>(); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
389 for (int i = 1; i < reportedRevisionPairs.size(); i += 2) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
390 rv.add(reportedRevisionPairs.get(i)); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
391 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
392 int[] x = new int[rv.size()]; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
393 int i = 0; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
394 for (int v : rv) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
395 x[i++] = v; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
396 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
397 return x; |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
398 } |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
399 |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
400 int[] getReportedRevisionPairs() { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
401 return reportedRevisionPairs.toArray(); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
402 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
403 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
404 void reset() { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
405 reportedRevisionPairs.clear(); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
406 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
407 |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
408 public void same(EqualBlock block) { |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
409 // nothing |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
410 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
411 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
412 public void deleted(DeleteBlock block) { |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
413 printRevs(block); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
414 out.printf("@@ -%d,%d +%d,0 @@\n", block.firstRemovedLine() + 1, block.totalRemovedLines(), block.removedAt()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
415 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
416 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
417 public void changed(ChangeBlock block) { |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
418 printRevs(block); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
419 out.printf("@@ -%d,%d +%d,%d @@\n", block.firstRemovedLine() + 1, block.totalRemovedLines(), block.firstAddedLine() + 1, block.totalAddedLines()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
420 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
421 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
422 public void added(AddBlock block) { |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
423 printRevs(block); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
424 out.printf("@@ -%d,0 +%d,%d @@\n", block.insertedAt(), block.firstAddedLine() + 1, block.totalAddedLines()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
425 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
426 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
427 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
428 public static class LineGrepOutputParser implements OutputParser { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
429 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
430 private final Pattern pattern; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
431 private final StringBuilder result = new StringBuilder(); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
432 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
433 public LineGrepOutputParser(String regexp) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
434 pattern = Pattern.compile(regexp); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
435 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
436 |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
437 public void reset() { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
438 result.setLength(0); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
439 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
440 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
441 public CharSequence result() { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
442 return result; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
443 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
444 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
445 public void parse(CharSequence seq) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
446 int lineStart = 0, lineEnd = 0; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
447 do { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
448 while (lineEnd < seq.length() && seq.charAt(lineEnd) != '\n') lineEnd++; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
449 if (lineEnd == lineStart) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
450 continue; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
451 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
452 CharSequence line = seq.subSequence(lineStart, lineEnd); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
453 if (pattern.matcher(line).matches()) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
454 result.append(line); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
455 result.append('\n'); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
456 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
457 lineStart = ++lineEnd; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
458 } while (lineStart < seq.length()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
459 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
460 } |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
461 |
555
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
462 private static class FileAnnotateInspector implements LineInspector { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
463 private Integer[] lineRevisions; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
464 private String[] lines; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
465 |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
466 FileAnnotateInspector() { |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
467 } |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
468 |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
469 public void line(int lineNumber, int changesetRevIndex, BlockData lineContent, LineDescriptor ld) { |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
470 if (lineRevisions == null) { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
471 lineRevisions = new Integer[ld.totalLines()]; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
472 Arrays.fill(lineRevisions, NO_REVISION); |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
473 lines = new String[ld.totalLines()]; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
474 } |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
475 lineRevisions[lineNumber] = changesetRevIndex; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
476 lines[lineNumber] = new String(lineContent.asArray()); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
477 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
478 |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
479 public String line(int i) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
480 return lines[i]; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
481 } |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
482 } |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
483 |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
484 @SuppressWarnings("unused") |
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
485 private static class LineDumpInspector implements HgBlameInspector { |
554
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
486 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
487 private final boolean lineByLine; |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
488 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
489 public LineDumpInspector(boolean lineByLine) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
490 this.lineByLine = lineByLine; |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
491 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
492 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
493 public void same(EqualBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
494 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
495 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
496 public void added(AddBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
497 BlockData lines = block.addedLines(); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
498 printBlock(lines, block.targetChangesetIndex(), block.firstAddedLine(), block.totalAddedLines(), "+++"); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
499 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
500 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
501 public void changed(ChangeBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
502 deleted(block); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
503 added(block); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
504 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
505 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
506 public void deleted(DeleteBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
507 BlockData lines = block.removedLines(); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
508 assert lines.elementCount() == block.totalRemovedLines(); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
509 printBlock(lines, block.originChangesetIndex(), block.firstRemovedLine(), block.totalRemovedLines(), "---"); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
510 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
511 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
512 private void printBlock(BlockData lines, int cset, int first, int length, String marker) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
513 assert lines.elementCount() == length; |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
514 if (lineByLine) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
515 for (int i = 0, ln = first; i < length; i++, ln++) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
516 String line = new String(lines.elementAt(i).asArray()); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
517 System.out.printf("%3d:%3d:%s:%s", cset, ln, marker, line); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
518 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
519 } else { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
520 String content = new String(lines.asArray()); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
521 System.out.printf("%3d:%s:[%d..%d):\n%s", cset, marker, first, first+length, content); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
522 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
523 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
524 } |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
525 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
526 static class AnnotateInspector implements HgAnnotateCommand.Inspector { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
527 private int lineNumber = 1; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
528 public final ArrayList<String> lines = new ArrayList<String>(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
529 public final ArrayList<Integer> changesets = new ArrayList<Integer>(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
530 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
531 public void next(LineInfo lineInfo) throws HgCallbackTargetException { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
532 Assert.assertEquals(lineInfo.getLineNumber(), lineNumber); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
533 lineNumber++; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
534 lines.add(new String(lineInfo.getContent())); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
535 changesets.add(lineInfo.getChangesetIndex()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
536 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
537 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
538 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
539 private static class AnnotateRunner { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
540 private final ExecHelper eh; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
541 private final OutputParser.Stub op; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
542 private final Path file; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
543 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
544 public AnnotateRunner(Path filePath, File repoDir) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
545 file = filePath; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
546 op = new OutputParser.Stub(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
547 eh = new ExecHelper(op, repoDir); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
548 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
549 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
550 public void run(int cset, boolean follow) throws Exception { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
551 op.reset(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
552 ArrayList<String> args = new ArrayList<String>(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
553 args.add("hg"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
554 args.add("annotate"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
555 args.add("-r"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
556 args.add(cset == TIP ? "tip" : String.valueOf(cset)); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
557 if (!follow) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
558 args.add("--no-follow"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
559 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
560 args.add(file.toString()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
561 eh.run(args); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
562 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
563 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
564 public String[] getLines() { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
565 return splitLines(op.result()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
566 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
567 } |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
568 } |