#1171: add real time xpath validation (#1196)

Author: davsclaus

build.gradle

@@ -126,6 +126,8 @@ dependencies {
     testImplementation 'org.hamcrest:hamcrest-all:1.3'
     testImplementation 'org.opentest4j:opentest4j:1.3.0'
     testImplementation "org.apache.camel:camel-jsonpath:${camelVersion}"
+    testImplementation "org.apache.camel:camel-jq:${camelVersion}"
+    testImplementation "org.apache.camel:camel-xpath:${camelVersion}"
     testImplementation 'junit:junit:4.13.2'
 }
 

src/main/java/com/github/cameltooling/idea/annotator/CamelLanguageAnnotator.java

@@ -41,7 +41,7 @@ public class CamelLanguageAnnotator extends AbstractCamelAnnotator {
 
     @Override
     boolean isEnabled() {
-        return CamelPreferenceService.getService().isRealTimeJSonPathValidation() || CamelPreferenceService.getService().isRealTimeJQValidation();
+        return CamelPreferenceService.getService().isRealTimeJSonPathValidation() || CamelPreferenceService.getService().isRealTimeJQValidation() || CamelPreferenceService.getService().isRealTimeXPathValidation();
     }
 
     /**
@@ -53,19 +53,30 @@ void validateText(@NotNull PsiElement element, @NotNull AnnotationHolder holder,
 
         boolean json = CamelPreferenceService.getService().isRealTimeJSonPathValidation() && camelIdeaUtils.isCamelExpression(element, "jsonpath");
         boolean jq = CamelPreferenceService.getService().isRealTimeJQValidation() && camelIdeaUtils.isCamelExpression(element, "jq");
-        if (json || jq) {
+        boolean xpath = CamelPreferenceService.getService().isRealTimeXPathValidation() && camelIdeaUtils.isCamelExpression(element, "xpath");
+        if (json || jq || xpath) {
             Project project = element.getProject();
             CamelCatalog catalogService = project.getService(CamelCatalogService.class).get();
             CamelService camelService = project.getService(CamelService.class);
 
             // must have the supporting library
-            String lib = json ? "camel-jsonpath" : "camel-jq";
+            String lib = null;
+            String lan = null;
+            if (json) {
+                lib = "camel-jsonpath";
+                lan = "jsonpath";
+            } else if (jq) {
+                lib = "camel-jq";
+                lan = "jq";
+            } else if (xpath) {
+                lib = "camel-xpath";
+                lan = "xpath";
+            }
             if (!camelService.containsLibrary(lib, false)) {
                 camelService.showMissingLanguageJarNotification(lib);
                 return;
             }
 
-            String lan = json ? "jsonpath" : "jq";
             try {
                 // need to use the classloader that can load classes from the project
                 ClassLoader loader = camelService.getProjectClassloader();

src/main/java/com/github/cameltooling/idea/preference/annotator/CamelAnnotatorPage.java

@@ -38,6 +38,7 @@ public class CamelAnnotatorPage implements SearchableConfigurable, Configurable.
     private JBCheckBox realTimeSimpleValidationCatalogCheckBox;
     private JBCheckBox realTimeJSonPathValidationCatalogCheckBox;
     private JBCheckBox realTimeJQValidationCatalogCheckBox;
+    private JBCheckBox realTimeXPathValidationCatalogCheckBox;
     private JBCheckBox realTimeIdReferenceTypeValidationCheckBox;
     private JBCheckBox realTimeBeanMethodValidationCheckBox;
     private JPanel result;
@@ -54,6 +55,7 @@ public JComponent createComponent() {
         realTimeSimpleValidationCatalogCheckBox = new JBCheckBox("Real time validation of Camel simple language in editor");
         realTimeJSonPathValidationCatalogCheckBox = new JBCheckBox("Real time validation of Camel JSonPath language in editor");
         realTimeJQValidationCatalogCheckBox = new JBCheckBox("Real time validation of Camel JQ language in editor");
+        realTimeXPathValidationCatalogCheckBox = new JBCheckBox("Real time validation of Camel XPath language in editor");
         realTimeIdReferenceTypeValidationCheckBox = new JBCheckBox("Real time type validation when referencing beans");
         realTimeBeanMethodValidationCheckBox = new JBCheckBox("Real time validation of call bean method in editor");
 
@@ -66,6 +68,7 @@ public JComponent createComponent() {
         jPanel.add(realTimeSimpleValidationCatalogCheckBox, "span 2");
         jPanel.add(realTimeJSonPathValidationCatalogCheckBox, "span 2");
         jPanel.add(realTimeJQValidationCatalogCheckBox, "span 2");
+        jPanel.add(realTimeXPathValidationCatalogCheckBox, "span 2");
         jPanel.add(realTimeIdReferenceTypeValidationCheckBox, "span 2");
         jPanel.add(realTimeBeanMethodValidationCheckBox, "span 2");
 
@@ -83,6 +86,7 @@ public void apply() {
         camelPreferenceService.setRealTimeSimpleValidation(realTimeSimpleValidationCatalogCheckBox.isSelected());
         camelPreferenceService.setRealTimeJSonPathValidation(realTimeJSonPathValidationCatalogCheckBox.isSelected());
         camelPreferenceService.setRealTimeJQValidation(realTimeJQValidationCatalogCheckBox.isSelected());
+        camelPreferenceService.setRealTimeXPathValidation(realTimeXPathValidationCatalogCheckBox.isSelected());
         camelPreferenceService.setRealTimeIdReferenceTypeValidation(realTimeIdReferenceTypeValidationCheckBox.isSelected());
         camelPreferenceService.setRealTimeBeanMethodValidationCheckBox(realTimeBeanMethodValidationCheckBox.isSelected());
     }
@@ -96,6 +100,7 @@ public boolean isModified() {
             || camelPreferenceService.isRealTimeSimpleValidation() != realTimeSimpleValidationCatalogCheckBox.isSelected()
             || camelPreferenceService.isRealTimeJSonPathValidation() != realTimeJSonPathValidationCatalogCheckBox.isSelected()
             || camelPreferenceService.isRealTimeJQValidation() != realTimeJQValidationCatalogCheckBox.isSelected()
+            || camelPreferenceService.isRealTimeXPathValidation() != realTimeXPathValidationCatalogCheckBox.isSelected()
             || camelPreferenceService.isRealTimeIdReferenceTypeValidation() != realTimeIdReferenceTypeValidationCheckBox.isSelected()
             || camelPreferenceService.isRealTimeBeanMethodValidationCheckBox() != realTimeBeanMethodValidationCheckBox.isSelected();
         return b1;
@@ -109,6 +114,7 @@ public void reset() {
         realTimeSimpleValidationCatalogCheckBox.setSelected(camelPreferenceService.isRealTimeSimpleValidation());
         realTimeJSonPathValidationCatalogCheckBox.setSelected(camelPreferenceService.isRealTimeJSonPathValidation());
         realTimeJQValidationCatalogCheckBox.setSelected(camelPreferenceService.isRealTimeJQValidation());
+        realTimeXPathValidationCatalogCheckBox.setSelected(camelPreferenceService.isRealTimeXPathValidation());
         realTimeIdReferenceTypeValidationCheckBox.setSelected(camelPreferenceService.isRealTimeIdReferenceTypeValidation());
         realTimeBeanMethodValidationCheckBox.setSelected(camelPreferenceService.isRealTimeBeanMethodValidationCheckBox());
     }
@@ -120,6 +126,7 @@ public void disposeUIResources() {
         realTimeSimpleValidationCatalogCheckBox = null;
         realTimeJSonPathValidationCatalogCheckBox = null;
         realTimeJQValidationCatalogCheckBox = null;
+        realTimeXPathValidationCatalogCheckBox = null;
         realTimeIdReferenceTypeValidationCheckBox = null;
         realTimeBeanMethodValidationCheckBox = null;
 
@@ -161,6 +168,10 @@ public JBCheckBox getRealTimeJQValidationCatalogCheckBox() {
         return realTimeJQValidationCatalogCheckBox;
     }
 
+    public JBCheckBox getRealTimeXPathValidationCatalogCheckBox() {
+        return realTimeXPathValidationCatalogCheckBox;
+    }
+
     JBCheckBox getRealTimeIdReferenceTypeValidationCheckBox() {
         return realTimeIdReferenceTypeValidationCheckBox;
     }

src/main/java/com/github/cameltooling/idea/service/CamelPreferenceService.java

@@ -67,6 +67,7 @@ public class CamelPreferenceService implements PersistentStateComponent<CamelPre
     private boolean realTimeSimpleValidation = true;
     private boolean realTimeJSonPathValidation = true;
     private boolean realTimeJQValidation = true;
+    private boolean realTimeXPathValidation = true;
     private boolean realTimeIdReferenceTypeValidation = true;
     private boolean realTimeBeanMethodValidationCheckBox = true;
     private boolean highlightCustomOptions = true;
@@ -133,6 +134,14 @@ public void setRealTimeJQValidation(boolean realTimeJQValidation) {
         this.realTimeJQValidation = realTimeJQValidation;
     }
 
+    public boolean isRealTimeXPathValidation() {
+        return realTimeXPathValidation;
+    }
+
+    public void setRealTimeXPathValidation(boolean realTimeXPathValidation) {
+        this.realTimeXPathValidation = realTimeXPathValidation;
+    }
+
     public boolean isRealTimeIdReferenceTypeValidation() {
         return realTimeIdReferenceTypeValidation;
     }

src/main/java/com/github/cameltooling/idea/service/CamelService.java

@@ -247,7 +247,7 @@ public synchronized boolean containsLibrary(String lib, boolean quickCheck) {
         boolean answer = processedLibraries.contains(lib);
         if (!answer && !quickCheck) {
             for (ArtifactCoordinates coordinates : projectLibraries.values()) {
-                if (coordinates.getArtifactId().equals(lib)) {
+                if (coordinates.getArtifactId().contains(lib)) {
                     answer = true;
                     break;
                 }

src/main/java/com/github/cameltooling/idea/service/extension/camel/JavaCamelIdeaUtils.java

@@ -248,6 +248,8 @@ public boolean isCamelExpression(PsiElement element, String language) {
             methods = new String[]{"jsonpath"};
         } else if ("jq".equals(language)) {
             methods = new String[]{"jq"};
+        } else if ("xpath".equals(language)) {
+            methods = new String[]{"xpath"};
         }
         if (methods != null) {
             return IdeaUtils.getService().isFromJavaMethodCall(element, true, methods);

src/main/resources/META-INF/plugin.xml

@@ -12,6 +12,7 @@
       v.1.4.5
       <ul>
         <li>Only IDEA 2025 onwards is supported</li>
+        <li>Added real-time validation of XPath expressions<li>
       </ul>
     ]]>
   </change-notes>

src/test/java/com/github/cameltooling/idea/annotator/CamelXPathAnnotatorTestIT.java

@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 com.github.cameltooling.idea.annotator;
+
+import com.github.cameltooling.idea.CamelLightCodeInsightFixtureTestCaseIT;
+import com.github.cameltooling.idea.service.CamelCatalogService;
+import com.github.cameltooling.idea.service.CamelService;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.roots.ModuleRootModificationUtil;
+import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.libraries.LibraryTable;
+import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.jboss.shrinkwrap.resolver.api.maven.Maven;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * Test Camel XPath validation and the expected value is highlighted
+ *
+ * @see CamelSimpleAnnotatorTestIT
+ */
+public class CamelXPathAnnotatorTestIT extends CamelLightCodeInsightFixtureTestCaseIT {
+
+    public static final String CAMEL_XPATH_MAVEN_ARTIFACT = "org.apache.camel:camel-xpath:4.14.1";
+
+    public CamelXPathAnnotatorTestIT() {
+        setIgnoreCamelCoreLib(true);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        File[] mavenArtifacts = getMavenArtifacts(CAMEL_XPATH_MAVEN_ARTIFACT);
+        for (File file : mavenArtifacts) {
+            final VirtualFile virtualFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file);
+            final LibraryTable projectLibraryTable = LibraryTablesRegistrar.getInstance().getLibraryTable(getModule().getProject());
+            ApplicationManager.getApplication().runWriteAction(() -> {
+                String name = file.getName();
+                Library library = projectLibraryTable.createLibrary("maven: " + name);
+                final Library.ModifiableModel libraryModifiableModel = library.getModifiableModel();
+                libraryModifiableModel.addRoot(virtualFile, OrderRootType.CLASSES);
+                libraryModifiableModel.commit();
+                ModuleRootModificationUtil.addDependency(getModule(), library);
+            });
+        }
+
+        disposeOnTearDown(getModule().getProject().getService(CamelCatalogService.class));
+        disposeOnTearDown(getModule().getProject().getService(CamelService.class));
+        getModule().getProject().getService(CamelService.class).setCamelPresent(true);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        try {
+            super.tearDown();
+        } catch (Throwable e) {
+            // ignore
+        }
+    }
+
+    protected static File[] getMavenArtifacts(String... mavenAritfiact) throws IOException {
+        File[] libs = Maven.resolver().resolve(mavenAritfiact).withTransitivity().asFile();
+        return libs;
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return "src/test/resources/testData/annotator";
+    }
+
+    public void testAnnotatorXPathValidation() {
+        myFixture.configureByText("AnnotatorTestData.java", getJavaWithXPath());
+        myFixture.checkHighlighting(false, false, true, true);
+    }
+
+    private String getJavaWithXPath() {
+        return """
+                import org.apache.camel.builder.RouteBuilder;
+                public class MyRouteBuilder extends RouteBuilder {
+                        public void configure() throws Exception {
+                            from("direct:start")
+                                .filter(xpath("\\/path/to"))
+                                    .to("mock:match")
+                                .end();
+                        }
+                    }""";
+    }
+
+}

src/test/java/com/github/cameltooling/idea/preference/annotator/CamelAnnotatorPageTest.java

@@ -161,6 +161,17 @@ public void testShouldChangeStateOfRealTimeJQValidationCatalogCheckBox() {
         assertFalse(preferenceService.isRealTimeJQValidation());
     }
 
+    public void testShouldChangeStateOfRealTimeXPathValidationCatalogCheckBox() {
+        JBCheckBox checkBox = annotatorPage.getRealTimeXPathValidationCatalogCheckBox();
+        assertTrue(checkBox.isSelected());
+        final CamelPreferenceService preferenceService = CamelPreferenceService.getService();
+        assertTrue(preferenceService.isRealTimeXPathValidation());
+        checkBox.setSelected(false);
+        annotatorPage.apply();
+        assertFalse(checkBox.isSelected());
+        assertFalse(preferenceService.isRealTimeXPathValidation());
+    }
+
     public void testShouldChangeStateOfRealTimeBeanMethodValidationCheckBox() {
         JBCheckBox checkBox = annotatorPage.getRealTimeBeanMethodValidationCheckBox();
         assertTrue(checkBox.isSelected());