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
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
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
|
# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
# vim: set filetype=python:
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import json
import os
import platform
import re
import subprocess
import sys
from filecmp import dircmp
from mozbuild.nodeutil import (
NODE_MIN_VERSION,
NPM_MIN_VERSION,
find_node_executable,
find_npm_executable,
)
from mozfile.mozfile import remove as mozfileremove
from packaging.version import Version
NODE_MACHING_VERSION_NOT_FOUND_MESSAGE = """
Could not find Node.js executable later than %s.
Executing `mach bootstrap --no-system-changes` should
install a compatible version in ~/.mozbuild on most platforms.
""".strip()
NPM_MACHING_VERSION_NOT_FOUND_MESSAGE = """
Could not find npm executable later than %s.
Executing `mach bootstrap --no-system-changes` should
install a compatible version in ~/.mozbuild on most platforms.
""".strip()
NODE_NOT_FOUND_MESSAGE = """
nodejs is either not installed or is installed to a non-standard path.
Executing `mach bootstrap --no-system-changes` should
install a compatible version in ~/.mozbuild on most platforms.
""".strip()
NPM_NOT_FOUND_MESSAGE = """
Node Package Manager (npm) is either not installed or installed to a
non-standard path.
Executing `mach bootstrap --no-system-changes` should
install a compatible version in ~/.mozbuild on most platforms.
""".strip()
VERSION_RE = re.compile(r"^\d+\.\d+\.\d+$")
CARET_VERSION_RANGE_RE = re.compile(r"^\^((\d+)\.\d+\.\d+)$")
project_root = None
def eslint_maybe_setup():
"""Setup ESLint only if it is needed."""
has_issues, needs_clobber = eslint_module_needs_setup()
if has_issues:
eslint_setup(needs_clobber)
def eslint_setup(should_clobber=False):
"""Ensure eslint is optimally configured.
This command will inspect your eslint configuration and
guide you through an interactive wizard helping you configure
eslint for optimal use on Mozilla projects.
"""
package_setup(get_project_root(), "eslint", should_clobber=should_clobber)
def remove_directory(path):
print("Clobbering %s..." % path)
if sys.platform.startswith("win") and have_winrm():
process = subprocess.Popen(["winrm", "-rf", path])
process.wait()
else:
mozfileremove(path)
def package_setup(
package_root,
package_name,
should_update=False,
should_clobber=False,
no_optional=False,
):
"""Ensure `package_name` at `package_root` is installed.
When `should_update` is true, clobber, install, and produce a new
"package-lock.json" file.
This populates `package_root/node_modules`.
"""
orig_project_root = get_project_root()
orig_cwd = os.getcwd()
if should_update:
should_clobber = True
try:
set_project_root(package_root)
sys.path.append(os.path.dirname(__file__))
# npm sometimes fails to respect cwd when it is run using check_call so
# we manually switch folders here instead.
project_root = get_project_root()
os.chdir(project_root)
if should_clobber:
remove_directory(os.path.join(project_root, "node_modules"))
# Always remove the eslint-plugin-mozilla sub-directory as that can
# sometimes conflict with the top level node_modules, see bug 1809036.
remove_directory(
os.path.join(
get_eslint_module_path(), "eslint-plugin-mozilla", "node_modules"
)
)
npm_path, _ = find_npm_executable()
if not npm_path:
return 1
node_path, _ = find_node_executable()
if not node_path:
return 1
extra_parameters = ["--loglevel=error"]
if no_optional:
extra_parameters.append("--no-optional")
package_lock_json_path = os.path.join(get_project_root(), "package-lock.json")
if should_update:
cmd = [npm_path, "install"]
mozfileremove(package_lock_json_path)
else:
cmd = [npm_path, "ci"]
# On non-Windows, ensure npm is called via node, as node may not be in the
# path.
if platform.system() != "Windows":
cmd.insert(0, node_path)
cmd.extend(extra_parameters)
# Ensure that bare `node` and `npm` in scripts, including post-install scripts, finds the
# binary we're invoking with. Without this, it's easy for compiled extensions to get
# mismatched versions of the Node.js extension API.
path = os.environ.get("PATH", "").split(os.pathsep)
node_dir = os.path.dirname(node_path)
if node_dir not in path:
path = [node_dir] + path
print('Installing %s for mach using "%s"...' % (package_name, " ".join(cmd)))
result = call_process(
package_name, cmd, append_env={"PATH": os.pathsep.join(path)}
)
if not result:
return 1
bin_path = os.path.join(
get_project_root(), "node_modules", ".bin", package_name
)
print("\n%s installed successfully!" % package_name)
print("\nNOTE: Your local %s binary is at %s\n" % (package_name, bin_path))
finally:
set_project_root(orig_project_root)
os.chdir(orig_cwd)
def call_process(name, cmd, cwd=None, append_env={}):
env = dict(os.environ)
env.update(append_env)
try:
with open(os.devnull, "w") as fnull:
subprocess.check_call(cmd, cwd=cwd, stdout=fnull, env=env)
except subprocess.CalledProcessError:
if cwd:
print("\nError installing %s in the %s folder, aborting." % (name, cwd))
else:
print("\nError installing %s, aborting." % name)
return False
return True
def expected_eslint_modules():
# Read the expected version of ESLint and external modules
expected_modules_path = os.path.join(get_project_root(), "package.json")
with open(expected_modules_path, "r", encoding="utf-8") as f:
sections = json.load(f)
expected_modules = sections.get("dependencies", {})
expected_modules.update(sections.get("devDependencies", {}))
# Also read the in-tree ESLint plugin mozilla information, to ensure the
# dependencies are up to date.
# Bug 1766659: This is disabled for now due to sub-dependencies at the top
# level providing different module versions to those in eslint-plugin-mozilla.
# mozilla_json_path = os.path.join(
# get_eslint_module_path(), "eslint-plugin-mozilla", "package.json"
# )
# with open(mozilla_json_path, "r", encoding="utf-8") as f:
# expected_modules.update(json.load(f).get("dependencies", {}))
# Also read the in-tree ESLint plugin spidermonkey information, to ensure the
# dependencies are up to date.
mozilla_json_path = os.path.join(
get_eslint_module_path(), "eslint-plugin-spidermonkey-js", "package.json"
)
with open(mozilla_json_path, "r", encoding="utf-8") as f:
expected_modules.update(json.load(f).get("dependencies", {}))
return expected_modules
def check_eslint_files(node_modules_path, name):
def check_file_diffs(dcmp):
# Diff files only looks at files that are different. Not for files
# that are only present on one side. This should be generally OK as
# new files will need to be added in the index.js for the package.
if dcmp.diff_files and dcmp.diff_files != ["package.json"]:
return True
result = False
# Again, we only look at common sub directories for the same reason
# as above.
for sub_dcmp in dcmp.subdirs.values():
result = result or check_file_diffs(sub_dcmp)
return result
dcmp = dircmp(
os.path.join(node_modules_path, name),
os.path.join(get_eslint_module_path(), name),
)
return check_file_diffs(dcmp)
def eslint_module_needs_setup():
has_issues = False
needs_clobber = False
node_modules_path = os.path.join(get_project_root(), "node_modules")
for name, expected_data in expected_eslint_modules().items():
# expected_eslint_modules returns a string for the version number of
# dependencies for installation of eslint generally, and an object
# for our in-tree plugins (which contains the entire module info).
if "version" in expected_data:
version_range = expected_data["version"]
else:
version_range = expected_data
path = os.path.join(node_modules_path, name, "package.json")
if not os.path.exists(path):
print("%s v%s needs to be installed locally." % (name, version_range))
has_issues = True
continue
data = json.load(open(path, encoding="utf-8"))
if version_range.startswith("file:"):
# We don't need to check local file installations for versions, as
# these are symlinked, so we'll always pick up the latest.
continue
if name == "eslint" and Version("4.0.0") > Version(data["version"]):
print("ESLint is an old version, clobbering node_modules directory")
needs_clobber = True
has_issues = True
continue
# For @microsoft/eslint-plugin-sdl we are loading a static version as
# long that PR is not merged into the master branch. Bug 1786290
if (name == "@microsoft/eslint-plugin-sdl") and (
version_range
== "github:mozfreddyb/eslint-plugin-sdl#17b22cd527682108af7a1a4edacf69cb7a9b4a06"
):
continue
if not version_in_range(data["version"], version_range):
print("%s v%s should be v%s." % (name, data["version"], version_range))
has_issues = True
continue
return has_issues, needs_clobber
def version_in_range(version, version_range):
"""
Check if a module version is inside a version range. Only supports explicit versions and
caret ranges for the moment, since that's all we've used so far.
"""
if version == version_range:
return True
version_match = VERSION_RE.match(version)
if not version_match:
raise RuntimeError("mach eslint doesn't understand module version %s" % version)
version = Version(version)
# Caret ranges as specified by npm allow changes that do not modify the left-most non-zero
# digit in the [major, minor, patch] tuple. The code below assumes the major digit is
# non-zero.
range_match = CARET_VERSION_RANGE_RE.match(version_range)
if range_match:
range_version = range_match.group(1)
range_major = int(range_match.group(2))
range_min = Version(range_version)
range_max = Version("%d.0.0" % (range_major + 1))
return range_min <= version < range_max
return False
def get_possible_node_paths_win():
"""
Return possible nodejs paths on Windows.
"""
if platform.system() != "Windows":
return []
return list(
{
"%s\\nodejs" % os.environ.get("SystemDrive"),
os.path.join(os.environ.get("ProgramFiles"), "nodejs"),
os.path.join(os.environ.get("PROGRAMW6432"), "nodejs"),
os.path.join(os.environ.get("PROGRAMFILES"), "nodejs"),
}
)
def get_version(path):
try:
version_str = subprocess.check_output(
[path, "--version"], stderr=subprocess.STDOUT, universal_newlines=True
)
return version_str
except (subprocess.CalledProcessError, OSError):
return None
def set_project_root(root=None):
"""Sets the project root to the supplied path, or works out what the root
is based on looking for 'mach'.
Keyword arguments:
root - (optional) The path to set the root to.
"""
global project_root
if root:
project_root = root
return
file_found = False
folder = os.getcwd()
while folder:
if os.path.exists(os.path.join(folder, "mach")):
file_found = True
break
else:
folder = os.path.dirname(folder)
if file_found:
project_root = os.path.abspath(folder)
def get_project_root():
"""Returns the absolute path to the root of the project, see set_project_root()
for how this is determined.
"""
global project_root
if not project_root:
set_project_root()
return project_root
def get_eslint_module_path():
return os.path.join(get_project_root(), "tools", "lint", "eslint")
def check_node_executables_valid():
node_path, version = find_node_executable()
if not node_path:
print(NODE_NOT_FOUND_MESSAGE)
return False
if not version:
print(NODE_MACHING_VERSION_NOT_FOUND_MESSAGE % NODE_MIN_VERSION)
return False
npm_path, version = find_npm_executable()
if not npm_path:
print(NPM_NOT_FOUND_MESSAGE)
return False
if not version:
print(NPM_MACHING_VERSION_NOT_FOUND_MESSAGE % NPM_MIN_VERSION)
return False
return True
def have_winrm():
# `winrm -h` should print 'winrm version ...' and exit 1
try:
p = subprocess.Popen(
["winrm.exe", "-h"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT
)
return p.wait() == 1 and p.stdout.read().startswith("winrm")
except Exception:
return False
|