htmlhint

#!/usr/bin/env node

var program = require('commander');
var fs = require('fs');
var path = require('path');
var stripJsonComments = require('strip-json-comments');
var async = require('async');
var glob = require("glob");
var parseGlob = require('parse-glob');
var request = require('request');

var HTMLHint  = require("../index").HTMLHint;
var formatter = require('./formatter');
var pkg = require('../package.json');

require('colors');

function map(val) {
    var objMap = {};
    val.split(',').forEach(function(item){
        var arrItem = item.split(/\s*=\s*/);
        objMap[arrItem[0]] = arrItem[1]?arrItem[1]:true;
    });
    return objMap;
}

program.on('--help', function(){
    console.log('  Examples:');
    console.log('');
    console.log('    htmlhint');
    console.log('    htmlhint www');
    console.log('    htmlhint www/test.html');
    console.log('    htmlhint www/**/*.xhtml');
    console.log('    htmlhint www/**/*.{htm,html}');
    console.log('    htmlhint http://www.alibaba.com/');
    console.log('    cat test.html | htmlhint stdin');
    console.log('    htmlhint --list');
    console.log('    htmlhint --rules tag-pair,id-class-value=underline test.html');
    console.log('    htmlhint --config .htmlhintrc test.html');
    console.log('    htmlhint --ignore **/build/**,**/test/**');
    console.log('    htmlhint --rulesdir ./rules/');
    console.log('');
});

var arrSupportedFormatters = formatter.getSupported();

program
    .version(pkg.version)
    .usage('<file|folder|pattern|stdin|url ...> [options]')
    .option('-l, --list', 'show all of the rules available')
    .option('-c, --config <file>', 'custom configuration file')
    .option('-r, --rules <ruleid, ruleid=value ...>', 'set all of the rules available', map)
    .option('-R, --rulesdir <file|folder>', 'load custom rules from file or folder')
    .option('-f, --format <'+arrSupportedFormatters.join('|')+'>', 'output messages as custom format')
    .option('-i, --ignore <pattern, pattern ...>', 'add pattern to exclude matches')
    .option('--nocolor', 'disable color')
    .option('--warn', 'Warn only, exit with 0')
    .parse(process.argv);

if(program.list){
    listRules();
    process.exit(0);
}

var arrTargets = program.args;
if(arrTargets.length === 0){
    arrTargets.push('./');
}

// init formatter
formatter.init(HTMLHint, {
    'nocolor': program.nocolor
});
var format = program.format || 'default';
if(format){
    formatter.setFormat(format);
}

hintTargets(arrTargets, {
    rulesdir: program.rulesdir,
    ruleset: program.rules,
    formatter: formatter,
    ignore: program.ignore
});

// list all rules
function listRules(){
    var rules = HTMLHint.rules;
    var rule;
    console.log('     All rules:');
    console.log(' ==================================================');
    for (var id in rules){
        rule = rules[id];
        console.log('     %s : %s', rule.id.bold, rule.description);
    }
}

function hintTargets(arrTargets, options){
    var arrAllMessages = [];
    var allFileCount = 0;
    var allHintFileCount = 0;
    var allHintCount = 0;
    var startTime = new Date().getTime();

    var formatter = options.formatter;

    // load custom rules
    var rulesdir = options.rulesdir;
    if(rulesdir){
        loadCustomRules(rulesdir);
    }

    // start hint
    formatter.emit('start');

    var arrTasks = [];
    arrTargets.forEach(function(target){
        arrTasks.push(function(next){
            hintAllFiles(target, options, function(result){
                allFileCount += result.targetFileCount;
                allHintFileCount += result.targetHintFileCount;
                allHintCount += result.targetHintCount;
                arrAllMessages = arrAllMessages.concat(result.arrTargetMessages);
                next();
            });
        });
    });
    async.series(arrTasks, function(){
        // end hint
        var spendTime = new Date().getTime() - startTime;
        formatter.emit('end', {
            arrAllMessages: arrAllMessages,
            allFileCount: allFileCount,
            allHintFileCount: allHintFileCount,
            allHintCount: allHintCount,
            time: spendTime
        });
        process.exit(!program.warn && allHintCount > 0 ? 1 : 0);
    });
}

// load custom rles
function loadCustomRules(rulesdir){
    rulesdir = rulesdir.replace(/\\/g, '/');
    if(fs.existsSync(rulesdir)){
        if(fs.statSync(rulesdir).isDirectory()){
            rulesdir += /\/$/.test(rulesdir)?'':'/';
            rulesdir += '**/*.js';
            var arrFiles = glob.sync(rulesdir, {
                'dot': false,
                'nodir': true,
                'strict': false,
                'silent': true
            });
            arrFiles.forEach(function(file){
                loadRule(file);
            });
        }
        else{
            loadRule(rulesdir);
        }
    }
}

// load rule
function loadRule(filepath){
    filepath = path.resolve(filepath);
    try{
        var module = require(filepath);
        module(HTMLHint);
    }
    catch(e){}
}

// hint all files
function hintAllFiles(target, options, onFinised){
    var globInfo = getGlobInfo(target);
    globInfo.ignore = options.ignore;

    var formatter = options.formatter;

    // hint result
    var targetFileCount = 0;
    var targetHintFileCount = 0;
    var targetHintCount = 0;
    var arrTargetMessages = [];

    // init ruleset
    var ruleset = options.ruleset;
    if(ruleset === undefined){
        ruleset = getConfig(program.config, globInfo.base, formatter);
    }

    // hint queue
    var hintQueue = async.queue(function (filepath, next) {
        var startTime = new Date().getTime();
        if(filepath === 'stdin'){
            hintStdin(ruleset, hintNext);
        }
        else if(/^https?:\/\//.test(filepath)){
            hintUrl(filepath, ruleset, hintNext);
        }
        else{
            var messages = hintFile(filepath, ruleset);
            hintNext(messages);
        }
        function hintNext(messages){
            var spendTime = new Date().getTime() - startTime;
            var hintCount = messages.length;
            if(hintCount > 0){
                formatter.emit('file', {
                    'file': filepath,
                    'messages': messages,
                    'time': spendTime
                });
                arrTargetMessages.push({
                    'file': filepath,
                    'messages': messages,
                    'time': spendTime
                });
                targetHintFileCount ++;
                targetHintCount += hintCount;
            }
            targetFileCount ++;
            setImmediate(next);
        }
    }, 10);
    // start hint
    var isWalkDone = false;
    var isHintDone = true;
    hintQueue.drain = function() {
        isHintDone = true;
        checkAllHinted();
    };
    function checkAllHinted(){
        if(isWalkDone && isHintDone){
            onFinised({
                targetFileCount: targetFileCount,
                targetHintFileCount: targetHintFileCount,
                targetHintCount: targetHintCount,
                arrTargetMessages: arrTargetMessages
            });
        }
    }
    if(target === 'stdin'){
        isWalkDone = true;
        hintQueue.push(target);
    }
    else if(/^https?:\/\//.test(target)){
        isWalkDone = true;
        hintQueue.push(target);
    }
    else{
        walkPath(globInfo, function(filepath){
            isHintDone = false;
            hintQueue.push(filepath);
        }, function(){
            isWalkDone = true;
            checkAllHinted();
        });
    }
}

// split target to base & glob
function getGlobInfo(target){
    // fix windows sep
    target = target.replace(/\\/g, '/');
    var globInfo = parseGlob(target);
    var base = path.resolve(globInfo.base);
    base += /\/$/.test(base) ? '' : '/';
    var pattern = globInfo.glob;
    var globPath = globInfo.path;
    var defaultGlob = '*.{htm,html}';
    if(globInfo.is.glob === true){
        // no basename
        if(globPath.basename === ''){
            pattern += defaultGlob;
        }
    }
    else{
        // no basename
        if(globPath.basename === ''){
            pattern += '**/' + defaultGlob;
        }
        // detect directory
        else if(fs.existsSync(target) && fs.statSync(target).isDirectory()){
            base += globPath.basename + '/';
            pattern = '**/' + defaultGlob;
        }
    }
    return {
        base: base,
        pattern: pattern
    };
}

// search and load config
function getConfig(configPath, base, formatter){
    if(configPath === undefined && fs.existsSync(base)){
        // find default config file in parent directory
        if(fs.statSync(base).isDirectory() === false){
            base = path.dirname(base);
        }
        while(base){
            var tmpConfigFile = path.resolve(base, '.htmlhintrc');
            if(fs.existsSync(tmpConfigFile)){
                configPath = tmpConfigFile;
                break;
            }
            if (!base) {break;}
            base = base.substring(0,base.lastIndexOf(path.sep));
        }
    }

    if(fs.existsSync(configPath)){
        var config = fs.readFileSync(configPath, 'utf-8'),
            ruleset;
        try{
            ruleset = JSON.parse(stripJsonComments(config));
            formatter.emit('config', {
                ruleset: ruleset,
                configPath: configPath
            });
        }
        catch(e){}
        return ruleset;
    }
}

// walk path
function walkPath(globInfo, callback, onFinish) {
    var base = globInfo.base;
    var pattern = globInfo.pattern;
    var ignore = globInfo.ignore;
    var arrIgnores = ['**/node_modules/**'];
    if(ignore){
        ignore.split(',').forEach(function(pattern){
            arrIgnores.push(pattern);
        });
    }
    var walk = glob(pattern, {
        'cwd': base,
        'dot': false,
        'ignore': arrIgnores,
        'nodir': true,
        'strict': false,
        'silent': true
    },function() {
        onFinish();
    });
    walk.on('match', function(file){
        base = base.replace(/^.\//, '');
        callback(base + file);
    });
}

// hint file
function hintFile(filepath, ruleset){
    var content = '';
    try{
        content = fs.readFileSync(filepath, 'utf-8');
    }
    catch(e){}
    return HTMLHint.verify(content, ruleset);
}

// hint stdin
function hintStdin(ruleset, callback){
    process.stdin.setEncoding('utf8');
    var buffers = [];
    process.stdin.on('data', function(text){
        buffers.push(text);
    });

    process.stdin.on('end', function(){
        var content = buffers.join('');
        var messages = HTMLHint.verify(content, ruleset);
        callback(messages);
    });
}

// hint url
function hintUrl(url, ruleset, callback){
    request.get(url, function(error, response, body){
        if(!error && response.statusCode == 200){
            var messages = HTMLHint.verify(body, ruleset);
            callback(messages);
        }
        else{
            callback([]);
        }
    });
}