function isBannedFilename (filename, logger) {
la(check.maybe.unemptyString(filename) ||
check.array(filename), 'expected single or list of filenames', filename)
logger = logger || console.error.bind(console)
const filenames = check.array(filename) ? filename : [filename]
return testers.some(singleTester.bind(null, filenames, logger))
}
function makePackageNicer(grunt, validators, done, options) {
validators = validators || {};
options = options || {};
verify.fn(done, 'expected done to be a function');
var pkg = grunt.file.readJSON('package.json');
var every = checkProperties(validators, grunt, pkg);
// advanced checking
if (!checkLicenseAndReadm(grunt)) {
return done(false);
}
var pkgText = JSON.stringify(pkg, null, 2);
pkgText = pkgText.replace(/\^/g, '');
var result = every && PJV.validate(pkgText);
printErrors(grunt, result);
if (check.array(result.warnings) &&
result.warnings.length) {
grunt.log.subhead('Warnings:');
result.warnings.forEach(unary(grunt.log.warn));
}
tightenVersions(grunt, function () {
sortPackageProperties(grunt, done, options.blankLine, !!result.valid);
});
}
function isPrerelease (version) {
la(is.unemptyString(version), 'expected version string', version)
// https://github.com/npm/node-semver#functions
const prereleaseComponents = semver.prerelease(version)
debug('version %s prerelease components %j', version, prereleaseComponents)
return is.array(prereleaseComponents) && is.not.empty(prereleaseComponents)
}
it('replaces multiple spaced arguments', function () {
var result = replace(pkg, ['pkg.name', 'pkg.version']);
la(check.array(result));
la(result.length === 2);
la(result[0] === 'foo');
la(result[1] === '1.0.0');
});
it('replaces spaced arguments', function () {
la(check.fn(replace));
var result = replace(pkg, ['something', 'pkg.name']);
la(check.array(result));
la(result.length === 2);
la(result[0] === 'something');
la(result[1] === 'foo');
});
function printErrors(grunt, result) {
if (result &&
!result.valid &&
check.array(result.errors)) {
grunt.log.subhead('Errors:');
result.errors.forEach(unary(grunt.log.error));
}
}
function checkOutput (human) {
la(is.array(human), 'not array', human)
la(
human.every(is.defined),
'found undefined entries in human formatted',
human
)
human.every(checkProps)
}
function makeSureValidModule (moduleNames, checkingModules) {
la(check.maybe.array(moduleNames), 'expected list of modules', moduleNames)
la(check.array(checkingModules), 'expected list of modules to check', checkingModules)
if (isSingleItem(moduleNames) && check.empty(checkingModules)) {
console.error('Could not find module "%s" in the list of dependencies', moduleNames[0])
console.error('Please check the name')
process.exit(-1)
}
}
function zipBlames(filenames, blames) {
la(check.array(blames), 'blame info', blames);
console.log('found blame info for', blames.length, 'files');
la(check.sameLength(filenames, blames),
'mismatch in blame lengths', filenames, blames);
var lineBlames = blames.map(toArray);
var fileBlame = R.zipObj(filenames, lineBlames);
return fileBlame;
}
function testDependents (options, dependents) {
la(check.array(dependents), 'expected dependents', dependents)
// TODO switch to parallel testing!
return dependents.reduce(function (prev, dependent) {
return prev.then(function () {
return testDependent(options, dependent)
})
}, Promise.resolve(true))
}
function checkSensitiveFiles (options) {
var start
if (is.array(options)) {
log('assuming got array of filenames to check for leaked data')
start = Promise.resolve(options)
} else {
start = collectFiles(options)
}
return start
.then(leaveSensitive)
.then(R.tap(print))
.then(findLeakedData)
}
function testExamples (tester, examples, fn) {
la(is.fn(tester), 'missing tester function')
if (is.not.fn(fn)) {
return false
}
la(is.array(examples), 'invalid examples', examples)
return examples.every((example) => {
la(is.array(example) && example.length === 2, 'invalid example', example)
// console.log('testing example', example[0], example[1])
return tester(example[0], example[1], fn)
})
}
// returns a promise
function available (moduleName, options) {
options = options || {}
var toCheck = getDependenciesToCheck(options, moduleName)
la(check.array(toCheck), 'expected object of deps to check, was', toCheck)
var toCheckHash = _.zipObject(
_.pluck(toCheck, 'name'),
_.pluck(toCheck, 'version')
)
log('need to check these dependencies')
log(toCheckHash)
var nextVersionsPromise = nextVersions(options, toCheck)
return nextVersionsPromise.then(function (info) {
return reportAvailable(info, toCheckHash, options)
}, function (error) {
console.error('Could not fetch available modules\n', error)
})
}
function formArguments (opts, name, moduleVersion) {
var args = ['install']
if (opts.prefix) {
check.verify.string(name, 'expected module name string')
check.verify.string(opts.prefix,
'install folder prefix should be a string, not ' + opts.prefix)
args.push('-g')
args.push('--prefix')
args.push(opts.prefix)
}
if (opts.registry) {
la(check.string(opts.registry), 'expected registry url string', opts)
args.push('--registry')
args.push(opts.registry)
}
if (moduleVersion) {
args.push(moduleVersion)
}
if (check.array(opts.flags)) {
args = args.concat(opts.flags)
}
return args
}
.then(function (dependents) {
la(check.array(dependents), 'cannot select top n, not a list', dependents)
console.log('limiting top downloads to first', n, 'from the list of', dependents.length)
return _.take(dependents, n)
})
function verifySingleModified(result) {
la(check.object(result) && check.array(result.M),
'has modified file list', result);
la(result.M.length === 1, 'single modified file', result);
la(result.M[0].name === 'foo.js', result);
}
return commits.all(root).then(list => {
la(is.array(list))
la(list.length > 1, 'has more than 1 commit')
})
return tags(vTagsOnly).then(function (list) {
la(is.array(list), 'has array of tags')
la(list.length > 1, 'has more than 1 tag')
list.forEach(isGoodTag)
})
return afterLastTag(false).then(function (list) {
la(is.array(list), 'has array of tags')
console.log('commits after last tag', list)
})
it('detects empty array property', () => {
la(check.array(bar.versions), 'has versions')
la(!check.unempty(bar.versions), 'is empty', bar.versions)
})
function isValidLicense(pkg) {
return check.string(pkg.license) ||
check.array(pkg.licenses);
}
function ensureUniq(list) {
la(check.array(list), 'expected list', list);
return _.uniq(list, 'name');
}
function print (files) {
la(is.array(files), 'expected list of files', files)
console.log('found %d sensitive %s',
files.length, pluralize('file', files.length))
console.log(files.join('\n'))
}
function deriveFunctions (examples, f, allSimpleDerivedFunctions) {
la(is.array(examples), 'missing examples', examples)
la(isNamed(f), 'not a named function', f)
la(is.fn(f.f), 'expected function to derive', f)
// derived functions specific
// TODO use Symbol
if (f.f === R.is) {
return [{
f: R.is(Number),
name: 'R.is(Number)'
}, {
f: R.is(Object),
name: 'R.is(Object)'
}, {
f: R.is(String),
name: 'R.is(String)'
}]
}
if (f.f === R.map || f.f === R.filter) {
// TODO replace with compose
return allSimpleDerivedFunctions.map((df) => {
la(isNamed(df), 'not a named function', df)
return {
f: f.f(df.f),
name: `${f.name}(${df.name})`
}
})
}
if (f.f === R.add || f.f === R.subtract || f.f === R.gt) {
// binary functions
const outsideData = firstValues.map((x) => {
return {
f: f.f(x),
name: `${f.name}(${x})`
}
})
const asSpread = [{
f: R.apply(f.f),
name: `R.apply(${f.name})`,
spread: true
}]
const pairs = grab.numberPairs(examples)
const guessesFromData = pairs.map((x) => {
la(isPair(x), 'invalid number pair', x)
// since we have both arguments for binary function, it evaluates
// right away, thus create dummy function around it
return {
f: R.always(f.f(x[0], x[1])),
name: `${f.name}(${x[0]}, ${x[1]})`
}
})
return asSpread.concat(guessesFromData).concat(outsideData)
// return guessesFromData
}
if (f.f === R.has) {
const propertyNames = grab.properties(examples)
la(is.array(propertyNames), 'could not grab property names from', examples)
return propertyNames.map((property) => {
return {
f: f.f(property),
name: `${f.name}('${property}')`
}
})
}
if (f.f === R.append) {
const allValues = grab.everything(examples)
la(is.array(allValues), 'could not grab values from', examples)
return allValues.map((value) => {
const s = is.string(value) ? `'${value}'` : value
return {
f: f.f(value),
name: `${f.name}(${s})`
}
})
}
if (f.f === R.split) {
const strings = grab.strings(examples)
la(is.array(strings), 'expected list of strings from', examples, strings)
const characters = R.uniq(strings.join('').split(''))
// console.log('characters', characters)
return characters.map((sep) => {
return {
f: f.f(sep),
name: `${f.name}('${sep}')`
}
})
}
return []
}
.then(R.tap(list => la(is.array(list))))
function isSingleItem (names) {
return names &&
check.array(names) &&
names.length === 1
}
it('replaces combined arguments', function () {
var result = replace(pkg, ['*****@*****.**']);
la(check.array(result));
la(result.length === 1);
la(result[0] === 'foo@1.0.0', 'replaced both parts', result[0]);
});
return examples.every((example) => {
la(is.array(example) && example.length === 2, 'invalid example', example)
// console.log('testing example', example[0], example[1])
return tester(example[0], example[1], fn)
})
const la = require('lazy-ass')
const check = require('check-more-types')
const rules = require('../git-deny-patterns.json')
la(check.array(rules), 'missing list of rules', rules)
const ruleToTester = require('./rule-to-tester')
la(check.fn(ruleToTester), 'could not get rule to tester')
const log = require('debug')('ban')
log('loaded', rules.length, 'rules')
// TODO lift?
function formTesters (rules) {
return rules.map(function (rule) {
return ruleToTester(rule)
})
}
const testers = formTesters(rules)
function singleTester (filenames, logger, tester, k) {
return filenames.some(function (filename) {
if (tester(filename)) {
const brokenRule = rules[k]
var message = 'invalid filename ' + filename
if (check.unemptyString(brokenRule.caption)) {
message += '\n - ' + brokenRule.caption
}
if (brokenRule.description) {
message += '\n - ' + brokenRule.description