Move the lookup logic into a separate class

Moved lookup logic from Finder to the new FindOperation class. Finder
manages the state of the whole lookup process, like remaining roots and
recursion, while FindOperation performs a single lookup for a single root.

Find and Find All both use the same executeLookup method for the lookup
and cast the results respectively into either a Node or a Set. The type
of lookup (first/all) is given as an argument in FindOperations constructor.

Methods for getting the FindPrefix and removing it from the query string
were moved to QueryParser.

Author: psaikkonen

src/main/java/javafxlibrary/utils/finder/FindOperation.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2017-2018   Eficode Oy
+ * Copyright 2018-       Robot Framework Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javafxlibrary.utils.finder;
+
+import javafx.collections.ObservableSet;
+import javafx.css.PseudoClass;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafxlibrary.exceptions.JavaFXLibraryNonFatalException;
+import javafxlibrary.matchers.InstanceOfMatcher;
+import javafxlibrary.utils.TestFxAdapter;
+import org.testfx.api.FxRobotInterface;
+import org.testfx.matcher.control.LabeledMatchers;
+import org.testfx.service.query.NodeQuery;
+
+public class FindOperation {
+
+    private Parent root;
+    private Query query;
+    private boolean findAll;
+    private FxRobotInterface robot;
+
+    public FindOperation(Parent root, Query query, boolean findAll) {
+        this.root = root;
+        this.query = query;
+        this.findAll = findAll;
+        this.robot = TestFxAdapter.getRobot();
+    }
+
+    protected Object executeLookup() {
+        FindPrefix prefix = query.getPrefix();
+        String lookupQuery = query.getQuery();
+
+        switch (prefix) {
+            case ID:
+            case CSS:
+                return findAll ? root.lookupAll(lookupQuery) : root.lookup(lookupQuery);
+            case CLASS:
+                NodeQuery classLookupResults = classLookup(root, lookupQuery);
+                return findAll ? classLookupResults.queryAll() : classLookupResults.query();
+            case TEXT:
+                NodeQuery textLookupResults = robot.from(root).lookup(LabeledMatchers.hasText(lookupQuery));
+                return findAll ? textLookupResults.queryAll() : textLookupResults.query();
+            case XPATH:
+                XPathFinder xPathFinder = new XPathFinder();
+                return findAll ? xPathFinder.findAll(lookupQuery, root) : xPathFinder.find(lookupQuery, root);
+            case PSEUDO:
+                NodeQuery pseudoLookupResults = pseudoLookup(root, lookupQuery);
+                return findAll ? pseudoLookupResults.queryAll() : pseudoLookupResults.query();
+        }
+        throw new IllegalArgumentException("FindPrefix value " + prefix + " of query " + query + " is not supported");
+    }
+
+    private NodeQuery pseudoLookup(Parent root, String query) {
+        String[] queries = query.split(";");
+        return robot.from(root).lookup((Node n) -> {
+            int matching = 0;
+            ObservableSet<PseudoClass> pseudoStates = n.getPseudoClassStates();
+
+            for (PseudoClass c : pseudoStates)
+                for (String q : queries)
+                    if (c.getPseudoClassName().equals(q))
+                        matching++;
+
+            return n != root && (matching == queries.length);
+        });
+    }
+
+    private NodeQuery classLookup(Parent root, String query) {
+        try {
+            Class<?> clazz = Class.forName(query);
+            InstanceOfMatcher matcher = new InstanceOfMatcher(clazz);
+            return robot.from(root).lookup(matcher);
+        } catch (ClassNotFoundException e) {
+            throw new JavaFXLibraryNonFatalException("Could not use \"" + query + "\" for " +
+                    "Node lookup: class was not found");
+        }
+    }
+}

src/main/java/javafxlibrary/utils/finder/FindPrefix.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017-2018   Eficode Oy
+ * Copyright 2018-       Robot Framework Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javafxlibrary.utils.finder;
+
+public enum FindPrefix { ID, CSS, CLASS, TEXT, XPATH, PSEUDO }

src/main/java/javafxlibrary/utils/finder/Finder.java

@@ -1,26 +1,33 @@
+/*
+ * Copyright 2017-2018   Eficode Oy
+ * Copyright 2018-       Robot Framework Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package javafxlibrary.utils.finder;
 
-import javafx.collections.ObservableSet;
-import javafx.css.PseudoClass;
 import javafx.scene.Node;
 import javafx.scene.Parent;
 import javafx.stage.Window;
-import javafxlibrary.exceptions.JavaFXLibraryNonFatalException;
-import javafxlibrary.matchers.InstanceOfMatcher;
 import javafxlibrary.utils.RobotLog;
 import javafxlibrary.utils.TestFxAdapter;
 import org.testfx.api.FxRobotInterface;
-import org.testfx.matcher.control.LabeledMatchers;
-import org.testfx.service.query.NodeQuery;
 
 import java.util.*;
 
-// import static javafxlibrary.utils.TestFxAdapter.robot;
-
 public class Finder {
 
-    public enum FindPrefix { ID, CSS, CLASS, TEXT, XPATH, PSEUDO }
-
     private String[] queries;
     private Set<Node> results = new LinkedHashSet<>();
     private FxRobotInterface robot;
@@ -141,98 +148,14 @@ private Set<Node> findAll(Parent root, int queryIndex) {
 
     private Node executeFind(Parent root, String query) {
         RobotLog.debug("Executing find with root: " + root + " and query: " + query);
-        FindPrefix prefix = getPrefix(query);
-
-        switch (prefix) {
-            case ID:
-                return root.lookup("#" + query.substring(3));
-            case CSS:
-                return root.lookup(query.substring(4));
-            case CLASS:
-                return classLookup(root, query).query();
-            case TEXT:
-                query = query.substring(6, query.length() - 1);
-                return robot.from(root).lookup(LabeledMatchers.hasText(query)).query();
-            case XPATH:
-                return new XPathFinder().find(query.substring(6), root);
-            case PSEUDO:
-                return pseudoLookup(root, query).query();
-        }
-        throw new IllegalArgumentException("FindPrefix value " + prefix + " of query " + query + " is not supported");
+        FindOperation findOperation = new FindOperation(root, new Query(query), false);
+        return (Node) findOperation.executeLookup();
     }
 
     // TODO: Add support for using indexes in queries (css=VBox[3]), xPath already implements this
     private Set<Node> executeFindAll(Parent root, String query) {
         RobotLog.debug("Executing find all with root: " + root + " and query: " + query);
-        FindPrefix prefix = getPrefix(query);
-
-        switch (prefix) {
-            case ID:
-                return root.lookupAll("#" + query.substring(3));
-            case CSS:
-                return root.lookupAll(query.substring(4));
-            case CLASS:
-                return classLookup(root, query).queryAll();
-            case TEXT:
-                query = query.substring(6, query.length() - 1);
-                return robot.from(root).lookup(LabeledMatchers.hasText(query)).queryAll();
-            case XPATH:
-                return new XPathFinder().findAll(query.substring(6), root);
-            case PSEUDO:
-                return pseudoLookup(root, query).queryAll();
-        }
-        throw new IllegalArgumentException("FindPrefix value " + prefix + " of query " + query + " is not supported");
-    }
-
-    protected FindPrefix getPrefix(String query) {
-
-        try {
-            String prefix = query.substring(0, query.indexOf('='));
-
-            switch (prefix) {
-                case "id":
-                    return FindPrefix.ID;
-                case "css":
-                    return FindPrefix.CSS;
-                case "class":
-                    return FindPrefix.CLASS;
-                case "text":
-                    return FindPrefix.TEXT;
-                case "xpath":
-                    return FindPrefix.XPATH;
-                case "pseudo":
-                    return FindPrefix.PSEUDO;
-                default:
-                    throw new IllegalArgumentException("Query \"" + query + "\" does not contain any supported prefix");
-            }
-        } catch (StringIndexOutOfBoundsException e) {
-            throw new IllegalArgumentException("Query \"" + query + "\" does not contain any supported prefix");
-        }
-    }
-
-    private NodeQuery pseudoLookup(Parent root, String query) {
-        String[] queries = query.substring(7).split(";");
-        return robot.from(root).lookup((Node n) -> {
-            int matching = 0;
-            ObservableSet<PseudoClass> pseudoStates = n.getPseudoClassStates();
-
-            for (PseudoClass c : pseudoStates)
-                for (String q : queries)
-                    if (c.getPseudoClassName().equals(q))
-                        matching++;
-
-            return n != root && (matching == queries.length);
-        });
-    }
-
-    private NodeQuery classLookup(Parent root, String query) {
-        try {
-            Class<?> clazz = Class.forName(query.substring(6));
-            InstanceOfMatcher matcher = new InstanceOfMatcher(clazz);
-            return robot.from(root).lookup(matcher);
-        } catch (ClassNotFoundException e) {
-            throw new JavaFXLibraryNonFatalException("Could not use \"" + query.substring(6) + "\" for " +
-                    "Node lookup: class was not found");
-        }
+        FindOperation findOperation = new FindOperation(root, new Query(query), true);
+        return (Set<Node>) findOperation.executeLookup();
     }
 }

src/main/java/javafxlibrary/utils/finder/Query.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2017-2018   Eficode Oy
+ * Copyright 2018-       Robot Framework Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javafxlibrary.utils.finder;
+
+public class Query {
+
+    private FindPrefix prefix;
+    private String query;
+
+    public Query(String query) {
+        this.prefix = QueryParser.getPrefix(query);
+        this.query = QueryParser.removePrefix(query, this.prefix);
+    }
+
+    public FindPrefix getPrefix() {
+        return this.prefix;
+    }
+
+    public String getQuery() {
+        return this.query;
+    }
+}

src/main/java/javafxlibrary/utils/finder/QueryParser.java

@@ -1,3 +1,20 @@
+/*
+ * Copyright 2017-2018   Eficode Oy
+ * Copyright 2018-       Robot Framework Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package javafxlibrary.utils.finder;
 
 import java.util.ArrayList;
@@ -61,4 +78,47 @@ protected static boolean startsWithPrefix(String query) {
                 return true;
         return false;
     }
+
+    protected static FindPrefix getPrefix(String query) {
+
+        try {
+            String prefix = query.substring(0, query.indexOf('='));
+
+            switch (prefix) {
+                case "id":
+                    return FindPrefix.ID;
+                case "css":
+                    return FindPrefix.CSS;
+                case "class":
+                    return FindPrefix.CLASS;
+                case "text":
+                    return FindPrefix.TEXT;
+                case "xpath":
+                    return FindPrefix.XPATH;
+                case "pseudo":
+                    return FindPrefix.PSEUDO;
+                default:
+                    throw new IllegalArgumentException("Query \"" + query + "\" does not contain any supported prefix");
+            }
+        } catch (StringIndexOutOfBoundsException e) {
+            throw new IllegalArgumentException("Query \"" + query + "\" does not contain any supported prefix");
+        }
+    }
+
+    protected static String removePrefix(String query, FindPrefix prefix) {
+        switch (prefix) {
+            case ID:
+                return "#" + query.substring(3);
+            case CSS:
+                return query.substring(4);
+            case CLASS:
+            case XPATH:
+                return query.substring(6);
+            case TEXT:
+                return query.substring(6, query.length() - 1);
+            case PSEUDO:
+                return query.substring(7);
+        }
+        throw new IllegalArgumentException("FindPrefix value " + prefix + " of query " + query + " is not supported");
+    }
 }

src/test/java/javafxlibrary/utils/finder/FinderTest.java

@@ -81,28 +81,4 @@ public void find_CustomRoot_TestFXSelector() {
         Node result = finder.find(".button", group);
         Assert.assertEquals(button, result);
     }
-
-    @Test
-    public void getPrefix_AcceptedValues() {
-        Assert.assertEquals(Finder.FindPrefix.ID, finder.getPrefix("id=nodeId"));
-        Assert.assertEquals(Finder.FindPrefix.CLASS, finder.getPrefix("class=java.lang.String"));
-        Assert.assertEquals(Finder.FindPrefix.CSS, finder.getPrefix("css=.vBox .hBox"));
-        Assert.assertEquals(Finder.FindPrefix.XPATH, finder.getPrefix("xpath=//Rectangle[@id=\"lime\"]"));
-        Assert.assertEquals(Finder.FindPrefix.PSEUDO, finder.getPrefix("pseudo=hover"));
-        Assert.assertEquals(Finder.FindPrefix.TEXT, finder.getPrefix("text=\"Text\""));
-    }
-
-    @Test
-    public void getPrefix_NoEquals() {
-        thrown.expect(IllegalArgumentException.class);
-        thrown.expectMessage("Query \"noEquals\" does not contain any supported prefix");
-        finder.getPrefix("noEquals");
-    }
-
-    @Test
-    public void getPrefix_InvalidValue() {
-        thrown.expect(IllegalArgumentException.class);
-        thrown.expectMessage("Query \"notaprefix=someValue\" does not contain any supported prefix");
-        finder.getPrefix("notaprefix=someValue");
-    }
 }