Mercurial > jhg
annotate cmdline/org/tmatesoft/hg/console/Main.java @ 582:90df078d6418
Delegate cancel to original support, do not implement CancelSupport ourselves
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Mon, 22 Apr 2013 19:17:29 +0200 |
parents | 3c4db86e8c1f |
children | e4a71afd3c71 |
rev | line source |
---|---|
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
2 * Copyright (c) 2011-2012 TMate Software Ltd |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.console; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
19 import static org.tmatesoft.hg.repo.HgRepository.TIP; |
429
cd658b24a620
FIXMEs: javadoc, proper use of constants
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
20 import static org.tmatesoft.hg.repo.HgRepository.WORKING_COPY; |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
21 import static org.tmatesoft.hg.util.LogFacility.Severity.*; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
22 |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
23 import java.io.File; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
24 import java.util.ArrayList; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
25 import java.util.Collections; |
328
a674b8590362
Move file tree history to upper API level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
317
diff
changeset
|
26 import java.util.HashSet; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
27 import java.util.List; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
28 import java.util.Map; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
29 |
328
a674b8590362
Move file tree history to upper API level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
317
diff
changeset
|
30 import org.tmatesoft.hg.core.HgChangeset; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
31 import org.tmatesoft.hg.core.HgChangesetFileSneaker; |
328
a674b8590362
Move file tree history to upper API level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
317
diff
changeset
|
32 import org.tmatesoft.hg.core.HgChangesetTreeHandler; |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
33 import org.tmatesoft.hg.core.HgCheckoutCommand; |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
350
diff
changeset
|
34 import org.tmatesoft.hg.core.HgException; |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
35 import org.tmatesoft.hg.core.HgFileRenameHandlerMixin; |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
36 import org.tmatesoft.hg.core.HgFileRevision; |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
37 import org.tmatesoft.hg.core.HgLogCommand; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
38 import org.tmatesoft.hg.core.HgManifestCommand; |
506
27398bbfd543
Experiment to add a facility to check working files for actual changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
501
diff
changeset
|
39 import org.tmatesoft.hg.core.HgManifestHandler; |
526
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
40 import org.tmatesoft.hg.core.HgRevertCommand; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
41 import org.tmatesoft.hg.core.Nodeid; |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
42 import org.tmatesoft.hg.internal.BasicSessionContext; |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
43 import org.tmatesoft.hg.internal.ByteArrayChannel; |
483
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
44 import org.tmatesoft.hg.internal.ConfigFile; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
45 import org.tmatesoft.hg.internal.DigestHelper; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
46 import org.tmatesoft.hg.internal.ManifestRevision; |
229
1ec6b327a6ac
Scope for status reworked: explicit files or a general matcher
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
226
diff
changeset
|
47 import org.tmatesoft.hg.internal.PathGlobMatcher; |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
48 import org.tmatesoft.hg.internal.RelativePathRewrite; |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
49 import org.tmatesoft.hg.internal.StreamLogFacility; |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
50 import org.tmatesoft.hg.repo.HgBookmarks; |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
51 import org.tmatesoft.hg.repo.HgBranches; |
233
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
52 import org.tmatesoft.hg.repo.HgChangelog; |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
53 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
54 import org.tmatesoft.hg.repo.HgDataFile; |
290
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
55 import org.tmatesoft.hg.repo.HgDirstate; |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
56 import org.tmatesoft.hg.repo.HgDirstate.EntryKind; |
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
57 import org.tmatesoft.hg.repo.HgDirstate.Record; |
339
863356c2847e
Issue 16: respect glob patterns in HgIgnore for sub-directories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
328
diff
changeset
|
58 import org.tmatesoft.hg.repo.HgIgnore; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 import org.tmatesoft.hg.repo.HgInternals; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 import org.tmatesoft.hg.repo.HgManifest; |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
61 import org.tmatesoft.hg.repo.HgManifest.Flags; |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
62 import org.tmatesoft.hg.repo.HgMergeState; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
63 import org.tmatesoft.hg.repo.HgRepository; |
506
27398bbfd543
Experiment to add a facility to check working files for actual changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
501
diff
changeset
|
64 import org.tmatesoft.hg.repo.HgRevisionMap; |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
65 import org.tmatesoft.hg.repo.HgRuntimeException; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
66 import org.tmatesoft.hg.repo.HgStatusCollector; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
67 import org.tmatesoft.hg.repo.HgStatusInspector; |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
68 import org.tmatesoft.hg.repo.HgSubrepoLocation; |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
69 import org.tmatesoft.hg.repo.HgSubrepoLocation.Kind; |
506
27398bbfd543
Experiment to add a facility to check working files for actual changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
501
diff
changeset
|
70 import org.tmatesoft.hg.repo.HgWorkingCopyStatusCollector; |
501
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
71 import org.tmatesoft.hg.repo.ext.HgExtensionsManager; |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
72 import org.tmatesoft.hg.repo.ext.HgExtensionsManager.HgExt; |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
73 import org.tmatesoft.hg.repo.ext.Rebase; |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
74 import org.tmatesoft.hg.util.Adaptable; |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
75 import org.tmatesoft.hg.util.FileWalker; |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
76 import org.tmatesoft.hg.util.LogFacility; |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
77 import org.tmatesoft.hg.util.Pair; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
78 import org.tmatesoft.hg.util.Path; |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
79 import org.tmatesoft.hg.util.PathRewrite; |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
80 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
81 /** |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
82 * Various debug dumps. |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
83 * |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
84 * @author Artem Tikhomirov |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
85 * @author TMate Software Ltd. |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
86 */ |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
87 @SuppressWarnings("unused") |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
88 public class Main { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
89 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
90 private Options cmdLineOpts; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
91 private HgRepository hgRepo; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
92 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
93 public Main(String[] args) throws Exception { |
299
45dc79e545f5
Recognize flag options (options with no arguments) in command line sample apps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
295
diff
changeset
|
94 cmdLineOpts = Options.parse(args, Collections.<String>emptySet()); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
95 hgRepo = cmdLineOpts.findRepository(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
96 if (hgRepo.isInvalid()) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
97 System.err.printf("Can't find repository in: %s\n", hgRepo.getLocation()); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
98 return; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
99 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
100 System.out.println("REPO:" + hgRepo.getLocation()); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
101 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
102 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
103 public static void main(String[] args) throws Exception { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
104 Main m = new Main(args); |
576
3c4db86e8c1f
Issue 43: poor performance with InflaterDataAccess. Phase 2: inflate into buffer, effective skip and readByte/readBytes()
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
105 m.checkFileSneakerPerformance(); |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
106 // m.testRevert(); |
526
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
107 // m.testCheckout(); |
507
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
506
diff
changeset
|
108 // m.tryExtensions(); |
501
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
109 // m.dumpBookmarks(); |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
110 // m.readConfigFile(); |
483
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
111 // m.dumpCommitLastMessage(); |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
112 // m.buildFileLog(); |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
113 // m.testConsoleLog(); |
270
c6450b0b1fd5
Avoid IAE:nullid when looking into stale merge/state file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
114 // m.testTreeTraversal(); |
244
4b661efb9374
Use updated location of cache files (cache/ folder instead of .cache filename extension). Provide means to update (write down) cache for subsequent uses
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
243
diff
changeset
|
115 // m.testRevisionMap(); |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
116 // m.testSubrepos(); |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
117 // m.testReadWorkingCopy(); |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
118 // m.testParents(); |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
119 // m.testEffectiveFileLog(); |
345
58725dd511b3
Provide access to revision's origins
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
341
diff
changeset
|
120 // m.testMergeState(); |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
121 // m.testFileStatus(); |
341
75c452fdd76a
Merging state not detected when there's no conflicts to resolve (no merge/state file)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
340
diff
changeset
|
122 // m.dumpBranches(); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
123 // m.inflaterLengthException(); |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
124 // m.dumpIgnored(); |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
125 // m.dumpDirstate(); |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
126 // m.testStatusInternals(); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
127 // m.catCompleteHistory(); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
128 // m.dumpCompleteManifestLow(); |
445
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
129 // m.dumpCompleteManifestHigh(); |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
130 // m.bunchOfTests(); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
131 } |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
132 |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
133 private void checkFileSneakerPerformance() throws Exception { |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
134 HgChangesetFileSneaker fs1 = new HgChangesetFileSneaker(hgRepo); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
135 HgChangesetFileSneaker fs2 = new HgChangesetFileSneaker(hgRepo); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
136 fs1.followRenames(true); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
137 fs2.followRenames(true); |
576
3c4db86e8c1f
Issue 43: poor performance with InflaterDataAccess. Phase 2: inflate into buffer, effective skip and readByte/readBytes()
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
138 Nodeid cset = hgRepo.getChangelog().getRevision(2); |
3c4db86e8c1f
Issue 43: poor performance with InflaterDataAccess. Phase 2: inflate into buffer, effective skip and readByte/readBytes()
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
139 Path fname = Path.create("dir9/file9"); // close to the manifest end |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
140 fs1.changeset(cset); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
141 fs2.changeset(cset); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
142 // hgRepo.getManifest().getFileRevision(TIP, fname); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
143 final long start1 = System.nanoTime(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
144 boolean e1 = fs1.checkExists(fname); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
145 final long end1 = System.nanoTime(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
146 boolean e2 = fs2.checkExists(fname); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
147 final long end2 = System.nanoTime(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
148 Nodeid fr = hgRepo.getManifest().getFileRevision(TIP, fname); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
149 final long end3 = System.nanoTime(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
150 System.out.printf("\t1st run: %d ms, %b\n\t2nd run: %d ms, %b\n\tfile only: %d ms", (end1 - start1) / 1000000, e1, (end2 - end1) / 1000000, e2, (end3-end2)/1000000); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
151 if (!fr.equals(fs1.revision()) || !fr.equals(fs2.revision())) { |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
152 throw new AssertionError(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
153 } |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
154 ManifestRevision mr = new ManifestRevision(null, null); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
155 final long _s1 = System.nanoTime(); |
576
3c4db86e8c1f
Issue 43: poor performance with InflaterDataAccess. Phase 2: inflate into buffer, effective skip and readByte/readBytes()
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
156 hgRepo.getManifest().walk(0, 0, mr); |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
157 final long _e1 = System.nanoTime(); |
576
3c4db86e8c1f
Issue 43: poor performance with InflaterDataAccess. Phase 2: inflate into buffer, effective skip and readByte/readBytes()
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
158 hgRepo.getManifest().getFileRevision(0, fname); |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
159 final long _e2 = System.nanoTime(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
160 System.out.printf("\n\tManifestRevision:%d ms, getFileRevision:%d ms\n", (_e1-_s1)/1000000, (_e2-_e1)/1000000); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
161 } |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
162 |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
163 // -agentlib:hprof=cpu=times,heap=sites,depth=10 |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
164 private void checkFileSneakerPerformance2() throws Exception { |
576
3c4db86e8c1f
Issue 43: poor performance with InflaterDataAccess. Phase 2: inflate into buffer, effective skip and readByte/readBytes()
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
165 Path fname = Path.create("dir9/file9"); // close to the manifest end |
3c4db86e8c1f
Issue 43: poor performance with InflaterDataAccess. Phase 2: inflate into buffer, effective skip and readByte/readBytes()
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
166 hgRepo.getManifest().getFileRevision(0, fname); |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
167 // ManifestRevision mr = new ManifestRevision(null, null); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
168 // hgRepo.getManifest().walk(2, 2, mr); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
169 } |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
170 |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
526
diff
changeset
|
171 |
526
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
172 private void testRevert() throws Exception { |
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
173 HgRevertCommand cmd = new HgRevertCommand(hgRepo); |
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
174 cmd.file(Path.create("a.txt")).execute(); |
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
175 } |
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
176 |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
177 private void testCheckout() throws Exception { |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
178 HgCheckoutCommand coCmd = new HgCheckoutCommand(hgRepo); |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
179 coCmd.changeset(17).execute(); |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
180 } |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
181 |
501
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
182 private void tryExtensions() throws Exception { |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
183 HgExtensionsManager em = hgRepo.getExtensions(); |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
184 if (!em.isEnabled(HgExt.Rebase)) { |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
185 System.out.println("Rebase is not enabled"); |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
186 return; |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
187 } |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
188 Rebase re = em.getRebaseExtension(); |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
189 if (!re.refresh().isRebaseInProgress()) { |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
190 System.out.println("No rebase is in progress"); |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
191 return; |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
192 } |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
193 System.out.printf("%s %s %s\n", re.getWorkingDirParent().shortNotation(), re.getTarget().shortNotation(), re.getExternalParent().shortNotation()); |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
194 System.out.printf("collapse:%b, keep:%b, keepbranches:%b\n", re.isCollapse(), re.isKeepOriginalRevisions(), re.isKeepBranchNames()); |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
195 } |
d2f6ab541330
Change the way extensions are accessed (with ExtensionsManager now), add preliminary Rebase extension support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
196 |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
197 // TODO as test |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
198 private void dumpBookmarks() throws Exception { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
199 HgBookmarks bm = hgRepo.getBookmarks(); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
200 String active = bm.getActiveBookmarkName(); |
506
27398bbfd543
Experiment to add a facility to check working files for actual changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
501
diff
changeset
|
201 ArrayList<String> all = new ArrayList<String>(bm.getAllBookmarks()); |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
202 Collections.sort(all); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
203 for (String bmname : all) { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
204 if (bmname.equals(active)) { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
205 System.out.print(" * "); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
206 } else { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
207 System.out.print(" "); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
208 } |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
209 System.out.printf("%-26s (%s)\n", bmname, bm.getRevision(bmname).shortNotation()); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
210 } |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
211 } |
483
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
212 |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
213 // TODO as test |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
214 private void readConfigFile() throws Exception { |
490
b3c16d1aede0
Refactoring: move HgRepository's implementation aspects to Internals (which is now its imlementation counterpart and primary repository class to be used by other parts of the library)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
484
diff
changeset
|
215 ConfigFile configFile = new ConfigFile(hgRepo.getSessionContext()); |
483
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
216 configFile.addLocation(new File(System.getProperty("user.home"), "test-cfg/aaa/config1")); |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
217 for (String s : configFile.getSectionNames()) { |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
218 System.out.printf("[%s]\n", s); |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
219 for (Map.Entry<String, String> e : configFile.getSection(s).entrySet()) { |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
220 System.out.printf("%s = %s\n", e.getKey(), e.getValue()); |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
221 } |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
222 } |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
223 |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
224 } |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
225 |
481
a458f9fb00ce
Access to user-supplied message of last commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
479
diff
changeset
|
226 private void dumpCommitLastMessage() throws Exception { |
a458f9fb00ce
Access to user-supplied message of last commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
479
diff
changeset
|
227 System.out.println(hgRepo.getCommitLastMessage()); |
a458f9fb00ce
Access to user-supplied message of last commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
479
diff
changeset
|
228 } |
464
1a3c18d57a8e
MqManager evolution: same PatchRecord instances, list patch queues, detect active queue
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
463
diff
changeset
|
229 |
328
a674b8590362
Move file tree history to upper API level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
317
diff
changeset
|
230 private void buildFileLog() throws Exception { |
450
03fd8d079e9c
Share PhasesHelper instance among few HgChangesets (mostly affects HgChangesetTreeHandler case)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
449
diff
changeset
|
231 final long start = System.nanoTime(); |
328
a674b8590362
Move file tree history to upper API level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
317
diff
changeset
|
232 HgLogCommand cmd = new HgLogCommand(hgRepo); |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
233 cmd.file("a2.txt", true, false); |
511
122e0600799f
Respect multiple joins/forks in a history of a single file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
234 final int[] count = new int[] { 0 }; |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
235 class MyHandler implements HgChangesetTreeHandler, Adaptable { |
427
31a89587eb04
FIXMEs: consistent names, throws for commands and their handlers. Use of checked exceptions in hi-level api
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
236 public void treeElement(HgChangesetTreeHandler.TreeElement entry) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
237 StringBuilder sb = new StringBuilder(); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
238 HashSet<Nodeid> test = new HashSet<Nodeid>(entry.childRevisions()); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
239 for (HgChangeset cc : entry.children()) { |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
240 sb.append(cc.getRevisionIndex()); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
241 sb.append(':'); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
242 sb.append(cc.getNodeid().shortNotation()); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
243 sb.append(", "); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
244 } |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
245 final Pair<Nodeid, Nodeid> parents = entry.parentRevisions(); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
246 final boolean isJoin = !parents.first().isNull() && !parents.second().isNull(); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
247 final boolean isFork = entry.children().size() > 1; |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
248 final HgChangeset cset = entry.changeset(); |
471
7bcfbc255f48
Merge changes from smartgit3 branch into 1.1 stream
Artem Tikhomirov <tikhomirov.artem@gmail.com>
diff
changeset
|
249 System.out.printf("%d:%s - %s (%s)\n", cset.getRevisionIndex(), cset.getNodeid().shortNotation(), cset.getComment(), cset.getPhase()); |
516
0ae5768081aa
Allow walking file rename history independently from file ancestry (native hg log --follow does both at once)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
515
diff
changeset
|
250 System.out.printf("\tKnown as %s (file rev:%s)\n", entry.file().getPath(), entry.fileRevision().shortNotation()); |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
251 if (!isJoin && !isFork && !entry.children().isEmpty()) { |
516
0ae5768081aa
Allow walking file rename history independently from file ancestry (native hg log --follow does both at once)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
515
diff
changeset
|
252 HgChangeset p1 = entry.parents().first(); |
0ae5768081aa
Allow walking file rename history independently from file ancestry (native hg log --follow does both at once)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
515
diff
changeset
|
253 HgChangeset p2 = entry.parents().second(); |
0ae5768081aa
Allow walking file rename history independently from file ancestry (native hg log --follow does both at once)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
515
diff
changeset
|
254 System.out.printf("\tp1:%d, p2:%d\n", p1 == null ? -1 : p1.getRevisionIndex(), p2 == null ? -1 : p2.getRevisionIndex()); |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
255 System.out.printf("\t=> %s\n", sb); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
256 } |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
257 if (isJoin) { |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
258 HgChangeset p1 = entry.parents().first(); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
259 HgChangeset p2 = entry.parents().second(); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
260 System.out.printf("\tjoin <= (%d:%s, %d:%s)", p1.getRevisionIndex(), p1.getNodeid().shortNotation(), p2.getRevisionIndex(), p2.getNodeid().shortNotation()); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
261 if (isFork) { |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
262 System.out.print(", "); |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
263 } |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
264 } |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
265 if (isFork) { |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
266 if (!isJoin) { |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
267 System.out.print('\t'); |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
268 } |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
269 System.out.printf("fork => [%s]", sb); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
270 } |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
271 if (isJoin || isFork) { |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
272 System.out.println(); |
317
09628675bcee
Rework file history build approach to match rest of the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
308
diff
changeset
|
273 } |
511
122e0600799f
Respect multiple joins/forks in a history of a single file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
274 count[0]++; |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
275 } |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
276 |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
277 public <T> T getAdapter(Class<T> adapterClass) { |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
278 if (adapterClass == HgFileRenameHandlerMixin.class) { |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
279 // in fact, new instance is not very nice, however |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
280 // getAdapter callers are supposed to understand the risk of new instance |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
281 // and cache returned value |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
282 // besides, stateless implementation of RenameDumpHandler |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
283 // doesn't really care about few instances |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
284 return adapterClass.cast(new Log.RenameDumpHandler()); |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
285 } |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
286 return null; |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
287 } |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
288 }; |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
289 cmd.execute(new MyHandler()); |
511
122e0600799f
Respect multiple joins/forks in a history of a single file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
290 System.out.println(count[0]); |
450
03fd8d079e9c
Share PhasesHelper instance among few HgChangesets (mostly affects HgChangesetTreeHandler case)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
449
diff
changeset
|
291 final long end = System.nanoTime(); |
03fd8d079e9c
Share PhasesHelper instance among few HgChangesets (mostly affects HgChangesetTreeHandler case)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
449
diff
changeset
|
292 System.out.printf("buildFileLog: %,d ms\n", (end-start)/1000); |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
293 } |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
294 |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
295 private void buildFileLogOld() throws Exception { |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
296 final HgDataFile fn = hgRepo.getFileNode("file1"); |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
297 final int[] fileChangesetRevisions = new int[fn.getRevisionCount()]; |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
298 fn.history(new HgChangelog.Inspector() { |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
299 private int fileLocalRevisions = 0; |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
300 private int[] parentRevisions = new int[2]; |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
301 |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
302 public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) { |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
303 try { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
304 fileChangesetRevisions[fileLocalRevisions] = revisionNumber; |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
305 fn.parents(fileLocalRevisions, parentRevisions, null, null); |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
306 boolean join = parentRevisions[0] != -1 && parentRevisions[1] != -1; |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
307 if (join) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
308 System.out.print("join["); |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
309 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
310 if (parentRevisions[0] != -1) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
311 System.out.printf("%2d->%2d, ", fileChangesetRevisions[parentRevisions[0]], revisionNumber); |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
312 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
313 if (parentRevisions[1] != -1) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
314 System.out.printf("%2d->%2d, ", fileChangesetRevisions[parentRevisions[1]], revisionNumber); |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
315 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
316 if (join) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
317 System.out.print("]"); |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
318 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
319 fileLocalRevisions++; |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
320 } catch (HgRuntimeException ex) { |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
321 ex.printStackTrace(); |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
322 } |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
323 } |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
324 }); |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
325 System.out.println(); |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
326 } |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
327 |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
328 private void testConsoleLog() { |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
329 LogFacility fc = new StreamLogFacility(Debug, true, System.out); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
330 System.out.printf("isDebug: %s, isInfo:%s\n", fc.isDebug(), fc.getLevel() == Info); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
331 fc.dump(getClass(), Debug, "%d", 1); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
332 fc.dump(getClass(), Info, "%d\n", 2); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
333 fc.dump(getClass(), Warn, "%d\n", 3); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
334 fc.dump(getClass(), Error, "%d", 4); |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
335 Exception ex = new Exception(); |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
336 fc.dump(getClass(), Debug, ex, "message"); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
337 fc.dump(getClass(), Info, ex, null); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
338 fc.dump(getClass(), Warn, ex, null); |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
339 fc.dump(getClass(), Error, ex, "message"); |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
340 } |
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
341 |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
342 private void testTreeTraversal() throws Exception { |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
343 File repoRoot = hgRepo.getWorkingDir(); |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
344 Path.Source pathSrc = new Path.SimpleSource(new PathRewrite.Composite(new RelativePathRewrite(repoRoot), hgRepo.getToRepoPathHelper())); |
431
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
429
diff
changeset
|
345 FileWalker w = new FileWalker(new BasicSessionContext(null), repoRoot, pathSrc); |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
346 int count = 0; |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
347 final long start = System.currentTimeMillis(); |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
348 while (w.hasNext()) { |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
349 count++; |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
350 w.next(); |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
351 } |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
352 System.out.printf("Traversal of %d files took %d ms", count, System.currentTimeMillis() - start); |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
353 } |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
354 |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
355 /* |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
356 * cpython repo with 70715 revisions. |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
357 3 revisions - 80 ms vs 250 ms (250ms init) |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
358 4 revisions - 110 ms vs 265 ms (265 ms init) |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
359 5 revisions - 94 vs 266. |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
366
diff
changeset
|
360 complete iteration in changelog.getRevisionIndex(tipNodeid) takes 47 ms |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
361 compared to complete iteration inside RevisionMap.init() of 171 ms. |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
362 The only difference is latter instantiates Nodeids, while former compares binary content as is. |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
363 Hence, with 20-30 ms per regular getLocalRevision, it pays off to use RevisionMap with at least 15-20 |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
364 queries |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
365 */ |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
366 private void testRevisionMap() throws Exception { |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
367 HgChangelog changelog = hgRepo.getChangelog(); |
433
be697c3e951e
Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
368 HgRevisionMap<HgChangelog> rmap = new HgRevisionMap<HgChangelog>(changelog).init(); // warm-up, ensure complete file read |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
369 int tip = changelog.getLastRevision(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
370 // take 5 arbitrary revisions at 0, 1/4, 2/4, 3/4 and 4/4 |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
371 final Nodeid[] revs = new Nodeid[5]; |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
372 revs[4] = changelog.getRevision(0); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
373 revs[3] = changelog.getRevision(tip / 4); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
374 revs[2] = changelog.getRevision(tip / 2); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
375 revs[1] = changelog.getRevision(tip / 4 + tip / 2); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
376 revs[0] = changelog.getRevision(tip); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
377 long start = System.currentTimeMillis(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
378 for (int i = 0; i < revs.length; i++) { |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
366
diff
changeset
|
379 final int localRev = changelog.getRevisionIndex(revs[i]); |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
380 System.out.printf("%d:%s\n", localRev, revs[i]); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
381 } |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
382 System.out.println(System.currentTimeMillis() - start); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
383 System.out.println(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
384 // |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
385 start = System.currentTimeMillis(); |
433
be697c3e951e
Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
386 rmap = new HgRevisionMap<HgChangelog>(changelog).init(); |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
387 long s2 = System.currentTimeMillis(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
388 for (int i = 0; i < revs.length; i++) { |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
366
diff
changeset
|
389 final int localRev = rmap.revisionIndex(revs[i]); |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
390 System.out.printf("%d:%s\n", localRev, revs[i]); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
391 } |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
392 System.out.println(System.currentTimeMillis() - start); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
393 System.out.printf("\t from that, init took %d ms\n", s2 - start); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
394 |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
395 } |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
396 |
442
6865eb742883
Tests for subrepo API, refactor status tests for reuse, better subrepos API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
433
diff
changeset
|
397 // any repository with subrepositories |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
398 private void testSubrepos() throws Exception { |
442
6865eb742883
Tests for subrepo API, refactor status tests for reuse, better subrepos API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
433
diff
changeset
|
399 // @see TestSubrepo#testAccessAPI |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
400 for (HgSubrepoLocation l : hgRepo.getSubrepositories()) { |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
401 System.out.println(l.getLocation()); |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
402 System.out.println(l.getSource()); |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
403 System.out.println(l.getType()); |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
404 System.out.println(l.isCommitted() ? l.getRevision() : "not yet committed"); |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
405 if (l.getType() == Kind.Hg) { |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
406 HgRepository r = l.getRepo(); |
442
6865eb742883
Tests for subrepo API, refactor status tests for reuse, better subrepos API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
433
diff
changeset
|
407 System.out.printf("%s (%s) has %d revisions\n", l.getLocation(), r.getLocation(), r.getChangelog().getLastRevision() + 1); |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
408 if (r.getChangelog().getLastRevision() >= 0) { |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
409 final RawChangeset c = r.getChangelog().range(TIP, TIP).get(0); |
442
6865eb742883
Tests for subrepo API, refactor status tests for reuse, better subrepos API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
433
diff
changeset
|
410 System.out.printf("TIP: %s %s '%s'\n", c.user(), c.dateString(), c.comment()); |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
411 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
412 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
413 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
414 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
415 |
237
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
416 private void testReadWorkingCopy() throws Exception { |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
417 for (String fname : cmdLineOpts.getList("")) { |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
418 HgDataFile fn = hgRepo.getFileNode(fname); |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
419 ByteArrayChannel sink = new ByteArrayChannel(); |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
420 fn.workingCopy(sink); |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
421 System.out.printf("%s: read %d bytes of working copy", fname, sink.toArray().length); |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
422 } |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
423 } |
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
236
diff
changeset
|
424 |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
425 private void testParents() throws Exception { |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
426 // hg parents cmd |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
427 final Pair<Nodeid, Nodeid> wcParents = hgRepo.getWorkingCopyParents(); |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
428 ChangesetDumpHandler dump = new ChangesetDumpHandler(hgRepo); |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
429 HgLogCommand cmd = new HgLogCommand(hgRepo); |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
430 if (wcParents.hasFirst()) { |
253
1874d11054e5
HgLogCommand.changeset(Nodeid) to ease command configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
252
diff
changeset
|
431 cmd.changeset(wcParents.first()).execute(dump); |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
432 } |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
433 if (wcParents.hasSecond()) { |
253
1874d11054e5
HgLogCommand.changeset(Nodeid) to ease command configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
252
diff
changeset
|
434 cmd.changeset(wcParents.second()).execute(dump); |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
435 } |
252
a6d19adc2636
HgRepository.getWorkingCopyBranchName() to retrieve branch associated with working directory
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
249
diff
changeset
|
436 System.out.println("Branch:" + hgRepo.getWorkingCopyBranchName()); |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
437 } |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
438 |
242
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
439 /* |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
440 * -R \temp\hg\hg4j-50 src/org/tmatesoft/hg/internal/RevlogStream.java |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
441 * |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
442 * -R \temp\hg\cpython Lib/doctest.py, range 15907..68588, total 251 revision |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
443 * no improvement (collect linkRev, hgchangelog.range([])) 10890 ms |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
444 * improved history logic in HgDataFile (minimize reads of close revisions): |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
445 * with no sort (defect for tool-created repos) took 10500 ms |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
446 * with sort (to order revisions from linkRev before use) 610 ms |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
447 * HgChangelog.range() - 92 calls |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
448 * RevlogStream with separate iterate(int[] sortedRevisions,...) |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
449 * RevlogStream.ReaderN1.range(): 185 380 ms |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
450 */ |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
451 private void testEffectiveFileLog() throws Exception { |
233
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
452 for (String fname : cmdLineOpts.getList("")) { |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
453 System.out.println(fname); |
242
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
454 final long start = System.currentTimeMillis(); |
233
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
455 HgDataFile fn = hgRepo.getFileNode(fname); |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
456 if (fn.exists()) { |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
457 fn.history(new HgChangelog.Inspector() { |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
458 public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) { |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
459 System.out.printf("%d:%s\n", revisionNumber, nodeid); |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
460 } |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
461 }); |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
462 } |
242
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
463 System.out.printf("Done: %d\n", System.currentTimeMillis() - start); |
233
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
464 } |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
465 } |
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
466 |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
467 private void testMergeState() throws Exception { |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
468 final HgMergeState mergeState = hgRepo.getMergeState(); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
469 mergeState.refresh(); |
270
c6450b0b1fd5
Avoid IAE:nullid when looking into stale merge/state file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
470 System.out.printf("isMerging: %s, isStale: %s.\n", mergeState.isMerging(), mergeState.isStale()); |
c6450b0b1fd5
Avoid IAE:nullid when looking into stale merge/state file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
471 System.out.printf("P1:%s\nP2:%s\nState parent:%s\n",mergeState.getFirstParent().shortNotation(), mergeState.getSecondParent().shortNotation(), mergeState.getStateParent().shortNotation()); |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
472 for (HgMergeState.Entry e : mergeState.getConflicts()) { |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
473 System.out.println(e.getState() + " " + e.getActualFile()); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
474 System.out.println("p1: " + formatFileRevision(e.getFirstParent())); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
475 System.out.println("p2: " + formatFileRevision(e.getSecondParent())); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
476 System.out.println("ancestor: " + formatFileRevision(e.getCommonAncestor())); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
477 System.out.println(); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
478 } |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
479 } |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
480 |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
481 private static String formatFileRevision(HgFileRevision r) throws Exception { |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
482 final ByteArrayChannel sink = new ByteArrayChannel(); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
483 r.putContentTo(sink); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
484 return String.format("%s %s (%d bytes)", r.getPath(), r.getRevision(), sink.toArray().length); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
485 } |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
486 |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
487 private void testFileStatus() throws Exception { |
226
26ad7827a62d
Support status query for a single file or a subdirectory of a repository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
488 // final Path path = Path.create("src/org/tmatesoft/hg/util/"); |
229
1ec6b327a6ac
Scope for status reworked: explicit files or a general matcher
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
226
diff
changeset
|
489 // final Path path = Path.create("src/org/tmatesoft/hg/internal/Experimental.java"); |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
490 // final Path path = Path.create("missing-dir/"); |
229
1ec6b327a6ac
Scope for status reworked: explicit files or a general matcher
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
226
diff
changeset
|
491 // HgWorkingCopyStatusCollector wcsc = HgWorkingCopyStatusCollector.create(hgRepo, path); |
233
1d389c0cb0a5
Optimize file history walk not to iterat over whole changelog for sparse and distant revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
492 HgWorkingCopyStatusCollector wcsc = HgWorkingCopyStatusCollector.create(hgRepo, new PathGlobMatcher("mi**")); |
429
cd658b24a620
FIXMEs: javadoc, proper use of constants
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
493 wcsc.walk(WORKING_COPY, new StatusDump()); |
226
26ad7827a62d
Support status query for a single file or a subdirectory of a repository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
494 } |
26ad7827a62d
Support status query for a single file or a subdirectory of a repository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
495 |
236
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
496 /* |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
497 * Straightforward approach to collect branches, no use of branchheads.cache |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
498 * First, single run - 18 563 |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
499 * 10 runs (after 1 warm up) of HgBranches.collect took 167391 ms, ~17 seconds per run. |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
500 */ |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
501 private void dumpBranches() throws Exception { |
236
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
502 final long start0 = System.currentTimeMillis(); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
503 HgBranches b = hgRepo.getBranches(); |
236
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
504 System.out.println("1:" + (System.currentTimeMillis() - start0)); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
505 for (HgBranches.BranchInfo bi : b.getAllBranches()) { |
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
506 System.out.print(bi.getName()); |
236
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
507 // System.out.print(" "); |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
508 // System.out.print(bi.getStart()); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
509 System.out.print(" "); |
308
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
510 System.out.print(bi.getHeads()); |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
511 if (bi.isClosed()) { |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
512 System.out.print(" x "); |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
513 } |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
514 System.out.println(); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
515 } |
308
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
516 // b.writeCache(); |
236
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
517 // final long start = System.currentTimeMillis(); |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
518 // for (int i = 0; i < 10; i++) { |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
519 // b.collect(ProgressSupport.Factory.get(null)); |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
520 // } |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
521 // System.out.println("10:" + (System.currentTimeMillis() - start)); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
522 } |
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
523 |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
524 private void inflaterLengthException() throws Exception { |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
525 HgDataFile f1 = hgRepo.getFileNode("src/com/tmate/hgkit/console/Bundle.java"); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
526 HgDataFile f2 = hgRepo.getFileNode("test-repos.jar"); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
527 System.out.println(f1.isCopy()); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
528 System.out.println(f2.isCopy()); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
529 ByteArrayChannel bac = new ByteArrayChannel(); |
158
b413b16d10a5
Integer offsets and file length explictly, rather than casts throughout code. Inflater may benefit from total length hint, but shall calculate it by its own if needed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
530 f1.content(1, bac); // 0: 1151, 1: 1139 |
b413b16d10a5
Integer offsets and file length explictly, rather than casts throughout code. Inflater may benefit from total length hint, but shall calculate it by its own if needed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
531 System.out.println(bac.toArray().length); |
b413b16d10a5
Integer offsets and file length explictly, rather than casts throughout code. Inflater may benefit from total length hint, but shall calculate it by its own if needed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
532 f2.content(0, bac = new ByteArrayChannel()); // 0: 14269 |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
533 System.out.println(bac.toArray().length); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
534 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
535 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
536 private void dumpIgnored() { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
537 String[] toCheck = new String[] {"design.txt", "src/com/tmate/hgkit/ll/Changelog.java", "src/Extras.java", "bin/com/tmate/hgkit/ll/Changelog.class"}; |
339
863356c2847e
Issue 16: respect glob patterns in HgIgnore for sub-directories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
328
diff
changeset
|
538 HgIgnore ignore = hgRepo.getIgnore(); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
539 for (int i = 0; i < toCheck.length; i++) { |
339
863356c2847e
Issue 16: respect glob patterns in HgIgnore for sub-directories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
328
diff
changeset
|
540 System.out.println("Ignored " + toCheck[i] + ": " + ignore.isIgnored(Path.create(toCheck[i]))); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
541 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
542 } |
348
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
543 |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
544 static class DirstateDump implements HgDirstate.Inspector { |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
545 private final char[] x = new char[] {'n', 'a', 'r', 'm' }; |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
546 |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
547 public boolean next(EntryKind kind, Record entry) { |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
548 System.out.printf("%c %3o%6d %30tc\t\t%s", x[kind.ordinal()], entry.mode(), entry.size(), (long) entry.modificationTime() * 1000, entry.name()); |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
549 if (entry.copySource() != null) { |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
550 System.out.printf(" --> %s", entry.copySource()); |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
551 } |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
552 System.out.println(); |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
553 return true; |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
554 } |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
555 } |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
556 |
348
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
557 private void dumpDirstate() throws Exception { |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
558 new HgInternals(hgRepo).getDirstate().walk(new DirstateDump()); |
290
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
559 HgWorkingCopyStatusCollector wcc = HgWorkingCopyStatusCollector.create(hgRepo, new Path.Matcher.Any()); |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
560 wcc.getDirstate().walk(new HgDirstate.Inspector() { |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
561 |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
562 public boolean next(EntryKind kind, Record entry) { |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
563 System.out.printf("%s %s\n", kind, entry.name()); |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
564 return true; |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
565 } |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
566 }); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
567 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
568 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
569 |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
570 private void catCompleteHistory() throws Exception { |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
571 DigestHelper dh = new DigestHelper(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
572 for (String fname : cmdLineOpts.getList("")) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
573 System.out.println(fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
574 HgDataFile fn = hgRepo.getFileNode(fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
575 if (fn.exists()) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
576 int total = fn.getRevisionCount(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
577 System.out.printf("Total revisions: %d\n", total); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
578 for (int i = 0; i < total; i++) { |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
579 ByteArrayChannel sink = new ByteArrayChannel(); |
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
580 fn.content(i, sink); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
581 System.out.println("==========>"); |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
143
diff
changeset
|
582 byte[] content = sink.toArray(); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
583 System.out.println(new String(content)); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
584 int[] parentRevisions = new int[2]; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
585 byte[] parent1 = new byte[20]; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
586 byte[] parent2 = new byte[20]; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
587 fn.parents(i, parentRevisions, parent1, parent2); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
588 System.out.println(dh.sha1(parent1, parent2, content).asHexString()); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
589 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
590 } else { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
591 System.out.println(">>>Not found!"); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
592 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
593 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
594 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
595 |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
596 private void dumpCompleteManifestLow() throws Exception { |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
597 hgRepo.getManifest().walk(0, TIP, new ManifestDump()); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
598 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
599 |
424
6437d261048a
Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
600 public static final class ManifestDump implements HgManifest.Inspector { |
222
373e07cd3991
Due to discrepancy in manifest and changelor indexes, wrong manifest revisions got cached and compared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
220
diff
changeset
|
601 public boolean begin(int manifestRevision, Nodeid nid, int changelogRevision) { |
373e07cd3991
Due to discrepancy in manifest and changelor indexes, wrong manifest revisions got cached and compared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
220
diff
changeset
|
602 System.out.printf("%d : %s\n", manifestRevision, nid); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
603 return true; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
604 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
605 |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
281
diff
changeset
|
606 public boolean next(Nodeid nid, Path fname, Flags flags) { |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
607 System.out.println(nid + "\t" + fname + "\t\t" + flags); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
608 return true; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
609 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
610 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
611 public boolean end(int revision) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
612 System.out.println(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
613 return true; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
614 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
615 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
616 |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
617 private void dumpCompleteManifestHigh() throws Exception { |
427
31a89587eb04
FIXMEs: consistent names, throws for commands and their handlers. Use of checked exceptions in hi-level api
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
618 new HgManifestCommand(hgRepo).dirs(true).execute(new HgManifestHandler() { |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
619 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
620 public void begin(Nodeid manifestRevision) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
621 System.out.println(">> " + manifestRevision); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
622 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
623 public void dir(Path p) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
624 System.out.println(p); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
625 } |
249
4c3b9f679412
Deprecated HgLogCommand.FileRevision gone, top-level HgFileRevision is bright and shiny replacement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
248
diff
changeset
|
626 public void file(HgFileRevision fileRevision) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
627 System.out.print(fileRevision.getRevision());; |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
628 System.out.print(" "); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
629 System.out.printf("%s %s", fileRevision.getParents().first().shortNotation(), fileRevision.getParents().second().shortNotation()); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
630 System.out.print(" "); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
417
diff
changeset
|
631 System.out.println(fileRevision.getPath()); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
632 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
633 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
634 public void end(Nodeid manifestRevision) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
635 System.out.println(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
636 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
637 }); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
638 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
639 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
640 private void bunchOfTests() throws Exception { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
641 final StatusDump dump = new StatusDump(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
642 dump.showIgnored = false; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
643 dump.showClean = false; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
644 HgStatusCollector sc = new HgStatusCollector(hgRepo); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
645 final int r1 = 0, r2 = 3; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
646 System.out.printf("Status for changes between revision %d and %d:\n", r1, r2); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
647 sc.walk(r1, r2, dump); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
648 // |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
649 System.out.println("\n\nSame, but sorted in the way hg status does:"); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
650 HgStatusCollector.Record r = sc.status(r1, r2); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
651 sortAndPrint('M', r.getModified(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
652 sortAndPrint('A', r.getAdded(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
653 sortAndPrint('R', r.getRemoved(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
654 // |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
655 System.out.println("\n\nTry hg status --change <rev>:"); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
656 sc.change(0, dump); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
657 System.out.println("\nStatus against working dir:"); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
658 HgWorkingCopyStatusCollector wcc = new HgWorkingCopyStatusCollector(hgRepo); |
429
cd658b24a620
FIXMEs: javadoc, proper use of constants
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
659 wcc.walk(WORKING_COPY, dump); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
660 System.out.println(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
661 System.out.printf("Manifest of the revision %d:\n", r2); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
662 hgRepo.getManifest().walk(r2, r2, new ManifestDump()); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
663 System.out.println(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
664 System.out.printf("\nStatus of working dir against %d:\n", r2); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
665 r = wcc.status(r2); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
666 sortAndPrint('M', r.getModified(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
667 sortAndPrint('A', r.getAdded(), r.getCopied()); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
668 sortAndPrint('R', r.getRemoved(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
669 sortAndPrint('?', r.getUnknown(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
670 sortAndPrint('I', r.getIgnored(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
671 sortAndPrint('C', r.getClean(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
672 sortAndPrint('!', r.getMissing(), null); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
673 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
674 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
675 private void sortAndPrint(char prefix, List<Path> ul, Map<Path, Path> copies) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
676 ArrayList<Path> sortList = new ArrayList<Path>(ul); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
677 Collections.sort(sortList); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
678 for (Path s : sortList) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
679 System.out.print(prefix); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
680 System.out.print(' '); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
681 System.out.println(s); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
682 if (copies != null && copies.containsKey(s)) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
683 System.out.println(" " + copies.get(s)); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
684 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
685 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
686 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
687 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
688 |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
350
diff
changeset
|
689 private void testStatusInternals() throws HgException { |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
690 HgDataFile n = hgRepo.getFileNode(Path.create("design.txt")); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
691 for (String s : new String[] {"011dfd44417c72bd9e54cf89b82828f661b700ed", "e5529faa06d53e06a816e56d218115b42782f1ba", "c18e7111f1fc89a80a00f6a39d51288289a382fc"}) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
692 // expected: 359, 2123, 3079 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
693 byte[] b = s.getBytes(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
694 final Nodeid nid = Nodeid.fromAscii(b, 0, b.length); |
416
d30083c80d52
Better names - non-confusing and aligned with the rest of API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
695 System.out.println(s + " : " + n.getLength(nid)); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
696 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
697 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
698 |
197
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
699 static void force_gc() { |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
700 Runtime.getRuntime().runFinalization(); |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
701 Runtime.getRuntime().gc(); |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
702 Thread.yield(); |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
703 Runtime.getRuntime().runFinalization(); |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
704 Runtime.getRuntime().gc(); |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
705 Thread.yield(); |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
706 } |
3a7696fb457c
Investigate optimization options to allow fast processing of huge repositories. Fix defect in StatusCollector that lead to wrong result comparing first revision to empty repo (-1 to 0), due to same TIP constant value
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
158
diff
changeset
|
707 |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
708 private static class StatusDump implements HgStatusInspector { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
709 public boolean hideStatusPrefix = false; // hg status -n option |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
710 public boolean showCopied = true; // -C |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
711 public boolean showIgnored = true; // -i |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
712 public boolean showClean = true; // -c |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
713 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
714 public void modified(Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
715 print('M', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
716 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
717 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
718 public void added(Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
719 print('A', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
720 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
721 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
722 public void copied(Path fnameOrigin, Path fnameAdded) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
723 added(fnameAdded); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
724 if (showCopied) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
725 print(' ', fnameOrigin); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
726 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
727 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
728 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
729 public void removed(Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
730 print('R', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
731 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
732 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
733 public void clean(Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
734 if (showClean) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
735 print('C', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
736 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
737 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
738 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
739 public void missing(Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
740 print('!', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
741 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
742 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
743 public void unknown(Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
744 print('?', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
745 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
746 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
747 public void ignored(Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
748 if (showIgnored) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
749 print('I', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
750 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
751 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
752 |
360
150500515714
Report non-critical errors during status operation to handler/inspector
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
753 public void invalid(Path fname, Exception ex) { |
150500515714
Report non-critical errors during status operation to handler/inspector
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
754 System.out.printf("FAILURE: %s\n", fname); |
150500515714
Report non-critical errors during status operation to handler/inspector
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
755 ex.printStackTrace(System.out); |
150500515714
Report non-critical errors during status operation to handler/inspector
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
756 } |
150500515714
Report non-critical errors during status operation to handler/inspector
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
757 |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
758 private void print(char status, Path fname) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
759 if (!hideStatusPrefix) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
760 System.out.print(status); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
761 System.out.print(' '); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
762 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
763 System.out.println(fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
764 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
765 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
766 } |