← 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-10-19 11:34:39 UTC
  • mto: (0.3.1 shelf-dev) (325.1.2 bzrtools)
  • mto: This revision was merged to the branch mainline in revision 246.
  • Revision ID: michael@ellerman.id.au-20051019113439-193bca379eec5798
Move all shelf functions into a class. Only logic change is we save the
bzr root dir rather than recomputing it again and again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
shelf.py
13
13
 
14
14
DEFAULT_IGNORE.append('./.bzr-shelf*')
15
15
 
16
 
def tree_root():
17
 
    return run_bzr('root')[0].strip()
18
 
 
19
 
def shelf_suffix(index):
20
 
    if index == 0:
21
 
        return ""
22
 
    else:
23
 
        return "-%d" % index
24
 
 
25
 
def next_shelf():
26
 
    def name_sequence():
27
 
        i = 0
28
 
        while True:
29
 
            yield shelf_suffix(i)
30
 
            i = i + 1
31
 
 
32
 
    stem = os.path.join(tree_root(), '.bzr-shelf')
33
 
    for end in name_sequence():
34
 
        name = stem + end
35
 
        if not os.path.exists(name):
36
 
            return name
37
 
 
38
 
def last_shelf():
39
 
    stem = os.path.join(tree_root(), '.bzr-shelf')
40
 
    shelves = glob.glob(stem)
41
 
    shelves.extend(glob.glob(stem + '-*'))
42
 
    def shelf_index(name):
43
 
        if name == stem:
44
 
            return 0
45
 
        return int(name[len(stem)+1:])
46
 
    shelvenums = [shelf_index(f) for f in shelves]
47
 
    shelvenums.sort()
48
 
 
49
 
    if len(shelvenums) == 0:
50
 
        return None
51
 
    return stem + shelf_suffix(shelvenums[-1])
52
 
 
53
 
def get_shelf_message(shelf):
54
 
    prefix = "# shelf: "
55
 
    if not shelf.startswith(prefix):
56
 
        return None
57
 
    return shelf[len(prefix):shelf.index('\n')]
58
 
 
59
 
def unshelve():
60
 
    shelf = last_shelf()
61
 
 
62
 
    if shelf is None:
63
 
        raise Exception("No shelf found in '%s'" % tree_root())
64
 
 
65
 
    patch = open(shelf, 'r').read()
66
 
 
67
 
    print >>sys.stderr, "Reapplying shelved patches",
68
 
    message = get_shelf_message(patch)
69
 
    if message is not None:
70
 
        print >>sys.stderr, ' "%s"' % message
71
 
    else:
72
 
        print >>sys.stderr, ""
73
 
    pipe = os.popen('patch -d %s -s -p0' % tree_root(), 'w')
74
 
    pipe.write(patch)
75
 
    pipe.flush()
76
 
 
77
 
    if pipe.close() is not None:
78
 
        raise Exception("Failed running patch!")
79
 
 
80
 
    os.remove(shelf)
81
 
    print 'Diff status is now:'
82
 
    os.system('bzr diff | diffstat')
83
 
 
84
 
    return True
85
 
 
86
 
class QuitException(Exception):
87
 
    pass
88
 
 
89
 
def shelve(message = None, revision = None, file_list = None):
90
 
    cmd = ['diff']
91
 
    if revision is not None:
92
 
        cmd.extend(['--revision', str(revision[0])])
93
 
    if file_list is not None:
94
 
        cmd.extend(file_list)
95
 
    patches = parse_patches(run_bzr(cmd))
96
 
    try:
97
 
        patches = HunkSelector(patches).select()
98
 
    except QuitException:
99
 
        return False
100
 
 
101
 
    if len(patches) == 0:
102
 
        print >>sys.stderr, 'Nothing to shelve'
103
 
        return True
104
 
 
105
 
    shelf = next_shelf()
106
 
    print >>sys.stderr, "Saving shelved patches to", shelf
107
 
    shelf = open(shelf, 'a')
108
 
    if message is not None:
109
 
        assert '\n' not in message
110
 
        shelf.write("# shelf: %s\n" % message)
111
 
    for patch in patches:
112
 
        shelf.write(str(patch))
113
 
 
114
 
    shelf.flush()
115
 
    os.fsync(shelf.fileno())
116
 
    shelf.close()
117
 
 
118
 
    print >>sys.stderr, "Reverting shelved patches"
119
 
    pipe = os.popen('patch -d %s -sR -p0' % tree_root(), 'w')
120
 
    for patch in patches:
121
 
       pipe.write(str(patch))
122
 
    pipe.flush()
123
 
 
124
 
    if pipe.close() is not None:
125
 
        raise Exception("Failed running patch!")
126
 
 
127
 
    print 'Diff status is now:'
128
 
    os.system('bzr diff | diffstat')
129
 
 
130
 
    return True
131
 
 
132
16
def run_bzr(args):
133
17
    if type(args) is str:
134
18
        args = [ args ]
137
21
    if pipe.close() is not None:
138
22
        raise Exception("Failed running bzr")
139
23
    return lines
 
24
 
 
25
class QuitException(Exception):
 
26
    pass
 
27
 
 
28
class Shelf(object):
 
29
    def __init__(self):
 
30
        self.bzr_root = run_bzr('root')[0].strip()
 
31
 
 
32
    def shelf_suffix(self, index):
 
33
        if index == 0:
 
34
            return ""
 
35
        else:
 
36
            return "-%d" % index
 
37
 
 
38
    def next_shelf(self):
 
39
        def name_sequence():
 
40
            i = 0
 
41
            while True:
 
42
                yield self.shelf_suffix(i)
 
43
                i = i + 1
 
44
 
 
45
        stem = os.path.join(self.bzr_root, '.bzr-shelf')
 
46
        for end in name_sequence():
 
47
            name = stem + end
 
48
            if not os.path.exists(name):
 
49
                return name
 
50
 
 
51
    def last_shelf(self):
 
52
        stem = os.path.join(self.bzr_root, '.bzr-shelf')
 
53
        shelves = glob.glob(stem)
 
54
        shelves.extend(glob.glob(stem + '-*'))
 
55
        def shelf_index(name):
 
56
            if name == stem:
 
57
                return 0
 
58
            return int(name[len(stem)+1:])
 
59
        shelvenums = [shelf_index(f) for f in shelves]
 
60
        shelvenums.sort()
 
61
 
 
62
        if len(shelvenums) == 0:
 
63
            return None
 
64
        return stem + self.shelf_suffix(shelvenums[-1])
 
65
 
 
66
    def get_shelf_message(self, shelf):
 
67
        prefix = "# shelf: "
 
68
        if not shelf.startswith(prefix):
 
69
            return None
 
70
        return shelf[len(prefix):shelf.index('\n')]
 
71
 
 
72
    def unshelve(self):
 
73
        shelf = self.last_shelf()
 
74
 
 
75
        if shelf is None:
 
76
            raise Exception("No shelf found in '%s'" % self.bzr_root)
 
77
 
 
78
        patch = open(shelf, 'r').read()
 
79
 
 
80
        print >>sys.stderr, "Reapplying shelved patches",
 
81
        message = self.get_shelf_message(patch)
 
82
        if message is not None:
 
83
            print >>sys.stderr, ' "%s"' % message
 
84
        else:
 
85
            print >>sys.stderr, ""
 
86
        pipe = os.popen('patch -d %s -s -p0' % self.bzr_root, 'w')
 
87
        pipe.write(patch)
 
88
        pipe.flush()
 
89
 
 
90
        if pipe.close() is not None:
 
91
            raise Exception("Failed running patch!")
 
92
 
 
93
        os.remove(shelf)
 
94
        print 'Diff status is now:'
 
95
        os.system('bzr diff | diffstat')
 
96
 
 
97
        return True
 
98
 
 
99
    def shelve(self, message=None, revision=None, file_list=None):
 
100
        cmd = ['diff']
 
101
        if revision is not None:
 
102
            cmd.extend(['--revision', str(revision[0])])
 
103
        if file_list is not None:
 
104
            cmd.extend(file_list)
 
105
        patches = parse_patches(run_bzr(cmd))
 
106
        try:
 
107
            patches = HunkSelector(patches).select()
 
108
        except QuitException:
 
109
            return False
 
110
 
 
111
        if len(patches) == 0:
 
112
            print >>sys.stderr, 'Nothing to shelve'
 
113
            return True
 
114
 
 
115
        shelf = self.next_shelf()
 
116
        print >>sys.stderr, "Saving shelved patches to", shelf
 
117
        shelf = open(shelf, 'a')
 
118
        if message is not None:
 
119
            assert '\n' not in message
 
120
            shelf.write("# shelf: %s\n" % message)
 
121
        for patch in patches:
 
122
            shelf.write(str(patch))
 
123
 
 
124
        shelf.flush()
 
125
        os.fsync(shelf.fileno())
 
126
        shelf.close()
 
127
 
 
128
        print >>sys.stderr, "Reverting shelved patches"
 
129
        pipe = os.popen('patch -d %s -sR -p0' % self.bzr_root, 'w')
 
130
        for patch in patches:
 
131
            pipe.write(str(patch))
 
132
        pipe.flush()
 
133
 
 
134
        if pipe.close() is not None:
 
135
            raise Exception("Failed running patch!")
 
136
 
 
137
        print 'Diff status is now:'
 
138
        os.system('bzr diff | diffstat')
 
139
 
 
140
        return True
 
141