← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to hunk_selector.py

  • Committer: Aaron Bentley
  • Date: 2006-03-16 05:48:38 UTC
  • mfrom: (321.2.5 bzrtools)
  • Revision ID: aaron.bentley@utoronto.ca-20060316054838-a59dfe944c17b493
Got push working with new-format branches

Show diffs side-by-side

added added

removed removed

Lines of Context:
hunk_selector.py
1
1
#!/usr/bin/python
2
2
 
3
 
from userinteractor import UserInteractor, UserOption
4
 
import copy
 
3
import sys
5
4
 
6
5
class HunkSelector:
7
 
    strings = {}
 
6
    class Option:
 
7
        def __init__(self, char, action, help, default=False):
 
8
            self.char = char
 
9
            self.action = action
 
10
            self.default = default
 
11
            self.help = help
 
12
 
 
13
    standard_options = [
 
14
        Option('n', 'shelve', 'shelve this change for the moment.',
 
15
            default=True),
 
16
        Option('y', 'keep', 'keep this change in your tree.'),
 
17
        Option('d', 'done', 'done, skip to the end.'),
 
18
        Option('i', 'invert', 'invert the current selection of all hunks.'),
 
19
        Option('s', 'status', 'show status of hunks.'),
 
20
        Option('q', 'quit', 'quit')
 
21
    ]
 
22
 
 
23
    end_options = [
 
24
        Option('y', 'continue', 'proceed to shelve selected changes.',
 
25
            default=True),
 
26
        Option('r', 'restart', 'restart the hunk selection loop.'),
 
27
        Option('s', 'status', 'show status of hunks.'),
 
28
        Option('i', 'invert', 'invert the current selection of all hunks.'),
 
29
        Option('q', 'quit', 'quit')
 
30
    ]
8
31
 
9
32
    def __init__(self, patches):
10
 
        self.standard_options = [
11
 
            UserOption('y', self._selected, self.strings['select_desc'],
12
 
                default=True),
13
 
            UserOption('n', self._unselected, self.strings['unselect_desc']),
14
 
            UserOption('d', UserInteractor.FINISH, 'done, skip to the end.'),
15
 
            UserOption('i', self._invert,
16
 
                'invert the current selection status of all hunks.'),
17
 
            UserOption('s', self._status,
18
 
                'show selection status of all hunks.'),
19
 
            UserOption('q', UserInteractor.QUIT, 'quit')
20
 
        ]
21
 
 
22
 
        self.end_options = [
23
 
            UserOption('y', UserInteractor.FINISH, self.strings['finish_desc'],
24
 
                default=True),
25
 
            UserOption('r', UserInteractor.RESTART,
26
 
                'restart the hunk selection loop.'),
27
 
            UserOption('s', self._status,
28
 
                'show selection status of all hunks.'),
29
 
            UserOption('i', self._invert,
30
 
                'invert the current selection status of all hunks.'),
31
 
            UserOption('q', UserInteractor.QUIT, 'quit')
32
 
        ]
33
 
 
34
33
        self.patches = patches
35
34
        self.total_hunks = 0
36
 
 
37
 
        self.interactor = UserInteractor()
38
 
        self.interactor.set_item_callback(self._hunk_callback)
39
 
        self.interactor.set_start_callback(self._start_callback)
40
 
        self.interactor.set_end_callback(self._end_callback)
41
 
 
42
35
        for patch in patches:
43
36
            for hunk in patch.hunks:
44
 
                # everything's selected by default
 
37
                # everything's shelved by default
45
38
                hunk.selected = True
46
39
                self.total_hunks += 1
47
 
                # we need a back pointer in the callbacks
48
 
                hunk.patch = patch
49
 
                self.interactor.add_item(hunk)
50
 
 
51
 
    # Called at the start of the main loop
52
 
    def _start_callback(self):
53
 
        self.last_printed = -1
54
 
        self.interactor.set_prompt(self.strings['prompt'])
55
 
        self.interactor.set_options(self.standard_options)
56
 
 
57
 
    # Called at the end of the item loop, return False to indicate that the
58
 
    # interaction isn't finished and the confirmation prompt should be displayed
59
 
    def _end_callback(self):
60
 
        self._status()
61
 
        self.interactor.set_prompt(self.strings['end_prompt'])
62
 
        self.interactor.set_options(self.end_options)
63
 
        return False
64
 
 
65
 
    # Called once for each hunk
66
 
    def _hunk_callback(self, hunk, count):
67
 
        if self.last_printed != count:
68
 
            print hunk.patch.get_header(), hunk
69
 
            self.last_printed = count
70
 
 
71
 
        if hunk.selected:
72
 
            self.interactor.get_option('y').default = True
73
 
            self.interactor.get_option('n').default = False
74
 
        else:
75
 
            self.interactor.get_option('y').default = False
76
 
            self.interactor.get_option('n').default = True
77
 
 
78
 
    # The user chooses to (un)shelve a hunk
79
 
    def _selected(self, hunk):
80
 
        hunk.selected = True
81
 
        return True
82
 
 
83
 
    # The user chooses to keep a hunk
84
 
    def _unselected(self, hunk):
85
 
        hunk.selected = False
86
 
        return True
87
 
 
88
 
    # The user chooses to invert the selection
89
 
    def _invert(self, hunk):
 
40
 
 
41
    def __get_option(self, char):
 
42
        for opt in self.standard_options:
 
43
            if opt.char == char:
 
44
                return opt
 
45
        raise Exception('Option "%s" not found!' % char)
 
46
 
 
47
    def __select_loop(self):
 
48
        j = 0
 
49
        for patch in self.patches:
 
50
            i = 0
 
51
            lasti = -1
 
52
            while i < len(patch.hunks):
 
53
                hunk = patch.hunks[i]
 
54
                if lasti != i:
 
55
                    print patch.get_header(), hunk
 
56
                    j += 1
 
57
                lasti = i
 
58
 
 
59
                prompt = 'Keep this change? (%d of %d)' \
 
60
                            % (j, self.total_hunks)
 
61
 
 
62
                if hunk.selected:
 
63
                    self.__get_option('n').default = True
 
64
                    self.__get_option('y').default = False
 
65
                else:
 
66
                    self.__get_option('n').default = False
 
67
                    self.__get_option('y').default = True
 
68
 
 
69
                action = self.__ask_user(prompt, self.standard_options)
 
70
 
 
71
                if action == 'keep':
 
72
                    hunk.selected = False
 
73
                elif action == 'shelve':
 
74
                    hunk.selected = True
 
75
                elif action == 'done':
 
76
                    return True
 
77
                elif action == 'invert':
 
78
                    self.__invert_selection()
 
79
                    self.__show_status()
 
80
                    continue
 
81
                elif action == 'status':
 
82
                    self.__show_status()
 
83
                    continue
 
84
                elif action == 'quit':
 
85
                    return False
 
86
 
 
87
                i += 1
 
88
        return True
 
89
 
 
90
    def select(self):
 
91
        if self.total_hunks == 0:
 
92
            return []
 
93
 
 
94
        done = False
 
95
        while not done:
 
96
            if not self.__select_loop():
 
97
                return []
 
98
 
 
99
            while True:
 
100
                self.__show_status()
 
101
                prompt = "Shelve these changes, or restart?"
 
102
                action = self.__ask_user(prompt, self.end_options)
 
103
 
 
104
                if action == 'continue':
 
105
                    done = True
 
106
                    break
 
107
                elif action == 'quit':
 
108
                    return []
 
109
                elif action == 'status':
 
110
                    self.__show_status()
 
111
                elif action == 'invert':
 
112
                    self.__invert_selection()
 
113
                elif action == 'restart':
 
114
                    break
 
115
 
 
116
 
 
117
        for patch in self.patches:
 
118
            tmp = []
 
119
            for hunk in patch.hunks:
 
120
                if hunk.selected:
 
121
                    tmp.append(hunk)
 
122
            patch.hunks = tmp
 
123
 
 
124
        tmp = []
 
125
        for patch in self.patches:
 
126
            if len(patch.hunks):
 
127
                tmp.append(patch)
 
128
        self.patches = tmp
 
129
 
 
130
        return self.patches
 
131
 
 
132
    def __invert_selection(self):
90
133
        for patch in self.patches:
91
134
            for hunk in patch.hunks:
92
135
                if hunk.__dict__.has_key('selected'):
93
136
                    hunk.selected = not hunk.selected
94
137
                else:
95
138
                    hunk.selected = True
96
 
        self._status()
97
 
        return False
98
139
 
99
 
    # The user wants to see the status
100
 
    def _status(self, hunk=None):
 
140
    def __show_status(self):
101
141
        print '\nStatus:'
102
142
        for patch in self.patches:
103
143
            print '  %s' % patch.oldname
104
 
            selected = 0
105
 
            unselected = 0
 
144
            shelve = 0
 
145
            keep = 0
106
146
            for hunk in patch.hunks:
107
147
                if hunk.selected:
108
 
                    selected += 1
 
148
                    shelve += 1
109
149
                else:
110
 
                    unselected += 1
 
150
                    keep += 1
111
151
 
112
 
            print '  ', self.strings['status_selected'] % selected
113
 
            print '  ', self.strings['status_unselected'] % unselected
 
152
            print '    %d hunks to be shelved' % shelve
 
153
            print '    %d hunks to be kept' % keep
114
154
            print
115
155
 
116
 
        # Tell the interactor we're not done with this item
117
 
        return False
118
 
 
119
 
    def select(self):
120
 
        if self.total_hunks == 0 or not self.interactor.interact():
121
 
            # False from interact means they chose to quit
122
 
            return ([], [])
123
 
 
124
 
        # Go through each patch and collect all selected/unselected hunks
125
 
        for patch in self.patches:
126
 
            patch.selected = []
127
 
            patch.unselected = []
128
 
            for hunk in patch.hunks:
129
 
                if hunk.selected:
130
 
                    patch.selected.append(hunk)
131
 
                else:
132
 
                    patch.unselected.append(hunk)
133
 
 
134
 
        # Now build two lists, one of selected patches the other unselected
135
 
        selected_patches = []
136
 
        unselected_patches = []
137
 
 
138
 
        for patch in self.patches:
139
 
            if len(patch.selected):
140
 
                tmp = copy.copy(patch)
141
 
                tmp.hunks = tmp.selected
142
 
                del tmp.selected
143
 
                del tmp.unselected
144
 
                selected_patches.append(tmp)
145
 
 
146
 
            if len(patch.unselected):
147
 
                tmp = copy.copy(patch)
148
 
                tmp.hunks = tmp.unselected
149
 
                del tmp.selected
150
 
                del tmp.unselected
151
 
                unselected_patches.append(tmp)
152
 
 
153
 
        return (selected_patches, unselected_patches)
154
 
 
155
 
class ShelveHunkSelector(HunkSelector):
156
 
    def __init__(self, patches):
157
 
        self.strings = {}
158
 
        self.strings['status_selected'] = '%d hunks to be shelved'
159
 
        self.strings['status_unselected'] = '%d hunks to be kept'
160
 
        self.strings['select_desc'] = 'shelve this change.'
161
 
        self.strings['unselect_desc'] = 'keep this change in your tree.'
162
 
        self.strings['finish_desc'] = 'shelve selected changes.'
163
 
        self.strings['prompt'] = 'Shelve this change? (%(count)d of %(total)d)'
164
 
        self.strings['end_prompt'] = 'Shelve these changes?'
165
 
        HunkSelector.__init__(self, patches)
166
 
 
167
 
class UnshelveHunkSelector(HunkSelector):
168
 
    def __init__(self, patches):
169
 
        self.strings = {}
170
 
        self.strings['status_selected'] = '%d hunks to be unshelved'
171
 
        self.strings['status_unselected'] = '%d hunks left on shelf'
172
 
        self.strings['select_desc'] = 'unshelve this change.'
173
 
        self.strings['unselect_desc'] = 'leave this change on the shelf.'
174
 
        self.strings['finish_desc'] = 'unshelve selected changes.'
175
 
        self.strings['prompt'] = 'Unshelve this change? ' \
176
 
            '(%(count)d of %(total)d)'
177
 
        self.strings['end_prompt'] = 'Unshelve these changes?'
178
 
        HunkSelector.__init__(self, patches)
 
156
    if sys.platform == "win32":
 
157
        import msvcrt
 
158
        def __getchar(self):
 
159
            return msvcrt.getche()
 
160
    else:
 
161
        def __getchar(self):
 
162
            import tty
 
163
            import termios
 
164
            fd = sys.stdin.fileno()
 
165
            settings = termios.tcgetattr(fd)
 
166
            try:
 
167
                tty.setraw(fd)
 
168
                ch = sys.stdin.read(1)
 
169
            finally:
 
170
                termios.tcsetattr(fd, termios.TCSADRAIN, settings)
 
171
            return ch
 
172
 
 
173
    def __ask_user(self, prompt, options):
 
174
        while True:
 
175
            sys.stdout.write(prompt)
 
176
            sys.stdout.write(' [')
 
177
            for opt in options:
 
178
                if opt.default:
 
179
                    default = opt
 
180
                sys.stdout.write(opt.char)
 
181
            sys.stdout.write('?] (%s): ' % default.char)
 
182
 
 
183
            response = self.__getchar()
 
184
 
 
185
            # default, which we see as newline, is 'n'
 
186
            if response in ['\n', '\r', '\r\n']:
 
187
                response = default.char
 
188
 
 
189
            print response # because echo is off
 
190
 
 
191
            for opt in options:
 
192
                if opt.char == response:
 
193
                    return opt.action
 
194
 
 
195
            for opt in options:
 
196
                print '  %s - %s' % (opt.char, opt.help)