atom--atom/src/module-cache.coffee at master · destenson/atom--atom · GitHub

History

313 lines (243 loc) · 9.87 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

Module = require 'module'

path = require 'path'

semver = require 'semver'

# Extend semver.Range to memoize matched versions for speed

class Range extends semver.Range

constructor: ->

super

@matchedVersions = new Set()

@unmatchedVersions = new Set()

test: (version) ->

return true if @matchedVersions.has(version)

return false if @unmatchedVersions.has(version)

matches = super

if matches

@matchedVersions.add(version)

else

@unmatchedVersions.add(version)

matches

nativeModules = process.binding('natives')

cache =

builtins: {}

debug: false

dependencies: {}

extensions: {}

folders: {}

ranges: {}

registered: false

resourcePath: null

resourcePathWithTrailingSlash: null

# isAbsolute is inlined from fs-plus so that fs-plus itself can be required

# from this cache.

if process.platform is 'win32'

isAbsolute = (pathToCheck) ->

pathToCheck and (pathToCheck[1] is ':' or (pathToCheck[0] is '\\' and pathToCheck[1] is '\\'))

else

isAbsolute = (pathToCheck) ->

pathToCheck and pathToCheck[0] is '/'

isCorePath = (pathToCheck) ->

pathToCheck.startsWith(cache.resourcePathWithTrailingSlash)

loadDependencies = (modulePath, rootPath, rootMetadata, moduleCache) ->

fs = require 'fs-plus'

for childPath in fs.listSync(path.join(modulePath, 'node_modules'))

continue if path.basename(childPath) is '.bin'

continue if rootPath is modulePath and rootMetadata.packageDependencies?.hasOwnProperty(path.basename(childPath))

childMetadataPath = path.join(childPath, 'package.json')

continue unless fs.isFileSync(childMetadataPath)

childMetadata = JSON.parse(fs.readFileSync(childMetadataPath))

if childMetadata?.version

try

mainPath = require.resolve(childPath)

catch error

mainPath = null

if mainPath

moduleCache.dependencies.push

name: childMetadata.name

version: childMetadata.version

path: path.relative(rootPath, mainPath)

loadDependencies(childPath, rootPath, rootMetadata, moduleCache)

return

loadFolderCompatibility = (modulePath, rootPath, rootMetadata, moduleCache) ->

fs = require 'fs-plus'

metadataPath = path.join(modulePath, 'package.json')

return unless fs.isFileSync(metadataPath)

dependencies = JSON.parse(fs.readFileSync(metadataPath))?.dependencies ? {}

for name, version of dependencies

try

new Range(version)

catch error

delete dependencies[name]

onDirectory = (childPath) ->

path.basename(childPath) isnt 'node_modules'

extensions = ['.js', '.coffee', '.json', '.node']

paths = {}

onFile = (childPath) ->

if path.extname(childPath) in extensions

relativePath = path.relative(rootPath, path.dirname(childPath))

paths[relativePath] = true

fs.traverseTreeSync(modulePath, onFile, onDirectory)

paths = Object.keys(paths)

if paths.length > 0 and Object.keys(dependencies).length > 0

moduleCache.folders.push({paths, dependencies})

for childPath in fs.listSync(path.join(modulePath, 'node_modules'))

continue if path.basename(childPath) is '.bin'

continue if rootPath is modulePath and rootMetadata.packageDependencies?.hasOwnProperty(path.basename(childPath))

loadFolderCompatibility(childPath, rootPath, rootMetadata, moduleCache)

return

loadExtensions = (modulePath, rootPath, rootMetadata, moduleCache) ->

fs = require 'fs-plus'

extensions = ['.js', '.coffee', '.json', '.node']

nodeModulesPath = path.join(rootPath, 'node_modules')

onFile = (filePath) ->

filePath = path.relative(rootPath, filePath)

segments = filePath.split(path.sep)

return if 'test' in segments

return if 'tests' in segments

return if 'spec' in segments

return if 'specs' in segments

return if segments.length > 1 and not (segments[0] in ['exports', 'lib', 'node_modules', 'src', 'static', 'vendor'])

extension = path.extname(filePath)

if extension in extensions

moduleCache.extensions[extension] ?= []

moduleCache.extensions[extension].push(filePath)

onDirectory = (childPath) ->

# Don't include extensions from bundled packages

# These are generated and stored in the package's own metadata cache

if rootMetadata.name is 'atom'

parentPath = path.dirname(childPath)

if parentPath is nodeModulesPath

packageName = path.basename(childPath)

return false if rootMetadata.packageDependencies?.hasOwnProperty(packageName)

true

fs.traverseTreeSync(rootPath, onFile, onDirectory)

return

satisfies = (version, rawRange) ->

unless parsedRange = cache.ranges[rawRange]

parsedRange = new Range(rawRange)

cache.ranges[rawRange] = parsedRange

parsedRange.test(version)

resolveFilePath = (relativePath, parentModule) ->

return unless relativePath

return unless parentModule?.filename

return unless relativePath[0] is '.' or isAbsolute(relativePath)

resolvedPath = path.resolve(path.dirname(parentModule.filename), relativePath)

return unless isCorePath(resolvedPath)

extension = path.extname(resolvedPath)

if extension

return resolvedPath if cache.extensions[extension]?.has(resolvedPath)

else

for extension, paths of cache.extensions

resolvedPathWithExtension = "#{resolvedPath}#{extension}"

return resolvedPathWithExtension if paths.has(resolvedPathWithExtension)

return

resolveModulePath = (relativePath, parentModule) ->

return unless relativePath

return unless parentModule?.filename

return if nativeModules.hasOwnProperty(relativePath)

return if relativePath[0] is '.'

return if isAbsolute(relativePath)

folderPath = path.dirname(parentModule.filename)

range = cache.folders[folderPath]?[relativePath]

unless range?

if builtinPath = cache.builtins[relativePath]

return builtinPath

else

return

candidates = cache.dependencies[relativePath]

return unless candidates?

for version, resolvedPath of candidates

if Module._cache.hasOwnProperty(resolvedPath) or isCorePath(resolvedPath)

return resolvedPath if satisfies(version, range)

return

registerBuiltins = (devMode) ->

if devMode or not cache.resourcePath.startsWith("#{process.resourcesPath}#{path.sep}")

fs = require 'fs-plus'

atomCoffeePath = path.join(cache.resourcePath, 'exports', 'atom.coffee')

cache.builtins.atom = atomCoffeePath if fs.isFileSync(atomCoffeePath)

cache.builtins.atom ?= path.join(cache.resourcePath, 'exports', 'atom.js')

atomShellRoot = path.join(process.resourcesPath, 'atom.asar')

commonRoot = path.join(atomShellRoot, 'common', 'api', 'lib')

commonBuiltins = ['callbacks-registry', 'clipboard', 'crash-reporter', 'screen', 'shell']

for builtin in commonBuiltins

cache.builtins[builtin] = path.join(commonRoot, "#{builtin}.js")

rendererRoot = path.join(atomShellRoot, 'renderer', 'api', 'lib')

rendererBuiltins = ['ipc-renderer', 'remote']

for builtin in rendererBuiltins

cache.builtins[builtin] = path.join(rendererRoot, "#{builtin}.js")

if cache.debug

cache.findPathCount = 0

cache.findPathTime = 0

cache.loadCount = 0

cache.requireTime = 0

global.moduleCache = cache

originalLoad = Module::load

Module::load = ->

cache.loadCount++

originalLoad.apply(this, arguments)

originalRequire = Module::require

Module::require = ->

startTime = Date.now()

exports = originalRequire.apply(this, arguments)

cache.requireTime += Date.now() - startTime

exports

originalFindPath = Module._findPath

Module._findPath = (request, paths) ->

cacheKey = JSON.stringify({request, paths})

cache.findPathCount++ unless Module._pathCache[cacheKey]

startTime = Date.now()

foundPath = originalFindPath.apply(global, arguments)

cache.findPathTime += Date.now() - startTime

foundPath

exports.create = (modulePath) ->

fs = require 'fs-plus'

modulePath = fs.realpathSync(modulePath)

metadataPath = path.join(modulePath, 'package.json')

metadata = JSON.parse(fs.readFileSync(metadataPath))

moduleCache =

version: 1

dependencies: []

extensions: {}

folders: []

loadDependencies(modulePath, modulePath, metadata, moduleCache)

loadFolderCompatibility(modulePath, modulePath, metadata, moduleCache)

loadExtensions(modulePath, modulePath, metadata, moduleCache)

metadata._atomModuleCache = moduleCache

fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2))

return

exports.register = ({resourcePath, devMode}={}) ->

return if cache.registered

originalResolveFilename = Module._resolveFilename

Module._resolveFilename = (relativePath, parentModule) ->

resolvedPath = resolveModulePath(relativePath, parentModule)

resolvedPath ?= resolveFilePath(relativePath, parentModule)

resolvedPath ? originalResolveFilename(relativePath, parentModule)

cache.registered = true

cache.resourcePath = resourcePath

cache.resourcePathWithTrailingSlash = "#{resourcePath}#{path.sep}"

registerBuiltins(devMode)

return

exports.add = (directoryPath, metadata) ->

# path.join isn't used in this function for speed since path.join calls

# path.normalize and all the paths are already normalized here.

unless metadata?

try

metadata = require("#{directoryPath}#{path.sep}package.json")

catch error

return

cacheToAdd = metadata?._atomModuleCache

return unless cacheToAdd?

for dependency in cacheToAdd.dependencies ? []

cache.dependencies[dependency.name] ?= {}

cache.dependencies[dependency.name][dependency.version] ?= "#{directoryPath}#{path.sep}#{dependency.path}"

for entry in cacheToAdd.folders ? []

for folderPath in entry.paths

if folderPath

cache.folders["#{directoryPath}#{path.sep}#{folderPath}"] = entry.dependencies

else

cache.folders[directoryPath] = entry.dependencies

for extension, paths of cacheToAdd.extensions

cache.extensions[extension] ?= new Set()

for filePath in paths

cache.extensions[extension].add("#{directoryPath}#{path.sep}#{filePath}")

return

exports.cache = cache

atom--atom/src/module-cache.coffee at master · destenson/atom--atom · GitHub

Expand file tree

Breadcrumbs

module-cache.coffee

Latest commit

History

Breadcrumbs

module-cache.coffee

File metadata and controls