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.client;
 
 import java.io.File;
 import java.net.URL;
 import java.util.List;
 
 
Simple command-line validator for HTML/XHTML files.
 
 public class SimpleCommandLineValidator {
 
     private static Package pkg = SimpleCommandLineValidator.class.getPackage();
 
     private static String version = .getImplementationVersion();
 
     private static SimpleDocumentValidator validator;
 
     private static OutputStream out;
 
     private static MessageEmitterAdapter errorHandler;
 
     private static boolean verbose;
 
     private static boolean errorsOnly;
 
     private static boolean loadEntities;
 
     private static boolean noStream;
 
     private static boolean skipNonHTML;
 
     private static boolean forceHTML;
 
     private static boolean asciiQuotes;
 
     private static int lineOffset;
 
     private static enum OutputFormat {
         HTML, XHTML, TEXT, XML, JSON, RELAXED, SOAP, UNICORN, GNU
     }
 
     private static OutputFormat outputFormat;
 
     public static void main(String[] argsthrows SAXExceptionException {
          = .;
         System.setProperty("nu.validator.datatype.warn""true");
          = false;
          = false;
          = false;
          = false;
          = false;
          = 0;
          = false;
          = false;
 
         String outFormat = null;
        String schemaUrl = null;
        boolean hasFileArgs = false;
        boolean readFromStdIn = false;
        int fileArgsStart = 0;
        if (args.length == 0) {
            usage();
            System.exit(1);
        }
        for (int i = 0; i < args.lengthi++) {
            if (args[i].equals("-")) {
                readFromStdIn = true;
                break;
            } else if (!args[i].startsWith("--")) {
                hasFileArgs = true;
                fileArgsStart = i;
                break;
            } else {
                if ("--verbose".equals(args[i])) {
                     = true;
                } else if ("--errors-only".equals(args[i])) {
                     = true;
                    System.setProperty("nu.validator.datatype.warn""false");
                } else if ("--format".equals(args[i])) {
                    outFormat = args[++i];
                } else if ("--version".equals(args[i])) {
                    if ( != null) {
                        ..println();
                    } else {
                        ..println("[uknown version]");
                    }
                    System.exit(0);
                } else if ("--help".equals(args[i])) {
                    help();
                    System.exit(0);
                } else if ("--skip-non-html".equals(args[i])) {
                     = true;
                } else if ("--html".equals(args[i])) {
                     = true;
                } else if ("--entities".equals(args[i])) {
                     = true;
                } else if ("--no-stream".equals(args[i])) {
                     = true;
                } else if ("--schema".equals(args[i])) {
                    schemaUrl = args[++i];
                    if (!schemaUrl.startsWith("http:")) {
                        ..println("error: The \"--schema\" option"
                                + " requires a URL for a schema.");
                        System.exit(1);
                    }
                }
            }
        }
        if (schemaUrl == null) {
            schemaUrl = "http://s.validator.nu/html5-rdfalite.rnc";
        }
        if (outFormat == null) {
             = .;
        } else {
            if ("text".equals(outFormat)) {
                 = .;
            } else if ("gnu".equals(outFormat)) {
                 = .;
            } else if ("xml".equals(outFormat)) {
                 = .;
            } else if ("json".equals(outFormat)) {
                 = .;
            } else {
                ..printf("Error: Unsupported output format \"%s\"."
                        + " Must be \"gnu\", \"xml\", \"json\","
                        + " or \"text\".\n"outFormat);
                System.exit(1);
            }
        }
        if (readFromStdIn) {
            InputSource is = new InputSource(.);
             = new SimpleDocumentValidator();
            setup(schemaUrl);
            .checkHtmlInputSource(is);
            end();
        } else if (hasFileArgs) {
            List<Filefiles = new ArrayList<File>();
            for (int i = fileArgsStarti < args.lengthi++) {
                files.add(new File(args[i]));
            }
             = new SimpleDocumentValidator();
            setup(schemaUrl);
            checkFiles(files);
            end();
        } else {
            ..printf("\nError: No documents specified.\n");
            usage();
            System.exit(1);
        }
    }
    private static void setup(String schemaUrlthrows SAXExceptionException {
        setErrorHandler();
        .setHtml(true);
        .start(null);
        try {
            .setUpMainSchema(schemaUrlnew SystemErrErrorHandler());
        } catch (SchemaReadException e) {
            ..println(e.getMessage() + " Terminating.");
            System.exit(1);
        } catch (StackOverflowError e) {
            ..println("StackOverflowError"
                    + " while evaluating HTML schema.");
            ..println("The checker requires a java thread stack size"
                    + " of at least 512k.");
            ..println("Consider invoking java with the -Xss"
                    + " option. For example:");
            ..println("\n  java -Xss512k -jar ~/vnu.jar FILE.html");
            System.exit(1);
        }
    }
    private static void end() throws SAXException {
        .end("Document checking completed. No errors found.",
                "Document checking completed.");
        if (.getErrors() > 0 || .getFatalErrors() > 0) {
            System.exit(1);
        }
    }
    private static void checkFiles(List<Filefilesthrows SAXException,
            IOException {
        for (File file : files) {
            if (file.isDirectory()) {
                recurseDirectory(file);
            } else {
                checkHtmlFile(file);
            }
        }
    }
    private static void recurseDirectory(File directorythrows SAXException,
            IOException {
        if (directory.canRead()) {
            File[] files = directory.listFiles();
            for (int i = 0; i < files.lengthi++) {
                File file = files[i];
                if (file.isDirectory()) {
                    recurseDirectory(file);
                } else {
                    checkHtmlFile(file);
                }
            }
        }
    }
    private static void checkHtmlFile(File filethrows IOException {
        try {
            String path = file.getPath();
            if (path.matches("^http:/[^/].+$")) {
                path = "http://" + path.substring(path.indexOf('/') + 1);
                emitFilename(path);
                try {
                    .checkHttpURL(new URL(path));
                } catch (IOException e) {
                    .error(new SAXParseException(e.toString(),
                            nullpath, -1, -1));
                }
            } else if (path.matches("^https:/[^/].+$")) {
                path = "https://" + path.substring(path.indexOf('/') + 1);
                emitFilename(path);
                try {
                    .checkHttpURL(new URL(path));
                } catch (IOException e) {
                    .error(new SAXParseException(e.toString(),
                            nullpath, -1, -1));
                }
            } else if (!file.exists()) {
                if () {
                    .warning(new SAXParseException(
                            "File not found."null,
                            file.toURI().toURL().toString(), -1, -1));
                }
                return;
            } else if (isHtml(file)) {
                emitFilename(path);
                .checkHtmlFile(filetrue);
            } else if (isXhtml(file)) {
                emitFilename(path);
                if () {
                    .checkHtmlFile(filetrue);
                } else {
                    .checkXmlFile(file);
                }
            } else {
                if () {
                    .warning(new SAXParseException(
                            "File was not checked. Files must have .html,"
                                    + " .xhtml, .htm, or .xht extensions.",
                            nullfile.toURI().toURL().toString(), -1, -1));
                }
            }
        } catch (SAXException e) {
            if (!) {
                ..printf("\"%s\":-1:-1: warning: %s\n",
                        file.toURI().toURL().toString(), e.getMessage());
            }
        }
    }
    private static boolean isXhtml(File file) {
        String name = file.getName();
        return (name.endsWith(".xhtml") || name.endsWith(".xht"));
    }
    private static boolean isHtml(File file) {
        String name = file.getName();
        return (name.endsWith(".html") || name.endsWith(".htm") || !);
    }
    private static void emitFilename(String name) {
        if () {
            ..println(name);
        }
    }
    private static void setErrorHandler() {
        SourceCode sourceCode = new SourceCode();
        ImageCollector imageCollector = new ImageCollector(sourceCode);
        boolean showSource = false;
        if ( == .) {
             = new MessageEmitterAdapter(sourceCodeshowSource,
                    imageCollectortruenew TextMessageEmitter(
                            ));
        } else if ( == .) {
             = new MessageEmitterAdapter(sourceCodeshowSource,
                    imageCollectortruenew GnuMessageEmitter(
                            ));
        } else if ( == .) {
             = new MessageEmitterAdapter(sourceCodeshowSource,
                    imageCollectortruenew XmlMessageEmitter(
                            new XmlSerializer()));
        } else if ( == .) {
            String callback = null;
             = new MessageEmitterAdapter(sourceCodeshowSource,
                    imageCollectortruenew JsonMessageEmitter(
                            new nu.validator.json.Serializer(), callback));
        } else {
            throw new RuntimeException("Bug. Should be unreachable.");
        }
    }
    private static void usage() {
        ..println("Usage:");
        ..println("");
        ..println("    java -jar vnu.jar [--errors-only] [--no-stream]");
        ..println("         [--format gnu|xml|json|text] [--help] [--html]");
        ..println("         [--verbose] [--version] FILES");
        ..println("");
        ..println("    java -cp vnu.jar nu.validator.servlet.Main 8888");
        ..println("");
        ..println("    java -cp vnu.jar nu.validator.client.HttpClient FILES");
        ..println("");
        ..println("For detailed usage information, use \"java -jar vnu.jar --help\" or see:");
        ..println("");
        ..println("  http://validator.github.io/");
        ..println("");
        ..println("To read from stdin, use \"-\" as the filename, like this: \"java -jar vnu.jar - \".");
    }
    private static void help() {
                "nu/validator/localentities/files/cli-help");
        try {
            ..println("");
            for (int b = help.read(); b != -1; b = help.read()) {
                ..write(b);
            }
            help.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
New to GrepCode? Check out our FAQ X