1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.cli;
19
20 import java.util.ArrayList;
21 import java.util.Arrays;
22 import java.util.Enumeration;
23 import java.util.List;
24 import java.util.ListIterator;
25 import java.util.Properties;
26
27
28
29
30
31
32 @Deprecated
33 public abstract class Parser implements CommandLineParser {
34
35 protected CommandLine cmd;
36
37
38 private Options options;
39
40
41 private List requiredOptions;
42
43
44
45
46
47
48 protected void checkRequiredOptions() throws MissingOptionException {
49
50 if (!getRequiredOptions().isEmpty()) {
51 throw new MissingOptionException(getRequiredOptions());
52 }
53 }
54
55
56
57
58
59
60
61
62
63
64 protected abstract String[] flatten(Options opts, String[] arguments, boolean stopAtNonOption) throws ParseException;
65
66
67
68
69
70
71 protected Options getOptions() {
72 return options;
73 }
74
75
76
77
78
79
80 protected List getRequiredOptions() {
81 return requiredOptions;
82 }
83
84
85
86
87
88
89
90
91
92 @Override
93 public CommandLine parse(final Options options, final String[] arguments) throws ParseException {
94 return parse(options, arguments, null, false);
95 }
96
97
98
99
100
101
102
103
104
105
106
107
108 @Override
109 public CommandLine parse(final Options options, final String[] arguments, final boolean stopAtNonOption) throws ParseException {
110 return parse(options, arguments, null, stopAtNonOption);
111 }
112
113
114
115
116
117
118
119
120
121
122
123 public CommandLine parse(final Options options, final String[] arguments, final Properties properties) throws ParseException {
124 return parse(options, arguments, properties, false);
125 }
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140 public CommandLine parse(final Options options, final String[] arguments, final Properties properties, final boolean stopAtNonOption)
141 throws ParseException {
142
143 for (final Option opt : options.helpOptions()) {
144 opt.clearValues();
145 }
146
147 for (final OptionGroup group : options.getOptionGroups()) {
148 group.setSelected(null);
149 }
150
151 setOptions(options);
152 cmd = CommandLine.builder().build();
153 boolean eatTheRest = false;
154 final List<String> tokenList = Arrays.asList(flatten(getOptions(), arguments == null ? new String[0] : arguments, stopAtNonOption));
155 final ListIterator<String> iterator = tokenList.listIterator();
156
157 while (iterator.hasNext()) {
158 final String token = iterator.next();
159
160 if ("--".equals(token)) {
161 eatTheRest = true;
162 }
163
164 else if ("-".equals(token)) {
165 if (stopAtNonOption) {
166 eatTheRest = true;
167 } else {
168 cmd.addArg(token);
169 }
170 }
171
172 else if (token.startsWith("-")) {
173 if (stopAtNonOption && !getOptions().hasOption(token)) {
174 eatTheRest = true;
175 cmd.addArg(token);
176 } else {
177 processOption(token, iterator);
178 }
179 }
180
181 else {
182 cmd.addArg(token);
183 if (stopAtNonOption) {
184 eatTheRest = true;
185 }
186 }
187
188 if (eatTheRest) {
189 while (iterator.hasNext()) {
190 final String str = iterator.next();
191
192 if (!"--".equals(str)) {
193 cmd.addArg(str);
194 }
195 }
196 }
197 }
198 processProperties(properties);
199 checkRequiredOptions();
200 return cmd;
201 }
202
203
204
205
206
207
208
209
210
211 public void processArgs(final Option opt, final ListIterator<String> iter) throws ParseException {
212
213 while (iter.hasNext()) {
214 final String str = iter.next();
215
216 if (getOptions().hasOption(str) && str.startsWith("-")) {
217 iter.previous();
218 break;
219 }
220
221 try {
222 opt.processValue(Util.stripLeadingAndTrailingQuotes(str));
223 } catch (final RuntimeException exp) {
224 iter.previous();
225 break;
226 }
227 }
228 if (opt.getValues() == null && !opt.hasOptionalArg()) {
229 throw new MissingArgumentException(opt);
230 }
231 }
232
233
234
235
236
237
238
239
240
241 protected void processOption(final String arg, final ListIterator<String> iter) throws ParseException {
242 final boolean hasOption = getOptions().hasOption(arg);
243
244 if (!hasOption) {
245 throw new UnrecognizedOptionException("Unrecognized option: " + arg, arg);
246 }
247
248 final Option opt = (Option) getOptions().getOption(arg).clone();
249
250 updateRequiredOptions(opt);
251
252 if (opt.hasArg()) {
253 processArgs(opt, iter);
254 }
255
256 cmd.addOption(opt);
257 }
258
259
260
261
262
263
264
265 protected void processProperties(final Properties properties) throws ParseException {
266 if (properties == null) {
267 return;
268 }
269 for (final Enumeration<?> e = properties.propertyNames(); e.hasMoreElements();) {
270 final String option = e.nextElement().toString();
271 final Option opt = options.getOption(option);
272 if (opt == null) {
273 throw new UnrecognizedOptionException("Default option wasn't defined", option);
274 }
275
276 final OptionGroup group = options.getOptionGroup(opt);
277 final boolean selected = group != null && group.getSelected() != null;
278 if (!cmd.hasOption(option) && !selected) {
279
280 final String value = properties.getProperty(option);
281 if (opt.hasArg()) {
282 if (opt.getValues() == null || opt.getValues().length == 0) {
283 try {
284 opt.processValue(value);
285 } catch (final RuntimeException exp) {
286
287 }
288 }
289 } else if (!("yes".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value))) {
290
291
292 continue;
293 }
294 cmd.addOption(opt);
295 updateRequiredOptions(opt);
296 }
297 }
298 }
299
300
301
302
303
304
305 protected void setOptions(final Options options) {
306 this.options = options;
307 this.requiredOptions = new ArrayList<>(options.getRequiredOptions());
308 }
309
310
311
312
313
314
315 private void updateRequiredOptions(final Option opt) throws ParseException {
316
317
318 if (opt.isRequired()) {
319 getRequiredOptions().remove(opt.getKey());
320 }
321
322
323 if (getOptions().getOptionGroup(opt) != null) {
324 final OptionGroup group = getOptions().getOptionGroup(opt);
325 if (group.isRequired()) {
326 getRequiredOptions().remove(group);
327 }
328 group.setSelected(opt);
329 }
330 }
331
332 }