1 /*

     1 /*

    18 package com.nokia.ant;

    18 package com.nokia.ant;

    19 

    19 

    20 import info.bliki.wiki.model.WikiModel;

    20 import info.bliki.wiki.model.WikiModel;

    21 

    21 

    22 import java.io.BufferedReader;

    22 import java.io.BufferedReader;

    56 import org.dom4j.XPath;

    56 import org.dom4j.XPath;

    57 import org.dom4j.io.OutputFormat;

    57 import org.dom4j.io.OutputFormat;

    58 import org.dom4j.io.SAXReader;

    58 import org.dom4j.io.SAXReader;

    59 import org.dom4j.io.XMLWriter;

    59 import org.dom4j.io.XMLWriter;

    60 

    60 

    62 /**

    61 /**

    63  * Reads the current ant project and a fileset and generates a xml file with a summary of targets,

    62  * Reads the current ant project and a fileset and generates a xml file with a summary of targets,

    64  * macros and properties.

    63  * macros and properties.

    65  */

    64  */

    68     private Project project;

    66     private Project project;

    69     private ResourceCollection rc;

    67     private ResourceCollection rc;

    70     private Task task;

    68     private Task task;

    71     private boolean debug;

    69     private boolean debug;

    72     private boolean homeFilesOnly = true;

    70     private boolean homeFilesOnly = true;

    73     private HashMap<String, List<String>> globalSignalList = new HashMap<String, List<String>>();

    71     private HashMap<String, List<String>> globalSignalList = new HashMap<String, List<String>>();

    74     private HashMap<String, String> map = new HashMap<String, String>();

    72     private HashMap<String, String> map = new HashMap<String, String>();

    75     private Document signaldoc;

    73     private Document signaldoc;

    79         this.project = project;

    76         this.project = project;

    80         this.rc = rc;

    77         this.rc = rc;

    81         this.task = task;

    78         this.task = task;

    82         map.put("hlm", "http://www.nokia.com/helium");

    79         map.put("hlm", "http://www.nokia.com/helium");

    83     }

    80     }

    95     }

    92     }

    96 

    93 

    97     public void log(String msg, int level) {

    94     public void log(String msg, int level) {

    98         if (task != null) {

    95         if (task != null) {

    99             task.log(msg, level);

    96             task.log(msg, level);

   101             project.log(msg, level);

    99             project.log(msg, level);

   102         }

   100         }

   103     }

   101     }

   104 

   102 

   108         Object object = r.getReferencedObject();

   104         Object object = r.getReferencedObject();

   111             throw new BuildException(r.getRefId() + " doesn\'t denote a ResourceCollection");

   106             throw new BuildException(r.getRefId() + " doesn\'t denote a ResourceCollection");

   112         }

   107         }

   113         rc = (ResourceCollection) object;

   108         rc = (ResourceCollection) object;

   114     }

   109     }

   115 

   110 

   116     public Document createDOM() throws DocumentException, IOException {

   111     public Document createDOM() throws DocumentException, IOException {

   118         Element root = DocumentHelper.createElement("antDatabase");

   113         Element root = DocumentHelper.createElement("antDatabase");

   119         Document outDoc = DocumentHelper.createDocument(root);

   114         Document outDoc = DocumentHelper.createDocument(root);

   120         ArrayList<String> antFiles = getAntFiles(getProject(), homeFilesOnly);

   115         ArrayList<String> antFiles = getAntFiles(getProject(), homeFilesOnly);

   127             parseAntFile(root, antFile);

   120             parseAntFile(root, antFile);

   128         }

   121         }

   129 

   122 

   130         buildTaskDefs(root);

   123         buildTaskDefs(root);

   131 

   124 

   139             if (outputFile != null) {

   132             if (outputFile != null) {

   140                 outStream = new FileOutputStream(outputFile);

   133                 outStream = new FileOutputStream(outputFile);

   141             }

   134             }

   142             XMLWriter out = new XMLWriter(outStream, OutputFormat.createPrettyPrint());

   135             XMLWriter out = new XMLWriter(outStream, OutputFormat.createPrettyPrint());

   143             out.write(outDoc);

   136             out.write(outDoc);

   145             throw new BuildException(e.getMessage());

   139             throw new BuildException(e.getMessage());

   147             throw new BuildException(e.getMessage());

   142             throw new BuildException(e.getMessage());

   148         }

   143         }

   149     }

   144     }

   150 

   145 

   151     @SuppressWarnings("unchecked")

   146     @SuppressWarnings("unchecked")

   154         SAXReader xmlReader = new SAXReader();

   148         SAXReader xmlReader = new SAXReader();

   155         Document antDoc = xmlReader.read(new File(antFile));

   149         Document antDoc = xmlReader.read(new File(antFile));

   156 

   150 

   157         XPath xpath = DocumentHelper.createXPath("//hlm:signalListenerConfig");

   151         XPath xpath = DocumentHelper.createXPath("//hlm:signalListenerConfig");

   158         xpath.setNamespaceURIs(map);

   152         xpath.setNamespaceURIs(map);

   159         List<Element> signalNodes = xpath.selectNodes(antDoc);

   153         List<Element> signalNodes = xpath.selectNodes(antDoc);

   162             signaldoc = antDoc;

   155             signaldoc = antDoc;

   163             String signalid = propertyNode.attributeValue("id");

   156             String signalid = propertyNode.attributeValue("id");

   164 

   157 

   165             String signaltarget = propertyNode.attributeValue("target");

   158             String signaltarget = propertyNode.attributeValue("target");

   166             List<String> existinglist = globalSignalList.get(signaltarget);

   159             List<String> existinglist = globalSignalList.get(signaltarget);

   167             String failbuild = signalType(signalid, signaldoc);

   160             String failbuild = signalType(signalid, signaldoc);

   169                 existinglist = new ArrayList<String>();

   162                 existinglist = new ArrayList<String>();

   170             existinglist.add(signalid + "," + failbuild);

   164             existinglist.add(signalid + "," + failbuild);

   171             globalSignalList.put(signaltarget, existinglist);

   165             globalSignalList.put(signaltarget, existinglist);

   172         }

   166         }

   173     }

   167     }

   174 

   168 

   175     @SuppressWarnings("unchecked")

   169     @SuppressWarnings("unchecked")

   179         xpath2.setNamespaceURIs(map);

   173         xpath2.setNamespaceURIs(map);

   180         List<Element> signalNodes3 = xpath2.selectNodes(antDoc);

   174         List<Element> signalNodes3 = xpath2.selectNodes(antDoc);

   181 

   175 

   184             String signalinputid = propertyNode3.attributeValue("refid");

   177             String signalinputid = propertyNode3.attributeValue("refid");

   185 

   178 

   187             xpath3.setNamespaceURIs(map);

   181             xpath3.setNamespaceURIs(map);

   188             List<Element> signalNodes4 = xpath3.selectNodes(antDoc);

   182             List<Element> signalNodes4 = xpath3.selectNodes(antDoc);

   191                 return propertyNode4.attributeValue("failbuild");

   184                 return propertyNode4.attributeValue("failbuild");

   192             }

   185             }

   193         }

   186         }

   194         return null;

   187         return null;

   195     }

   188     }

   199      * @param antFile

   192      * @param antFile

   200      * @throws DocumentException

   193      * @throws DocumentException

   201      * @throws IOException

   194      * @throws IOException

   202      */

   195      */

   203     @SuppressWarnings("unchecked")

   196     @SuppressWarnings("unchecked")

   206         log("Processing Ant file: " + antFile, Project.MSG_DEBUG);

   198         log("Processing Ant file: " + antFile, Project.MSG_DEBUG);

   207         SAXReader xmlReader = new SAXReader();

   199         SAXReader xmlReader = new SAXReader();

   208         Document antDoc = xmlReader.read(new File(antFile));

   200         Document antDoc = xmlReader.read(new File(antFile));

   209 

   201 

   210         // Element targetElement =

   202         // Element targetElement =

   220         String description = antDoc.valueOf("/project/description");

   212         String description = antDoc.valueOf("/project/description");

   221         insertDocumentation(projectElement, description);

   213         insertDocumentation(projectElement, description);

   222 

   214 

   223         // descriptionElement.setText(description);

   215         // descriptionElement.setText(description);

   224 

   216 

   227             log("Project has no comment: " + projectName, Project.MSG_WARN);

   218             log("Project has no comment: " + projectName, Project.MSG_WARN);

   228         }

   219         }

   229 

   220 

   230         Element defaultElement = projectElement.addElement("default");

   221         Element defaultElement = projectElement.addElement("default");

   231         defaultElement.setText(antDoc.valueOf("/project/@default"));

   222         defaultElement.setText(antDoc.valueOf("/project/@default"));

   232 

   223 

   233         // Project import statements

   224         // Project import statements

   234         List importNodes = antDoc.selectNodes("//import");

   225         List importNodes = antDoc.selectNodes("//import");

   237             Element importCurrentNode = (Element) iterator.next();

   227             Element importCurrentNode = (Element) iterator.next();

   240         }

   229         }

   241 

   230 

   242         projectElement.addElement("pythonDependency");

   231         projectElement.addElement("pythonDependency");

   243 

   232 

   244         // Project exec statements

   233         // Project exec statements

   245         List<Element> execNodes = antDoc.selectNodes("//exec//arg");

   234         List<Element> execNodes = antDoc.selectNodes("//exec//arg");

   248             String argValue = argNode.attributeValue("value");

   236             String argValue = argNode.attributeValue("value");

   249 

   237 

   251                 argValue = argNode.attributeValue("line");

   239                 argValue = argNode.attributeValue("line");

   255                 Pattern filePattern = Pattern.compile(".pl|.py|.bat|.xml|.txt");

   243                 Pattern filePattern = Pattern.compile(".pl|.py|.bat|.xml|.txt");

   256                 Matcher fileMatcher = filePattern.matcher(argValue);

   244                 Matcher fileMatcher = filePattern.matcher(argValue);

   259                     addTextElement(projectElement, "fileDependency", argValue);

   246                     addTextElement(projectElement, "fileDependency", argValue);

   260                 }

   247                 }

   261             }

   248             }

   262         }

   249         }

   263 

   250 

   264         List<Element> targetNodes = antDoc.selectNodes("//target");

   251         List<Element> targetNodes = antDoc.selectNodes("//target");

   267             processTarget(targetNode, projectElement);

   253             processTarget(targetNode, projectElement);

   268         }

   254         }

   269 

   255 

   270         // Process macrodef and scriptdef tasks

   256         // Process macrodef and scriptdef tasks

   271         // TODO - maybe scriptdefs should be separate?

   257         // TODO - maybe scriptdefs should be separate?

   272         List macroNodes = antDoc.selectNodes("//macrodef | //scriptdef");

   258         List macroNodes = antDoc.selectNodes("//macrodef | //scriptdef");

   275             Element macroNode = (Element) iterator.next();

   260             Element macroNode = (Element) iterator.next();

   276             processMacro(macroNode, projectElement, antFile);

   261             processMacro(macroNode, projectElement, antFile);

   277         }

   262         }

   278 

   263 

   279         // Project properties

   264         // Project properties

   280         List propertyNodes = antDoc.selectNodes("//property");

   265         List propertyNodes = antDoc.selectNodes("//property");

   283             Element propertyNode = (Element) iterator.next();

   267             Element propertyNode = (Element) iterator.next();

   284             processProperty(propertyNode, projectElement);

   268             processProperty(propertyNode, projectElement);

   285         }

   269         }

   286     }

   270     }

   287 

   271 

   290         return getAntFiles(getProject(), true);

   273         return getAntFiles(getProject(), true);

   291     }

   274     }

   292 

   275 

   295         return getAntFiles(project, true);

   277         return getAntFiles(project, true);

   296     }

   278     }

   297 

   279 

   298     /**

   280     /**

   301      * 

   282      * 

   302      * @return antFiles a list of ant files to be processed

   283      * @return antFiles a list of ant files to be processed

   303      */

   284      */

   304     @SuppressWarnings("unchecked")

   285     @SuppressWarnings("unchecked")

   307         ArrayList<String> antFiles = new ArrayList<String>();

   287         ArrayList<String> antFiles = new ArrayList<String>();

   308 

   288 

   309         Map<String, Target> targets = project.getTargets();

   289         Map<String, Target> targets = project.getTargets();

   310         Iterator<Target> targetsIter = targets.values().iterator();

   290         Iterator<Target> targetsIter = targets.values().iterator();

   311 

   291 

   312         String projectHome = null;

   292         String projectHome = null;

   313         try {

   293         try {

   314             projectHome = new File(project.getProperty("helium.dir")).getCanonicalPath();

   294             projectHome = new File(project.getProperty("helium.dir")).getCanonicalPath();

   315 

   295 

   318                 Target target = targetsIter.next();

   297                 Target target = targetsIter.next();

   319                 String projectPath = new File(target.getLocation().getFileName()).getCanonicalPath();

   298                 String projectPath = new File(target.getLocation().getFileName()).getCanonicalPath();

   320 

   299 

   327                             antFiles.add(projectPath);

   303                             antFiles.add(projectPath);

   328                         }

   304                         }

   329                     }

   307                     }

   332                 }

   308                 }

   333             }

   309             }

   334 

   310 

   337                 Iterator extraFilesIter = rc.iterator();

   312                 Iterator extraFilesIter = rc.iterator();

   340                     FileResource fileResource = (FileResource) extraFilesIter.next();

   314                     FileResource fileResource = (FileResource) extraFilesIter.next();

   341                     String extrafile = fileResource.getFile().getCanonicalPath();

   315                     String extrafile = fileResource.getFile().getCanonicalPath();

   342 

   316 

   349                                 antFiles.add(extrafile);

   321                                 antFiles.add(extrafile);

   350                             }

   322                             }

   351                         }

   323                         }

   353                             antFiles.add(extrafile);

   325                             antFiles.add(extrafile);

   354                     }

   327                     }

   355                 }

   328                 }

   356             }

   329             }

   357 

   330 

   360             e.printStackTrace();

   334             e.printStackTrace();

   361         }

   335         }

   362         return antFiles;

   336         return antFiles;

   363     }

   337     }

   364 

   338 

   366 

   340 

   367     @SuppressWarnings("unchecked")

   341     @SuppressWarnings("unchecked")

   368     private void processMacro(Element macroNode, Element outProjectNode, String antFile)

   342     private void processMacro(Element macroNode, Element outProjectNode, String antFile)

   371         String macroName = macroNode.attributeValue("name");

   344         String macroName = macroNode.attributeValue("name");

   372         log("Processing macro: " + macroName, Project.MSG_DEBUG);

   345         log("Processing macro: " + macroName, Project.MSG_DEBUG);

   373 

   346 

   374         Element outmacroNode = outProjectNode.addElement("macro");

   347         Element outmacroNode = outProjectNode.addElement("macro");

   375         addTextElement(outmacroNode, "name", macroNode.attributeValue("name"));

   348         addTextElement(outmacroNode, "name", macroNode.attributeValue("name"));

   387         // Add the location with just the file path for now and a dummy line

   360         // Add the location with just the file path for now and a dummy line

   388         // number.

   361         // number.

   389         // TODO - Later we should find the line number from the XML input.

   362         // TODO - Later we should find the line number from the XML input.

   390         addTextElement(outmacroNode, "location", antFile + ":1:");

   363         addTextElement(outmacroNode, "location", antFile + ":1:");

   391 

   364 

   393         String usage = "";

   367         String usage = "";

   396             String defaultval = statement.valueOf("@default");

   369             String defaultval = statement.valueOf("@default");

   398                 defaultval = "value";

   371                 defaultval = "value";

   400                 defaultval = "<i>" + defaultval + "</i>";

   373                 defaultval = "<i>" + defaultval + "</i>";

   401             usage = usage + " " + statement.valueOf("@name") + "=\"" + defaultval + "\"";

   375             usage = usage + " " + statement.valueOf("@name") + "=\"" + defaultval + "\"";

   402         }

   376         }

   403 

   377 

   404         String macroElements = "";

   378         String macroElements = "";

   408             macroElements = "<" + statement.valueOf("@name") + "/>\n" + macroElements;

   382             macroElements = "<" + statement.valueOf("@name") + "/>\n" + macroElements;

   409         }

   383         }

   411             addTextElement(outmacroNode, "usage", "<hlm:" + macroName + " " + usage + "/>");

   385             addTextElement(outmacroNode, "usage", "<hlm:" + macroName + " " + usage + "/>");

   415 

   390 

   416         // Add dependencies

   391         // Add dependencies

   417         // Enumeration dependencies = antmacro.getDependencies();

   392         // Enumeration dependencies = antmacro.getDependencies();

   418         // while (dependencies.hasMoreElements())

   393         // while (dependencies.hasMoreElements())

   419         // {

   394         // {

   421         // Element dependencyElement = addTextElement(outmacroNode,

   396         // Element dependencyElement = addTextElement(outmacroNode,

   422         // "dependency", dependency);

   397         // "dependency", dependency);

   423         // dependencyElement.addAttribute("type","direct");

   398         // dependencyElement.addAttribute("type","direct");

   424         // }

   399         // }

   425 

   400 

   427 

   402 

   428         // Add documentation

   403         // Add documentation

   429         // Get comment element before the macro element to extract macro doc

   404         // Get comment element before the macro element to extract macro doc

   430         List<Node> children = macroNode.selectNodes("preceding-sibling::node()");

   405         List<Node> children = macroNode.selectNodes("preceding-sibling::node()");

   433             // Scan past the text nodes, which are most likely whitespace

   407             // Scan past the text nodes, which are most likely whitespace

   434             int index = children.size() - 1;

   408             int index = children.size() - 1;

   435             Node child = (Node) children.get(index);

   409             Node child = (Node) children.get(index);

   438                 index--;

   411                 index--;

   439                 child = (Node) children.get(index);

   412                 child = (Node) children.get(index);

   440             }

   413             }

   441 

   414 

   442             // Check if there is a comment node

   415             // Check if there is a comment node

   443             String commentText = null;

   416             String commentText = null;

   446                 Comment macroComment = (Comment) child;

   418                 Comment macroComment = (Comment) child;

   447                 commentText = macroComment.getStringValue().trim();

   419                 commentText = macroComment.getStringValue().trim();

   448                 log(macroName + " comment: " + commentText, Project.MSG_DEBUG);

   420                 log(macroName + " comment: " + commentText, Project.MSG_DEBUG);

   449             }

   421             }

   452                 log("Macro has no comment: " + macroName, Project.MSG_WARN);

   423                 log("Macro has no comment: " + macroName, Project.MSG_WARN);

   453             }

   424             }

   454 

   425 

   455             insertDocumentation(outmacroNode, commentText);

   426             insertDocumentation(outmacroNode, commentText);

   458         }

   427         }

   459 

   428 

   460         // Get names of all properties used in this macro

   429         // Get names of all properties used in this macro

   461         ArrayList properties = new ArrayList();

   430         ArrayList properties = new ArrayList();

   462         Visitor visitor = new AntPropertyVisitor(properties);

   431         Visitor visitor = new AntPropertyVisitor(properties);

   463         macroNode.accept(visitor);

   432         macroNode.accept(visitor);

   466             String property = (String) iterator.next();

   434             String property = (String) iterator.next();

   467             addTextElement(outmacroNode, "propertyDependency", property);

   435             addTextElement(outmacroNode, "propertyDependency", property);

   468         }

   436         }

   469     }

   437     }

   470 

   438 

   473         // Add antcall/runtarget dependencies

   440         // Add antcall/runtarget dependencies

   474         ArrayList<String> antcallTargets = new ArrayList<String>();

   441         ArrayList<String> antcallTargets = new ArrayList<String>();

   475         ArrayList<String> logs = new ArrayList<String>();

   442         ArrayList<String> logs = new ArrayList<String>();

   476         ArrayList<String> signals = new ArrayList<String>();

   443         ArrayList<String> signals = new ArrayList<String>();

   477         ArrayList<String> executables = new ArrayList<String>();

   444         ArrayList<String> executables = new ArrayList<String>();

   478         Visitor visitorTarget = new AntTargetVisitor(antcallTargets, logs, signals, executables);

   445         Visitor visitorTarget = new AntTargetVisitor(antcallTargets, logs, signals, executables);

   479         targetNode.accept(visitorTarget);

   446         targetNode.accept(visitorTarget);

   482             Element dependencyElement = addTextElement(outTargetNode, "dependency", antcallTarget);

   448             Element dependencyElement = addTextElement(outTargetNode, "dependency", antcallTarget);

   483             dependencyElement.addAttribute("type", "exec");

   449             dependencyElement.addAttribute("type", "exec");

   484         }

   450         }

   485 

   451 

   488             addTextElement(outTargetNode, "log", log);

   453             addTextElement(outTargetNode, "log", log);

   489         }

   454         }

   490 

   455 

   492             signals.addAll(globalSignalList.get(targetNode.attributeValue("name")));

   457             signals.addAll(globalSignalList.get(targetNode.attributeValue("name")));

   496             addTextElement(outTargetNode, "signal", signal);

   461             addTextElement(outTargetNode, "signal", signal);

   497         }

   462         }

   498 

   463 

   501             addTextElement(outTargetNode, "executable", executable);

   465             addTextElement(outTargetNode, "executable", executable);

   502         }

   466         }

   503     }

   467     }

   504 

   468 

   505     @SuppressWarnings("unchecked")

   469     @SuppressWarnings("unchecked")

   508         String targetName = targetNode.attributeValue("name");

   472         String targetName = targetNode.attributeValue("name");

   509         log("Processing target: " + targetName, Project.MSG_DEBUG);

   473         log("Processing target: " + targetName, Project.MSG_DEBUG);

   510 

   474 

   511         // Add documentation

   475         // Add documentation

   512         // Get comment element before the target element to extract target doc

   476         // Get comment element before the target element to extract target doc

   513         String commentText = "";

   477         String commentText = "";

   514         List<Node> children = targetNode.selectNodes("preceding-sibling::node()");

   478         List<Node> children = targetNode.selectNodes("preceding-sibling::node()");

   517             // Scan past the text nodes, which are most likely whitespace

   480             // Scan past the text nodes, which are most likely whitespace

   518             int index = children.size() - 1;

   481             int index = children.size() - 1;

   519             Node child = children.get(index);

   482             Node child = children.get(index);

   522                 index--;

   484                 index--;

   523                 child = (Node) children.get(index);

   485                 child = (Node) children.get(index);

   524             }

   486             }

   525 

   487 

   526             // Check if there is a comment node

   488             // Check if there is a comment node

   529                 Comment targetComment = (Comment) child;

   490                 Comment targetComment = (Comment) child;

   530                 commentText = targetComment.getStringValue().trim();

   491                 commentText = targetComment.getStringValue().trim();

   531 

   492 

   532                 log(targetName + " comment: " + commentText, Project.MSG_DEBUG);

   493                 log(targetName + " comment: " + commentText, Project.MSG_DEBUG);

   533             }

   494             }

   536                 log("Target has no comment: " + targetName, Project.MSG_WARN);

   496                 log("Target has no comment: " + targetName, Project.MSG_WARN);

   537             }

   497             }

   544             Element outTargetNode = outProjectNode.addElement("target");

   501             Element outTargetNode = outProjectNode.addElement("target");

   545 

   502 

   546             addTextElement(outTargetNode, "name", targetNode.attributeValue("name"));

   503             addTextElement(outTargetNode, "name", targetNode.attributeValue("name"));

   547             addTextElement(outTargetNode, "ifDependency", targetNode.attributeValue("if"));

   504             addTextElement(outTargetNode, "ifDependency", targetNode.attributeValue("if"));

   548             addTextElement(outTargetNode, "unlessDependency", targetNode.attributeValue("unless"));

   505             addTextElement(outTargetNode, "unlessDependency", targetNode.attributeValue("unless"));

   551 

   508 

   552             // Add location

   509             // Add location

   553             Project project = getProject();

   510             Project project = getProject();

   554             Target antTarget = (Target) project.getTargets().get(targetName);

   511             Target antTarget = (Target) project.getTargets().get(targetName);

   555 

   512 

   557                 return;

   514                 return;

   558 

   516 

   559             addTextElement(outTargetNode, "location", antTarget.getLocation().toString());

   517             addTextElement(outTargetNode, "location", antTarget.getLocation().toString());

   560 

   518 

   561             // Add dependencies

   519             // Add dependencies

   562             Enumeration dependencies = antTarget.getDependencies();

   520             Enumeration dependencies = antTarget.getDependencies();

   565                 String dependency = (String) dependencies.nextElement();

   522                 String dependency = (String) dependencies.nextElement();

   566                 Element dependencyElement = addTextElement(outTargetNode, "dependency", dependency);

   523                 Element dependencyElement = addTextElement(outTargetNode, "dependency", dependency);

   567                 dependencyElement.addAttribute("type", "direct");

   524                 dependencyElement.addAttribute("type", "direct");

   568             }

   525             }

   569 

   526 

   571 

   528 

   572             // Process the comment text as MediaWiki syntax and convert to HTML

   529             // Process the comment text as MediaWiki syntax and convert to HTML

   573             insertDocumentation(outTargetNode, commentText);

   530             insertDocumentation(outTargetNode, commentText);

   574 

   531 

   575             // Get names of all properties used in this target

   532             // Get names of all properties used in this target

   576             ArrayList properties = new ArrayList();

   533             ArrayList properties = new ArrayList();

   577             Visitor visitor = new AntPropertyVisitor(properties);

   534             Visitor visitor = new AntPropertyVisitor(properties);

   578             targetNode.accept(visitor);

   535             targetNode.accept(visitor);

   581                 String property = (String) iterator.next();

   537                 String property = (String) iterator.next();

   582                 addTextElement(outTargetNode, "propertyDependency", property);

   538                 addTextElement(outTargetNode, "propertyDependency", property);

   583             }

   539             }

   584 

   540 

   585             // Add the raw XML content of the element

   541             // Add the raw XML content of the element

   589 

   545 

   590             addTextElement(outTargetNode, "source", targetXml, true);

   546             addTextElement(outTargetNode, "source", targetXml, true);

   591         }

   547         }

   592     }

   548     }

   593 

   549 

   596         String propertyName = propertyNode.attributeValue("name");

   551         String propertyName = propertyNode.attributeValue("name");

   597         log("Processing Property: " + propertyName, Project.MSG_DEBUG);

   552         log("Processing Property: " + propertyName, Project.MSG_DEBUG);

   598 

   553 

   599         Element outPropertyNode = outProjectNode.addElement("property");

   554         Element outPropertyNode = outProjectNode.addElement("property");

   600         addTextElement(outPropertyNode, "name", propertyNode.attributeValue("name"));

   555         addTextElement(outPropertyNode, "name", propertyNode.attributeValue("name"));

   603             addTextElement(outPropertyNode, "defaultValue", propertyNode.attributeValue("location"));

   557             addTextElement(outPropertyNode, "defaultValue", propertyNode.attributeValue("location"));

   604         }

   558         }

   607             addTextElement(outPropertyNode, "defaultValue", propertyNode.attributeValue("value"));

   560             addTextElement(outPropertyNode, "defaultValue", propertyNode.attributeValue("value"));

   608         }

   561         }

   609     }

   562     }

   610 

   563 

   615             WikiModel wikiModel = new WikiModel("", "");

   567             WikiModel wikiModel = new WikiModel("", "");

   618                 commentText = commentText.replace("**", "").replace("==", "").replace("- -", "").trim();

   570                 commentText = commentText.replace("**", "").replace("==", "").replace("- -", "").trim();

   619                 log("Warning: Comment code has invalid syntax: " + commentText, Project.MSG_WARN);

   571                 log("Warning: Comment code has invalid syntax: " + commentText, Project.MSG_WARN);

   620             }

   572             }

   622                 commentText = commentText.replace("-", "");

   574                 commentText = commentText.replace("-", "");

   623             commentText = commentText.trim();

   576             commentText = commentText.trim();

   624 

   577 

   625             String commentTextCheck = commentText.replace("deprecated>", "").replace("tt>", "").replace("todo>", "");

   578             String commentTextCheck = commentText.replace("deprecated>", "").replace("tt>", "").replace("todo>", "");

   627                 log("Warning: Comment code needs <pre> tags around it: " + commentText, Project.MSG_WARN);

   580                 log("Warning: Comment code needs <pre> tags around it: " + commentText, Project.MSG_WARN);

   628 

   582 

   629             commentText = filterTextNewlines(commentText);

   583             commentText = filterTextNewlines(commentText);

   630             commentText = wikiModel.render(commentText);

   584             commentText = wikiModel.render(commentText);

   631 

   585 

   632             // If <deprecated> tag exists in the comment, then parse the

   586             // If <deprecated> tag exists in the comment, then parse the

   633             // deprecated message.

   587             // deprecated message.

   636                 int deprecatedMsgStart = commentText.indexOf("<deprecated>") + 20;

   589                 int deprecatedMsgStart = commentText.indexOf("<deprecated>") + 20;

   637                 int deprecatedMsgEnd = commentText.indexOf("</deprecated>");

   590                 int deprecatedMsgEnd = commentText.indexOf("</deprecated>");

   638 

   591 

   639                 // Add deprecated element.

   592                 // Add deprecated element.

   640                 String deprecatedMsg = commentText.substring(deprecatedMsgStart, deprecatedMsgEnd);

   593                 String deprecatedMsg = commentText.substring(deprecatedMsgStart, deprecatedMsgEnd);

   641                 addTextElement(outNode, "deprecated", deprecatedMsg);

   594                 addTextElement(outNode, "deprecated", deprecatedMsg);

   642 

   595 

   643                 // remove <deprecated> part from description field.

   596                 // remove <deprecated> part from description field.

   644                 int commentTextLength = commentText.length();

   597                 int commentTextLength = commentText.length();

   645                 String documentationMsgStart = commentText.substring(1, deprecatedMsgStart - 20);

   598                 String documentationMsgStart = commentText.substring(1, deprecatedMsgStart - 20);

   648                 String documentationMsg = documentationMsgStart.concat(documentationMsgEnd);

   600                 String documentationMsg = documentationMsgStart.concat(documentationMsgEnd);

   649                 commentText = documentationMsg.trim();

   601                 commentText = documentationMsg.trim();

   650             }

   602             }

   651         }

   603         }

   654             commentText = "";

   605             commentText = "";

   655         }

   606         }

   656         // Get the documentation element as a document

   607         // Get the documentation element as a document

   659         Document docDoc = DocumentHelper.parseText(documentationText);

   609         Document docDoc = DocumentHelper.parseText(documentationText);

   660         outNode.add(docDoc.getRootElement());

   610         outNode.add(docDoc.getRootElement());

   661         log("HTML comment: " + commentText, Project.MSG_DEBUG);

   611         log("HTML comment: " + commentText, Project.MSG_DEBUG);

   662     }

   612     }

   663 

   613 

   666         Element element = addTextElement(parent, name, text, false);

   615         Element element = addTextElement(parent, name, text, false);

   667 

   616 

   668         return element;

   617         return element;

   669     }

   618     }

   670 

   619 

   673         Element element = parent.addElement(name);

   621         Element element = parent.addElement(name);

   678                 element.addCDATA(text);

   624                 element.addCDATA(text);

   679             }

   625             }

   682                 element.setText(text);

   627                 element.setText(text);

   683             }

   628             }

   684         }

   629         }

   685         return element;

   630         return element;

   686     }

   631     }

   687 

   632 

   690         BufferedReader in = new BufferedReader(new StringReader(text));

   634         BufferedReader in = new BufferedReader(new StringReader(text));

   691         StringBuilder out = new StringBuilder();

   635         StringBuilder out = new StringBuilder();

   692         String line = in.readLine();

   636         String line = in.readLine();

   695             out.append(line.trim());

   638             out.append(line.trim());

   696             out.append("\n");

   639             out.append("\n");

   697             line = in.readLine();

   640             line = in.readLine();

   698         }

   641         }

   699         return out.toString();

   642         return out.toString();

   703      * Method adds taskdef nodes to the specified project.

   646      * Method adds taskdef nodes to the specified project.

   704      * 

   647      * 

   705      * @param outProjectNode

   648      * @param outProjectNode

   706      * @throws IOException

   649      * @throws IOException

   707      */

   650      */

   710         Element projectElement = root.addElement("project");

   652         Element projectElement = root.addElement("project");

   711         projectElement.addElement("name");

   653         projectElement.addElement("name");

   712         insertDocumentation(projectElement, "");

   654         insertDocumentation(projectElement, "");

   717             log("Processing TaskDef: " + taskName, Project.MSG_DEBUG);

   659             log("Processing TaskDef: " + taskName, Project.MSG_DEBUG);

   718 

   660 

   719             Element outTaskDefNode = projectElement.addElement("taskdef");

   661             Element outTaskDefNode = projectElement.addElement("taskdef");

   722         }

   664         }

   723     }

   665     }

   724 

   666 

   725     /**

   667     /**

   726      * Method returns all the helium ant tasks in the project.

   668      * Method returns all the helium ant tasks in the project.

   727      * 

   669      * 

   728      * @return

   670      * @return

   729      */

   671      */

   730     @SuppressWarnings("unchecked")

   672     @SuppressWarnings("unchecked")

   732 

   674 

   733         // 1. Get all the task definitions from the project

   675         // 1. Get all the task definitions from the project

   735         // 2. Filter the list by applying criteria

   677         // 2. Filter the list by applying criteria

   737     }

   679     }

   738 

   680 

   739     /**

   681     /**

   741      * 

   683      * 

   742      * @param allTaskdefs

   684      * @param allTaskdefs

   743      * @param criteria

   685      * @param criteria

   744      */

   686      */

   750             String key = taskdefsenum.nextElement();

   692             String key = taskdefsenum.nextElement();

   751             Class<?> clazz = allTaskdefs.get(key);

   693             Class<?> clazz = allTaskdefs.get(key);

   752             String className = clazz.getName();

   694             String className = clazz.getName();

   756             }

   698             }

   757         }

   699         }

   758         return tasks;

   700         return tasks;

   759     }

   701     }

   760 

   702 

   762      * Returns the task name delimiting the helium namespace.

   704      * Returns the task name delimiting the helium namespace.

   763      * 

   705      * 

   764      * @param text

   706      * @param text

   765      * @return

   707      * @return

   766      */

   708      */

   768         int lastIndex = text.lastIndexOf(':');

   710         int lastIndex = text.lastIndexOf(':');

   776         private List<String> propertyList;

   717         private List<String> propertyList;

   777 

   718 

   780             this.propertyList = propertyList;

   720             this.propertyList = propertyList;

   781         }

   721         }

   782 

   722 

   785             String text = node.getStringValue();

   724             String text = node.getStringValue();

   786             extractUsedProperties(text);

   725             extractUsedProperties(text);

   787         }

   726         }

   788 

   727 

   791             String text = node.getText();

   729             String text = node.getText();

   792             extractUsedProperties(text);

   730             extractUsedProperties(text);

   793         }

   731         }

   794 

   732 

   797             String text = node.getText();

   734             String text = node.getText();

   798             extractUsedProperties(text);

   735             extractUsedProperties(text);

   799         }

   736         }

   800 

   737 

   805                 String propertyName = node.attributeValue("name");

   740                 String propertyName = node.attributeValue("name");

   808                     propertyList.add(propertyName);

   742                     propertyList.add(propertyName);

   809                     log("property matches :" + propertyName, Project.MSG_DEBUG);

   743                     log("property matches :" + propertyName, Project.MSG_DEBUG);

   810                 }

   744                 }

   811             }

   745             }

   812         }

   746         }

   813 

   747 

   816             Pattern p1 = Pattern.compile("\\$\\{([^@$}]*)\\}");

   749             Pattern p1 = Pattern.compile("\\$\\{([^@$}]*)\\}");

   817             Matcher m1 = p1.matcher(text);

   750             Matcher m1 = p1.matcher(text);

   818             log(text, Project.MSG_DEBUG);

   751             log(text, Project.MSG_DEBUG);

   821                 String group = m1.group(1);

   753                 String group = m1.group(1);

   824                     propertyList.add(group);

   755                     propertyList.add(group);

   825                 }

   756                 }

   826                 log("property matches: " + group, Project.MSG_DEBUG);

   757                 log("property matches: " + group, Project.MSG_DEBUG);

   827             }

   758             }

   828 

   759 

   829             Pattern p2 = Pattern.compile("\\$\\{([^\n]*\\})\\}");

   760             Pattern p2 = Pattern.compile("\\$\\{([^\n]*\\})\\}");

   830             Matcher m2 = p2.matcher(text);

   761             Matcher m2 = p2.matcher(text);

   831             log(text, Project.MSG_DEBUG);

   762             log(text, Project.MSG_DEBUG);

   834                 String group = m2.group(1);

   764                 String group = m2.group(1);

   837                     propertyList.add(group);

   766                     propertyList.add(group);

   838                 }

   767                 }

   839                 log("property matches: " + group, Project.MSG_DEBUG);

   768                 log("property matches: " + group, Project.MSG_DEBUG);

   840             }

   769             }

   841 

   770 

   842             Pattern p3 = Pattern.compile("\\$\\{(\\@\\{[^\n]*)\\}");

   771             Pattern p3 = Pattern.compile("\\$\\{(\\@\\{[^\n]*)\\}");

   843             Matcher m3 = p3.matcher(text);

   772             Matcher m3 = p3.matcher(text);

   844             log(text, Project.MSG_DEBUG);

   773             log(text, Project.MSG_DEBUG);

   847                 String group = m3.group(1);

   775                 String group = m3.group(1);

   850                     propertyList.add(group);

   777                     propertyList.add(group);

   851                 }

   778                 }

   852                 log("property matches: " + group, Project.MSG_DEBUG);

   779                 log("property matches: " + group, Project.MSG_DEBUG);

   853             }

   780             }

   854         }

   781         }

   855     }

   782     }

   856 

   783 

   859         private List<String> targetList;

   785         private List<String> targetList;

   860         private List<String> logList;

   786         private List<String> logList;

   861         private List<String> signalList;

   787         private List<String> signalList;

   862         private List<String> executableList;

   788         private List<String> executableList;

   863 

   789 

   866             this.targetList = targetList;

   792             this.targetList = targetList;

   867             this.logList = logList;

   793             this.logList = logList;

   868             this.signalList = signalList;

   794             this.signalList = signalList;

   869             this.executableList = executableList;

   795             this.executableList = executableList;

   870         }

   796         }

   871 

   797 

   874             String name = node.getName();

   799             String name = node.getName();

   877                 String text = node.attributeValue("target");

   801                 String text = node.attributeValue("target");

   878                 extractTarget(text);

   802                 extractTarget(text);

   879             }

   803             }

   880 

   804 

   883                 String text = node.attributeValue("name");

   806                 String text = node.attributeValue("name");

   884                 addLog(text);

   807                 addLog(text);

   885                 text = node.attributeValue("output");

   808                 text = node.attributeValue("output");

   886                 addLog(text);

   809                 addLog(text);

   887                 text = node.attributeValue("value");

   810                 text = node.attributeValue("value");

   892                 addLog(text);

   815                 addLog(text);

   893                 text = node.attributeValue("file");

   816                 text = node.attributeValue("file");

   894                 addLog(text);

   817                 addLog(text);

   895             }

   818             }

   896 

   819 

   899                 String signalid = getProject().replaceProperties(node.attributeValue("name"));

   821                 String signalid = getProject().replaceProperties(node.attributeValue("name"));

   900                 String failbuild = signalType(signalid, signaldoc);

   822                 String failbuild = signalType(signalid, signaldoc);

   901 

   823 

   905                         signalList.add(signalid + "," + failbuild);

   826                         signalList.add(signalid + "," + failbuild);

   907                         signalList.add(signalid);

   828                         signalList.add(signalid);

   908                 }

   830                 }

   909             }

   831             }

   910 

   832 

   913                 String text = node.attributeValue("executable");

   834                 String text = node.attributeValue("executable");

   914                 executableList.add(text);

   835                 executableList.add(text);

   915                 log("Executable: " + text, Project.MSG_DEBUG);

   836                 log("Executable: " + text, Project.MSG_DEBUG);

   916             }

   837             }

   917         }

   838         }

   918 

   839 

   925                     String fulllogname = getProject().replaceProperties(log);

   843                     String fulllogname = getProject().replaceProperties(log);

   928                         log = log.replace("--log=", "");

   846                         log = log.replace("--log=", "");

   929                         logList.add(log);

   847                         logList.add(log);

   930                     }

   848                     }

   931                 }

   849                 }

   932             }

   850             }

   933         }

   851         }

   934 

   852 

   937             String iText = getProject().replaceProperties(text);

   854             String iText = getProject().replaceProperties(text);

   938             targetList.add(iText);

   855             targetList.add(iText);

   939         }

   856         }

   940 

   857 

   941     }

   858     }

   942 }

   859 }