Examples with CFLintChainedConfig com.cflint.config.CFLintChainedConfig used on opensource projects

Example 1 with CFLintChainedConfig

use of com.cflint.config.CFLintChainedConfig in project CFLint by cflint.

the class CFLintMain method main.

public static void main(final String[] args) throws Exception {
    final Options options = new Options();
    options.addOption(RULES, false, "list of all supported rules");
    options.addOption("config", false, "list of rules in config file");
    options.addOption(INCLUDE_RULE, true, "specify rules to include");
    options.addOption(EXCLUDE_RULE, true, "specify rules to exclude");
    options.addOption(FOLDER, true, "folder(s) to scan");
    options.addOption("file", true, "file(s) to scan");
    options.addOption(FILTER_FILE, true, "filter file");
    options.addOption("v", false, VERBOSE);
    options.addOption("version", false, "show the version number");
    options.addOption("ui", false, "show UI");
    options.addOption(VERBOSE, false, VERBOSE);
    options.addOption(SHOWPROGRESS, false, "show progress bar");
    options.addOption("singlethread", false, "show progress bar");
    options.addOption("logerror", false, "log parsing errors as bugs");
    options.addOption("e", false, "log parsing errors as bugs");
    options.addOption("q", false, QUIET);
    options.addOption(QUIET, false, QUIET);
    options.addOption("?", false, DISPLAY_THIS_HELP);
    options.addOption("h", false, DISPLAY_THIS_HELP);
    options.addOption("help", false, DISPLAY_THIS_HELP);
    options.addOption("xml", false, "output in xml format");
    options.addOption(XMLFILE, true, "specify the output xml file (default: cflint-results.xml)");
    options.addOption(XMLSTYLE, true, "cflint,findbugs");
    options.addOption("html", false, "output in html format (default)");
    options.addOption(HTMLFILE, true, "specify the output html file (default: cflint-results.html)");
    // fancy,fancy-hist,summary
    options.addOption(HTMLSTYLE, true, "default,plain");
    options.addOption("json", false, "output in json format");
    options.addOption(JSONFILE, true, "specify the output json file (default: cflint-results.json)");
    options.addOption("text", false, "output in plain text");
    options.addOption(TEXTFILE, true, "specify the output text file (default: cflint-results.txt)");
    options.addOption("stats", false, "show bug count statstics");
    options.addOption(EXTENSIONS, true, "specify the extensions of the CF source files (default: .cfm,.cfc)");
    options.addOption(CONFIGFILE, true, "specify the location of the config file");
    options.addOption(STDIN, true, "use stdin for file input (default: source.cfc)");
    options.addOption("stdout", false, "output to stdout only");
    options.addOption("listrulegroups", false, "list rule groups");
    options.addOption("rulegroups", true, "rule groups");
    final CommandLineParser parser = new GnuParser();
    final CommandLine cmd = parser.parse(options, args);
    final CFLintMain main = new CFLintMain();
    if (cmd.hasOption('h') || cmd.hasOption("help") || cmd.hasOption("?")) {
        final HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(CFLINT, options);
        return;
    }
    if (cmd.hasOption("version")) {
        System.out.println("CFLint " + Version.getVersion());
        System.out.println("CFParser " + cfml.parsing.Version.getVersion());
        return;
    }
    if (cmd.hasOption(RULES) || cmd.hasOption("config")) {
        final CFLintPluginInfo pluginInfo = cmd.hasOption(RULES) ? ConfigUtils.loadDefaultPluginInfo() : new CFLintPluginInfo();
        main.defaultConfig = new CFLintConfig();
        main.defaultConfig.setRules(pluginInfo.getRules());
        CFLintChainedConfig myConfig = new CFLintChainedConfig(main.defaultConfig);
        if (cmd.hasOption(CONFIGFILE)) {
            final String configfile = cmd.getOptionValue(CONFIGFILE);
            myConfig = myConfig.createNestedConfig(loadConfig(configfile));
        }
        final HashMap<String, String> descriptions = ConfigUtils.loadDescriptions();
        System.out.println("Supported rules");
        for (final PluginInfoRule rule : myConfig.getRules()) {
            System.out.println("  " + rule.getName());
            for (final PluginMessage message : rule.getMessages()) {
                System.out.println("    " + message.getCode() + " - " + descriptions.get(message.getCode()));
            }
        }
        return;
    }
    final CFLintPluginInfo pluginInfo = ConfigUtils.loadDefaultPluginInfo();
    main.defaultConfig = new CFLintConfig();
    main.defaultConfig.setRules(pluginInfo.getRules());
    if (cmd.hasOption("listrulegroups")) {
        listRuleGroups(pluginInfo);
        return;
    }
    // groups are specified
    if (cmd.hasOption("rulegroups")) {
        final String rulegroups = cmd.getOptionValue("rulegroups");
        applyRuleGroups(main, pluginInfo, rulegroups);
    } else {
        // Exclude the experimental by default.
        applyRuleGroups(main, pluginInfo, "!Experimental");
    }
    main.verbose = (cmd.hasOption('v') || cmd.hasOption(VERBOSE));
    main.quiet = (cmd.hasOption('q') || cmd.hasOption(QUIET));
    main.logerror = (cmd.hasOption('e') || cmd.hasOption("logerror"));
    main.xmlOutput = cmd.hasOption("xml") || cmd.hasOption(XMLSTYLE) || cmd.hasOption(XMLFILE);
    main.textOutput = cmd.hasOption("text") || cmd.hasOption(TEXTFILE);
    main.jsonOutput = cmd.hasOption("json") || cmd.hasOption("jsonFile");
    main.showStats = cmd.hasOption("stats");
    if (cmd.hasOption("ui")) {
        main.ui();
    }
    // If an output is specified, htmlOutput is not defaulted to true.
    if (main.xmlOutput || main.textOutput || main.jsonOutput) {
        main.htmlOutput = cmd.hasOption("html") || cmd.hasOption(HTMLSTYLE) || cmd.hasOption(HTMLFILE);
    }
    if (main.verbose) {
        System.out.println("XML Output " + main.xmlOutput);
        System.out.println("Text Output " + main.textOutput);
        System.out.println("JSON Output " + main.jsonOutput);
        System.out.println("HTML Output " + main.htmlOutput);
    }
    if (cmd.hasOption(FOLDER)) {
        main.folder.addAll(Arrays.asList(cmd.getOptionValue(FOLDER).split(",")));
    }
    if (cmd.hasOption("file")) {
        main.folder.addAll(Arrays.asList(cmd.getOptionValue("file").split(",")));
    }
    if (cmd.hasOption(HTMLSTYLE)) {
        main.htmlStyle = cmd.getOptionValue(HTMLSTYLE);
        if (!main.htmlStyle.endsWith(".xsl") && !main.htmlStyle.endsWith(".xslt")) {
            main.htmlStyle = main.htmlStyle + ".xsl";
        }
    }
    if (cmd.hasOption(XMLSTYLE)) {
        main.xmlstyle = cmd.getOptionValue(XMLSTYLE);
    }
    if (cmd.hasOption(FILTER_FILE)) {
        main.filterFile = cmd.getOptionValue(FILTER_FILE);
    }
    if (cmd.hasOption(XMLFILE)) {
        main.xmlOutFile = cmd.getOptionValue(XMLFILE);
    }
    if (cmd.hasOption(JSONFILE)) {
        main.jsonOutFile = cmd.getOptionValue(JSONFILE);
    }
    if (cmd.hasOption(CONFIGFILE)) {
        final String configfile = cmd.getOptionValue(CONFIGFILE);
        main.configFileConfig = loadConfig(configfile);
    }
    if (cmd.hasOption(HTMLFILE)) {
        main.htmlOutFile = cmd.getOptionValue(HTMLFILE);
    }
    if (cmd.hasOption(TEXTFILE)) {
        main.textOutFile = cmd.getOptionValue(TEXTFILE);
    }
    if (cmd.hasOption(JSONFILE)) {
        main.jsonOutFile = cmd.getOptionValue(JSONFILE);
    }
    if (cmd.hasOption(EXTENSIONS)) {
        main.extensions = cmd.getOptionValue(EXTENSIONS);
    }
    if (cmd.hasOption(INCLUDE_RULE) || cmd.hasOption(EXCLUDE_RULE)) {
        main.cmdLineConfig = new CFLintConfig();
        if (cmd.hasOption(INCLUDE_RULE)) {
            for (final String code : cmd.getOptionValue(INCLUDE_RULE).split(",")) {
                main.cmdLineConfig.addInclude(new PluginMessage(code));
                main.cmdLineConfig.setInheritParent(false);
            }
        }
        if (cmd.hasOption(EXCLUDE_RULE)) {
            for (final String code : cmd.getOptionValue(EXCLUDE_RULE).split(",")) {
                main.cmdLineConfig.addExclude(new PluginMessage(code));
            }
        }
    }
    main.showprogress = cmd.hasOption(SHOWPROGRESS) || (!cmd.hasOption(SHOWPROGRESS) && cmd.hasOption("ui"));
    main.progressUsesThread = !cmd.hasOption("singlethread");
    main.stdIn = cmd.hasOption(STDIN);
    if (main.stdIn) {
        final String stdInOptionValue = cmd.getOptionValue(STDIN);
        if (stdInOptionValue != null) {
            main.stdInFile = stdInOptionValue;
        }
    }
    main.stdOut = cmd.hasOption("stdout");
    if (main.isValid()) {
        main.execute();
        if (cmd.hasOption("ui")) {
            main.open();
        }
    } else {
        final HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(CFLINT, options);
    }
}

Example 2 with CFLintChainedConfig

use of com.cflint.config.CFLintChainedConfig in project CFLint by cflint.

the class CFLintMain method buildConfigChain.

private CFLintConfiguration buildConfigChain() {
    CFLintChainedConfig myConfig = new CFLintChainedConfig(defaultConfig);
    myConfig = myConfig.createNestedConfig(configFileConfig);
    return myConfig.createNestedConfig(cmdLineConfig);
}

Example 3 with CFLintChainedConfig

use of com.cflint.config.CFLintChainedConfig in project CFLint by cflint.

the class CFLint method scan.

public void scan(final File folderOrFile) {
    if (debug) {
        System.out.println("Current file: " + folderOrFile.getAbsolutePath());
    }
    if (getBugs().getFileFilter() != null && !getBugs().getFileFilter().includeFile(folderOrFile)) {
        return;
    }
    if (!folderOrFile.exists()) {
        System.err.println("File " + folderOrFile + " does not exist.");
        return;
    }
    if (folderOrFile.isDirectory()) {
        if (folderOrFile.getName().startsWith(".") && !folderOrFile.getName().equals(".")) {
            if (verbose) {
                System.out.println("Skipping folder and its children: " + folderOrFile.getAbsolutePath());
            }
            return;
        }
        final CFLintConfiguration saveConfig = configuration;
        try {
            for (final File file : folderOrFile.listFiles()) {
                if (file.getName().toLowerCase().equals(".cflintrc" + getEnvSuffix())) {
                    try {
                        if (verbose) {
                            System.out.println("read config " + file);
                        }
                        @SuppressWarnings("deprecation") final CFLintConfiguration newConfig = file.getName().toLowerCase().endsWith(".xml") ? ConfigUtils.unmarshal(file, CFLintConfig.class) : ConfigUtils.unmarshalJson(new FileInputStream(file), CFLintConfig.class);
                        configuration = new CFLintChainedConfig(newConfig, configuration);
                    } catch (final Exception e) {
                        System.err.println("Could not read config file " + file);
                    }
                }
            }
            for (final File file : folderOrFile.listFiles()) {
                scan(file);
            }
        } finally {
            configuration = saveConfig;
        }
    } else if (!folderOrFile.isHidden() && FileUtil.checkExtension(folderOrFile, allowedExtensions)) {
        if (!debug && verbose) {
            System.out.println("Current file: " + folderOrFile.getAbsolutePath());
        }
        final String src = FileUtil.loadFile(folderOrFile);
        includeFileStack.clear();
        try {
            // Report number of lines in the source
            stats.addFile(src == null || src.length() == 0 ? 0 : src.split("\\R").length + 1);
            process(src, folderOrFile.getAbsolutePath());
        } catch (final Exception e) {
            printException(e);
            if (logError) {
                System.err.println("Logging Error: " + FILE_ERROR);
                fireCFLintException(e, FILE_ERROR, folderOrFile.getAbsolutePath(), null, null, null, null);
            }
        }
    }
}

Example 4 with CFLintChainedConfig

use of com.cflint.config.CFLintChainedConfig in project CFLint by cflint.

the class TestFiles method loadPluginInfo.

public static CFLintConfiguration loadPluginInfo(final File folder) throws IOException {
    final CFLintChainedConfig config = new CFLintChainedConfig(CFLintConfig.createDefault());
    try {
        final InputStream jsonInputStream = new FileInputStream(folder.getPath() + "/.cflintrc");
        final CFLintConfig retval = ConfigUtils.unmarshalJson(jsonInputStream, CFLintConfig.class);
        jsonInputStream.close();
        return config.createNestedConfig(retval);
    } catch (final FileNotFoundException fnfe) {
    }
    final InputStream inputStream = new FileInputStream(folder.getPath() + "/.cflintrc.xml");
    try {
        final CFLintConfig retval = ConfigUtils.unmarshal(inputStream, CFLintConfig.class);
        return config.createNestedConfig(retval);
    } catch (final JAXBException e) {
        throw new IOException(e);
    }
}