java/src/main/com/google/appengine/tools/util/Parser.java

   1 // Copyright 2008 Google Inc. All Rights Reserved.
   2
   3 package com.google.appengine.tools.util;
   4
   5 import com.google.appengine.tools.util.Action;
   6 import com.google.appengine.tools.util.Option;
   7
   8 import java.util.List;
   9 import java.util.ArrayList;
  10 import java.util.Arrays;
  11
  12 /**
  13  * Parses command line arguments.
  14  *
  15  */
  16 public class Parser {
  17
  18   /**
  19    * Contains the parsed {@link Action} and {@link Option arguments}
  20    * from a program command line.
  21    */
  22   public static class ParseResult {
  23     private final List<Option> parsedOptions;
  24     private final Action action;
  25
  26     ParseResult(List<Option> parsedOptions, Action action) {
  27       this.parsedOptions = parsedOptions;
  28       this.action = action;
  29     }
  30
  31     public List<Option> getParsedOptions() {
  32       return parsedOptions;
  33     }
  34
  35     public Action getAction() {
  36       return action;
  37     }
  38
  39     /**
  40      * Applies the arguments to all {@link Option#apply() options} and
  41      * to the parsed {@link Action#apply() action}.
  42      */
  43     public void applyArgs() {
  44       for (Option option : parsedOptions) {
  45         option.apply();
  46       }
  47       action.apply();
  48     }
  49   }
  50
  51   /**
  52    * Finds the action for a particular name.
  53    * @param actions the actions available
  54    * @param name the name of the desired action
  55    * @returns an {@link Action} for the given name, or {@code null} if there
  56    *    is no match.
  57    */
  58   public static Action lookupAction(List<Action> actions, String[] args, int index) {
  59     for (Action action : actions) {
  60       if (matchesAction(action, args, index)) {
  61         return action;
  62       }
  63     }
  64     return null;
  65   }
  66
  67   private static boolean matchesAction(Action action, String[] args, int index) {
  68     if ((args.length - index) < action.getNames().length) {
  69       return false;
  70     }
  71     for (String name : action.getNames()) {
  72       if (!name.equals(args[index++])) {
  73         return false;
  74       }
  75     }
  76     return true;
  77   }
  78
  79   /**
  80    * Parses command line arguments for the specified {@code actions}
  81    * and {@code args}.  This variant assumes that there is only a
  82    * single {@link Action} and, as a result, the user does not specify
  83    * an action name on the command line.
  84    *
  85    * @param actions a single not-{@code null} {@link Action}
  86    * @param options a not {@code null}, optionally empty, list
  87    * @param cmdLineArgs a not {@code null} array of command line arguments
  88    *
  89    * @return a not {@code null} {@code ParseResult}
  90    */
  91   public ParseResult parseArgs(Action action, List<Option> options, String[] cmdLineArgs) {
  92     List<Option> parsedOptions = new ArrayList<Option>();
  93     int currentArg = parseOptions(options, parsedOptions, cmdLineArgs);
  94
  95     List<String> actionArgs = Arrays.asList(cmdLineArgs).subList(currentArg, cmdLineArgs.length);
  96     action.setArgs(actionArgs);
  97     return new ParseResult(parsedOptions, action);
  98   }
  99
 100   /**
 101    * Parses command line arguments using the specified {@code actions} and
 102    * {@code args}.
 103    *
 104    * @param actions a not {@code null}, not empty, list
 105    * @param options a not {@code null}, optionally empty, list
 106    * @param cmdLineArgs a not {@code null} array of command line arguments
 107    *
 108    * @return a not {@code null} {@code ParseResult}
 109    */
 110   public ParseResult parseArgs(List<Action> actions, List<Option> options, String[] cmdLineArgs) {
 111     List<Option> parsedOptions = new ArrayList<Option>();
 112
 113     int currentArg = parseOptions(options, parsedOptions, cmdLineArgs);
 114     if (currentArg >= cmdLineArgs.length) {
 115       throw new IllegalArgumentException("Expected an action: " + buildActionString(actions));
 116     }
 117
 118     String actionString = cmdLineArgs[currentArg];
 119     if (actionString.startsWith("-") || actionString.startsWith("--")) {
 120       throw new IllegalArgumentException("Unknown option: " + actionString);
 121     }
 122
 123     Action foundAction = lookupAction(actions, cmdLineArgs, currentArg);
 124     if (foundAction == null) {
 125       throw new IllegalArgumentException("Expected an action: " + buildActionString(actions));
 126     }
 127     currentArg += foundAction.getNames().length;
 128
 129     List<String> actionArgs = Arrays.asList(cmdLineArgs).subList(currentArg, cmdLineArgs.length);
 130     foundAction.setArgs(actionArgs);
 131     return new ParseResult(parsedOptions, foundAction);
 132   }
 133
 134   private int parseOptions(List<Option> availableOptions, List<Option> parsedOptions,
 135                            String[] cmdLineArgs) {
 136     int currentArg = -1;
 137
 138     while (true) {
 139       ++currentArg;
 140       if (currentArg >= cmdLineArgs.length) {
 141         break;
 142       }
 143       Option option = parseArg(availableOptions, cmdLineArgs, currentArg);
 144       if (option != null) {
 145         parsedOptions.add(option);
 146         if (option.getArgStyle() == Option.Style.Short) {
 147           ++currentArg;
 148         }
 149         continue;
 150       }
 151       break;
 152     }
 153
 154     return currentArg;
 155   }
 156
 157   private static String buildActionString(List<Action> actions) {
 158     StringBuffer msg = new StringBuffer("[");
 159
 160     for (int i = 0; i < actions.size(); ++i) {
 161       Action action = actions.get(i);
 162       msg.append(action.getNameString());
 163       if (i != actions.size() - 1) {
 164         msg.append(", ");
 165       } else {
 166         msg.append("]");
 167       }
 168     }
 169
 170     return msg.toString();
 171   }
 172
 173   private static Option parseArg(List<Option> optionParsers, String[] cmdLineArgs, int currentArg) {
 174     for (Option option : optionParsers) {
 175       if (option.parse(cmdLineArgs, currentArg)) {
 176         return option;
 177       }
 178     }
 179     return null;
 180   }
 181 }