Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2013-2015 Mozilla Foundation
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   * and/or sell copies of the Software, and to permit persons to whom the
   * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
 
 package nu.validator.validation;
 
 import java.io.File;
 import java.net.URL;
 
 
 
 
Simple validation interface.
 
 public class SimpleDocumentValidator {
 
 
     private Schema mainSchema;
 
     private boolean hasHtml5Schema;
 
     private Schema assertionSchema;
 
     private Validator validator;
 
     private SourceCode sourceCode = new SourceCode();
 
     private HtmlParser htmlParser = null;
 
     private XMLReader htmlReader;
 
    private SAXDriver xmlParser;
    private XMLReader xmlReader;
    private Schema schemaByUrl(String schemaUrlErrorHandler errorHandler)
            throws ExceptionSchemaReadException {
        PropertyMapBuilder pmb = new PropertyMapBuilder();
        pmb.put(.errorHandler);
                new Jaxp11XMLReaderCreator());
        ..add(pmb);
        PropertyMap jingPropertyMap = pmb.toPropertyMap();
        try {
            TypedInputSource schemaInput = (TypedInputSource.resolveEntity(
                    nullschemaUrl);
            SchemaReader sr;
            if ("application/relax-ng-compact-syntax".equals(schemaInput.getType())) {
                sr = CompactSchemaReader.getInstance();
            } else {
                sr = new AutoSchemaReader();
            }
            return sr.createSchema(schemaInputjingPropertyMap);
        } catch (ClassCastException e) {
            throw new SchemaReadException(String.format(
                    "Failed to resolve schema URL \"%s\"."schemaUrl));
        }
    }
    public SimpleDocumentValidator() {
        PropertyConfigurator.configure(SimpleDocumentValidator.class.getClassLoader().getResource(
                "nu/validator/localentities/files/log4j.properties"));
        this. = new LocalCacheEntityResolver(
                new NullEntityResolver());
        this..setAllowRnc(true);
    }
    public SourceCode getSourceCode() {
        return this.;
    }
    /* *
     * Prepares the main RelaxNG schema to use for document validation, by
     * retrieving a serialized schema instance from the copies of known
     * http://s.validator.nu/* schemas in the local entity cache packaged with
     * the validator code and creating a Schema instance from it. Also checks
     * for resolution of secondary schemas.
     * 
     * @param schemaUrl an http://s.validator.nu/* URL
     * 
     * @param errorHandler error handler for schema-error reporting
     * 
     * @throws SchemaReadException if retrieval of any schema fails
     */
    public void setUpMainSchema(String schemaUrlErrorHandler errorHandler)
            throws SAXExceptionExceptionSchemaReadException {
        Schema schema = schemaByUrl(schemaUrlerrorHandler);
        if (schemaUrl.contains("html5")) {
            try {
                 = .;
            } catch (Exception e) {
                throw new SchemaReadException(
                        "Failed to retrieve secondary schema.");
            }
            schema = new DataAttributeDroppingSchemaWrapper(schema);
            schema = new XmlLangAttributeDroppingSchemaWrapper(schema);
            schema = new RoleAttributeFilteringSchemaWrapper(schema);
            this. = true;
            if ("http://s.validator.nu/html5-all.rnc".equals(schemaUrl)) {
                System.setProperty("nu.validator.schema.rdfa-full""1");
            } else {
                System.setProperty("nu.validator.schema.rdfa-full""0");
            }
        }
        this. = schema;
    }
    /* *
     * Prepares a Validator instance along with HTML and XML parsers, and then
     * attaches the Validator instance and supplied ErrorHandler instance to the
     * parsers so that the ErrorHandler is used for processing of all document-
     * validation problems reported.
     * 
     * @param docValidationErrHandler error handler for doc-validation reporting
     * 
     * @param loadExternalEnts whether XML parser should load remote DTDs, etc.
     * 
     * @param noStream whether HTML parser should buffer instead of streaming
     */
    public void setUpValidatorAndParsers(ErrorHandler docValidationErrHandler,
            boolean noStreamboolean loadExternalEntsthrows SAXException {
        PropertyMapBuilder pmb = new PropertyMapBuilder();
        pmb.put(.docValidationErrHandler);
                new Jaxp11XMLReaderCreator());
        ..add(pmb);
        PropertyMap jingPropertyMap = pmb.toPropertyMap();
         = this..createValidator(jingPropertyMap);
        if (this.) {
            Validator assertionValidator = .createValidator(jingPropertyMap);
             = new CombineValidator(assertionValidator);
             = new CombineValidator(new CheckerValidator(
                    new TableChecker(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new ConformingButObsoleteWarner(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new MicrodataChecker(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new NormalizationChecker(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new TextContentChecker(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new UncheckedSubtreeWarner(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new UnsupportedFeatureChecker(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new UsemapChecker(), jingPropertyMap));
             = new CombineValidator(new CheckerValidator(
                    new XmlPiChecker(), jingPropertyMap));
        }
         = new HtmlParser();
        .setMappingLangToXmlLang(true);
        .setErrorHandler(docValidationErrHandler);
        .setMappingLangToXmlLang(true);
        .setFeature(
                "http://xml.org/sax/features/unicode-normalization-checking",
                true);
        if (!noStream) {
        }
         = getWiretap();
         = new SAXDriver();
        if ( != null) {
            .setProperty(
                    "http://xml.org/sax/properties/lexical-handler",
                    (LexicalHandler);
        }
         = new IdFilter();
        .setFeature("http://xml.org/sax/features/string-interning"true);
        .setFeature(
                "http://xml.org/sax/features/unicode-normalization-checking",
                true);
        if (loadExternalEnts) {
        } else {
            .setFeature(
                    "http://xml.org/sax/features/external-general-entities",
                    false);
            .setFeature(
                    "http://xml.org/sax/features/external-parameter-entities",
                    false);
            .setEntityResolver(new NullEntityResolver());
        }
         = getWiretap();
        .setErrorHandler(docValidationErrHandler);
        .lockErrorHandler();
    }
    private WiretapXMLReaderWrapper getWiretap(XMLReader reader) {
        WiretapXMLReaderWrapper wiretap = new WiretapXMLReaderWrapper(reader);
        ContentHandler recorder = .getLocationRecorder();
        wiretap.setWiretapContentHander(recorder);
        wiretap.setWiretapLexicalHandler((LexicalHandlerrecorder);
        return wiretap;
    }
    /* *
     * Checks an InputSource as a text/html HTML document.
     */
    public void checkHtmlInputSource(InputSource isthrows IOException,
            SAXException {
        .reset();
        is.setEncoding("UTF-8");
        checkAsHTML(is);
    }
    /* *
     * Checks an InputSource as an XHTML/XML document.
     */
    public void checkXmlInputSource(InputSource isthrows IOException,
            SAXException {
        .reset();
        checkAsXML(is);
    }
    /* *
     * Checks a text/html HTML document.
     */
    public void checkHtmlFile(File fileboolean asUTF8throws IOException,
            SAXException {
        .reset();
        InputSource is = new InputSource(new FileInputStream(file));
        is.setSystemId(file.toURI().toURL().toString());
        if (asUTF8) {
            is.setEncoding("UTF-8");
        }
        checkAsHTML(is);
    }
    /* *
     * Checks an XHTML document or other XML document.
     */
    public void checkXmlFile(File filethrows IOExceptionSAXException {
        .reset();
        InputSource is = new InputSource(new FileInputStream(file));
        is.setSystemId(file.toURI().toURL().toString());
        checkAsXML(is);
    }
    /* *
     * Checks a Web document.
     * 
     * @throws IOException if loading of the URL fails for some reason
     */
    public void checkHttpURL(URL urlthrows IOExceptionSAXException {
        String address = url.toString();
        .reset();
        HttpURLConnection connection = (HttpURLConnectionurl.openConnection();
        String contentType = connection.getContentType();
        InputSource is = new InputSource(url.openStream());
        is.setSystemId(address);
        for (String param : contentType.replace(" """).split(";")) {
            if (param.startsWith("charset=")) {
                is.setEncoding(param.split("=", 2)[1]);
                break;
            }
        }
        if (connection.getContentType().startsWith("text/html")) {
            checkAsHTML(is);
        } else {
            checkAsXML(is);
        }
    }
    /* *
     * Parses a document with the text/html parser and validates it.
     */
    private void checkAsHTML(InputSource isthrows IOExceptionSAXException {
        .initialize(is);
        try {
            .parse(is);
        } catch (SAXParseException e) {
        }
    }
    /* *
     * Parses a document with the XML parser and validates it.
     */
    private void checkAsXML(InputSource isthrows IOExceptionSAXException {
        .initialize(is);
        try {
            .parse(is);
        } catch (SAXParseException e) {
        }
    }
    @SuppressWarnings("serial"public class SchemaReadException extends
            Exception {
        public SchemaReadException() {
        }
        public SchemaReadException(String message) {
            super(message);
        }
    }
New to GrepCode? Check out our FAQ X