diff options
Diffstat (limited to 'build/lib.linux-x86_64-2.7/dogtail/path.py')
-rw-r--r-- | build/lib.linux-x86_64-2.7/dogtail/path.py | 113 |
1 files changed, 113 insertions, 0 deletions
diff --git a/build/lib.linux-x86_64-2.7/dogtail/path.py b/build/lib.linux-x86_64-2.7/dogtail/path.py new file mode 100644 index 00000000000..5742cfb03e6 --- /dev/null +++ b/build/lib.linux-x86_64-2.7/dogtail/path.py @@ -0,0 +1,113 @@ +# -*- coding: utf-8 -*- +""" +Author: David Malcolm <dmalcolm@redhat.com> +""" +__author__ = """David Malcolm <dmalcolm@redhat.com>""" + + +class SearchPath(object): + + """ + Class used by the recording framework (and for more verbose script + logging) for identifying nodes in a persistent way, independent of the + style of script being written. + + Implemented as a list of (predicate, isRecursive) pairs, giving the + 'best' way to find the Accessible wrapped by a Node, starting at the + root and applying each search in turn. + + This is somewhat analagous to an absolute path in a filesystem, except + that some of searches may be recursive, rather than just searching + direct children. + + FIXME: try to ensure uniqueness + FIXME: need some heuristics to get 'good' searches, whatever + that means + """ + + def __init__(self): + self.__list = [] + + def __str__(self): + result = "{" + for (predicate, isRecursive) in self.__list: + result += "/(%s,%s)" % ( + predicate.describeSearchResult(), isRecursive) + return result + "}" + + # We need equality to work so that dicts of these work: + def __eq__(self, other): + # print "eq: self:%s"%self + # print " other:%s"%other + if len(self.__list) != len(other.__list): + # print "nonequal length" + return False + else: + for i in range(len(self.__list)): + if self.__list[i] != other.__list[i]: + return False + # print True + return True + + def append(self, predicate, isRecursive): + assert predicate + self.__list.append((predicate, isRecursive)) + + def __iter__(self): + return iter(self.__list) + + def length(self): + return len(self.__list) + + def makeScriptMethodCall(self): + """ + Used by the recording system. + + Generate the Python source code that will carry out this search. + """ + result = "" + for (predicate, isRecursive) in self.__list: + # print predicate + # print self.generateVariableName(predicate) + result += "." + predicate.makeScriptMethodCall(isRecursive) + return result + + def getRelativePath(self, other): + """ + Given another SearchPath instance, if the other is 'below' this + one, return a SearchPath that describes how to reach it relative + to this one (a copy of the second part of the list). Otherwise + return None. + """ + for i in range(len(self.__list)): + if self.__list[i] != other.__list[i]: + break + if i > 0: + # Slice from this point to the end: + result = SearchPath() + result.__list = other.__list[i + 1:] + + if False: + print("....................") + print("from %s" % self) + print("to %s" % other) + print("i=%s" % i) + print("relative path %s" % result) + print("....................") + + return result + else: + return None + + def getPrefix(self, n): + """ + Get the first n components of this instance as a new instance + """ + result = SearchPath() + for i in range(n): + result.__list.append(self.__list[i]) + return result + + def getPredicate(self, i): + (predicate, isRecursive) = self.__list[i] + return predicate |