package org.andromda.core.common;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.Reader;
   import java.io.StringReader;
   import java.net.URL;
   import java.util.HashMap;
   import java.util.Map;
  import javax.xml.XMLConstants;
  import org.apache.commons.digester.Digester;
  import org.apache.commons.digester.xmlrules.DigesterLoader;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  import org.xml.sax.EntityResolver;
  import org.xml.sax.ErrorHandler;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXParseException;
  
  /**
   * <p>
   * Creates and returns Objects based on a set of Apache Digester rules in a consistent manner, providing validation in
   * the process.
   * </p>
   * <p>
   * This XML object factory allows us to define a consistent/clean of configuring java objects from XML configuration
   * files (i.e. it uses the class name of the java object to find what rule file and what XSD file to use). It also
   * allows us to define a consistent way in which schema validation is performed.
   * </p>
   * <p>
   * It separates each concern into one file, for example: to configure and perform validation on the MetafacadeMappings
   * class, we need 3 files 1.) the java object (MetafacadeMappings.java), 2.) the rules file which tells the apache
   * digester how to populate the java object from the XML configuration file (MetafacadeMappings-Rules.xml), and 3.) the
   * XSD schema validation file (MetafacadeMappings.xsd). Note that each file is based on the name of the java object:
   * 'java object name'.xsd and 'java object name'-Rules.xml'. After you have these three files then you just need to call
   * the method #getInstance(java.net.URL objectClass) in this class from the java object you want to configure. This
   * keeps the dependency to digester (or whatever XML configuration tool we are using at the time) to this single file.
   * </p>
   * <p>
   * In order to add/modify an existing element/attribute in your configuration file, first make the modification in your
   * java object, then modify its rules file to instruct the digester on how to configure your new attribute/method in
   * the java object, and then modify your XSD file to provide correct validation for this new method/attribute. Please
   * see the org.andromda.core.metafacade.MetafacadeMappings* files for an example on how to do this.
   * </p>
   *
   * @author Chad Brandon
   * @author Bob Fields
   * @author Michail Plushnikov
   */
  public class XmlObjectFactory
  {
      /**
       * The class logger. Note: visibility is protected to improve access within {@link XmlObjectValidator}
       */
      protected static final Logger logger = Logger.getLogger(XmlObjectFactory.class);
  
      /**
       * The expected suffixes for rule files.
       */
      private static final String RULES_SUFFIX = "-Rules.xml";
  
      /**
       * The expected suffix for XSD files.
       */
      private static final String SCHEMA_SUFFIX = ".xsd";
  
      /**
       * The digester instance.
       */
      private Digester digester = null;
  
      /**
       * The class of which the object we're instantiating.
       */
      private Class objectClass = null;
  
      /**
       * The URL to the object rules.
       */
      private URL objectRulesXml = null;
  
      /**
       * The URL of the schema.
       */
      private URL schemaUri = null;
  
      /**
       * Whether or not validation should be turned on by default when using this factory to load XML configuration
       * files.
       */
      private static boolean defaultValidating = true;
  
      /**
       * Cache containing XmlObjectFactory instances which have already been configured for given objectRulesXml
       */
      private static final Map<Class, XmlObjectFactory> factoryCache = new HashMap<Class, XmlObjectFactory>();
  
     /**
      * Creates an instance of this XmlObjectFactory with the given <code>objectRulesXml</code>
      *
      * @param objectRulesXml URL to the XML file defining the digester rules for object
      */
     private XmlObjectFactory(final URL objectRulesXml)
     {
         ExceptionUtils.checkNull(
                 "objectRulesXml",
                 objectRulesXml);
         this.digester = DigesterLoader.createDigester(objectRulesXml);
         this.digester.setUseContextClassLoader(true);
     }
 
     /**
      * Gets an instance of this XmlObjectFactory using the digester rules belonging to the <code>objectClass</code>.
      *
      * @param objectClass the Class of the object from which to configure this factory.
      * @return the XmlObjectFactoy instance.
      */
     public static XmlObjectFactory getInstance(final Class objectClass)
     {
         ExceptionUtils.checkNull(
                 "objectClass",
                 objectClass);
 
         XmlObjectFactory factory = factoryCache.get(objectClass);
         if (factory == null)
         {
             final URL objectRulesXml =
                     XmlObjectFactory.class.getResource('/' + objectClass.getName().replace(
                             '.',
                             '/') + RULES_SUFFIX);
             if (objectRulesXml == null)
             {
                 throw new XmlObjectFactoryException("No configuration rules found for class --> '" + objectClass + '\'');
             }
             factory = new XmlObjectFactory(objectRulesXml);
             factory.objectClass = objectClass;
             factory.objectRulesXml = objectRulesXml;
             factory.setValidating(defaultValidating);
             factoryCache.put(
                     objectClass,
                     factory);
         }
 
         return factory;
     }
 
     /**
      * Allows us to set default validation to true/false for all instances of objects instantiated by this factory. This
      * is necessary in some cases where the underlying parser doesn't support schema validation (such as when performing
      * JUnit tests)
      *
      * @param validating true/false
      */
     public static void setDefaultValidating(final boolean validating)
     {
         defaultValidating = validating;
     }
 
     /**
      * Sets whether or not the XmlObjectFactory should be validating, default is <code>true</code>. If it IS set to be
      * validating, then there needs to be a schema named objectClass.xsd in the same package as the objectClass that
      * this factory was created from.
      *
      * @param validating true/false
      */
     public void setValidating(final boolean validating)
     {
         this.digester.setValidating(validating);
         if (validating)
         {
             if (this.schemaUri == null)
             {
                 final String schemaLocation = '/' + this.objectClass.getName().replace(
                         '.',
                         '/') + SCHEMA_SUFFIX;
                 this.schemaUri = XmlObjectFactory.class.getResource(schemaLocation);
                 InputStream stream = null;
                 try
                 {
                     if (this.schemaUri != null)
                     {
                         stream = this.schemaUri.openStream();
                         IOUtils.closeQuietly(stream);
                     }
                 }
                 catch (final IOException exception)
                 {
                     this.schemaUri = null;
                 }
                 finally
                 {
                     if (stream != null)
                     {
                         IOUtils.closeQuietly(stream);
                     }
                 }
                 if (this.schemaUri == null)
                 {
                     logger.warn(
                             "WARNING! Was not able to find schemaUri --> '" + schemaLocation +
                                     "' continuing in non validating mode");
                 }
             }
             if (this.schemaUri != null)
             {
                 try
                 {
                     this.digester.setProperty("http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation", this.schemaUri.toString());
                     this.digester.setProperty("http://java.sun.com/xml/jaxp/properties/schemaLanguage", XMLConstants.W3C_XML_SCHEMA_NS_URI);
 
                     this.digester.setErrorHandler(new XmlObjectValidator());
                 }
                 catch (final Exception exception)
                 {
                     logger.warn(
                             "WARNING! Your parser does NOT support the " +
                                     " schema validation continuing in non validation mode",
                             exception);
                 }
             }
         }
     }
 
     /**
      * Returns a configured Object based on the objectXml configuration file
      *
      * @param objectXml the path to the Object XML config file.
      * @return Object the created instance.
      */
     public Object getObject(final URL objectXml)
     {
         return this.getObject(
                 objectXml != null ? ResourceUtils.getContents(objectXml) : null,
                 objectXml);
     }
 
     /**
      * Returns a configured Object based on the objectXml configuration reader.
      *
      * @param objectXml the path to the Object XML config file.
      * @return Object the created instance.
      */
     public Object getObject(final Reader objectXml)
     {
         return getObject(ResourceUtils.getContents(objectXml));
     }
 
     /**
      * Returns a configured Object based on the objectXml configuration file passed in as a String.
      *
      * @param objectXml the path to the Object XML config file.
      * @return Object the created instance.
      */
     public Object getObject(String objectXml)
     {
         return this.getObject(
                 objectXml,
                 null);
     }
 
     /**
      * Returns a configured Object based on the objectXml configuration file passed in as a String.
      *
      * @param objectXml the path to the Object XML config file.
      * @param resource  the resource from which the objectXml was retrieved (this is needed to resolve
      *                  any relative references; like XML entities).
      * @return Object the created instance.
      */
     public Object getObject(
             String objectXml,
             final URL resource)
     {
         ExceptionUtils.checkNull(
                 "objectXml",
                 objectXml);
         Object object = null;
         try
         {
             this.digester.setEntityResolver(new XmlObjectEntityResolver(resource));
             object = this.digester.parse(new StringReader(objectXml));
             objectXml = null;
             if (object == null)
             {
                 final String message =
                         "Was not able to instantiate an object using objectRulesXml '" + this.objectRulesXml +
                                 "' with objectXml '" + objectXml + "', please check either the objectXml " +
                                 "or objectRulesXml file for inconsistencies";
                 throw new XmlObjectFactoryException(message);
             }
         }
         catch (final SAXException exception)
         {
             final Throwable cause = ExceptionUtils.getRootCause(exception);
             logger.warn("SAXException " + schemaUri, cause);
             if (cause instanceof SAXException)
             {
                 final String message =
                         "VALIDATION FAILED for --> '" + objectXml + "' against SCHEMA --> '" + this.schemaUri +
                                 "' --> message: '" + exception.getMessage() + '\'';
                 throw new XmlObjectFactoryException(message);
             }
             throw new XmlObjectFactoryException(cause);
         }
         catch (final Throwable throwable)
         {
             final String message = "XML resource could not be loaded --> '" + objectXml + '\'';
             throw new XmlObjectFactoryException(message, throwable);
         }
         return object;
     }
 
     /**
      * Handles the validation errors.
      */
     static final class XmlObjectValidator
             implements ErrorHandler
     {
         /**
          * @see org.xml.sax.ErrorHandler#error(org.xml.sax.SAXParseException)
          */
         public final void error(final SAXParseException exception)
                 throws SAXException
         {
             throw new SAXException(getMessage(exception));
         }
 
         /**
          * @see org.xml.sax.ErrorHandler#fatalError(org.xml.sax.SAXParseException)
          */
         public final void fatalError(final SAXParseException exception)
                 throws SAXException
         {
             throw new SAXException(getMessage(exception));
         }
 
         /**
          * @see org.xml.sax.ErrorHandler#warning(org.xml.sax.SAXParseException)
          */
         public final void warning(final SAXParseException exception)
         {
             logger.warn("WARNING!: " + getMessage(exception));
         }
 
         /**
          * Constructs and returns the appropriate error message.
          *
          * @param exception the exception from which to extract the message.
          * @return the message.
          */
         @SuppressWarnings("static-method")
         private String getMessage(final SAXParseException exception)
         {
             final StringBuilder message = new StringBuilder(100);
 
             message.append(exception.getMessage());
             message.append(", line: ");
             message.append(exception.getLineNumber());
             message.append(", column: ").append(exception.getColumnNumber());
 
             return message.toString();
         }
     }
 
     /**
      * The prefix that the systemId should start with when attempting
      * to resolve it within a jar.
      */
     private static final String SYSTEM_ID_FILE = "file:";
 
     /**
      * Provides the resolution of external entities from the classpath.
      */
     private static final class XmlObjectEntityResolver
             implements EntityResolver
     {
         private URL xmlResource;
 
         XmlObjectEntityResolver(final URL xmlResource)
         {
             this.xmlResource = xmlResource;
         }
 
         /**
          * @see org.xml.sax.EntityResolver#resolveEntity(String, String)
          */
         public InputSource resolveEntity(
                 final String publicId,
                 final String systemId)
                 throws SAXException, IOException
         {
             InputSource source = null;
             if (this.xmlResource != null)
             {
                 String path = systemId;
                 if (path != null && path.startsWith(SYSTEM_ID_FILE))
                 {
                     final String xmlResource = this.xmlResource.toString();
                     path = path.replaceFirst(
                             SYSTEM_ID_FILE,
                             "");
 
                     // - remove any extra starting slashes
                     path = ResourceUtils.normalizePath(path);
 
                     // - if we still have one starting slash, remove it
                     if (path.startsWith("/"))
                     {
                         path = path.substring(
                                 1,
                                 path.length());
                     }
                     final String xmlResourceName = xmlResource.replaceAll(
                             ".*(\\+|/)",
                             "");
                     URL uri = null;
                     InputStream inputStream = null;
                     try
                     {
                         uri = ResourceUtils.toURL(StringUtils.replace(
                                 xmlResource,
                                 xmlResourceName,
                                 path));
                         if (uri != null)
                         {
                             inputStream = uri.openStream();
                         }
                     }
                     catch (final IOException exception)
                     {
                         // - ignore
                     }
                     if (inputStream == null)
                     {
                         try
                         {
                             uri = ResourceUtils.getResource(path);
                             if (uri != null)
                             {
                                 inputStream = uri.openStream();
                             }
                         }
                         catch (final IOException exception)
                         {
                             // - ignore
                         }
                     }
                     if (inputStream != null && uri != null)
                     {
                         source = new InputSource(inputStream);
                         source.setPublicId(publicId);
                         source.setSystemId(uri.toString());
                     }
                     // TODO Close InputStream while still returning a valid InputSource
                 }
             }
             return source;
         }
     }
 
     /**
      * @see Object#toString()
      */
     @Override
     public String toString()
     {
         StringBuilder builder = new StringBuilder();
         builder.append(super.toString()).append(" [digester=").append(this.digester)
                 .append(", objectClass=").append(this.objectClass).append(", objectRulesXml=")
                 .append(this.objectRulesXml).append(", schemaUri=").append(this.schemaUri)
                 .append("]");
         return builder.toString();
     }
 }