~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to shelf.py

  • Committer: Aaron Bentley
  • Date: 2006-03-14 18:10:04 UTC
  • mto: This revision was merged to the branch mainline in revision 329.
  • Revision ID: abentley@panoramicfeedback.com-20060314181004-ea3edbc59ddc8ae3
Handle aliases in bzr shell

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#!/usr/bin/python
2
2
 
 
3
from patches import parse_patches
3
4
import os
4
5
import sys
5
 
import subprocess
6
 
from datetime import datetime
7
 
from errors import CommandError, PatchFailed
8
 
from hunk_selector import ShelveHunkSelector, UnshelveHunkSelector
9
 
from patchsource import PatchSource, FilePatchSource
10
 
from bzrlib.osutils import rename
 
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
 
12
from hunk_selector import HunkSelector
 
13
from diffstat import DiffStat
 
14
from subprocess import Popen, PIPE
 
15
 
 
16
DEFAULT_IGNORE.append('./.bzr-shelf*')
 
17
 
 
18
class QuitException(Exception):
 
19
    pass
11
20
 
12
21
class Shelf(object):
13
 
    MESSAGE_PREFIX = "# Shelved patch: "
14
 
 
15
 
    _paths = {
16
 
        'base'          : '.shelf',
17
 
        'shelves'       : '.shelf/shelves',
18
 
        'current-shelf' : '.shelf/current-shelf',
19
 
    }
20
 
 
21
 
    def __init__(self, base, name=None):
22
 
        self.base = base
23
 
        self.__setup()
24
 
 
25
 
        if name is None:
26
 
            current = os.path.join(self.base, self._paths['current-shelf'])
27
 
            name = open(current).read().strip()
28
 
 
29
 
        assert '\n' not in name
30
 
        self.name = name
31
 
 
32
 
        self.dir = os.path.join(self.base, self._paths['shelves'], name)
33
 
        if not os.path.isdir(self.dir):
34
 
            os.mkdir(self.dir)
35
 
 
36
 
    def __setup(self):
37
 
        # Create required directories etc.
38
 
        for dir in [self._paths['base'], self._paths['shelves']]:
39
 
            dir = os.path.join(self.base, dir)
40
 
            if not os.path.isdir(dir):
41
 
                os.mkdir(dir)
42
 
 
43
 
        current = os.path.join(self.base, self._paths['current-shelf'])
44
 
        if not os.path.exists(current):
45
 
            f = open(current, 'w')
46
 
            f.write('default')
47
 
            f.close()
48
 
 
49
 
    def make_default(self):
50
 
        f = open(os.path.join(self.base, self._paths['current-shelf']), 'w')
51
 
        f.write(self.name)
52
 
        f.close()
53
 
        self.log("Default shelf is now '%s'\n" % self.name)
54
 
 
55
 
    def log(self, msg):
56
 
        sys.stderr.write(msg)
57
 
 
58
 
    def delete(self, patch):
59
 
        path = self.__path_from_user(patch)
60
 
        rename(path, '%s~' % path)
61
 
 
62
 
    def display(self, patch=None):
63
 
        if patch is None:
64
 
            path = self.last_patch()
65
 
        else:
66
 
            path = self.__path_from_user(patch)
67
 
        sys.stdout.write(open(path).read())
68
 
 
69
 
    def list(self):
70
 
        indexes = self.__list()
71
 
        self.log("Patches on shelf '%s':" % self.name)
72
 
        if len(indexes) == 0:
73
 
            self.log(' None\n')
74
 
            return
75
 
        self.log('\n')
76
 
        for index in indexes:
77
 
            msg = self.get_patch_message(self.__path(index))
78
 
            if msg is None:
79
 
                msg = "No message saved with patch."
80
 
            self.log(' %.2d: %s\n' % (index, msg))
81
 
 
82
 
    def __path_from_user(self, patch_id):
83
 
        try:
84
 
            patch_index = int(patch_id)
85
 
        except (TypeError, ValueError):
86
 
            raise CommandError("Invalid patch name '%s'" % patch_id)
87
 
 
88
 
        path = self.__path(patch_index)
89
 
 
90
 
        if not os.path.exists(path):
91
 
            raise CommandError("Patch '%s' doesn't exist on shelf %s!" % \
92
 
                        (patch_id, self.name))
93
 
 
94
 
        return path
95
 
 
96
 
    def __path(self, index):
97
 
        return os.path.join(self.dir, '%.2d' % index)
98
 
 
99
 
    def next_patch(self):
100
 
        indexes = self.__list()
101
 
 
102
 
        if len(indexes) == 0:
103
 
            next = 0
104
 
        else:
105
 
            next = indexes[-1] + 1
106
 
        return self.__path(next)
107
 
 
108
 
    def __list(self):
109
 
        patches = os.listdir(self.dir)
110
 
        indexes = []
111
 
        for f in patches:
112
 
            if f.endswith('~'):
113
 
                continue # ignore backup files
114
 
            try:
115
 
                indexes.append(int(f))
116
 
            except ValueError:
117
 
                self.log("Warning: Ignoring junk file '%s' on shelf.\n" % f)
118
 
 
119
 
        indexes.sort()
120
 
        return indexes
121
 
 
122
 
    def last_patch(self):
123
 
        indexes = self.__list()
124
 
 
125
 
        if len(indexes) == 0:
126
 
            return None
127
 
 
128
 
        return self.__path(indexes[-1])
129
 
 
130
 
    def get_patch_message(self, patch_path):
131
 
        patch = open(patch_path, 'r').read()
132
 
 
133
 
        if not patch.startswith(self.MESSAGE_PREFIX):
134
 
            return None
135
 
        return patch[len(self.MESSAGE_PREFIX):patch.index('\n')]
136
 
 
137
 
    def unshelve(self, patch_source, patch_name=None, all=False, force=False):
138
 
        self._check_upgrade()
139
 
 
140
 
        if patch_name is None:
141
 
            patch_path = self.last_patch()
142
 
        else:
143
 
            patch_path = self.__path_from_user(patch_name)
144
 
 
145
 
        if patch_path is None:
146
 
            raise CommandError("No patch found on shelf %s" % self.name)
147
 
 
148
 
        patches = FilePatchSource(patch_path).readpatches()
149
 
        if all:
150
 
            to_unshelve = patches
151
 
            to_remain = []
152
 
        else:
153
 
            to_unshelve, to_remain = UnshelveHunkSelector(patches).select()
154
 
 
155
 
        if len(to_unshelve) == 0:
156
 
            raise CommandError('Nothing to unshelve')
157
 
 
158
 
        message = self.get_patch_message(patch_path)
159
 
        if message is None:
160
 
            message = "No message saved with patch."
161
 
        self.log('Unshelving from %s/%s: "%s"\n' % \
162
 
                (self.name, os.path.basename(patch_path), message))
163
 
 
164
 
        try:
165
 
            self._run_patch(to_unshelve, dry_run=True)
166
 
            self._run_patch(to_unshelve)
167
 
        except PatchFailed:
168
 
            try:
169
 
                self._run_patch(to_unshelve, strip=1, dry_run=True)
170
 
                self._run_patch(to_unshelve, strip=1)
171
 
            except PatchFailed:
172
 
                if force:
173
 
                    self.log('Warning: Unshelving failed, forcing as ' \
174
 
                             'requested. Shelf will not be modified.\n')
175
 
                    try:
176
 
                        self._run_patch(to_unshelve)
177
 
                    except PatchFailed:
178
 
                        pass
179
 
                    return
180
 
                raise CommandError("Your shelved patch no " \
181
 
                    "longer applies cleanly to the working tree!")
182
 
 
183
 
        # Backup the shelved patch
184
 
        rename(patch_path, '%s~' % patch_path)
185
 
 
186
 
        if len(to_remain) > 0:
187
 
            f = open(patch_path, 'w')
188
 
            for patch in to_remain:
189
 
                f.write(str(patch))
190
 
            f.close()
191
 
 
192
 
    def shelve(self, patch_source, all=False, message=None):
193
 
        self._check_upgrade()
194
 
 
195
 
        patches = patch_source.readpatches()
196
 
 
197
 
        if all:
198
 
            to_shelve = patches
199
 
        else:
200
 
            to_shelve = ShelveHunkSelector(patches).select()[0]
201
 
 
202
 
        if len(to_shelve) == 0:
203
 
            raise CommandError('Nothing to shelve')
204
 
 
205
 
        if message is None:
206
 
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
207
 
            message = "Changes shelved on %s" % timestamp
208
 
 
209
 
        patch_path = self.next_patch()
210
 
        self.log('Shelving to %s/%s: "%s"\n' % \
211
 
                (self.name, os.path.basename(patch_path), message))
212
 
 
213
 
        f = open(patch_path, 'a')
214
 
 
215
 
        assert '\n' not in message
216
 
        f.write("%s%s\n" % (self.MESSAGE_PREFIX, message))
217
 
 
218
 
        for patch in to_shelve:
219
 
            f.write(str(patch))
220
 
 
221
 
        f.flush()
222
 
        os.fsync(f.fileno())
223
 
        f.close()
224
 
 
225
 
        try:
226
 
            self._run_patch(to_shelve, reverse=True, dry_run=True)
227
 
            self._run_patch(to_shelve, reverse=True)
228
 
        except PatchFailed:
229
 
            try:
230
 
                self._run_patch(to_shelve, reverse=True, strip=1, dry_run=True)
231
 
                self._run_patch(to_shelve, reverse=True, strip=1)
232
 
            except PatchFailed:
233
 
                raise CommandError("Failed removing shelved changes from the"
234
 
                    "working tree!")
235
 
 
236
 
    def _run_patch(self, patches, strip=0, reverse=False, dry_run=False):
237
 
        args = ['patch', '-d', self.base, '-s', '-p%d' % strip, '-f']
238
 
 
239
 
        if sys.platform == "win32":
240
 
            args.append('--binary')
241
 
 
242
 
        if reverse:
243
 
            args.append('-R')
244
 
        if dry_run:
245
 
            args.append('--dry-run')
246
 
            stdout = stderr = subprocess.PIPE
247
 
        else:
248
 
            stdout = stderr = None
249
 
 
250
 
        process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=stdout,
251
 
                        stderr=stderr)
252
 
        for patch in patches:
253
 
            process.stdin.write(str(patch))
254
 
 
255
 
        process.communicate()
256
 
 
257
 
        result = process.wait()
258
 
        if result != 0:
259
 
            raise PatchFailed()
260
 
 
261
 
        return result
262
 
 
263
 
    def _check_upgrade(self):
264
 
        if len(self._list_old_shelves()) > 0:
265
 
            raise CommandError("Old format shelves found, either upgrade " \
266
 
                    "or remove them!")
267
 
 
268
 
    def _list_old_shelves(self):
269
 
        import glob
270
 
        stem = os.path.join(self.base, '.bzr-shelf')
271
 
 
272
 
        patches = glob.glob(stem)
273
 
        patches.extend(glob.glob(stem + '-*[!~]'))
274
 
 
275
 
        if len(patches) == 0:
276
 
            return []
277
 
 
278
 
        def patch_index(name):
 
22
    def __init__(self, location):
 
23
        self.branch = Branch.open_containing(location)[0]
 
24
 
 
25
    def shelf_suffix(self, index):
 
26
        if index == 0:
 
27
            return ""
 
28
        else:
 
29
            return "-%d" % index
 
30
 
 
31
    def next_shelf(self):
 
32
        def name_sequence():
 
33
            i = 0
 
34
            while True:
 
35
                yield self.shelf_suffix(i)
 
36
                i = i + 1
 
37
 
 
38
        stem = os.path.join(self.branch.base, '.bzr-shelf')
 
39
        for end in name_sequence():
 
40
            name = stem + end
 
41
            if not os.path.exists(name):
 
42
                return name
 
43
 
 
44
    def last_shelf(self):
 
45
        stem = os.path.join(self.branch.base, '.bzr-shelf')
 
46
        shelves = glob.glob(stem)
 
47
        shelves.extend(glob.glob(stem + '-*'))
 
48
        def shelf_index(name):
279
49
            if name == stem:
280
50
                return 0
281
 
            return int(name[len(stem) + 1:])
282
 
 
283
 
        # patches might not be sorted in the right order
284
 
        patch_ids = []
285
 
        for patch in patches:
286
 
            if patch == stem:
287
 
                patch_ids.append(0)
288
 
            else:
289
 
                patch_ids.append(int(patch[len(stem) + 1:]))
290
 
 
291
 
        patch_ids.sort()
292
 
 
293
 
        patches = []
294
 
        for id in patch_ids:
295
 
            if id == 0:
296
 
                patches.append(stem)
297
 
            else:
298
 
                patches.append('%s-%s' % (stem, id))
299
 
 
300
 
        return patches
301
 
 
302
 
    def upgrade(self):
303
 
        patches = self._list_old_shelves()
 
51
            return int(name[len(stem)+1:])
 
52
        shelvenums = [shelf_index(f) for f in shelves]
 
53
        shelvenums.sort()
 
54
 
 
55
        if len(shelvenums) == 0:
 
56
            return None
 
57
        return stem + self.shelf_suffix(shelvenums[-1])
 
58
 
 
59
    def get_shelf_message(self, shelf):
 
60
        prefix = "# shelf: "
 
61
        if not shelf.startswith(prefix):
 
62
            return None
 
63
        return shelf[len(prefix):shelf.index('\n')]
 
64
 
 
65
    def unshelve(self):
 
66
        shelf = self.last_shelf()
 
67
 
 
68
        if shelf is None:
 
69
            raise Exception("No shelf found in '%s'" % self.branch.base)
 
70
 
 
71
        patch = open(shelf, 'r').read()
 
72
 
 
73
        print >>sys.stderr, "Reapplying shelved patches",
 
74
        message = self.get_shelf_message(patch)
 
75
        if message is not None:
 
76
            print >>sys.stderr, ' "%s"' % message
 
77
        else:
 
78
            print >>sys.stderr, ""
 
79
        run_patch(self.branch.base, (patch,))
 
80
        os.remove(shelf)
 
81
 
 
82
        diff_stat = DiffStat(self.get_patches(None, None))
 
83
        print 'Diff status is now:\n', diff_stat
 
84
 
 
85
        return 1
 
86
 
 
87
    def get_patches(self, revision, file_list):
 
88
        from StringIO import StringIO
 
89
        from bzrlib.diff import show_diff
 
90
        out = StringIO()
 
91
        show_diff(self.branch, revision, specific_files=file_list, output=out)
 
92
        out.seek(0)
 
93
        return out.readlines()
 
94
 
 
95
    def shelve(self, all_hunks=False, message=None, revision=None,
 
96
             file_list=None):
 
97
        patches = parse_patches(self.get_patches(revision, file_list))
 
98
 
 
99
        if not all_hunks:
 
100
            try:
 
101
                patches = HunkSelector(patches).select()
 
102
            except QuitException:
 
103
                return False
304
104
 
305
105
        if len(patches) == 0:
306
 
            self.log('No old-style shelves found to upgrade.\n')
307
 
            return
 
106
            print >>sys.stderr, 'Nothing to shelve'
 
107
            return 0
308
108
 
 
109
        shelf = self.next_shelf()
 
110
        print >>sys.stderr, "Saving shelved patches to", shelf
 
111
        shelf = open(shelf, 'a')
 
112
        if message is not None:
 
113
            assert '\n' not in message
 
114
            shelf.write("# shelf: %s\n" % message)
309
115
        for patch in patches:
310
 
            old_file = open(patch, 'r')
311
 
            new_path = self.next_patch()
312
 
            new_file = open(new_path, 'w')
313
 
            new_file.write(old_file.read())
314
 
            old_file.close()
315
 
            new_file.close()
316
 
            self.log('Copied %s to %s/%s\n' % (os.path.basename(patch),
317
 
                self.name, os.path.basename(new_path)))
318
 
            rename(patch, patch + '~')
 
116
            shelf.write(str(patch))
 
117
 
 
118
        shelf.flush()
 
119
        os.fsync(shelf.fileno())
 
120
        shelf.close()
 
121
 
 
122
        print >>sys.stderr, "Reverting shelved patches"
 
123
        run_patch(self.branch.base, patches, reverse=True)
 
124
 
 
125
        diff_stat = DiffStat(self.get_patches(None, None))
 
126
        print 'Diff status is now:\n', diff_stat
 
127
 
 
128
        return 1
 
129
 
 
130
def run_patch(branch_base, patches, reverse=False):
 
131
    args = ['patch', '-d', branch_base, '-s', '-p1', '-f']
 
132
    if reverse:
 
133
        args.append('-R')
 
134
    process = Popen(args, stdin=PIPE)
 
135
    for patch in patches:
 
136
        process.stdin.write(str(patch))
 
137
    process.stdin.close()
 
138
    result = process.wait()
 
139
    if result not in (0, 1):
 
140
        raise Exception("Error applying patches")
 
141
    return result