« back to all changes in this revision
Viewing changes to dogtail/predicate.py
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- Committer: Bazaar Package Importer
- Author(s): Jose Carlos Garcia Sogo
- Date: 2006-12-16 10:57:30 UTC
- mfrom: (1.2.1 upstream) (3.1.1 edgy)
- Revision ID: james.westby@ubuntu.com-20061216105730-utt6mcidfssawo7j
Tags: 0.6.1-3
pyhton-at-spi has to be added as dependency (Closes: #402752)
added
removed
dogtail/predicate.py
8
8
from i18n import TranslatableString
9
9
10
10
def stringMatches(scriptName, reportedName):
11
assert isinstance(scriptName, TranslatableString)
12
13
return scriptName.matchedBy(reportedName)
14
11
assert isinstance(scriptName, TranslatableString)
12
13
return scriptName.matchedBy(reportedName)
14
15
15
def makeScriptRecursiveArgument(isRecursive, defaultValue):
16
if isRecursive==defaultValue:
17
return ""
18
else:
19
return ", recursive=%s"%isRecursive
16
if isRecursive==defaultValue:
17
return ""
18
else:
19
return ", recursive=%s"%isRecursive
20
20
21
21
def makeCamel(string):
22
"""
23
Convert string to camelCaps
24
"""
25
# FIXME: this function is probably really fragile, lots of difficult cases here
22
"""
23
Convert string to camelCaps
24
"""
25
string = str(string)
26
# FIXME: this function is probably really fragile, lots of difficult cases here
26
27
27
# Sanitize string, replacing bad characters with spaces:
28
for char in ":;!@#$%^&*()-+=_~`\\/?|[]{}<>,.\t\n\r\"'":
29
string = string.replace(char, " ")
30
words = string.strip().split(" ")
31
for word in words:
32
word.strip
33
result = ""
34
firstWord=True
35
for word in words:
36
lowercaseWord = word.lower()
37
if firstWord:
38
result += lowercaseWord
39
firstWord=False
40
else:
41
result += lowercaseWord.capitalize()
42
return result
28
# Sanitize string, replacing bad characters with spaces:
29
for char in ":;!@#$%^&*()-+=_~`\\/?|[]{}<>,.\t\n\r\"'":
30
string = string.replace(char, " ")
31
words = string.strip().split(" ")
32
for word in words:
33
word.strip
34
result = ""
35
firstWord=True
36
for word in words:
37
lowercaseWord = word.lower()
38
if firstWord:
39
result += lowercaseWord
40
firstWord=False
41
else:
42
result += lowercaseWord.capitalize()
43
return result
43
44
44
45
class Predicate:
45
"""Abstract base class representing a predicate function on nodes.
46
47
It's more than just a function in that it has data and can describe itself"""
48
def satisfiedByNode(self, node):
49
"""Pure virtual method returning a boolean if the predicate is satisfied by the node"""
50
raise NotImplementedError
51
52
def describeSearchResult(self, node):
53
raise NotImplementedError
54
55
def makeScriptMethodCall(self, isRecursive):
56
"""
57
Method to generate a string containing a (hopefully) readable search
58
method call on a node (to be used when generating Python source code in
59
the event recorder)
60
"""
61
raise NotImplementedError
62
63
def makeScriptVariableName(self):
64
"""
65
Method to generate a string containing a (hopefully) readable name
66
for a Node instance variable that would be the result of a search on
67
this predicate (to be used when generating Python source code in the
68
event recorder).
69
"""
70
raise NotImplementedError
71
72
def __eq__(self, other):
73
"""
74
Predicates are considered equal if they are of the same subclass and
75
have the same data
76
"""
77
# print "predeq: self:%s"%self
78
# print " other:%s"%other
79
# print "predeq: selfdict:%s"%self.__dict__
80
# print " otherdict:%s"%other.__dict__
81
82
if type(self)!=type(other):
83
return False
84
else:
85
return self.__dict__ == other.__dict__
46
"""Abstract base class representing a predicate function on nodes.
47
48
It's more than just a function in that it has data and can describe itself"""
49
def satisfiedByNode(self, node):
50
"""Pure virtual method returning a boolean if the predicate is satisfied by the node"""
51
raise NotImplementedError
52
53
def describeSearchResult(self, node):
54
raise NotImplementedError
55
56
def makeScriptMethodCall(self, isRecursive):
57
"""
58
Method to generate a string containing a (hopefully) readable search
59
method call on a node (to be used when generating Python source code in
60
the event recorder)
61
"""
62
raise NotImplementedError
63
64
def makeScriptVariableName(self):
65
"""
66
Method to generate a string containing a (hopefully) readable name
67
for a Node instance variable that would be the result of a search on
68
this predicate (to be used when generating Python source code in the
69
event recorder).
70
"""
71
raise NotImplementedError
72
73
def __eq__(self, other):
74
"""
75
Predicates are considered equal if they are of the same subclass and
76
have the same data
77
"""
78
# print "predeq: self:%s"%self
79
# print " other:%s"%other
80
# print "predeq: selfdict:%s"%self.__dict__
81
# print " otherdict:%s"%other.__dict__
82
83
if type(self)!=type(other):
84
return False
85
else:
86
return self.__dict__ == other.__dict__
86
87
87
88
88
89
class IsAnApplicationNamed(Predicate):
89
"""Search subclass that looks for an application by name"""
90
def __init__(self, appName):
91
self.appName = TranslatableString(appName)
92
93
def satisfiedByNode(self, node):
94
return node.roleName=='application' and stringMatches(self.appName, node.name)
95
96
def describeSearchResult(self):
97
return '%s application'%self.appName
98
99
def makeScriptMethodCall(self, isRecursive):
100
# ignores the isRecursive parameter
101
return "application('%s')"%self.appName
102
103
def makeScriptVariableName(self):
104
return makeCamel(self.appName)+"App"
90
"""Search subclass that looks for an application by name"""
91
def __init__(self, appName):
92
self.appName = TranslatableString(appName)
93
self.debugName = self.describeSearchResult()
94
95
def satisfiedByNode(self, node):
96
return node.roleName=='application' and stringMatches(self.appName, node.name)
97
98
def describeSearchResult(self):
99
return '%s application'%self.appName
100
101
def makeScriptMethodCall(self, isRecursive):
102
# ignores the isRecursive parameter
103
return "application(%s)"%self.appName
104
105
def makeScriptVariableName(self):
106
return makeCamel(self.appName)+"App"
105
107
106
108
class GenericPredicate(Predicate):
107
"""SubtreePredicate subclass that takes various optional search fields"""
108
109
def __init__(self, name = None, roleName = None, description= None, label = None, debugName=None):
110
if name:
111
self.name = TranslatableString(name)
112
else:
113
self.name = None
114
self.roleName = roleName
115
self.description = description
116
if label:
117
self.label = TranslatableString(label)
118
else:
119
self.label = None
120
121
if debugName:
122
self.debugName = debugName
123
else:
124
if label:
125
self.debugName = "labelled '%s'"%self.label
126
else:
127
self.debugName = "child with"
128
if name:
129
self.debugName += " name=%s" % self.name
130
if roleName:
131
self.debugName += " roleName='%s'"%roleName
132
if description:
133
self.debugName += " description='%s'"%description
134
assert self.debugName
135
136
137
def satisfiedByNode(self, node):
138
# labelled nodes are handled specially:
139
if self.label:
140
# this reverses the search; we're looking for a node with LABELLED_BY
141
# and then checking the label, rather than looking for a label and
142
# then returning whatever LABEL_FOR targets
143
if node.labeller:
144
return stringMatches(self.label, node.labeller.name)
145
else: return False
146
else:
147
# Ensure the node matches any criteria that were set:
148
if self.name:
149
if not stringMatches(self.name,node.name): return False
150
if self.roleName:
151
if self.roleName!=node.roleName: return False
152
if self.description:
153
if self.description!=node.description: return False
154
return True
155
156
def describeSearchResult(self):
157
return self.debugName
158
159
def makeScriptMethodCall(self, isRecursive):
160
if self.label:
161
args = "label='%s'"%label
162
else:
163
args = ""
164
if self.name:
165
args += " name='%s'"%self.name
166
if self.roleName:
167
args += " roleName='%s'"%self.roleName
168
if self.description:
169
args += " description='%s'"%self.description
170
return "child(%s%s)"%(args, makeScriptRecursiveArgument(isRecursive, True))
171
172
def makeScriptVariableName(self):
173
if self.label:
174
return makeCamel(self.label)+"Node"
175
else:
176
if self.name:
177
return makeCamel(self.name)+"Node"
178
if self.roleName:
179
return makeCamel(self.roleName)+"Node"
180
if self.description:
181
return makeCamel(self.description)+"Node"
109
"""SubtreePredicate subclass that takes various optional search fields"""
110
111
def __init__(self, name = None, roleName = None, description= None, label = None, debugName=None):
112
if name:
113
self.name = TranslatableString(name)
114
else:
115
self.name = None
116
self.roleName = roleName
117
self.description = description
118
if label:
119
self.label = TranslatableString(label)
120
else:
121
self.label = None
122
123
if debugName:
124
self.debugName = debugName
125
else:
126
if label:
127
self.debugName = "labelled '%s'"%self.label
128
else:
129
self.debugName = "child with"
130
if name:
131
self.debugName += " name=%s" % self.name
132
if roleName:
133
self.debugName += " roleName='%s'"%roleName
134
if description:
135
self.debugName += " description='%s'"%description
136
assert self.debugName
137
138
139
def satisfiedByNode(self, node):
140
# labelled nodes are handled specially:
141
if self.label:
142
# this reverses the search; we're looking for a node with LABELLED_BY
143
# and then checking the label, rather than looking for a label and
144
# then returning whatever LABEL_FOR targets
145
if node.labeller:
146
return stringMatches(self.label, node.labeller.name)
147
else: return False
148
else:
149
# Ensure the node matches any criteria that were set:
150
if self.name:
151
if not stringMatches(self.name,node.name): return False
152
if self.roleName:
153
if self.roleName!=node.roleName: return False
154
if self.description:
155
if self.description!=node.description: return False
156
return True
157
158
def describeSearchResult(self):
159
return self.debugName
160
161
def makeScriptMethodCall(self, isRecursive):
162
if self.label:
163
args = "label=%s"%label
164
else:
165
args = ""
166
if self.name:
167
args += " name=%s"%self.name
168
if self.roleName:
169
args += " roleName=%s"%self.roleName
170
if self.description:
171
args += " description=%s"%self.description
172
return "child(%s%s)"%(args, makeScriptRecursiveArgument(isRecursive, True))
173
174
def makeScriptVariableName(self):
175
if self.label:
176
return makeCamel(self.label)+"Node"
177
else:
178
if self.name:
179
return makeCamel(self.name)+"Node"
180
if self.roleName:
181
return makeCamel(self.roleName)+"Node"
182
if self.description:
183
return makeCamel(self.description)+"Node"
182
184
183
185
class IsNamed(Predicate):
184
"""Predicate subclass that looks simply by name"""
185
186
def __init__(self, name):
187
self.name = TranslatableString(name)
188
189
def satisfiedByNode(self, node):
190
return stringMatches(self.name, node.name)
191
192
def describeSearchResult(self):
193
return "named %s"%self.name
194
195
def makeScriptMethodCall(self, isRecursive):
196
return "child(name='%s'%s)"%(self.name, makeScriptRecursiveArgument(isRecursive, True))
197
def makeScriptVariableName(self):
198
return makeCamel(self.name)+"Node"
186
"""Predicate subclass that looks simply by name"""
187
188
def __init__(self, name):
189
self.name = TranslatableString(name)
190
self.debugName = self.describeSearchResult()
191
192
def satisfiedByNode(self, node):
193
return stringMatches(self.name, node.name)
194
195
def describeSearchResult(self):
196
return "named %s"%self.name
197
198
def makeScriptMethodCall(self, isRecursive):
199
return "child(name=%s%s)"%(self.name, makeScriptRecursiveArgument(isRecursive, True))
200
def makeScriptVariableName(self):
201
return makeCamel(self.name)+"Node"
199
202
200
203
class IsAWindowNamed(Predicate):
201
"""Predicate subclass that looks for a top-level window by name"""
202
def __init__(self, windowName):
203
self.windowName = TranslatableString(windowName)
204
205
def satisfiedByNode(self, node):
206
return node.roleName=='frame' and stringMatches(self.windowName, node.name)
207
208
def describeSearchResult(self):
209
return "%s window"%self.windowName
210
211
def makeScriptMethodCall(self, isRecursive):
212
return "window('%s'%s)"%(self.windowName, makeScriptRecursiveArgument(isRecursive, False))
213
214
def makeScriptVariableName(self):
215
return makeCamel(self.windowName)+"Win"
204
"""Predicate subclass that looks for a top-level window by name"""
205
def __init__(self, windowName):
206
self.windowName = TranslatableString(windowName)
207
self.debugName = self.describeSearchResult()
208
209
def satisfiedByNode(self, node):
210
return node.roleName=='frame' and stringMatches(self.windowName, node.name)
211
212
def describeSearchResult(self):
213
return "%s window"%self.windowName
214
215
def makeScriptMethodCall(self, isRecursive):
216
return "window(%s%s)"%(self.windowName, makeScriptRecursiveArgument(isRecursive, False))
217
218
def makeScriptVariableName(self):
219
return makeCamel(self.windowName)+"Win"
216
220
217
221
class IsAWindow(Predicate):
218
"""Predicate subclass that looks for top-level windows"""
219
def satisfiedByNode(self, node):
220
return node.roleName=='frame'
222
"""Predicate subclass that looks for top-level windows"""
223
def satisfiedByNode(self, node):
224
return node.roleName=='frame'
221
225
222
def describeSearchResult(self):
223
return "window"
226
def describeSearchResult(self):
227
return "window"
224
228
225
229
class IsADialogNamed(Predicate):
226
"""Predicate subclass that looks for a top-level dialog by name"""
227
def __init__(self, dialogName):
228
self.dialogName = TranslatableString(dialogName)
229
230
def satisfiedByNode(self, node):
231
return node.roleName=='dialog' and stringMatches(self.dialogName, node.name)
232
233
def describeSearchResult(self):
234
return '%s dialog'%self.dialogName
235
236
def makeScriptMethodCall(self, isRecursive):
237
return "dialog('%s'%s)"%(self.dialogName, makeScriptRecursiveArgument(isRecursive, False))
238
239
def makeScriptVariableName(self):
240
return makeCamel(self.dialogName)+"Dlg"
230
"""Predicate subclass that looks for a top-level dialog by name"""
231
def __init__(self, dialogName):
232
self.dialogName = TranslatableString(dialogName)
233
self.debugName = self.describeSearchResult()
234
235
def satisfiedByNode(self, node):
236
return node.roleName=='dialog' and stringMatches(self.dialogName, node.name)
237
238
def describeSearchResult(self):
239
return '%s dialog'%self.dialogName
240
241
def makeScriptMethodCall(self, isRecursive):
242
return "dialog(%s%s)"%(self.dialogName, makeScriptRecursiveArgument(isRecursive, False))
243
244
def makeScriptVariableName(self):
245
return makeCamel(self.dialogName)+"Dlg"
241
246
242
247
class IsLabelledBy(Predicate):
243
"""Predicate: is this node labelled by another node"""
244
pass
248
"""Predicate: is this node labelled by another node"""
249
pass
245
250
246
251
class IsLabelledAs(Predicate):
247
"""Predicate: is this node labelled with the text string (i.e. by another node with that as a name)"""
248
def __init__(self, labelText):
249
self.labelText = TranslatableString(labelText)
250
251
def satisfiedByNode(self, node):
252
# FIXME
253
if node.labeller:
254
return stringMatches(self.labelText, node.labeller.name)
255
else: return False
256
257
def describeSearchResult(self):
258
return 'labelled %s'%self.labelText
259
260
def makeScriptMethodCall(self, isRecursive):
261
return "child(label='%s'%s)"%(self.labelText, makeScriptRecursiveArgument(isRecursive, True))
262
263
def makeScriptVariableName(self):
264
return makeCamel(self.labelText)+"Node"
252
"""Predicate: is this node labelled with the text string (i.e. by another node with that as a name)"""
253
def __init__(self, labelText):
254
self.labelText = TranslatableString(labelText)
255
self.debugName = self.describeSearchResult()
256
257
def satisfiedByNode(self, node):
258
# FIXME
259
if node.labeller:
260
return stringMatches(self.labelText, node.labeller.name)
261
else: return False
262
263
def describeSearchResult(self):
264
return 'labelled %s'%self.labelText
265
266
def makeScriptMethodCall(self, isRecursive):
267
return "child(label=%s%s)"%(self.labelText, makeScriptRecursiveArgument(isRecursive, True))
268
269
def makeScriptVariableName(self):
270
return makeCamel(self.labelText)+"Node"
265
271
266
272
class IsAMenuNamed(Predicate):
267
"""Predicate subclass that looks for a menu by name"""
268
def __init__(self, menuName):
269
self.menuName = TranslatableString(menuName)
270
271
def satisfiedByNode(self, node):
272
return node.roleName=='menu' and stringMatches(self.menuName, node.name)
273
274
def describeSearchResult(self):
275
return '%s menu'%(self.menuName)
276
277
def makeScriptMethodCall(self, isRecursive):
278
return "menu('%s'%s)"%(self.menuName, makeScriptRecursiveArgument(isRecursive, True))
279
280
def makeScriptVariableName(self):
281
return makeCamel(self.menuName)+"Menu"
273
"""Predicate subclass that looks for a menu by name"""
274
def __init__(self, menuName):
275
self.menuName = TranslatableString(menuName)
276
self.debugName = self.describeSearchResult()
277
278
def satisfiedByNode(self, node):
279
return node.roleName=='menu' and stringMatches(self.menuName, node.name)
280
281
def describeSearchResult(self):
282
return '%s menu'%(self.menuName)
283
284
def makeScriptMethodCall(self, isRecursive):
285
return "menu(%s%s)"%(self.menuName, makeScriptRecursiveArgument(isRecursive, True))
286
287
def makeScriptVariableName(self):
288
return makeCamel(self.menuName)+"Menu"
282
289
283
290
class IsAMenuItemNamed(Predicate):
284
"""Predicate subclass that looks for a menu item by name"""
285
def __init__(self, menuItemName):
286
self.menuItemName = TranslatableString(menuItemName)
287
288
def satisfiedByNode(self, node):
289
roleName = node.roleName
290
return (roleName=='menu item' or roleName=='check menu item' or roleName=='radio menu item') and stringMatches(self.menuItemName, node.name)
291
292
def describeSearchResult(self):
293
return '%s menuitem'%(self.menuItemName)
294
295
def makeScriptMethodCall(self, isRecursive):
296
return "menuItem('%s'%s)"%(self.menuItemName, makeScriptRecursiveArgument(isRecursive, True))
297
298
def makeScriptVariableName(self):
299
return makeCamel(self.menuItemName)+"MenuItem"
291
"""Predicate subclass that looks for a menu item by name"""
292
def __init__(self, menuItemName):
293
self.menuItemName = TranslatableString(menuItemName)
294
self.debugName = self.describeSearchResult()
295
296
def satisfiedByNode(self, node):
297
roleName = node.roleName
298
return (roleName=='menu item' or roleName=='check menu item' or roleName=='radio menu item') and stringMatches(self.menuItemName, node.name)
299
300
def describeSearchResult(self):
301
return '%s menuitem'%(self.menuItemName)
302
303
def makeScriptMethodCall(self, isRecursive):
304
return "menuItem(%s%s)"%(self.menuItemName, makeScriptRecursiveArgument(isRecursive, True))
305
306
def makeScriptVariableName(self):
307
return makeCamel(self.menuItemName)+"MenuItem"
300
308
301
309
class IsATextEntryNamed(Predicate):
302
"""Predicate subclass that looks for a text entry by name"""
303
def __init__(self, textEntryName):
304
self.textEntryName = TranslatableString(textEntryName)
305
306
def satisfiedByNode(self, node):
307
return node.roleName=='text' and stringMatches(self.textEntryName, node.name)
308
309
def describeSearchResult(self):
310
return '%s textentry'%(self.textEntryName)
311
312
def makeScriptMethodCall(self, isRecursive):
313
return "textentry('%s'%s)"%(self.textEntryName, makeScriptRecursiveArgument(isRecursive, True))
314
315
def makeScriptVariableName(self):
316
return makeCamel(self.textEntryName)+"Entry"
310
"""Predicate subclass that looks for a text entry by name"""
311
def __init__(self, textEntryName):
312
self.textEntryName = TranslatableString(textEntryName)
313
self.debugName = self.describeSearchResult()
314
315
def satisfiedByNode(self, node):
316
return node.roleName=='text' and stringMatches(self.textEntryName, node.name)
317
318
def describeSearchResult(self):
319
return '%s textentry'%(self.textEntryName)
320
321
def makeScriptMethodCall(self, isRecursive):
322
return "textentry(%s%s)"%(self.textEntryName, makeScriptRecursiveArgument(isRecursive, True))
323
324
def makeScriptVariableName(self):
325
return makeCamel(self.textEntryName)+"Entry"
317
326
318
327
class IsAButtonNamed(Predicate):
319
"""Predicate subclass that looks for a button by name"""
320
def __init__(self, buttonName):
321
self.buttonName = TranslatableString(buttonName)
322
323
def satisfiedByNode(self, node):
324
return node.roleName=='push button' and stringMatches(self.buttonName, node.name)
325
326
def describeSearchResult(self):
327
return '%s button'%(self.buttonName)
328
329
def makeScriptMethodCall(self, isRecursive):
330
return "button('%s'%s)"%(self.buttonName, makeScriptRecursiveArgument(isRecursive, True))
331
332
def makeScriptVariableName(self):
333
return makeCamel(self.buttonName)+"Button"
328
"""Predicate subclass that looks for a button by name"""
329
def __init__(self, buttonName):
330
self.buttonName = TranslatableString(buttonName)
331
self.debugName = self.describeSearchResult()
332
333
def satisfiedByNode(self, node):
334
return node.roleName=='push button' and stringMatches(self.buttonName, node.name)
335
336
def describeSearchResult(self):
337
return '%s button'%(self.buttonName)
338
339
def makeScriptMethodCall(self, isRecursive):
340
return "button(%s%s)"%(self.buttonName, makeScriptRecursiveArgument(isRecursive, True))
341
342
def makeScriptVariableName(self):
343
return makeCamel(self.buttonName)+"Button"
334
344
335
345
class IsATabNamed(Predicate):
336
"""Predicate subclass that looks for a tab by name"""
337
def __init__(self, tabName):
338
self.tabName = TranslatableString(tabName)
339
340
def satisfiedByNode(self, node):
341
return node.roleName=='page tab' and stringMatches(self.tabName, node.name)
342
343
def describeSearchResult(self):
344
return '%s tab'%(self.tabName)
345
346
def makeScriptMethodCall(self, isRecursive):
347
return "tab('%s'%s)"%(self.tabName, makeScriptRecursiveArgument(isRecursive, True))
348
349
def makeScriptVariableName(self):
350
return makeCamel(self.tabName)+"Tab"
346
"""Predicate subclass that looks for a tab by name"""
347
def __init__(self, tabName):
348
self.tabName = TranslatableString(tabName)
349
self.debugName = self.describeSearchResult()
350
351
def satisfiedByNode(self, node):
352
return node.roleName=='page tab' and stringMatches(self.tabName, node.name)
353
354
def describeSearchResult(self):
355
return '%s tab'%(self.tabName)
356
357
def makeScriptMethodCall(self, isRecursive):
358
return "tab(%s%s)"%(self.tabName, makeScriptRecursiveArgument(isRecursive, True))
359
360
def makeScriptVariableName(self):
361
return makeCamel(self.tabName)+"Tab"
351
362
352
363
class PredicateTests(unittest.TestCase):
353
def testCapitalization(self):
354
self.assertEquals(makeCamel("gnome-terminal"),"gnomeTerminal")
355
self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")
356
self.assertEquals(makeCamel('self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")'), "selfAssertequalsMakecamelEvolutionMailEvolutionmail")
364
def testCapitalization(self):
365
self.assertEquals(makeCamel("gnome-terminal"),"gnomeTerminal")
366
self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")
367
self.assertEquals(makeCamel('self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")'), "selfAssertequalsMakecamelEvolutionMailEvolutionmail")
357
368
358
369
if __name__ == "__main__":
359
unittest.main()
370
unittest.main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1