function checkPackage()

in tasks/check-package.js [161:293]
102 lines of code
34 McCabe index (conditional complexity)

function checkPackage (packageJSONFile, isMSPackage, logger) {
    var packageJSONFile = packageJSONFile || "**/package.json";
    var packageDirectory = path.dirname(packageJSONFile);
    var packageJSON = JSON.parse(fs.readFileSync(packageJSONFile, "utf8"));

    pkglogger = logger.pkg

    // if new pbiviz tools generated
    var packageJSONSchema = '';
    if (packageJSON.metadata) {
        if(isMSPackage){
            packageJSONSchema = JSON.parse(fs.readFileSync('./config/package.pbiviztoolsgenerated.ms.schema.json', "utf8"))
        }else{
            packageJSONSchema = JSON.parse(fs.readFileSync(__dirname+'/../config/package.pbiviztoolsgenerated.schema.json', "utf8"))
        }
    } else {
        if(isMSPackage){
            packageJSONSchema = JSON.parse(fs.readFileSync('./config/package.ms.schema.json', "utf8")) 
        }else{
            packageJSONSchema = JSON.parse(fs.readFileSync(__dirname+'/../config/package.schema.json', "utf8"));
        }
    }

    var v = new jsonschema.Validator();

    // for custom field validation 
    // you could refactor ./config/package.schema.json with "pattern" field, 
    // but it will give undreadable messages like 
    // 'instance.version does not match pattern ^(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)?$'
    // so lets do it in not flexible but readable way
    // with custom field "format" and its processor
    v.attributes.format = function formatProccessor(instance, schema, options, ctx) {
        if(typeof instance!='string') return;
        if(typeof schema.format!='string') throw new jsonschema.SchemaError('"format" expects a string', schema);

        //to support multiformat like "file|image|screenshot"
        var formats = schema.format.split('|');
        var i = 0;
        var format = '';

        for (i; i < formats.length; i++) {
            format = formats[i];
            switch(format) {
                case 'exact':
                    if ( instance !== schema.default ) {
                        return 'need to be equeal to ' + JSON.stringify(schema.default);
                    }
                    break;

                case 'x.x.x':
                    if (!utils.isVersion(instance)) {
                        return JSON.stringify(instance) + ' doesn`t much pattern ' + JSON.stringify(format);
                    }
                    break;

                case 'email':
                    if (!utils.isEmail(instance)) {
                        return JSON.stringify(instance) + ' is not an ' + JSON.stringify(format);
                    } 
                    break;

                case 'url':
                    if (!utils.isURL(instance)) {
                        return JSON.stringify(instance) + ' is not ' + JSON.stringify(format);
                    } else {
                        // async test for url
                        utils.isURLAvailable(instance);
                    }
                    break;

                case 'file':
                    if (!utils.isFileAvailable(path.join(packageDirectory, instance))) {
                        return JSON.stringify(instance) + ' is not in package';
                    }
                    break;

                case 'image':
                    if (!utils.isImage(instance)) {
                        return JSON.stringify(instance) + ' is not an ' + JSON.stringify(format);
                    }
                    break;

                case 'svg':
                    if (!utils.isSVG(instance)) {
                        return JSON.stringify(instance) + ' is not an ' + JSON.stringify(format);
                    }
                    break;

                case 'icon':
                case 'thumbnail':
                case 'screenshot':
                    if (!utils.isImageSize(path.join(packageDirectory, instance), imageTypes[format])) {
                        return JSON.stringify(instance) + ' as ' + 
                            JSON.stringify(format) + 
                            ' needs to be in size ' +
                            imageTypes[format].width + 'x' + imageTypes[format].height;
                    }
                    break;
            }
        };
    }

    var validationResult = v.validate(packageJSON, packageJSONSchema);
    var i = 0;

    if(validationResult.errors && validationResult.errors.length) {
        validationResult.errors.forEach( function (error, i) {
            utils.log('error', error.property, error.message);
        })
    }

    // Extra tests
    if (packageJSON && packageJSON.version && 
        packageJSON.visual && packageJSON.visual.version && 
        packageJSON.version !== packageJSON.visual.version
    ) {
        utils.log('error', 'instance.version and instance.visual.version', 'need to be the same')
    }

    var result = new Promise((resolve, reject) => {
        resultResolver = resolve
    });

    if(!urlPromiseCounter){
        resultResolver()
        return pkglogger;
    }else{
        return result;
    }

    // TODO try to use gulp pipeline to speed up
    // return gulp.src(path)
};