2.4/dev/core/src/com/google/gwt/util/tools/ToolBase.java - gwt - Git at Google

 /*
  * Copyright 2006 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.util.tools;

 import com.google.gwt.dev.About;

 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;

 /**
  * A base class for a GWT related command-line application. To use this:
  * <ol>
  * <li>Derive a class for this class.</li>
  * <li>In your constructor, call {@link #registerHandler(ArgHandler)}
  * repeatedly to register particular command line arguments and options.</li>
  * <li>Write a main that looks like this:
  *
  * <pre>
  * public static void main(String[] args) {
  *  MyShell myShell = new MyShell();
  *  if (myShell.processArgs(args)) {
  *    // main program operation
  *  }
  *  System.exit(1);
  * }
  * </pre>
  *
  * </li>
  * <li>Create launch config whose main class is MyShell.</li>
  * </ol>
  */
 public abstract class ToolBase {

   private static final String PROPERTY_NOWARN_LEGACY_TOOLS = "gwt.nowarn.legacy.tools";

   public static void legacyWarn(Class<?> legacy, Class<?> replacement) {
     if (System.getProperty(PROPERTY_NOWARN_LEGACY_TOOLS) == null) {
       System.err.println("WARNING: '" + legacy.getName()
           + "' is deprecated and will be removed in a future release.");
       System.err.println("Use '" + replacement.getName() + "' instead.");
       System.err.println("(To disable this warning, pass -D"
           + PROPERTY_NOWARN_LEGACY_TOOLS + " as a JVM arg.)");
     }
   }

   /**
    * Use a linked hash map to preserve the declaration order.
    */
   private final Map<String, ArgHandler> argHandlers = new LinkedHashMap<String, ArgHandler>();

   /**
    * Log deprecation warning on old JREs.
    */
   protected void checkJdkVersion() {
     // JDK 1.6 is 50
     double classVersion = Double.valueOf(System.getProperty("java.class.version","0.0"));
     if (classVersion < 50) {
       System.err.println("WARNING: Use on a JRE prior to version 1.6 is deprecated");
     }
   }

   protected String getDescription() {
     return null;
   }

   protected String getName() {
     return getClass().getName();
   }

   protected void printHelp() {
     System.err.println(About.getGwtVersion());

     ArgHandler nullHandler = null;
     int widest = 0;
     for (ArgHandler handler : argHandlers.values()) {
       if (handler.isUndocumented()) {
         continue;
       }
       String tag = handler.getTag();
       if (tag != null) {
         if (tag.length() > widest) {
           widest = tag.length();
         }
       } else {
         nullHandler = handler;
         int len = nullHandler.getTagArgs()[0].length();
         if (len > widest) {
           widest = len;
         }
       }
     }

     // Print the name.
     //
     String name = getName();
     int i = name.lastIndexOf('.');
     if (i != -1) {
       name = name.substring(i + 1);
     }
     System.err.print(name);

     // Print the command-line template.
     //
     for (ArgHandler handler : argHandlers.values()) {
       if (handler.isUndocumented()) {
         continue;
       }
       String tag = handler.getTag();
       if (tag != null) {
         System.err.print(handler.isRequired() ? " " : " [");
         System.err.print(tag);
         String[] tagArgs = handler.getTagArgs();
         for (String tagArg : tagArgs) {
           System.err.print(" " + tagArg);
         }
         System.err.print(handler.isRequired() ? "" : "]");
       }
     }

     // Print the flagless args.
     //
     if (nullHandler != null && !nullHandler.isUndocumented()) {
       String[] tagArgs = nullHandler.getTagArgs();
       for (String element : tagArgs) {
         System.err.print(nullHandler.isRequired() ? " " : " [");
         System.err.print(element);
         System.err.print(nullHandler.isRequired() ? " " : "]");
       }
       System.err.println();
     }

     System.err.println();
     String description = getDescription();
     if (description != null) {
       System.err.println(description);
       System.err.println();
     }

     System.err.println("where ");

     // Print the details.
     //
     for (ArgHandler handler : argHandlers.values()) {
       if (handler.isUndocumented()) {
         continue;
       }
       String tag = handler.getTag();
       if (tag != null) {
         int len = tag.length();
         System.err.print("  ");
         System.err.print(tag);
         for (i = len; i < widest; ++i) {
           System.err.print(' ');
         }
         System.err.print("  ");
         System.err.print(handler.getPurpose());
         System.err.println();
       }
     }

     // And details for the "extra" args, if any.
     //
     if (nullHandler != null && !nullHandler.isUndocumented()) {
       System.err.println("and ");
       String tagArg = nullHandler.getTagArgs()[0];
       int len = tagArg.length();
       System.err.print("  ");
       System.err.print(tagArg);
       for (i = len; i < widest; ++i) {
         System.err.print(' ');
       }
       System.err.print("  ");
       System.err.print(nullHandler.getPurpose());
       System.err.println();
     }
   }

   protected boolean processArgs(String... args) {
     checkJdkVersion();

     if (args.length > 0) {
       boolean help = false;
       if ("-help".equalsIgnoreCase(args[0])) {
         help = true;
       } else if ("-?".equals(args[0])) {
         help = true;
       }

       if (help) {
         printHelp();
         return false;
       }
     }

     Set<ArgHandler> defs = new HashSet<ArgHandler>(argHandlers.values());
     int extraArgCount = 0;

     Set<ArgHandler> receivedArg = new HashSet<ArgHandler>();

     // Let the args drive the handlers.
     //
     ArgHandler nullHandler = argHandlers.get("");
     for (int i = 0; i < args.length; i++) {
       String arg = args[i];
       ArgHandler handler;
       if (arg.startsWith("-")) {
         // Use the handler registered for this flag.
         //
         handler = argHandlers.get(arg);
       } else {
         // Use the handler that doesn't have a leading flag.
         //
         handler = nullHandler;
         ++extraArgCount;
       }

       if (handler == null) {
         System.err.println("Unknown argument: " + arg);
         printHelp();
         return false;
       }

       int addtlConsumed = handler.handle(args, i);
       if (addtlConsumed == -1) {
         printHelp();
         return false;
       }

       i += addtlConsumed;

       // We don't need to use this as a default handler.
       //
       defs.remove(handler);

       // Record that this handler saw a value
       //
       receivedArg.add(handler);
     }

     // See if any handler didn't get its required argument(s).
     //
     for (ArgHandler argHandler : argHandlers.values()) {
       if (argHandler.isRequired() && !receivedArg.contains(argHandler)) {
         System.err.print("Missing required argument '");
         String tag = argHandler.getTag();
         if (tag != null) {
           System.err.print(tag);
           System.err.print(" ");
         }

         String tagArg = argHandler.getTagArgs()[0];
         System.err.print(tagArg);
         System.err.println("'");

         printHelp();
         return false;
       }
     }
     if (extraArgCount == 0 && nullHandler != null && nullHandler.isRequired()) {
       System.err.print("Missing required argument '");
       String tagArg = nullHandler.getTagArgs()[0];
       System.err.print(tagArg);
       System.err.println("'");
       printHelp();
       return false;
     }

     // Set if there are any remaining unused handlers with default arguments.
     // Allow the default handlers to pretend there were other arguments.
     //
     for (ArgHandler def : defs) {
       String[] defArgs = def.getDefaultArgs();
       if (defArgs != null) {
         if (def.handle(defArgs, 0) == -1) {
           return false;
         }
       }
     }

     return true;
   }

   protected void registerHandler(ArgHandler handler) {
     String tag = handler.getTag();
     argHandlers.put(tag != null ? tag : "", handler);
   }
 }
	/*
	* Copyright 2006 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.util.tools;

	import com.google.gwt.dev.About;

	import java.util.HashSet;
	import java.util.LinkedHashMap;
	import java.util.Map;
	import java.util.Set;

	/**
	* A base class for a GWT related command-line application. To use this:
	* <ol>
	* <li>Derive a class for this class.</li>
	* <li>In your constructor, call {@link #registerHandler(ArgHandler)}
	* repeatedly to register particular command line arguments and options.</li>
	* <li>Write a main that looks like this:
	*
	* <pre>
	* public static void main(String[] args) {
	* MyShell myShell = new MyShell();
	* if (myShell.processArgs(args)) {
	* // main program operation
	* }
	* System.exit(1);
	* }
	* </pre>
	*
	* </li>
	* <li>Create launch config whose main class is MyShell.</li>
	* </ol>
	*/
	public abstract class ToolBase {

	private static final String PROPERTY_NOWARN_LEGACY_TOOLS = "gwt.nowarn.legacy.tools";

	public static void legacyWarn(Class<?> legacy, Class<?> replacement) {
	if (System.getProperty(PROPERTY_NOWARN_LEGACY_TOOLS) == null) {
	System.err.println("WARNING: '" + legacy.getName()
	+ "' is deprecated and will be removed in a future release.");
	System.err.println("Use '" + replacement.getName() + "' instead.");
	System.err.println("(To disable this warning, pass -D"
	+ PROPERTY_NOWARN_LEGACY_TOOLS + " as a JVM arg.)");
	}
	}

	/**
	* Use a linked hash map to preserve the declaration order.
	*/
	private final Map<String, ArgHandler> argHandlers = new LinkedHashMap<String, ArgHandler>();

	/**
	* Log deprecation warning on old JREs.
	*/
	protected void checkJdkVersion() {
	// JDK 1.6 is 50
	double classVersion = Double.valueOf(System.getProperty("java.class.version","0.0"));
	if (classVersion < 50) {
	System.err.println("WARNING: Use on a JRE prior to version 1.6 is deprecated");
	}
	}

	protected String getDescription() {
	return null;
	}

	protected String getName() {
	return getClass().getName();
	}

	protected void printHelp() {
	System.err.println(About.getGwtVersion());

	ArgHandler nullHandler = null;
	int widest = 0;
	for (ArgHandler handler : argHandlers.values()) {
	if (handler.isUndocumented()) {
	continue;
	}
	String tag = handler.getTag();
	if (tag != null) {
	if (tag.length() > widest) {
	widest = tag.length();
	}
	} else {
	nullHandler = handler;
	int len = nullHandler.getTagArgs()[0].length();
	if (len > widest) {
	widest = len;
	}
	}
	}

	// Print the name.
	//
	String name = getName();
	int i = name.lastIndexOf('.');
	if (i != -1) {
	name = name.substring(i + 1);
	}
	System.err.print(name);

	// Print the command-line template.
	//
	for (ArgHandler handler : argHandlers.values()) {
	if (handler.isUndocumented()) {
	continue;
	}
	String tag = handler.getTag();
	if (tag != null) {
	System.err.print(handler.isRequired() ? " " : " [");
	System.err.print(tag);
	String[] tagArgs = handler.getTagArgs();
	for (String tagArg : tagArgs) {
	System.err.print(" " + tagArg);
	}
	System.err.print(handler.isRequired() ? "" : "]");
	}
	}

	// Print the flagless args.
	//
	if (nullHandler != null && !nullHandler.isUndocumented()) {
	String[] tagArgs = nullHandler.getTagArgs();
	for (String element : tagArgs) {
	System.err.print(nullHandler.isRequired() ? " " : " [");
	System.err.print(element);
	System.err.print(nullHandler.isRequired() ? " " : "]");
	}
	System.err.println();
	}

	System.err.println();
	String description = getDescription();
	if (description != null) {
	System.err.println(description);
	System.err.println();
	}

	System.err.println("where ");

	// Print the details.
	//
	for (ArgHandler handler : argHandlers.values()) {
	if (handler.isUndocumented()) {
	continue;
	}
	String tag = handler.getTag();
	if (tag != null) {
	int len = tag.length();
	System.err.print(" ");
	System.err.print(tag);
	for (i = len; i < widest; ++i) {
	System.err.print(' ');
	}
	System.err.print(" ");
	System.err.print(handler.getPurpose());
	System.err.println();
	}
	}

	// And details for the "extra" args, if any.
	//
	if (nullHandler != null && !nullHandler.isUndocumented()) {
	System.err.println("and ");
	String tagArg = nullHandler.getTagArgs()[0];
	int len = tagArg.length();
	System.err.print(" ");
	System.err.print(tagArg);
	for (i = len; i < widest; ++i) {
	System.err.print(' ');
	}
	System.err.print(" ");
	System.err.print(nullHandler.getPurpose());
	System.err.println();
	}
	}

	protected boolean processArgs(String... args) {
	checkJdkVersion();

	if (args.length > 0) {
	boolean help = false;
	if ("-help".equalsIgnoreCase(args[0])) {
	help = true;
	} else if ("-?".equals(args[0])) {
	help = true;
	}

	if (help) {
	printHelp();
	return false;
	}
	}

	Set<ArgHandler> defs = new HashSet<ArgHandler>(argHandlers.values());
	int extraArgCount = 0;

	Set<ArgHandler> receivedArg = new HashSet<ArgHandler>();

	// Let the args drive the handlers.
	//
	ArgHandler nullHandler = argHandlers.get("");
	for (int i = 0; i < args.length; i++) {
	String arg = args[i];
	ArgHandler handler;
	if (arg.startsWith("-")) {
	// Use the handler registered for this flag.
	//
	handler = argHandlers.get(arg);
	} else {
	// Use the handler that doesn't have a leading flag.
	//
	handler = nullHandler;
	++extraArgCount;
	}

	if (handler == null) {
	System.err.println("Unknown argument: " + arg);
	printHelp();
	return false;
	}

	int addtlConsumed = handler.handle(args, i);
	if (addtlConsumed == -1) {
	printHelp();
	return false;
	}

	i += addtlConsumed;

	// We don't need to use this as a default handler.
	//
	defs.remove(handler);

	// Record that this handler saw a value
	//
	receivedArg.add(handler);
	}

	// See if any handler didn't get its required argument(s).
	//
	for (ArgHandler argHandler : argHandlers.values()) {
	if (argHandler.isRequired() && !receivedArg.contains(argHandler)) {
	System.err.print("Missing required argument '");
	String tag = argHandler.getTag();
	if (tag != null) {
	System.err.print(tag);
	System.err.print(" ");
	}

	String tagArg = argHandler.getTagArgs()[0];
	System.err.print(tagArg);
	System.err.println("'");

	printHelp();
	return false;
	}
	}
	if (extraArgCount == 0 && nullHandler != null && nullHandler.isRequired()) {
	System.err.print("Missing required argument '");
	String tagArg = nullHandler.getTagArgs()[0];
	System.err.print(tagArg);
	System.err.println("'");
	printHelp();
	return false;
	}

	// Set if there are any remaining unused handlers with default arguments.
	// Allow the default handlers to pretend there were other arguments.
	//
	for (ArgHandler def : defs) {
	String[] defArgs = def.getDefaultArgs();
	if (defArgs != null) {
	if (def.handle(defArgs, 0) == -1) {
	return false;
	}
	}
	}

	return true;
	}

	protected void registerHandler(ArgHandler handler) {
	String tag = handler.getTag();
	argHandlers.put(tag != null ? tag : "", handler);
	}
	}