Merge lp:~dobey/dirspec/add-exefind into lp:dirspec

[dobey]

Add a generic API for discovering paths to program executables

[Mike McCracken (mikemc)]

Thanks for putting this together. It needs just a bit more doc string cleanup:

The doc string for UnfrozenSrcTestCase, and its first two test functions are still from the version that prepended 'python' to the return value.

The doc string for test_darwin_pkgd_raises_on_no_appnames is also from the old version.

and probably the function name 'test_linux_no_src_relative_path_no_constants' and its doc string should be changed, too - since the code doesn't look for a constants module anymore.

review: Needs Fixing

[Mike McCracken (mikemc)]

Just noticed this - you might also want to tag it as fixing bug #1021833.

[lp:~dobey/dirspec/add-exefind]

14. By dobey on 2012-07-11

Update tests docstrings from review
Remove a couple of now extraneous/duplicate tests
Rename the ExeFind test case to ProgramPath
Link the bug as LP isn't picking up the sub-commit bugs

[Mike McCracken (mikemc)]

review: Approve

[Roberto Alsina (ralsina)]

review: Approve

=== modified file 'dirspec/tests/test_utils.py'
--- dirspec/tests/test_utils.py	2012-06-26 15:25:21 +0000
+++ dirspec/tests/test_utils.py	2012-07-11 14:57:22 +0000
@@ -17,8 +17,11 @@
 import os
 import sys
 
-from dirspec import basedir
-from dirspec.utils import get_env_path, get_special_folders, user_home
+from twisted.trial.unittest import TestCase
+
+from dirspec import basedir, utils as dirutils
+from dirspec.utils import (get_env_path, get_special_folders,
+                           user_home, get_program_path)
 from dirspec.tests import BaseTestCase
 
 
@@ -150,3 +153,116 @@
         self.assertEqual(get_env_path(fake_env_var, default), default)
     test_get_env_path_var.skip = 'UnicodeEncodeError: bug #907053'
     test_get_env_path_no_var.skip = test_get_env_path_var.skip
+
+
+class ProgramPathBaseTestCase(TestCase):
+    """Base class for testing the executable finder."""
+
+    def setUp(self):
+        """Set up fake modules."""
+        super(ProgramPathBaseTestCase, self).setUp()
+        self.patch(os.path, "exists", lambda x: True)
+
+
+class UnfrozenSrcTestCase(ProgramPathBaseTestCase):
+    """Test non-linux path discovery."""
+
+    def setUp(self):
+        super(UnfrozenSrcTestCase, self).setUp()
+        self.patch(sys, "platform", "darwin")
+
+    def test_unfrozen_dev_toplevel(self):
+        """Not frozen, return path to bin dir."""
+        path = get_program_path("foo", fallback_dirs=['/path/to/bin'])
+        self.assertEquals(path, "/path/to/bin/foo")
+
+    def test_unfrozen_dev_toplevel_raises_nopath(self):
+        """Not frozen, raise OSError when the path doesn't exist."""
+        self.patch(os.path, "exists", lambda x: False)
+        self.assertRaises(OSError, get_program_path, "foo")
+
+
+class DarwinPkgdTestCase(ProgramPathBaseTestCase):
+    """Test cmdline for running packaged on darwin."""
+
+    def setUp(self):
+        """SetUp to mimic frozen darwin."""
+        super(DarwinPkgdTestCase, self).setUp()
+        self.patch(sys, "platform", "darwin")
+        sys.frozen = True
+
+        self.darwin_app_names = {"foo": "Foo.app"}
+
+    def tearDown(self):
+        """tearDown, Remove frozen attr"""
+        del sys.frozen
+        super(DarwinPkgdTestCase, self).tearDown()
+
+    def test_darwin_pkgd(self):
+        """Return sub-app path on darwin when frozen."""
+        path = get_program_path("foo", app_names=self.darwin_app_names)
+        expectedpath = "%s/%s" % (
+            dirutils.__file__,
+            "Contents/Resources/Foo.app/Contents/MacOS/foo")
+        self.assertEquals(path, expectedpath)
+
+    def test_darwin_pkgd_raises_on_no_appnames(self):
+        """Raises TypeError when no app_names dict is in the kwargs."""
+        self.assertRaises(TypeError, get_program_path, "foo")
+
+    def test_darwin_pkgd_raises_nopath(self):
+        """Frozen, raise OSError when the path doesn't exist."""
+        self.patch(os.path, "exists", lambda x: False)
+        self.assertRaises(OSError, get_program_path, "foo",
+                          app_names=self.darwin_app_names)
+
+
+class Win32PkgdTestCase(ProgramPathBaseTestCase):
+    """Test cmdline for running packaged on windows."""
+
+    def setUp(self):
+        """SetUp to mimic frozen windows."""
+        super(Win32PkgdTestCase, self).setUp()
+        self.patch(sys, "platform", "win32")
+        sys.frozen = True
+
+    def tearDown(self):
+        """tearDown, Remove frozen attr"""
+        del sys.frozen
+        super(Win32PkgdTestCase, self).tearDown()
+
+    def test_windows_pkgd(self):
+        """Return sub-app path on windows when frozen."""
+
+        self.patch(sys, "executable", os.path.join("C:\\path", "to",
+                                                   "current.exe"))
+        # patch abspath to let us run this tests on non-windows:
+        self.patch(os.path, "abspath", lambda x: x)
+        path = get_program_path("foo", None)
+        expectedpath = os.path.join("C:\\path", "to", "foo.exe")
+        self.assertEquals(path, expectedpath)
+
+    def test_windows_pkgd_raises_nopath(self):
+        """Frozen, raise OSError when the path doesn't exist."""
+        self.patch(os.path, "exists", lambda x: False)
+        self.assertRaises(OSError, get_program_path, "foo")
+
+
+class PosixTestCase(ProgramPathBaseTestCase):
+    """Test cmdline for running on linux."""
+
+    def setUp(self):
+        """SetUp to mimic linux2."""
+        super(PosixTestCase, self).setUp()
+        self.patch(sys, "platform", "linux2")
+
+    def test_linux_src_relative_path_exists(self):
+        """linux, return source relative path if it exists."""
+        path = get_program_path("foo", fallback_dirs=['/path/to/bin'])
+        expectedpath = "/path/to/bin/foo"
+        self.assertEquals(path, expectedpath)
+
+    def test_linux_no_src_relative_path(self):
+        """raise if no src rel path."""
+        self.patch(os.path, "exists", lambda x: False)
+        self.assertRaises(OSError, get_program_path, "foo")

=== modified file 'dirspec/utils.py'
--- dirspec/utils.py	2011-12-17 00:46:26 +0000
+++ dirspec/utils.py	2012-07-11 14:57:22 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2011 Canonical Ltd.
+# Copyright 2011-2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License version 3
@@ -15,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Utilities for multiplatform support of XDG directory handling."""
 
+import errno
 import os
 import sys
 
@@ -25,10 +26,79 @@
            'default_data_home',
            'default_data_path',
            'get_env_path',
+           'get_program_path',
            'unicode_path',
            ]
 
 
+def _get_exe_path_frozen_win32(exe_name):
+    """Get path to the helper .exe on packaged windows."""
+    # all the .exes are in the same place on windows:
+    cur_exec_path = os.path.abspath(sys.executable)
+    exe_dir = os.path.dirname(cur_exec_path)
+    return os.path.join(exe_dir, exe_name + ".exe")
+
+
+def _get_exe_path_frozen_darwin(exe_name, app_names):
+    """Get path to the sub-app executable on packaged darwin."""
+
+    sub_app_name = app_names[exe_name]
+    main_app_dir = "".join(__file__.partition(".app")[:-1])
+    main_app_resources_dir = os.path.join(main_app_dir,
+                                          "Contents",
+                                          "Resources")
+    exe_bin = os.path.join(main_app_resources_dir,
+                           sub_app_name,
+                           "Contents", "MacOS",
+                           exe_name)
+    return exe_bin
+
+
+def get_program_path(program_name, *args, **kwargs):
+    """Given a program name, returns the path to run that program.
+
+    Raises OSError if the program is not found.
+
+    :param program_name: The name of the program to find. For darwin and win32
+        platforms, the behavior is changed slightly, when sys.frozen is set,
+        to look in the packaged program locations for the program.
+    :param search_dirs: A list of directories to look for the program in. This
+        is only available as a keyword argument.
+    :param app_names: A dict of program names mapped to sub-app names. Used
+        for discovering paths in embedded .app bundles on the darwin platform.
+        This is only available as a keyword argument.
+    :return: The path to the discovered program.
+    """
+    search_dirs = kwargs.get('fallback_dirs', None)
+    app_names = kwargs.get('app_names', None)
+
+    if getattr(sys, "frozen", None) is not None:
+        if sys.platform == 'win32':
+            program_path = _get_exe_path_frozen_win32(program_name)
+        elif sys.platform == 'darwin':
+            program_path = _get_exe_path_frozen_darwin(program_name,
+                                                       app_names)
+        else:
+            raise Exception("Unsupported platform for frozen execution: %r" %
+                            sys.platform)
+    else:
+        if search_dirs is not None:
+            for dirname in search_dirs:
+                program_path = os.path.join(dirname, program_name)
+                if os.path.exists(program_path):
+                    return program_path
+        else:
+            # Check in normal system $PATH, if no fallback dirs specified
+            from distutils.spawn import find_executable
+            program_path = find_executable(program_name)
+
+    if program_path is None or not os.path.exists(program_path):
+        raise OSError(errno.ENOENT,
+                      "Could not find executable %r" % program_name)
+
+    return program_path
+
+
 def get_env_path(key, default):
     """Get a UTF-8 encoded path from an environment variable."""
     if key in os.environ:
@@ -41,7 +111,7 @@
 
 
 def unicode_path(utf8path):
-    """Turn an utf8 path into a unicode path."""
+    """Turn a UTF-8 path into a unicode path."""
     return utf8path.decode("utf-8")