Coverage report

  %line %branch
org.apache.commons.jelly.util.CommandLineParser$1
0% 
0% 

 1  
 /*
 2  
  * Copyright 2002,2004 The Apache Software Foundation.
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *      http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 
 17  
 package org.apache.commons.jelly.util;
 18  
 
 19  
 import java.io.File;
 20  
 import java.io.FileWriter;
 21  
 import java.net.URL;
 22  
 import java.util.Arrays;
 23  
 import java.util.ArrayList;
 24  
 import java.util.List;
 25  
 import java.util.Properties;
 26  
 
 27  
 import org.apache.commons.cli.CommandLine;
 28  
 import org.apache.commons.cli.Options;
 29  
 import org.apache.commons.cli.ParseException;
 30  
 import org.apache.commons.cli.Parser;
 31  
 import org.apache.commons.cli.HelpFormatter;
 32  
 import org.apache.commons.jelly.Jelly;
 33  
 import org.apache.commons.jelly.JellyContext;
 34  
 import org.apache.commons.jelly.JellyException;
 35  
 import org.apache.commons.jelly.Script;
 36  
 import org.apache.commons.jelly.XMLOutput;
 37  
 
 38  
 /**
 39  
  * Utility class to parse command line options using CLI.
 40  
  * Using a separate class allows us to run Jelly without
 41  
  * CLI in the classpath when the command line interface
 42  
  * is not in use.
 43  
  *
 44  
  * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
 45  
  * @author Morgan Delagrange
 46  
  * @version $Revision: 155420 $
 47  
  */
 48  
 public class CommandLineParser {
 49  
 
 50  
     protected static CommandLineParser _instance = new CommandLineParser();
 51  
     
 52  
     private Options cmdLineOptions = null;
 53  
 
 54  
     public static CommandLineParser getInstance() {
 55  
         return _instance;
 56  
     }
 57  
 
 58  
     /**
 59  
      * Parse out the command line options and configure
 60  
      * the give Jelly instance.
 61  
      *
 62  
      * @param args   options from the command line
 63  
      * @exception JellyException
 64  
      *                   if the command line could not be parsed
 65  
      */
 66  
     public void invokeCommandLineJelly(String[] args) throws JellyException {
 67  
         CommandLine cmdLine = null;
 68  
         try {
 69  
             cmdLine = parseCommandLineOptions(args);
 70  
         } catch (ParseException e) {
 71  
             throw new JellyException(e);
 72  
         }
 73  
         
 74  
         // check for -h or -v
 75  
         if (cmdLine.hasOption("h")) {
 76  
             new HelpFormatter().printHelp("jelly [scriptFile] [-script scriptFile] [-o outputFile] [-Dsysprop=syspropval] [-awt]",
 77  
                 cmdLineOptions);
 78  
             System.exit(1);
 79  
         }
 80  
         if (cmdLine.hasOption("v")) {
 81  
             System.err.println("Jelly " + Jelly.getJellyVersion());
 82  
             System.err.println(" compiled: " + Jelly.getJellyBuildDate());
 83  
             System.err.println("");
 84  
             System.exit(1);
 85  
         }
 86  
 
 87  
         // get the -script option. If there isn't one then use args[0]
 88  
         String scriptFile = null;
 89  
         if (cmdLine.hasOption("script")) {
 90  
             scriptFile = cmdLine.getOptionValue("script");
 91  
         } else {
 92  
             scriptFile = args[0];
 93  
         }
 94  
         
 95  
         // check the -awt option.
 96  
         boolean runInSwingThread = cmdLine.hasOption("awt") || cmdLine.hasOption("swing");
 97  
 
 98  
         //
 99  
         // Use classloader to find file
 100  
         //
 101  
         URL url = ClassLoaderUtils.getClassLoader(getClass()).getResource(scriptFile);
 102  
         // check if the script file exists
 103  
         if (url == null && !(new File(scriptFile)).exists()) {
 104  
             throw new JellyException("Script file " + scriptFile + " not found");
 105  
         }
 106  
 
 107  
         try {
 108  
             // extract the -o option for the output file to use
 109  
             final XMLOutput output = cmdLine.hasOption("o") ?
 110  
                     XMLOutput.createXMLOutput(new FileWriter(cmdLine.getOptionValue("o"))) :
 111  
                     XMLOutput.createXMLOutput(System.out);
 112  
 
 113  
             Jelly jelly = new Jelly();
 114  
             jelly.setScript(scriptFile);
 115  
 
 116  
             final Script script = jelly.compileScript();
 117  
 
 118  
             // add the system properties and the command line arguments
 119  
             final JellyContext context = jelly.getJellyContext();
 120  
             context.setVariable("args", args);
 121  
             context.setVariable("commandLine", cmdLine);
 122  
             if (runInSwingThread) {
 123  0
                 javax.swing.SwingUtilities.invokeAndWait(new Runnable() { public void run() {
 124  
                     try {
 125  0
                         script.run(context, output);
 126  0
                     } catch (Exception ex) {
 127  0
                         ex.printStackTrace();
 128  0
                     }
 129  0
             } } ); } else {
 130  
                 script.run(context, output);
 131  
             }
 132  
 
 133  
             // now lets wait for all threads to close
 134  
             Runtime.getRuntime().addShutdownHook(new Thread() {
 135  
                     public void run() {
 136  
                         try {
 137  
                             output.close();
 138  
                         }
 139  
                         catch (Exception e) {
 140  
                             // ignore errors
 141  
                         }
 142  
                     }
 143  
                 }
 144  
             );
 145  
 
 146  
         } catch (Exception e) {
 147  
             throw new JellyException(e);
 148  
         }
 149  
 
 150  
     }
 151  
 
 152  
     /**
 153  
      * Parse the command line using CLI. -o and -script are reserved for Jelly.
 154  
      * -Dsysprop=sysval is support on the command line as well.
 155  
      */
 156  
     public CommandLine parseCommandLineOptions(String[] args) throws ParseException {
 157  
         // create the expected options
 158  
         cmdLineOptions = new Options();
 159  
         cmdLineOptions.addOption("o", true, "Output file");
 160  
         cmdLineOptions.addOption("script", true, "Jelly script to run");
 161  
         cmdLineOptions.addOption("h","help", false, "Give this help message");
 162  
         cmdLineOptions.addOption("v","version", false, "prints Jelly's version and exits");
 163  
         cmdLineOptions.addOption("script", true, "Jelly script to run");
 164  
         cmdLineOptions.addOption("awt", false, "Wether to run in the AWT thread.");
 165  
         cmdLineOptions.addOption("swing", false, "Synonym of \"-awt\".");
 166  
         List builtinOptionNames = Arrays.asList(new String[]{
 167  
             "-o","-script","-h","--help","-v","--version","-awt","-swing"});
 168  
         
 169  
         // -D options will be added to the system properties
 170  
         Properties sysProps = System.getProperties();
 171  
 
 172  
         // filter the system property setting from the arg list
 173  
         // before passing it to the CLI parser
 174  
         ArrayList filteredArgList = new ArrayList();
 175  
 
 176  
         for (int i=0;i<args.length;i++) {
 177  
             String arg = args[i];
 178  
 
 179  
             // if this is a -D property parse it and add it to the system properties.
 180  
             // -D args will not be copied into the filteredArgList.
 181  
             if (arg.startsWith("-D") && (arg.length() > 2)) {
 182  
                 arg = arg.substring(2);
 183  
                 int ePos = arg.indexOf("=");
 184  
                 if(ePos==-1 || ePos==0 || ePos==arg.length()-1)
 185  
                     System.err.println("Invalid system property: \"" + arg + "\".");
 186  
                 sysProps.setProperty(arg.substring(0,ePos), arg.substring(ePos+1));
 187  
             } else {
 188  
                 // add this to the filtered list of arguments
 189  
                 filteredArgList.add(arg);
 190  
 
 191  
                 // add additional "-?" options to the options object. if this is not done
 192  
                 // the only options allowed would be the builtin-ones.
 193  
                 if (arg.startsWith("-") && arg.length() > 1) {
 194  
                     if (!(builtinOptionNames.contains(arg))) {
 195  
                         cmdLineOptions.addOption(arg.substring(1, arg.length()), true, "dynamic option");
 196  
                     }
 197  
                 }
 198  
             }
 199  
         }
 200  
 
 201  
         // make the filteredArgList into an array
 202  
         String[] filterArgs = new String[filteredArgList.size()];
 203  
         filteredArgList.toArray(filterArgs);
 204  
 
 205  
         // parse the command line
 206  
         Parser parser = new org.apache.commons.cli.GnuParser();
 207  
         return parser.parse(cmdLineOptions, filterArgs);
 208  
     }
 209  
 
 210  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.