← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to shelf.py

  • Committer: Aaron Bentley
  • Date: 2006-05-03 19:39:28 UTC
  • mfrom: (147.4.37 push-to-rpush)
  • mto: This revision was merged to the branch mainline in revision 366.
  • Revision ID: abentley@panoramicfeedback.com-20060503193928-9cb76ec7fa7e881d
Merge from Robert

Show diffs side-by-side

added added

removed removed

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