mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
349 lines
13 KiB
349 lines
13 KiB
// vim: set softtabstop=16 shiftwidth=16:
|
|
|
|
try {
|
|
var fs = require("graceful-fs")
|
|
} catch (er) {
|
|
var fs = require("fs")
|
|
}
|
|
|
|
|
|
module.exports = readJson
|
|
|
|
var LRU = require("lru-cache")
|
|
readJson.cache = new LRU({max: 1000})
|
|
var path = require("path")
|
|
var glob = require("glob")
|
|
var normalizeData = require("normalize-package-data")
|
|
|
|
// put more stuff on here to customize.
|
|
readJson.extraSet = [
|
|
gypfile,
|
|
serverjs,
|
|
authors,
|
|
readme,
|
|
mans,
|
|
bins,
|
|
githead
|
|
]
|
|
|
|
var typoWarned = {}
|
|
|
|
|
|
function readJson (file, log_, strict_, cb_) {
|
|
var log, strict, cb
|
|
for (var i = 1; i < arguments.length - 1; i++) {
|
|
if (typeof arguments[i] === 'boolean')
|
|
strict = arguments[i]
|
|
else if (typeof arguments[i] === 'function')
|
|
log = arguments[i]
|
|
}
|
|
if (!log) log = function () {};
|
|
cb = arguments[ arguments.length - 1 ]
|
|
|
|
var c = readJson.cache.get(file)
|
|
if (c) {
|
|
cb = cb.bind(null, null, c)
|
|
return process.nextTick(cb);
|
|
}
|
|
cb = (function (orig) { return function (er, data) {
|
|
if (data) readJson.cache.set(file, data);
|
|
return orig(er, data)
|
|
} })(cb)
|
|
readJson_(file, log, strict, cb)
|
|
}
|
|
|
|
|
|
function readJson_ (file, log, strict, cb) {
|
|
fs.readFile(file, "utf8", function (er, d) {
|
|
parseJson(file, er, d, log, strict, cb)
|
|
})
|
|
}
|
|
|
|
|
|
function stripBOM(content) {
|
|
// Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
|
|
// because the buffer-to-string conversion in `fs.readFileSync()`
|
|
// translates it to FEFF, the UTF-16 BOM.
|
|
if (content.charCodeAt(0) === 0xFEFF) {
|
|
content = content.slice(1);
|
|
}
|
|
return content;
|
|
}
|
|
|
|
|
|
function parseJson (file, er, d, log, strict, cb) {
|
|
if (er && er.code === "ENOENT") {
|
|
indexjs(file, er, log, strict, cb)
|
|
return
|
|
}
|
|
if (er) return cb(er);
|
|
try {
|
|
d = JSON.parse(stripBOM(d))
|
|
} catch (er) {
|
|
d = parseIndex(d)
|
|
if (!d) return cb(parseError(er, file));
|
|
}
|
|
extras(file, d, log, strict, cb)
|
|
}
|
|
|
|
|
|
function indexjs (file, er, log, strict, cb) {
|
|
if (path.basename(file) === "index.js") {
|
|
return cb(er);
|
|
}
|
|
var index = path.resolve(path.dirname(file), "index.js")
|
|
fs.readFile(index, "utf8", function (er2, d) {
|
|
if (er2) return cb(er);
|
|
d = parseIndex(d)
|
|
if (!d) return cb(er);
|
|
extras(file, d, log, strict, cb)
|
|
})
|
|
}
|
|
|
|
|
|
readJson.extras = extras
|
|
function extras (file, data, log_, strict_, cb_) {
|
|
var log, strict, cb
|
|
for (var i = 2; i < arguments.length - 1; i++) {
|
|
if (typeof arguments[i] === 'boolean')
|
|
strict = arguments[i]
|
|
else if (typeof arguments[i] === 'function')
|
|
log = arguments[i]
|
|
}
|
|
cb = arguments[i]
|
|
var set = readJson.extraSet
|
|
var n = set.length
|
|
var errState = null
|
|
set.forEach(function (fn) {
|
|
fn(file, data, then)
|
|
})
|
|
function then(er) {
|
|
if (errState) return;
|
|
if (er) return cb(errState = er);
|
|
if (--n > 0) return;
|
|
final(file, data, log, strict, cb);
|
|
}
|
|
}
|
|
|
|
function gypfile (file, data, cb) {
|
|
var dir = path.dirname(file)
|
|
var s = data.scripts || {}
|
|
if (s.install || s.preinstall)
|
|
return cb(null, data);
|
|
glob("*.gyp", { cwd: dir }, function (er, files) {
|
|
if (er) return cb(er);
|
|
gypfile_(file, data, files, cb)
|
|
})
|
|
}
|
|
|
|
function gypfile_ (file, data, files, cb) {
|
|
if (!files.length) return cb(null, data);
|
|
var s = data.scripts || {}
|
|
s.install = "node-gyp rebuild"
|
|
data.scripts = s
|
|
data.gypfile = true
|
|
return cb(null, data);
|
|
}
|
|
|
|
function serverjs (file, data, cb) {
|
|
var dir = path.dirname(file)
|
|
var s = data.scripts || {}
|
|
if (s.start) return cb(null, data)
|
|
glob("server.js", { cwd: dir }, function (er, files) {
|
|
if (er) return cb(er);
|
|
serverjs_(file, data, files, cb)
|
|
})
|
|
}
|
|
function serverjs_ (file, data, files, cb) {
|
|
if (!files.length) return cb(null, data);
|
|
var s = data.scripts || {}
|
|
s.start = "node server.js"
|
|
data.scripts = s
|
|
return cb(null, data)
|
|
}
|
|
|
|
function authors (file, data, cb) {
|
|
if (data.contributors) return cb(null, data);
|
|
var af = path.resolve(path.dirname(file), "AUTHORS")
|
|
fs.readFile(af, "utf8", function (er, ad) {
|
|
// ignore error. just checking it.
|
|
if (er) return cb(null, data);
|
|
authors_(file, data, ad, cb)
|
|
})
|
|
}
|
|
function authors_ (file, data, ad, cb) {
|
|
ad = ad.split(/\r?\n/g).map(function (line) {
|
|
return line.replace(/^\s*#.*$/, '').trim()
|
|
}).filter(function (line) {
|
|
return line
|
|
})
|
|
data.contributors = ad
|
|
return cb(null, data)
|
|
}
|
|
|
|
var defDesc = "Unnamed repository; edit this file " +
|
|
"'description' to name the repository."
|
|
function gitDescription (file, data, cb) {
|
|
if (data.description) return cb(null, data);
|
|
var dir = path.dirname(file)
|
|
// just cuz it'd be nice if this file mattered...
|
|
var gitDesc = path.resolve(dir, '.git/description')
|
|
fs.readFile(gitDesc, 'utf8', function (er, desc) {
|
|
if (desc) desc = desc.trim()
|
|
if (!er && desc !== defDesc)
|
|
data.description = desc
|
|
return cb(null, data)
|
|
})
|
|
}
|
|
|
|
function readmeDescription (file, data) {
|
|
if (data.description) return cb(null, data);
|
|
var d = data.readme
|
|
if (!d) return;
|
|
// the first block of text before the first heading
|
|
// that isn't the first line heading
|
|
d = d.trim().split('\n')
|
|
for (var s = 0; d[s] && d[s].trim().match(/^(#|$)/); s ++);
|
|
var l = d.length
|
|
for (var e = s + 1; e < l && d[e].trim(); e ++);
|
|
data.description = d.slice(s, e).join(' ').trim()
|
|
}
|
|
|
|
function readme (file, data, cb) {
|
|
if (data.readme) return cb(null, data);
|
|
var dir = path.dirname(file)
|
|
var globOpts = { cwd: dir, nocase: true, mark: true }
|
|
glob("README?(.*)", globOpts, function (er, files) {
|
|
if (er) return cb(er);
|
|
// don't accept directories.
|
|
files = files.filter(function (file) {
|
|
return !file.match(/\/$/)
|
|
})
|
|
if (!files.length) return cb();
|
|
var rm = path.resolve(dir, files[0])
|
|
readme_(file, data, rm, cb)
|
|
})
|
|
}
|
|
function readme_(file, data, rm, cb) {
|
|
var rmfn = path.basename(rm);
|
|
fs.readFile(rm, "utf8", function (er, rm) {
|
|
// maybe not readable, or something.
|
|
if (er) return cb()
|
|
data.readme = rm
|
|
data.readmeFilename = rmfn
|
|
return cb(er, data)
|
|
})
|
|
}
|
|
|
|
function mans (file, data, cb) {
|
|
var m = data.directories && data.directories.man
|
|
if (data.man || !m) return cb(null, data);
|
|
m = path.resolve(path.dirname(file), m)
|
|
glob("**/*.[0-9]", { cwd: m }, function (er, mans) {
|
|
if (er) return cb(er);
|
|
mans_(file, data, mans, cb)
|
|
})
|
|
}
|
|
function mans_ (file, data, mans, cb) {
|
|
var m = data.directories && data.directories.man
|
|
data.man = mans.map(function (mf) {
|
|
return path.resolve(path.dirname(file), m, mf)
|
|
})
|
|
return cb(null, data)
|
|
}
|
|
|
|
function bins (file, data, cb) {
|
|
if (Array.isArray(data.bin)) {
|
|
return bins_(file, data, data.bin, cb)
|
|
}
|
|
var m = data.directories && data.directories.bin
|
|
if (data.bin || !m) return cb(null, data);
|
|
m = path.resolve(path.dirname(file), m)
|
|
glob("**", { cwd: m }, function (er, bins) {
|
|
if (er) return cb(er);
|
|
bins_(file, data, bins, cb)
|
|
})
|
|
}
|
|
function bins_ (file, data, bins, cb) {
|
|
var m = data.directories && data.directories.bin || '.'
|
|
data.bin = bins.reduce(function (acc, mf) {
|
|
if (mf && mf.charAt(0) !== '.') {
|
|
var f = path.basename(mf)
|
|
acc[f] = path.join(m, mf)
|
|
}
|
|
return acc
|
|
}, {})
|
|
return cb(null, data)
|
|
}
|
|
|
|
function githead (file, data, cb) {
|
|
if (data.gitHead) return cb(null, data);
|
|
var dir = path.dirname(file)
|
|
var head = path.resolve(dir, '.git/HEAD')
|
|
fs.readFile(head, 'utf8', function (er, head) {
|
|
if (er) return cb(null, data);
|
|
githead_(file, data, dir, head, cb)
|
|
})
|
|
}
|
|
function githead_ (file, data, dir, head, cb) {
|
|
if (!head.match(/^ref: /)) {
|
|
data.gitHead = head.trim()
|
|
return cb(null, data)
|
|
}
|
|
var headFile = head.replace(/^ref: /, '').trim()
|
|
headFile = path.resolve(dir, '.git', headFile)
|
|
fs.readFile(headFile, 'utf8', function (er, head) {
|
|
if (er || !head) return cb(null, data)
|
|
head = head.replace(/^ref: /, '').trim()
|
|
data.gitHead = head
|
|
return cb(null, data)
|
|
})
|
|
}
|
|
|
|
function final (file, data, log, strict, cb) {
|
|
var pId = makePackageId(data)
|
|
function warn(msg) {
|
|
if (typoWarned[pId]) return;
|
|
if (log) log("package.json", pId, msg);
|
|
}
|
|
try {
|
|
normalizeData(data, warn, strict)
|
|
}
|
|
catch (error) {
|
|
return cb(error)
|
|
}
|
|
typoWarned[pId] = true
|
|
readJson.cache.set(file, data)
|
|
cb(null, data)
|
|
}
|
|
|
|
function makePackageId (data) {
|
|
return cleanString(data.name) + "@" + cleanString(data.version)
|
|
}
|
|
|
|
function cleanString(str) {
|
|
return (!str || typeof(str) !== "string") ? "" : str.trim()
|
|
}
|
|
|
|
// /**package { "name": "foo", "version": "1.2.3", ... } **/
|
|
function parseIndex (data) {
|
|
data = data.split(/^\/\*\*package(?:\s|$)/m)
|
|
if (data.length < 2) return null
|
|
data = data[1]
|
|
data = data.split(/\*\*\/$/m)
|
|
if (data.length < 2) return null
|
|
data = data[0]
|
|
data = data.replace(/^\s*\*/mg, "")
|
|
try {
|
|
return JSON.parse(data)
|
|
} catch (er) {
|
|
return null
|
|
}
|
|
}
|
|
|
|
function parseError (ex, file) {
|
|
var e = new Error("Failed to parse json\n"+ex.message)
|
|
e.code = "EJSONPARSE"
|
|
e.file = file
|
|
return e
|
|
}
|
|
|