major overhaul of version detection

Author: tony

libtmux/common.py

@@ -11,7 +11,7 @@
 import re
 import sys
 import subprocess
-from distutils.version import StrictVersion, LooseVersion
+from distutils.version import LooseVersion
 
 from . import exc
 from ._compat import console_to_str
@@ -395,67 +395,93 @@ def _is_executable_file_or_link(exe):
     return None
 
 
-def is_version(version):
+def get_version():
+    """Return tmux version.
+
+    :returns: tmux version
+    :rtype: :class:`distutils.version.LooseVersion`
+    """
+    proc = tmux_cmd('-V')
+    if proc.stderr:
+        if proc.stderr[0] == 'tmux: unknown option -- V':
+            if sys.platform.startswith("openbsd"):  # openbsd has no tmux -V
+                return LooseVersion('2.3')
+            raise exc.LibTmuxException(
+                'libtmux supports tmux 1.8 and greater. This system'
+                ' is running tmux 1.3 or earlier.')
+        raise exc.VersionTooLow(proc.stderr)
+
+    version = proc.stdout[0].split('tmux ')[1]
+
+    # Allow latest tmux HEAD
+    if version == 'master':
+        return LooseVersion('master')
+
+    version = re.sub(r'[a-z]', '', version)
+
+    return LooseVersion(version)
+
+
+def has_version(version):
     """Return True if tmux version installed.
 
     :param version: version, '1.8'
-    :param type: string
+    :type version: string
+    :returns: True if version matches
     :rtype: bool
-
     """
-    if sys.platform.startswith("openbsd"):
-        if LooseVersion(version) > LooseVersion('2.1'):
-            return 'openbsd'
-        else:
-            return False
+    return get_version() == LooseVersion(version)
 
-    proc = tmux_cmd('-V')
 
-    if proc.stderr:
-        raise exc.LibTmuxException(proc.stderr)
+def has_gt_version(min_version):
+    """Return True if tmux version greater than minimum.
+
+    :param min_version: version, e.g. '1.8'
+    :type min_version: string
+    :returns: True if version above min_version
+    :rtype: bool
+    """
+    return get_version() >= LooseVersion(min_version)
 
-    installed_version = proc.stdout[0].split('tmux ')[1]
 
-    return LooseVersion(installed_version) == LooseVersion(version)
+def has_lt_version(max_version):
+    """Return True if tmux version less than minimum.
+
+    :param max_version: version, e.g. '1.8'
+    :type max_version: string
+    :returns: True if version below max_version
+    :rtype: bool
+    """
+    return get_version() <= LooseVersion(max_version)
 
 
-def has_required_tmux_version(version=None):
+def has_minimum_tmux_version(raises=True):
     """Return if tmux meets version requirement. Version >1.8 or above.
 
+    :param raises: Will raise exception if version too low, default ``True``
+    :type raises: bool
+    :returns: True if tmux meets minimum required version
+    :rtype: bool
+
+    :versionchanged: 0.7.0
+        No longer returns version, returns True or False
     :versionchanged: 0.1.7
         Versions will now remove trailing letters per `Issue 55`_.
 
         .. _Issue 55: https://github.com/tony/tmuxp/issues/55.
 
     """
 
-    if not version:
-        if sys.platform.startswith("openbsd"):  # openbsd has no tmux -V
-            return '2.3'
-
-        proc = tmux_cmd('-V')
-
-        if proc.stderr:
-            if proc.stderr[0] == 'tmux: unknown option -- V':
-                raise exc.LibTmuxException(
-                    'libtmux supports tmux 1.8 and greater. This system'
-                    ' is running tmux 1.3 or earlier.')
-            raise exc.LibTmuxException(proc.stderr)
-
-        version = proc.stdout[0].split('tmux ')[1]
-
-    # Allow latest tmux HEAD
-    if version == 'master':
-        return version
-
-    version = re.sub(r'[a-z]', '', version)
-
-    if StrictVersion(version) <= StrictVersion("1.7"):
-        raise exc.LibTmuxException(
-            'libtmux only supports tmux 1.8 and greater. This system'
-            ' has %s installed. Upgrade your tmux to use libtmux.' % version
-        )
-    return version
+    if get_version() <= LooseVersion("1.7"):
+        if raises:
+            raise exc.VersionTooLow(
+                'libtmux only supports tmux 1.8 and greater. This system'
+                ' has %s installed. Upgrade your tmux to use libtmux.' %
+                get_version()
+            )
+        else:
+            return False
+    return True
 
 
 def session_check_name(session_name):
@@ -477,3 +503,32 @@ def session_check_name(session_name):
     elif ':' in session_name:
         raise exc.BadSessionName(
             "tmux session name \"%s\" may not contain colons.", session_name)
+
+
+def handle_option_error(error):
+    """Raises exception if error in option command found.
+
+    Purpose: As of tmux 2.4, there are now 3 different types of option errors:
+
+    - unknown option
+    - invalid option
+    - ambiguous option
+
+    Before 2.4, unknown option was the user.
+
+    All errors raised will have the base error of :exc:`exc.OptionError`. So to
+    catch any option error, use ``except exc.OptionError``.
+
+    :param error: error response from subprocess call
+    :type error: str
+    :raises: :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`excAmbiguousOption`
+    """
+    if 'unknown option' in error:
+        raise exc.UnknownOption(error)
+    elif 'invalid option' in error:
+        raise exc.InvalidOption(error)
+    elif 'ambiguous option' in error:
+        raise exc.AmbiguousOption(error)
+    else:
+        raise exc.OptionError(error)  # Raise generic option error

tests/test_common.py

@@ -2,26 +2,54 @@
 """Tests for utility functions in tmux."""
 
 import re
+import sys
 
 import pytest
 
+from distutils.version import LooseVersion
+
+import libtmux
+
 from libtmux.common import (
-    has_required_tmux_version, which, session_check_name, is_version, tmux_cmd
+    has_minimum_tmux_version, which, session_check_name, tmux_cmd,
+    has_version, has_gt_version, has_lt_version, get_version
 )
 from libtmux.exc import LibTmuxException, BadSessionName, TmuxCommandNotFound
 
 version_regex = re.compile(r'([0-9]\.[0-9])|(master)')
 
 
-def test_no_arg_uses_tmux_version():
-    """Test the :meth:`has_required_tmux_version`."""
-    result = has_required_tmux_version()
-    assert version_regex.match(result) is not None
+def test_allows_master_version(monkeypatch):
+    def mock_get_version():
+        return LooseVersion('master')
+    monkeypatch.setattr(libtmux.common, 'get_version', mock_get_version)
+
+    assert has_minimum_tmux_version()
 
 
-def test_allows_master_version():
-    result = has_required_tmux_version('master')
-    assert version_regex.match(result) is not None
+def test_get_version_openbsd(monkeypatch):
+    def mock_tmux_cmd(param):
+        class Hi(object):
+            pass
+        proc = Hi()
+        proc.stderr = ['tmux: unknown option -- V']
+        return proc
+    monkeypatch.setattr(libtmux.common, 'tmux_cmd', mock_tmux_cmd)
+    monkeypatch.setattr(sys, 'platform', 'openbsd 5.2')
+    assert get_version() == LooseVersion('2.3')
+
+
+def test_get_version_too_low(monkeypatch):
+    def mock_tmux_cmd(param):
+        class Hi(object):
+            pass
+        proc = Hi()
+        proc.stderr = ['tmux: unknown option -- V']
+        return proc
+    monkeypatch.setattr(libtmux.common, 'tmux_cmd', mock_tmux_cmd)
+    with pytest.raises(LibTmuxException) as exc_info:
+        get_version()
+    exc_info.match('is running tmux 1.3 or earlier')
 
 
 def test_ignores_letter_versions():
@@ -33,29 +61,47 @@ def test_ignores_letter_versions():
     allow letters.
 
     """
-    result = has_required_tmux_version('1.9a')
-    assert version_regex.match(result) is not None
+    result = has_minimum_tmux_version('1.9a')
+    assert result
 
-    result = has_required_tmux_version('1.8a')
-    assert result == r'1.8'
+    result = has_minimum_tmux_version('1.8a')
+    assert result
 
     # Should not throw
-    assert type(is_version('1.8')) is bool
-    assert type(is_version('1.8a')) is bool
-    assert type(is_version('1.9a')) is bool
+    assert type(has_version('1.8')) is bool
+    assert type(has_version('1.8a')) is bool
+    assert type(has_version('1.9a')) is bool
 
 
-def test_error_version_less_1_7():
+def test_error_version_less_1_7(monkeypatch):
+    def mock_get_version():
+        return LooseVersion('1.7')
+    monkeypatch.setattr(libtmux.common, 'get_version', mock_get_version)
     with pytest.raises(LibTmuxException) as excinfo:
-        has_required_tmux_version('1.7')
-        excinfo.match(r'tmuxp only supports')
+        has_minimum_tmux_version()
+        excinfo.match(r'libtmux only supports')
 
     with pytest.raises(LibTmuxException) as excinfo:
-        has_required_tmux_version('1.6a')
+        has_minimum_tmux_version()
+
+        excinfo.match(r'libtmux only supports')
+
+
+def test_has_version():
+    assert has_version(str(get_version()))
+
+
+def test_has_gt_version():
+    assert has_gt_version('1.6')
+    assert has_gt_version('1.6b')
+    assert not has_gt_version('4.0')
+
 
-        excinfo.match(r'tmuxp only supports')
+def test_has_lt_version():
+    assert has_lt_version('4.0a')
+    assert has_lt_version('4.0')
 
-    has_required_tmux_version('1.9a')
+    assert not has_lt_version('1.7')
 
 
 def test_which_no_bin_found():