← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to shelf.py

  • Committer: Michael Ellerman
  • Date: 2005-11-29 01:41:52 UTC
  • mto: (0.3.1 shelf-dev) (325.1.2 bzrtools)
  • mto: This revision was merged to the branch mainline in revision 334.
  • Revision ID: michael@ellerman.id.au-20051129014152-f5ede8888bcebc48
HunkSelector was broken if you did a "done" followed by "status/invert" etc.
Fixup to make pychecker happy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
shelf.py
1
1
#!/usr/bin/python
2
2
 
 
3
from patches import parse_patches
3
4
import os
4
5
import sys
5
 
from errors import CommandError
 
6
import string
 
7
import glob
 
8
import bzrlib
 
9
from bzrlib.commands import Command
 
10
from bzrlib.branch import Branch
 
11
from bzrlib import DEFAULT_IGNORE
6
12
from hunk_selector import ShelveHunkSelector, UnshelveHunkSelector
7
13
from diffstat import DiffStat
8
 
from patchsource import PatchSource, FilePatchSource
9
 
 
10
 
BASE_DIR = '.shelf'
 
14
 
 
15
DEFAULT_IGNORE.append('./.bzr-shelf*')
 
16
 
 
17
class QuitException(Exception):
 
18
    pass
11
19
 
12
20
class Shelf(object):
13
 
    def __init__(self, base, name='default'):
14
 
        self.base = base
15
 
        shelf_base = os.path.join(self.base, BASE_DIR)
16
 
        self.shelf_dir = os.path.join(shelf_base, name)
 
21
    def __init__(self, location, name='default'):
 
22
        self.branch = Branch.open_containing(location)[0]
 
23
        base = self.branch.controlfilename('x-shelf')
 
24
        self.shelf_dir = os.path.join(base, name)
17
25
 
18
 
        for dir in [shelf_base, self.shelf_dir]:
19
 
            if not os.path.isdir(dir):
20
 
                os.mkdir(dir)
 
26
        # FIXME surely there's an easier way to do this?
 
27
        t = self.branch._transport
 
28
        for dir in [base, self.shelf_dir]:
 
29
            if not t.has(dir):
 
30
                t.mkdir(dir)
21
31
 
22
32
    def __path(self, idx):
23
33
        return os.path.join(self.shelf_dir, '%.2d' % idx)
46
56
            return None
47
57
        return shelf[len(prefix):shelf.index('\n')]
48
58
 
49
 
    def __show_status(self, source):
50
 
        if source.can_live_update():
51
 
            diff_stat = DiffStat(source.readlines())
52
 
            print 'Diff status is now:\n', diff_stat
53
 
 
54
 
    def unshelve(self, patch_source, pick_hunks=False):
 
59
    def unshelve(self, pick_hunks=False):
55
60
        shelf = self.last_shelf()
56
61
 
57
62
        if shelf is None:
58
 
            raise CommandError("No shelf found in '%s'" % self.base)
 
63
            raise Exception("No shelf found in '%s'" % self.branch.base)
59
64
 
60
 
        patches = FilePatchSource(shelf).readpatches()
 
65
        patches = parse_patches(open(shelf, 'r').readlines())
61
66
        if pick_hunks:
62
 
            to_unshelve, to_remain = UnshelveHunkSelector(patches).select()
63
 
        else:
64
 
            to_unshelve = patches
65
 
            to_remain = []
 
67
            try:
 
68
                patches = UnshelveHunkSelector(patches).select()
 
69
            except QuitException:
 
70
                return False
66
71
 
67
 
        if len(to_unshelve) == 0:
68
 
            raise CommandError('Nothing to unshelve')
 
72
        if len(patches) == 0:
 
73
            print >>sys.stderr, 'Nothing to unshelve'
 
74
            return True
69
75
 
70
76
        print >>sys.stderr, "Reapplying shelved patches",
71
77
        message = self.get_shelf_message(open(shelf, 'r').read())
73
79
            print >>sys.stderr, ' "%s"' % message
74
80
        else:
75
81
            print >>sys.stderr, ""
76
 
 
77
 
        pipe = os.popen('patch -d %s -s -p0' % self.base, 'w')
78
 
        for patch in to_unshelve:
 
82
        pipe = os.popen('patch -d %s -s -p0' % self.branch.base, 'w')
 
83
        for patch in patches:
79
84
            pipe.write(str(patch))
80
85
        pipe.flush()
81
86
 
82
87
        if pipe.close() is not None:
83
 
            raise CommandError("Failed running patch!")
84
 
 
85
 
        if len(to_remain) == 0:
86
 
            os.remove(shelf)
87
 
        else:
88
 
            f = open(shelf, 'w')
89
 
            for patch in to_remain:
90
 
                f.write(str(patch))
91
 
            f.close()
92
 
 
93
 
        self.__show_status(patch_source)
94
 
 
95
 
    def shelve(self, patch_source, pick_hunks=False, message=None):
96
 
        patches = patch_source.readpatches()
 
88
            raise Exception("Failed running patch!")
 
89
 
 
90
        os.remove(shelf)
 
91
 
 
92
        diff_stat = DiffStat(self.get_patches(None, None))
 
93
        print 'Diff status is now:\n', diff_stat
 
94
 
 
95
        return True
 
96
 
 
97
    def get_patches(self, revision, file_list):
 
98
        from StringIO import StringIO
 
99
        from bzrlib.diff import show_diff
 
100
        out = StringIO()
 
101
        show_diff(self.branch, revision, specific_files=file_list, output=out)
 
102
        out.seek(0)
 
103
        return out.readlines()
 
104
 
 
105
    def shelve(self, pick_hunks=False, message=None, revision=None,
 
106
             file_list=None):
 
107
        patches = parse_patches(self.get_patches(revision, file_list))
97
108
 
98
109
        if pick_hunks:
99
 
            to_shelve = ShelveHunkSelector(patches).select()[0]
100
 
        else:
101
 
            to_shelve = patches
 
110
            try:
 
111
                patches = ShelveHunkSelector(patches).select()
 
112
            except QuitException:
 
113
                return False
102
114
 
103
 
        if len(to_shelve) == 0:
104
 
            raise CommandError('Nothing to shelve')
 
115
        if len(patches) == 0:
 
116
            print >>sys.stderr, 'Nothing to shelve'
 
117
            return True
105
118
 
106
119
        shelf = self.next_shelf()
107
120
        print >>sys.stderr, "Saving shelved patches to", shelf
109
122
        if message is not None:
110
123
            assert '\n' not in message
111
124
            shelf.write("# shelf: %s\n" % message)
112
 
        for patch in to_shelve:
 
125
        for patch in patches:
113
126
            shelf.write(str(patch))
114
127
 
115
128
        shelf.flush()
117
130
        shelf.close()
118
131
 
119
132
        print >>sys.stderr, "Reverting shelved patches"
120
 
        pipe = os.popen('patch -d %s -sR -p0' % self.base, 'w')
121
 
        for patch in to_shelve:
 
133
        pipe = os.popen('patch -d %s -sR -p0' % self.branch.base, 'w')
 
134
        for patch in patches:
122
135
            pipe.write(str(patch))
123
136
        pipe.flush()
124
137
 
125
138
        if pipe.close() is not None:
126
 
            raise CommandError("Failed running patch!")
127
 
 
128
 
        self.__show_status(patch_source)
 
139
            raise Exception("Failed running patch!")
 
140
 
 
141
        diff_stat = DiffStat(self.get_patches(None, None))
 
142
        print 'Diff status is now:\n', diff_stat
 
143
 
 
144
        return True
 
145