~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2006-11-30 03:18:39 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20061130031839-q2s2ixzkebyrc9qq
Change recommendation to pybaz 1.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron.bentley@utoronto.ca>
 
1
# Copyright (C) 2005, 2006 Aaron Bentley <aaron.bentley@utoronto.ca>
2
2
# Copyright (C) 2005, 2006 Canonical Limited.
3
3
# Copyright (C) 2006 Michael Ellerman.
4
4
#
23
23
import bzrlib
24
24
 
25
25
 
26
 
__version__ = '0.16.0'
 
26
__version__ = '0.14.0'
27
27
 
28
28
 
29
29
version_info = tuple(int(n) for n in __version__.split('.'))
47
47
        # get the message out any way we can
48
48
        from warnings import warn as warning
49
49
    if bzrlib_version < desired:
50
 
        warning('Installed Bazaar version %s is too old to be used with'
51
 
                ' plugin \n'
52
 
                '"Bzrtools" %s.' % (bzrlib.__version__, __version__))
 
50
        warning('Installed bzr version %s is too old to be used with bzrtools'
 
51
                ' %s.' % (bzrlib.__version__, __version__))
53
52
        # Not using BzrNewError, because it may not exist.
54
53
        raise Exception, ('Version mismatch', version_info)
55
54
    else:
56
 
        warning('Plugin "Bzrtools" is not up to date with installed Bazaar'
57
 
                ' version %s.\n'
58
 
                ' There should be a newer version of Bzrtools available, e.g.'
59
 
                ' %i.%i.'
 
55
        warning('Bzrtools is not up to date with installed bzr version %s.'
 
56
                ' \nThere should be a newer version available, e.g. %i.%i.' 
60
57
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
61
58
        if bzrlib_version != desired_plus:
62
59
            raise Exception, 'Version mismatch'
64
61
 
65
62
check_bzrlib_version(version_info[:2])
66
63
 
67
 
from bzrlib.lazy_import import lazy_import
68
 
lazy_import(globals(), """
69
 
from bzrlib import help
70
 
import shelf
71
 
""")
72
64
 
73
65
from errors import CommandError, NoPyBaz
74
66
from patchsource import BzrPatchSource
 
67
from shelf import Shelf
75
68
import sys
76
69
import os.path
77
70
 
79
72
import bzrlib.commands
80
73
from bzrlib.commands import get_cmd_object
81
74
from bzrlib.errors import BzrCommandError
 
75
from bzrlib.help import command_usage
82
76
import bzrlib.ignores
83
77
from bzrlib.option import Option
84
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__),
 
78
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
85
79
                                                 "external")))
86
80
 
87
81
import show_paths
104
98
 
105
99
    To check what clean-tree will do, use --dry-run.
106
100
    """
107
 
    takes_options = [Option('ignored', help='delete all ignored files.'),
 
101
    takes_options = [Option('ignored', help='delete all ignored files.'), 
108
102
                     Option('detritus', help='delete conflict files, merge'
109
 
                            ' backups, and failed selftest dirs.'),
110
 
                     Option('unknown',
 
103
                            ' backups, and failed selftest dirs.'), 
 
104
                     Option('unknown', 
111
105
                            help='delete files unknown to bzr.  (default)'),
112
106
                     Option('dry-run', help='show files to delete instead of'
113
107
                            ' deleting them.')]
115
109
        from clean_tree import clean_tree
116
110
        if not (unknown or ignored or detritus):
117
111
            unknown = True
118
 
        clean_tree('.', out=self.outf, unknown=unknown, ignored=ignored,
119
 
                   detritus=detritus, dry_run=dry_run)
 
112
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
 
113
                   dry_run=dry_run)
120
114
 
121
115
 
122
116
class cmd_graph_ancestry(bzrlib.commands.Command):
123
117
    """Produce ancestry graphs using dot.
124
 
 
 
118
    
125
119
    Output format is detected according to file extension.  Some of the more
126
120
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
127
121
    will cause a dot graph file to be produced.  HTML output has mouseovers
131
125
    with the last 5 characters of their revision identifier are used instead.
132
126
 
133
127
    The value starting with d is "(maximum) distance from the null revision".
134
 
 
 
128
    
135
129
    If --merge-branch is specified, the two branches are compared and a merge
136
130
    base is selected.
137
 
 
 
131
    
138
132
    Legend:
139
133
    white    normal revision
140
134
    yellow   THIS  history
155
149
    be disabled with --no-antialias.
156
150
    """
157
151
    takes_args = ['branch', 'file']
158
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"),
 
152
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
159
153
                     Option('no-antialias',
160
 
                     help="Do not use rsvg to produce antialiased output"),
161
 
                     Option('merge-branch', type=str,
162
 
                     help="Use this branch to calcuate a merge base"),
163
 
                     Option('cluster', help="Use clustered output."),
164
 
                     Option('max-distance', help="Show no nodes farther than this",
165
 
                            type=int)]
 
154
                     help="Do not use rsvg to produce antialiased output"), 
 
155
                     Option('merge-branch', type=str, 
 
156
                     help="Use this branch to calcuate a merge base"), 
 
157
                     Option('cluster', help="Use clustered output.")]
166
158
    def run(self, branch, file, no_collapse=False, no_antialias=False,
167
 
        merge_branch=None, cluster=False, max_distance=None):
 
159
        merge_branch=None, cluster=False):
168
160
        import graph
169
161
        if cluster:
170
162
            ranking = "cluster"
171
163
        else:
172
164
            ranking = "forced"
173
 
        graph.write_ancestry_file(branch, file, not no_collapse,
174
 
                                  not no_antialias, merge_branch, ranking,
175
 
                                  max_distance=max_distance)
 
165
        graph.write_ancestry_file(branch, file, not no_collapse, 
 
166
                                  not no_antialias, merge_branch, ranking)
176
167
 
177
168
 
178
169
class cmd_fetch_ghosts(bzrlib.commands.Command):
188
179
 
189
180
strip_help="""Strip the smallest prefix containing num leading slashes  from \
190
181
each file name found in the patch file."""
 
182
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
 
183
                                help="""Handle extra bzr tags""")
191
184
 
192
185
 
193
186
class cmd_patch(bzrlib.commands.Command):
194
187
    """Apply a named patch to the current tree.
195
188
    """
196
189
    takes_args = ['filename?']
197
 
    takes_options = [Option('strip', type=int, help=strip_help),
198
 
                     Option('silent', help='Suppress chatter')]
199
 
    def run(self, filename=None, strip=None, silent=False):
 
190
    takes_options = [Option('strip', type=int, help=strip_help)]
 
191
    def run(self, filename=None, strip=-1, bzrdiff=0):
200
192
        from patch import patch
201
193
        from bzrlib.workingtree import WorkingTree
202
194
        wt = WorkingTree.open_containing('.')[0]
203
 
        if strip is None:
204
 
            strip = 0
205
 
        return patch(wt, filename, strip, silent)
 
195
        if strip == -1:
 
196
            if bzrdiff: strip = 0
 
197
            else:       strip = 0
 
198
 
 
199
        return patch(wt, filename, strip, legacy= not bzrdiff)
206
200
 
207
201
 
208
202
class cmd_shelve(bzrlib.commands.Command):
237
231
 
238
232
    takes_args = ['file*']
239
233
    takes_options = ['message', 'revision',
240
 
            Option('all', help='Shelve all changes without prompting'),
 
234
            Option('all', help='Shelve all changes without prompting'), 
241
235
            Option('no-color', help='Never display changes in color')]
242
236
 
243
237
    def run(self, all=False, file_list=None, message=None, revision=None,
250
244
                                  "parameter.")
251
245
 
252
246
        source = BzrPatchSource(revision, file_list)
253
 
        s = shelf.Shelf(source.base)
 
247
        s = Shelf(source.base)
254
248
        s.shelve(source, all, message, no_color)
255
249
        return 0
256
250
 
278
272
    aliases = ['switch']
279
273
    takes_args = ['othershelf']
280
274
    def run(self, othershelf):
281
 
        s = shelf.Shelf(self.shelf.base, othershelf)
 
275
        s = Shelf(self.shelf.base, othershelf)
282
276
        s.make_default()
283
277
 
284
278
 
311
305
            args_list = []
312
306
        cmd = self._get_cmd_object(subcommand)
313
307
        source = BzrPatchSource()
314
 
        s = shelf.Shelf(source.base)
 
308
        s = Shelf(source.base)
315
309
        cmd.shelf = s
316
 
 
317
 
        if args_list is None:
318
 
            args_list = []
319
310
        return cmd.run_argv_aliases(args_list)
320
311
 
321
312
    def _get_cmd_object(self, cmd_name):
338
329
        cmd_obj = cmd_class()
339
330
        indent = 2 * ' '
340
331
 
341
 
        usage = help.command_usage(cmd_obj)
 
332
        usage = command_usage(cmd_obj)
342
333
        usage = usage.replace('bzr shelf-', '')
343
334
        text.append('%s%s\n' % (indent, usage))
344
335
 
379
370
    takes_args = ['patch?']
380
371
    def run(self, patch=None, all=False, force=False, no_color=False):
381
372
        source = BzrPatchSource()
382
 
        s = shelf.Shelf(source.base)
 
373
        s = Shelf(source.base)
383
374
        s.unshelve(source, patch, all, force, no_color)
384
375
        return 0
385
376
 
417
408
    """
418
409
    takes_args = ["branch?"]
419
410
    def run(self, branch=None):
420
 
        from branchhistory import branch_history
 
411
        from branchhistory import branch_history 
421
412
        return branch_history(branch)
422
413
 
423
414
 
443
434
class cmd_cbranch(bzrlib.commands.Command):
444
435
    """
445
436
    Create a new checkout, associated with a new repository branch.
446
 
 
447
 
    When you cbranch, bzr looks up a target location in locations.conf, and
448
 
    creates the branch there.
449
 
 
450
 
    In your locations.conf, add the following lines:
451
 
    [/working_directory_root]
452
 
    cbranch_target = /branch_root
453
 
    cbranch_target:policy = appendpath
454
 
 
455
 
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
456
 
    working directory root, the branch will be created in
457
 
    "/branch_root/foo/baz"
458
 
 
459
 
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
460
 
    deprecated.
 
437
    
 
438
    When you cbranch, bzr looks up the repository associated with your current
 
439
    directory in locations.conf.  It creates a new branch in that repository
 
440
    with the same name and relative path as the checkout you request.
 
441
 
 
442
    The locations.conf parameter is "cbranch_root".  So if you want 
 
443
    cbranch operations in /home/jrandom/bigproject to produce branches in 
 
444
    /home/jrandom/bigproject/repository, you'd add this:
 
445
 
 
446
    [/home/jrandom/bigproject]
 
447
    cbranch_root = /home/jrandom/bigproject/repository
 
448
 
 
449
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
 
450
    standalone branches will be produced.  Standalone branches will also
 
451
    be produced if the source branch is in 0.7 format (or earlier).
461
452
    """
462
 
    takes_options = [Option("lightweight",
 
453
    takes_options = [Option("lightweight", 
463
454
                            help="Create a lightweight checkout"), 'revision']
464
455
    takes_args = ["source", "target?"]
465
456
    def run(self, source, target=None, lightweight=False, revision=None):
466
457
        from cbranch import cbranch
467
 
        return cbranch(source, target, lightweight=lightweight,
 
458
        return cbranch(source, target, lightweight=lightweight, 
468
459
                       revision=revision)
469
460
 
470
461
 
478
469
 
479
470
class cmd_multi_pull(bzrlib.commands.Command):
480
471
    """Pull all the branches under a location, e.g. a repository.
481
 
 
 
472
    
482
473
    Both branches present in the directory and the branches of checkouts are
483
474
    pulled.
484
475
    """
535
526
 
536
527
 
537
528
class cmd_import(bzrlib.commands.Command):
538
 
    """Import sources from a directory, tarball or zip file
539
 
 
540
 
    This command will import a directory, tarball or zip file into a bzr
541
 
    tree, replacing any versioned files already present.  If a directory is
542
 
    specified, it is used as the target.  If the directory does not exist, or
543
 
    is not versioned, it is created.
 
529
    """Import sources from a tarball
 
530
    
 
531
    This command will import a tarball into a bzr tree, replacing any versioned
 
532
    files already present.  If a directory is specified, it is used as the
 
533
    target.  If the directory does not exist, or is not versioned, it is
 
534
    created.
544
535
 
545
536
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
546
537
 
547
 
    If the tarball or zip has a single root directory, that directory is
548
 
    stripped when extracting the tarball.  This is not done for directories.
 
538
    If the tarball has a single root directory, that directory is stripped
 
539
    when extracting the tarball.
549
540
    """
550
 
 
 
541
    
551
542
    takes_args = ['source', 'tree?']
552
543
    def run(self, source, tree=None):
553
544
        from upstream_import import do_import
557
548
class cmd_cdiff(bzrlib.commands.Command):
558
549
    """A color version of bzr's diff"""
559
550
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
560
 
 
561
 
    def _takes_options(self):
562
 
        options = list(get_cmd_object('diff').takes_options)
563
 
        options.append(Option('check-style',
564
 
            help='Warn if trailing whitespace or spurious changes have been'
565
 
                 ' added.'))
566
 
        return options
567
 
 
568
 
    takes_options = property(_takes_options)
569
 
 
570
 
    def run(self, check_style=False, *args, **kwargs):
 
551
    takes_options = property(lambda x: get_cmd_object('diff').takes_options)
 
552
    def run(*args, **kwargs):
571
553
        from colordiff import colordiff
572
 
        colordiff(check_style, *args, **kwargs)
 
554
        colordiff(*args, **kwargs)
573
555
 
574
556
 
575
557
class cmd_baz_import(bzrlib.commands.Command):
577
559
 
578
560
    This command should be used on local archives (or mirrors) only.  It is
579
561
    quite slow on remote archives.
580
 
 
581
 
    reuse_history allows you to specify any previous imports you
 
562
    
 
563
    reuse_history allows you to specify any previous imports you 
582
564
    have done of different archives, which this archive has branches
583
 
    tagged from. This will dramatically reduce the time to convert
 
565
    tagged from. This will dramatically reduce the time to convert 
584
566
    the archive as it will not have to convert the history already
585
567
    converted in that other branch.
586
568
 
600
582
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
601
583
    takes_options = ['verbose', Option('prefixes', type=str,
602
584
                     help="Prefixes of branches to import, colon-separated"),
603
 
                     Option('encoding', type=str,
 
585
                     Option('encoding', type=str, 
604
586
                     help='Force encoding to specified value.  See WARNING.')]
605
587
 
606
588
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
626
608
    """
627
609
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
628
610
    takes_options = ['verbose', Option('max-count', type=int),
629
 
                     Option('encoding', type=str,
 
611
                     Option('encoding', type=str, 
630
612
                     help='Force encoding to specified value.  See WARNING.')]
631
613
 
632
614
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
635
617
        from errors import NoPyBaz
636
618
        try:
637
619
            import baz_import
638
 
            baz_import.baz_import_branch(to_location, from_branch, fast,
 
620
            baz_import.baz_import_branch(to_location, from_branch, fast, 
639
621
                                         max_count, verbose, encoding, dry_run,
640
622
                                         reuse_history_list)
641
623
        except NoPyBaz:
645
627
class cmd_rspush(bzrlib.commands.Command):
646
628
    """Upload this branch to another location using rsync.
647
629
 
648
 
    If no location is specified, the last-used location will be used.  To
649
 
    prevent dirty trees from being uploaded, rspush will error out if there are
650
 
    unknown files or local changes.  It will also error out if the upstream
651
 
    directory is non-empty and not an earlier version of the branch.
 
630
    If no location is specified, the last-used location will be used.  To 
 
631
    prevent dirty trees from being uploaded, rspush will error out if there are 
 
632
    unknown files or local changes.  It will also error out if the upstream 
 
633
    directory is non-empty and not an earlier version of the branch. 
652
634
    """
653
635
    takes_args = ['location?']
654
636
    takes_options = [Option('overwrite', help='Ignore differences between'
660
642
        from bzrlib import workingtree
661
643
        import bzrtools
662
644
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
663
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
 
645
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
664
646
                      working_tree=not no_tree)
665
647
 
666
648
 
680
662
            cmd_branches,
681
663
            cmd_branch_history,
682
664
            cmd_branch_mark,
683
 
            cmd_cbranch,
 
665
            cmd_cbranch,  
684
666
            cmd_cdiff,
685
667
            cmd_clean_tree,
686
668
            cmd_fetch_ghosts,
689
671
            cmd_multi_pull,
690
672
            cmd_patch,
691
673
            cmd_rspush,
692
 
            cmd_shelf,
 
674
            cmd_shelf, 
693
675
            cmd_shell,
694
 
            cmd_shelve,
 
676
            cmd_shelve, 
695
677
            cmd_switch,
696
 
            cmd_unshelve,
697
 
            cmd_zap,
 
678
            cmd_unshelve, 
 
679
            cmd_zap,            
698
680
            ]
699
681
 
700
682
 
710
692
    from unittest import TestSuite
711
693
    import bzrtools
712
694
    import tests.clean_tree
713
 
    import tests.is_clean
714
 
    import tests.upstream_import
 
695
    import upstream_import
715
696
    import zap
716
697
    import tests.blackbox
717
698
    import tests.shelf_tests
726
707
    result.addTest(tests.test_suite())
727
708
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
728
709
    result.addTest(tests.blackbox.test_suite())
729
 
    result.addTest(tests.upstream_import.test_suite())
 
710
    result.addTest(upstream_import.test_suite())
730
711
    result.addTest(zap.test_suite())
731
 
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
732
712
    return result