« back to all changes in this revision
Viewing changes to shelf.py
- browse files at revision 327
- compare with another revision
- download diff
- download tarball
- view history from revision 327
- Committer: Aaron Bentley
- Date: 2006-03-13 00:13:56 UTC
- Revision ID: aaron.bentley@utoronto.ca-20060313001356-6aadd11700e1ac1f
Marked deprecation bugs
- files added:
- diffstat.py
- files removed:
- NEWS.Shelf
- files renamed:
- tests/blackbox.py => blackbox.py
- tests/shelf_tests.py => shelf_tests.py
- files modified:
- .bzrignore
added
removed
shelf.py
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
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
10
20
11
21
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):
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):
268
49
if name == stem:
269
50
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()
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
293
104
294
105
if len(patches) == 0:
295
self.log('No old-style shelves found to upgrade.\n')
296
return
106
print >>sys.stderr, 'Nothing to shelve'
107
return 0
297
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)
298
115
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 + '~')
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
Loggerhead is a web-based interface for Breezy
Version: 2.0.1