Add a node-install goal to Pants for installing node_modules

contrib/node/src/python/pants/contrib/node/register.py

@@ -5,6 +5,7 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 from pants.build_graph.build_file_aliases import BuildFileAliases
+from pants.goal.goal import Goal
 from pants.goal.task_registrar import TaskRegistrar as task
 
 from pants.contrib.node.subsystems.resolvers.node_preinstalled_module_resolver import \
@@ -18,8 +19,10 @@
 from pants.contrib.node.tasks.javascript_style import JavascriptStyleFmt, JavascriptStyleLint
 from pants.contrib.node.tasks.node_build import NodeBuild
 from pants.contrib.node.tasks.node_bundle import NodeBundle as NodeBundleTask
+from pants.contrib.node.tasks.node_install import NodeInstall
 from pants.contrib.node.tasks.node_repl import NodeRepl
 from pants.contrib.node.tasks.node_resolve import NodeResolve
+from pants.contrib.node.tasks.node_resolve_local import NodeResolveLocal
 from pants.contrib.node.tasks.node_run import NodeRun
 from pants.contrib.node.tasks.node_test import NodeTest as NodeTestTask
 
@@ -37,12 +40,19 @@ def build_file_aliases():
 
 
 def register_goals():
+  # Register descriptions.
+  Goal.register('node-install', 'Installs a node_module target.')
+
+  # Register tasks.
+
   task(name='node', action=NodeRepl).install('repl')
   task(name='node', action=NodeResolve).install('resolve')
+  task(name='node-install', action=NodeResolveLocal).install('resolve')
   task(name='node', action=NodeRun).install('run')
   task(name='node', action=NodeBuild).install('compile', first=True)
   task(name='node', action=NodeTestTask).install('test')
   task(name='node', action=NodeBundleTask).install('bundle')
+  task(name='node', action=NodeInstall).install('node-install')
   # Linting
   task(name='javascriptstyle', action=JavascriptStyleLint).install('lint')
   task(name='javascriptstyle', action=JavascriptStyleFmt).install('fmt')

contrib/node/src/python/pants/contrib/node/subsystems/resolvers/node_preinstalled_module_resolver.py

@@ -18,6 +18,7 @@
 from pants.contrib.node.subsystems.resolvers.node_resolver_base import NodeResolverBase
 from pants.contrib.node.targets.node_preinstalled_module import NodePreinstalledModule
 from pants.contrib.node.tasks.node_resolve import NodeResolve
+from pants.contrib.node.tasks.node_resolve_local import NodeResolveLocal
 
 
 class NodePreinstalledModuleResolver(Subsystem, NodeResolverBase):
@@ -29,8 +30,9 @@ def register_options(cls, register):
              help='Timeout the fetch if the connection is idle for longer than this value.')
     super(NodePreinstalledModuleResolver, cls).register_options(register)
     NodeResolve.register_resolver_for_type(NodePreinstalledModule, cls)
+    NodeResolveLocal.register_resolver_for_type(NodePreinstalledModule, cls)
 
-  def resolve_target(self, node_task, target, results_dir, node_paths):
+  def resolve_target(self, node_task, target, results_dir, node_paths, resolve_locally=False):
     self._copy_sources(target, results_dir)
 
     with temporary_dir() as temp_dir:

contrib/node/src/python/pants/contrib/node/subsystems/resolvers/node_resolver_base.py

@@ -15,7 +15,7 @@
 
 class NodeResolverBase(AbstractClass):
   @abstractmethod
-  def resolve_target(self, node_task, target, results_dir, node_paths):
+  def resolve_target(self, node_task, target, results_dir, node_paths, resolve_locally=False):
     """Resolve a NodePackage target."""
 
   @classmethod

contrib/node/src/python/pants/contrib/node/subsystems/resolvers/npm_resolver.py

@@ -19,6 +19,7 @@
 from pants.contrib.node.subsystems.resolvers.node_resolver_base import NodeResolverBase
 from pants.contrib.node.targets.node_module import NodeModule
 from pants.contrib.node.tasks.node_resolve import NodeResolve
+from pants.contrib.node.tasks.node_resolve_local import NodeResolveLocal
 
 
 class NpmResolver(Subsystem, NodeResolverBase):
@@ -31,16 +32,20 @@ def register_options(cls, register):
       '--install-optional', type=bool, default=False, fingerprint=True,
       help='If enabled, install optional dependencies.')
     NodeResolve.register_resolver_for_type(NodeModule, cls)
+    NodeResolveLocal.register_resolver_for_type(NodeModule, cls)
 
-  def resolve_target(self, node_task, target, results_dir, node_paths):
-    self._copy_sources(target, results_dir)
+  def resolve_target(self, node_task, target, results_dir, node_paths, resolve_locally=False):
+    if not resolve_locally:
+      self._copy_sources(target, results_dir)
     with pushd(results_dir):
       if not os.path.exists('package.json'):
         raise TaskError(
           'Cannot find package.json. Did you forget to put it in target sources?')
       # TODO: remove/remodel the following section when node_module dependency is fleshed out.
       package_manager = node_task.get_package_manager(target=target).name
       if package_manager == PACKAGE_MANAGER_NPM:
+        if resolve_locally:
+          raise TaskError('Resolving node package modules locally is not supported for NPM.')
         if os.path.exists('npm-shrinkwrap.json'):
           node_task.context.log.info('Found npm-shrinkwrap.json, will not inject package.json')
         else:

contrib/node/src/python/pants/contrib/node/tasks/BUILD

@@ -10,12 +10,15 @@ target(
     ':node_run',
     ':node_test',
     ':javascript_style',
+    ':node_install',
   ]
 )
 
 python_library(
   name='node_paths',
-  sources=['node_paths.py'],
+  sources=[
+    'node_paths.py',
+    'node_paths_local.py'],
   dependencies = [
     '3rdparty/python:future',
   ],
@@ -77,7 +80,9 @@ python_library(
 
 python_library(
   name='node_resolve',
-  sources=['node_resolve.py'],
+  sources=[
+   'node_resolve.py',
+   'node_resolve_local.py'],
   dependencies=[
     ':node_paths',
     ':node_task',
@@ -125,4 +130,16 @@ python_library(
     'src/python/pants/util:contextutil',
     'src/python/pants/util:process_handler',
   ]
-)
+)
+
+python_library(
+  name='node_install',
+  sources=['node_install.py'],
+  dependencies=[
+    ':node_paths',
+    ':node_task',
+    'src/python/pants/base:exceptions',
+    'src/python/pants/base:workunit',
+    'src/python/pants/util:contextutil',
+  ]
+)

contrib/node/src/python/pants/contrib/node/tasks/node_install.py

@@ -0,0 +1,28 @@
+# coding=utf-8
+# Copyright 2015 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from pants.contrib.node.tasks.node_paths_local import NodePathsLocal
+from pants.contrib.node.tasks.node_task import NodeTask
+
+
+class NodeInstall(NodeTask):
+  """Installs a node_module target into the source directory"""
+
+  @classmethod
+  def prepare(cls, options, round_manager):
+    super(NodeInstall, cls).prepare(options, round_manager)
+    round_manager.require_data(NodePathsLocal)
+
+  @classmethod
+  def supports_passthru_args(cls):
+    return True
+
+  def execute(self):
+    for target in self.context.target_roots:
+      if self.is_node_module(target):
+        node_paths = self.context.products.get_data(NodePathsLocal)
+        self.context.log.debug('Start installing node_module target: {}'.format(target))
+        self.context.log.debug('Node_path: {}'.format(node_paths.node_path(target)))

contrib/node/src/python/pants/contrib/node/tasks/node_paths_local.py

@@ -0,0 +1,11 @@
+# coding=utf-8
+# Copyright 2015 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from pants.contrib.node.tasks.node_paths import NodePaths
+
+
+class NodePathsLocal(NodePaths):
+  """Maps Node package targets to their local NODE_PATH chroot."""

contrib/node/src/python/pants/contrib/node/tasks/node_resolve_local.py

@@ -0,0 +1,54 @@
+# coding=utf-8
+# Copyright 2015 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os
+
+from pants.base.workunit import WorkUnitLabel
+
+from pants.contrib.node.tasks.node_paths_local import NodePathsLocal
+from pants.contrib.node.tasks.node_resolve import NodeResolve
+
+
+class NodeResolveLocal(NodeResolve):
+  """Resolves node_package targets to source chroots using different registered resolvers."""
+
+  @classmethod
+  def product_types(cls):
+    return [NodePathsLocal]
+
+  @property
+  def cache_target_dirs(self):
+    # Do not create a results_dir for this task
+    return True
+
+  def artifact_cache_reads_enabled(self):
+    # Artifact caching is not necessary for local installation.
+    # Just depend on the local cache provided by the package manager.
+    return self._cache_factory.read_cache_available()
+
+  def execute(self):
+    targets = self.context.targets(predicate=self._can_resolve_target)
+    if not targets:
+      return
+
+    node_paths = self.context.products.get_data(NodePathsLocal, init_func=NodePathsLocal)
+    # Invalidate all targets for this task, and use invalidated() check
+    # to build topologically sorted target graph. This is probably not the best way
+    # to do this, but it works.
+    self.invalidate()
+    with self.invalidated(targets,
+                          # This is necessary to ensure that transitive dependencies are installed first
+                          topological_order=True,
+                          invalidate_dependents=True,
+                          silent=True) as invalidation_check:
+      with self.context.new_workunit(name='node-install', labels=[WorkUnitLabel.MULTITOOL]):
+        for vt in invalidation_check.all_vts:
+          target = vt.target
+          if not vt.valid:
+            resolver_for_target_type = self._resolver_for_target(target).global_instance()
+            results_dir = os.path.abspath(target.address.spec_path)
+            resolver_for_target_type.resolve_target(self, target, results_dir, node_paths, resolve_locally=True)
+          node_paths.resolved(target, results_dir)