← 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-07-11 18:56:01 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060711185601-6e7f164148ed616d
Remove <BZRTOOLS> tag from command descriptions

Show diffs side-by-side

added added

removed removed

Lines of Context:
shelf.py
2
2
 
3
3
import os
4
4
import sys
5
 
from errors import CommandError
 
5
import subprocess
 
6
from datetime import datetime
 
7
from errors import CommandError, PatchFailed
6
8
from hunk_selector import ShelveHunkSelector, UnshelveHunkSelector
7
 
from diffstat import DiffStat
8
9
from patchsource import PatchSource, FilePatchSource
9
 
 
10
 
BASE_DIR = '.shelf'
 
10
from bzrlib.osutils import rename
11
11
 
12
12
class Shelf(object):
13
 
    def __init__(self, base, name='default'):
 
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
14
30
        self.name = name
15
 
        self.base = base
16
 
        shelf_base = os.path.join(self.base, BASE_DIR)
17
 
        self.shelf_dir = os.path.join(shelf_base, name)
18
 
 
19
 
        for dir in [shelf_base, self.shelf_dir]:
 
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)
20
40
            if not os.path.isdir(dir):
21
41
                os.mkdir(dir)
22
42
 
23
 
    def __path(self, idx):
24
 
        return os.path.join(self.shelf_dir, '%.2d' % idx)
25
 
 
26
 
    def next_shelf(self):
27
 
        index = 0
28
 
        while True:
29
 
            name = self.__path(index)
30
 
            if not os.path.exists(name):
31
 
                return name
32
 
            index += 1
33
 
 
34
 
    def last_shelf(self):
35
 
        shelves = os.listdir(self.shelf_dir)
36
 
        indexes = [int(f) for f in shelves]
 
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
 
37
119
        indexes.sort()
 
120
        return indexes
 
121
 
 
122
    def last_patch(self):
 
123
        indexes = self.__list()
38
124
 
39
125
        if len(indexes) == 0:
40
126
            return None
41
127
 
42
128
        return self.__path(indexes[-1])
43
129
 
44
 
    def get_shelf_message(self, shelf):
45
 
        prefix = "# shelf: "
46
 
        if not shelf.startswith(prefix):
 
130
    def get_patch_message(self, patch_path):
 
131
        patch = open(patch_path, 'r').read()
 
132
 
 
133
        if not patch.startswith(self.MESSAGE_PREFIX):
47
134
            return None
48
 
        return shelf[len(prefix):shelf.index('\n')]
49
 
 
50
 
    def __show_status(self, source):
51
 
        if source.can_live_update():
52
 
            diff_stat = str(DiffStat(source.readlines()))
53
 
            if len(diff_stat) > 0:
54
 
                print >> sys.stderr, 'Diff status is now:\n', diff_stat
55
 
            else:
56
 
                print >> sys.stderr, 'No changes left in working tree.'
57
 
 
58
 
    def unshelve(self, patch_source, pick_hunks=False):
59
 
        shelf = self.last_shelf()
60
 
 
61
 
        if shelf is None:
62
 
            raise CommandError("No shelf found in '%s'" % self.base)
63
 
 
64
 
        patches = FilePatchSource(shelf).readpatches()
65
 
        if pick_hunks:
66
 
            to_unshelve, to_remain = UnshelveHunkSelector(patches).select()
 
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()
67
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:
68
150
            to_unshelve = patches
69
151
            to_remain = []
 
152
        else:
 
153
            to_unshelve, to_remain = UnshelveHunkSelector(patches).select()
70
154
 
71
155
        if len(to_unshelve) == 0:
72
156
            raise CommandError('Nothing to unshelve')
73
157
 
74
 
        print >>sys.stderr, "Reapplying shelved patches",
75
 
        message = self.get_shelf_message(open(shelf, 'r').read())
76
 
        if message is not None:
77
 
            print >>sys.stderr, ' "%s"' % message
78
 
        else:
79
 
            print >>sys.stderr, ""
80
 
 
81
 
        pipe = os.popen('patch -d %s -s -p0' % self.base, 'w')
82
 
        for patch in to_unshelve:
83
 
            pipe.write(str(patch))
84
 
        pipe.flush()
85
 
 
86
 
        if pipe.close() is not None:
87
 
            raise CommandError("Failed running patch!")
88
 
 
89
 
        if len(to_remain) == 0:
90
 
            os.remove(shelf)
91
 
        else:
92
 
            f = open(shelf, 'w')
 
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')
93
188
            for patch in to_remain:
94
189
                f.write(str(patch))
95
190
            f.close()
96
191
 
97
 
        self.__show_status(patch_source)
 
192
    def shelve(self, patch_source, all=False, message=None):
 
193
        self._check_upgrade()
98
194
 
99
 
    def shelve(self, patch_source, pick_hunks=False, message=None):
100
195
        patches = patch_source.readpatches()
101
196
 
102
 
        if pick_hunks:
 
197
        if all:
 
198
            to_shelve = patches
 
199
        else:
103
200
            to_shelve = ShelveHunkSelector(patches).select()[0]
104
 
        else:
105
 
            to_shelve = patches
106
201
 
107
202
        if len(to_shelve) == 0:
108
203
            raise CommandError('Nothing to shelve')
109
204
 
110
 
        shelf = self.next_shelf()
111
 
        print >>sys.stderr, "Saving to shelf '%s', patch '%s'" % \
112
 
                (self.name, os.path.basename(shelf))
113
 
        shelf = open(shelf, 'a')
114
 
        if message is not None:
115
 
            assert '\n' not in message
116
 
            shelf.write("# shelf: %s\n" % message)
117
 
        for patch in to_shelve:
118
 
            shelf.write(str(patch))
119
 
 
120
 
        shelf.flush()
121
 
        os.fsync(shelf.fileno())
122
 
        shelf.close()
123
 
 
124
 
        print >>sys.stderr, "Reverting shelved patches."
125
 
        pipe = os.popen('patch -d %s -sR -p0' % self.base, 'w')
126
 
        for patch in to_shelve:
127
 
            pipe.write(str(patch))
128
 
        pipe.flush()
129
 
 
130
 
        if pipe.close() is not None:
131
 
            raise CommandError("Failed running patch!")
132
 
 
133
 
        self.__show_status(patch_source)
 
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):
 
279
            if name == stem:
 
280
                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()
 
304
 
 
305
        if len(patches) == 0:
 
306
            self.log('No old-style shelves found to upgrade.\n')
 
307
            return
 
308
 
 
309
        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 + '~')