Fix core completion, broken in the previous commit.

1 files changed, 73 insertions, 73 deletions

diff --git a/poezio/core/completions.py b/poezio/core/completions.py
index 04764268..9b64cd48 100644
--- a/poezio/core/completions.py
+++ b/poezio/core/completions.py
@@ -22,13 +22,13 @@ class CompletionCore:
     def __init__(self, core):
         self.core = core
 
-    def completion_help(self, the_input):
+    def help(self, the_input):
         """Completion for /help."""
-        commands = sorted(self.commands.keys()) + sorted(self.current_tab().commands.keys())
+        commands = sorted(self.core.commands.keys()) + sorted(self.core.current_tab().commands.keys())
         return the_input.new_completion(commands, 1, quotify=False)
 
 
-    def completion_status(self, the_input):
+    def status(self, the_input):
         """
         Completion of /status
         """
@@ -36,7 +36,7 @@ class CompletionCore:
             return the_input.new_completion([status for status in POSSIBLE_SHOW], 1, ' ', quotify=False)
 
 
-    def completion_presence(self, the_input):
+    def presence(self, the_input):
         """
         Completion of /presence
         """
@@ -47,35 +47,35 @@ class CompletionCore:
             return the_input.auto_completion([status for status in POSSIBLE_SHOW], '', quotify=True)
 
 
-    def completion_theme(self, the_input):
+    def theme(self, the_input):
         """ Completion for /theme"""
         themes_dir = config.get('themes_dir')
-        themes_dir = themes_dir or\
-        os.path.join(os.environ.get('XDG_DATA_HOME') or\
-                         os.path.join(os.environ.get('HOME'), '.local', 'share'),
-                     'poezio', 'themes')
+        themes_dir = (themes_dir or
+                      os.path.join(os.environ.get('XDG_DATA_HOME') or
+                                   os.path.join(os.environ.get('HOME'), '.local', 'share'),
+                                   'poezio', 'themes'))
         themes_dir = os.path.expanduser(themes_dir)
         try:
             names = os.listdir(themes_dir)
         except OSError as e:
             log.error('Completion for /theme failed', exc_info=True)
-            return
+            return False
         theme_files = [name[:-3] for name in names if name.endswith('.py') and name != '__init__.py']
-        if not 'default' in theme_files:
+        if 'default' not in theme_files:
             theme_files.append('default')
         return the_input.new_completion(theme_files, 1, '', quotify=False)
 
 
-    def completion_win(self, the_input):
+    def win(self, the_input):
         """Completion for /win"""
         l = []
-        for tab in self.tabs:
+        for tab in self.core.tabs:
             l.extend(tab.matching_names())
         l = [i[1] for i in l]
         return the_input.new_completion(l, 1, '', quotify=False)
 
 
-    def completion_join(self, the_input):
+    def join(self, the_input):
         """
         Completion for /join
 
@@ -98,9 +98,9 @@ class CompletionCore:
             jid.user = args[1][:-1]
 
         relevant_rooms = []
-        relevant_rooms.extend(sorted(self.pending_invites.keys()))
-        bookmarks = {str(elem.jid): False for elem in self.bookmarks}
-        for tab in self.get_tabs(tabs.MucTab):
+        relevant_rooms.extend(sorted(self.core.pending_invites.keys()))
+        bookmarks = {str(elem.jid): False for elem in self.core.bookmarks}
+        for tab in self.core.get_tabs(tabs.MucTab):
             name = tab.name
             if name in bookmarks and not tab.joined:
                 bookmarks[name] = True
@@ -112,54 +112,54 @@ class CompletionCore:
         if jid.user:
             # we are writing the server: complete the server
             serv_list = []
-            for tab in self.get_tabs(tabs.MucTab):
+            for tab in self.core.get_tabs(tabs.MucTab):
                 if tab.joined:
-                    serv_list.append('%s@%s'% (jid.user, safeJID(tab.name).host))
+                    serv_list.append('%s@%s' % (jid.user, safeJID(tab.name).host))
             serv_list.extend(relevant_rooms)
             return the_input.new_completion(serv_list, 1, quotify=True)
         elif args[1].startswith('/'):
             # we completing only a resource
-            return the_input.new_completion(['/%s' % self.own_nick], 1, quotify=True)
+            return the_input.new_completion(['/%s' % self.core.own_nick], 1, quotify=True)
         else:
             return the_input.new_completion(relevant_rooms, 1, quotify=True)
 
 
-    def completion_version(self, the_input):
+    def version(self, the_input):
         """Completion for /version"""
         comp = reduce(lambda x, y: x + [i.jid for i in y], (roster[jid].resources for jid in roster.jids() if len(roster[jid])), [])
         return the_input.new_completion(sorted(comp), 1, quotify=False)
 
 
-    def completion_list(self, the_input):
+    def list(self, the_input):
         """Completion for /list"""
         muc_serv_list = []
-        for tab in self.get_tabs(tabs.MucTab):   # TODO, also from an history
+        for tab in self.core.get_tabs(tabs.MucTab):   # TODO, also from an history
             if tab.name not in muc_serv_list:
                 muc_serv_list.append(safeJID(tab.name).server)
         if muc_serv_list:
             return the_input.new_completion(muc_serv_list, 1, quotify=False)
 
 
-    def completion_move_tab(self, the_input):
+    def move_tab(self, the_input):
         """Completion for /move_tab"""
         n = the_input.get_argument_position(quoted=True)
         if n == 1:
-            nodes = [tab.name for tab in self.tabs if tab]
+            nodes = [tab.name for tab in self.core.tabs if tab]
             nodes.remove('Roster')
             return the_input.new_completion(nodes, 1, ' ', quotify=True)
 
 
-    def completion_runkey(self, the_input):
+    def runkey(self, the_input):
         """
         Completion for /runkey
         """
         list_ = []
-        list_.extend(self.key_func.keys())
-        list_.extend(self.current_tab().key_func.keys())
+        list_.extend(self.core.key_func.keys())
+        list_.extend(self.core.current_tab().key_func.keys())
         return the_input.new_completion(list_, 1, quotify=False)
 
 
-    def completion_bookmark(self, the_input):
+    def bookmark(self, the_input):
         """Completion for /bookmark"""
         args = common.shell_split(the_input.text)
         n = the_input.get_argument_position(quoted=True)
@@ -167,60 +167,60 @@ class CompletionCore:
         if n == 2:
             return the_input.new_completion(['true', 'false'], 2, quotify=True)
         if n >= 3:
-            return
+            return False
 
         if len(args) == 1:
             args.append('')
         jid = safeJID(args[1])
 
         if jid.server and (jid.resource or jid.full.endswith('/')):
-            tab = self.get_tab_by_name(jid.bare, tabs.MucTab)
+            tab = self.core.get_tab_by_name(jid.bare, tabs.MucTab)
             nicks = [tab.own_nick] if tab else []
             default = os.environ.get('USER') if os.environ.get('USER') else 'poezio'
             nick = config.get('default_nick')
             if not nick:
-                if not default in nicks:
+                if default not in nicks:
                     nicks.append(default)
             else:
-                if not nick in nicks:
+                if nick not in nicks:
                     nicks.append(nick)
             jids_list = ['%s/%s' % (jid.bare, nick) for nick in nicks]
             return the_input.new_completion(jids_list, 1, quotify=True)
-        muc_list = [tab.name for tab in self.get_tabs(tabs.MucTab)]
+        muc_list = [tab.name for tab in self.core.get_tabs(tabs.MucTab)]
         muc_list.sort()
         muc_list.append('*')
         return the_input.new_completion(muc_list, 1, quotify=True)
 
 
-    def completion_remove_bookmark(self, the_input):
+    def remove_bookmark(self, the_input):
         """Completion for /remove_bookmark"""
-        return the_input.new_completion([bm.jid for bm in self.bookmarks], 1, quotify=False)
+        return the_input.new_completion([bm.jid for bm in self.core.bookmarks], 1, quotify=False)
 
 
-    def completion_decline(self, the_input):
+    def decline(self, the_input):
         """Completion for /decline"""
         n = the_input.get_argument_position(quoted=True)
         if n == 1:
-            return the_input.auto_completion(sorted(self.pending_invites.keys()), 1, '', quotify=True)
+            return the_input.auto_completion(sorted(self.core.pending_invites.keys()), 1, '', quotify=True)
 
 
-    def completion_bind(self, the_input):
+    def bind(self, the_input):
         n = the_input.get_argument_position()
         if n == 1:
-            args = [key for key in self.key_func if not key.startswith('_')]
+            args = [key for key in self.core.key_func if not key.startswith('_')]
         elif n == 2:
-            args = [key for key in self.key_func]
+            args = [key for key in self.core.key_func]
         else:
-            return
+            return False
 
         return the_input.new_completion(args, n, '', quotify=False)
 
 
-    def completion_message(self, the_input):
+    def message(self, the_input):
         """Completion for /message"""
         n = the_input.get_argument_position(quoted=True)
         if n >= 2:
-            return
+            return False
         l = []
         for jid in roster.jids():
             if len(roster[jid]):
@@ -230,7 +230,7 @@ class CompletionCore:
         return the_input.new_completion(l, 1, '', quotify=True)
 
 
-    def completion_invite(self, the_input):
+    def invite(self, the_input):
         """Completion for /invite"""
         n = the_input.get_argument_position(quoted=True)
         if n == 1:
@@ -242,14 +242,14 @@ class CompletionCore:
             return the_input.new_completion(comp, n, quotify=True)
         elif n == 2:
             rooms = []
-            for tab in self.get_tabs(tabs.MucTab):
+            for tab in self.core.get_tabs(tabs.MucTab):
                 if tab.joined:
                     rooms.append(tab.name)
             rooms.sort()
             return the_input.new_completion(rooms, n, '', quotify=True)
 
 
-    def completion_activity(self, the_input):
+    def activity(self, the_input):
         """Completion for /activity"""
         n = the_input.get_argument_position(quoted=True)
         args = common.shell_split(the_input.text)
@@ -263,34 +263,34 @@ class CompletionCore:
                 return the_input.new_completion(l, n, quotify=True)
 
 
-    def completion_mood(self, the_input):
+    def mood(self, the_input):
         """Completion for /mood"""
         n = the_input.get_argument_position(quoted=True)
         if n == 1:
             return the_input.new_completion(sorted(pep.MOODS.keys()), 1, quotify=True)
 
 
-    def completion_last_activity(self, the_input):
+    def last_activity(self, the_input):
         """
         Completion for /last_activity <jid>
         """
         n = the_input.get_argument_position(quoted=False)
         if n >= 2:
-            return
+            return False
         comp = reduce(lambda x, y: x + [i.jid for i in y], (roster[jid].resources for jid in roster.jids() if len(roster[jid])), [])
         return the_input.new_completion(sorted(comp), 1, '', quotify=False)
 
 
-    def completion_server_cycle(self, the_input):
+    def server_cycle(self, the_input):
         """Completion for /server_cycle"""
         serv_list = set()
-        for tab in self.get_tabs(tabs.MucTab):
+        for tab in self.core.get_tabs(tabs.MucTab):
             serv = safeJID(tab.name).server
             serv_list.add(serv)
         return the_input.new_completion(sorted(serv_list), 1, ' ')
 
 
-    def completion_set(self, the_input):
+    def set(self, the_input):
         """Completion for /set"""
         args = common.shell_split(the_input.text)
         n = the_input.get_argument_position(quoted=True)
@@ -299,9 +299,9 @@ class CompletionCore:
         if n == 1:
             if '|' in args[1]:
                 plugin_name, section = args[1].split('|')[:2]
-                if not plugin_name in self.plugin_manager.plugins:
-                        return the_input.new_completion([], n, quotify=True)
-                plugin = self.plugin_manager.plugins[plugin_name]
+                if plugin_name not in self.core.plugin_manager.plugins:
+                    return the_input.new_completion([], n, quotify=True)
+                plugin = self.core.plugin_manager.plugins[plugin_name]
                 end_list = ['%s|%s' % (plugin_name, section) for section in plugin.config.sections()]
             else:
                 end_list = set(config.options('Poezio'))
@@ -311,9 +311,9 @@ class CompletionCore:
         elif n == 2:
             if '|' in args[1]:
                 plugin_name, section = args[1].split('|')[:2]
-                if not plugin_name in self.plugin_manager.plugins:
-                        return the_input.new_completion([''], n, quotify=True)
-                plugin = self.plugin_manager.plugins[plugin_name]
+                if plugin_name not in self.core.plugin_manager.plugins:
+                    return the_input.new_completion([''], n, quotify=True)
+                plugin = self.core.plugin_manager.plugins[plugin_name]
                 end_list = set(plugin.config.options(section or plugin_name))
                 if plugin.config.default:
                     end_list.update(plugin.config.default.get(section or plugin_name, {}))
@@ -330,9 +330,9 @@ class CompletionCore:
         elif n == 3:
             if '|' in args[1]:
                 plugin_name, section = args[1].split('|')[:2]
-                if not plugin_name in self.plugin_manager.plugins:
-                        return the_input.new_completion([''], n, quotify=True)
-                plugin = self.plugin_manager.plugins[plugin_name]
+                if plugin_name not in self.core.plugin_manager.plugins:
+                    return the_input.new_completion([''], n, quotify=True)
+                plugin = self.core.plugin_manager.plugins[plugin_name]
                 end_list = [str(plugin.config.get(args[2], '', section or plugin_name)), '']
             else:
                 if not config.has_section(args[1]):
@@ -340,11 +340,11 @@ class CompletionCore:
                 else:
                     end_list = [str(config.get(args[2], '', args[1])), '']
         else:
-            return
+            return False
         return the_input.new_completion(end_list, n, quotify=True)
 
 
-    def completion_set_default(self, the_input):
+    def set_default(self, the_input):
         """ Completion for /set_default
         """
         args = common.shell_split(the_input.text)
@@ -352,40 +352,40 @@ class CompletionCore:
         if n >= len(args):
             args.append('')
         if n == 1 or (n == 2 and config.has_section(args[1])):
-            return self.completion_set(the_input)
-        return []
+            return self.set(the_input)
+        return False
 
 
-    def completion_toggle(self, the_input):
+    def toggle(self, the_input):
         "Completion for /toggle"
         return the_input.new_completion(config.options('Poezio'), 1, quotify=False)
 
 
-    def completion_bookmark_local(self, the_input):
+    def bookmark_local(self, the_input):
         """Completion for /bookmark_local"""
         n = the_input.get_argument_position(quoted=True)
         args = common.shell_split(the_input.text)
 
         if n >= 2:
-            return
+            return False
         if len(args) == 1:
             args.append('')
         jid = safeJID(args[1])
 
         if jid.server and (jid.resource or jid.full.endswith('/')):
-            tab = self.get_tab_by_name(jid.bare, tabs.MucTab)
+            tab = self.core.get_tab_by_name(jid.bare, tabs.MucTab)
             nicks = [tab.own_nick] if tab else []
             default = os.environ.get('USER') if os.environ.get('USER') else 'poezio'
             nick = config.get('default_nick')
             if not nick:
-                if not default in nicks:
+                if default not in nicks:
                     nicks.append(default)
             else:
-                if not nick in nicks:
+                if nick not in nicks:
                     nicks.append(nick)
             jids_list = ['%s/%s' % (jid.bare, nick) for nick in nicks]
             return the_input.new_completion(jids_list, 1, quotify=True)
-        muc_list = [tab.name for tab in self.get_tabs(tabs.MucTab)]
+        muc_list = [tab.name for tab in self.core.get_tabs(tabs.MucTab)]
         muc_list.append('*')
         return the_input.new_completion(muc_list, 1, quotify=True)