path: root/bundles/org.eclipse.wst.wsdl.validation/src/org/eclipse/wst/wsdl/validation/internal/ui/text/WSDLValidate.java

/*******************************************************************************
 * Copyright (c) 2001, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.wst.wsdl.validation.internal.ui.text;

import java.net.MalformedURLException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import org.eclipse.wst.wsdl.validation.internal.ClassloaderWSDLValidatorDelegate;
import org.eclipse.wst.wsdl.validation.internal.IValidationMessage;
import org.eclipse.wst.wsdl.validation.internal.IValidationReport;
import org.eclipse.wst.wsdl.validation.internal.WSDLValidationConfiguration;
import org.eclipse.wst.wsdl.validation.internal.WSDLValidator;
import org.eclipse.wst.wsdl.validation.internal.logging.ILogger;
import org.eclipse.wst.wsdl.validation.internal.logging.LoggerFactory;
import org.eclipse.wst.wsdl.validation.internal.resolver.URIResolverDelegate;
import org.eclipse.wst.wsdl.validation.internal.wsdl11.ClassloaderWSDL11ValidatorDelegate;
import org.eclipse.wst.wsdl.validation.internal.wsdl11.WSDL11ValidatorDelegate;
import org.eclipse.wst.wsdl.validation.internal.xml.XMLCatalog;
import org.eclipse.wst.wsdl.validation.internal.xml.XMLCatalogEntityHolder;

import com.ibm.wsdl.util.StringUtils;

/**
 * A commande line tool to run WSDL Validation on a single or multiple files.
 * 
 * Options
 * -schemaDir directory       : a directory of schemas to load into the catalog
 * -schema namespace location : a schema to load into the registry
 * -wsdl11v classname namespace resourcebundle : register a WSDL 1.1 extension validator
 *                              to load for the given namespace with the given resourcebundle
 * -wsiv validatorClass namespace propertiesfile : register a WS-I validator
 * -uriresolver URIResolverClass : register an extension URI resolver
 */
public class WSDLValidate
{
  private final String FILE_PREFIX = "file:///";
  private static final String VALIDATOR_PROPERTIES =
    org.eclipse.wst.wsdl.validation.internal.Constants.WSDL_VALIDATOR_PROPERTIES_FILE;
  
  protected static final String PARAM_WSDL11VAL = "-wsdl11v";
  protected static final String PARAM_EXTVAL = "-extv";
  protected static final String PARAM_SCHEMADIR = "-schemaDir";
  protected static final String PARAM_SCHEMA = "-schema";
  protected static final String PARAM_URIRESOLVER = "-uriresolver";
  protected static final String PARAM_LOGGER = "-logger";
  protected static final String PARAM_PROPERTY = "-D";
  protected static final String PARAM_VERBOSE = "-verbose";
  protected static final String PARAM_VERBOSE_SHORT = "-v";
  
  private static final String STRING_EMPTY = "";
  private static final String STRING_SPACE = " ";
  private static final String STRING_DASH = "-";
  
  String workingdir = System.getProperty("user.dir");
  
  //protected ResourceBundle resourceBundle;

  protected WSDLValidator wsdlValidator = null;
  protected WSDLValidationConfiguration configuration = null;
  protected List wsdlFiles = new ArrayList();
  protected boolean verbose = false;
  protected ResourceBundle validatorRB = null;

  /**
   * Constuctor.
   */
  protected WSDLValidate()
  {
  	wsdlValidator = new WSDLValidator();
  	configuration = new WSDLValidationConfiguration();
  	
    try
    {
      validatorRB = ResourceBundle.getBundle(VALIDATOR_PROPERTIES);
    }
    catch (MissingResourceException e)
    {
      LoggerFactory.getInstance().getLogger().log("Validation failed: Unable to load the WSDL validator properties file.", ILogger.SEV_ERROR, e);
    }
  }
  
  /**
   * Validate the files specified.
   */
  protected void validate()
  {
	ILogger logger = LoggerFactory.getInstance().getLogger();
	
	int numInvalid = 0;

	Iterator filesIter = wsdlFiles.iterator();
    while (filesIter.hasNext())
	{
	  String wsdlFile = (String)filesIter.next();
	  IValidationReport valReport = validateFile(wsdlFile);

	  if(valReport.hasErrors())
	  {
	    numInvalid++;
	    logger.log(MessageFormat.format(WSDLValidateTextUIMessages._UI_FILE_INVALID, new Object[]{wsdlFile}), ILogger.SEV_INFO);
	    //logger.log(WSDLValidateTextUIMessages._UI_INFORMATION_DELIMITER, ILogger.SEV_ERROR);
	    logger.log(getMessages(valReport.getValidationMessages()), ILogger.SEV_INFO);
	  }
	  else if(verbose)
	  {
	    logger.log(MessageFormat.format(WSDLValidateTextUIMessages._UI_FILE_VALID, new Object[]{wsdlFile}), ILogger.SEV_VERBOSE);
	  }
	}
    
    // Log the summary.
    logger.log(MessageFormat.format(WSDLValidateTextUIMessages._UI_VALIDATION_SUMMARY, new Object[]{new Integer(wsdlFiles.size()), new Integer(numInvalid)}), ILogger.SEV_INFO);
  }

  /**
   * Run WSDL validation on a given file.
   * 
   * @param filename 
   * 		The name of the file to validate.
   * @throws Exception
   */
  protected IValidationReport validateFile(String filename)
  {	
    // Resolve the location of the file.
    String filelocation = null;
    try
    {
      URL fileURL = StringUtils.getURL(new URL(FILE_PREFIX + workingdir + "/"), filename);
      filelocation = fileURL.toExternalForm();
    }
    catch (MalformedURLException e)
    {
      // Do nothing. The WSDL validator will handle the error.
      //LoggerFactory.getInstance().getLogger().log(MessageFormat.format(WSDLValidateTextUIMessages._ERROR_UNABLE_TO_READ_FILE, new Object[]{filename}), ILogger.SEV_ERROR);
    }
    
    // Run validation on the file.
    IValidationReport valReport = wsdlValidator.validate(filelocation, null, configuration);
    return valReport;
  }

  /**
   * Returns a String with formatted output for a list of messages.
   * 
   * @param messages 
   * 		The messages to get.
   * @return 
   * 		A string with a formatted list of the messages.
   */
  protected String getMessages(IValidationMessage[] messages)
  {
    StringBuffer outputBuffer = new StringBuffer();
    if (messages != null)
    {
      // create a list of messages that looks like
      // ERROR 1:1 Error message content
      int numMessages = messages.length;
      String marker = null;
      for (int i = 0; i < numMessages; i++)
      {
        IValidationMessage message = messages[i];
        int severity = message.getSeverity();
        if (severity == IValidationMessage.SEV_ERROR)
        {
          marker = WSDLValidateTextUIMessages._UI_ERROR_MARKER;
        }
        else if (severity == IValidationMessage.SEV_WARNING)
        {
          marker = WSDLValidateTextUIMessages._UI_WARNING_MARKER;
        }
        else
        {
          marker = STRING_EMPTY;
        }
        outputBuffer
          .append(marker)
          .append(STRING_SPACE)
          .append(message.getLine())
          .append(":")
          .append(message.getColumn())
          .append(STRING_SPACE)
          .append(message.getMessage());
        if(i != numMessages -1)
        {
          outputBuffer.append("\n");
        }
      }
    }
    return outputBuffer.toString();
  }

  /**
   * The main entry point into the command line tool. 
   * Checks the command line arguments, registers the default validators and runs validation on the
   * list of files.
   * 
   * @param args - the arguments to the validator
   */
  public static void main(String[] args)
  {
    // No arguments specified. Print usage.
	if (args.length < 1)
    {
	  System.err.println(WSDLValidateTextUIMessages._ERROR_WRONG_ARGUMENTS);
	  System.exit(0);
	}
	
	WSDLValidate wsdlValidate = new WSDLValidate();
	wsdlValidate.parseArguments(args);
	wsdlValidate.validate();
  }
  
  /**
   * Parse the arguments specified for this WSDLValidate task and
   * configure validation.
   * 
   * @param args
   * 		The arguments specified for this task.
   */
  protected void parseArguments(String[] args)
  {
	int numargs = args.length;

	for (int i = 0; i < numargs; i++)
	{
	  String param = args[i];

	  // Registering an extension validator or WSDL 1.1 extension validator.
	  if (param.equals(WSDLValidate.PARAM_WSDL11VAL) 
			  || param.equals(WSDLValidate.PARAM_EXTVAL))
	  {
	    String namespace = args[++i];
	    if (!namespace.startsWith(WSDLValidate.STRING_DASH))
	    {
	      String validatorClass = args[++i];

	      if (!validatorClass.startsWith(WSDLValidate.STRING_DASH))
	      {
	        if(param.equalsIgnoreCase(WSDLValidate.PARAM_WSDL11VAL))
	        {  
	          WSDL11ValidatorDelegate delegate = new ClassloaderWSDL11ValidatorDelegate(validatorClass);
	          wsdlValidator.registerWSDL11Validator(namespace, delegate);
	        }
	        else if(param.equalsIgnoreCase(WSDLValidate.PARAM_EXTVAL))
	        {
	          ClassloaderWSDLValidatorDelegate delegate = new ClassloaderWSDLValidatorDelegate(validatorClass);
	          wsdlValidator.registerWSDLExtensionValidator(namespace, delegate);
	        }
	      }
	      else
	      {
	        i--;
	      }
	    }
	    else
	    {
	      i--;
	    }  
	  }
	  // Register a directory with schemas.
	  else if (param.equalsIgnoreCase(WSDLValidate.PARAM_SCHEMADIR))
	  {
	    String xsdDir = args[++i];
	    XMLCatalog.addSchemaDir(xsdDir);
	  }
	  // Register a schema.
	  // TODO: Replace this with an XML catalog.
	  else if (param.equalsIgnoreCase(WSDLValidate.PARAM_SCHEMA))
	  {
	    String publicid = args[++i];
	    String systemid = args[++i];
	    XMLCatalog.addEntity(new XMLCatalogEntityHolder(publicid, systemid));
	  }
	  // Register a URI resolver. 
	  // TODO: Determine if this is appropriate for the text UI.
	  else if(param.equalsIgnoreCase(PARAM_URIRESOLVER))
	  {
	    String resolverClass = args[++i];
	    wsdlValidator.addURIResolver(new URIResolverDelegate(resolverClass, null).getURIResolver());
	  }
	  // Configure the logger.
	  else if(param.equals(PARAM_LOGGER))
	  {
	    String loggerClassString = args[++i];
	    try
	    {
	      Class loggerClass = WSDLValidate.class.getClassLoader().loadClass(loggerClassString);
	      ILogger logger = (ILogger)loggerClass.newInstance();
	      LoggerFactory.getInstance().setLogger(logger);
	    }
	    catch(Exception e)
	    {
	      System.err.println(MessageFormat.format(WSDLValidateTextUIMessages._ERROR_LOADING_LOGGER, new Object[]{loggerClassString}));
	    }
	  }
	  // Set properties.
	  else if(param.startsWith(PARAM_PROPERTY))
	  {
	    int separator = param.indexOf('=');
	    String name = param.substring(2, separator);
	    String value = param.substring(separator+1);
	    configuration.setProperty(name, value);
	  }
	  // Set verbose;
	  else if(param.equals(PARAM_VERBOSE) || param.equals( PARAM_VERBOSE_SHORT))
	  {
		verbose = true;
	  }
	  // a file to validate
	  else
	  {
	    if(!param.startsWith(WSDLValidate.STRING_DASH))
	    {  
	      wsdlFiles.add(param);
	    }
	  }
    }
  }
}