Mercurial > jhg
annotate cmdline/org/tmatesoft/hg/console/Main.java @ 572:becd2a1310a2
Report file object in case of error to be helpful as much as possible
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Fri, 12 Apr 2013 18:30:55 +0200 |
parents | 2f9ed6bcefa2 |
children | 88afffd39899 |
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; |
a674b8590362
Move file tree history to upper API level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
317
diff
changeset
|
31 import org.tmatesoft.hg.core.HgChangesetTreeHandler; |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
32 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
|
33 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
|
34 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
|
35 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
|
36 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
|
37 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
|
38 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
|
39 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
|
40 import org.tmatesoft.hg.core.Nodeid; |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
41 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
|
42 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
|
43 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
|
44 import org.tmatesoft.hg.internal.DigestHelper; |
229
1ec6b327a6ac
Scope for status reworked: explicit files or a general matcher
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
226
diff
changeset
|
45 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
|
46 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
|
47 import org.tmatesoft.hg.internal.StreamLogFacility; |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
48 import org.tmatesoft.hg.repo.HgBookmarks; |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
49 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
|
50 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
|
51 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
|
52 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
|
53 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
|
54 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
|
55 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
|
56 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
|
57 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
|
58 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
|
59 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
|
60 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
|
61 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
|
62 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
|
63 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
|
64 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
|
65 import org.tmatesoft.hg.repo.HgStatusInspector; |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
66 import org.tmatesoft.hg.repo.HgSubrepoLocation; |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
67 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
|
68 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
|
69 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
|
70 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
|
71 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
|
72 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
|
73 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
|
74 import org.tmatesoft.hg.util.LogFacility; |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
75 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
|
76 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
|
77 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
|
78 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
79 /** |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
80 * Various debug dumps. |
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 * @author Artem Tikhomirov |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
83 * @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
|
84 */ |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
85 @SuppressWarnings("unused") |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
86 public class Main { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
87 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
88 private Options cmdLineOpts; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
89 private HgRepository hgRepo; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
90 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
91 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
|
92 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
|
93 hgRepo = cmdLineOpts.findRepository(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
94 if (hgRepo.isInvalid()) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
95 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
|
96 return; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
97 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
98 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
|
99 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
100 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
101 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
|
102 Main m = new Main(args); |
526
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
103 m.testRevert(); |
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
104 // 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
|
105 // 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
|
106 // m.dumpBookmarks(); |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
107 // m.readConfigFile(); |
483
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
108 // m.dumpCommitLastMessage(); |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
109 // m.buildFileLog(); |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
110 // m.testConsoleLog(); |
270
c6450b0b1fd5
Avoid IAE:nullid when looking into stale merge/state file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
111 // 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
|
112 // m.testRevisionMap(); |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
113 // m.testSubrepos(); |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
114 // 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
|
115 // m.testParents(); |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
116 // m.testEffectiveFileLog(); |
345
58725dd511b3
Provide access to revision's origins
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
341
diff
changeset
|
117 // m.testMergeState(); |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
118 // 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
|
119 // m.dumpBranches(); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
120 // 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
|
121 // m.dumpIgnored(); |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
122 // 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
|
123 // 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
|
124 // 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
|
125 // m.dumpCompleteManifestLow(); |
445
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
126 // 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
|
127 // 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
|
128 } |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
129 |
526
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
130 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
|
131 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
|
132 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
|
133 } |
2f9ed6bcefa2
Initial support for Revert command with accompanying minor refactoring
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
525
diff
changeset
|
134 |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
135 private void testCheckout() throws Exception { |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
136 HgCheckoutCommand coCmd = new HgCheckoutCommand(hgRepo); |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
137 coCmd.changeset(17).execute(); |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
138 } |
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
139 |
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
|
140 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
|
141 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
|
142 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
|
143 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
|
144 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
|
145 } |
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
|
146 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
|
147 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
|
148 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
|
149 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
|
150 } |
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
|
151 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
|
152 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
|
153 } |
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
|
154 |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
155 // TODO as test |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
156 private void dumpBookmarks() throws Exception { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
157 HgBookmarks bm = hgRepo.getBookmarks(); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
158 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
|
159 ArrayList<String> all = new ArrayList<String>(bm.getAllBookmarks()); |
484
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
160 Collections.sort(all); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
161 for (String bmname : all) { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
162 if (bmname.equals(active)) { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
163 System.out.print(" * "); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
164 } else { |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
165 System.out.print(" "); |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
166 } |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
167 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
|
168 } |
ae4d6604debd
Bookmarks support added
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
169 } |
483
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
170 |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
171 // TODO as test |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
172 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
|
173 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
|
174 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
|
175 for (String s : configFile.getSectionNames()) { |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
176 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
|
177 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
|
178 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
|
179 } |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
180 } |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
181 |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
182 } |
e31e85cf4d4c
Handle include and unset directives in config files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
481
diff
changeset
|
183 |
481
a458f9fb00ce
Access to user-supplied message of last commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
479
diff
changeset
|
184 private void dumpCommitLastMessage() throws Exception { |
a458f9fb00ce
Access to user-supplied message of last commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
479
diff
changeset
|
185 System.out.println(hgRepo.getCommitLastMessage()); |
a458f9fb00ce
Access to user-supplied message of last commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
479
diff
changeset
|
186 } |
464
1a3c18d57a8e
MqManager evolution: same PatchRecord instances, list patch queues, detect active queue
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
463
diff
changeset
|
187 |
328
a674b8590362
Move file tree history to upper API level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
317
diff
changeset
|
188 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
|
189 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
|
190 HgLogCommand cmd = new HgLogCommand(hgRepo); |
525
0be5be8d57e9
Repository checkout support, first iteration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
516
diff
changeset
|
191 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
|
192 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
|
193 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
|
194 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
|
195 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
|
196 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
|
197 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
|
198 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
|
199 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
|
200 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
|
201 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
|
202 } |
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
|
203 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
|
204 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
|
205 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
|
206 final HgChangeset cset = entry.changeset(); |
471
7bcfbc255f48
Merge changes from smartgit3 branch into 1.1 stream
Artem Tikhomirov <tikhomirov.artem@gmail.com>
diff
changeset
|
207 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
|
208 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
|
209 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
|
210 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
|
211 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
|
212 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
|
213 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
|
214 } |
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
|
215 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
|
216 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
|
217 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
|
218 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
|
219 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
|
220 System.out.print(", "); |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
221 } |
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
|
222 } |
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
|
223 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
|
224 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
|
225 System.out.print('\t'); |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
226 } |
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
|
227 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
|
228 } |
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
|
229 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
|
230 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
|
231 } |
511
122e0600799f
Respect multiple joins/forks in a history of a single file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
232 count[0]++; |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
233 } |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
234 |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
235 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
|
236 if (adapterClass == HgFileRenameHandlerMixin.class) { |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
237 // 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
|
238 // 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
|
239 // and cache returned value |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
240 // 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
|
241 // 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
|
242 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
|
243 } |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
244 return null; |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
245 } |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
246 }; |
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
511
diff
changeset
|
247 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
|
248 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
|
249 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
|
250 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
|
251 } |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
252 |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
253 private void buildFileLogOld() throws Exception { |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
254 final HgDataFile fn = hgRepo.getFileNode("file1"); |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
255 final int[] fileChangesetRevisions = new int[fn.getRevisionCount()]; |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
256 fn.history(new HgChangelog.Inspector() { |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
257 private int fileLocalRevisions = 0; |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
258 private int[] parentRevisions = new int[2]; |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
259 |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
260 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
|
261 try { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
262 fileChangesetRevisions[fileLocalRevisions] = revisionNumber; |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
263 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
|
264 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
|
265 if (join) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
266 System.out.print("join["); |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
267 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
268 if (parentRevisions[0] != -1) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
269 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
|
270 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
271 if (parentRevisions[1] != -1) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
272 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
|
273 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
274 if (join) { |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
275 System.out.print("]"); |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
276 } |
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
277 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
|
278 } catch (HgRuntimeException ex) { |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
279 ex.printStackTrace(); |
305
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
280 } |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
281 } |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
282 }); |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
283 System.out.println(); |
ae8d116f4ee2
Experimental code to build file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
299
diff
changeset
|
284 } |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
285 |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
286 private void testConsoleLog() { |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
287 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
|
288 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
|
289 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
|
290 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
|
291 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
|
292 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
|
293 Exception ex = new Exception(); |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
442
diff
changeset
|
294 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
|
295 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
|
296 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
|
297 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
|
298 } |
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
290
diff
changeset
|
299 |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
300 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
|
301 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
|
302 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
|
303 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
|
304 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
|
305 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
|
306 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
|
307 count++; |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
308 w.next(); |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
309 } |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
310 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
|
311 } |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
253
diff
changeset
|
312 |
243
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
313 /* |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
314 * cpython repo with 70715 revisions. |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
315 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
|
316 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
|
317 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
|
318 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
|
319 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
|
320 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
|
321 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
|
322 queries |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
323 */ |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
324 private void testRevisionMap() throws Exception { |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
325 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
|
326 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
|
327 int tip = changelog.getLastRevision(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
328 // 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
|
329 final Nodeid[] revs = new Nodeid[5]; |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
330 revs[4] = changelog.getRevision(0); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
331 revs[3] = changelog.getRevision(tip / 4); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
332 revs[2] = changelog.getRevision(tip / 2); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
333 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
|
334 revs[0] = changelog.getRevision(tip); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
335 long start = System.currentTimeMillis(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
336 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
|
337 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
|
338 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
|
339 } |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
340 System.out.println(System.currentTimeMillis() - start); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
341 System.out.println(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
342 // |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
343 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
|
344 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
|
345 long s2 = System.currentTimeMillis(); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
346 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
|
347 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
|
348 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
|
349 } |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
350 System.out.println(System.currentTimeMillis() - start); |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
351 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
|
352 |
0e01f9182e16
External cache Nodeid<->int added, Revlog.RevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
242
diff
changeset
|
353 } |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
354 |
442
6865eb742883
Tests for subrepo API, refactor status tests for reuse, better subrepos API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
433
diff
changeset
|
355 // any repository with subrepositories |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
356 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
|
357 // @see TestSubrepo#testAccessAPI |
239
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
358 for (HgSubrepoLocation l : hgRepo.getSubrepositories()) { |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
359 System.out.println(l.getLocation()); |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
360 System.out.println(l.getSource()); |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
361 System.out.println(l.getType()); |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
362 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
|
363 if (l.getType() == Kind.Hg) { |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
364 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
|
365 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
|
366 if (r.getChangelog().getLastRevision() >= 0) { |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
367 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
|
368 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
|
369 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
370 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
371 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
372 } |
df9d2854d3d6
Initial access to subrepositories
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
373 |
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
|
374 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
|
375 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
|
376 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
|
377 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
|
378 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
|
379 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
|
380 } |
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
|
381 } |
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
|
382 |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
383 private void testParents() throws Exception { |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
384 // hg parents cmd |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
385 final Pair<Nodeid, Nodeid> wcParents = hgRepo.getWorkingCopyParents(); |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
386 ChangesetDumpHandler dump = new ChangesetDumpHandler(hgRepo); |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
387 HgLogCommand cmd = new HgLogCommand(hgRepo); |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
388 if (wcParents.hasFirst()) { |
253
1874d11054e5
HgLogCommand.changeset(Nodeid) to ease command configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
252
diff
changeset
|
389 cmd.changeset(wcParents.first()).execute(dump); |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
390 } |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
391 if (wcParents.hasSecond()) { |
253
1874d11054e5
HgLogCommand.changeset(Nodeid) to ease command configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
252
diff
changeset
|
392 cmd.changeset(wcParents.second()).execute(dump); |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
393 } |
252
a6d19adc2636
HgRepository.getWorkingCopyBranchName() to retrieve branch associated with working directory
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
249
diff
changeset
|
394 System.out.println("Branch:" + hgRepo.getWorkingCopyBranchName()); |
235
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
395 } |
fd845a53f53d
Experimental access to working dir parents
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
233
diff
changeset
|
396 |
242
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
397 /* |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
398 * -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
|
399 * |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
400 * -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
|
401 * 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
|
402 * 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
|
403 * 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
|
404 * 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
|
405 * HgChangelog.range() - 92 calls |
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
406 * 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
|
407 * 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
|
408 */ |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
409 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
|
410 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
|
411 System.out.println(fname); |
242
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
412 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
|
413 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
|
414 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
|
415 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
|
416 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
|
417 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
|
418 } |
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
|
419 }); |
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
|
420 } |
242
ad6a046943be
Improved reading of sparse revisions from a revlog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
239
diff
changeset
|
421 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
|
422 } |
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
|
423 } |
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
|
424 |
231
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
425 private void testMergeState() throws Exception { |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
426 final HgMergeState mergeState = hgRepo.getMergeState(); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
427 mergeState.refresh(); |
270
c6450b0b1fd5
Avoid IAE:nullid when looking into stale merge/state file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
428 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
|
429 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
|
430 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
|
431 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
|
432 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
|
433 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
|
434 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
|
435 System.out.println(); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
436 } |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
437 } |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
438 |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
439 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
|
440 final ByteArrayChannel sink = new ByteArrayChannel(); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
441 r.putContentTo(sink); |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
442 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
|
443 } |
1792b37650f2
Introduced access to conflict resolution information (merge state)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
229
diff
changeset
|
444 |
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
|
445 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
|
446 // 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
|
447 // 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
|
448 // 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
|
449 // 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
|
450 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
|
451 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
|
452 } |
26ad7827a62d
Support status query for a single file or a subdirectory of a repository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
453 |
236
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
454 /* |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
455 * 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
|
456 * 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
|
457 * 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
|
458 */ |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
459 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
|
460 final long start0 = System.currentTimeMillis(); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
461 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
|
462 System.out.println("1:" + (System.currentTimeMillis() - start0)); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
463 for (HgBranches.BranchInfo bi : b.getAllBranches()) { |
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
464 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
|
465 // System.out.print(" "); |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
466 // System.out.print(bi.getStart()); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
467 System.out.print(" "); |
308
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
468 System.out.print(bi.getHeads()); |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
469 if (bi.isClosed()) { |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
470 System.out.print(" x "); |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
471 } |
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
472 System.out.println(); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
473 } |
308
3f40262153a4
Recognize closed branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
305
diff
changeset
|
474 // b.writeCache(); |
236
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
475 // 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
|
476 // 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
|
477 // 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
|
478 // } |
883300108179
Speed up branches calculation when cached branch information is available
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
235
diff
changeset
|
479 // System.out.println("10:" + (System.currentTimeMillis() - start)); |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
480 } |
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
197
diff
changeset
|
481 |
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
|
482 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
|
483 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
|
484 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
|
485 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
|
486 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
|
487 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
|
488 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
|
489 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
|
490 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
|
491 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
|
492 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
493 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
494 private void dumpIgnored() { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
495 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
|
496 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
|
497 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
|
498 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
|
499 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
500 } |
348
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
501 |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
502 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
|
503 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
|
504 |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
505 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
|
506 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
|
507 if (entry.copySource() != null) { |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
508 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
|
509 } |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
510 System.out.println(); |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
511 return true; |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
512 } |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
513 } |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
514 |
348
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
515 private void dumpDirstate() throws Exception { |
a0864b2892cd
Expose errors reading mercurial control files with exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
345
diff
changeset
|
516 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
|
517 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
|
518 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
|
519 |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
520 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
|
521 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
|
522 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
|
523 } |
8faad08c709b
Expose dirstate to allow pre-configuration of FileIterators for status collection in particular
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
524 }); |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
525 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
526 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
527 |
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
|
528 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
|
529 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
|
530 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
|
531 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
|
532 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
|
533 if (fn.exists()) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
534 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
|
535 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
|
536 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
|
537 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
|
538 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
|
539 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
|
540 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
|
541 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
|
542 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
|
543 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
|
544 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
|
545 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
|
546 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
|
547 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
548 } else { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
549 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
|
550 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
551 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
552 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
553 |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
554 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
|
555 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
|
556 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
557 |
424
6437d261048a
Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
558 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
|
559 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
|
560 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
|
561 return true; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
562 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
563 |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
281
diff
changeset
|
564 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
|
565 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
|
566 return true; |
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 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
|
570 System.out.println(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
571 return true; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
572 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
573 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
574 |
366
189dc6dc1c3e
Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
362
diff
changeset
|
575 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
|
576 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
|
577 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
578 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
|
579 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
|
580 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
581 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
|
582 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
|
583 } |
249
4c3b9f679412
Deprecated HgLogCommand.FileRevision gone, top-level HgFileRevision is bright and shiny replacement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
248
diff
changeset
|
584 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
|
585 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
|
586 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
|
587 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
|
588 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
|
589 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
|
590 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
591 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
592 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
|
593 System.out.println(); |
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 }); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
596 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
597 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
598 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
|
599 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
|
600 dump.showIgnored = false; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
601 dump.showClean = false; |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
602 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
|
603 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
|
604 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
|
605 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
|
606 // |
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("\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
|
608 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
|
609 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
|
610 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
|
611 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
|
612 // |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
613 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
|
614 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
|
615 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
|
616 HgWorkingCopyStatusCollector wcc = new HgWorkingCopyStatusCollector(hgRepo); |
429
cd658b24a620
FIXMEs: javadoc, proper use of constants
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
617 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
|
618 System.out.println(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
619 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
|
620 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
|
621 System.out.println(); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
622 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
|
623 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
|
624 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
|
625 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
|
626 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
|
627 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
|
628 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
|
629 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
|
630 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
|
631 } |
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 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
|
634 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
|
635 Collections.sort(sortList); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
636 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
|
637 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
|
638 System.out.print(' '); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
639 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
|
640 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
|
641 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
|
642 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
643 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
644 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
645 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
646 |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
350
diff
changeset
|
647 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
|
648 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
|
649 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
|
650 // 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
|
651 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
|
652 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
|
653 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
|
654 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
655 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
656 |
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
|
657 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
|
658 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
|
659 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
|
660 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
|
661 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
|
662 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
|
663 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
|
664 } |
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
|
665 |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
666 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
|
667 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
|
668 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
|
669 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
|
670 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
|
671 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
672 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
|
673 print('M', fname); |
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 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
676 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
|
677 print('A', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
678 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
679 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
680 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
|
681 added(fnameAdded); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
682 if (showCopied) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
683 print(' ', fnameOrigin); |
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 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
|
688 print('R', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
689 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
690 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
691 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
|
692 if (showClean) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
693 print('C', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
694 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
695 } |
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 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
|
698 print('!', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
699 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
700 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
701 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
|
702 print('?', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
703 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
704 |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
705 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
|
706 if (showIgnored) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
707 print('I', fname); |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
708 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
709 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
710 |
360
150500515714
Report non-critical errors during status operation to handler/inspector
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
711 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
|
712 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
|
713 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
|
714 } |
150500515714
Report non-critical errors during status operation to handler/inspector
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
715 |
143
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
716 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
|
717 if (!hideStatusPrefix) { |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
718 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
|
719 System.out.print(' '); |
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 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
|
722 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
723 } |
b9700740553a
Command line tools parse and respect most of command-line arguments
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
724 } |