Merge pull request #49 from pre-commit/fix_cwd_problem

Fix cwd problem

pre_commit/languages/all.py

@@ -5,14 +5,22 @@ from pre_commit.languages import ruby
 
 # A language implements the following two functions in its module:
 #
-# def install_environment():
+# def install_environment(repo_cmd_runner):
 #     """Installs a repository in the given repository.  Note that the current
 #     working directory will already be inside the repository.
+#
+#     Args:
+#         repo_cmd_runner - `PrefixedCommandRunner` bound to the repository.
 #     """
 #
-# def run_hook(hook, file_args):
+# def run_hook(repo_cmd_runner, hook, file_args):
 #     """Runs a hook and returns the returncode and output of running that hook.
 #
+#     Args:
+#         repo_cmd_runner - `PrefixedCommandRunner` bound to the repository.
+#         hook - Hook dictionary
+#         file_args - The files to be run
+#
 #     Returns:
 #         (returncode, stdout, stderr)
 #     """

pre_commit/languages/helpers.py

@@ -1,15 +1,17 @@
 
-import subprocess
-
 
 def run_hook(env, hook, file_args):
     return env.run(
         ' '.join(['xargs', hook['entry']] + hook.get('args', [])),
         stdin='\n'.join(list(file_args) + ['']),
+        retcode=None,
     )
 
 
 class Environment(object):
+    def __init__(self, repo_cmd_runner):
+        self.repo_cmd_runner = repo_cmd_runner
+
     @property
     def env_prefix(self):
         """env_prefix is a value that is prefixed to the command that is run.
@@ -24,14 +26,8 @@ class Environment(object):
         """
         raise NotImplementedError
 
-    def run(self, cmd, stdin=None):
+    def run(self, cmd, **kwargs):
         """Returns (returncode, stdout, stderr)."""
-        proc = subprocess.Popen(
-            ['bash', '-c', ' '.join([self.env_prefix, cmd])],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+        return self.repo_cmd_runner.run(
+            ['bash', '-c', ' '.join([self.env_prefix, cmd])], **kwargs
         )
-        stdout, stderr = proc.communicate(stdin)
-
-        return proc.returncode, stdout, stderr

pre_commit/languages/node.py

@@ -1,8 +1,8 @@
 import contextlib
-from plumbum import local
 
 from pre_commit.languages import helpers
 from pre_commit.languages import python
+from pre_commit.prefixed_command_runner import CalledProcessError
 
 
 NODE_ENV = 'node_env'
@@ -12,37 +12,42 @@ class NodeEnv(python.PythonEnv):
     @property
     def env_prefix(self):
         base = super(NodeEnv, self).env_prefix
-        return ' '.join([base, '. {0}/bin/activate &&'.format(NODE_ENV)])
+        return ' '.join([
+            base,
+            '. {{prefix}}{0}/bin/activate &&'.format(NODE_ENV)]
+        )
 
 
 @contextlib.contextmanager
-def in_env():
-    yield NodeEnv()
+def in_env(repo_cmd_runner):
+    yield NodeEnv(repo_cmd_runner)
 
 
-def install_environment():
-    assert local.path('package.json').exists()
+def install_environment(repo_cmd_runner):
+    assert repo_cmd_runner.exists('package.json')
 
-    if local.path(NODE_ENV).exists():
+    # Return immediately if we already have a virtualenv
+    if repo_cmd_runner.exists(NODE_ENV):
         return
 
-    local['virtualenv'][python.PY_ENV]()
+    repo_cmd_runner.run(['virtualenv', '{{prefix}}{0}'.format(python.PY_ENV)])
 
-    with python.in_env() as python_env:
+    with python.in_env(repo_cmd_runner) as python_env:
         python_env.run('pip install nodeenv')
 
         # Try and use the system level node executable first
-        retcode, _, _ = python_env.run('nodeenv -n system {0}'.format(NODE_ENV))
-        # TODO: log failure here
-        # cleanup
-        if retcode:
-            local.path(NODE_ENV).delete()
-            python_env.run('nodeenv --jobs 4 {0}'.format(NODE_ENV))
+        try:
+            python_env.run('nodeenv -n system {{prefix}}{0}'.format(NODE_ENV))
+        except CalledProcessError:
+            # TODO: log failure here
+            # cleanup
+            # TODO: local.path(NODE_ENV).delete()
+            python_env.run('nodeenv --jobs 4 {{prefix}}{0}'.format(NODE_ENV))
 
-        with in_env() as node_env:
-            node_env.run('npm install -g')
+        with in_env(repo_cmd_runner) as node_env:
+            node_env.run('cd {prefix} && npm install -g')
 
 
-def run_hook(hook, file_args):
-    with in_env() as node_env:
-        return helpers.run_hook(node_env, hook, file_args)
+def run_hook(repo_cmd_runner, hook, file_args):
+    with in_env(repo_cmd_runner) as env:
+        return helpers.run_hook(env, hook, file_args)

pre_commit/languages/python.py

@@ -1,34 +1,35 @@
 
 import contextlib
-from plumbum import local
+
 from pre_commit.languages import helpers
 
+
 PY_ENV = 'py_env'
 
 
 class PythonEnv(helpers.Environment):
     @property
     def env_prefix(self):
-        return '. {0}/bin/activate &&'.format(PY_ENV)
+        return '. {{prefix}}{0}/bin/activate &&'.format(PY_ENV)
 
 
 @contextlib.contextmanager
-def in_env():
-    yield PythonEnv()
+def in_env(repo_cmd_runner):
+    yield PythonEnv(repo_cmd_runner)
 
 
-def install_environment():
-    assert local.path('setup.py').exists()
+def install_environment(repo_cmd_runner):
+    assert repo_cmd_runner.exists('setup.py')
     # Return immediately if we already have a virtualenv
-    if local.path(PY_ENV).exists():
+    if repo_cmd_runner.exists(PY_ENV):
         return
 
     # Install a virtualenv
-    local['virtualenv'][PY_ENV]()
-    with in_env() as env:
-        env.run('pip install .')
+    repo_cmd_runner.run(['virtualenv', '{{prefix}}{0}'.format(PY_ENV)])
+    with in_env(repo_cmd_runner) as env:
+        env.run('cd {prefix} && pip install .')
 
 
-def run_hook(hook, file_args):
-    with in_env() as env:
+def run_hook(repo_cmd_runner, hook, file_args):
+    with in_env(repo_cmd_runner) as env:
         return helpers.run_hook(env, hook, file_args)

pre_commit/languages/ruby.py

@@ -1,6 +1,5 @@
 
 import contextlib
-from plumbum import local
 
 from pre_commit.languages import helpers
 
@@ -8,29 +7,27 @@ from pre_commit.languages import helpers
 RVM_ENV = 'rvm_env'
 
 
-class RubyEnv(object):
-    def __init__(self):
-        self.env_prefix = '. {0}/.rvm/scripts/rvm'.format(RVM_ENV)
-
-    def run(self, cmd, **kwargs):
-        return local['bash']['-c', ' '.join([self.env_prefix, cmd])].run(**kwargs)
+class RubyEnv(helpers.Environment):
+    @property
+    def env_prefix(self):
+        return '. {{prefix}}{0}/bin/activate &&'.format(RVM_ENV)
 
 
 @contextlib.contextmanager
-def in_env():
-    yield RubyEnv()
+def in_env(repo_cmd_runner):
+    yield RubyEnv(repo_cmd_runner)
 
 
-def install_environment():
+def install_environment(repo_cmd_runner):
     # Return immediately if we already have a virtualenv
-    if local.path(RVM_ENV).exists():
+    if repo_cmd_runner.exists(RVM_ENV):
         return
 
-    local['__rvm-env.sh'][RVM_ENV]()
-    with in_env() as env:
-        env.run('bundle install')
+    repo_cmd_runner.run(['__rvm-env.sh', '{{prefix}}{0}'.format(RVM_ENV)])
+    with in_env(repo_cmd_runner) as env:
+        env.run('cd {prefix} && bundle install')
 
 
-def run_hook(hook, file_args):
-    with in_env() as env:
+def run_hook(repo_cmd_runner, hook, file_args):
+    with in_env(repo_cmd_runner) as env:
         return helpers.run_hook(env, hook, file_args)

pre_commit/prefixed_command_runner.py

@@ -0,0 +1,82 @@
+
+import os
+import os.path
+import subprocess
+
+
+class CalledProcessError(RuntimeError):
+    def __init__(self, returncode, cmd, expected_returncode, output=None):
+        self.returncode = returncode
+        self.cmd = cmd
+        self.expected_returncode = expected_returncode
+        self.output = output
+
+    def __str__(self):
+        return (
+            'Command: {0!r}\n'
+            'Return code: {1}\n'
+            'Expected return code {2}\n',
+            'Output: {3!r}\n'.format(
+                self.cmd,
+                self.returncode,
+                self.expected_returncode,
+                self.output,
+            ),
+        )
+
+
+def _replace_cmd(cmd, **kwargs):
+    return [part.format(**kwargs) for part in cmd]
+
+
+class PrefixedCommandRunner(object):
+    """A PrefixedCommandRunner allows you to run subprocess commands with
+    comand substitution.
+
+    For instance:
+        PrefixedCommandRunner('/tmp/foo').run(['{prefix}foo.sh', 'bar', 'baz'])
+
+    will run ['/tmpl/foo/foo.sh', 'bar', 'baz']
+    """
+    def __init__(self, prefix_dir, popen=subprocess.Popen, makedirs=os.makedirs):
+        self.prefix_dir = prefix_dir.rstrip(os.sep) + os.sep
+        self.__popen = popen
+        self.__makedirs = makedirs
+
+    def _create_path_if_not_exists(self):
+        if not os.path.exists(self.prefix_dir):
+            self.__makedirs(self.prefix_dir)
+
+    def run(self, cmd, retcode=0, stdin=None, **kwargs):
+        self._create_path_if_not_exists()
+        replaced_cmd = _replace_cmd(cmd, prefix=self.prefix_dir)
+        proc = self.__popen(
+            replaced_cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            **kwargs
+        )
+        stdout, stderr = proc.communicate(stdin)
+        returncode = proc.returncode
+
+        if retcode is not None and retcode != returncode:
+            raise CalledProcessError(
+                returncode, replaced_cmd, retcode, output=(stdout, stderr),
+            )
+
+        return proc.returncode, stdout, stderr
+
+    def path(self, *parts):
+        path = os.path.join(self.prefix_dir, *parts)
+        return os.path.normpath(path)
+
+    def exists(self, *parts):
+        return os.path.exists(self.path(*parts))
+
+    @classmethod
+    def from_command_runner(cls, command_runner, path_end):
+        """Constructs a new command runner from an existing one by appending
+        `path_end` to the command runner's prefix directory.
+        """
+        return cls(command_runner.path(path_end), popen=command_runner.__popen)

pre_commit/repository.py

@@ -7,12 +7,15 @@ from pre_commit.clientlib.validate_manifest import load_manifest
 from pre_commit.hooks_workspace import in_hooks_workspace
 from pre_commit.languages.all import languages
 from pre_commit.ordereddict import OrderedDict
+from pre_commit.prefixed_command_runner import PrefixedCommandRunner
 from pre_commit.util import cached_property
 
 
 class Repository(object):
     def __init__(self, repo_config):
         self.repo_config = repo_config
+        self.__created = False
+        self.__installed = False
 
     @cached_property
     def repo_url(self):
@@ -43,13 +46,17 @@ class Repository(object):
                 for hook in load_manifest(C.MANIFEST_FILE)
             )
 
-    @contextlib.contextmanager
-    def in_checkout(self):
-        with in_hooks_workspace():
-            # SMELL:
-            self.create()
-            with local.cwd(self.sha):
-                yield
+    def get_cmd_runner(self, hooks_cmd_runner):
+        return PrefixedCommandRunner.from_command_runner(
+            hooks_cmd_runner, self.sha,
+        )
+
+    def require_created(self):
+        if self.__created:
+            return
+
+        self.create()
+        self.__created = True
 
     def create(self):
         with in_hooks_workspace():
@@ -61,13 +68,42 @@ class Repository(object):
             with self.in_checkout():
                 local['git']['checkout', self.sha]()
 
-    def install(self):
-        with self.in_checkout():
-            for language in C.SUPPORTED_LANGUAGES:
-                if language in self.languages:
-                    languages[language].install_environment()
+    def require_installed(self, cmd_runner):
+        if self.__installed:
+            return
 
-    def run_hook(self, hook_id, file_args):
-        with self.in_checkout():
-            hook = self.hooks[hook_id]
-            return languages[hook['language']].run_hook(hook, file_args)
+        self.install(cmd_runner)
+
+    def install(self, cmd_runner):
+        """Install the hook repository.
+
+        Args:
+            cmd_runner - A `PrefixedCommandRunner` bound to the hooks workspace
+        """
+        self.require_created()
+        repo_cmd_runner = self.get_cmd_runner(cmd_runner)
+        for language in C.SUPPORTED_LANGUAGES:
+            if language in self.languages:
+                languages[language].install_environment(repo_cmd_runner)
+
+    @contextlib.contextmanager
+    def in_checkout(self):
+        self.require_created()
+        with in_hooks_workspace():
+            with local.cwd(self.sha):
+                yield
+
+    def run_hook(self, cmd_runner, hook_id, file_args):
+        """Run a hook.
+
+        Args:
+            cmd_runner - A `PrefixedCommandRunner` bound to the hooks workspace
+            hook_id - Id of the hook
+            file_args - List of files to run
+        """
+        self.require_installed(cmd_runner)
+        repo_cmd_runner = self.get_cmd_runner(cmd_runner)
+        hook = self.hooks[hook_id]
+        return languages[hook['language']].run_hook(
+            repo_cmd_runner, hook, file_args,
+        )

pre_commit/run.py

@@ -1,6 +1,5 @@
 
 import argparse
-import os.path
 import subprocess
 import sys
 
@@ -18,9 +17,7 @@ COLS = int(subprocess.Popen(['tput', 'cols'], stdout=subprocess.PIPE).communicat
 PASS_FAIL_LENGTH = 6
 
 
-def _run_single_hook(repository, hook_id, all_files=False):
-    repository.install()
-
+def _run_single_hook(runner, repository, hook_id, all_files=False):
     if all_files:
         get_filenames = git.get_all_files_matching
     else:
@@ -36,8 +33,9 @@ def _run_single_hook(repository, hook_id, all_files=False):
     ),
 
     retcode, stdout, stderr = repository.run_hook(
+        runner.cmd_runner,
         hook_id,
-        map(os.path.abspath, get_filenames(hook['files'])),
+        get_filenames(hook['files']),
     )
 
     if retcode != repository.hooks[hook_id].get('expected_return_value', 0):
@@ -69,6 +67,7 @@ def run_hooks(runner, all_files=False):
     for repo in runner.repositories:
         for hook_id in repo.hooks:
             retval |= _run_single_hook(
+                runner,
                 repo,
                 hook_id,
                 all_files=all_files,
@@ -81,6 +80,7 @@ def run_single_hook(runner, hook_id, all_files=False):
     for repo in runner.repositories:
         if hook_id in repo.hooks:
             return _run_single_hook(
+                runner,
                 repo,
                 hook_id,
                 all_files=all_files,

pre_commit/runner.py

@@ -5,6 +5,7 @@ import os.path
 import pre_commit.constants as C
 from pre_commit import git
 from pre_commit.clientlib.validate_config import load_config
+from pre_commit.prefixed_command_runner import PrefixedCommandRunner
 from pre_commit.repository import Repository
 from pre_commit.util import cached_property
 
@@ -44,3 +45,7 @@ class Runner(object):
     @cached_property
     def pre_commit_path(self):
         return os.path.join(self.git_root, '.git/hooks/pre-commit')
+
+    @cached_property
+    def cmd_runner(self):
+        return PrefixedCommandRunner(self.hooks_workspace_path)