← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to testdata/mod

Make work with integration again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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