index.js
3.71 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
'use strict';
var path = require('path');
var fs = require('fs');
// Due to the fact that the node community doesn't feel that
// the node_modules resolution algorithm should be public method
// we have copy pasta'd it here.
function nodeModulePaths(from) {
// guarantee that 'from' is absolute.
from = path.resolve(from);
// note: this approach *only* works when the path is guaranteed
// to be absolute. Doing a fully-edge-case-correct path.split
// that works on both Windows and Posix is non-trivial.
var splitRe = process.platform === 'win32' ? /[\/\\]/ : /\//;
var paths = [];
var parts = from.split(splitRe);
for (var tip = parts.length - 1; tip >= 0; tip--) {
// don't search in .../node_modules/node_modules
if (parts[tip] === 'node_modules') {
continue;
}
var dir = parts.slice(0, tip + 1).concat('node_modules').join(path.sep);
paths.push(dir);
}
return paths;
}
function isSubdirectoryOf(parentPath, possibleChildPath) {
return possibleChildPath.length > parentPath.length &&
possibleChildPath.indexOf(parentPath) === 0;
}
/**
A utility function for determining what path an addon may be found at. Addons
will only be resolved in the project's own `node_modules/` directory, they
do not follow the standard node `require` logic that a standard
`require('mode-module')` lookup would use, which finds the module according
to the `NODE_PATH`.
A description of node's lookup logic can be found here:
https://nodejs.org/api/modules.html#modules_all_together
Using this method to discover the correct location of project's `node_modules`
directory allows addons to be looked up properly even when that `node_modules`
directory is outside of the project's root.
This method checks the env variable `EMBER_NODE_PATH`. If present, its value
is used to determine the `node_modules` path.
Possible use cases for this include caching
the `node_modules/` directory outside of a source code checkout, and
ensuring the same source code (shared over a network) can be used with
different environments (Linux, OSX) where binary compatibility may not
exist.
For example, if you have a project in /projects/my-app and its `node_modules`
directory is at /resource/node_modules, you would:
```
# Node uses this as its search path for standard `require('module')` calls
export NODE_PATH=/resource/node_modules
# So that ember addon discovery looks here
export EMBER_NODE_PATH=/resource/node_modules
cd /projects/my-app && ember build
```
@private
@method nodeModulesPath
@param {String} context The starting directory to use to find the
node_modules path. This will usually be the
project's root
@return {String} absolute path to the node_modules directory
*/
module.exports = function nodeModulesPath(context) {
var nodePath = process.env.EMBER_NODE_PATH;
var contextPath = path.resolve(context);
if (nodePath) {
var configuredPath = path.resolve(nodePath);
// The contextPath is likely the project root, or possibly a subdirectory in
// node_modules/ nested dependencies. If it is more specific than the
// the configuredPath (i.e. it is a subdirectory of the configuredPath)
// prefer the more specific contextPath.
if (isSubdirectoryOf(configuredPath, contextPath)) {
return path.resolve(contextPath, 'node_modules');
} else {
return path.resolve(nodePath);
}
} else {
var paths = nodeModulePaths(contextPath);
for (var i = 0, l = paths.length; i < l; i++) {
var nodeModulePathUnderTest = paths[i];
if (fs.existsSync(nodeModulePathUnderTest)) {
return nodeModulePathUnderTest;
}
}
return null;
}
};