Let's see if this makes Sonar happy.

Added a StatusHandler to be able to move more logic into the backend modules

Author: totokaka

mcman/backend/plugins.py

@@ -308,7 +308,7 @@ def resolve_dependencies(server, plugin_name, status_hook,
 
     plugin = bukget.find_by_name(server, plugin_name)
     if plugin is None:
-        status_hook(1, (plugin_name,))
+        status_hook(1, plugin_name)
         return stack
 
     plugin = bukget.plugin_details(server, plugin, version,
@@ -327,7 +327,7 @@ def resolve_dependencies(server, plugin_name, status_hook,
     for dep in plugin['versions'][0]['hard_dependencies']:
         slug = bukget.find_by_name(server, dep)
         if slug is None:
-            status_hook(3, (dep,))
+            status_hook(3, dep)
             continue
         if slug not in stack:
             resolve_dependencies(server, slug, status_hook, stack=stack)
@@ -363,7 +363,7 @@ def find_plugins(server, queries, status_hook):
         version = ''
         slug = bukget.find_by_name(server, plugin)
         if slug is None:
-            status_hook(1, (plugin,))
+            status_hook(1, plugin)
             continue
         if len(plugin_version) > 1:
             version = plugin_version[1]
@@ -407,3 +407,43 @@ def download(question, frmt, plugins, skip=False):
             plugin = plugins[i]
             prefix = frmt.format(total=len(plugins), part=i+1)
             download_plugin(plugin, prefix)
+
+
+def find_updates(server, to_install, versions, status_hook):
+    """ Find updates for plugins.
+
+    This function will also check if the plugins are allready installed.
+
+    Parameters:
+        server         The server
+        to_install     A list over plugins that should be installed
+        versions       A dict with optional specific versions for plugins
+        status_hook    A status hook
+
+    """
+    plugins = list()
+    installed = list_plugins()
+
+    for slug in to_install:
+        plugin = download_details(server, slug,
+                                  versions[slug]
+                                  if slug in versions
+                                  else VERSION)
+
+        if plugin is None:
+            status_hook(1, slug)
+            continue
+        elif len(plugin['versions']) < 1:
+            status_hook(2, slug)
+            continue
+
+        for i in installed:
+            if i[0] == slug and i[1] >= plugin['versions'][0]['version']:
+                status_hook(3, plugin['plugin_name'])
+                break
+            elif i[0] == slug:
+                status_hook(4, plugin['plugin_name'])
+        else:
+            plugins.append(plugin)
+
+    return plugins

mcman/frontend/plugins_command.py

@@ -7,6 +7,7 @@
 """
 
 from urllib.error import URLError
+from mcman.status_handler import StatusHandler
 from mcman.backend import plugins as backend
 from mcman.backend import common as utils
 from mcman.frontend.common import Command
@@ -34,18 +35,6 @@ def __init__(self, args):
 
         self.invoke_subcommand(args.subcommand, (ValueError, URLError))
 
-    def status_find_plugins(self, key, values):
-        """ Print status for backend.find_plugins. """
-        self.p_sub('Could not find {}'.format(values[0]))
-
-    def status_dependencies(self, key, values):
-        """ Print status for backend.dependencies. """
-        if key == 1 or key == 3:
-            self.p_sub('Could not find `{}`', values[0])
-            return
-        self.p_sub('Could not find version `{}` of `{}`'.format(
-            values[1], values[0]))
-
     def search(self):
         """ Search for plugins. """
         query = self.args.query
@@ -164,16 +153,27 @@ def download(self):
         """ Download plugins. """
         self.p_main('Finding plugins on BukGet')
 
+        status_handler = StatusHandler()
+        status_handler.register_handler(1, lambda arguments:
+                                        self.p_sub('Could not find {}'.format(
+                                            arguments[0])))
         to_install, versions = backend.find_plugins(self.args.server,
                                                     self.args.plugins,
-                                                    self.status_find_plugins)
+                                                    status_handler.get_hook())
 
         self.p_main('Resolving dependencies')
 
-        to_install = backend.dependencies(self.args.server,
-                                          to_install,
-                                          versions,
-                                          self.status_dependencies)
+        status_handler = StatusHandler()
+        one_three = lambda arguments: \
+            self.p_sub('Could not find `{}`'.format(arguments))
+        two = lambda arguments: \
+            self.p_sub('Could not find version `{}` of `{}`'.format(
+                arguments[0], arguments[1]))
+        status_handler.register_handler(1, one_three)
+        status_handler.register_handler(2, two)
+        status_handler.register_handler(3, one_three)
+        to_install = backend.dependencies(self.args.server, to_install,
+                                          versions, status_handler.get_hook())
 
         if len(to_install) < 1:
             self.p_main('Found no plugins!')
@@ -182,32 +182,25 @@ def download(self):
         self.p_main(
             'Resolving versions, and checking allready installed plugins')
 
-        installed = backend.list_plugins()
-        plugins = list()
-        for slug in to_install:
-            plugin = backend.download_details(self.server, slug,
-                                              versions[slug]
-                                              if slug in versions
-                                              else self.args.version)
-
-            if plugin is None:
-                self.p_sub('Could not find plugin `{}` again'.format(slug))
-                continue
-            elif len(plugin['versions']) < 1:
-                self.p_sub('Could not find version of `{}` again'.format(slug))
-                continue
-
-            for i in installed:
-                if i[0] == slug and i[1] >= plugin['versions'][0]['version']:
-                    self.p_sub('{} was allready installed.'.format(
-                        plugin['plugin_name']))
-                    break
-                elif i[0] == slug:
-                    self.p_sub(
-                        '{} is allready installed, but out of date'.format(
-                            plugin['plugin_name']))
-            else:
-                plugins.append(plugin)
+        status_handler = StatusHandler()
+        one = lambda argument: \
+            self.p_sub('Could not find plugin `{}` again'.format(argument))
+        two = lambda argument: \
+            self.p_sub('Could not find version of `{}` again'.format(
+                argument))
+        three = lambda argument: \
+            self.p_sub('{} was allready installed.'.format(
+                argument))
+        four = lambda argument: \
+            self.p_sub('{} is allready installed, but out of date'.format(
+                argument))
+        status_handler.register_handler(1, one)
+        status_handler.register_handler(2, two)
+        status_handler.register_handler(3, three)
+        status_handler.register_handler(4, four)
+
+        plugins = backend.find_updates(self.server, to_install, versions,
+                                       status_handler.get_hook())
 
         if len(plugins) < 1:
             self.p_main('No plugins left to install')

mcman/status_handler.py

@@ -0,0 +1,29 @@
+""" Status Handler. """
+
+
+class StatusHandler(object):
+
+    """ Status Handler.
+
+    A status handler can register functions to run when a status is sent.
+
+    """
+
+    def __init__(self):
+        """ Initialize. """
+        self.statuses = dict()
+
+    def register_handler(self, key, function):
+        """ Register a handler. """
+        self.statuses[key] = function
+
+    def get_hook(self):
+        """ Get the status hook. """
+        def invoke(key, arguments):
+            """ Invoke an handler. """
+            if key in self.statuses:
+                self.statuses[key](arguments)
+            else:
+                print('No handler found for key {}'.format(key))
+
+        return invoke