Issue 6909 - Make ensure_dependencies.py call "npm install" for non-repositories

ensure_dependencies.py

 #!/usr/bin/env 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 sys
 import os
 import posixpath
 import re
@@ skipping 228 matching lines @@
         raise Exception('Dependency path %s cannot be absolute' % subpath)
     if normpath == posixpath.pardir or normpath.startswith(posixpath.pardir + posixpath.sep):
         raise Exception('Dependency path %s has to be inside the repository' % subpath)
     return os.path.join(path, *normpath.split(posixpath.sep))
 
 
 def get_repo_type(repo):
     for name, repotype in repo_types.iteritems():
         if repotype.istype(repo):
             return name
-    return 'hg'
+    return None
 
 
 def resolve_npm_dependencies(target, vcs):
     """Install Node.js production-only dependencies if necessary and desired.
 
     When the target dependency has additional Node.js dependencies declared
     run "npm install --only=production --loglevel=warn" to resolve the declared
     dependencies.
 
     Additionally, make sure that any VCS will ignore the installed files.
@@ skipping 24 matching lines @@
             # Node.js only provides a npm.cmd, which is executable but won't
             # be recognized as such by CreateProcess().
             npm_exec = 'npm.cmd'
         else:
             npm_exec = 'npm'
 
         cmd = [npm_exec, 'install', '--only=production', '--loglevel=warn',
                '--no-package-lock', '--no-optional']
         subprocess.check_output(cmd, cwd=target)
 
-        repo_types[vcs].ignore(os.path.join(target, NPM_LOCKFILE), target)
-        repo_types[vcs].ignore(os.path.join(target, 'node_modules'), target)
+        if vcs:
+            repo_types[vcs].ignore(os.path.join(target, NPM_LOCKFILE), target)
+            repo_types[vcs].ignore(os.path.join(target, 'node_modules'), target)
 
         os.remove(lockfile_path)
     except OSError as e:
         import errno
         if e.errno == errno.ENOENT:
             logging.error('Failed to install Node.js dependencies for %s,'
                           ' please ensure Node.js is installed.', target)
         else:
             raise
 
@@ skipping 38 matching lines @@
             resolved_revision = repo_types[type].get_revision_id(target, revision)
             if not resolved_revision:
                 raise Exception('Failed to resolve revision %s' % revision)
 
         logging.info('Updating repository %s to revision %s' % (target, resolved_revision))
         repo_types[type].update(target, resolved_revision, revision)
         return True
     return False
 
 
-def resolve_deps(repodir, level=0, self_update=True, overrideroots=None, skipdependencies=set()):
+def resolve_deps(repodir, repotype, level=0, self_update=True,
+                 overrideroots=None, skipdependencies=set()):
     config = read_deps(repodir)
     if config is None:
         if level == 0:
             logging.warning('No dependencies file in directory %s, nothing to do...\n%s' % (repodir, USAGE))
         return
     if level >= 10:
         logging.warning('Too much subrepository nesting, ignoring %s' % repo)
         return
 
     if overrideroots is not None:
         config['_root'] = overrideroots
 
     for dir, sources in sorted(config.iteritems()):
         if (dir.startswith('_') or
             skipdependencies.intersection([s[0] for s in sources if s[0]])):
             continue
 
         target = safe_join(repodir, dir)
-        parenttype = get_repo_type(repodir)
+        parenttype = repotype or 'hg'
         _root = config.get('_root', {})
 
         for key in sources.keys() + _root.keys():
             if key == parenttype or key is None and vcs != '*':
                 vcs = key
         source, rev = merge_seqs(sources.get('*'), sources.get(vcs))
 
         if not (vcs and source and rev):
             logging.warning('No valid source / revision found to create %s' % target)
             continue
 
         repo_cloned = ensure_repo(repodir, parenttype, target, vcs,
                                   _root.get(vcs, ''), source)
-        repo_updated = update_repo(target, vcs, rev)
+        if repo_types[vcs].istype(target):
+            repo_updated = update_repo(target, vcs, rev)
+            npm_outdated = repo_cloned or repo_updated
+        else:
+            vcs = None
+            npm_outdated = not os.path.exists(
+                os.path.join(target, 'node_modules')
+            )
+
         recent_npm_failed = os.path.exists(os.path.join(target, NPM_LOCKFILE))
-        if repo_cloned or repo_updated or recent_npm_failed:
+        if npm_outdated or recent_npm_failed:
             resolve_npm_dependencies(target, vcs)
-        resolve_deps(target, level + 1, self_update=False,
+
+        resolve_deps(target, vcs, level + 1, self_update=False,
                      overrideroots=overrideroots, skipdependencies=skipdependencies)
 
     if self_update and '_self' in config and '*' in config['_self']:
         source = safe_join(repodir, config['_self']['*'])
         try:
             with io.open(source, 'rb') as handle:
                 sourcedata = handle.read()
         except IOError as e:
             if e.errno != errno.ENOENT:
                 raise
@@ skipping 35 matching lines @@
     parser.add_argument('-q', '--quiet', action='store_true', help='Suppress informational output')
     args = parser.parse_args()
 
     if args.quiet:
         logging.disable(logging.INFO)
 
     repos = args.repos
     if not len(repos):
         repos = [os.path.dirname(__file__)]
     for repo in repos:
-        resolve_deps(repo)
+        resolve_deps(repo, get_repo_type(repo))