1 package net.sourceforge.pmd.swingui;
2
3 import net.sourceforge.pmd.PMDException;
4 import net.sourceforge.pmd.Rule;
5 import net.sourceforge.pmd.RuleProperties;
6 import net.sourceforge.pmd.RuleSet;
7 import net.sourceforge.pmd.swingui.event.ListenerList;
8 import net.sourceforge.pmd.swingui.event.PMDDirectoryRequestEvent;
9 import net.sourceforge.pmd.swingui.event.PMDDirectoryReturnedEvent;
10 import net.sourceforge.pmd.swingui.event.PMDDirectoryReturnedEventListener;
11 import net.sourceforge.pmd.swingui.event.RulesTreeModelEvent;
12 import net.sourceforge.pmd.swingui.event.RulesTreeModelEventListener;
13
14 import javax.swing.tree.DefaultTreeModel;
15 import java.util.ArrayList;
16 import java.util.Arrays;
17 import java.util.Comparator;
18 import java.util.Enumeration;
19 import java.util.List;
20 import java.util.Set;
21
22 /***
23 *
24 * @author Donald A. Leckie
25 * @since December 13, 2002
26 * @version $Revision: 1.7 $, $Date: 2003/03/14 19:04:11 $
27 */
28 class RulesTreeModel extends DefaultTreeModel {
29
30 private PMDDirectoryReturnedEventHandler m_pmdDirectoryReturnedEventHandler;
31 private RulesTreeModelEventHandler m_rulesTreeModelEventHandler;
32 private static RulesTreeModel m_rulesTreeModel;
33
34 /***
35 ****************************************************************************
36 *
37 * @param rootNode
38 */
39 private RulesTreeModel(RulesTreeNode rootNode) {
40 super(rootNode);
41
42 m_pmdDirectoryReturnedEventHandler = new PMDDirectoryReturnedEventHandler();
43 m_rulesTreeModelEventHandler = new RulesTreeModelEventHandler();
44 ListenerList.addListener((PMDDirectoryReturnedEventListener) m_pmdDirectoryReturnedEventHandler);
45 }
46
47 /***
48 ***************************************************************************
49 *
50 * @param ruleSetName
51 *
52 * @return
53 */
54 protected RulesTreeNode getRuleSetNode(String ruleSetName) {
55 if (ruleSetName != null) {
56 RulesTreeNode rootNode = (RulesTreeNode) getRoot();
57 Enumeration ruleSetNodes = rootNode.children();
58
59 while (ruleSetNodes.hasMoreElements()) {
60 RulesTreeNode ruleSetNode = (RulesTreeNode) ruleSetNodes.nextElement();
61
62 if (ruleSetNode.getName().equalsIgnoreCase(ruleSetName)) {
63 return ruleSetNode;
64 }
65 }
66 }
67
68 return null;
69 }
70
71 /***
72 ***************************************************************************
73 *
74 * @param ruleSetName
75 * @param ruleName
76 *
77 * @return
78 */
79 protected RulesTreeNode getRuleNode(String ruleSetName, String ruleName) {
80 if ((ruleSetName != null) && (ruleName != null)) {
81 RulesTreeNode rootNode = (RulesTreeNode) getRoot();
82 Enumeration ruleSetNodes = rootNode.children();
83
84 while (ruleSetNodes.hasMoreElements()) {
85 RulesTreeNode ruleSetNode = (RulesTreeNode) ruleSetNodes.nextElement();
86
87 if (ruleSetNode.getName().equalsIgnoreCase(ruleSetName)) {
88 Enumeration ruleNodes = ruleSetNode.children();
89
90 while (ruleNodes.hasMoreElements()) {
91 RulesTreeNode ruleNode = (RulesTreeNode) ruleNodes.nextElement();
92
93 if (ruleNode.getName().equalsIgnoreCase(ruleName)) {
94 return ruleNode;
95 }
96 }
97 }
98 }
99 }
100
101 return null;
102 }
103
104 /***
105 ***************************************************************************
106 * @return
107 */
108 protected static final RulesTreeModel get() throws PMDException {
109 if (m_rulesTreeModel == null) {
110 RulesTreeNode rootNode;
111
112 rootNode = new RulesTreeNode("Rules");
113 m_rulesTreeModel = new RulesTreeModel(rootNode);
114 m_rulesTreeModel.buildTree();
115 }
116
117 return m_rulesTreeModel;
118 }
119
120 /***
121 *******************************************************************************
122 *
123 */
124 private void buildTree() throws PMDException {
125 RuleSet[] ruleSets;
126 RulesTreeNode rootNode;
127
128 ruleSets = loadRuleSets();
129 rootNode = (RulesTreeNode) getRoot();
130
131 for (int n1 = 0; n1 < ruleSets.length; n1++) {
132 RulesTreeNode ruleSetNode = new RulesTreeNode(ruleSets[n1]);
133
134 rootNode.add(ruleSetNode);
135 loadRuleTreeNodes(ruleSetNode);
136 }
137
138 }
139
140 /***
141 *******************************************************************************
142 *
143 * @return
144 */
145 private RuleSet[] loadRuleSets() throws PMDException {
146 PMDDirectoryRequestEvent.notifyRequestAllRuleSets(this);
147
148 // The event is processed. The requested rule set is assembled by another class
149 // that calls notifyReturnedAllRuleSets. The list of rule sets is stored in the
150 // inner class PMDDirectoryReturnedEventHandler. Then processing will then continue here.
151 //
152
153 List ruleSetList = m_pmdDirectoryReturnedEventHandler.getRuleSetList();
154
155 if (ruleSetList == null) {
156 ruleSetList = new ArrayList();
157 }
158
159 //
160 // Sort the rule sets by name in ascending order.
161 //
162 RuleSet[] ruleSets = new RuleSet[ruleSetList.size()];
163
164 ruleSetList.toArray(ruleSets);
165 Arrays.sort(ruleSets, new RuleSetNameComparator());
166
167 return ruleSets;
168 }
169
170 /***
171 *******************************************************************************
172 *
173 * @param ruleSetNode
174 */
175 private void loadRuleTreeNodes(RulesTreeNode ruleSetNode) {
176 RuleSet ruleSet;
177 Set setOfRules;
178 Rule[] rules;
179
180 ruleSet = ruleSetNode.getRuleSet();
181 setOfRules = ruleSet.getRules();
182 rules = new Rule[setOfRules.size()];
183
184 setOfRules.toArray(rules);
185 Arrays.sort(rules, new RuleNameComparator());
186
187 for (int n = 0; n < rules.length; n++) {
188 RulesTreeNode ruleNode = new RulesTreeNode(ruleSetNode, rules[n]);
189
190 ruleSetNode.add(ruleNode);
191 loadProperties(ruleNode);
192
193 rules[n] = null;
194 }
195 }
196
197 /***
198 *******************************************************************************
199 *
200 * @param ruleNode
201 */
202 private void loadProperties(RulesTreeNode ruleNode) {
203 Rule rule;
204 RuleProperties properties;
205 String[] propertyNames;
206 Enumeration keys;
207 int index;
208
209 rule = ruleNode.getRule();
210 properties = rule.getProperties();
211 propertyNames = new String[properties.size()];
212 keys = properties.keys();
213 index = 0;
214
215 while (keys.hasMoreElements()) {
216 propertyNames[index] = (String) keys.nextElement();
217 index++;
218 }
219
220 Arrays.sort(propertyNames, new PropertyNameComparator());
221
222 for (int n = 0; n < propertyNames.length; n++) {
223 String propertyName;
224 String propertyValue;
225 String propertyValueType;
226 RulesTreeNode propertyNode;
227
228 propertyName = propertyNames[n];
229 propertyValue = properties.getValue(propertyName);
230 propertyValueType = properties.getValueType(propertyName);
231 propertyNode = new RulesTreeNode(ruleNode, propertyName, propertyValue, propertyValueType);
232
233 ruleNode.add(propertyNode);
234
235 propertyNames[n] = null;
236 }
237 }
238
239 /***
240 ****************************************************************************
241 ****************************************************************************
242 ****************************************************************************
243 */
244 private class RulesTreeModelEventHandler implements RulesTreeModelEventListener {
245
246 /***
247 ***********************************************************************
248 *
249 */
250 private RulesTreeModelEventHandler() {
251 ListenerList.addListener((RulesTreeModelEventListener) this);
252 }
253
254 /***
255 ************************************************************************
256 *
257 * @param parentNode
258 */
259 public void reload(RulesTreeModelEvent event) {
260 RulesTreeNode parentNode = event.getParentNode();
261 RulesTreeModel.this.reload(parentNode);
262 }
263
264 /***
265 ****************************************************************************
266 *
267 * @param event
268 */
269 public void requestSelectedRule(RulesTreeModelEvent event) {
270 }
271
272 /***
273 ****************************************************************************
274 *
275 * @param event
276 */
277 public void returnedSelectedRule(RulesTreeModelEvent event) {
278 }
279 }
280
281 /***
282 *******************************************************************************
283 *******************************************************************************
284 *******************************************************************************
285 */
286 private class PropertyNameComparator implements Comparator {
287
288 /***
289 ************************************************************************
290 *
291 * @param objectA
292 * @param objectB
293 *
294 * @return
295 */
296 public int compare(Object objectA, Object objectB) {
297 String propertyNameA = (String) objectA;
298 String propertyNameB = (String) objectB;
299
300 return propertyNameA.compareToIgnoreCase(propertyNameB);
301 }
302 }
303
304 /***
305 *******************************************************************************
306 *******************************************************************************
307 *******************************************************************************
308 */
309 private class RuleSetNameComparator implements Comparator {
310
311 /***
312 ************************************************************************
313 *
314 * @param objectA
315 * @param objectB
316 *
317 * @return
318 */
319 public int compare(Object objectA, Object objectB) {
320 String ruleSetNameA = ((RuleSet) objectA).getName();
321 String ruleSetNameB = ((RuleSet) objectB).getName();
322
323 return ruleSetNameA.compareToIgnoreCase(ruleSetNameB);
324 }
325 }
326
327 /***
328 *******************************************************************************
329 *******************************************************************************
330 *******************************************************************************
331 */
332 private class RuleNameComparator implements Comparator {
333
334 /***
335 ************************************************************************
336 *
337 * @param objectA
338 * @param objectB
339 *
340 * @return
341 */
342 public int compare(Object objectA, Object objectB) {
343 String ruleNameA = ((Rule) objectA).getName();
344 String ruleNameB = ((Rule) objectB).getName();
345
346 return ruleNameA.compareToIgnoreCase(ruleNameB);
347 }
348 }
349
350 /***
351 *******************************************************************************
352 *******************************************************************************
353 *******************************************************************************
354 */
355 private class PMDDirectoryReturnedEventHandler implements PMDDirectoryReturnedEventListener {
356
357 private List m_ruleSetList;
358 private String m_ruleSetPath;
359
360 /***
361 ***************************************************************************
362 */
363 private String getRuleSetPath() {
364 return m_ruleSetPath;
365 }
366
367 /***
368 ***************************************************************************
369 */
370 private List getRuleSetList() {
371 return m_ruleSetList;
372 }
373
374 /***
375 ***************************************************************************
376 *
377 * @param event
378 */
379 public void returnedRuleSetPath(PMDDirectoryReturnedEvent event) {
380 m_ruleSetPath = event.getRuleSetPath();
381 }
382
383 /***
384 ***************************************************************************
385 *
386 * @param event
387 */
388 public void returnedAllRuleSets(PMDDirectoryReturnedEvent event) {
389 m_ruleSetList = event.getRuleSetList();
390 }
391
392 /***
393 ***************************************************************************
394 *
395 * @param event
396 */
397 public void returnedDefaultRuleSets(PMDDirectoryReturnedEvent event) {
398 m_ruleSetList = event.getRuleSetList();
399 }
400
401 /***
402 ***************************************************************************
403 *
404 * @param event
405 */
406 public void returnedIncludedRules(PMDDirectoryReturnedEvent event) {
407 m_ruleSetList = event.getRuleSetList();
408 }
409 }
410 }
This page was automatically generated by Maven