[common] Fix handling of forkable VS versionnable asset types

The lists were wrong. All assets that can be versionned are not
forkable and experiment can currently be forked but has not version
support.

beat/cmdline/common.py

@@ -151,9 +151,9 @@ class Selector(object):
         self.__version = {}
         self.__fork = {}
         self.__versionables = [
+            "algorithm",
             "dataformat",
             "database",
-            "algorithm",
             "library",
             "toolchain",
             "plotter",
@@ -161,7 +161,15 @@ class Selector(object):
             "protocoltemplate",
         ]
 
-        self.__forkables = self.__versionables + ["experiment"]
+        self.__forkables = [
+            "algorithm",
+            "dataformat",
+            "experiment",
+            "library",
+            "toolchain",
+            "plotter",
+            "plotterparameter",
+        ]
 
         if os.path.exists(self.path):
             self.load()
@@ -187,27 +195,37 @@ class Selector(object):
             if asset_type not in self.__fork:
                 self.__fork[asset_type] = dict()
 
-    def fork(self, type, src, dst):
+    def can_fork(self, asset_type):
+        """Returns whether the given asset type can be forked"""
+
+        return asset_type in self.__forkables
+
+    def fork(self, asset_type, src, dst):
         """Registers that object ``dst`` is a fork of object ``src``"""
 
+        if not self.can_fork(asset_type):
+            raise RuntimeError("Can't create new version of {}".format(asset_type))
+
         logger.info(
             "`%s/%s' is forked from `%s/%s'",
-            TYPE_PLURAL[type],
+            TYPE_PLURAL[asset_type],
             dst,
-            TYPE_PLURAL[type],
+            TYPE_PLURAL[asset_type],
             src,
         )
-        self.__fork[type][dst] = src
+        self.__fork[asset_type][dst] = src
 
-    def forked_from(self, type, name):
+    def forked_from(self, asset_type, name):
         """Returns the name of the originating source object or ``None``"""
+        if not self.can_fork(asset_type):
+            return None
 
-        return self.__fork[type].get(name)
+        return self.__fork[asset_type].get(name)
 
     def version(self, asset_type, src, dst):
         """Registers that object ``dst`` is a new version of object ``src``"""
 
-        if asset_type not in self.__version:
+        if asset_type not in self.__versionables:
             raise RuntimeError("Can't create new version of {}".format(asset_type))
 
         logger.info(
@@ -230,7 +248,7 @@ class Selector(object):
     def delete(self, asset_type, name):
         """Forgets about an object that was being tracked"""
 
-        if name in self.__fork[asset_type]:
+        if asset_type in self.__fork and name in self.__fork[asset_type]:
             del self.__fork[asset_type][name]
         if asset_type in self.__version and name in self.__version[asset_type]:
             del self.__version[asset_type][name]