Idea: implement an object tree helper module

[ghost]

We might want to have a module that provides support for common operations with the object tree. It can also have a function that is more flexible than squish.findAllObjects. It can use the object.children() method, and thus will be able to use object references as an argument.

Points:

• Both Selenium and Squish use BFS (Breadth-first search) algorithm, so we might as well want to implement our recursive algorithms that way.
• The common return type for all the find methods should be a tuple.
• Additional behaviors could be implemented. Like, find children objects with multiple types, or all types.

Possible functions/methods:

• find_children_by_type(object_reference, type:str) -> tuple
• find_all_children(object_reference) -> tuple - this function could possibly return a tuple with all children of the given object. There may be a need in providing the depth of search, or this can be a separate function. Those could be useful if you would like to sort or reduce the tuple/list using python methods.
• find_siblings(object_reference) -> tuple

[pawtom]

I do think that function names should distinguish children (understood by immediate children) and search all descendant elements.

Take a look at how this is done in jQuery API:
The .children() method differs from .find() in that .children() only travels a single level down the DOM tree while .find() can traverse down multiple levels to select descendant elements (grandchildren, etc.) as well.
More info here: https://api.jquery.com/category/traversing/tree-traversal/

[pawtom]

I think in the end I would see just two functions for looking for children:
children(parent_obj, selectors:dict) -> for looking only at immediate children
find(parent_obj, selectors:dict) -> for looking at all descendant objects

And similar for parents:
find_parent(obj, selectors:dict)

[Adakar]

I like the idea of following jQuery. IMO find_parents(obj, selectors:dict) or parents(obj, selectors:dict)

[Adakar]

@EduardKaverinskyi unless you have any other questions feel free to start working on that. The final function names can be decided later :)

[ghost]

One thing that came to my mind while developing this idea, is that it would be useful to have lambda functions in selectors. This way it will be very easy to find very specific objects using this module.

For example:
selector = {
'y' : lambda x: x > 0,
'text' : lambda x: len(x) > 0 and len(x) < 25
}

It will be also possible to check that object has the specified attribute with any value as following:
selector = {
'geometry' : lambda: True
}

What do you guys think?

[pawtom]

I like this idea :)

[ghost]

Another thing that in my opinion would be useful is a function named is_highlightable(obj), which will return True or False and will be universal for the objects of different types and properties.

It will be possible to find all highlightable objects very easily with:
highlightable_objects = filter(is_highlightable, object_tree.find(mainWindow))

[pawtom]

I don't think this is a good idea, all visible objects which have e a "non-zero" are highlightable. So the real issue is to be able to say if the object is "really" visible - so visible property is True and size is "non-zero" and maybe the location is inside a screen. But this is a topic for another module, not an object-tree.