refactor igalic/bools branch

Author: gronke

libiocage/lib/Datasets.py

@@ -89,7 +89,7 @@ def activate_pool(self, pool, mountpoint=None):
         )
 
     def _is_pool_active(self, pool):
-        return libiocage.lib.helpers.parse_bool(self._get_pool_property(
+        return libiocage.lib.helpers.parse_user_input(self._get_pool_property(
             pool,
             self.ZFS_POOL_ACTIVE_PROPERTY
         ))

libiocage/lib/JailConfig.py

@@ -212,27 +212,27 @@ def _set_type(self, value, **kwargs):
             self.data["type"] = value
 
     def _get_basejail(self):
-        return libiocage.lib.helpers.parse_bool(self.data["basejail"])
+        return libiocage.lib.helpers.parse_user_input(self.data["basejail"])
 
     def _default_basejail(self):
         return False
 
     def _set_basejail(self, value, **kwargs):
         if self["legacy"]:
-            self.data["basejail"] = libiocage.lib.helpers.get_str_bool(
+            self.data["basejail"] = libiocage.lib.helpers.to_string(
                 value, true="on", false="off")
         else:
-            self.data["basejail"] = libiocage.lib.helpers.get_str_bool(
+            self.data["basejail"] = libiocage.lib.helpers.to_string(
                 value, true="yes", false="no")
 
     def _get_clonejail(self):
-        return libiocage.lib.helpers.parse_bool(self.data["clonejail"])
+        return libiocage.lib.helpers.parse_user_input(self.data["clonejail"])
 
     def _default_clonejail(self):
         return True
 
     def _set_clonejail(self, value, **kwargs):
-        self.data["clonejail"] = libiocage.lib.helpers.get_str_bool(
+        self.data["clonejail"] = libiocage.lib.helpers.to_string(
             value, true="on", false="off")
 
     def _get_ip4_addr(self):
@@ -307,10 +307,10 @@ def _default_defaultrouter6(self):
         return None
 
     def _get_vnet(self):
-        return libiocage.lib.helpers.parse_bool(self.data["vnet"])
+        return libiocage.lib.helpers.parse_user_input(self.data["vnet"])
 
     def _set_vnet(self, value, **kwargs):
-        self.data["vnet"] = libiocage.lib.helpers.get_str_bool(
+        self.data["vnet"] = libiocage.lib.helpers.to_string(
             value, true="on", false="off")
 
     def _get_jail_zfs_dataset(self):
@@ -325,7 +325,7 @@ def _set_jail_zfs_dataset(self, value, **kwargs):
         self.data["jail_zfs_dataset"] = " ".join(value)
 
     def _get_jail_zfs(self):
-        enabled = libiocage.lib.helpers.parse_bool(self.data["jail_zfs"])
+        enabled = libiocage.lib.helpers.parse_user_input(self.data["jail_zfs"])
         if not enabled:
             if len(self.jail_zfs_dataset) > 0:
                 raise libiocage.lib.errors.JailConigZFSIsNotAllowed(
@@ -336,7 +336,7 @@ def _set_jail_zfs(self, value, **kwargs):
         if (value is None) or (value == ""):
             del self.data["jail_zfs"]
             return
-        self.data["jail_zfs"] = libiocage.lib.helpers.get_str_bool(
+        self.data["jail_zfs"] = libiocage.lib.helpers.to_string(
             value, true="on", false="off")
 
     def _default_jail_zfs(self):

libiocage/lib/RCConf.py

@@ -88,15 +88,14 @@ def save(self):
             self.logger.spam(output[:-1], jail=self.jail, indent=1)
 
     def __setitem__(self, key, value):
+       
+        val = libiocage.lib.helpers.to_string(
+            libiocage.lib.helpers.parse_user_input(value),
+            true="YES",
+            false="NO"
+        )
 
-        val = libiocage.lib.helpers.parse_user_input(value)
-        # normalize booleans
-        if isinstance(value, bool):
-            dict.__setitem__(self, key,
-                             libiocage.lib.helpers.get_str_bool(
-                                 value, true="YES", false="NO"))
-        else:
-            dict.__setitem__(self, key, str(val))
+        dict.__setitem__(self, key, val)
 
     def __getitem__(self, key):
         val = dict.__getitem__(self, key)

libiocage/lib/helpers.py

@@ -99,82 +99,124 @@ def _prettify_output(output):
 # helper function to validate names
 def validate_name(name):
     validate = re.compile(r'[a-z0-9][a-z0-9\.\-_]{0,31}', re.I)
-
     return bool(validate.fullmatch(name))
 
 
-# data -> bool | default
-def parse_bool(data, default=False):
-    """
-    try to parse booleans from strings
+def _parse_none(data):
 
-    On success, it returns the parsed boolean
-    on failure it returns the `default`.
-    By default, `default` is `False`.
+    if data is None:
+        return None
 
-    >>> parse_bool("YES")
-    True
-    >>> parse_bool("false")
-    False
-    >>> parse_bool("/etc/passwd")
-    False
+    if data in ["none", "-"]:
+        return None
 
-    Note that "-" gets a special treatment:
+    raise TypeError("Value is not None")
 
-    >>> parse_bool("-")
-    None
 
-    The behavior of the default parameter can be used to create a
-    pass-thru function:
+def _parse_bool(data):
+    """
+    try to parse booleans from strings
 
-    >>> default = "/etc/passwd"
-    >>> parse_bool(default, default)
-    "/etc/passwd"
+    On success, it returns the parsed boolean on failure it raises a TypeError.
+
+    Usage:
+        
+        >>> _parse_bool("YES")
+        True
+        >>> _parse_bool("false")
+        False
+        >>> _parse_bool("/etc/passwd")
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+        TypeError: Not a boolean value
+    
     """
 
     if isinstance(data, bool):
         return data
     if isinstance(data, str):
-        if data == "-":
-            return None
-        elif data.lower() in ["yes", "true", "on"]:
+        val = data.lower()
+        if val in ["yes", "true", "on"]:
             return True
-        elif data.lower() in ["no", "false", "off"]:
+        elif val in ["no", "false", "off"]:
             return False
-    return default
+    
+    raise TypeError("Value is not a boolean")
 
 
 def parse_user_input(data):
     """
-    uses parse_bool() to partially return Boolean and NoneType values
+    uses _parse_bool() to partially return Boolean and NoneType values
     All other types as returned as-is
 
-    >>> parse_bool("YES")
+    >>> parse_user_input("YES")
     True
-    >>> parse_bool("false")
+    >>> parse_user_input("false")
     False
-    >>> parse_bool(8.4)
+    >>> parse_user_input("notfalse")
+    'notfalse'
+    >>> parse_user_input(8.4)
     8.4
     """
-    return parse_bool(data, data)
 
+    try:
+        return _parse_bool(data)
+    except TypeError:
+        pass
+
+    try:
+        return _parse_none(data)
+    except TypeError:
+        pass
+
+    return data
 
-def get_str_bool(data, true="yes", false="no"):
+
+def to_string(data, true="yes", false="no", none="-"):
     """
-    return a string boolean value using parse_bool(), of specified style
+    return a string boolean value using _parse_bool(), of specified style
+
+    Args:
+
+        true (string):
+            The expected return value when data is True
+
+        false (string):
+            The expected return value when data is False
+
+        none (string):
+            The expected return value when data is None
+
+    Returns:
 
-    >>> get_str_bool(True)
-    "yes"
-    >>> get_str_bool(False)
-    "no"
+        string: Map input according to arguments or stringified input
 
-    >>> get_str_bool(True, true="yip", false="nope")
-    "yip"
-    >>> get_str_bool(False, true="yip", false="nope")
-    "nope"
+    Usage:
+
+        >>> to_string(True)
+        "yes"
+        >>> to_string(False)
+        "no"
+
+        >>> to_string(True, true="yip", false="nope")
+        "yip"
+        >>> to_string(False, true="yip", false="nope")
+        "nope"
+
+        >>> to_string(None)
+        "-"
     """
-    return true if parse_bool(data) else false
 
+    data = parse_user_input(data)
+
+    if data is None:
+        return none
+    elif data is True:
+        return true
+    elif data is False:
+        return false
+
+    return str(data)
 
 def exec_passthru(command, logger=None):
     if isinstance(command, str):