result = this.myDescriptorsMap.get(kind);
125 | if (result == null) {
126 | result = CachedValuesManager.getManager(this.myProject)
127 | .createCachedValue(() ->
128 | CachedValueProvider.Result.create(ZkDomElementDescriptorHolder.this.doCreateDescriptor(kind),
129 | PsiModificationTracker.MODIFICATION_COUNT), false);
130 | this.myDescriptorsMap.put(kind, result);
131 | }
132 |
133 | return result.getValue();
134 | }
135 |
136 | @Nullable
137 | private XmlNSDescriptorImpl doCreateDescriptor(ZkDomElementDescriptorHolder.FileKind kind) {
138 | String schemaUrl = kind.getSchemaUrl();
139 | String location = ExternalResourceManager.getInstance().getResourceLocation(schemaUrl, "");
140 | if (schemaUrl.equals(location)) {
141 | return null;
142 | } else {
143 | VirtualFile schema;
144 | try {
145 | schema = VfsUtil.findFileByURL(new URL(location));
146 | } catch (MalformedURLException var7) {
147 | return null;
148 | }
149 | if (schema == null) {
150 | return null;
151 | } else {
152 | PsiFile psiFile = PsiManager.getInstance(this.myProject).findFile(schema);
153 | if (!(psiFile instanceof XmlFile)) {
154 | return null;
155 | } else {
156 | XmlNSDescriptorImpl result = new XmlNSDescriptorImpl();
157 | result.init(psiFile);
158 | return result;
159 | }
160 | }
161 | }
162 | }
163 |
164 | @Nullable
165 | private static ZkDomElementDescriptorHolder.FileKind getFileKind(PsiFile file) {
166 | if (ZulDomUtil.isLangAddonFile(file)) {
167 | return FileKind.LANG_ADDON_FILE;
168 | } else if (ZulDomUtil.isZkConfigFile(file)) {
169 | return FileKind.ZK_CONFIG_FILE;
170 | } else if (ZulDomUtil.isZKFile(file)) {
171 | return FileKind.ZUL_FILE;
172 | } else {
173 | return null;
174 | }
175 | }
176 |
177 | private enum FileKind {
178 | ZUL_FILE {
179 | public String getSchemaUrl() {
180 | return ZulSchemaProvider.ZUL_PROJECT_SCHEMA_URL;
181 | }
182 | },
183 | ZK_CONFIG_FILE {
184 | public String getSchemaUrl() {
185 | return ZkConfigSchemaProvider.ZK_CONFIG_PROJECT_SCHEMA_URL;
186 | }
187 | },
188 | LANG_ADDON_FILE {
189 | public String getSchemaUrl() {
190 | return LangAddonSchemaProvider.LANG_ADDON_SCHEMA_URL;
191 | }
192 | };
193 |
194 | FileKind() {
195 | }
196 |
197 | public abstract String getSchemaUrl();
198 | }
199 | }
--------------------------------------------------------------------------------
/src/main/java/org/zkoss/zkidea/editorActions/WebBrowserUrlProvider.java:
--------------------------------------------------------------------------------
1 | /* WebBrowserUrlProvider.java
2 |
3 | Purpose:
4 |
5 | Description:
6 |
7 | History:
8 | 4:56 PM 7/31/15, Created by jumperchen
9 |
10 | Copyright (C) 2015 Potix Corporation. All Rights Reserved.
11 | */
12 | package org.zkoss.zkidea.editorActions;
13 |
14 | import com.intellij.execution.ExecutionManager;
15 | import com.intellij.execution.process.ProcessHandler;
16 | import com.intellij.ide.browsers.OpenInBrowserRequest;
17 | import com.intellij.openapi.fileTypes.FileType;
18 | import com.intellij.openapi.project.Project;
19 | import com.intellij.openapi.vfs.VirtualFile;
20 | import com.intellij.util.Url;
21 | import com.intellij.util.Urls;
22 | import org.jdom.Content;
23 | import org.jdom.Element;
24 | import org.jetbrains.annotations.NotNull;
25 | import org.jetbrains.idea.maven.model.MavenPlugin;
26 | import org.jetbrains.idea.maven.project.MavenProject;
27 | import org.jetbrains.idea.maven.project.MavenProjectsManager;
28 | import org.zkoss.zkidea.dom.ZulDomUtil;
29 |
30 | /**
31 | * Provides a URL for ZUL files for the "Open in Browser" feature.
32 | *
33 | * This class is responsible for generating the correct URL when a user right-clicks on a ZUL file
34 | * and selects "Open in Browser." It intelligently constructs the URL by analyzing the Maven `pom.xml`
35 | * to determine the web application's context path and server port.
36 | *
37 | * Specifically, it parses the configuration of various Jetty Maven plugins to find the correct port and context path.
38 | * It also works in conjunction with {@link MavenRunnerPatcher} to get the port from a running Jetty instance,
39 | * ensuring that even dynamically assigned ports are handled correctly. This provides a seamless development
40 | * experience for ZK developers using Maven.
41 | *
42 | * @author jumperchen
43 | */
44 | public class WebBrowserUrlProvider
45 | extends com.intellij.ide.browsers.WebBrowserUrlProvider {
46 |
47 | private static String MAVEN_STANDARD_WEBAPP_PATH = "src/main/webapp/";
48 | protected Url getUrl(@NotNull OpenInBrowserRequest request, @NotNull VirtualFile file) throws WebBrowserUrlProvider.BrowserException {
49 | Project project = request.getProject();
50 | MavenProjectsManager instance = MavenProjectsManager
51 | .getInstance(project);
52 | if (instance.isMavenizedProject()) {
53 | MavenProject project1 = instance.findProject(file);
54 |
55 | String port = "8080";
56 |
57 | FileType fileType = file.getFileType();
58 | if (ZulDomUtil.isZKFile(file.getExtension())) {
59 | ProcessHandler[] runningProcesses = ExecutionManager
60 | .getInstance(request.getProject())
61 | .getRunningProcesses();
62 | // PsiFile file1 = PsiManager.getInstance(project).findFile(file);
63 | MavenProject maven = instance
64 | .findContainingProject(file);
65 | if (maven != null) {
66 | String contextPath = maven.getMavenId().getArtifactId();
67 | String filePath = file.getPath();
68 | if (filePath.contains(MAVEN_STANDARD_WEBAPP_PATH)) {
69 | filePath = trim(filePath, MAVEN_STANDARD_WEBAPP_PATH);
70 | } else {
71 | MavenPlugin plugin = maven
72 | .findPlugin("org.mortbay.jetty",
73 | "jetty-maven-plugin");
74 | if (plugin != null) {
75 | for (Content content : plugin.getConfigurationElement().getContent()) {
76 | if (content instanceof Element) {
77 | Element element = (Element) content;
78 | if ("webAppSourceDirectory".equals(element.getName())) {
79 | String value = element.getValue();
80 | filePath = trim(filePath, value);
81 | } else if ("webAppConfig".equals(element.getName())) {
82 | for (Content c : element.getContent()) {
83 | if (c instanceof Element) {
84 | Element el = (Element) c;
85 |
86 | if ("contextPath".equals(el.getName())) {
87 | contextPath = el.getValue();
88 | break;
89 | }
90 | }
91 | }
92 | } else if ("webApp".equals(element.getName())) {
93 | for (Content c : element.getContent()) {
94 | if (c instanceof Element) {
95 | Element el = (Element) c;
96 |
97 | if ("contextPath".equals(el.getName())) {
98 | contextPath = el.getValue();
99 | break;
100 | }
101 | }
102 | }
103 | } else if ("connectors".equals(element.getName())) {
104 | for (Content c : element.getContent()) {
105 | if (c instanceof Element) {
106 | Element el = (Element) c;
107 |
108 | if ("connectors".equals(el.getName())) {
109 | for (Content c0 : element.getContent()) {
110 | if (c instanceof Element) {
111 | Element el0 = (Element) c0;
112 |
113 | if ("port".equals(el0.getName())) {
114 | port = el0.getValue();
115 | break;
116 | }
117 | }
118 | }
119 | break;
120 | }
121 | }
122 | }
123 | }
124 | }
125 | }
126 | } else {
127 | plugin = maven
128 | .findPlugin("org.eclipse.jetty",
129 | "jetty-maven-plugin");
130 | if (plugin != null) {
131 | for (Content content : plugin
132 | .getConfigurationElement().getContent()) {
133 | if (content instanceof Element) {
134 | Element element = (Element) content;
135 | if ("webAppSourceDirectory"
136 | .equals(element.getName())) {
137 | String value = element.getValue();
138 | filePath = trim(filePath, value);
139 | } else if ("webApp".equals(element.getName())) {
140 | for (Content c : element.getContent()) {
141 | if (c instanceof Element) {
142 | Element el = (Element) c;
143 |
144 | if ("contextPath".equals(el.getName())) {
145 | contextPath = el.getValue();
146 | break;
147 | }
148 | }
149 | }
150 | } else if ("httpConnector".equals(element.getName())) {
151 | for (Content c : element.getContent()) {
152 | if (c instanceof Element) {
153 | Element el = (Element) c;
154 |
155 | if ("port".equals(el.getName())) {
156 | port = el.getValue();
157 | break;
158 | }
159 | }
160 | }
161 | }
162 | }
163 | }
164 | } else {
165 | plugin = maven
166 | .findPlugin("org.mortbay.jetty",
167 | "maven-jetty-plugin");
168 | if (plugin != null) {
169 | for (Content content : plugin
170 | .getConfigurationElement().getContent()) {
171 | if (content instanceof Element) {
172 | Element element = (Element) content;
173 | if ("webAppSourceDirectory"
174 | .equals(element.getName())) {
175 | String value = element.getValue();
176 | filePath = trim(filePath, value);
177 | } else if ("webAppConfig".equals(element.getName())) {
178 | for (Content c : element.getContent()) {
179 | if (c instanceof Element) {
180 | Element el = (Element) c;
181 |
182 | if ("contextPath".equals(el.getName())) {
183 | contextPath = el.getValue();
184 | break;
185 | }
186 | }
187 | }
188 | }
189 | }
190 | }
191 | }
192 | }
193 | }
194 | }
195 | if (contextPath.startsWith("/"))
196 | contextPath = contextPath.substring(1);
197 | if (filePath.startsWith("/"))
198 | filePath = filePath.substring(1);
199 | if (System.getProperty("org.zkoss.zkidea.jetty.port." + maven.getFinalName()) != null)
200 | port = System.getProperty("org.zkoss.zkidea.jetty.port." + maven.getFinalName());
201 | return Urls.newHttpUrl("localhost:" + port + "/", contextPath + "/" + filePath);
202 | }
203 | }
204 | }
205 | return null;
206 | }
207 |
208 | private String trim(String filePath, String directory) {
209 | if (filePath.contains(directory)) {
210 | return filePath
211 | .substring(filePath.indexOf(directory) + (directory.length()));
212 | }
213 | return filePath;
214 | }
215 | }
216 |
--------------------------------------------------------------------------------
/src/main/java/org/zkoss/zkidea/project/ZKProjectsManager.java:
--------------------------------------------------------------------------------
1 | /* ZKProjectsManager.java
2 |
3 | Purpose:
4 |
5 | Description:
6 |
7 | History:
8 | 12:14 PM 7/24/15, Created by jumperchen
9 |
10 | Copyright (C) 2015 Potix Corporation. All Rights Reserved.
11 | */
12 | package org.zkoss.zkidea.project;
13 |
14 | import com.intellij.javaee.ExternalResourceManager;
15 | import com.intellij.openapi.application.ApplicationManager;
16 | import com.intellij.openapi.diagnostic.Logger;
17 | import com.intellij.openapi.project.*;
18 | import com.intellij.openapi.startup.StartupActivity;
19 | import com.intellij.openapi.util.io.FileUtil;
20 | import org.jetbrains.annotations.NotNull;
21 | import org.jetbrains.idea.maven.utils.MavenUtil;
22 | import org.w3c.dom.*;
23 | import org.zkoss.zkidea.lang.ZulSchemaProvider;
24 | import org.zkoss.zkidea.maven.ZKMavenArchetypesProvider;
25 |
26 | import javax.xml.parsers.*;
27 | import java.io.*;
28 | import java.net.*;
29 | import java.util.Date;
30 | import java.util.concurrent.atomic.AtomicBoolean;
31 |
32 | /**
33 | * This class implements StartupActivity.DumbAware to perform initialization tasks
34 | * when a project is opened in the IDE.
35 | *
36 | * Key responsibilities:
37 | * - Initializes ZK-related resources for new projects
38 | * - Updates and manages ZUL schema files for XML validation
39 | * - Updates ZK Maven archetypes with the latest one from the remote repository
40 | * - Handles resource synchronization with remote ZK repositories
41 | *
42 | * The manager ensures that:
43 | * 1. The latest ZUL schema (zul.xsd) is downloaded and maintained
44 | * 2. Maven archetypes are kept up to date
45 | * 3. Resources are properly registered with IntelliJ's ExternalResourceManager
46 | *
47 | * @author jumperchen
48 | */
49 | public class ZKProjectsManager implements StartupActivity.DumbAware {
50 |
51 | private static final Logger LOG = Logger.getInstance(ZKProjectsManager.class);
52 |
53 | private final AtomicBoolean isInitialized = new AtomicBoolean();
54 |
55 | public void runActivity(@NotNull Project project) {
56 | // fix for issue #20
57 | if (!project.isDefault()) {
58 | ZKProjectsManager.this.doInit(project);
59 | }
60 | }
61 |
62 | private void doInit(@NotNull Project project) {
63 | synchronized (this.isInitialized) {
64 | if (!this.isInitialized.getAndSet(true)) {
65 | // fetch the lastes zul.xsd file
66 | MavenUtil.runWhenInitialized(project, new DumbAwareRunnable() {
67 | public void run() {
68 | // TODO: support with project's ZK version
69 | updateZulSchema();
70 | updateMavenArchetype();
71 | }
72 | });
73 | }
74 | }
75 | }
76 |
77 | private void copyResourceToFile(String path, File toFile) {
78 | InputStream in = getClass().getClassLoader().getResourceAsStream(path);
79 | FileOutputStream out = null;
80 | try {
81 | if (!toFile.exists()) {
82 | // Bug fixed #7
83 | toFile.getParentFile().mkdirs();
84 | toFile.createNewFile();
85 | }
86 |
87 | out = new FileOutputStream(toFile);
88 | if (in != null) {
89 | FileUtil.copy(in, out);
90 | }
91 | } catch (Exception e) {
92 | LOG.error(e);
93 | } finally {
94 | if (in != null) {
95 | try {
96 | in.close();
97 | } catch (IOException e) {
98 | }
99 | }
100 | if (out != null) {
101 | try {
102 | out.close();
103 | } catch (IOException e) {
104 | }
105 | }
106 | }
107 | }
108 |
109 | private static boolean equals(Object a, Object b) {
110 | return (a == b) || (a != null && a.equals(b));
111 | }
112 |
113 | private void updateZulSchema() {
114 | try {
115 | final String pluginResourcePath = "file:" + ZKPathManager.getPluginResourcePath(ZulSchemaProvider.ZUL_PROJECT_SCHEMA_PATH);
116 | LOG.debug("PluginResourcePath: " + pluginResourcePath);
117 |
118 | ExternalResourceManager instance = ExternalResourceManager.getInstance();
119 | if (!equals(pluginResourcePath, instance.getResourceLocation(ZulSchemaProvider.ZUL_PROJECT_SCHEMA_PATH, ""))) {
120 | ApplicationManager.getApplication().invokeLater(new Runnable() {
121 | @Override
122 | public void run() {
123 | ApplicationManager.getApplication().runWriteAction(new Runnable() {
124 | @Override
125 | public void run() {
126 | ExternalResourceManager.getInstance().addResource(ZulSchemaProvider.ZUL_PROJECT_SCHEMA_URL, pluginResourcePath);
127 | }
128 | });
129 | }
130 | });
131 | }
132 |
133 | File fileSrc = new File(ZKPathManager.getPluginResourcePath(ZulSchemaProvider.ZUL_PROJECT_SCHEMA_PATH));
134 | if (!fileSrc.isFile() || fileSrc.length() < 20) {
135 | // copy from jar file.
136 | copyResourceToFile(ZulSchemaProvider.ZUL_PROJECT_SCHEMA_PATH, fileSrc);
137 | }
138 | if (fileSrc.lastModified() > new Date().getTime()) {
139 | return;// won't support this case
140 | }
141 |
142 | LOG.info("Downloading latest zul file: " + ZulSchemaProvider.ZUL_PROJECT_SCHEMA_URL);
143 |
144 | File fileTmp = new File(fileSrc.getAbsolutePath() + ".tmp");
145 | byte[] download = download(
146 | new URL(ZulSchemaProvider.ZUL_PROJECT_SCHEMA_URL));
147 | if (download != null && download.length == 0)
148 | return; // try next time.
149 | FileUtil.writeToFile(fileTmp, download);
150 | // HttpRequests.request(ZulSchemaProvider.ZUL_PROJECT_SCHEMA_URL).saveToFile(fileTmp, ProgressManager.getGlobalProgressIndicator());
151 | double origin = getSchemaVersion(fileSrc);
152 | double newone = getSchemaVersion(fileTmp);
153 | if (newone > origin) {
154 | FileUtil.copy(fileTmp, fileSrc);
155 | fileTmp.deleteOnExit();
156 | }
157 | fileSrc.setLastModified(new Date().getTime() + 7 * 24 * 60 * 60 * 1000);
158 | } catch (IOException e) {
159 | }
160 | }
161 | private byte[] download(URL url) throws IOException {
162 | URLConnection uc = url.openConnection();
163 | int len = uc.getContentLength();
164 | if (len < 0) return new byte[0];
165 | InputStream is = new BufferedInputStream(uc.getInputStream());
166 | try {
167 | byte[] data = new byte[len];
168 | int offset = 0;
169 | while (offset < len) {
170 | int read = is.read(data, offset, data.length - offset);
171 | if (read < 0) {
172 | break;
173 | }
174 | offset += read;
175 | }
176 | if (offset < len) {
177 | throw new IOException(
178 | String.format("Read %d bytes; expected %d", offset, len));
179 | }
180 | return data;
181 | } finally {
182 | is.close();
183 | }
184 | }
185 | private void updateMavenArchetype() {
186 | try {
187 | File fileSrc = new File(ZKPathManager.getPluginResourcePath(ZKMavenArchetypesProvider.MAVEN_ARCHETYPE_PATH));
188 | if (!fileSrc.isFile() || fileSrc.length() < 20) {
189 | // copy from jar file.
190 | copyResourceToFile(ZKMavenArchetypesProvider.MAVEN_ARCHETYPE_PATH, fileSrc);
191 | }
192 |
193 | if (fileSrc.lastModified() > new Date().getTime()) {
194 | return;// won't support this case
195 | }
196 | LOG.info("Downloading latest maven archetype file: " + ZKMavenArchetypesProvider.MAVEN_ARCHETYPE_PATH);
197 |
198 | File fileTmp = new File(fileSrc.getAbsolutePath() + ".tmp");
199 |
200 | byte[] download = download(new URL(ZKMavenArchetypesProvider.MAVEN_ARCHETYPE_URL));
201 | if (download != null && download.length == 0)
202 | return; // try next time.
203 | FileUtil.writeToFile(fileTmp, download);
204 | // HttpRequests.request(ZKMavenArchetypesProvider.MAVEN_ARCHETYPE_URL).saveToFile(fileTmp, ProgressManager.getGlobalProgressIndicator());
205 | // to compare with length is not correct
206 | // if (fileTmp.length() > fileSrc.length()) {
207 | FileUtil.copy(fileTmp, fileSrc);
208 | fileTmp.deleteOnExit();
209 | // }
210 | fileSrc.setLastModified(new Date().getTime() + 7 * 24 * 60 * 60 * 1000);
211 | } catch (IOException e) {
212 | LOG.debug(e);
213 | }
214 | }
215 |
216 | private double getSchemaVersion(File file) {
217 | try {
218 | DocumentBuilderFactory instance = DocumentBuilderFactory.newInstance();
219 | //Using factory get an instance of document builder
220 | DocumentBuilder db = instance.newDocumentBuilder();
221 |
222 | //parse using builder to get DOM representation of the XML file
223 | Document parse = db.parse(file);
224 | NodeList elementsByTagName = parse.getElementsByTagName("xs:schema");
225 | if (elementsByTagName.getLength() > 0) {
226 | NamedNodeMap attributes = elementsByTagName.item(0).getAttributes();
227 | Node version = attributes.getNamedItem("version");
228 | if (version != null) {
229 | String nodeValue = version.getNodeValue().replace(".", "");
230 | return Double.parseDouble(nodeValue);
231 | }
232 | }
233 | }catch(Exception pce) {
234 | LOG.error(pce);
235 | }
236 | return 0;
237 | }
238 | }
--------------------------------------------------------------------------------
/src/main/resources/org/zkoss/zkidea/lang/resources/lang-addon.xsd:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 |
168 |
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 |
198 |
199 |
200 |
201 |
202 |
203 |
204 |
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 |
225 |
226 |
227 |
228 |
229 |
230 |
231 |
232 |
233 |
--------------------------------------------------------------------------------
/src/main/resources/META-INF/plugin.xml:
--------------------------------------------------------------------------------
1 |
2 | org.zkoss.zkidea
3 | ZK
4 | ZK Framework
5 | org.jetbrains.idea.maven
6 | com.intellij.modules.java
7 |
8 | A ZK framework plugin for IntelliJ IDEA that helps developers work with the ZK Java Web Framework. The plugin provides powerful, schema-aware code completion and validation to accelerate development.
10 | Features:
11 |
12 | -
13 | ZUL File Support
14 |
15 | - ZUL code completion for ZK components, attributes, and events
16 | - ZUL to class declaration navigation
17 | - ZUL syntax check and validation
18 |
19 |
20 | -
21 | ZK Configuration File Support
22 |
23 | - ZK configuration file (
zk.xml) code completion and validation
24 | - Language addon configuration file (
lang-addon.xml) code completion and validation
25 | - Note: To enable code completion, either use the default filenames (
zk.xml, lang-addon.xml) or add the correct namespace to your custom-named XML file.
26 |
27 |
28 | -
29 | MVVM Development Support
30 |
31 | - ZK MVVM annotation code completion (@init, @load, @bind, @save, @command, etc.)
32 |
33 |
34 | -
35 | Project Creation
36 |
37 | - Provide ZK Maven archetypes for creating ZK projects
38 |
39 |
40 | -
41 | Feedback Menu
42 |
43 | - a feedback menu under the Help menu for feedback and documentation
44 |
45 |
46 |
47 | See ZK Developer's Reference / Intellij IDEA ZK Plugin for details.
48 | ]]>
49 |
50 | 0.4.1
52 |
53 | - update plugin icon and description
54 |
55 | 0.4.0
56 |
64 | 0.2.0
65 |
66 | - Refined news notification to help users stay better informed by keeping important messages accessible until they are reviewed
67 |
68 | 0.1.23
69 |
73 | 0.1.22
74 |
75 | - Upgrade for Intellij 2024.1 version
76 |
77 |
78 | 0.1.21
79 |
80 | - [bug] #40 Cannot run under IU-233.11799.241
81 |
82 |
83 | 0.1.20
84 |
85 | - [bug] #38 ZK news popup has an error in Linux env. for 2023-2
86 |
87 |
88 | 0.1.19
89 |
90 | - [bug] #36 Add support for Intellij 2023.2
91 |
92 |
93 | 0.1.18
94 |
95 | - [bug] #34 Add support for Intellij 2023.1
96 |
97 |
98 | 0.1.17
99 |
100 | - [bug] #33 ZK Plugin not compatible with Intellij 2022.3
101 |
102 |
103 | 0.1.16
104 |
105 | - [bug] #32 support latest intellij version 222.*
106 |
107 |
108 | 0.1.15
109 |
110 | - [bug] #31 Plugin error for IC-221.5.080.210 with Version 0.1.14
111 |
112 |
113 | 0.1.14
114 |
115 | - [bug] #30 No compatible with v2021.3
116 |
117 |
118 | 0.1.13
119 |
120 | - fix deprecated API usage
121 | - add news notification
122 |
123 |
124 | 0.1.12
125 |
126 | - [bug] #28 - Plugin dont work in Intellij 2021.2
127 |
128 |
129 | 0.1.11
130 |
131 | - [bug] #25 - failed with RuntimeExceptionWithAttachments in IntellijJ 2020.1
132 |
133 |
134 | 0.1.10
135 |
136 | - [bug] #20 - Error when starting IntelliJ IDEA 2017.2
137 |
138 |
139 | 0.1.9
140 |
141 | - [bug] #19 - Exception on Intellij IU-163.12024.16
142 |
143 |
144 | 0.1.8
145 |
146 | - [bug] #14 - Worker exited due to exception
147 | - [bug] #17 - Assertion on load of IDE/Project
148 |
149 |
150 | 0.1.7
151 |
152 | - [bug] #10 - Plugin crashes on latest Idea 14 with JDK 6
153 | - [bug] #13 - Worker exited due to exception
154 |
155 |
156 | 0.1.6
157 |
158 | - [enhancement] #8 - Support to open zul file in browser when run project with Jetty maven plugin
159 | - [bug] #7 - IOException on IDEA startup
160 |
161 |
162 | 0.1.5
163 |
164 | - [enhancement] #6 - JDK 6 or 7 support
165 | - [bug] #5 - v0.1.4 cannot work well on Windows environment
166 |
167 |
168 | 0.1.4
169 |
170 | - Fixed an issue about stackoverflow exception
171 |
172 |
173 | 0.1.3
174 |
175 | - Support ZK Maven archetypes to create project
176 | - some bugs fixed
177 |
178 |
179 | 0.1.2
180 |
181 | - Support MVVM annotation content assistant
182 | - Support to upgrade zul.xsd file automatically
183 | - Support MVVM annotation to go to declaration for Java class
184 |
185 |
186 | 0.1.1
187 |
188 | - Update zul.xsd to ZK 7.0.6-FL version
189 |
190 |
191 | 0.1.0
192 |
193 | - ZUL editor supports content assistant.
194 | - ZUL editor supports syntax checking.
195 |
196 |
197 | ]]>
198 |
199 |
201 |
204 |
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
213 |
214 |
215 |
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 |
225 |
226 |
227 |
228 |
229 |
230 |
231 |
232 |
233 |
234 |
235 |
236 |
237 |
238 |
239 |
240 |
241 |
242 |
243 |
247 |
248 |
252 |
256 |
260 |
264 |
265 |
266 |
267 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "{}"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright {yyyy} {name of copyright owner}
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
203 |
--------------------------------------------------------------------------------
/doc/code-completion-xml.md:
--------------------------------------------------------------------------------
1 | # ZKIdea XML Code Completion Architecture
2 |
3 | ## Overview
4 |
5 | The ZKIdea plugin provides comprehensive code completion and validation for three types of XML files in the ZK Framework ecosystem:
6 |
7 | - **ZUL files** (`.zul`) - ZK User Interface markup files
8 | - **ZK configuration files** (`zk.xml`) - ZK application configuration
9 | - **Language addon files** (`lang-addon.xml`) - ZK component library definitions
10 |
11 | This document describes the architectural patterns, key components, and integration mechanisms that enable IntelliJ IDEA to provide schema-aware completion, validation, and navigation for these file types.
12 |
13 | ## Architectural Principles
14 |
15 | ### Dual-Layer Architecture
16 |
17 | The code completion system operates on two complementary layers:
18 |
19 | 1. **Schema Provider Layer** - Explicit namespace-based completion using `StandardResourceProvider`
20 | 2. **DOM Descriptor Layer** - Default namespace completion for files without explicit `xmlns` declarations
21 |
22 | This dual approach ensures that files work seamlessly whether developers include explicit namespace declarations or rely on filename-based detection.
23 |
24 | ### IntelliJ Integration Strategy
25 |
26 | The architecture leverages IntelliJ Platform's XML infrastructure rather than creating custom completion mechanisms:
27 |
28 | - **XSD Schema Integration** - Uses standard XML Schema files for element definitions
29 | - **Standard Extension Points** - Implements IntelliJ's `StandardResourceProvider` and `XmlElementDescriptorProvider` interfaces
30 | - **Built-in Caching** - Relies on IntelliJ's `CachedValue` system for performance optimization
31 | - **Namespace Resolution** - Uses `XmlNSDescriptorImpl` for schema-based validation and completion
32 |
33 | ## Core Components
34 |
35 | ### Schema Provider Layer
36 |
37 | #### StandardResourceProvider Implementation
38 |
39 | Each XML file type has a dedicated schema provider that registers XSD resources:
40 |
41 | **ZulSchemaProvider**
42 | - Registers `zul.xsd` for namespace `http://www.zkoss.org/2005/zul`
43 | - Handles multiple ZK-related namespaces (native, client, annotation, shadow)
44 | - Maps HTTP and HTTPS schema URLs to local XSD resources
45 |
46 | **ZkConfigSchemaProvider**
47 | - Registers `zk.xsd` for namespace `http://www.zkoss.org/2005/zk/config`
48 | - Provides schema support for ZK application configuration elements
49 |
50 | **LangAddonSchemaProvider**
51 | - Registers `lang-addon.xsd` for namespace `http://www.zkoss.org/2005/zk/lang-addon`
52 | - Enables completion for component library and language addon definitions
53 |
54 | #### Schema Provider Pattern
55 |
56 | All schema providers follow a consistent implementation pattern:
57 |
58 | ```java
59 | public class [Type]SchemaProvider implements StandardResourceProvider {
60 | public static final String SCHEMA_URL = "http://www.zkoss.org/...";
61 | public static final String PROJECT_SCHEMA_URL = "https://www.zkoss.org/.../schema.xsd";
62 | public static final String PROJECT_SCHEMA_PATH = "org/zkoss/zkidea/lang/resources/schema.xsd";
63 |
64 | public void registerResources(ResourceRegistrar registrar) {
65 | var path = "/" + PROJECT_SCHEMA_PATH;
66 | registrar.addStdResource("schema-name", path, getClass());
67 | registrar.addStdResource(SCHEMA_URL, path, getClass());
68 | registrar.addStdResource(PROJECT_SCHEMA_URL, path, getClass());
69 | }
70 | }
71 | ```
72 |
73 | ### DOM Descriptor Layer
74 |
75 | #### File Type Detection
76 |
77 | **ZulDomUtil** serves as the central utility for identifying ZK-related XML files:
78 |
79 | - `isZKFile(PsiFile)` - Detects all ZK-related XML files
80 | - `isZkConfigFile(PsiFile)` - Identifies `zk.xml` files by filename
81 | - `isLangAddonFile(PsiFile)` - Identifies `lang-addon.xml` files by filename
82 |
83 | The detection logic uses filename patterns rather than content analysis for performance.
84 |
85 | #### Element Descriptor Management
86 |
87 | **ZkDomElementDescriptorProvider** implements `XmlElementDescriptorProvider`:
88 | - Entry point for IntelliJ's XML completion system
89 | - Delegates to `ZkDomElementDescriptorHolder` for actual descriptor resolution
90 | - Registered in `plugin.xml` as `xml.elementDescriptorProvider`
91 |
92 | **ZkDomElementDescriptorHolder** manages schema descriptors per project:
93 | - Project-level service that caches `XmlNSDescriptorImpl` instances
94 | - Maps file types to appropriate XSD schemas
95 | - Uses `CachedValue` with `PsiModificationTracker` for cache invalidation
96 | - Provides default namespace context for schema-based completion
97 |
98 | #### FileKind Enumeration
99 |
100 | The system uses an internal `FileKind` enum to map file types to schema URLs:
101 |
102 | ```java
103 | enum FileKind {
104 | ZUL_FILE { getSchemaUrl() → ZulSchemaProvider.ZUL_PROJECT_SCHEMA_URL },
105 | ZK_CONFIG_FILE { getSchemaUrl() → ZkConfigSchemaProvider.ZK_CONFIG_PROJECT_SCHEMA_URL },
106 | LANG_ADDON_FILE { getSchemaUrl() → LangAddonSchemaProvider.LANG_ADDON_PROJECT_SCHEMA_URL }
107 | }
108 | ```
109 |
110 | ## Integration Flow
111 |
112 | ### Schema-Based Completion (With Namespace)
113 |
114 | 1. Developer types `<` in an XML file with explicit namespace (`xmlns="http://www.zkoss.org/..."`)
115 | 2. IntelliJ Platform's XML parser identifies the namespace
116 | 3. `ExternalResourceManager` resolves namespace to local XSD via registered `StandardResourceProvider`
117 | 4. IntelliJ provides completion based on XSD schema elements and attributes
118 | 5. Real-time validation occurs against the schema
119 |
120 | ### Default Namespace Completion (Without Namespace)
121 |
122 | 1. Developer types `<` in a ZK XML file without explicit namespace
123 | 2. `ZkDomElementDescriptorProvider.getDescriptor()` is called by IntelliJ
124 | 3. `ZulDomUtil` identifies file type by filename pattern
125 | 4. `ZkDomElementDescriptorHolder` maps file type to appropriate schema URL
126 | 5. Cached `XmlNSDescriptorImpl` provides schema-based completion with default namespace
127 | 6. Elements complete as if explicit namespace were present
128 |
129 | ## Activating Code Completion
130 |
131 | For the plugin to provide code completion and validation for `zk.xml` and `lang-addon.xml` files, one of the following two conditions must be met:
132 |
133 | 1. **Filename Convention**: The file must be named exactly `zk.xml` or `lang-addon.xml`. The plugin's **DOM Descriptor Layer** automatically detects these filenames and applies the correct schema, even if no XML namespace is declared.
134 |
135 | 2. **Explicit XML Namespace**: If you use a custom filename (e.g., `my-zk-config.xml`), you **must** declare the correct XML namespace in the root element. The plugin's **Schema Provider Layer** uses this namespace to associate the file with the proper XSD.
136 |
137 | - For **ZK configuration files**, the required namespace is:
138 | ```xml
139 |
140 | ...
141 |
142 | ```
143 | - For **language addon files**, the required namespace is:
144 | ```xml
145 |
146 | ...
147 |
148 | ```
149 |
150 | This dual-system ensures flexibility while providing a reliable mechanism for activating the plugin's features.
151 |
152 | ## Schema Architecture
153 |
154 | ### XSD Schema Structure
155 |
156 | Each XML file type is backed by a comprehensive XSD schema:
157 |
158 | **zul.xsd** - ZK UI components
159 | - Root `` elements and ZK component hierarchy
160 | - Event handlers, data binding attributes
161 | - Layout and styling properties
162 |
163 | **zk.xsd** - ZK configuration
164 | - Application-level configuration sections
165 | - Client, desktop, session, and system configuration elements
166 | - Library properties and preference settings
167 |
168 | **lang-addon.xsd** - Language addons
169 | - Component definitions and inheritance
170 | - JavaScript and CSS resource declarations
171 | - Custom properties and annotation support
172 |
173 | ### Schema Location Resolution
174 |
175 | Schema resolution follows IntelliJ's standard pattern:
176 |
177 | 1. **Resource Registration** - Schema providers register local XSD paths
178 | 2. **URL Mapping** - External URLs (HTTP/HTTPS) map to local resources
179 | 3. **Classpath Loading** - XSD files loaded from plugin JAR resources
180 | 4. **Namespace Resolution** - `ExternalResourceManager` handles URL-to-file mapping
181 |
182 | ## Performance Considerations
183 |
184 | ### Caching Strategy
185 |
186 | - **Project-Level Caching** - One descriptor cache per IntelliJ project
187 | - **Modification Tracking** - Cache invalidation tied to `PsiModificationTracker.MODIFICATION_COUNT`
188 | - **Lazy Loading** - Descriptors created on-demand, not at plugin startup
189 | - **Thread Safety** - Synchronized descriptor creation prevents race conditions
190 |
191 | ### Resource Management
192 |
193 | - **Local Schema Storage** - XSD files bundled in plugin resources
194 | - **Minimal Memory Footprint** - Reuses IntelliJ's existing XML infrastructure
195 | - **No Network Dependency** - All schemas resolved locally
196 |
197 | ## Plugin Configuration
198 |
199 | ### Extension Point Registration
200 |
201 | The system registers through standard IntelliJ extension points:
202 |
203 | ```xml
204 |
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 | ```
220 |
221 | ## Extensibility Patterns
222 |
223 | ### Adding New XML File Types
224 |
225 | To add support for additional ZK XML file types:
226 |
227 | 1. **Create Schema Provider** - Implement `StandardResourceProvider` following existing patterns
228 | 2. **Add XSD Schema** - Place schema file in `resources/org/zkoss/zkidea/lang/resources/`
229 | 3. **Update File Detection** - Add detection method to `ZulDomUtil`
230 | 4. **Extend FileKind Enum** - Add new enum value in `ZkDomElementDescriptorHolder`
231 | 5. **Register Extensions** - Update `plugin.xml` with provider and file type registrations
232 |
233 | ### Schema Evolution
234 |
235 | - **Backward Compatibility** - New XSD versions should maintain element compatibility
236 | - **Automatic Updates** - Schema changes automatically flow through to completion
237 | - **Version Management** - Consider schema versioning for breaking changes
238 |
239 | ## Development Guidelines
240 |
241 | ### Code Organization
242 |
243 | - **Package Structure** - Schema providers in `.lang` package, DOM descriptors in `.dom` package
244 | - **Naming Conventions** - `[Type]SchemaProvider` and clear, descriptive class names
245 | - **Documentation** - Comprehensive JavaDoc explaining integration points
246 |
247 | ### Testing Considerations
248 |
249 | - **Test Files** - Provide sample XML files for manual testing
250 | - **Namespace Variants** - Test both explicit and implicit namespace scenarios
251 | - **Error Conditions** - Verify behavior with malformed or incomplete XML
252 | - **Performance** - Test caching behavior under various modification scenarios
253 |
254 | ### Maintenance Notes
255 |
256 | - **IntelliJ Version Compatibility** - Monitor IntelliJ Platform API changes
257 | - **Schema Updates** - Coordinate XSD updates with ZK Framework releases
258 | - **Error Handling** - Graceful degradation when schemas unavailable
259 | - **Logging** - Appropriate logging for debugging completion issues
260 |
261 | This architecture provides a robust, maintainable foundation for XML code completion in ZK Framework development environments while following IntelliJ Platform best practices and patterns.
--------------------------------------------------------------------------------
/src/main/resources/org/zkoss/zkidea/lang/resources/zk.xsd:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 |
168 |
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 |
198 |
199 |
200 |
201 |
202 |
203 |
204 |
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 |
225 |
226 |
227 |
228 |
229 |
230 |
231 |
232 |
233 |
234 |
235 |
236 |
237 |
238 |
239 |
240 |
241 |
242 |
243 |
244 |
245 |
246 |
247 |
248 |
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 |
262 |
263 |
264 |
265 |
266 |
267 |
268 |
269 |
270 |
271 |
272 |
273 |
274 |
275 |
276 |
277 |
278 |
279 |
280 |
281 |
282 |
283 |
284 |
285 |
286 |
287 |
288 |
289 |
290 |
291 |
292 |
293 |
294 |
295 |
296 |
297 |
298 |
299 |
300 |
301 |
302 |
303 |
304 |
305 |
306 |
307 |
308 |
309 |
310 |
311 |
312 |
313 |
314 |
315 |
316 |
317 |
318 |
319 |
320 |
321 |
322 |
323 |
324 |
325 |
326 |
327 |
328 |
329 |
330 |
331 |
332 |
333 |
334 |
335 |
336 |
337 |
338 |
339 |
340 |
341 |
342 |
343 |
344 |
345 |
346 |
347 |
348 |
349 |
350 |
351 |
352 |
353 |
354 |
355 |
356 |
357 |
358 |
359 |
360 |
361 |
362 |
363 |
364 |
365 |
366 |
367 |
368 |
369 |
370 |
371 |
372 |
373 |
374 |
375 |
376 |
377 |
378 |
379 |
380 |
381 |
382 |
383 |
384 |
385 |
386 |
387 |
388 |
389 |
390 |
391 |
392 |
393 |
394 |
--------------------------------------------------------------------------------
/ISSUES.md:
--------------------------------------------------------------------------------
1 | # Cannot init component state (componentName=GradleJvmSupportMatrix, componentClass=GradleJvmSupportMatrix)
2 | ## Steps to reproduce
3 | * run gradle task "runIde"
4 |
5 | ## Current result
6 | IDE starts with errors:
7 | ```text
8 | 2025-09-30 22:49:43,706 [ 5009] SEVERE - #c.i.c.ComponentStoreImpl - Cannot init component state (componentName=GradleJvmSupportMatrix, componentClass=GradleJvmSupportMatrix) [Plugin: com.intellij.gradle]
9 | com.intellij.diagnostic.PluginException: Cannot init component state (componentName=GradleJvmSupportMatrix, componentClass=GradleJvmSupportMatrix) [Plugin: com.intellij.gradle]
10 | at com.intellij.configurationStore.ComponentStoreImpl.initComponent(ComponentStoreImpl.kt:174)
11 | at com.intellij.configurationStore.ComponentStoreWithExtraComponents.initComponent(ComponentStoreWithExtraComponents.kt:48)
12 | at com.intellij.serviceContainer.ComponentManagerImpl.initializeComponent$intellij_platform_serviceContainer(ComponentManagerImpl.kt:931)
13 | at com.intellij.serviceContainer.ServiceInstanceInitializer.createInstance$suspendImpl(ServiceInstanceInitializer.kt:41)
14 | at com.intellij.serviceContainer.ServiceInstanceInitializer.createInstance(ServiceInstanceInitializer.kt)
15 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1$1.invokeSuspend(LazyInstanceHolder.kt:162)
16 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1$1.invoke(LazyInstanceHolder.kt)
17 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1$1.invoke(LazyInstanceHolder.kt)
18 | at kotlinx.coroutines.intrinsics.UndispatchedKt.startUndispatchedOrReturn(Undispatched.kt:78)
19 | at kotlinx.coroutines.BuildersKt__Builders_commonKt.withContext(Builders.common.kt:167)
20 | at kotlinx.coroutines.BuildersKt.withContext(Unknown Source)
21 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1.invokeSuspend(LazyInstanceHolder.kt:160)
22 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1.invoke(LazyInstanceHolder.kt)
23 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1.invoke(LazyInstanceHolder.kt)
24 | at kotlinx.coroutines.intrinsics.UndispatchedKt.startCoroutineUndispatched(Undispatched.kt:44)
25 | at kotlinx.coroutines.CoroutineStart.invoke(CoroutineStart.kt:112)
26 | at kotlinx.coroutines.AbstractCoroutine.start(AbstractCoroutine.kt:126)
27 | at kotlinx.coroutines.BuildersKt__Builders_commonKt.launch(Builders.common.kt:56)
28 | at kotlinx.coroutines.BuildersKt.launch(Unknown Source)
29 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.initialize(LazyInstanceHolder.kt:145)
30 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.access$initialize(LazyInstanceHolder.kt:13)
31 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.tryInitialize(LazyInstanceHolder.kt:135)
32 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.getInstance(LazyInstanceHolder.kt:95)
33 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.getInstanceInCallerContext$suspendImpl(LazyInstanceHolder.kt:87)
34 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.getInstanceInCallerContext(LazyInstanceHolder.kt)
35 | at com.intellij.serviceContainer.ComponentManagerImplKt$getOrCreateInstanceBlocking$3.invokeSuspend(ComponentManagerImpl.kt:2337)
36 | at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
37 | at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:108)
38 | at kotlinx.coroutines.EventLoopImplBase.processNextEvent(EventLoop.common.kt:280)
39 | at kotlinx.coroutines.BlockingCoroutine.joinBlocking(Builders.kt:85)
40 | at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking(Builders.kt:59)
41 | at kotlinx.coroutines.BuildersKt.runBlocking(Unknown Source)
42 | at com.intellij.serviceContainer.ComponentManagerImplKt$runBlockingInitialization$1.invoke(ComponentManagerImpl.kt:2406)
43 | at com.intellij.serviceContainer.ComponentManagerImplKt$runBlockingInitialization$1.invoke(ComponentManagerImpl.kt:2397)
44 | at com.intellij.openapi.progress.ContextKt.prepareThreadContext(context.kt:83)
45 | at com.intellij.serviceContainer.ComponentManagerImplKt.runBlockingInitialization(ComponentManagerImpl.kt:2397)
46 | at com.intellij.serviceContainer.ComponentManagerImplKt.getOrCreateInstanceBlocking(ComponentManagerImpl.kt:2336)
47 | at com.intellij.serviceContainer.ComponentManagerImpl.doGetService(ComponentManagerImpl.kt:1057)
48 | at com.intellij.serviceContainer.ComponentManagerImpl.getService(ComponentManagerImpl.kt:988)
49 | at org.jetbrains.plugins.gradle.jvmcompat.GradleJvmSupportMatrix$Companion.getInstance(GradleJvmSupportMatrix.kt:220)
50 | at org.jetbrains.plugins.gradle.jvmcompat.GradleCompatibilitySupportUpdater.(GradleCompatibilitySupportUpdater.kt:14)
51 | at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
52 | at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:77)
53 | at java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
54 | at java.base/java.lang.reflect.Constructor.newInstanceWithCaller(Constructor.java:499)
55 | at java.base/java.lang.reflect.Constructor.newInstance(Constructor.java:480)
56 | at com.intellij.platform.instanceContainer.instantiation.InstantiateKt$instantiate$4.invoke(instantiate.kt:74)
57 | at com.intellij.platform.instanceContainer.instantiation.InstantiateKt$instantiate$4.invoke(instantiate.kt:72)
58 | at com.intellij.platform.instanceContainer.instantiation.InstantiateKt.instantiate(instantiate.kt:278)
59 | at com.intellij.platform.instanceContainer.instantiation.InstantiateKt.instantiate(instantiate.kt:72)
60 | at com.intellij.serviceContainer.InstantiateKt.instantiateWithContainer(instantiate.kt:19)
61 | at com.intellij.serviceContainer.ServiceInstanceInitializer.createInstance$suspendImpl(ServiceInstanceInitializer.kt:26)
62 | at com.intellij.serviceContainer.ServiceInstanceInitializer.createInstance(ServiceInstanceInitializer.kt)
63 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1$1.invokeSuspend(LazyInstanceHolder.kt:162)
64 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1$1.invoke(LazyInstanceHolder.kt)
65 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1$1.invoke(LazyInstanceHolder.kt)
66 | at kotlinx.coroutines.intrinsics.UndispatchedKt.startUndispatchedOrReturn(Undispatched.kt:78)
67 | at kotlinx.coroutines.BuildersKt__Builders_commonKt.withContext(Builders.common.kt:167)
68 | at kotlinx.coroutines.BuildersKt.withContext(Unknown Source)
69 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1.invokeSuspend(LazyInstanceHolder.kt:160)
70 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1.invoke(LazyInstanceHolder.kt)
71 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder$initialize$1.invoke(LazyInstanceHolder.kt)
72 | at kotlinx.coroutines.intrinsics.UndispatchedKt.startCoroutineUndispatched(Undispatched.kt:44)
73 | at kotlinx.coroutines.CoroutineStart.invoke(CoroutineStart.kt:112)
74 | at kotlinx.coroutines.AbstractCoroutine.start(AbstractCoroutine.kt:126)
75 | at kotlinx.coroutines.BuildersKt__Builders_commonKt.launch(Builders.common.kt:56)
76 | at kotlinx.coroutines.BuildersKt.launch(Unknown Source)
77 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.initialize(LazyInstanceHolder.kt:145)
78 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.access$initialize(LazyInstanceHolder.kt:13)
79 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.tryInitialize(LazyInstanceHolder.kt:135)
80 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.getInstance(LazyInstanceHolder.kt:95)
81 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.getInstanceInCallerContext$suspendImpl(LazyInstanceHolder.kt:87)
82 | at com.intellij.platform.instanceContainer.internal.LazyInstanceHolder.getInstanceInCallerContext(LazyInstanceHolder.kt)
83 | at com.intellij.serviceContainer.ComponentManagerImplKt$getOrCreateInstanceBlocking$3.invokeSuspend(ComponentManagerImpl.kt:2337)
84 | at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
85 | at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:108)
86 | at kotlinx.coroutines.EventLoopImplBase.processNextEvent(EventLoop.common.kt:280)
87 | at kotlinx.coroutines.BlockingCoroutine.joinBlocking(Builders.kt:85)
88 | at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking(Builders.kt:59)
89 | at kotlinx.coroutines.BuildersKt.runBlocking(Unknown Source)
90 | at com.intellij.serviceContainer.ComponentManagerImplKt$runBlockingInitialization$1.invoke(ComponentManagerImpl.kt:2406)
91 | at com.intellij.serviceContainer.ComponentManagerImplKt$runBlockingInitialization$1.invoke(ComponentManagerImpl.kt:2397)
92 | at com.intellij.openapi.progress.ContextKt.prepareThreadContext(context.kt:86)
93 | at com.intellij.serviceContainer.ComponentManagerImplKt.runBlockingInitialization(ComponentManagerImpl.kt:2397)
94 | at com.intellij.serviceContainer.ComponentManagerImplKt.getOrCreateInstanceBlocking(ComponentManagerImpl.kt:2336)
95 | at com.intellij.serviceContainer.ComponentManagerImpl.doGetService(ComponentManagerImpl.kt:1057)
96 | at com.intellij.serviceContainer.ComponentManagerImpl.getService(ComponentManagerImpl.kt:988)
97 | at org.jetbrains.plugins.gradle.jvmcompat.GradleCompatibilitySupportUpdater$Companion.getInstance(GradleCompatibilitySupportUpdater.kt:26)
98 | at org.jetbrains.plugins.gradle.service.project.GradleVersionUpdateStartupActivity.execute(GradleVersionUpdateStartupActivity.kt:12)
99 | at com.intellij.ide.startup.impl.StartupManagerImplKt$launchActivity$1.invokeSuspend(StartupManagerImpl.kt:482)
100 | at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
101 | at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:108)
102 | at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:584)
103 | at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:793)
104 | at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:697)
105 | at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:684)
106 | Caused by: java.lang.IllegalArgumentException: 25
107 | at com.intellij.util.lang.JavaVersion.parse(JavaVersion.java:307)
108 | at org.jetbrains.plugins.gradle.jvmcompat.GradleJvmSupportMatrix$getCompatibilityRanges$1$javaRange$1.invoke(GradleJvmSupportMatrix.kt:44)
109 | at org.jetbrains.plugins.gradle.jvmcompat.GradleJvmSupportMatrix$getCompatibilityRanges$1$javaRange$1.invoke(GradleJvmSupportMatrix.kt:44)
110 | at org.jetbrains.plugins.gradle.jvmcompat.IdeVersionedDataParser$Companion.parseVersion(IdeVersionedDataParser.kt:21)
111 | at org.jetbrains.plugins.gradle.jvmcompat.IdeVersionedDataParser$Companion.parseRange(IdeVersionedDataParser.kt:31)
112 | at org.jetbrains.plugins.gradle.jvmcompat.GradleJvmSupportMatrix.getCompatibilityRanges(GradleJvmSupportMatrix.kt:44)
113 | at org.jetbrains.plugins.gradle.jvmcompat.GradleJvmSupportMatrix.applyState(GradleJvmSupportMatrix.kt:28)
114 | at org.jetbrains.plugins.gradle.jvmcompat.GradleJvmSupportMatrix.onStateChanged(GradleJvmSupportMatrix.kt:50)
115 | at org.jetbrains.plugins.gradle.jvmcompat.GradleJvmSupportMatrix.onStateChanged(GradleJvmSupportMatrix.kt:13)
116 | at org.jetbrains.plugins.gradle.jvmcompat.IdeVersionedDataStorage.loadState(IdeVersionedDataStorage.kt:38)
117 | at org.jetbrains.plugins.gradle.jvmcompat.IdeVersionedDataStorage.loadState(IdeVersionedDataStorage.kt:7)
118 | at com.intellij.configurationStore.ComponentStoreImpl.doInitComponent(ComponentStoreImpl.kt:490)
119 | at com.intellij.configurationStore.ComponentStoreImpl.initComponent(ComponentStoreImpl.kt:409)
120 | at com.intellij.configurationStore.ComponentStoreImpl.initComponent(ComponentStoreImpl.kt:131)
121 | ... 95 more
122 | ```
123 |
124 | ## Root cause
125 | The IntelliJ IDEA version you're using has a Gradle plugin that doesn't recognize Java 25. The error happens when:
126 |
127 | The GradleJvmSupportMatrix component tries to initialize
128 | It attempts to parse Java version compatibility data
129 | The parser encounters "25" (Java 25) but the JavaVersion.parse() method doesn't recognize it as a valid version
130 |
131 | Why this happens:
132 |
133 | Java 25 is a relatively new version (early access/preview)
134 | Your IntelliJ IDEA version was released before Java 25 support was added
135 | The Gradle plugin's compatibility matrix includes Java 25, but the version parser hasn't been updated to handle it
136 |
137 | ## Solution
138 | Upgrade the IntelliJ platform version in `build.gradle`
139 | ```gradle
140 | intellij {
141 | version = '2024.2' // or later
142 | plugins = ['maven', 'com.intellij.java']
143 | }
144 | ```
145 | but it also needs to adjust the compatible version range:
146 |
147 | ```xml
148 |
149 | sinceBuild = '241' // Start from 2024.1
150 | untilBuild = '253.*'
151 |
152 | ```
153 |
154 | That might affect some users who are on older versions of IntelliJ IDEA, so consider the trade-offs.
--------------------------------------------------------------------------------