Make pylint happier with metadata.py

A bunch of cosmetic changes to be more compliant with PEP80 and pylint.
And I added a pylintrc so that we can ignore some rules that just add
too much clutter.

Author: koljonen

pylintrc

@@ -0,0 +1,2 @@
+[MESSAGES CONTROL]
+disable=missing-docstring,invalid-name

tests/metadata.py

@@ -1,27 +1,34 @@
-from pgcli.packages.parseutils.meta import FunctionMetadata, ForeignKey
-from prompt_toolkit.completion import Completion
 from functools import partial
 from itertools import product
+from pgcli.packages.parseutils.meta import FunctionMetadata, ForeignKey
+from prompt_toolkit.completion import Completion
 from prompt_toolkit.document import Document
 from mock import Mock
 import pytest
 
-escape = lambda name: ('"' + name + '"' if not name.islower() or name in (
-    'select', 'insert') else name)
-
 parametrize = pytest.mark.parametrize
+
 qual = ['if_more_than_one_table', 'always']
 no_qual = ['if_more_than_one_table', 'never']
 
+
+def escape(name):
+    if not name.islower() or name in ('select', 'insert'):
+        return '"' + name + '"'
+    return name
+
+
 def completion(display_meta, text, pos=0):
     return Completion(text, start_position=pos, display_meta=display_meta)
 
+
 def get_result(completer, text, position=None):
     position = len(text) if position is None else position
     return completer.get_completions(
         Document(text=text, cursor_position=position), Mock()
     )
 
+
 def result_set(completer, text, position=None):
     return set(get_result(completer, text, position))
 
@@ -30,14 +37,23 @@ def result_set(completer, text, position=None):
 # def schema(text, pos=0):
 #   return completion('schema', text, pos)
 # and so on
-schema, table, view, function, column, keyword, datatype, alias, name_join,\
-    fk_join, join = [partial(completion, display_meta)
-    for display_meta in('schema', 'table', 'view', 'function', 'column',
-    'keyword', 'datatype', 'table alias', 'name join', 'fk join', 'join')]
+schema = partial(completion, 'schema')
+table = partial(completion, 'table')
+view = partial(completion, 'view')
+function = partial(completion, 'function')
+column = partial(completion, 'column')
+keyword = partial(completion, 'keyword')
+datatype = partial(completion, 'datatype')
+alias = partial(completion, 'table alias')
+name_join = partial(completion, 'name join')
+fk_join = partial(completion, 'fk join')
+join = partial(completion, 'join')
+
 
 def wildcard_expansion(cols, pos=-1):
-        return Completion(cols, start_position=pos, display_meta='columns',
-            display = '*')
+    return Completion(
+        cols, start_position=pos, display_meta='columns', display='*')
+
 
 class MetaData(object):
     def __init__(self, metadata):
@@ -52,97 +68,103 @@ def builtin_datatypes(self, pos=0):
     def keywords(self, pos=0):
         return [keyword(kw, pos) for kw in self.completer.keywords]
 
-    def columns(self, parent, schema='public', typ='tables', pos=0):
+    def columns(self, tbl, parent='public', typ='tables', pos=0):
         if typ == 'functions':
-            fun = [x for x in self.metadata[typ][schema] if x[0] == parent][0]
+            fun = [x for x in self.metadata[typ][parent] if x[0] == tbl][0]
             cols = fun[1]
         else:
-            cols = self.metadata[typ][schema][parent]
+            cols = self.metadata[typ][parent][tbl]
         return [column(escape(col), pos) for col in cols]
 
-    def datatypes(self, schema='public', pos=0):
-        return [datatype(escape(x), pos)
-            for x in self.metadata.get('datatypes', {}).get(schema, [])]
+    def datatypes(self, parent='public', pos=0):
+        return [
+            datatype(escape(x), pos)
+            for x in self.metadata.get('datatypes', {}).get(parent, [])]
 
-    def tables(self, schema='public', pos=0):
-        return [table(escape(x), pos)
-            for x in self.metadata.get('tables', {}).get(schema, [])]
+    def tables(self, parent='public', pos=0):
+        return [
+            table(escape(x), pos)
+            for x in self.metadata.get('tables', {}).get(parent, [])]
 
-    def views(self, schema='public', pos=0):
-        return [view(escape(x), pos)
-            for x in self.metadata.get('views', {}).get(schema, [])]
+    def views(self, parent='public', pos=0):
+        return [
+            view(escape(x), pos)
+            for x in self.metadata.get('views', {}).get(parent, [])]
 
-    def functions(self, schema='public', pos=0):
-        return [function(escape(x[0] + '()'), pos)
-            for x in self.metadata.get('functions', {}).get(schema, [])]
+    def functions(self, parent='public', pos=0):
+        return [
+            function(escape(x[0] + '()'), pos)
+            for x in self.metadata.get('functions', {}).get(parent, [])]
 
     def schemas(self, pos=0):
         schemas = set(sch for schs in self.metadata.values() for sch in schs)
         return [schema(escape(s), pos=pos) for s in schemas]
 
-    def functions_and_keywords(self, schema='public', pos=0):
+    def functions_and_keywords(self, parent='public', pos=0):
         return (
-            self.functions(schema, pos) + self.builtin_functions(pos) +
+            self.functions(parent, pos) + self.builtin_functions(pos) +
             self.keywords(pos)
         )
 
     # Note that the filtering parameters here only apply to the columns
-    def columns_functions_and_keywords(self, parent, schema='public', typ='tables', pos=0):
+    def columns_functions_and_keywords(
+            self, tbl, parent='public', typ='tables', pos=0
+    ):
         return (
             self.functions_and_keywords(pos=pos) +
-            self.columns(parent, schema, typ, pos)
+            self.columns(tbl, parent, typ, pos)
         )
 
-    def from_clause_items(self, schema='public', pos=0):
+    def from_clause_items(self, parent='public', pos=0):
         return (
-            self.functions(schema, pos) + self.views(schema, pos) +
-            self.tables(schema, pos)
+            self.functions(parent, pos) + self.views(parent, pos) +
+            self.tables(parent, pos)
         )
 
-    def schemas_and_from_clause_items(self, schema='public', pos=0):
-        return self.from_clause_items(schema, pos) + self.schemas(pos)
+    def schemas_and_from_clause_items(self, parent='public', pos=0):
+        return self.from_clause_items(parent, pos) + self.schemas(pos)
 
-    def types(self, schema='public', pos=0):
-        return self.datatypes(schema, pos) + self.tables(schema, pos)
+    def types(self, parent='public', pos=0):
+        return self.datatypes(parent, pos) + self.tables(parent, pos)
 
     @property
     def completer(self):
         return self.get_completer()
 
     def get_completers(self, casing):
-        '''
-        Returns a function taking three bools `casing`, `filtr`, `alias` and
+        """
+        Returns a function taking three bools `casing`, `filtr`, `aliasing` and
         the list `qualify`, all defaulting to None.
         Returns a list of completers.
         These parameters specify the allowed values for the corresponding
         completer parameters, `None` meaning any, i.e. (None, None, None, None)
         results in all 24 possible completers, whereas e.g.
-        (True, False, True, ['never']) results in the one completer with casing,
-        without `search_path` filtering of objects, with table aliasing, and
-        without column qualification.
-        '''
-        def _cfg(_casing, filtr, alias, qualify):
-            cfg = {'settings':{}}
+        (True, False, True, ['never']) results in the one completer with
+        casing, without `search_path` filtering of objects, with table
+        aliasing, and without column qualification.
+        """
+        def _cfg(_casing, filtr, aliasing, qualify):
+            cfg = {'settings': {}}
             if _casing:
                 cfg['casing'] = casing
             cfg['settings']['search_path_filter'] = filtr
-            cfg['settings']['generate_aliases'] = alias
+            cfg['settings']['generate_aliases'] = aliasing
             cfg['settings']['qualify_columns'] = qualify
             return cfg
 
-        def _cfgs(casing, filtr, alias, qualify):
+        def _cfgs(casing, filtr, aliasing, qualify):
             casings = [True, False] if casing is None else [casing]
             filtrs = [True, False] if filtr is None else [filtr]
-            aliases = [True, False] if alias is None else [alias]
+            aliases = [True, False] if aliasing is None else [aliasing]
             qualifys = qualify or ['always', 'if_more_than_one_table', 'never']
             return [
                 _cfg(*p) for p in product(casings, filtrs, aliases, qualifys)
             ]
 
-        def completers(casing=None, filtr=None, alias=None, qualify=None):
+        def completers(casing=None, filtr=None, aliasing=None, qualify=None):
             get_comp = self.get_completer
             return [
-                get_comp(**c) for c in _cfgs(casing, filtr, alias, qualify)
+                get_comp(**c) for c in _cfgs(casing, filtr, aliasing, qualify)
             ]
 
         return completers
@@ -154,29 +176,32 @@ def get_completer(self, settings=None, casing=None):
 
         schemata, tables, tbl_cols, views, view_cols = [], [], [], [], []
 
-        for schema, tbls in metadata['tables'].items():
-            schemata.append(schema)
+        for sch, tbls in metadata['tables'].items():
+            schemata.append(sch)
 
-            for table, cols in tbls.items():
-                tables.append((schema, table))
+            for tbl, cols in tbls.items():
+                tables.append((sch, tbl))
                 # Let all columns be text columns
-                tbl_cols.extend([(schema, table, col, 'text') for col in cols])
+                tbl_cols.extend([(sch, tbl, col, 'text') for col in cols])
 
-        for schema, tbls in metadata.get('views', {}).items():
-            for view, cols in tbls.items():
-                views.append((schema, view))
+        for sch, tbls in metadata.get('views', {}).items():
+            for tbl, cols in tbls.items():
+                views.append((sch, tbl))
                 # Let all columns be text columns
-                view_cols.extend([(schema, view, col, 'text') for col in cols])
+                view_cols.extend([(sch, tbl, col, 'text') for col in cols])
 
-        functions = [FunctionMetadata(schema, *func_meta)
-                        for schema, funcs in metadata['functions'].items()
-                        for func_meta in funcs]
+        functions = [
+            FunctionMetadata(sch, *func_meta)
+            for sch, funcs in metadata['functions'].items()
+            for func_meta in funcs]
 
-        datatypes = [(schema, datatype)
-                        for schema, datatypes in metadata['datatypes'].items()
-                        for datatype in datatypes]
+        datatypes = [
+            (sch, typ)
+            for sch, datatypes in metadata['datatypes'].items()
+            for typ in datatypes]
 
-        foreignkeys = [ForeignKey(*fk) for fks in metadata['foreignkeys'].values()
+        foreignkeys = [
+            ForeignKey(*fk) for fks in metadata['foreignkeys'].values()
             for fk in fks]
 
         comp.extend_schemata(schemata)