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.