1"""Classes that replace tkinter gui objects used by an object being tested.
2
3A gui object is anything with a master or parent parameter, which is
4typically required in spite of what the doc strings say.
5"""
6import re
7from _tkinter import TclError
8
9
10class Event:
11    '''Minimal mock with attributes for testing event handlers.
12
13    This is not a gui object, but is used as an argument for callbacks
14    that access attributes of the event passed. If a callback ignores
15    the event, other than the fact that is happened, pass 'event'.
16
17    Keyboard, mouse, window, and other sources generate Event instances.
18    Event instances have the following attributes: serial (number of
19    event), time (of event), type (of event as number), widget (in which
20    event occurred), and x,y (position of mouse). There are other
21    attributes for specific events, such as keycode for key events.
22    tkinter.Event.__doc__ has more but is still not complete.
23    '''
24    def __init__(self, **kwds):
25        "Create event with attributes needed for test"
26        self.__dict__.update(kwds)
27
28
29class Var:
30    "Use for String/Int/BooleanVar: incomplete"
31    def __init__(self, master=None, value=None, name=None):
32        self.master = master
33        self.value = value
34        self.name = name
35    def set(self, value):
36        self.value = value
37    def get(self):
38        return self.value
39
40
41class Mbox_func:
42    """Generic mock for messagebox functions, which all have the same signature.
43
44    Instead of displaying a message box, the mock's call method saves the
45    arguments as instance attributes, which test functions can then examine.
46    The test can set the result returned to ask function
47    """
48    def __init__(self, result=None):
49        self.result = result  # Return None for all show funcs
50    def __call__(self, title, message, *args, **kwds):
51        # Save all args for possible examination by tester
52        self.title = title
53        self.message = message
54        self.args = args
55        self.kwds = kwds
56        return self.result  # Set by tester for ask functions
57
58
59class Mbox:
60    """Mock for tkinter.messagebox with an Mbox_func for each function.
61
62    Example usage in test_module.py for testing functions in module.py:
63    ---
64from idlelib.idle_test.mock_tk import Mbox
65import module
66
67orig_mbox = module.messagebox
68showerror = Mbox.showerror  # example, for attribute access in test methods
69
70class Test(unittest.TestCase):
71
72    @classmethod
73    def setUpClass(cls):
74        module.messagebox = Mbox
75
76    @classmethod
77    def tearDownClass(cls):
78        module.messagebox = orig_mbox
79    ---
80    For 'ask' functions, set func.result return value before calling the method
81    that uses the message function. When messagebox functions are the
82    only gui alls in a method, this replacement makes the method gui-free,
83    """
84    askokcancel = Mbox_func()     # True or False
85    askquestion = Mbox_func()     # 'yes' or 'no'
86    askretrycancel = Mbox_func()  # True or False
87    askyesno = Mbox_func()        # True or False
88    askyesnocancel = Mbox_func()  # True, False, or None
89    showerror = Mbox_func()    # None
90    showinfo = Mbox_func()     # None
91    showwarning = Mbox_func()  # None
92
93
94class Text:
95    """A semi-functional non-gui replacement for tkinter.Text text editors.
96
97    The mock's data model is that a text is a list of \n-terminated lines.
98    The mock adds an empty string at  the beginning of the list so that the
99    index of actual lines start at 1, as with Tk. The methods never see this.
100    Tk initializes files with a terminal \n that cannot be deleted. It is
101    invisible in the sense that one cannot move the cursor beyond it.
102
103    This class is only tested (and valid) with strings of ascii chars.
104    For testing, we are not concerned with Tk Text's treatment of,
105    for instance, 0-width characters or character + accent.
106   """
107    def __init__(self, master=None, cnf={}, **kw):
108        '''Initialize mock, non-gui, text-only Text widget.
109
110        At present, all args are ignored. Almost all affect visual behavior.
111        There are just a few Text-only options that affect text behavior.
112        '''
113        self.data = ['', '\n']
114
115    def index(self, index):
116        "Return string version of index decoded according to current text."
117        return "%s.%s" % self._decode(index, endflag=1)
118
119    def _decode(self, index, endflag=0):
120        """Return a (line, char) tuple of int indexes into self.data.
121
122        This implements .index without converting the result back to a string.
123        The result is constrained by the number of lines and linelengths of
124        self.data. For many indexes, the result is initially (1, 0).
125
126        The input index may have any of several possible forms:
127        * line.char float: converted to 'line.char' string;
128        * 'line.char' string, where line and char are decimal integers;
129        * 'line.char lineend', where lineend='lineend' (and char is ignored);
130        * 'line.end', where end='end' (same as above);
131        * 'insert', the positions before terminal \n;
132        * 'end', whose meaning depends on the endflag passed to ._endex.
133        * 'sel.first' or 'sel.last', where sel is a tag -- not implemented.
134        """
135        if isinstance(index, (float, bytes)):
136            index = str(index)
137        try:
138            index=index.lower()
139        except AttributeError:
140            raise TclError('bad text index "%s"' % index) from None
141
142        lastline =  len(self.data) - 1  # same as number of text lines
143        if index == 'insert':
144            return lastline, len(self.data[lastline]) - 1
145        elif index == 'end':
146            return self._endex(endflag)
147
148        line, char = index.split('.')
149        line = int(line)
150
151        # Out of bounds line becomes first or last ('end') index
152        if line < 1:
153            return 1, 0
154        elif line > lastline:
155            return self._endex(endflag)
156
157        linelength = len(self.data[line])  -1  # position before/at \n
158        if char.endswith(' lineend') or char == 'end':
159            return line, linelength
160            # Tk requires that ignored chars before ' lineend' be valid int
161        if m := re.fullmatch(r'end-(\d*)c', char, re.A):  # Used by hyperparser.
162            return line, linelength - int(m.group(1))
163
164        # Out of bounds char becomes first or last index of line
165        char = int(char)
166        if char < 0:
167            char = 0
168        elif char > linelength:
169            char = linelength
170        return line, char
171
172    def _endex(self, endflag):
173        '''Return position for 'end' or line overflow corresponding to endflag.
174
175       -1: position before terminal \n; for .insert(), .delete
176       0: position after terminal \n; for .get, .delete index 1
177       1: same viewed as beginning of non-existent next line (for .index)
178       '''
179        n = len(self.data)
180        if endflag == 1:
181            return n, 0
182        else:
183            n -= 1
184            return n, len(self.data[n]) + endflag
185
186    def insert(self, index, chars):
187        "Insert chars before the character at index."
188
189        if not chars:  # ''.splitlines() is [], not ['']
190            return
191        chars = chars.splitlines(True)
192        if chars[-1][-1] == '\n':
193            chars.append('')
194        line, char = self._decode(index, -1)
195        before = self.data[line][:char]
196        after = self.data[line][char:]
197        self.data[line] = before + chars[0]
198        self.data[line+1:line+1] = chars[1:]
199        self.data[line+len(chars)-1] += after
200
201    def get(self, index1, index2=None):
202        "Return slice from index1 to index2 (default is 'index1+1')."
203
204        startline, startchar = self._decode(index1)
205        if index2 is None:
206            endline, endchar = startline, startchar+1
207        else:
208            endline, endchar = self._decode(index2)
209
210        if startline == endline:
211            return self.data[startline][startchar:endchar]
212        else:
213            lines = [self.data[startline][startchar:]]
214            for i in range(startline+1, endline):
215                lines.append(self.data[i])
216            lines.append(self.data[endline][:endchar])
217            return ''.join(lines)
218
219    def delete(self, index1, index2=None):
220        '''Delete slice from index1 to index2 (default is 'index1+1').
221
222        Adjust default index2 ('index+1) for line ends.
223        Do not delete the terminal \n at the very end of self.data ([-1][-1]).
224        '''
225        startline, startchar = self._decode(index1, -1)
226        if index2 is None:
227            if startchar < len(self.data[startline])-1:
228                # not deleting \n
229                endline, endchar = startline, startchar+1
230            elif startline < len(self.data) - 1:
231                # deleting non-terminal \n, convert 'index1+1 to start of next line
232                endline, endchar = startline+1, 0
233            else:
234                # do not delete terminal \n if index1 == 'insert'
235                return
236        else:
237            endline, endchar = self._decode(index2, -1)
238            # restricting end position to insert position excludes terminal \n
239
240        if startline == endline and startchar < endchar:
241            self.data[startline] = self.data[startline][:startchar] + \
242                                             self.data[startline][endchar:]
243        elif startline < endline:
244            self.data[startline] = self.data[startline][:startchar] + \
245                                   self.data[endline][endchar:]
246            startline += 1
247            for i in range(startline, endline+1):
248                del self.data[startline]
249
250    def compare(self, index1, op, index2):
251        line1, char1 = self._decode(index1)
252        line2, char2 = self._decode(index2)
253        if op == '<':
254            return line1 < line2 or line1 == line2 and char1 < char2
255        elif op == '<=':
256            return line1 < line2 or line1 == line2 and char1 <= char2
257        elif op == '>':
258            return line1 > line2 or line1 == line2 and char1 > char2
259        elif op == '>=':
260            return line1 > line2 or line1 == line2 and char1 >= char2
261        elif op == '==':
262            return line1 == line2 and char1 == char2
263        elif op == '!=':
264            return line1 != line2 or  char1 != char2
265        else:
266            raise TclError('''bad comparison operator "%s": '''
267                                  '''must be <, <=, ==, >=, >, or !=''' % op)
268
269    # The following Text methods normally do something and return None.
270    # Whether doing nothing is sufficient for a test will depend on the test.
271
272    def mark_set(self, name, index):
273        "Set mark *name* before the character at index."
274        pass
275
276    def mark_unset(self, *markNames):
277        "Delete all marks in markNames."
278
279    def tag_remove(self, tagName, index1, index2=None):
280        "Remove tag tagName from all characters between index1 and index2."
281        pass
282
283    # The following Text methods affect the graphics screen and return None.
284    # Doing nothing should always be sufficient for tests.
285
286    def scan_dragto(self, x, y):
287        "Adjust the view of the text according to scan_mark"
288
289    def scan_mark(self, x, y):
290        "Remember the current X, Y coordinates."
291
292    def see(self, index):
293        "Scroll screen to make the character at INDEX is visible."
294        pass
295
296    #  The following is a Misc method inherited by Text.
297    # It should properly go in a Misc mock, but is included here for now.
298
299    def bind(sequence=None, func=None, add=None):
300        "Bind to this widget at event sequence a call to function func."
301        pass
302
303
304class Entry:
305    "Mock for tkinter.Entry."
306    def focus_set(self):
307        pass
308