« back to all changes in this revision
Viewing changes to fai/cmdutil.py
- browse files at revision 63
- compare with another revision
- download diff
- download tarball
- view history from revision 63
- Committer: Aaron Bentley
- Date: 2005-06-07 18:52:04 UTC
- Revision ID: abentley@panoramicfeedback.com-20050607185204-5fc1f0e3d393b909
Added NEWS, obsoleted bzr-pull
- files removed:
- :61
- debian
- fai
- fai/.arch-ids
- fai/aba
- fai/aba/.arch-ids
- fai/aba/commands
- fai/aba/commands/.arch-ids
- fai/aba/options
- fai/aba/options/.arch-ids
- fai/arch
- fai/arch/.arch-ids
- fai/arch/backends
- fai/arch/backends/.arch-ids
- fai/arch/tests
- fai/arch/tests/.arch-ids
- fai/command
- fai/command/.arch-ids
- fai/doxygen
- fai/doxygen/.arch-ids
- fai/pylon
- fai/pylon/.arch-ids
- fai/pylon/testdata
- fai/pylon/testdata/.arch-ids
- fai/python-dateutil-0.4
- fai/python-dateutil-0.4/.arch-ids
- fai/python-dateutil-0.4/dateutil
- fai/python-dateutil-0.4/dateutil/.arch-ids
- testdata
- tests
- files renamed:
- bzrtools.py => scriptlib.py
- files modified:
- .bzrignore
added
removed
fai/cmdutil.py
1
# Copyright (C) 2004 Aaron Bentley
2
# <aaron.bentley@utoronto.ca>
3
#
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
8
#
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
# GNU General Public License for more details.
13
#
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18
import options
19
import os
20
import sys
21
import pybaz as arch
22
23
import pylon
24
from pylon.errors import *
25
from pylon import errors
26
from pylon import paths
27
from pylon import util
28
29
import shutil
30
import datetime
31
import dateutil.parser
32
import optparse
33
import re
34
from optparse import OptionGroup
35
import add_tagline
36
from add_tagline import AlreadyTagged, NoCommentSyntax
37
import terminal
38
39
__docformat__ = "restructuredtext"
40
__doc__ = "Utility functions to be used by commands"
41
42
43
def alias_endpoint(spectype, spec):
44
"""Determines the endpoint for iteration. Assumes input is of the form \
45
"tprev" or "tprev:5".
46
47
:param spectype: The leading portion of the specification, e.g. "tprev"
48
:type spectype: string
49
:param spec: The actual spec
50
:type spec: string
51
:return: The endpoint to use
52
:rtype: integer
53
"""
54
if len(spec)>len(spectype+":"):
55
try:
56
endpoint=int(spec[len(spectype+":"):])
57
except ValueError:
58
raise errors.CantDetermineRevision(spec,
59
"\""+spec[len(spectype+":"):]\
60
+"\" is not an integer.")
61
if endpoint < 0:
62
raise errors.CantDetermineRevision(spec, "\""+str(endpoint)+\
63
"\" is negative.")
64
65
else:
66
endpoint=1
67
return endpoint
68
69
70
def determine_version_arch(arg, tree):
71
"""
72
Returns an `arch.Version`, using the default archive if necessary.
73
74
:param arg: version name
75
:type arg: str
76
:rtype: `arch.Version`
77
"""
78
name=arch.NameParser(expand_alias(arg, tree))
79
if not name.is_version():
80
raise CantDetermineVersion(arg, "\"%s\" is not a version" % name)
81
if not name.has_archive():
82
return arch.Version(
83
str(arch.default_archive())+"/"+ name.get_package_version())
84
else:
85
return arch.Version(name)
86
87
def determine_version_tree(arg, tree):
88
"""
89
Returns an `arch.Version`, using the tree-version archive if necessary.
90
91
:param arg: version name
92
:type arg: str
93
:param tree: The tree to use for getting the archive (if needed).
94
:type tree: `arch.ArchSourceTree`
95
:rtype: `arch.Version`
96
"""
97
if arg is None:
98
return tree.tree_version
99
name=arch.NameParser(expand_alias(arg, tree))
100
if not name.is_version():
101
raise CantDetermineVersion(arg, "\"%s\" is not a version" % name)
102
if not name.has_archive():
103
return arch.Version(
104
str(tree.tree_version.archive)+"/"+
105
name.get_package_version())
106
else:
107
return arch.Version(name)
108
109
110
def determine_version_or_revision_tree(tree, spec):
111
name=arch.NameParser(expand_alias(arg.tree))
112
if name.is_version():
113
return determine_version_tree(name, tree)
114
else:
115
return determine_revision_tree(tree, name)
116
117
118
def expand_prefix_alias(args, tree, prefix="^"):
119
"""
120
Treats all arguments that have the prefix as aliases, and expands them.
121
122
:param args: The list of arguments.
123
:type args: List of str
124
:param tree: The current tree (or None, if there is no current tree)
125
:type tree: `arch.ArchSourceTree`
126
:param prefix: The prefix to use for aliases
127
:type prefix: str
128
:rtype: list of str
129
"""
130
expanded=[]
131
for segment in args:
132
if segment.startswith(prefix):
133
cropped=segment[len(prefix):]
134
expansion=expand_alias(cropped, tree)
135
if expansion != cropped:
136
expanded.append(str(expansion))
137
else:
138
expanded.append(segment)
139
return expanded
140
141
142
def tag_cur(tree):
143
"""Determine the latest revision of the version of the tag source.
144
145
:param tree: The tree to determine the current revision of
146
:type tree: `arch.WorkingTree`
147
:return: The archive-latest revision of the tag source version
148
:rtype: `arch.Revision`
149
"""
150
if tree==None:
151
raise CantDetermineRevision("tagcur", "No source tree available.")
152
spec = pylon.tag_source(tree)
153
if spec is None:
154
raise CantDetermineRevision("tagcur",
155
"This revision has no ancestor version.")
156
ensure_archive_registered(spec.version.archive)
157
spec = spec.version.iter_revisions(reverse=True).next()
158
return spec
159
160
161
def expand_alias(spec, tree):
162
"""
163
Attempts to perform alias expansion on a given spec. Will expand both \
164
automatic aliases and user-specified aliases
165
166
:param spec: The specification to expand.
167
:type spec: string
168
:param tree: The current working tree
169
:type tree: `arch.ArchSourceTree`
170
:return: The expanded result, or spec if no expansion was done
171
:rtype: string or Revision
172
173
"""
174
name = arch.NameParser(spec)
175
if name.is_version() or name.has_patchlevel():
176
return spec
177
if spec.startswith("^"):
178
spec=spec[1:]
179
if pylon.paths.is_url_path(spec):
180
try:
181
spec, dummy=pylon.paths.full_path_decode(spec)
182
except pylon.paths.CantDecode, e:
183
pass
184
185
elif spec.startswith("tprev"):
186
if tree==None:
187
raise CantDetermineRevision(spec, "No source tree available.")
188
189
iter = tree.iter_logs(reverse=True)
190
endpoint=alias_endpoint("tprev", spec)
191
try:
192
for q in range(endpoint):
193
iter.next()
194
spec = iter.next().revision
195
except StopIteration:
196
raise CantDetermineRevision(spec,
197
"Value \"%d\" is out of range." % endpoint)
198
elif spec.startswith("tcur"):
199
if tree==None:
200
raise CantDetermineRevision(spec, "No source tree available.")
201
version = None
202
try:
203
if len(spec)>4:
204
version=determine_version_tree(expand_alias(spec[5:], tree),
205
tree)
206
spec = tree.iter_logs(version, reverse=True).next().revision
207
except StopIteration:
208
if version is None:
209
version = "default version (%s)" % str(tree.tree_version)
210
raise CantDetermineRevision(spec,
211
"Tree contains no logs for %s." % str(version))
212
elif spec == "ttag":
213
if tree==None:
214
raise CantDetermineRevision(spec, "No source tree available.")
215
spec = pylon.tag_source(tree)
216
if spec is None:
217
raise CantDetermineRevision("ttag",
218
"This revision has no ancestor version.")
219
220
elif spec == "tagcur":
221
spec = tag_cur(tree)
222
223
elif spec.startswith("tanc"):
224
iter = pylon.iter_ancestry(tree)
225
endpoint=alias_endpoint("tanc", spec)
226
try:
227
for q in range(endpoint):
228
iter.next()
229
spec = iter.next()
230
except StopIteration:
231
raise CantDetermineRevision(spec,
232
"Value \"%d\" is out of range." % endpoint)
233
234
elif spec.startswith("tmod:"):
235
try:
236
return modified_iter(spec[5:], tree).next().revision
237
except StopIteration, e:
238
raise CantDetermineRevision(spec,
239
"Can't find a revision that changed \"%s\"." % spec[5:])
240
241
242
elif spec.startswith("tdate:"):
243
default=datetime.datetime.now().replace(hour=23, minute=59, second=59,
244
microsecond=999999)
245
try:
246
date = dateutil.parser.parse(spec[6:], default=default).timetuple()
247
except ValueError, e:
248
raise CantDetermineRevision(spec, str(e))
249
if date > default.timetuple():
250
raise CantDetermineRevision(spec, "Date is in the future.")
251
revision = None
252
for log in pylon.iter_any_ancestry(tree, tree.tree_revision):
253
if not isinstance(log, arch.Patchlog):
254
break
255
if log.date <= date:
256
revision = log.revision
257
break
258
if revision is None:
259
raise CantDetermineRevision(spec, "No logs found for date \"%s\"."\
260
% spec[6:])
261
spec = revision
262
263
elif spec.startswith("acur"):
264
if len(spec)>4:
265
version=determine_version_arch(expand_alias(spec[5:], tree), tree)
266
elif tree:
267
version=tree.tree_version
268
else:
269
raise CantDetermineRevision(spec, "No source tree available.")
270
ensure_archive_registered(version.archive)
271
spec=version.iter_revisions(True).next()
272
273
elif spec.startswith("mergeanc"):
274
if tree is None:
275
raise CantDetermineRevision(spec, "No source tree available.")
276
277
if spec == "mergeanc":
278
try:
279
other_version = pylon.iter_partners(tree).next()
280
other_revision = other_version.iter_revisions(True).next()
281
except StopIteration, e:
282
other_revision = tag_cur(tree)
283
else:
284
other_revision = determine_revision_arch(tree,
285
spec[len("mergeanc:"):])
286
other_tree = pylon.find_or_make_local_revision(other_revision)
287
merge_anc = pylon.merge_ancestor2(tree, other_tree,
288
other_revision)
289
if merge_anc is None:
290
raise CantDetermineRevision(spec, "Can't find a common ancestor.")
291
return merge_anc
292
293
elif spec.startswith("micro"):
294
specsection = spec.split(':')
295
if len(specsection) > 1:
296
version = determine_version_arch(specsection[1], tree)
297
else:
298
version = tree.tree_version
299
try:
300
return pylon.iter_micro(tree, version).next().revision
301
except StopIteration, e:
302
raise CantDetermineRevision(spec, "No next microbranch revision")
303
304
else:
305
expansion=None
306
if '@' in spec:
307
return spec
308
for parts in pylon.iter_all_alias(tree):
309
if spec.startswith(parts[0]):
310
expansion=parts[1]+spec[len(parts[0]):]
311
if expansion != None:
312
spec = expansion
313
return spec
314
315
316
def determine_revision_arch(tree, spec=None, check_existence=True, allow_package=False):
317
"""
318
Determines a revision from a revision, patchlevel, package-version, or package.
319
Uses the archive to supply missing elements.
320
321
:param tree: The working tree, used to interpret patchlevels
322
:type tree: `arch.WorkingTree`
323
:param spec: The name specification
324
:type spec: string
325
"""
326
name = None
327
if spec!=None:
328
spec=expand_alias(spec, tree)
329
name = arch.NameParser(spec)
330
elif tree:
331
name = arch.NameParser(tree.tree_version)
332
else:
333
raise CantDetermineRevision("", "Not using a source tree.")
334
if name.has_patchlevel() or name.is_version() or (allow_package and name.is_package()):
335
if not name.has_archive():
336
archive=arch.default_archive()
337
if archive is None:
338
raise CantDetermineRevision(spec, "No default archive is set")
339
name=arch.NameParser(str(archive)+"/"+str(name))
340
if name.has_patchlevel():
341
return arch.Revision(name)
342
343
if name.is_version():
344
version = arch.Version(name)
345
ensure_archive_registered(version.archive)
346
try:
347
return get_latest_revision_anywhere(version)
348
except StopIteration:
349
if not arch.Version(name).exists():
350
raise CantDetermineRevision(spec, "The version \""+str(name)+"\" does not exist")
351
else:
352
raise CantDetermineRevision(spec, "The version \""+str(name)+"\" has no revisions")
353
354
except Exception, e:
355
print e
356
raise CantDetermineRevision(spec,
357
"Error listing revisions for \""+str(name)+"\".")
358
359
elif (allow_package and name.is_package()):
360
branch = arch.Branch(name)
361
ensure_archive_registered(branch.archive)
362
try:
363
return get_latest_revision_anywhere(branch)
364
except StopIteration:
365
if not arch.Branch(name).exists():
366
raise CantDetermineRevision(spec, "The package \""+str(name)+"\" does not exist")
367
else:
368
raise CantDetermineRevision(spec, "The package \""+str(name)+"\" has no revisions")
369
370
except Exception, e:
371
print e
372
raise CantDetermineRevision(spec,
373
"Error listing revisions for \""+str(name)+"\".")
374
375
else:
376
if tree is None:
377
raise CantDetermineRevision(spec, "Not in a project tree")
378
name=arch.NameParser(str(tree.tree_version)+"--"+spec)
379
if not name.has_patchlevel():
380
raise CantDetermineRevision(spec,
381
"Not a revision, package-version, or patchlevel.")
382
return arch.Revision(name)
383
384
def determine_revision_tree(tree, spec=None):
385
"""
386
Determines a revision from a revision, patchlevel, or package-version.
387
388
Uses the tree to supply missing elements
389
390
:param tree: The tree to use by default
391
:type tree: `arch.ArchSourceTree`
392
:param spec: The revision specification
393
:type spec: string
394
:rtype: `arch.Revision`
395
"""
396
name = None
397
if spec!=None:
398
spec=expand_alias(spec, tree)
399
name = arch.NameParser(spec)
400
else:
401
name = arch.NameParser(str(tree.tree_version))
402
403
revision = None
404
if name.is_version():
405
try:
406
version = name.get_package_version()
407
if name.has_archive():
408
version = name.get_archive()+"/"+version
409
else:
410
version = arch.Version(str(tree.tree_version.archive)
411
+"/"+version)
412
revision = tree.iter_logs(version, True).next().revision
413
except StopIteration:
414
raise CantDetermineRevision(spec,
415
"No revisions present for this version.")
416
elif name !=None:
417
if not name.has_patchlevel():
418
name = arch.NameParser (str(tree.tree_version) +"--"+ name)
419
if name.has_patchlevel():
420
revision=name.get_nonarch()
421
if not name.has_archive():
422
name = arch.NameParser (str(tree.tree_version))
423
revision = name.get_archive()+"/"+revision
424
if revision == None:
425
raise CantDetermineRevision(spec,
426
"Not a revision, package-version, or patchlevel.")
427
return arch.Revision(revision)
428
429
def determine_version_revision_tree(spec, tree):
430
"""Get a version or revision from tree and input. Version preferred.
431
432
:param spec: A revision, version, patchlevel or alias
433
:type spec: str
434
:param tree: The tree to use for determining revision/version info
435
:type tree: `arch.ArchSourceTree`
436
:return: The version or revision specified
437
:rtype: `arch.Version` or `arch.Revision`
438
"""
439
try:
440
return determine_version_tree(spec, tree)
441
except errors.CantDetermineVersion, e:
442
return determine_revision_tree(tree, spec)
443
444
445
def show_diffs(changeset):
446
"""
447
Print diff output for a changeset.
448
449
:param changeset: the name of the changeset
450
:type changeset: string
451
"""
452
453
for line in pylon.diff_iter2(changeset):
454
colorize(line)
455
456
457
def show_custom_diffs(changeset, diffargs, orig, mod):
458
"""
459
Generates and displays alternative diffs for a changeset.
460
:param changeset: The (initialized) ChangesetMunger to generate diffs for
461
:type changeset: `pylon.ChangesetMunger`
462
:param diffargs: The arguments to pass to diff
463
:type diffargs: list of str
464
:param orig: The path to the ORIG directory
465
:type orig: str
466
:param mod: The path to the MOD directory
467
:type mod: str
468
"""
469
try:
470
for entry in changeset.get_entries().itervalues():
471
if entry.diff is None:
472
continue
473
try:
474
print pylon.invoke_diff(orig, entry.orig_name, mod,
475
entry.mod_name,
476
diffargs).rstrip("\n")
477
except pylon.BinaryFiles:
478
pass
479
except arch.util.ExecProblem, e:
480
print e.proc.error
481
482
483
def colorize (item, suppress_chatter=False):
484
"""
485
Colorizes and prints tla-style output, according to class type.
486
487
Colorizing can be disabled by setting options.colorize to false.
488
489
:param item: The item to display
490
:type item: Any tla output object, string
491
:param suppress_chatter: If true, no chatter output is displayed.
492
:type suppress_chatter: bool
493
"""
494
if options.colorize not in ('yes', 'no', 'maybe'): raise BadOption
495
colorize = options.colorize
496
if colorize == 'maybe':
497
if sys.stdout.isatty() and terminal.has_ansi_colors():
498
colorize = 'yes'
499
else:
500
colorize = 'no'
501
502
if colorize == 'no':
503
print item
504
return
505
if isinstance(item, arch.Chatter):
506
if not suppress_chatter:
507
print terminal.colorstring(str(item), 'yellow')
508
#sys.stdout.write(term_title("Fai: %s" % item.text))
509
elif isinstance(item, arch.PatchConflict):
510
print terminal.colorstring(str(item), 'white', True, 'red')
511
elif isinstance(item, arch.FileAddition):
512
print terminal.colorstring(str(item), 'green')
513
elif isinstance(item, arch.FileDeletion):
514
print terminal.colorstring(str(item), 'red', True)
515
elif isinstance(item, arch.FileModification):
516
print terminal.colorstring(str(item), 'magenta', True)
517
elif isinstance(item, arch.FilePermissionsChange):
518
print terminal.colorstring(str(item), 'magenta')
519
elif isinstance(item, arch.FileRename):
520
print "=> "+terminal.colorstring(item.oldname, 'red', True)+"\t"+terminal.colorstring(item.name, 'green')
521
elif isinstance(item, pylon.DiffFilenames):
522
print terminal.colorstring("---"+item.orig, 'red', True)
523
print terminal.colorstring("+++"+item.mod, 'green')
524
elif isinstance(item, pylon.DiffHunk):
525
print terminal.colorstring(str(item), 'blue')
526
elif isinstance(item, pylon.DiffAddLine):
527
print terminal.colorstring(str(item), 'green')
528
elif isinstance(item, pylon.DiffRemoveLine):
529
print terminal.colorstring(str(item), 'red', True)
530
elif isinstance(item, pylon.DiffLine):
531
print item
532
else:
533
print item
534
sys.stdout.flush()
535
536
537
def confirm(question, default=False):
538
"""
539
Prompts a user to confirm or deny an action.
540
541
:param question: The question to ask
542
:type question: string
543
:param default: The default choice
544
:type default: boolean
545
"""
546
547
while True:
548
sys.stdout.write(question)
549
if default:
550
sys.stdout.write(" [Y/n] ")
551
else:
552
sys.stdout.write(" [y/N] ")
553
answer=sys.stdin.readline().strip().lower()
554
if answer=="y":
555
return True
556
elif answer=="n":
557
return False
558
elif answer=="":
559
return default
560
561
562
def prompt(type):
563
"""
564
Prompts the user to decide whether to perform an action
565
566
Prompts can be overridden by setting their option to "always" or "never"
567
:param type: the prompt type, as defined in options
568
:type type: string
569
"""
570
if options.prompts[type]=="always":
571
return True
572
elif options.prompts[type]=="never":
573
return False
574
elif options.prompts[type]=="occasionally":
575
return confirm(options.promptquestions[type], False)
576
elif options.prompts[type]=="often":
577
return confirm(options.promptquestions[type], True)
578
else:
579
raise BadOption
580
581
def get_mirror_source(archive):
582
"""
583
Returns the source of a mirror, if available. If not available, or
584
if the archive is not a mirror, returns None. We check whether it's a
585
mirror second, to reduce network use.
586
587
:param archive: The archive to find the source for
588
:type archive: `arch.Archive`
589
"""
590
591
sourcename=str(archive)+"-SOURCE"
592
for arch_entry in arch.iter_archives():
593
if str(arch_entry) == sourcename and archive.is_mirror:
594
return sourcename
595
return None
596
597
def get_best_branch_or_version(branch_version):
598
"""
599
Returns the most authentic Branch or Version available. If there is a mirror source,
600
returns the version for that. Otherwise, returns the input.
601
602
:param branch_version: The `arch.Version` to retrieve the version of
603
:type branch_version: `arch.Version` or `arch.Branch`
604
605
"""
606
maybe_source = arch.Archive(str(branch_version.archive)+"-SOURCE")
607
if not (maybe_source.is_registered() and prompt("Source latest revision")):
608
return branch_version
609
610
source=get_mirror_source(branch_version.archive)
611
if source is None:
612
return branch_version
613
elif arch.NameParser(branch_version).is_package():
614
return arch.Branch(source+"/"+branch_version.nonarch)
615
else:
616
return arch.Version(source+"/"+branch_version.nonarch)
617
618
def get_latest_revision_anywhere(branch_version):
619
"""
620
Returns the latest revision of the branch or version. If a mirror source is
621
available, uses that. Otherwise, uses the normal archive. Revisions
622
are returned in terms of their official name, not -SOURCE
623
624
:param branch_version: The version to find the latest revision for
625
:type branch_version: `arch.Version` or `arch.Branch`
626
:rtype: `arch.Revision`
627
"""
628
ensure_archive_registered(branch_version.archive)
629
source_branch_version = get_best_branch_or_version(branch_version)
630
if not source_branch_version.exists():
631
raise StopIteration
632
source_revision = source_branch_version.iter_revisions(True).next()
633
revision = arch.Revision(str(branch_version.archive) + "/"+
634
source_revision.nonarch)
635
return revision
636
637
638
def update(revision, tree, patch_forward=False):
639
"""
640
Puts the given revision in a tree, preserving uncommitted changes
641
642
:param revision: The revision to get
643
:param tree: The tree to update
644
"""
645
command=['update', '--dir', str(tree)]
646
if patch_forward:
647
command.append('--forward')
648
command.append(str(revision))
649
return arch.util.exec_safe_iter_stdout('tla', command, expected=(0, 1, 2))
650
651
652
def apply_delta(a_spec, b_spec, tree, ignore_present=False):
653
"""Apply the difference between two things to tree.
654
655
:param a_spec: The first thing to compare
656
:type a_spec: `arch.Revision`, `arch.ArchSourceTree`
657
:param b_spec: The first thing to compare
658
:type b_spec: `arch.Revision`, `arch.ArchSourceTree`
659
:param tree: The tree to apply changes to
660
:type tree: `arch.ArchSourceTree`
661
:rtype: Iterator of changeset application output
662
"""
663
tmp=pylon.util.tmpdir(tree)
664
changeset=tmp+"/changeset"
665
delt=arch.iter_delta(a_spec, b_spec, changeset)
666
for line in delt:
667
yield line
668
yield arch.Chatter("* applying changeset")
669
for line in delt.changeset.iter_apply(tree, ignore_present):
670
yield line
671
shutil.rmtree(tmp)
672
673
674
def iter_apply_delta_filter(iter):
675
show_file_changes=False
676
for line in iter:
677
if pylon.chattermatch(line, "applying changeset"):
678
show_file_changes=True
679
if pylon.chattermatch(line, "changeset:"):
680
pass
681
elif not show_file_changes and isinstance(line, arch.MergeOutcome):
682
pass
683
else:
684
yield line
685
686
687
def find_editor():
688
"""
689
Finds an editor to use. Uses the EDITOR environment variable.
690
691
:rtype: string
692
"""
693
if os.environ.has_key("EDITOR") and os.environ["EDITOR"] != "":
694
return os.environ["EDITOR"]
695
else:
696
raise NoEditorSpecified
697
698
699
def invoke_editor(filename):
700
"""
701
Invokes user-specified editor.
702
703
:param filename: The file to edit
704
:type filename: string
705
"""
706
os.system("%s %s" % (find_editor(), filename))
707
708
def iter_reverse(iter):
709
"""Produce brute-force reverse iterator.
710
711
:param iter: The iterator to run through in reverse
712
:type iter: Iterator of any
713
:rtype: reversed list of any
714
"""
715
reversed = list(iter)
716
reversed.reverse()
717
return reversed
718
719
def iter_cacherevs(version, reverse=False):
720
"""Iterates through cached revisions as revisions, not patchlevels"""
721
iter = version.iter_cachedrevs()
722
if not reverse:
723
return iter
724
else:
725
return iter_reverse(iter)
726
727
def iter_present(tree, version, reverse=False):
728
"""The inverse of skip-present. Iterates through revisions that are
729
missing, but merge revisions already present in the tree.
730
:param tree: The tree to look for patchlogs in
731
:type tree: `arch.ArchSourceTree`
732
:param version: The version of patchlogs to look for
733
:type version: `arch.Version`
734
:param reverse: If true, go in reverse
735
:type reverse: bool
736
"""
737
miss = pylon.iter_missing(tree, version, reverse)
738
miss_skip = pylon.iter_missing(tree, version, reverse, skip_present=True)
739
for skip_revision in miss_skip:
740
for miss_revision in miss:
741
if miss_revision == skip_revision:
742
break
743
yield miss_revision
744
for miss_revision in miss:
745
yield miss_revision
746
747
748
def iter_partner_missing(tree, reverse=False, skip_present=False):
749
"""Generate an iterator of all missing partner revisions.
750
751
:param tree: The tree that may be missing revisions from partners
752
:type tree: `arch.ArchSourceTree`
753
:param reverse: If true, perform iteration in reverse
754
:type reverse: bool
755
:return: Iterator of missing partner revisions
756
:rtype: Iterator of `arch.Revision`
757
"""
758
pylon.valid_tree_root(tree)
759
for version in pylon.iter_partners(tree, tree.tree_version):
760
ensure_archive_registered(version.archive)
761
for revision in pylon.iter_missing(tree, version, reverse,
762
skip_present):
763
yield revision
764
765
def iter_skip(iter, skips=0):
766
"""Ajusts an iteration list by skipping items at beginning or end. May
767
modify original iterator.
768
769
:param iter: The base iterator to use.
770
:type iter: Iterator of anything
771
:param skips: Positive numbers skip from the beginning. Negative numbers
772
skip from the end.
773
:type skips: int
774
:return: an iterator that starts or stops at a different place
775
:rtype: iterator of iter's iter type
776
"""
777
if skips == 0:
778
return iter;
779
if skips > 0:
780
for q in range(skips):
781
iter.next()
782
return iter
783
if skips < 0:
784
return iter_skip_end(iter, -skips)
785
786
def iter_skip_end(iter, skips):
787
"""Generates an iterator based on iter that skips the last skips items
788
789
:param skips: number of items to skip from the end.
790
:type skips: int
791
:return: an iterator that stops at a different place
792
:rtype: iterator of iter's iteration type
793
"""
794
iter = iter_skip(iter, -skips + 1)
795
item = None
796
for it in iter:
797
if item is not None:
798
yield item
799
item = it
800
801
def modified_iter(modified, tree, originator=False):
802
sections = modified.split(':')
803
revision = tree.tree_revision
804
if len(sections) == 1:
805
return pylon.iter_changedfile(tree, revision, sections[0])
806
elif len(sections) == 2 and originator:
807
return pylon.iter_changed_file_line_orig(tree, revision,
808
sections[0],
809
int(sections[1]))
810
elif len(sections) == 2:
811
return pylon.iter_changed_file_line(tree, revision,
812
sections[0],
813
int(sections[1]))
814
815
816
def iter_combine(iterators):
817
"""Generate an iterator that iterates through the values in several.
818
:param iterators: The iterators to get values from
819
:type iterators: List of iterator
820
:rtype: iterator of input iterators' value type
821
"""
822
for iterator in iterators:
823
for value in iterator:
824
yield value
825
826
827
def is_tla_command(command):
828
"""Determines whether the specified string is a tla command.
829
830
:param command: The string to check
831
:type command: str
832
:rtype: bool"""
833
for line in pylon.iter_tla_commands():
834
if (line == command):
835
return True
836
return False
837
838
839
840
class BadCommandOption:
841
def __init__(self, message):
842
self.text = message
843
844
def __str__(self):
845
return self.text
846
847
def raise_get_help(option, opt, value, parser):
848
raise GetHelp
849
850
851
class CmdOptionParser(optparse.OptionParser):
852
def __init__(self, usage):
853
optparse.OptionParser.__init__(self, usage)
854
self.remove_option("-h")
855
self.add_option("-h", "--help", action="callback",
856
callback=raise_get_help, help="Print a help message")
857
858
def error(self, message):
859
raise BadCommandOption(message)
860
861
def iter_options(self):
862
return iter_combine([self._short_opt.iterkeys(),
863
self._long_opt.iterkeys()])
864
865
866
def add_tagline_or_explicit_id(file, tltl=False, implicit=False):
867
"""This is basically a wrapper for add-tagline
868
869
:param file: The file to add an id for
870
:type file: str
871
:param tltl: Use lord-style tagline
872
:type tltl: bool
873
"""
874
opt = optparse.Values()
875
opt.__dict__["tltl"] = tltl
876
opt.__dict__["id"] = None
877
opt.__dict__["implicit"] = implicit
878
879
if not os.path.isfile(file) or os.path.islink(file):
880
pylon.add_id([file])
881
return
882
try:
883
add_tagline.tagFile(file, opt)
884
except add_tagline.NoCommentSyntax:
885
print "Can't use tagline for \"%s\" because no comment sytax known." % \
886
file
887
if prompt("Fallthrough to explicit"):
888
pylon.add_id([file])
889
else:
890
raise
891
892
browse_memo = {}
893
894
def iter_browse_memo(search):
895
"""Memoized version of iter_browse.
896
:param search: The string to find entries for
897
:type search: str
898
:return: Any categories, branches, versions that matched
899
:rtype: iterator of `arch.Category`, `arch.Branch`, `arch.Version`, \
900
`arch.Revision`
901
"""
902
global browse_memo
903
if arch.NameParser.is_archive_name(search):
904
archive = search
905
else:
906
name = arch.NameParser(search)
907
archive = name.get_archive()
908
if not browse_memo.has_key(str(archive)):
909
browse_memo[str(archive)] = list(pylon.iter_browse(archive))
910
911
for entry in browse_memo[str(archive)]:
912
if str(entry).startswith(search):
913
yield entry
914
915
916
def iter_revision_completions(arg, tree):
917
if arg.count('/') == 0:
918
for completion in arch.iter_archives():
919
yield str(completion)+"/"
920
for completion in pylon.iter_all_alias(tree):
921
yield completion[0]
922
923
default_archive = str(arch.default_archive())
924
if default_archive is not None:
925
default_archive_arg = default_archive+'/'+arg
926
for completion in iter_browse_memo(default_archive_arg):
927
completion = str(completion)
928
if completion.startswith(default_archive_arg) and \
929
completion != default_archive_arg:
930
yield completion[len(default_archive)+1:]
931
932
else:
933
if arg.endswith('/'):
934
arg = arg[:-1]
935
try:
936
expansion = expand_alias(arg, tree)
937
for completion in iter_browse_memo(expansion):
938
completion = str(completion)
939
if completion.startswith(expansion) and completion != expansion:
940
yield arg + completion[len(expansion):]
941
except Exception, e:
942
print e
943
944
945
def ensure_archive_registered(archive, location=None):
946
if archive.is_registered():
947
return
948
user_supplied = False
949
if location is None:
950
colorize (arch.Chatter("* Looking up archive %s" % archive))
951
home = None
952
mirror = None
953
954
try:
955
colorize (arch.Chatter("* Checking bonehunter.rulez.org"))
956
home = pylon.bh_lookup(archive)
957
except ArchiveLookupError, e:
958
print e
959
960
if home is not None:
961
print "Found location %s" % home
962
if prompt("Use lookup location"):
963
location = home
964
if location is None:
965
try:
966
colorize (arch.Chatter("* Checking sourcecontrol.net"))
967
(home, mirror) = pylon.sc_lookup(archive)
968
if home is not None:
969
print "Found location %s" % home
970
if prompt("Use lookup location"):
971
location = home
972
if location is None and mirror is not None:
973
print "Found mirror location %s" % mirror
974
if prompt("Use lookup mirror location"):
975
location = mirror
976
except ArchiveLookupError, e:
977
print e
978
if location is None:
979
print "If you know the location for %s, please enter it here." % \
980
archive
981
location = raw_input("Fai> ")
982
if location == "":
983
location = None
984
else:
985
user_supplied = True
986
987
if location is None:
988
raise arch.errors.ArchiveNotRegistered(archive)
989
990
print "Registering archive \""+str(archive)+"\""
991
if location_cacheable(location) and prompt("Register cached"):
992
cached_location="cached:"+location
993
ar = register_archive(str(archive), cached_location, str(archive))
994
elif prompt ("Make local mirror"):
995
ar = arch.Archive(str(archive)+"-SOURCE")
996
if not ar.is_registered():
997
ar = register_archive(str(archive)+"-SOURCE", location, str(archive))
998
ar.make_mirror(str(archive),
999
os.path.expanduser(options.mirror_path)+"/"+str(archive))
1000
1001
else:
1002
ar = register_archive(str(archive), location, str(archive))
1003
if user_supplied and prompt("Submit user-supplied"):
1004
pylon.bh_submit(archive, location)
1005
1006
pylon.ensure_archive_registered = ensure_archive_registered
1007
1008
def location_cacheable(location):
1009
return not location.startswith('/') and not location.startswith('cached:')\
1010
and pylon.ArchParams().exists('=arch-cache')
1011
1012
def ensure_revision_exists(revision):
1013
ensure_archive_registered(revision.archive)
1014
if revision.exists():
1015
return
1016
source = get_mirror_source(revision.archive)
1017
if source is not None:
1018
if arch.Revision(str(source)+"/"+revision.nonarch).exists():
1019
cmd = pylon.mirror_archive(str(source), str(revision.archive),
1020
str(revision.version.nonarch))
1021
for line in arch.classify_chatter(cmd):
1022
colorize(line)
1023
return
1024
raise NoSuchRevision(revision)
1025
1026
pylon.ensure_revision_exists = ensure_revision_exists
1027
1028
1029
def merge_ancestor(mine, other, other_start):
1030
"""Determines an ancestor suitable for merging, according to the tree logs.
1031
1032
:param mine: Tree to find an ancestor for (usually the working tree)
1033
:type mine: `arch.WorkingTree`
1034
:param other: Tree that merged or was merged by mine
1035
:type other: `arch.ArchSourceTree`
1036
:param other_start: The start revision to use for the other tree
1037
:type other_start: `arch.Revision`
1038
:return: Log of the merged revision
1039
:rtype: `arch.Patchlog`
1040
"""
1041
my_ancestors = list (pylon.iter_ancestry_logs(mine))
1042
other_ancestors = list (pylon.iter_ancestry_logs(other,
1043
other_start))
1044
1045
other_ancestor = None
1046
mine_ancestor = None
1047
1048
for log in my_ancestors:
1049
for oth_log in other_ancestors:
1050
if log.continuation_of:
1051
if oth_log.revision == log.continuation_of:
1052
mine_ancestor = oth_log
1053
break
1054
elif oth_log.revision in log.new_patches:
1055
mine_ancestor = oth_log
1056
break
1057
if mine_ancestor is not None:
1058
break
1059
1060
for log in other_ancestors:
1061
if log == mine_ancestor:
1062
break
1063
for my_log in my_ancestors:
1064
if log.continuation_of:
1065
if my_log.revision == my_log:
1066
other_ancestor = my_log
1067
break
1068
elif my_log.revision in log.new_patches:
1069
other_ancestor = my_log
1070
break
1071
if other_ancestor is not None:
1072
break
1073
1074
if other_ancestor is not None:
1075
return other_ancestor
1076
else:
1077
return mine_ancestor
1078
1079
1080
1081
1082
def iter_supported_switches(cmd):
1083
for line in pylon.iter_tla_cmd_help(cmd):
1084
if not line.startswith(" -"):
1085
continue
1086
chunks = line[2:].split()
1087
if chunks[0][-1] == ",":
1088
yield chunks[0][:-1]
1089
yield chunks[1]
1090
else:
1091
yield chunks[0]
1092
1093
def supports_switch(cmd, switch):
1094
return switch in list(iter_supported_switches(cmd))
1095
1096
1097
def register_archive(name, location, expected_name=None):
1098
"""Wrapper that can require a certain official_name for the location
1099
:param name: The name of the archive to register
1100
:param location: The location where a version is stored
1101
:param expected_name: If supplied, the location's expected official_name
1102
"""
1103
ar = arch.register_archive(name, location)
1104
if expected_name is not None:
1105
arname = ar.official_name
1106
if arname!=expected_name:
1107
print "The archive at this location is wrong: %s" %\
1108
arname
1109
if not prompt("Register wrong name"):
1110
ar.unregister()
1111
raise WrongArchName(location, expected_name, arname)
1112
return ar
1113
1114
1115
def direct_merges(merges):
1116
"""Get a list of direct merges, from a list of direct and indirect
1117
1118
:param merges: Iterator of merge patchlogs
1119
:type merges: iter of `arch.Patchlog`
1120
:return: The direct merges
1121
:rtype: list of `arch.Patchlog`
1122
"""
1123
indirect = []
1124
direct = []
1125
logs = list(merges)
1126
if not logs:
1127
return []
1128
for log in logs:
1129
indirect.extend([f for f in log.new_patches if f != log.revision])
1130
if log.continuation_of is not None:
1131
# continuations list everything in new_patches
1132
continue
1133
try:
1134
# ask baz if we can
1135
ancestor = log.revision.ancestor
1136
except pybaz.errors.ExecProblem:
1137
# baz does not know
1138
# guess
1139
ancestor = namespace_previous(log.revision)
1140
if ancestor is not None and ancestor != '<<<no previous revision>>>':
1141
indirect.append(ancestor)
1142
return [log for log in logs if not log.revision in indirect]
1143
1144
def namespace_previous(revision):
1145
if revision.patchlevel == 'patch-1':
1146
return revision.version['base-0']
1147
if revision.patchlevel.startswith('patch'):
1148
level = int(revision.patchlevel[len('patch-'):]) -1
1149
return revision.version['patch-%d' % level]
1150
if revision.patchlevel == 'version-0':
1151
raise RuntimeError("cannot determine prior namespace level for a "
1152
"version-0 patch")
1153
if revision.patchlevel == 'version-1':
1154
return revision.version['version-0']
1155
print pybaz.NameParser
1156
1157
def require_version_exists(version, spec):
1158
if not version.exists():
1159
raise errors.CantDetermineVersion(spec,
1160
"The version %s does not exist." \
1161
% version)
1162
1163
1164
def revision_iterator(tree, type, args, reverse, modified, shallow):
1165
"""Produce an iterator of revisions
1166
1167
:param tree: The project tree or None
1168
:type tree: `arch.ArchSourceTree`
1169
:param type: The type of iterator to produce
1170
:type type: str
1171
:param args: The commandline positional arguments
1172
:type args: list of str
1173
:param reverse: If true, iterate in reverse
1174
:type reverse: bool
1175
:param modified: if non-null, use to create a file modification iterator
1176
:type modified: str
1177
"""
1178
if len(args) > 0:
1179
spec = args[0]
1180
else:
1181
spec = None
1182
if modified is not None:
1183
iter = modified_iter(modified, tree, shallow != True)
1184
if reverse:
1185
return iter
1186
else:
1187
return iter_reverse(iter)
1188
elif type == "archive":
1189
if spec is None:
1190
if tree is None:
1191
raise CantDetermineRevision("", "Not in a project tree")
1192
version = determine_version_tree(spec, tree)
1193
else:
1194
version = determine_version_arch(spec, tree)
1195
ensure_archive_registered(version.archive)
1196
require_version_exists(version, spec)
1197
return version.iter_revisions(reverse)
1198
elif type == "cacherevs":
1199
if spec is None:
1200
if tree is None:
1201
raise CantDetermineRevision("", "Not in a project tree")
1202
version = determine_version_tree(spec, tree)
1203
else:
1204
version = determine_version_arch(spec, tree)
1205
ensure_archive_registered(version.archive)
1206
require_version_exists(version, spec)
1207
return iter_cacherevs(version, reverse)
1208
elif type == "library":
1209
if spec is None:
1210
if tree is None:
1211
raise CantDetermineRevision("",
1212
"Not in a project tree")
1213
version = determine_version_tree(spec, tree)
1214
else:
1215
version = determine_version_arch(spec, tree)
1216
return version.iter_library_revisions(reverse)
1217
elif type == "logs":
1218
if tree is None:
1219
raise CantDetermineRevision("", "Not in a project tree")
1220
return tree.iter_logs(determine_version_tree(spec, \
1221
tree), reverse)
1222
elif type == "missing" or type == "skip-present":
1223
if tree is None:
1224
raise CantDetermineRevision("", "Not in a project tree")
1225
skip = (type == "skip-present")
1226
version = determine_version_tree(spec, tree)
1227
ensure_archive_registered(version.archive)
1228
require_version_exists(version, spec)
1229
return pylon.iter_missing(tree, version, reverse, skip_present=skip)
1230
1231
elif type == "present":
1232
if tree is None:
1233
raise CantDetermineRevision("", "Not in a project tree")
1234
version = determine_version_tree(spec, tree)
1235
ensure_archive_registered(version.archive)
1236
require_version_exists(version, spec)
1237
return iter_present(tree, version, reverse)
1238
1239
elif type == "new-merges" or type == "direct-merges":
1240
if tree is None:
1241
raise CantDetermineRevision("", "Not in a project tree")
1242
version = determine_version_tree(spec, tree)
1243
ensure_archive_registered(version.archive)
1244
require_version_exists(version, spec)
1245
iter = pylon.iter_new_merges(tree, version, reverse)
1246
if type == "new-merges":
1247
return iter
1248
elif type == "direct-merges":
1249
return pylon.direct_merges(iter)
1250
1251
elif type == "missing-from":
1252
if tree is None:
1253
raise CantDetermineRevision("", "Not in a project tree")
1254
revision = determine_revision_tree(tree, spec)
1255
libtree = pylon.find_or_make_local_revision(revision)
1256
return pylon.iter_missing(libtree, tree.tree_version, reverse)
1257
1258
elif type == "partner-missing":
1259
return iter_partner_missing(tree, reverse)
1260
1261
elif type == "ancestry":
1262
revision = determine_revision_tree(tree, spec)
1263
iter = pylon.iter_any_ancestry(tree, revision)
1264
if reverse:
1265
return iter
1266
else:
1267
return iter_reverse(iter)
1268
1269
elif type == "archive-ancestry":
1270
revision = determine_revision_tree(tree, spec)
1271
iter = revision.iter_ancestors(metoo=True)
1272
if reverse:
1273
return iter
1274
else:
1275
return iter_reverse(iter)
1276
1277
elif type == "dependencies" or type == "non-dependencies" or \
1278
type == "with-deps":
1279
nondeps = (type == "non-dependencies")
1280
revision = determine_revision_tree(tree, spec)
1281
anc_tree = pylon.find_or_make_local_revision(revision)
1282
anc_iter = pylon.iter_any_ancestry(anc_tree, revision)
1283
iter = pylon.iter_depends(anc_iter, nondeps)
1284
if type == "with-deps":
1285
iter = iter_combine(((revision,),
1286
pylon.iter_to_present(iter, tree)))
1287
if reverse:
1288
return iter
1289
else:
1290
return iter_reverse(iter)
1291
1292
elif type == "micro":
1293
return pylon.iter_micro(tree)
1294
1295
elif type == "added-log":
1296
revision = determine_revision_tree(tree, spec)
1297
iter = pylon.iter_ancestry_logs(tree)
1298
return pylon.iter_added_log(iter, revision)
1299
1300
elif type == "skip-conflicts":
1301
#this only works for replay
1302
if reverse:
1303
raise Exception("Skip-conflicts doesn't work in reverse.")
1304
version = determine_version_tree(spec, tree)
1305
return pylon.iter_skip_replay_conflicts(tree, version)
1306
1307
def add_revision_iter_options(select):
1308
select.add_option("", "--archive", action="store_const",
1309
const="archive", dest="type", default="default",
1310
help="List all revisions in the archive")
1311
select.add_option("", "--cacherevs", action="store_const",
1312
const="cacherevs", dest="type",
1313
help="List all revisions stored in the archive as "
1314
"complete copies")
1315
select.add_option("", "--logs", action="store_const",
1316
const="logs", dest="type",
1317
help="List revisions that have a patchlog in the "
1318
"tree")
1319
select.add_option("", "--missing", action="store_const",
1320
const="missing", dest="type",
1321
help="List revisions from the specified version that"
1322
" have no patchlog in the tree")
1323
select.add_option("", "--skip-present", action="store_const",
1324
const="skip-present", dest="type",
1325
help="List revisions from the specified version that"
1326
" have no patchlogs at all in the tree")
1327
select.add_option("", "--present", action="store_const",
1328
const="present", dest="type",
1329
help="List revisions from the specified version that"
1330
" have no patchlog in the tree, but can't be merged")
1331
select.add_option("", "--missing-from", action="store_const",
1332
const="missing-from", dest="type",
1333
help="List revisions from the specified revision "
1334
"that have no patchlog for the tree version")
1335
select.add_option("", "--partner-missing", action="store_const",
1336
const="partner-missing", dest="type",
1337
help="List revisions in partner versions that are"
1338
" missing")
1339
select.add_option("", "--new-merges", action="store_const",
1340
const="new-merges", dest="type",
1341
help="List revisions that have had patchlogs added"
1342
" to the tree since the last commit")
1343
select.add_option("", "--direct-merges", action="store_const",
1344
const="direct-merges", dest="type",
1345
help="List revisions that have been directly added"
1346
" to tree since the last commit ")
1347
select.add_option("", "--library", action="store_const",
1348
const="library", dest="type",
1349
help="List revisions in the revision library")
1350
select.add_option("", "--archive-ancestry", action="store_const",
1351
const="archive-ancestry", dest="type",
1352
help="List revisions that are ancestors of the "
1353
"current tree version")
1354
select.add_option("", "--ancestry", action="store_const",
1355
const="ancestry", dest="type",
1356
help="List revisions that are ancestors of the "
1357
"current tree version")
1358
1359
select.add_option("", "--dependencies", action="store_const",
1360
const="dependencies", dest="type",
1361
help="List revisions that the given revision "
1362
"depends on")
1363
1364
select.add_option("", "--non-dependencies", action="store_const",
1365
const="non-dependencies", dest="type",
1366
help="List revisions that the given revision "
1367
"does not depend on")
1368
1369
select.add_option("", "--with-deps", action="store_const",
1370
const="with-deps", dest="type",
1371
help="The specified revision, plus its dependencies"
1372
"since the last present dependency")
1373
1374
select.add_option("--micro", action="store_const",
1375
const="micro", dest="type",
1376
help="List partner revisions aimed for this "
1377
"micro-branch")
1378
1379
select.add_option("", "--modified", dest="modified",
1380
help="List tree ancestor revisions that modified a "
1381
"given file", metavar="FILE[:LINE]")
1382
1383
select.add_option("", "--shallow", dest="shallow", action="store_true",
1384
help="Don't scan merges when looking for revisions"
1385
" that modified a line")
1386
select.add_option("--added-log", action="store_const",
1387
const="added-log", dest="type",
1388
help="List revisions that added this log")
1389
1390
def log_for_merge2(tree, version):
1391
merges = list(pylon.iter_new_merges(tree, version))
1392
direct = direct_merges (merges)
1393
out = "Patches applied:\n\n"
1394
for log in direct:
1395
out +=merge_log_recurse(log, merges, tree)
1396
return out
1397
1398
def merge_log_recurse(log, interesting_merges, tree, indent = None):
1399
"""A variation on log-for-merge that scaled extremely badly"""
1400
if indent is None:
1401
indent = ""
1402
out = "%s * %s\n%s %s\n\n" % (indent, log.revision, indent, log.summary)
1403
new_patch_logs = [f for f in interesting_merges if (f.revision in
1404
log.new_patches and f != log) ]
1405
direct = direct_merges(new_patch_logs)
1406
for merge in direct:
1407
out+=merge_log_recurse(merge, new_patch_logs, tree, indent+" ")
1408
return out
1409
1410
def chatter(str):
1411
colorize(arch.Chatter("* "+str))
1412
1413
1414
def user_hunk_confirm(hunk):
1415
"""Asks user to confirm each hunk
1416
1417
:param hunk: a diff hunk
1418
:type hunk: str
1419
:return: The user's choice
1420
:rtype: bool
1421
"""
1422
for line in pylon.diff_classifier(hunk.split('\n')):
1423
colorize(line)
1424
return confirm("Revert this hunk?", False)
1425
1426
def merge_completions(tree, arg, index):
1427
completions = list(pylon.iter_partners(tree, tree.tree_version))
1428
if len(completions) == 0:
1429
completions = list(tree.iter_log_versions())
1430
1431
aliases = []
1432
try:
1433
for completion in completions:
1434
alias = pylon.compact_alias(str(completion), tree)
1435
if alias:
1436
aliases.extend(alias)
1437
1438
for completion in completions:
1439
if completion.archive == tree.tree_version.archive:
1440
aliases.append(completion.nonarch)
1441
1442
except Exception, e:
1443
print e
1444
1445
completions.extend(aliases)
1446
return completions
1447
1448
1449
def iter_file_completions(arg, only_dirs = False):
1450
"""Generate an iterator that iterates through filename completions.
1451
1452
:param arg: The filename fragment to match
1453
:type arg: str
1454
:param only_dirs: If true, match only directories
1455
:type only_dirs: bool
1456
"""
1457
cwd = os.getcwd()
1458
if cwd != "/":
1459
extras = [".", ".."]
1460
else:
1461
extras = []
1462
(dir, file) = os.path.split(arg)
1463
if dir != "":
1464
listingdir = os.path.expanduser(dir)
1465
else:
1466
listingdir = cwd
1467
for file in iter_combine([os.listdir(listingdir), extras]):
1468
if dir != "":
1469
userfile = dir+'/'+file
1470
else:
1471
userfile = file
1472
if userfile.startswith(arg):
1473
if os.path.isdir(listingdir+'/'+file):
1474
userfile+='/'
1475
yield userfile
1476
elif not only_dirs:
1477
yield userfile
1478
1479
1480
def iter_dir_completions(arg):
1481
"""Generate an iterator that iterates through directory name completions.
1482
1483
:param arg: The directory name fragment to match
1484
:type arg: str
1485
"""
1486
return iter_file_completions(arg, True)
1487
1488
1489
def iter_munged_completions(iter, arg, text):
1490
for completion in iter:
1491
completion = str(completion)
1492
if completion.startswith(arg):
1493
yield completion[len(arg)-len(text):]
1494
1495
# arch-tag: 7d28710a-0b02-4dcb-86a7-e6b3b5486da4
Loggerhead is a web-based interface for Breezy
Version: 2.0.1