« back to all changes in this revision
Viewing changes to testdata/mod
- browse files at revision 787
- compare with another revision
- download diff
- download tarball
- view history from revision 787
- Committer: Aaron Bentley
- Date: 2013-08-20 03:02:43 UTC
- Revision ID: aaron@aaronbentley.com-20130820030243-r8v1xfbcnd8f10p4
Fix zap command for 2.6/7
- files added:
- .be/bugs/0fc1fb5e-c545-453c-999d-5fc5ef852ca5
- .be/bugs/1804f828-abfe-4433-b287-7560ff9ea354
- .be/bugs/1804f828-abfe-4433-b287-7560ff9ea354/comments
- .be/bugs/1804f828-abfe-4433-b287-7560ff9ea354/comments/a68c4dc0-c796-4747-b7a1-60bee9fb2c86
- .be/bugs/1804f828-abfe-4433-b287-7560ff9ea354/comments/aa6140d3-b4a7-46c3-abae-4c7b8a3523ce
- .be/bugs/1e6d3356-5668-47f3-b451-5285bcc0ec3b
- .be/bugs/55bd43ce-953b-4233-83d2-2034ea63a805
- .be/bugs/5be3aa64-4585-49e4-8479-172c67afcc1b
- .be/bugs/5be3aa64-4585-49e4-8479-172c67afcc1b/comments
- .be/bugs/5be3aa64-4585-49e4-8479-172c67afcc1b/comments/298847ed-8d6a-416f-a3aa-4fd6d3f3417b
- .be/bugs/83031098-bd41-4159-852d-eec95740ab19
- .be/bugs/83031098-bd41-4159-852d-eec95740ab19/comments
- .be/bugs/83031098-bd41-4159-852d-eec95740ab19/comments/5aa94e9e-8a61-4bb1-aa74-b50428b8324c
- .be/bugs/9312b4cf-379e-490b-bfb5-dfb81357ee25
- .be/bugs/9312b4cf-379e-490b-bfb5-dfb81357ee25/comments
- .be/bugs/9312b4cf-379e-490b-bfb5-dfb81357ee25/comments/906938f4-be68-4d65-9b75-def07743b043
- .be/bugs/945dc3f8-75e1-4312-b56d-9ecb02310783
- .be/bugs/945dc3f8-75e1-4312-b56d-9ecb02310783/comments
- .be/bugs/945dc3f8-75e1-4312-b56d-9ecb02310783/comments/5c42de60-2f51-48a0-9756-dcef5f6955ab
- .be/bugs/aa3f38e8-8544-498f-893e-dec21b1b8f13
- .be/bugs/aa3f38e8-8544-498f-893e-dec21b1b8f13/comments
- .be/bugs/aa3f38e8-8544-498f-893e-dec21b1b8f13/comments/e53c2ce1-5b28-4e48-8453-bad891786713
- .be/bugs/b394a88a-3ecc-4058-8e29-4ebdbf96c95f
- .be/bugs/b394a88a-3ecc-4058-8e29-4ebdbf96c95f/comments
- .be/bugs/b394a88a-3ecc-4058-8e29-4ebdbf96c95f/comments/0978c6a8-194e-4437-b3fc-2c99adf96499
- .be/bugs/b47ef4d6-6a96-44ad-9694-6dd2c855d9c3
- .be/bugs/b47ef4d6-6a96-44ad-9694-6dd2c855d9c3/comments
- .be/bugs/b47ef4d6-6a96-44ad-9694-6dd2c855d9c3/comments/4946aca8-392b-4d95-ae22-65c1a38d842c
- .be/bugs/bad9a00f-50f5-4782-9da6-722fb0a58c93
- .be/bugs/be87c595-f555-4bce-a12a-9eeefc7349ab
- .be/bugs/be87c595-f555-4bce-a12a-9eeefc7349ab/comments
- .be/bugs/be87c595-f555-4bce-a12a-9eeefc7349ab/comments/3448c47d-def5-4d03-9b8c-f0968e0c787c
- .be/bugs/c4664fbc-3b6a-48a6-bc09-9e96fa250592
- .be/bugs/c4664fbc-3b6a-48a6-bc09-9e96fa250592/comments
- .be/bugs/c4664fbc-3b6a-48a6-bc09-9e96fa250592/comments/f752631b-5590-4b6f-86d9-57aadca441ce
- .be/bugs/c59acbbf-25f4-450a-9a8f-7a6a45b3985e
- .be/bugs/da0f16ce-1ee0-4f9e-bf1a-9a78c4a7e765
- .be/bugs/dbd10145-51f8-4bda-96d9-06b5d3ef80b8
- .be/bugs/fdc2b62a-9622-4f08-ac78-bd2603a4e0af
- .be/bugs/fdc2b62a-9622-4f08-ac78-bd2603a4e0af/comments
- .be/bugs/fdc2b62a-9622-4f08-ac78-bd2603a4e0af/comments/f13e3358-1a65-4a45-9472-781548bc3fc3
- .the_kraken
- tests
- files removed:
- baz_import.py
- debian
- obsolete
- testdata
- files renamed:
- __init__.py => command_classes.py
- push.py => rspush.py
- blackbox.py => tests/blackbox.py
- shelf_tests.py => tests/shelf_tests.py
- files modified:
- .bzrignore
added
removed
testdata/mod
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 sys
19
import arch
20
import arch.util
21
import arch.arch
22
23
import pylon.errors
24
from pylon.errors import *
25
from pylon import errors
26
from pylon import util
27
from pylon import arch_core
28
from pylon import arch_compound
29
from pylon import ancillary
30
from pylon import misc
31
from pylon import paths
32
33
import abacmds
34
import cmdutil
35
import shutil
36
import os
37
import options
38
import time
39
import cmd
40
import readline
41
import re
42
import string
43
import terminal
44
import email
45
import smtplib
46
import textwrap
47
48
__docformat__ = "restructuredtext"
49
__doc__ = "Implementation of user (sub) commands"
50
commands = {}
51
52
def find_command(cmd):
53
"""
54
Return an instance of a command type. Return None if the type isn't
55
registered.
56
57
:param cmd: the name of the command to look for
58
:type cmd: the type of the command
59
"""
60
if commands.has_key(cmd):
61
return commands[cmd]()
62
else:
63
return None
64
65
class BaseCommand:
66
def __call__(self, cmdline):
67
try:
68
self.do_command(cmdline.split())
69
except cmdutil.GetHelp, e:
70
self.help()
71
except Exception, e:
72
print e
73
74
def get_completer(index):
75
return None
76
77
def complete(self, args, text):
78
"""
79
Returns a list of possible completions for the given text.
80
81
:param args: The complete list of arguments
82
:type args: List of str
83
:param text: text to complete (may be shorter than args[-1])
84
:type text: str
85
:rtype: list of str
86
"""
87
matches = []
88
candidates = None
89
90
if len(args) > 0:
91
realtext = args[-1]
92
else:
93
realtext = ""
94
95
try:
96
parser=self.get_parser()
97
if realtext.startswith('-'):
98
candidates = parser.iter_options()
99
else:
100
(options, parsed_args) = parser.parse_args(args)
101
102
if len (parsed_args) > 0:
103
candidates = self.get_completer(parsed_args[-1], len(parsed_args) -1)
104
else:
105
candidates = self.get_completer("", 0)
106
except:
107
pass
108
if candidates is None:
109
return
110
for candidate in candidates:
111
candidate = str(candidate)
112
if candidate.startswith(realtext):
113
matches.append(candidate[len(realtext)- len(text):])
114
return matches
115
116
117
class Help(BaseCommand):
118
"""
119
Lists commands, prints help messages.
120
"""
121
def __init__(self):
122
self.description="Prints help mesages"
123
self.parser = None
124
125
def do_command(self, cmdargs):
126
"""
127
Prints a help message.
128
"""
129
options, args = self.get_parser().parse_args(cmdargs)
130
if len(args) > 1:
131
raise cmdutil.GetHelp
132
133
if options.native or options.suggestions or options.external:
134
native = options.native
135
suggestions = options.suggestions
136
external = options.external
137
else:
138
native = True
139
suggestions = False
140
external = True
141
142
if len(args) == 0:
143
self.list_commands(native, suggestions, external)
144
return
145
elif len(args) == 1:
146
command_help(args[0])
147
return
148
149
def help(self):
150
self.get_parser().print_help()
151
print """
152
If no command is specified, commands are listed. If a command is
153
specified, help for that command is listed.
154
"""
155
156
def get_parser(self):
157
"""
158
Returns the options parser to use for the "revision" command.
159
160
:rtype: cmdutil.CmdOptionParser
161
"""
162
if self.parser is not None:
163
return self.parser
164
parser=cmdutil.CmdOptionParser("fai help [command]")
165
parser.add_option("-n", "--native", action="store_true",
166
dest="native", help="Show native commands")
167
parser.add_option("-e", "--external", action="store_true",
168
dest="external", help="Show external commands")
169
parser.add_option("-s", "--suggest", action="store_true",
170
dest="suggestions", help="Show suggestions")
171
self.parser = parser
172
return parser
173
174
def list_commands(self, native=True, suggest=False, external=True):
175
"""
176
Lists supported commands.
177
178
:param native: list native, python-based commands
179
:type native: bool
180
:param external: list external aba-style commands
181
:type external: bool
182
"""
183
if native:
184
print "Native Fai commands"
185
keys=commands.keys()
186
keys.sort()
187
for k in keys:
188
space=""
189
for i in range(28-len(k)):
190
space+=" "
191
print space+k+" : "+commands[k]().description
192
print
193
if suggest:
194
print "Unavailable commands and suggested alternatives"
195
key_list = suggestions.keys()
196
key_list.sort()
197
for key in key_list:
198
print "%28s : %s" % (key, suggestions[key])
199
print
200
if external:
201
fake_aba = abacmds.AbaCmds()
202
if (fake_aba.abadir == ""):
203
return
204
print "External commands"
205
fake_aba.list_commands()
206
print
207
if not suggest:
208
print "Use help --suggest to list alternatives to tla and aba"\
209
" commands."
210
if options.tla_fallthrough and (native or external):
211
print "Fai also supports tla commands."
212
213
def command_help(cmd):
214
"""
215
Prints help for a command.
216
217
:param cmd: The name of the command to print help for
218
:type cmd: str
219
"""
220
fake_aba = abacmds.AbaCmds()
221
cmdobj = find_command(cmd)
222
if cmdobj != None:
223
cmdobj.help()
224
elif suggestions.has_key(cmd):
225
print "Not available\n" + suggestions[cmd]
226
else:
227
abacmd = fake_aba.is_command(cmd)
228
if abacmd:
229
abacmd.help()
230
else:
231
print "No help is available for \""+cmd+"\". Maybe try \"tla "+cmd+" -H\"?"
232
233
234
235
class Changes(BaseCommand):
236
"""
237
the "changes" command: lists differences between trees/revisions:
238
"""
239
240
def __init__(self):
241
self.description="Lists what files have changed in the project tree"
242
243
def get_completer(self, arg, index):
244
if index > 1:
245
return None
246
try:
247
tree = arch.tree_root()
248
except:
249
tree = None
250
return cmdutil.iter_revision_completions(arg, tree)
251
252
def parse_commandline(self, cmdline):
253
"""
254
Parse commandline arguments. Raises cmdutil.GetHelp if help is needed.
255
256
:param cmdline: A list of arguments to parse
257
:rtype: (options, Revision, Revision/WorkingTree)
258
"""
259
parser=self.get_parser()
260
(options, args) = parser.parse_args(cmdline)
261
if len(args) > 2:
262
raise cmdutil.GetHelp
263
264
tree=arch.tree_root()
265
if len(args) == 0:
266
a_spec = ancillary.comp_revision(tree)
267
else:
268
a_spec = cmdutil.determine_revision_tree(tree, args[0])
269
cmdutil.ensure_archive_registered(a_spec.archive)
270
if len(args) == 2:
271
b_spec = cmdutil.determine_revision_tree(tree, args[1])
272
cmdutil.ensure_archive_registered(b_spec.archive)
273
else:
274
b_spec=tree
275
return options, a_spec, b_spec
276
277
def do_command(self, cmdargs):
278
"""
279
Master function that perfoms the "changes" command.
280
"""
281
try:
282
options, a_spec, b_spec = self.parse_commandline(cmdargs);
283
except cmdutil.CantDetermineRevision, e:
284
print e
285
return
286
except arch.errors.TreeRootError, e:
287
print e
288
return
289
if options.changeset:
290
changeset=options.changeset
291
tmpdir = None
292
else:
293
tmpdir=util.tmpdir()
294
changeset=tmpdir+"/changeset"
295
try:
296
delta=arch.iter_delta(a_spec, b_spec, changeset)
297
try:
298
for line in delta:
299
if cmdutil.chattermatch(line, "changeset:"):
300
pass
301
else:
302
cmdutil.colorize(line, options.suppress_chatter)
303
except arch.util.ExecProblem, e:
304
if e.proc.error and e.proc.error.startswith(
305
"missing explicit id for file"):
306
raise MissingID(e)
307
else:
308
raise
309
status=delta.status
310
if status > 1:
311
return
312
if (options.perform_diff):
313
chan = arch_compound.ChangesetMunger(changeset)
314
chan.read_indices()
315
if options.diffopts is not None:
316
if isinstance(b_spec, arch.Revision):
317
b_dir = b_spec.library_find()
318
else:
319
b_dir = b_spec
320
a_dir = a_spec.library_find()
321
diffopts = options.diffopts.split()
322
cmdutil.show_custom_diffs(chan, diffopts, a_dir, b_dir)
323
else:
324
cmdutil.show_diffs(delta.changeset)
325
finally:
326
if tmpdir and (os.access(tmpdir, os.X_OK)):
327
shutil.rmtree(tmpdir)
328
329
def get_parser(self):
330
"""
331
Returns the options parser to use for the "changes" command.
332
333
:rtype: cmdutil.CmdOptionParser
334
"""
335
parser=cmdutil.CmdOptionParser("fai changes [options] [revision]"
336
" [revision]")
337
parser.add_option("-d", "--diff", action="store_true",
338
dest="perform_diff", default=False,
339
help="Show diffs in summary")
340
parser.add_option("-c", "--changeset", dest="changeset",
341
help="Store a changeset in the given directory",
342
metavar="DIRECTORY")
343
parser.add_option("-s", "--silent", action="store_true",
344
dest="suppress_chatter", default=False,
345
help="Suppress chatter messages")
346
parser.add_option("--diffopts", dest="diffopts",
347
help="Use the specified diff options",
348
metavar="OPTIONS")
349
350
return parser
351
352
def help(self, parser=None):
353
"""
354
Prints a help message.
355
356
:param parser: If supplied, the parser to use for generating help. If \
357
not supplied, it is retrieved.
358
:type parser: cmdutil.CmdOptionParser
359
"""
360
if parser is None:
361
parser=self.get_parser()
362
parser.print_help()
363
print """
364
Performs source-tree comparisons
365
366
If no revision is specified, the current project tree is compared to the
367
last-committed revision. If one revision is specified, the current project
368
tree is compared to that revision. If two revisions are specified, they are
369
compared to each other.
370
"""
371
help_tree_spec()
372
return
373
374
375
class ApplyChanges(BaseCommand):
376
"""
377
Apply differences between two revisions to a tree
378
"""
379
380
def __init__(self):
381
self.description="Applies changes to a project tree"
382
383
def get_completer(self, arg, index):
384
if index > 1:
385
return None
386
try:
387
tree = arch.tree_root()
388
except:
389
tree = None
390
return cmdutil.iter_revision_completions(arg, tree)
391
392
def parse_commandline(self, cmdline, tree):
393
"""
394
Parse commandline arguments. Raises cmdutil.GetHelp if help is needed.
395
396
:param cmdline: A list of arguments to parse
397
:rtype: (options, Revision, Revision/WorkingTree)
398
"""
399
parser=self.get_parser()
400
(options, args) = parser.parse_args(cmdline)
401
if len(args) != 2:
402
raise cmdutil.GetHelp
403
404
a_spec = cmdutil.determine_revision_tree(tree, args[0])
405
cmdutil.ensure_archive_registered(a_spec.archive)
406
b_spec = cmdutil.determine_revision_tree(tree, args[1])
407
cmdutil.ensure_archive_registered(b_spec.archive)
408
return options, a_spec, b_spec
409
410
def do_command(self, cmdargs):
411
"""
412
Master function that performs "apply-changes".
413
"""
414
try:
415
tree = arch.tree_root()
416
options, a_spec, b_spec = self.parse_commandline(cmdargs, tree);
417
except cmdutil.CantDetermineRevision, e:
418
print e
419
return
420
except arch.errors.TreeRootError, e:
421
print e
422
return
423
delta=cmdutil.apply_delta(a_spec, b_spec, tree)
424
for line in cmdutil.iter_apply_delta_filter(delta):
425
cmdutil.colorize(line, options.suppress_chatter)
426
427
def get_parser(self):
428
"""
429
Returns the options parser to use for the "apply-changes" command.
430
431
:rtype: cmdutil.CmdOptionParser
432
"""
433
parser=cmdutil.CmdOptionParser("fai apply-changes [options] revision"
434
" revision")
435
parser.add_option("-d", "--diff", action="store_true",
436
dest="perform_diff", default=False,
437
help="Show diffs in summary")
438
parser.add_option("-c", "--changeset", dest="changeset",
439
help="Store a changeset in the given directory",
440
metavar="DIRECTORY")
441
parser.add_option("-s", "--silent", action="store_true",
442
dest="suppress_chatter", default=False,
443
help="Suppress chatter messages")
444
return parser
445
446
def help(self, parser=None):
447
"""
448
Prints a help message.
449
450
:param parser: If supplied, the parser to use for generating help. If \
451
not supplied, it is retrieved.
452
:type parser: cmdutil.CmdOptionParser
453
"""
454
if parser is None:
455
parser=self.get_parser()
456
parser.print_help()
457
print """
458
Applies changes to a project tree
459
460
Compares two revisions and applies the difference between them to the current
461
tree.
462
"""
463
help_tree_spec()
464
return
465
466
class Update(BaseCommand):
467
"""
468
Updates a project tree to a given revision, preserving un-committed hanges.
469
"""
470
471
def __init__(self):
472
self.description="Apply the latest changes to the current directory"
473
474
def get_completer(self, arg, index):
475
if index > 0:
476
return None
477
try:
478
tree = arch.tree_root()
479
except:
480
tree = None
481
return cmdutil.iter_revision_completions(arg, tree)
482
483
def parse_commandline(self, cmdline, tree):
484
"""
485
Parse commandline arguments. Raises cmdutil.GetHelp if help is needed.
486
487
:param cmdline: A list of arguments to parse
488
:rtype: (options, Revision, Revision/WorkingTree)
489
"""
490
parser=self.get_parser()
491
(options, args) = parser.parse_args(cmdline)
492
if len(args) > 2:
493
raise cmdutil.GetHelp
494
495
spec=None
496
if len(args)>0:
497
spec=args[0]
498
revision=cmdutil.determine_revision_arch(tree, spec)
499
cmdutil.ensure_archive_registered(revision.archive)
500
501
mirror_source = cmdutil.get_mirror_source(revision.archive)
502
if mirror_source != None:
503
if cmdutil.prompt("Mirror update"):
504
cmd=cmdutil.mirror_archive(mirror_source,
505
revision.archive, arch.NameParser(revision).get_package_version())
506
for line in arch.chatter_classifier(cmd):
507
cmdutil.colorize(line, options.suppress_chatter)
508
509
revision=cmdutil.determine_revision_arch(tree, spec)
510
511
return options, revision
512
513
def do_command(self, cmdargs):
514
"""
515
Master function that perfoms the "update" command.
516
"""
517
tree=arch.tree_root()
518
try:
519
options, to_revision = self.parse_commandline(cmdargs, tree);
520
except cmdutil.CantDetermineRevision, e:
521
print e
522
return
523
except arch.errors.TreeRootError, e:
524
print e
525
return
526
from_revision = arch_compound.tree_latest(tree)
527
if from_revision==to_revision:
528
print "Tree is already up to date with:\n"+str(to_revision)+"."
529
return
530
cmdutil.ensure_archive_registered(from_revision.archive)
531
cmd=cmdutil.apply_delta(from_revision, to_revision, tree,
532
options.patch_forward)
533
for line in cmdutil.iter_apply_delta_filter(cmd):
534
cmdutil.colorize(line)
535
if to_revision.version != tree.tree_version:
536
if cmdutil.prompt("Update version"):
537
tree.tree_version = to_revision.version
538
539
def get_parser(self):
540
"""
541
Returns the options parser to use for the "update" command.
542
543
:rtype: cmdutil.CmdOptionParser
544
"""
545
parser=cmdutil.CmdOptionParser("fai update [options]"
546
" [revision/version]")
547
parser.add_option("-f", "--forward", action="store_true",
548
dest="patch_forward", default=False,
549
help="pass the --forward option to 'patch'")
550
parser.add_option("-s", "--silent", action="store_true",
551
dest="suppress_chatter", default=False,
552
help="Suppress chatter messages")
553
return parser
554
555
def help(self, parser=None):
556
"""
557
Prints a help message.
558
559
:param parser: If supplied, the parser to use for generating help. If \
560
not supplied, it is retrieved.
561
:type parser: cmdutil.CmdOptionParser
562
"""
563
if parser is None:
564
parser=self.get_parser()
565
parser.print_help()
566
print """
567
Updates a working tree to the current archive revision
568
569
If a revision or version is specified, that is used instead
570
"""
571
help_tree_spec()
572
return
573
574
575
class Commit(BaseCommand):
576
"""
577
Create a revision based on the changes in the current tree.
578
"""
579
580
def __init__(self):
581
self.description="Write local changes to the archive"
582
583
def get_completer(self, arg, index):
584
if arg is None:
585
arg = ""
586
return iter_modified_file_completions(arch.tree_root(), arg)
587
# return iter_source_file_completions(arch.tree_root(), arg)
588
589
def parse_commandline(self, cmdline, tree):
590
"""
591
Parse commandline arguments. Raise cmtutil.GetHelp if help is needed.
592
593
:param cmdline: A list of arguments to parse
594
:rtype: (options, Revision, Revision/WorkingTree)
595
"""
596
parser=self.get_parser()
597
(options, args) = parser.parse_args(cmdline)
598
599
if len(args) == 0:
600
args = None
601
if options.version is None:
602
return options, tree.tree_version, args
603
604
revision=cmdutil.determine_revision_arch(tree, options.version)
605
return options, revision.get_version(), args
606
607
def do_command(self, cmdargs):
608
"""
609
Master function that perfoms the "commit" command.
610
"""
611
tree=arch.tree_root()
612
options, version, files = self.parse_commandline(cmdargs, tree)
613
ancestor = None
614
if options.__dict__.has_key("base") and options.base:
615
base = cmdutil.determine_revision_tree(tree, options.base)
616
ancestor = base
617
else:
618
base = ancillary.submit_revision(tree)
619
ancestor = base
620
if ancestor is None:
621
ancestor = arch_compound.tree_latest(tree, version)
622
623
writeversion=version
624
archive=version.archive
625
source=cmdutil.get_mirror_source(archive)
626
allow_old=False
627
writethrough="implicit"
628
629
if source!=None:
630
if writethrough=="explicit" and \
631
cmdutil.prompt("Writethrough"):
632
writeversion=arch.Version(str(source)+"/"+str(version.get_nonarch()))
633
elif writethrough=="none":
634
raise CommitToMirror(archive)
635
636
elif archive.is_mirror:
637
raise CommitToMirror(archive)
638
639
try:
640
last_revision=tree.iter_logs(version, True).next().revision
641
except StopIteration, e:
642
last_revision = None
643
if ancestor is None:
644
if cmdutil.prompt("Import from commit"):
645
return do_import(version)
646
else:
647
raise NoVersionLogs(version)
648
try:
649
arch_last_revision = version.iter_revisions(True).next()
650
except StopIteration, e:
651
arch_last_revision = None
652
653
if last_revision != arch_last_revision:
654
print "Tree is not up to date with %s" % str(version)
655
if not cmdutil.prompt("Out of date"):
656
raise OutOfDate
657
else:
658
allow_old=True
659
660
try:
661
if not cmdutil.has_changed(ancestor):
662
if not cmdutil.prompt("Empty commit"):
663
raise EmptyCommit
664
except arch.util.ExecProblem, e:
665
if e.proc.error and e.proc.error.startswith(
666
"missing explicit id for file"):
667
raise MissingID(e)
668
else:
669
raise
670
log = tree.log_message(create=False, version=version)
671
if log is None:
672
try:
673
if cmdutil.prompt("Create log"):
674
edit_log(tree, version)
675
676
except cmdutil.NoEditorSpecified, e:
677
raise CommandFailed(e)
678
log = tree.log_message(create=False, version=version)
679
if log is None:
680
raise NoLogMessage
681
if log["Summary"] is None or len(log["Summary"].strip()) == 0:
682
if not cmdutil.prompt("Omit log summary"):
683
raise errors.NoLogSummary
684
try:
685
for line in tree.iter_commit(version, seal=options.seal_version,
686
base=base, out_of_date_ok=allow_old, file_list=files):
687
cmdutil.colorize(line, options.suppress_chatter)
688
689
except arch.util.ExecProblem, e:
690
if e.proc.error and e.proc.error.startswith(
691
"These files violate naming conventions:"):
692
raise LintFailure(e.proc.error)
693
else:
694
raise
695
696
def get_parser(self):
697
"""
698
Returns the options parser to use for the "commit" command.
699
700
:rtype: cmdutil.CmdOptionParser
701
"""
702
703
parser=cmdutil.CmdOptionParser("fai commit [options] [file1]"
704
" [file2...]")
705
parser.add_option("--seal", action="store_true",
706
dest="seal_version", default=False,
707
help="seal this version")
708
parser.add_option("-v", "--version", dest="version",
709
help="Use the specified version",
710
metavar="VERSION")
711
parser.add_option("-s", "--silent", action="store_true",
712
dest="suppress_chatter", default=False,
713
help="Suppress chatter messages")
714
if cmdutil.supports_switch("commit", "--base"):
715
parser.add_option("--base", dest="base", help="",
716
metavar="REVISION")
717
return parser
718
719
def help(self, parser=None):
720
"""
721
Prints a help message.
722
723
:param parser: If supplied, the parser to use for generating help. If \
724
not supplied, it is retrieved.
725
:type parser: cmdutil.CmdOptionParser
726
"""
727
if parser is None:
728
parser=self.get_parser()
729
parser.print_help()
730
print """
731
Updates a working tree to the current archive revision
732
733
If a version is specified, that is used instead
734
"""
735
# help_tree_spec()
736
return
737
738
739
740
class CatLog(BaseCommand):
741
"""
742
Print the log of a given file (from current tree)
743
"""
744
def __init__(self):
745
self.description="Prints the patch log for a revision"
746
747
def get_completer(self, arg, index):
748
if index > 0:
749
return None
750
try:
751
tree = arch.tree_root()
752
except:
753
tree = None
754
return cmdutil.iter_revision_completions(arg, tree)
755
756
def do_command(self, cmdargs):
757
"""
758
Master function that perfoms the "cat-log" command.
759
"""
760
parser=self.get_parser()
761
(options, args) = parser.parse_args(cmdargs)
762
try:
763
tree = arch.tree_root()
764
except arch.errors.TreeRootError, e:
765
tree = None
766
spec=None
767
if len(args) > 0:
768
spec=args[0]
769
if len(args) > 1:
770
raise cmdutil.GetHelp()
771
try:
772
if tree:
773
revision = cmdutil.determine_revision_tree(tree, spec)
774
else:
775
revision = cmdutil.determine_revision_arch(tree, spec)
776
except cmdutil.CantDetermineRevision, e:
777
raise CommandFailedWrapper(e)
778
log = None
779
780
use_tree = (options.source == "tree" or \
781
(options.source == "any" and tree))
782
use_arch = (options.source == "archive" or options.source == "any")
783
784
log = None
785
if use_tree:
786
for log in tree.iter_logs(revision.get_version()):
787
if log.revision == revision:
788
break
789
else:
790
log = None
791
if log is None and use_arch:
792
cmdutil.ensure_revision_exists(revision)
793
log = arch.Patchlog(revision)
794
if log is not None:
795
for item in log.items():
796
print "%s: %s" % item
797
print log.description
798
799
def get_parser(self):
800
"""
801
Returns the options parser to use for the "cat-log" command.
802
803
:rtype: cmdutil.CmdOptionParser
804
"""
805
parser=cmdutil.CmdOptionParser("fai cat-log [revision]")
806
parser.add_option("--archive", action="store_const", dest="source",
807
const="archive", default="any",
808
help="Always get the log from the archive")
809
parser.add_option("--tree", action="store_const", dest="source",
810
const="tree", help="Always get the log from the tree")
811
return parser
812
813
def help(self, parser=None):
814
"""
815
Prints a help message.
816
817
:param parser: If supplied, the parser to use for generating help. If \
818
not supplied, it is retrieved.
819
:type parser: cmdutil.CmdOptionParser
820
"""
821
if parser==None:
822
parser=self.get_parser()
823
parser.print_help()
824
print """
825
Prints the log for the specified revision
826
"""
827
help_tree_spec()
828
return
829
830
class Revert(BaseCommand):
831
""" Reverts a tree (or aspects of it) to a revision
832
"""
833
def __init__(self):
834
self.description="Reverts a tree (or aspects of it) to a revision "
835
836
def get_completer(self, arg, index):
837
if index > 0:
838
return None
839
try:
840
tree = arch.tree_root()
841
except:
842
tree = None
843
return iter_modified_file_completions(tree, arg)
844
845
def do_command(self, cmdargs):
846
"""
847
Master function that perfoms the "revert" command.
848
"""
849
parser=self.get_parser()
850
(options, args) = parser.parse_args(cmdargs)
851
try:
852
tree = arch.tree_root()
853
except arch.errors.TreeRootError, e:
854
raise CommandFailed(e)
855
spec=None
856
if options.revision is not None:
857
spec=options.revision
858
try:
859
if spec is not None:
860
revision = cmdutil.determine_revision_tree(tree, spec)
861
else:
862
revision = ancillary.comp_revision(tree)
863
except cmdutil.CantDetermineRevision, e:
864
raise CommandFailedWrapper(e)
865
munger = None
866
867
if options.file_contents or options.file_perms or options.deletions\
868
or options.additions or options.renames or options.hunk_prompt:
869
munger = arch_compound.MungeOpts()
870
munger.set_hunk_prompt(cmdutil.colorize, cmdutil.user_hunk_confirm,
871
options.hunk_prompt)
872
873
if len(args) > 0 or options.logs or options.pattern_files or \
874
options.control:
875
if munger is None:
876
munger = cmdutil.arch_compound.MungeOpts(True)
877
munger.all_types(True)
878
if len(args) > 0:
879
t_cwd = arch_compound.tree_cwd(tree)
880
for name in args:
881
if len(t_cwd) > 0:
882
t_cwd += "/"
883
name = "./" + t_cwd + name
884
munger.add_keep_file(name);
885
886
if options.file_perms:
887
munger.file_perms = True
888
if options.file_contents:
889
munger.file_contents = True
890
if options.deletions:
891
munger.deletions = True
892
if options.additions:
893
munger.additions = True
894
if options.renames:
895
munger.renames = True
896
if options.logs:
897
munger.add_keep_pattern('^\./\{arch\}/[^=].*')
898
if options.control:
899
munger.add_keep_pattern("/\.arch-ids|^\./\{arch\}|"\
900
"/\.arch-inventory$")
901
if options.pattern_files:
902
munger.add_keep_pattern(options.pattern_files)
903
904
for line in arch_compound.revert(tree, revision, munger,
905
not options.no_output):
906
cmdutil.colorize(line)
907
908
909
def get_parser(self):
910
"""
911
Returns the options parser to use for the "cat-log" command.
912
913
:rtype: cmdutil.CmdOptionParser
914
"""
915
parser=cmdutil.CmdOptionParser("fai revert [options] [FILE...]")
916
parser.add_option("", "--contents", action="store_true",
917
dest="file_contents",
918
help="Revert file content changes")
919
parser.add_option("", "--permissions", action="store_true",
920
dest="file_perms",
921
help="Revert file permissions changes")
922
parser.add_option("", "--deletions", action="store_true",
923
dest="deletions",
924
help="Restore deleted files")
925
parser.add_option("", "--additions", action="store_true",
926
dest="additions",
927
help="Remove added files")
928
parser.add_option("", "--renames", action="store_true",
929
dest="renames",
930
help="Revert file names")
931
parser.add_option("--hunks", action="store_true",
932
dest="hunk_prompt", default=False,
933
help="Prompt which hunks to revert")
934
parser.add_option("--pattern-files", dest="pattern_files",
935
help="Revert files that match this pattern",
936
metavar="REGEX")
937
parser.add_option("--logs", action="store_true",
938
dest="logs", default=False,
939
help="Revert only logs")
940
parser.add_option("--control-files", action="store_true",
941
dest="control", default=False,
942
help="Revert logs and other control files")
943
parser.add_option("-n", "--no-output", action="store_true",
944
dest="no_output",
945
help="Don't keep an undo changeset")
946
parser.add_option("--revision", dest="revision",
947
help="Revert to the specified revision",
948
metavar="REVISION")
949
return parser
950
951
def help(self, parser=None):
952
"""
953
Prints a help message.
954
955
:param parser: If supplied, the parser to use for generating help. If \
956
not supplied, it is retrieved.
957
:type parser: cmdutil.CmdOptionParser
958
"""
959
if parser==None:
960
parser=self.get_parser()
961
parser.print_help()
962
print """
963
Reverts changes in the current working tree. If no flags are specified, all
964
types of changes are reverted. Otherwise, only selected types of changes are
965
reverted.
966
967
If a revision is specified on the commandline, differences between the current
968
tree and that revision are reverted. If a version is specified, the current
969
tree is used to determine the revision.
970
971
If files are specified, only those files listed will have any changes applied.
972
To specify a renamed file, you can use either the old or new name. (or both!)
973
974
Unless "-n" is specified, reversions can be undone with "redo".
975
"""
976
return
977
978
class Revision(BaseCommand):
979
"""
980
Print a revision name based on a revision specifier
981
"""
982
def __init__(self):
983
self.description="Prints the name of a revision"
984
985
def get_completer(self, arg, index):
986
if index > 0:
987
return None
988
try:
989
tree = arch.tree_root()
990
except:
991
tree = None
992
return cmdutil.iter_revision_completions(arg, tree)
993
994
def do_command(self, cmdargs):
995
"""
996
Master function that perfoms the "revision" command.
997
"""
998
parser=self.get_parser()
999
(options, args) = parser.parse_args(cmdargs)
1000
1001
try:
1002
tree = arch.tree_root()
1003
except arch.errors.TreeRootError:
1004
tree = None
1005
1006
spec=None
1007
if len(args) > 0:
1008
spec=args[0]
1009
if len(args) > 1:
1010
raise cmdutil.GetHelp
1011
try:
1012
if tree:
1013
revision = cmdutil.determine_revision_tree(tree, spec)
1014
else:
1015
revision = cmdutil.determine_revision_arch(tree, spec)
1016
except cmdutil.CantDetermineRevision, e:
1017
print str(e)
1018
return
1019
print options.display(revision)
1020
1021
def get_parser(self):
1022
"""
1023
Returns the options parser to use for the "revision" command.
1024
1025
:rtype: cmdutil.CmdOptionParser
1026
"""
1027
parser=cmdutil.CmdOptionParser("fai revision [revision]")
1028
parser.add_option("", "--location", action="store_const",
1029
const=paths.determine_path, dest="display",
1030
help="Show location instead of name", default=str)
1031
parser.add_option("--import", action="store_const",
1032
const=paths.determine_import_path, dest="display",
1033
help="Show location of import file")
1034
parser.add_option("--log", action="store_const",
1035
const=paths.determine_log_path, dest="display",
1036
help="Show location of log file")
1037
parser.add_option("--patch", action="store_const",
1038
dest="display", const=paths.determine_patch_path,
1039
help="Show location of patchfile")
1040
parser.add_option("--continuation", action="store_const",
1041
const=paths.determine_continuation_path,
1042
dest="display",
1043
help="Show location of continuation file")
1044
parser.add_option("--cacherev", action="store_const",
1045
const=paths.determine_cacherev_path, dest="display",
1046
help="Show location of cacherev file")
1047
return parser
1048
1049
def help(self, parser=None):
1050
"""
1051
Prints a help message.
1052
1053
:param parser: If supplied, the parser to use for generating help. If \
1054
not supplied, it is retrieved.
1055
:type parser: cmdutil.CmdOptionParser
1056
"""
1057
if parser==None:
1058
parser=self.get_parser()
1059
parser.print_help()
1060
print """
1061
Expands aliases and prints the name of the specified revision. Instead of
1062
the name, several options can be used to print locations. If more than one is
1063
specified, the last one is used.
1064
"""
1065
help_tree_spec()
1066
return
1067
1068
class Revisions(BaseCommand):
1069
"""
1070
Print a revision name based on a revision specifier
1071
"""
1072
def __init__(self):
1073
self.description="Lists revisions"
1074
self.cl_revisions = []
1075
1076
def do_command(self, cmdargs):
1077
"""
1078
Master function that perfoms the "revision" command.
1079
"""
1080
(options, args) = self.get_parser().parse_args(cmdargs)
1081
if len(args) > 1:
1082
raise cmdutil.GetHelp
1083
try:
1084
self.tree = arch.tree_root()
1085
except arch.errors.TreeRootError:
1086
self.tree = None
1087
if options.type == "default":
1088
options.type = "archive"
1089
try:
1090
iter = cmdutil.revision_iterator(self.tree, options.type, args,
1091
options.reverse, options.modified,
1092
options.shallow)
1093
except cmdutil.CantDetermineRevision, e:
1094
raise CommandFailedWrapper(e)
1095
except cmdutil.CantDetermineVersion, e:
1096
raise CommandFailedWrapper(e)
1097
if options.skip is not None:
1098
iter = cmdutil.iter_skip(iter, int(options.skip))
1099
1100
try:
1101
for revision in iter:
1102
log = None
1103
if isinstance(revision, arch.Patchlog):
1104
log = revision
1105
revision=revision.revision
1106
out = options.display(revision)
1107
if out is not None:
1108
print out
1109
if log is None and (options.summary or options.creator or
1110
options.date or options.merges):
1111
log = revision.patchlog
1112
if options.creator:
1113
print " %s" % log.creator
1114
if options.date:
1115
print " %s" % time.strftime('%Y-%m-%d %H:%M:%S %Z', log.date)
1116
if options.summary:
1117
print " %s" % log.summary
1118
if options.merges:
1119
showed_title = False
1120
for revision in log.merged_patches:
1121
if not showed_title:
1122
print " Merged:"
1123
showed_title = True
1124
print " %s" % revision
1125
if len(self.cl_revisions) > 0:
1126
print pylon.changelog_for_merge(self.cl_revisions)
1127
except pylon.errors.TreeRootNone:
1128
raise CommandFailedWrapper(
1129
Exception("This option can only be used in a project tree."))
1130
1131
def changelog_append(self, revision):
1132
if isinstance(revision, arch.Revision):
1133
revision=arch.Patchlog(revision)
1134
self.cl_revisions.append(revision)
1135
1136
def get_parser(self):
1137
"""
1138
Returns the options parser to use for the "revision" command.
1139
1140
:rtype: cmdutil.CmdOptionParser
1141
"""
1142
parser=cmdutil.CmdOptionParser("fai revisions [version/revision]")
1143
select = cmdutil.OptionGroup(parser, "Selection options",
1144
"Control which revisions are listed. These options"
1145
" are mutually exclusive. If more than one is"
1146
" specified, the last is used.")
1147
1148
cmdutil.add_revision_iter_options(select)
1149
parser.add_option("", "--skip", dest="skip",
1150
help="Skip revisions. Positive numbers skip from "
1151
"beginning, negative skip from end.",
1152
metavar="NUMBER")
1153
1154
parser.add_option_group(select)
1155
1156
format = cmdutil.OptionGroup(parser, "Revision format options",
1157
"These control the appearance of listed revisions")
1158
format.add_option("", "--location", action="store_const",
1159
const=paths.determine_path, dest="display",
1160
help="Show location instead of name", default=str)
1161
format.add_option("--import", action="store_const",
1162
const=paths.determine_import_path, dest="display",
1163
help="Show location of import file")
1164
format.add_option("--log", action="store_const",
1165
const=paths.determine_log_path, dest="display",
1166
help="Show location of log file")
1167
format.add_option("--patch", action="store_const",
1168
dest="display", const=paths.determine_patch_path,
1169
help="Show location of patchfile")
1170
format.add_option("--continuation", action="store_const",
1171
const=paths.determine_continuation_path,
1172
dest="display",
1173
help="Show location of continuation file")
1174
format.add_option("--cacherev", action="store_const",
1175
const=paths.determine_cacherev_path, dest="display",
1176
help="Show location of cacherev file")
1177
format.add_option("--changelog", action="store_const",
1178
const=self.changelog_append, dest="display",
1179
help="Show location of cacherev file")
1180
parser.add_option_group(format)
1181
display = cmdutil.OptionGroup(parser, "Display format options",
1182
"These control the display of data")
1183
display.add_option("-r", "--reverse", action="store_true",
1184
dest="reverse", help="Sort from newest to oldest")
1185
display.add_option("-s", "--summary", action="store_true",
1186
dest="summary", help="Show patchlog summary")
1187
display.add_option("-D", "--date", action="store_true",
1188
dest="date", help="Show patchlog date")
1189
display.add_option("-c", "--creator", action="store_true",
1190
dest="creator", help="Show the id that committed the"
1191
" revision")
1192
display.add_option("-m", "--merges", action="store_true",
1193
dest="merges", help="Show the revisions that were"
1194
" merged")
1195
parser.add_option_group(display)
1196
return parser
1197
def help(self, parser=None):
1198
"""Attempt to explain the revisions command
1199
1200
:param parser: If supplied, used to determine options
1201
"""
1202
if parser==None:
1203
parser=self.get_parser()
1204
parser.print_help()
1205
print """List revisions.
1206
"""
1207
help_tree_spec()
1208
1209
1210
class Get(BaseCommand):
1211
"""
1212
Retrieve a revision from the archive
1213
"""
1214
def __init__(self):
1215
self.description="Retrieve a revision from the archive"
1216
self.parser=self.get_parser()
1217
1218
1219
def get_completer(self, arg, index):
1220
if index > 0:
1221
return None
1222
try:
1223
tree = arch.tree_root()
1224
except:
1225
tree = None
1226
return cmdutil.iter_revision_completions(arg, tree)
1227
1228
1229
def do_command(self, cmdargs):
1230
"""
1231
Master function that perfoms the "get" command.
1232
"""
1233
(options, args) = self.parser.parse_args(cmdargs)
1234
if len(args) < 1:
1235
return self.help()
1236
try:
1237
tree = arch.tree_root()
1238
except arch.errors.TreeRootError:
1239
tree = None
1240
1241
arch_loc = None
1242
try:
1243
revision, arch_loc = paths.full_path_decode(args[0])
1244
except Exception, e:
1245
revision = cmdutil.determine_revision_arch(tree, args[0],
1246
check_existence=False, allow_package=True)
1247
if len(args) > 1:
1248
directory = args[1]
1249
else:
1250
directory = str(revision.nonarch)
1251
if os.path.exists(directory):
1252
raise DirectoryExists(directory)
1253
cmdutil.ensure_archive_registered(revision.archive, arch_loc)
1254
try:
1255
cmdutil.ensure_revision_exists(revision)
1256
except cmdutil.NoSuchRevision, e:
1257
raise CommandFailedWrapper(e)
1258
1259
link = cmdutil.prompt ("get link")
1260
for line in cmdutil.iter_get(revision, directory, link,
1261
options.no_pristine,
1262
options.no_greedy_add):
1263
cmdutil.colorize(line)
1264
1265
def get_parser(self):
1266
"""
1267
Returns the options parser to use for the "get" command.
1268
1269
:rtype: cmdutil.CmdOptionParser
1270
"""
1271
parser=cmdutil.CmdOptionParser("fai get revision [dir]")
1272
parser.add_option("--no-pristine", action="store_true",
1273
dest="no_pristine",
1274
help="Do not make pristine copy for reference")
1275
parser.add_option("--no-greedy-add", action="store_true",
1276
dest="no_greedy_add",
1277
help="Never add to greedy libraries")
1278
1279
return parser
1280
1281
def help(self, parser=None):
1282
"""
1283
Prints a help message.
1284
1285
:param parser: If supplied, the parser to use for generating help. If \
1286
not supplied, it is retrieved.
1287
:type parser: cmdutil.CmdOptionParser
1288
"""
1289
if parser==None:
1290
parser=self.get_parser()
1291
parser.print_help()
1292
print """
1293
Expands aliases and constructs a project tree for a revision. If the optional
1294
"dir" argument is provided, the project tree will be stored in this directory.
1295
"""
1296
help_tree_spec()
1297
return
1298
1299
class PromptCmd(cmd.Cmd):
1300
def __init__(self):
1301
cmd.Cmd.__init__(self)
1302
self.prompt = "Fai> "
1303
try:
1304
self.tree = arch.tree_root()
1305
except:
1306
self.tree = None
1307
self.set_title()
1308
self.set_prompt()
1309
self.fake_aba = abacmds.AbaCmds()
1310
self.identchars += '-'
1311
self.history_file = os.path.expanduser("~/.fai-history")
1312
readline.set_completer_delims(string.whitespace)
1313
if os.access(self.history_file, os.R_OK) and \
1314
os.path.isfile(self.history_file):
1315
readline.read_history_file(self.history_file)
1316
self.cwd = os.getcwd()
1317
1318
def write_history(self):
1319
readline.write_history_file(self.history_file)
1320
1321
def do_quit(self, args):
1322
self.write_history()
1323
sys.exit(0)
1324
1325
def do_exit(self, args):
1326
self.do_quit(args)
1327
1328
def do_EOF(self, args):
1329
print
1330
self.do_quit(args)
1331
1332
def postcmd(self, line, bar):
1333
self.set_title()
1334
self.set_prompt()
1335
1336
def set_prompt(self):
1337
if self.tree is not None:
1338
try:
1339
prompt = pylon.alias_or_version(self.tree.tree_version,
1340
self.tree,
1341
full=False)
1342
if prompt is not None:
1343
prompt = " " + prompt
1344
except:
1345
prompt = ""
1346
else:
1347
prompt = ""
1348
self.prompt = "Fai%s> " % prompt
1349
1350
def set_title(self, command=None):
1351
try:
1352
version = pylon.alias_or_version(self.tree.tree_version, self.tree,
1353
full=False)
1354
except:
1355
version = "[no version]"
1356
if command is None:
1357
command = ""
1358
sys.stdout.write(terminal.term_title("Fai %s %s" % (command, version)))
1359
1360
def do_cd(self, line):
1361
if line == "":
1362
line = "~"
1363
line = os.path.expanduser(line)
1364
if os.path.isabs(line):
1365
newcwd = line
1366
else:
1367
newcwd = self.cwd+'/'+line
1368
newcwd = os.path.normpath(newcwd)
1369
try:
1370
os.chdir(newcwd)
1371
self.cwd = newcwd
1372
except Exception, e:
1373
print e
1374
try:
1375
self.tree = arch.tree_root()
1376
except:
1377
self.tree = None
1378
1379
def do_help(self, line):
1380
Help()(line)
1381
1382
def default(self, line):
1383
args = line.split()
1384
if find_command(args[0]):
1385
try:
1386
find_command(args[0]).do_command(args[1:])
1387
except cmdutil.BadCommandOption, e:
1388
print e
1389
except cmdutil.GetHelp, e:
1390
find_command(args[0]).help()
1391
except CommandFailed, e:
1392
print e
1393
except arch.errors.ArchiveNotRegistered, e:
1394
print e
1395
except KeyboardInterrupt, e:
1396
print "Interrupted"
1397
except arch.util.ExecProblem, e:
1398
print e.proc.error.rstrip('\n')
1399
except cmdutil.CantDetermineVersion, e:
1400
print e
1401
except cmdutil.CantDetermineRevision, e:
1402
print e
1403
except Exception, e:
1404
print "Unhandled error:\n%s" % errors.exception_str(e)
1405
1406
elif suggestions.has_key(args[0]):
1407
print suggestions[args[0]]
1408
1409
elif self.fake_aba.is_command(args[0]):
1410
tree = None
1411
try:
1412
tree = arch.tree_root()
1413
except arch.errors.TreeRootError:
1414
pass
1415
cmd = self.fake_aba.is_command(args[0])
1416
try:
1417
cmd.run(cmdutil.expand_prefix_alias(args[1:], tree))
1418
except KeyboardInterrupt, e:
1419
print "Interrupted"
1420
1421
elif options.tla_fallthrough and args[0] != "rm" and \
1422
cmdutil.is_tla_command(args[0]):
1423
try:
1424
tree = None
1425
try:
1426
tree = arch.tree_root()
1427
except arch.errors.TreeRootError:
1428
pass
1429
args = cmdutil.expand_prefix_alias(args, tree)
1430
arch.util.exec_safe('tla', args, stderr=sys.stderr,
1431
expected=(0, 1))
1432
except arch.util.ExecProblem, e:
1433
pass
1434
except KeyboardInterrupt, e:
1435
print "Interrupted"
1436
else:
1437
try:
1438
try:
1439
tree = arch.tree_root()
1440
except arch.errors.TreeRootError:
1441
tree = None
1442
args=line.split()
1443
os.system(" ".join(cmdutil.expand_prefix_alias(args, tree)))
1444
except KeyboardInterrupt, e:
1445
print "Interrupted"
1446
1447
def completenames(self, text, line, begidx, endidx):
1448
completions = []
1449
iter = iter_command_names(self.fake_aba)
1450
try:
1451
if len(line) > 0:
1452
arg = line.split()[-1]
1453
else:
1454
arg = ""
1455
iter = cmdutil.iter_munged_completions(iter, arg, text)
1456
except Exception, e:
1457
print e
1458
return list(iter)
1459
1460
def completedefault(self, text, line, begidx, endidx):
1461
"""Perform completion for native commands.
1462
1463
:param text: The text to complete
1464
:type text: str
1465
:param line: The entire line to complete
1466
:type line: str
1467
:param begidx: The start of the text in the line
1468
:type begidx: int
1469
:param endidx: The end of the text in the line
1470
:type endidx: int
1471
"""
1472
try:
1473
(cmd, args, foo) = self.parseline(line)
1474
command_obj=find_command(cmd)
1475
if command_obj is not None:
1476
return command_obj.complete(args.split(), text)
1477
elif not self.fake_aba.is_command(cmd) and \
1478
cmdutil.is_tla_command(cmd):
1479
iter = cmdutil.iter_supported_switches(cmd)
1480
if len(args) > 0:
1481
arg = args.split()[-1]
1482
else:
1483
arg = ""
1484
if arg.startswith("-"):
1485
return list(cmdutil.iter_munged_completions(iter, arg,
1486
text))
1487
else:
1488
return list(cmdutil.iter_munged_completions(
1489
cmdutil.iter_file_completions(arg), arg, text))
1490
1491
1492
elif cmd == "cd":
1493
if len(args) > 0:
1494
arg = args.split()[-1]
1495
else:
1496
arg = ""
1497
iter = cmdutil.iter_dir_completions(arg)
1498
iter = cmdutil.iter_munged_completions(iter, arg, text)
1499
return list(iter)
1500
elif len(args)>0:
1501
arg = args.split()[-1]
1502
iter = cmdutil.iter_file_completions(arg)
1503
return list(cmdutil.iter_munged_completions(iter, arg, text))
1504
else:
1505
return self.completenames(text, line, begidx, endidx)
1506
except Exception, e:
1507
print e
1508
1509
1510
def iter_command_names(fake_aba):
1511
for entry in cmdutil.iter_combine([commands.iterkeys(),
1512
fake_aba.get_commands(),
1513
cmdutil.iter_tla_commands(False)]):
1514
if not suggestions.has_key(str(entry)):
1515
yield entry
1516
1517
1518
def iter_source_file_completions(tree, arg):
1519
treepath = arch_compound.tree_cwd(tree)
1520
if len(treepath) > 0:
1521
dirs = [treepath]
1522
else:
1523
dirs = None
1524
for file in tree.iter_inventory(dirs, source=True, both=True):
1525
file = file_completion_match(file, treepath, arg)
1526
if file is not None:
1527
yield file
1528
1529
1530
def iter_untagged(tree, dirs):
1531
for file in arch_core.iter_inventory_filter(tree, dirs, tagged=False,
1532
categories=arch_core.non_root,
1533
control_files=True):
1534
yield file.name
1535
1536
1537
def iter_untagged_completions(tree, arg):
1538
"""Generate an iterator for all visible untagged files that match arg.
1539
1540
:param tree: The tree to look for untagged files in
1541
:type tree: `arch.WorkingTree`
1542
:param arg: The argument to match
1543
:type arg: str
1544
:return: An iterator of all matching untagged files
1545
:rtype: iterator of str
1546
"""
1547
treepath = arch_compound.tree_cwd(tree)
1548
if len(treepath) > 0:
1549
dirs = [treepath]
1550
else:
1551
dirs = None
1552
1553
for file in iter_untagged(tree, dirs):
1554
file = file_completion_match(file, treepath, arg)
1555
if file is not None:
1556
yield file
1557
1558
1559
def file_completion_match(file, treepath, arg):
1560
"""Determines whether a file within an arch tree matches the argument.
1561
1562
:param file: The rooted filename
1563
:type file: str
1564
:param treepath: The path to the cwd within the tree
1565
:type treepath: str
1566
:param arg: The prefix to match
1567
:return: The completion name, or None if not a match
1568
:rtype: str
1569
"""
1570
if not file.startswith(treepath):
1571
return None
1572
if treepath != "":
1573
file = file[len(treepath)+1:]
1574
1575
if not file.startswith(arg):
1576
return None
1577
if os.path.isdir(file):
1578
file += '/'
1579
return file
1580
1581
def iter_modified_file_completions(tree, arg):
1582
"""Returns a list of modified files that match the specified prefix.
1583
1584
:param tree: The current tree
1585
:type tree: `arch.WorkingTree`
1586
:param arg: The prefix to match
1587
:type arg: str
1588
"""
1589
treepath = arch_compound.tree_cwd(tree)
1590
tmpdir = util.tmpdir()
1591
changeset = tmpdir+"/changeset"
1592
completions = []
1593
revision = cmdutil.determine_revision_tree(tree)
1594
for line in arch.iter_delta(revision, tree, changeset):
1595
if isinstance(line, arch.FileModification):
1596
file = file_completion_match(line.name[1:], treepath, arg)
1597
if file is not None:
1598
completions.append(file)
1599
shutil.rmtree(tmpdir)
1600
return completions
1601
1602
class Shell(BaseCommand):
1603
def __init__(self):
1604
self.description = "Runs Fai as a shell"
1605
1606
def do_command(self, cmdargs):
1607
if len(cmdargs)!=0:
1608
raise cmdutil.GetHelp
1609
prompt = PromptCmd()
1610
try:
1611
prompt.cmdloop()
1612
finally:
1613
prompt.write_history()
1614
1615
class AddID(BaseCommand):
1616
"""
1617
Adds an inventory id for the given file
1618
"""
1619
def __init__(self):
1620
self.description="Add an inventory id for a given file"
1621
1622
def get_completer(self, arg, index):
1623
tree = arch.tree_root()
1624
return iter_untagged_completions(tree, arg)
1625
1626
def do_command(self, cmdargs):
1627
"""
1628
Master function that perfoms the "revision" command.
1629
"""
1630
parser=self.get_parser()
1631
(options, args) = parser.parse_args(cmdargs)
1632
1633
try:
1634
tree = arch.tree_root()
1635
except arch.errors.TreeRootError, e:
1636
raise pylon.errors.CommandFailedWrapper(e)
1637
1638
1639
if (len(args) == 0) == (options.untagged == False):
1640
raise cmdutil.GetHelp
1641
1642
#if options.id and len(args) != 1:
1643
# print "If --id is specified, only one file can be named."
1644
# return
1645
1646
method = tree.tagging_method
1647
1648
if options.id_type == "tagline":
1649
if method != "tagline":
1650
if not cmdutil.prompt("Tagline in other tree"):
1651
if method == "explicit" or method == "implicit":
1652
options.id_type == method
1653
else:
1654
print "add-id not supported for \"%s\" tagging method"\
1655
% method
1656
return
1657
1658
elif options.id_type == "implicit":
1659
if method != "implicit":
1660
if not cmdutil.prompt("Implicit in other tree"):
1661
if method == "explicit" or method == "tagline":
1662
options.id_type == method
1663
else:
1664
print "add-id not supported for \"%s\" tagging method"\
1665
% method
1666
return
1667
elif options.id_type == "explicit":
1668
if method != "tagline" and method != explicit:
1669
if not prompt("Explicit in other tree"):
1670
print "add-id not supported for \"%s\" tagging method" % \
1671
method
1672
return
1673
1674
if options.id_type == "auto":
1675
if method != "tagline" and method != "explicit" \
1676
and method !="implicit":
1677
print "add-id not supported for \"%s\" tagging method" % method
1678
return
1679
else:
1680
options.id_type = method
1681
if options.untagged:
1682
args = None
1683
self.add_ids(tree, options.id_type, args)
1684
1685
def add_ids(self, tree, id_type, files=()):
1686
"""Add inventory ids to files.
1687
1688
:param tree: the tree the files are in
1689
:type tree: `arch.WorkingTree`
1690
:param id_type: the type of id to add: "explicit" or "tagline"
1691
:type id_type: str
1692
:param files: The list of files to add. If None do all untagged.
1693
:type files: tuple of str
1694
"""
1695
1696
untagged = (files is None)
1697
if untagged:
1698
files = list(iter_untagged(tree, None))
1699
previous_files = []
1700
while len(files) > 0:
1701
previous_files.extend(files)
1702
if id_type == "explicit":
1703
cmdutil.add_id(files)
1704
elif id_type == "tagline" or id_type == "implicit":
1705
for file in files:
1706
try:
1707
implicit = (id_type == "implicit")
1708
cmdutil.add_tagline_or_explicit_id(file, False,
1709
implicit)
1710
except cmdutil.AlreadyTagged:
1711
print "\"%s\" already has a tagline." % file
1712
except cmdutil.NoCommentSyntax:
1713
pass
1714
#do inventory after tagging until no untagged files are encountered
1715
if untagged:
1716
files = []
1717
for file in iter_untagged(tree, None):
1718
if not file in previous_files:
1719
files.append(file)
1720
1721
else:
1722
break
1723
1724
def get_parser(self):
1725
"""
1726
Returns the options parser to use for the "revision" command.
1727
1728
:rtype: cmdutil.CmdOptionParser
1729
"""
1730
parser=cmdutil.CmdOptionParser("fai add-id file1 [file2] [file3]...")
1731
# ddaa suggests removing this to promote GUIDs. Let's see who squalks.
1732
# parser.add_option("-i", "--id", dest="id",
1733
# help="Specify id for a single file", default=None)
1734
parser.add_option("--tltl", action="store_true",
1735
dest="lord_style", help="Use Tom Lord's style of id.")
1736
parser.add_option("--explicit", action="store_const",
1737
const="explicit", dest="id_type",
1738
help="Use an explicit id", default="auto")
1739
parser.add_option("--tagline", action="store_const",
1740
const="tagline", dest="id_type",
1741
help="Use a tagline id")
1742
parser.add_option("--implicit", action="store_const",
1743
const="implicit", dest="id_type",
1744
help="Use an implicit id (deprecated)")
1745
parser.add_option("--untagged", action="store_true",
1746
dest="untagged", default=False,
1747
help="tag all untagged files")
1748
return parser
1749
1750
def help(self, parser=None):
1751
"""
1752
Prints a help message.
1753
1754
:param parser: If supplied, the parser to use for generating help. If \
1755
not supplied, it is retrieved.
1756
:type parser: cmdutil.CmdOptionParser
1757
"""
1758
if parser==None:
1759
parser=self.get_parser()
1760
parser.print_help()
1761
print """
1762
Adds an inventory to the specified file(s) and directories. If --untagged is
1763
specified, adds inventory to all untagged files and directories.
1764
"""
1765
return
1766
1767
1768
class Merge(BaseCommand):
1769
"""
1770
Merges changes from other versions into the current tree
1771
"""
1772
def __init__(self):
1773
self.description="Merges changes from other versions"
1774
try:
1775
self.tree = arch.tree_root()
1776
except:
1777
self.tree = None
1778
1779
1780
def get_completer(self, arg, index):
1781
if self.tree is None:
1782
raise arch.errors.TreeRootError
1783
return cmdutil.merge_completions(self.tree, arg, index)
1784
1785
def do_command(self, cmdargs):
1786
"""
1787
Master function that perfoms the "merge" command.
1788
"""
1789
parser=self.get_parser()
1790
(options, args) = parser.parse_args(cmdargs)
1791
if options.diff3:
1792
action="star-merge"
1793
else:
1794
action = options.action
1795
1796
if self.tree is None:
1797
raise arch.errors.TreeRootError(os.getcwd())
1798
if cmdutil.has_changed(ancillary.comp_revision(self.tree)):
1799
raise UncommittedChanges(self.tree)
1800
1801
if len(args) > 0:
1802
revisions = []
1803
for arg in args:
1804
revisions.append(cmdutil.determine_revision_arch(self.tree,
1805
arg))
1806
source = "from commandline"
1807
else:
1808
revisions = ancillary.iter_partner_revisions(self.tree,
1809
self.tree.tree_version)
1810
source = "from partner version"
1811
revisions = misc.rewind_iterator(revisions)
1812
try:
1813
revisions.next()
1814
revisions.rewind()
1815
except StopIteration, e:
1816
revision = cmdutil.tag_cur(self.tree)
1817
if revision is None:
1818
raise CantDetermineRevision("", "No version specified, no "
1819
"partner-versions, and no tag"
1820
" source")
1821
revisions = [revision]
1822
source = "from tag source"
1823
for revision in revisions:
1824
cmdutil.ensure_archive_registered(revision.archive)
1825
cmdutil.colorize(arch.Chatter("* Merging %s [%s]" %
1826
(revision, source)))
1827
if action=="native-merge" or action=="update":
1828
if self.native_merge(revision, action) == 0:
1829
continue
1830
elif action=="star-merge":
1831
try:
1832
self.star_merge(revision, options.diff3)
1833
except errors.MergeProblem, e:
1834
break
1835
if cmdutil.has_changed(self.tree.tree_version):
1836
break
1837
1838
def star_merge(self, revision, diff3):
1839
"""Perform a star-merge on the current tree.
1840
1841
:param revision: The revision to use for the merge
1842
:type revision: `arch.Revision`
1843
:param diff3: If true, do a diff3 merge
1844
:type diff3: bool
1845
"""
1846
try:
1847
for line in self.tree.iter_star_merge(revision, diff3=diff3):
1848
cmdutil.colorize(line)
1849
except arch.util.ExecProblem, e:
1850
if e.proc.status is not None and e.proc.status == 1:
1851
if e.proc.error:
1852
print e.proc.error
1853
raise MergeProblem
1854
else:
1855
raise
1856
1857
def native_merge(self, other_revision, action):
1858
"""Perform a native-merge on the current tree.
1859
1860
:param other_revision: The revision to use for the merge
1861
:type other_revision: `arch.Revision`
1862
:return: 0 if the merge was skipped, 1 if it was applied
1863
"""
1864
other_tree = arch_compound.find_or_make_local_revision(other_revision)
1865
try:
1866
if action == "native-merge":
1867
ancestor = arch_compound.merge_ancestor2(self.tree, other_tree,
1868
other_revision)
1869
elif action == "update":
1870
ancestor = arch_compound.tree_latest(self.tree,
1871
other_revision.version)
1872
except CantDetermineRevision, e:
1873
raise CommandFailedWrapper(e)
1874
cmdutil.colorize(arch.Chatter("* Found common ancestor %s" % ancestor))
1875
if (ancestor == other_revision):
1876
cmdutil.colorize(arch.Chatter("* Skipping redundant merge"
1877
% ancestor))
1878
return 0
1879
delta = cmdutil.apply_delta(ancestor, other_tree, self.tree)
1880
for line in cmdutil.iter_apply_delta_filter(delta):
1881
cmdutil.colorize(line)
1882
return 1
1883
1884
1885
1886
def get_parser(self):
1887
"""
1888
Returns the options parser to use for the "merge" command.
1889
1890
:rtype: cmdutil.CmdOptionParser
1891
"""
1892
parser=cmdutil.CmdOptionParser("fai merge [VERSION]")
1893
parser.add_option("-s", "--star-merge", action="store_const",
1894
dest="action", help="Use star-merge",
1895
const="star-merge", default="native-merge")
1896
parser.add_option("--update", action="store_const",
1897
dest="action", help="Use update picker",
1898
const="update")
1899
parser.add_option("--diff3", action="store_true",
1900
dest="diff3",
1901
help="Use diff3 for merge (implies star-merge)")
1902
return parser
1903
1904
def help(self, parser=None):
1905
"""
1906
Prints a help message.
1907
1908
:param parser: If supplied, the parser to use for generating help. If \
1909
not supplied, it is retrieved.
1910
:type parser: cmdutil.CmdOptionParser
1911
"""
1912
if parser==None:
1913
parser=self.get_parser()
1914
parser.print_help()
1915
print """
1916
Performs a merge operation using the specified version.
1917
"""
1918
return
1919
1920
class ELog(BaseCommand):
1921
"""
1922
Produces a raw patchlog and invokes the user's editor
1923
"""
1924
def __init__(self):
1925
self.description="Edit a patchlog to commit"
1926
try:
1927
self.tree = arch.tree_root()
1928
except:
1929
self.tree = None
1930
1931
1932
def do_command(self, cmdargs):
1933
"""
1934
Master function that perfoms the "elog" command.
1935
"""
1936
parser=self.get_parser()
1937
(options, args) = parser.parse_args(cmdargs)
1938
if self.tree is None:
1939
raise arch.errors.TreeRootError
1940
1941
try:
1942
edit_log(self.tree, self.tree.tree_version)
1943
except pylon.errors.NoEditorSpecified, e:
1944
raise pylon.errors.CommandFailedWrapper(e)
1945
1946
def get_parser(self):
1947
"""
1948
Returns the options parser to use for the "merge" command.
1949
1950
:rtype: cmdutil.CmdOptionParser
1951
"""
1952
parser=cmdutil.CmdOptionParser("fai elog")
1953
return parser
1954
1955
1956
def help(self, parser=None):
1957
"""
1958
Invokes $EDITOR to produce a log for committing.
1959
1960
:param parser: If supplied, the parser to use for generating help. If \
1961
not supplied, it is retrieved.
1962
:type parser: cmdutil.CmdOptionParser
1963
"""
1964
if parser==None:
1965
parser=self.get_parser()
1966
parser.print_help()
1967
print """
1968
Invokes $EDITOR to produce a log for committing.
1969
"""
1970
return
1971
1972
def edit_log(tree, version):
1973
"""Makes and edits the log for a tree. Does all kinds of fancy things
1974
like log templates and merge summaries and log-for-merge
1975
1976
:param tree: The tree to edit the log for
1977
:type tree: `arch.WorkingTree`
1978
"""
1979
#ensure we have an editor before preparing the log
1980
cmdutil.find_editor()
1981
log = tree.log_message(create=False, version=version)
1982
log_is_new = False
1983
if log is None or cmdutil.prompt("Overwrite log"):
1984
if log is not None:
1985
os.remove(log.name)
1986
log = tree.log_message(create=True, version=version)
1987
log_is_new = True
1988
tmplog = log.name
1989
template = pylon.log_template_path(tree)
1990
if template:
1991
shutil.copyfile(template, tmplog)
1992
comp_version = ancillary.comp_revision(tree).version
1993
new_merges = cmdutil.iter_new_merges(tree, comp_version)
1994
new_merges = cmdutil.direct_merges(new_merges)
1995
log["Summary"] = pylon.merge_summary(new_merges,
1996
version)
1997
if len(new_merges) > 0:
1998
if cmdutil.prompt("Log for merge"):
1999
if cmdutil.prompt("changelog for merge"):
2000
mergestuff = "Patches applied:\n"
2001
mergestuff += pylon.changelog_for_merge(new_merges)
2002
else:
2003
mergestuff = cmdutil.log_for_merge(tree, comp_version)
2004
log.description += mergestuff
2005
log.save()
2006
try:
2007
cmdutil.invoke_editor(log.name)
2008
except:
2009
if log_is_new:
2010
os.remove(log.name)
2011
raise
2012
2013
2014
class MirrorArchive(BaseCommand):
2015
"""
2016
Updates a mirror from an archive
2017
"""
2018
def __init__(self):
2019
self.description="Update a mirror from an archive"
2020
2021
def do_command(self, cmdargs):
2022
"""
2023
Master function that perfoms the "revision" command.
2024
"""
2025
2026
parser=self.get_parser()
2027
(options, args) = parser.parse_args(cmdargs)
2028
if len(args) > 1:
2029
raise GetHelp
2030
try:
2031
tree = arch.tree_root()
2032
except:
2033
tree = None
2034
2035
if len(args) == 0:
2036
if tree is not None:
2037
name = tree.tree_version()
2038
else:
2039
name = cmdutil.expand_alias(args[0], tree)
2040
name = arch.NameParser(name)
2041
2042
to_arch = name.get_archive()
2043
from_arch = cmdutil.get_mirror_source(arch.Archive(to_arch))
2044
limit = name.get_nonarch()
2045
2046
iter = arch_core.mirror_archive(from_arch,to_arch, limit)
2047
for line in arch.chatter_classifier(iter):
2048
cmdutil.colorize(line)
2049
2050
def get_parser(self):
2051
"""
2052
Returns the options parser to use for the "revision" command.
2053
2054
:rtype: cmdutil.CmdOptionParser
2055
"""
2056
parser=cmdutil.CmdOptionParser("fai mirror-archive ARCHIVE")
2057
return parser
2058
2059
def help(self, parser=None):
2060
"""
2061
Prints a help message.
2062
2063
:param parser: If supplied, the parser to use for generating help. If \
2064
not supplied, it is retrieved.
2065
:type parser: cmdutil.CmdOptionParser
2066
"""
2067
if parser==None:
2068
parser=self.get_parser()
2069
parser.print_help()
2070
print """
2071
Updates a mirror from an archive. If a branch, package, or version is
2072
supplied, only changes under it are mirrored.
2073
"""
2074
return
2075
2076
def help_tree_spec():
2077
print """Specifying revisions (default: tree)
2078
Revisions may be specified by alias, revision, version or patchlevel.
2079
Revisions or versions may be fully qualified. Unqualified revisions, versions,
2080
or patchlevels use the archive of the current project tree. Versions will
2081
use the latest patchlevel in the tree. Patchlevels will use the current tree-
2082
version.
2083
2084
Use "alias" to list available (user and automatic) aliases."""
2085
2086
auto_alias = [
2087
"acur",
2088
"The latest revision in the archive of the tree-version. You can specify \
2089
a different version like so: acur:foo--bar--0 (aliases can be used)",
2090
"tcur",
2091
"""(tree current) The latest revision in the tree of the tree-version. \
2092
You can specify a different version like so: tcur:foo--bar--0 (aliases can be \
2093
used).""",
2094
"tprev" ,
2095
"""(tree previous) The previous revision in the tree of the tree-version. To \
2096
specify an older revision, use a number, e.g. "tprev:4" """,
2097
"tanc" ,
2098
"""(tree ancestor) The ancestor revision of the tree To specify an older \
2099
revision, use a number, e.g. "tanc:4".""",
2100
"tdate" ,
2101
"""(tree date) The latest revision from a given date, e.g. "tdate:July 6".""",
2102
"tmod" ,
2103
""" (tree modified) The latest revision to modify a given file, e.g. \
2104
"tmod:engine.cpp" or "tmod:engine.cpp:16".""",
2105
"ttag" ,
2106
"""(tree tag) The revision that was tagged into the current tree revision, \
2107
according to the tree""",
2108
"tagcur",
2109
"""(tag current) The latest revision of the version that the current tree \
2110
was tagged from.""",
2111
"mergeanc" ,
2112
"""The common ancestor of the current tree and the specified revision. \
2113
Defaults to the first partner-version's latest revision or to tagcur.""",
2114
]
2115
2116
2117
def is_auto_alias(name):
2118
"""Determine whether a name is an auto alias name
2119
2120
:param name: the name to check
2121
:type name: str
2122
:return: True if the name is an auto alias, false if not
2123
:rtype: bool
2124
"""
2125
return name in [f for (f, v) in pylon.util.iter_pairs(auto_alias)]
2126
2127
2128
def display_def(iter, wrap = 80):
2129
"""Display a list of definitions
2130
2131
:param iter: iter of name, definition pairs
2132
:type iter: iter of (str, str)
2133
:param wrap: The width for text wrapping
2134
:type wrap: int
2135
"""
2136
vals = list(iter)
2137
maxlen = 0
2138
for (key, value) in vals:
2139
if len(key) > maxlen:
2140
maxlen = len(key)
2141
for (key, value) in vals:
2142
tw=textwrap.TextWrapper(width=wrap,
2143
initial_indent=key.rjust(maxlen)+" : ",
2144
subsequent_indent="".rjust(maxlen+3))
2145
print tw.fill(value)
2146
2147
2148
def help_aliases(tree):
2149
print """Auto-generated aliases"""
2150
display_def(pylon.util.iter_pairs(auto_alias))
2151
print "User aliases"
2152
display_def(ancillary.iter_all_alias(tree))
2153
2154
class Inventory(BaseCommand):
2155
"""List the status of files in the tree"""
2156
def __init__(self):
2157
self.description=self.__doc__
2158
2159
def do_command(self, cmdargs):
2160
"""
2161
Master function that perfoms the "revision" command.
2162
"""
2163
2164
parser=self.get_parser()
2165
(options, args) = parser.parse_args(cmdargs)
2166
tree = arch.tree_root()
2167
categories = []
2168
2169
if (options.source):
2170
categories.append(arch_core.SourceFile)
2171
if (options.precious):
2172
categories.append(arch_core.PreciousFile)
2173
if (options.backup):
2174
categories.append(arch_core.BackupFile)
2175
if (options.junk):
2176
categories.append(arch_core.JunkFile)
2177
2178
if len(categories) == 1:
2179
show_leading = False
2180
else:
2181
show_leading = True
2182
2183
if len(categories) == 0:
2184
categories = None
2185
2186
if options.untagged:
2187
categories = arch_core.non_root
2188
show_leading = False
2189
tagged = False
2190
else:
2191
tagged = None
2192
2193
for file in arch_core.iter_inventory_filter(tree, None,
2194
control_files=options.control_files,
2195
categories = categories, tagged=tagged):
2196
print arch_core.file_line(file,
2197
category = show_leading,
2198
untagged = show_leading,
2199
id = options.ids)
2200
2201
def get_parser(self):
2202
"""
2203
Returns the options parser to use for the "revision" command.
2204
2205
:rtype: cmdutil.CmdOptionParser
2206
"""
2207
parser=cmdutil.CmdOptionParser("fai inventory [options]")
2208
parser.add_option("--ids", action="store_true", dest="ids",
2209
help="Show file ids")
2210
parser.add_option("--control", action="store_true",
2211
dest="control_files", help="include control files")
2212
parser.add_option("--source", action="store_true", dest="source",
2213
help="List source files")
2214
parser.add_option("--backup", action="store_true", dest="backup",
2215
help="List backup files")
2216
parser.add_option("--precious", action="store_true", dest="precious",
2217
help="List precious files")
2218
parser.add_option("--junk", action="store_true", dest="junk",
2219
help="List junk files")
2220
parser.add_option("--unrecognized", action="store_true",
2221
dest="unrecognized", help="List unrecognized files")
2222
parser.add_option("--untagged", action="store_true",
2223
dest="untagged", help="List only untagged files")
2224
return parser
2225
2226
def help(self, parser=None):
2227
"""
2228
Prints a help message.
2229
2230
:param parser: If supplied, the parser to use for generating help. If \
2231
not supplied, it is retrieved.
2232
:type parser: cmdutil.CmdOptionParser
2233
"""
2234
if parser==None:
2235
parser=self.get_parser()
2236
parser.print_help()
2237
print """
2238
Lists the status of files in the archive:
2239
S source
2240
P precious
2241
B backup
2242
J junk
2243
U unrecognized
2244
T tree root
2245
? untagged-source
2246
Leading letter are not displayed if only one kind of file is shown
2247
"""
2248
return
2249
2250
2251
class Alias(BaseCommand):
2252
"""List or adjust aliases"""
2253
def __init__(self):
2254
self.description=self.__doc__
2255
2256
def get_completer(self, arg, index):
2257
if index > 2:
2258
return ()
2259
try:
2260
self.tree = arch.tree_root()
2261
except:
2262
self.tree = None
2263
2264
if index == 0:
2265
return [part[0]+" " for part in ancillary.iter_all_alias(self.tree)]
2266
elif index == 1:
2267
return cmdutil.iter_revision_completions(arg, self.tree)
2268
2269
2270
def do_command(self, cmdargs):
2271
"""
2272
Master function that perfoms the "revision" command.
2273
"""
2274
2275
parser=self.get_parser()
2276
(options, args) = parser.parse_args(cmdargs)
2277
try:
2278
self.tree = arch.tree_root()
2279
except:
2280
self.tree = None
2281
2282
2283
try:
2284
options.action(args, options)
2285
except cmdutil.ForbiddenAliasSyntax, e:
2286
raise CommandFailedWrapper(e)
2287
2288
def no_prefix(self, alias):
2289
if alias.startswith("^"):
2290
alias = alias[1:]
2291
return alias
2292
2293
def arg_dispatch(self, args, options):
2294
"""Add, modify, or list aliases, depending on number of arguments
2295
2296
:param args: The list of commandline arguments
2297
:type args: list of str
2298
:param options: The commandline options
2299
"""
2300
if len(args) == 0:
2301
help_aliases(self.tree)
2302
return
2303
else:
2304
alias = self.no_prefix(args[0])
2305
if len(args) == 1:
2306
self.print_alias(alias)
2307
elif (len(args)) == 2:
2308
self.add(alias, args[1], options)
2309
else:
2310
raise cmdutil.GetHelp
2311
2312
def print_alias(self, alias):
2313
answer = None
2314
if is_auto_alias(alias):
2315
raise pylon.errors.IsAutoAlias(alias, "\"%s\" is an auto alias."
2316
" Use \"revision\" to expand auto aliases." % alias)
2317
for pair in ancillary.iter_all_alias(self.tree):
2318
if pair[0] == alias:
2319
answer = pair[1]
2320
if answer is not None:
2321
print answer
2322
else:
2323
print "The alias %s is not assigned." % alias
2324
2325
def add(self, alias, expansion, options):
2326
"""Add or modify aliases
2327
2328
:param alias: The alias name to create/modify
2329
:type alias: str
2330
:param expansion: The expansion to assign to the alias name
2331
:type expansion: str
2332
:param options: The commandline options
2333
"""
2334
if is_auto_alias(alias):
2335
raise IsAutoAlias(alias)
2336
newlist = ""
2337
written = False
2338
new_line = "%s=%s\n" % (alias, cmdutil.expand_alias(expansion,
2339
self.tree))
2340
ancillary.check_alias(new_line.rstrip("\n"), [alias, expansion])
2341
2342
for pair in self.get_iterator(options):
2343
if pair[0] != alias:
2344
newlist+="%s=%s\n" % (pair[0], pair[1])
2345
elif not written:
2346
newlist+=new_line
2347
written = True
2348
if not written:
2349
newlist+=new_line
2350
self.write_aliases(newlist, options)
2351
2352
def delete(self, args, options):
2353
"""Delete the specified alias
2354
2355
:param args: The list of arguments
2356
:type args: list of str
2357
:param options: The commandline options
2358
"""
2359
deleted = False
2360
if len(args) != 1:
2361
raise cmdutil.GetHelp
2362
alias = self.no_prefix(args[0])
2363
if is_auto_alias(alias):
2364
raise IsAutoAlias(alias)
2365
newlist = ""
2366
for pair in self.get_iterator(options):
2367
if pair[0] != alias:
2368
newlist+="%s=%s\n" % (pair[0], pair[1])
2369
else:
2370
deleted = True
2371
if not deleted:
2372
raise errors.NoSuchAlias(alias)
2373
self.write_aliases(newlist, options)
2374
2375
def get_alias_file(self, options):
2376
"""Return the name of the alias file to use
2377
2378
:param options: The commandline options
2379
"""
2380
if options.tree:
2381
if self.tree is None:
2382
self.tree == arch.tree_root()
2383
return str(self.tree)+"/{arch}/+aliases"
2384
else:
2385
return "~/.aba/aliases"
2386
2387
def get_iterator(self, options):
2388
"""Return the alias iterator to use
2389
2390
:param options: The commandline options
2391
"""
2392
return ancillary.iter_alias(self.get_alias_file(options))
2393
2394
def write_aliases(self, newlist, options):
2395
"""Safely rewrite the alias file
2396
:param newlist: The new list of aliases
2397
:type newlist: str
2398
:param options: The commandline options
2399
"""
2400
filename = os.path.expanduser(self.get_alias_file(options))
2401
file = util.NewFileVersion(filename)
2402
file.write(newlist)
2403
file.commit()
2404
2405
2406
def get_parser(self):
2407
"""
2408
Returns the options parser to use for the "alias" command.
2409
2410
:rtype: cmdutil.CmdOptionParser
2411
"""
2412
parser=cmdutil.CmdOptionParser("fai alias [ALIAS] [NAME]")
2413
parser.add_option("-d", "--delete", action="store_const", dest="action",
2414
const=self.delete, default=self.arg_dispatch,
2415
help="Delete an alias")
2416
parser.add_option("--tree", action="store_true", dest="tree",
2417
help="Create a per-tree alias", default=False)
2418
return parser
2419
2420
def help(self, parser=None):
2421
"""
2422
Prints a help message.
2423
2424
:param parser: If supplied, the parser to use for generating help. If \
2425
not supplied, it is retrieved.
2426
:type parser: cmdutil.CmdOptionParser
2427
"""
2428
if parser==None:
2429
parser=self.get_parser()
2430
parser.print_help()
2431
print """
2432
Lists current aliases or modifies the list of aliases.
2433
2434
If no arguments are supplied, aliases will be listed. If two arguments are
2435
supplied, the specified alias will be created or modified. If -d or --delete
2436
is supplied, the specified alias will be deleted.
2437
2438
You can create aliases that refer to any fully-qualified part of the
2439
Arch namespace, e.g.
2440
archive,
2441
archive/category,
2442
archive/category--branch,
2443
archive/category--branch--version (my favourite)
2444
archive/category--branch--version--patchlevel
2445
2446
Aliases can be used automatically by native commands. To use them
2447
with external or tla commands, prefix them with ^ (you can do this
2448
with native commands, too).
2449
"""
2450
2451
2452
class RequestMerge(BaseCommand):
2453
"""Submit a merge request to Bug Goo"""
2454
def __init__(self):
2455
self.description=self.__doc__
2456
2457
def do_command(self, cmdargs):
2458
"""Submit a merge request
2459
2460
:param cmdargs: The commandline arguments
2461
:type cmdargs: list of str
2462
"""
2463
parser = self.get_parser()
2464
(options, args) = parser.parse_args(cmdargs)
2465
try:
2466
cmdutil.find_editor()
2467
except pylon.errors.NoEditorSpecified, e:
2468
raise pylon.errors.CommandFailedWrapper(e)
2469
try:
2470
self.tree=arch.tree_root()
2471
except:
2472
self.tree=None
2473
base, revisions = self.revision_specs(args)
2474
message = self.make_headers(base, revisions)
2475
message += self.make_summary(revisions)
2476
path = self.edit_message(message)
2477
message = self.tidy_message(path)
2478
if cmdutil.prompt("Send merge"):
2479
self.send_message(message)
2480
print "Merge request sent"
2481
2482
def make_headers(self, base, revisions):
2483
"""Produce email and Bug Goo header strings
2484
2485
:param base: The base revision to apply merges to
2486
:type base: `arch.Revision`
2487
:param revisions: The revisions to replay into the base
2488
:type revisions: list of `arch.Patchlog`
2489
:return: The headers
2490
:rtype: str
2491
"""
2492
headers = "To: gnu-arch-users@gnu.org\n"
2493
headers += "From: %s\n" % options.fromaddr
2494
if len(revisions) == 1:
2495
headers += "Subject: [MERGE REQUEST] %s\n" % revisions[0].summary
2496
else:
2497
headers += "Subject: [MERGE REQUEST]\n"
2498
headers += "\n"
2499
headers += "Base-Revision: %s\n" % base
2500
for revision in revisions:
2501
headers += "Revision: %s\n" % revision.revision
2502
headers += "Bug: \n\n"
2503
return headers
2504
2505
def make_summary(self, logs):
2506
"""Generate a summary of merges
2507
2508
:param logs: the patchlogs that were directly added by the merges
2509
:type logs: list of `arch.Patchlog`
2510
:return: the summary
2511
:rtype: str
2512
"""
2513
summary = ""
2514
for log in logs:
2515
summary+=str(log.revision)+"\n"
2516
summary+=log.summary+"\n"
2517
if log.description.strip():
2518
summary+=log.description.strip('\n')+"\n\n"
2519
return summary
2520
2521
def revision_specs(self, args):
2522
"""Determine the base and merge revisions from tree and arguments.
2523
2524
:param args: The parsed arguments
2525
:type args: list of str
2526
:return: The base revision and merge revisions
2527
:rtype: `arch.Revision`, list of `arch.Patchlog`
2528
"""
2529
if len(args) > 0:
2530
target_revision = cmdutil.determine_revision_arch(self.tree,
2531
args[0])
2532
else:
2533
target_revision = arch_compound.tree_latest(self.tree)
2534
if len(args) > 1:
2535
merges = [ arch.Patchlog(cmdutil.determine_revision_arch(
2536
self.tree, f)) for f in args[1:] ]
2537
else:
2538
if self.tree is None:
2539
raise CantDetermineRevision("", "Not in a project tree")
2540
merge_iter = cmdutil.iter_new_merges(self.tree,
2541
target_revision.version,
2542
False)
2543
merges = [f for f in cmdutil.direct_merges(merge_iter)]
2544
return (target_revision, merges)
2545
2546
def edit_message(self, message):
2547
"""Edit an email message in the user's standard editor
2548
2549
:param message: The message to edit
2550
:type message: str
2551
:return: the path of the edited message
2552
:rtype: str
2553
"""
2554
if self.tree is None:
2555
path = os.get_cwd()
2556
else:
2557
path = self.tree
2558
path += "/,merge-request"
2559
file = open(path, 'w')
2560
file.write(message)
2561
file.flush()
2562
cmdutil.invoke_editor(path)
2563
return path
2564
2565
def tidy_message(self, path):
2566
"""Validate and clean up message.
2567
2568
:param path: The path to the message to clean up
2569
:type path: str
2570
:return: The parsed message
2571
:rtype: `email.Message`
2572
"""
2573
mail = email.message_from_file(open(path))
2574
if mail["Subject"].strip() == "[MERGE REQUEST]":
2575
raise BlandSubject
2576
2577
request = email.message_from_string(mail.get_payload())
2578
if request.has_key("Bug"):
2579
if request["Bug"].strip()=="":
2580
del request["Bug"]
2581
mail.set_payload(request.as_string())
2582
return mail
2583
2584
def send_message(self, message):
2585
"""Send a message, using its headers to address it.
2586
2587
:param message: The message to send
2588
:type message: `email.Message`"""
2589
server = smtplib.SMTP("localhost")
2590
server.sendmail(message['From'], message['To'], message.as_string())
2591
server.quit()
2592
2593
def help(self, parser=None):
2594
"""Print a usage message
2595
2596
:param parser: The options parser to use
2597
:type parser: `cmdutil.CmdOptionParser`
2598
"""
2599
if parser is None:
2600
parser = self.get_parser()
2601
parser.print_help()
2602
print """
2603
Sends a merge request formatted for Bug Goo. Intended use: get the tree
2604
you'd like to merge into. Apply the merges you want. Invoke request-merge.
2605
The merge request will open in your $EDITOR.
2606
2607
When no TARGET is specified, it uses the current tree revision. When
2608
no MERGE is specified, it uses the direct merges (as in "revisions
2609
--direct-merges"). But you can specify just the TARGET, or all the MERGE
2610
revisions.
2611
"""
2612
2613
def get_parser(self):
2614
"""Produce a commandline parser for this command.
2615
2616
:rtype: `cmdutil.CmdOptionParser`
2617
"""
2618
parser=cmdutil.CmdOptionParser("request-merge [TARGET] [MERGE1...]")
2619
return parser
2620
2621
commands = {
2622
'changes' : Changes,
2623
'help' : Help,
2624
'update': Update,
2625
'apply-changes':ApplyChanges,
2626
'cat-log': CatLog,
2627
'commit': Commit,
2628
'revision': Revision,
2629
'revisions': Revisions,
2630
'get': Get,
2631
'revert': Revert,
2632
'shell': Shell,
2633
'add-id': AddID,
2634
'merge': Merge,
2635
'elog': ELog,
2636
'mirror-archive': MirrorArchive,
2637
'ninventory': Inventory,
2638
'alias' : Alias,
2639
'request-merge': RequestMerge,
2640
}
2641
2642
def my_import(mod_name):
2643
module = __import__(mod_name)
2644
components = mod_name.split('.')
2645
for comp in components[1:]:
2646
module = getattr(module, comp)
2647
return module
2648
2649
def plugin(mod_name):
2650
module = my_import(mod_name)
2651
module.add_command(commands)
2652
2653
for file in os.listdir(sys.path[0]+"/command"):
2654
if len(file) > 3 and file[-3:] == ".py" and file != "__init__.py":
2655
plugin("command."+file[:-3])
2656
2657
suggestions = {
2658
'apply-delta' : "Try \"apply-changes\".",
2659
'delta' : "To compare two revisions, use \"changes\".",
2660
'diff-rev' : "To compare two revisions, use \"changes\".",
2661
'undo' : "To undo local changes, use \"revert\".",
2662
'undelete' : "To undo only deletions, use \"revert --deletions\"",
2663
'missing-from' : "Try \"revisions --missing-from\".",
2664
'missing' : "Try \"revisions --missing\".",
2665
'missing-merge' : "Try \"revisions --partner-missing\".",
2666
'new-merges' : "Try \"revisions --new-merges\".",
2667
'cachedrevs' : "Try \"revisions --cacherevs\". (no 'd')",
2668
'logs' : "Try \"revisions --logs\"",
2669
'tree-source' : "Use the \"^ttag\" alias (\"revision ^ttag\")",
2670
'latest-revision' : "Use the \"^acur\" alias (\"revision ^acur\")",
2671
'change-version' : "Try \"update REVISION\"",
2672
'tree-revision' : "Use the \"^tcur\" alias (\"revision ^tcur\")",
2673
'rev-depends' : "Use revisions --dependencies",
2674
'auto-get' : "Plain get will do archive lookups",
2675
'tagline' : "Use add-id. It uses taglines in tagline trees",
2676
'emlog' : "Use elog. It automatically adds log-for-merge text, if any",
2677
'library-revisions' : "Use revisions --library",
2678
'file-revert' : "Use revert FILE",
2679
'join-branch' : "Use replay --logs-only"
2680
}
2681
# arch-tag: 19d5739d-3708-486c-93ba-deecc3027fc7
Loggerhead is a web-based interface for Breezy
Version: 2.0.1