fix more problems detected by pylint

Author: Scony

gdtoolkit/common/ast.py

@@ -5,6 +5,7 @@
 from .utils import find_name_token_among_children
 
 
+# pylint: disable=too-few-public-methods
 class Function:
     """Abstract representation of function"""
 
@@ -14,6 +15,7 @@ def __init__(self, func_def: Tree):
         self.name = name_token.value
 
 
+# pylint: disable=too-few-public-methods
 class Class:
     """Abstract representation of class.
     Since it contains sub-classes, it forms a tree"""
@@ -47,6 +49,7 @@ def _load_data_from_class_def(self, class_def: Tree) -> None:
         self._load_data_from_node_children(class_def)
 
 
+# pylint: disable=too-few-public-methods
 class AbstractSyntaxTree:
     """Post-processed version of parse tree - more convenient representation
     for further processing"""

gdtoolkit/formatter/__main__.py

@@ -85,8 +85,8 @@ def _check_files_formatting(
     failed_files = set()
     for file_path in files:
         try:
-            with open(file_path, "r") as fh:
-                code = fh.read()
+            with open(file_path, "r", encoding="utf-8") as handle:
+                code = handle.read()
                 success, actually_formatted, formatted_code = _format_code(
                     code, line_length, file_path, safety_checks
                 )
@@ -108,9 +108,9 @@ def _check_files_formatting(
                     formattable_files.add(file_path)
                 elif not success:
                     failed_files.add(file_path)
-        except OSError as e:
+        except OSError as exceptions:
             print(
-                "Cannot open file '{}': {}".format(file_path, e.strerror),
+                "Cannot open file '{}': {}".format(file_path, exceptions.strerror),
                 file=sys.stderr,
             )
             failed_files.add(file_path)
@@ -140,22 +140,22 @@ def _format_files(files: List[str], line_length: int, safety_checks: bool) -> No
     failed_files = set()
     for file_path in files:
         try:
-            with open(file_path, "r+") as fh:
-                code = fh.read()
+            with open(file_path, "r+", encoding="utf-8") as handle:
+                code = handle.read()
                 success, actually_formatted, formatted_code = _format_code(
                     code, line_length, file_path, safety_checks
                 )
                 if success and actually_formatted:
                     print("reformatted {}".format(file_path))
                     formatted_files.add(file_path)
-                    fh.seek(0)
-                    fh.truncate(0)
-                    fh.write(formatted_code)
+                    handle.seek(0)
+                    handle.truncate(0)
+                    handle.write(formatted_code)
                 elif not success:
                     failed_files.add(file_path)
-        except OSError as e:
+        except OSError as exceptions:
             print(
-                "Cannot open file '{}': {}".format(file_path, e.strerror),
+                "Cannot open file '{}': {}".format(file_path, exceptions.strerror),
                 file=sys.stderr,
             )
             failed_files.add(file_path)
@@ -198,19 +198,19 @@ def _format_code(
                     given_code_parse_tree=code_parse_tree,
                     given_code_comment_parse_tree=comment_parse_tree,
                 )
-    except lark.exceptions.UnexpectedToken as e:
+    except lark.exceptions.UnexpectedToken as exception:
         success = False
         print(
             f"{file_path}:\n",
-            lark_unexpected_token_to_str(e, code),
+            lark_unexpected_token_to_str(exception, code),
             sep="\n",
             file=sys.stderr,
         )
-    except lark.exceptions.UnexpectedInput as e:
+    except lark.exceptions.UnexpectedInput as exception:
         success = False
         print(
             f"{file_path}:\n",
-            lark_unexpected_input_to_str(e),
+            lark_unexpected_input_to_str(exception),
             sep="\n",
             file=sys.stderr,
         )

gdtoolkit/formatter/context.py

@@ -6,6 +6,7 @@
 
 # pylint: disable=too-many-arguments
 # pylint: disable=too-many-instance-attributes
+# pylint: disable=too-few-public-methods
 class Context:
     def __init__(
         self,

gdtoolkit/gd2py/__main__.py

@@ -30,5 +30,5 @@ def main():
         __doc__,
         version="gd2py {}".format(pkg_resources.get_distribution("gdtoolkit").version),
     )
-    with open(arguments["<path>"], "r") as fh:
-        print(convert_code(fh.read()))
+    with open(arguments["<path>"], "r", encoding="utf-8") as handle:
+        print(convert_code(handle.read()))

gdtoolkit/gdradon/__main__.py

@@ -43,8 +43,8 @@ def main():
 
 def _cc(file_path: str) -> None:
     try:
-        with open(file_path, "r") as fh:
-            python_code = convert_code(fh.read())
+        with open(file_path, "r", encoding="utf-8") as handle:
+            python_code = convert_code(handle.read())
             results = cc_visit(python_code)
             if not results:
                 return
@@ -67,13 +67,15 @@ def _cc(file_path: str) -> None:
                         RESET,
                     )
                 )
-    except OSError as e:
+    except OSError as exception:
         print(
-            "Cannot open file '{}': {}".format(file_path, e.strerror),
+            "Cannot open file '{}': {}".format(file_path, exception.strerror),
             file=sys.stderr,
         )
-    except Exception as e:  # pylint: disable=broad-except
+    except Exception as exception:  # pylint: disable=broad-except
         print(
-            "Cannot process file '{}' due to exception: {}".format(file_path, e),
+            "Cannot process file '{}' due to exception: {}".format(
+                file_path, exception
+            ),
             file=sys.stderr,
         )

gdtoolkit/linter/__main__.py

@@ -80,8 +80,8 @@ def main():
 def _dump_default_config() -> None:
     # TODO: error handling
     assert not os.path.isfile(CONFIG_FILE_NAME)
-    with open(CONFIG_FILE_NAME, "w") as fh:
-        fh.write(yaml.dump(DEFAULT_CONFIG.copy()))
+    with open(CONFIG_FILE_NAME, "w", encoding="utf-8") as handle:
+        handle.write(yaml.dump(DEFAULT_CONFIG.copy()))
     sys.exit(0)
 
 
@@ -105,8 +105,8 @@ def _load_config_file_or_default(config_file_path: Optional[str]) -> MappingProx
     # TODO: error handling
     if config_file_path is not None:
         logging.info("Config file found: '%s'", config_file_path)
-        with open(config_file_path, "r") as fh:
-            return yaml.load(fh.read(), Loader=yaml.Loader)
+        with open(config_file_path, "r", encoding="utf-8") as handle:
+            return yaml.load(handle.read(), Loader=yaml.Loader)
 
     logging.info("""No 'gdlintrc' nor '.gdlintrc' found. Using default config...""")
     return DEFAULT_CONFIG
@@ -129,31 +129,31 @@ def _update_config_with_missing_entries_inplace(config: dict) -> None:
 
 def _lint_file(file_path: str, config: MappingProxyType) -> int:
     try:
-        with open(file_path, "r") as fh:
-            content = fh.read()
+        with open(file_path, "r", encoding="utf-8") as handle:
+            content = handle.read()
             problems = lint_code(content, config)
             if len(problems) > 0:  # TODO: friendly frontend like in halint
                 for problem in problems:
                     print_problem(problem, file_path)
             return len(problems)
-    except OSError as e:
+    except OSError as exception:
         print(
-            "Cannot open file '{}': {}".format(file_path, e.strerror),
+            "Cannot open file '{}': {}".format(file_path, exception.strerror),
             file=sys.stderr,
         )
         return 1
-    except lark.exceptions.UnexpectedToken as e:
+    except lark.exceptions.UnexpectedToken as exception:
         print(
             f"{file_path}:\n",
-            lark_unexpected_token_to_str(e, content),
+            lark_unexpected_token_to_str(exception, content),
             sep="\n",
             file=sys.stderr,
         )
         return 1
-    except lark.exceptions.UnexpectedInput as e:
+    except lark.exceptions.UnexpectedInput as exception:
         print(
             f"{file_path}:\n",
-            lark_unexpected_input_to_str(e),
+            lark_unexpected_input_to_str(exception),
             sep="\n",
             file=sys.stderr,
         )

gdtoolkit/linter/format_checks.py

@@ -41,9 +41,9 @@ def lint(gdscript_code: str, config: MappingProxyType) -> List[Problem]:
 def _max_line_length_check(threshold, tab_characters, code: str) -> List[Problem]:
     problems = []
     lines = code.splitlines()
-    for line_number in range(len(lines)):
+    for line_number, line in enumerate(lines):
         assert tab_characters is not None
-        line = lines[line_number].replace("\t", " " * tab_characters)
+        line = line.replace("\t", " " * tab_characters)
         if len(line) > threshold:
             problems.append(
                 Problem(
@@ -78,8 +78,7 @@ def _max_file_lines_check(threshold, code: str) -> List[Problem]:
 def _trailing_ws_check(code: str) -> List[Problem]:
     problems = []
     lines = code.splitlines()
-    for line_number in range(len(lines)):
-        line = lines[line_number]
+    for line_number, line in enumerate(lines):
         if re.search(r"\s$", line) is not None:
             problems.append(
                 Problem(
@@ -95,8 +94,7 @@ def _trailing_ws_check(code: str) -> List[Problem]:
 def _mixed_tabs_and_spaces_check(code: str) -> List[Problem]:
     problems = []
     lines = code.splitlines()
-    for line_number in range(len(lines)):
-        line = lines[line_number]
+    for line_number, line in enumerate(lines):
         if re.search("^(\t+ +| +\t+)", line) is not None:
             problems.append(
                 Problem(

gdtoolkit/parser/__main__.py

@@ -50,12 +50,12 @@ def main():
 
 def _parse_file(file_path: str, arguments: Dict) -> bool:
     try:
-        with open(file_path, "r") as fh:
-            file_content = fh.read()
+        with open(file_path, "r", encoding="utf-8") as handle:
+            file_content = handle.read()
             return _parse_file_content(file_content, arguments, file_path)
-    except OSError as e:
+    except OSError as exception:
         print(
-            "Cannot open file '{}': {}".format(file_path, e.strerror),
+            "Cannot open file '{}': {}".format(file_path, exception.strerror),
             file=sys.stderr,
         )
     return False
@@ -65,18 +65,18 @@ def _parse_file_content(content: str, arguments: Dict, file_path: str = None) ->
     actual_file_path = "STDIN" if file_path is None else file_path
     try:
         tree = parser.parse(content)  # TODO: handle exceptions
-    except lark.exceptions.UnexpectedToken as e:
+    except lark.exceptions.UnexpectedToken as exception:
         print(
             f"{actual_file_path}:\n",
-            lark_unexpected_token_to_str(e, content),
+            lark_unexpected_token_to_str(exception, content),
             sep="\n",
             file=sys.stderr,
         )
         return False
-    except lark.exceptions.UnexpectedInput as e:
+    except lark.exceptions.UnexpectedInput as exception:
         print(
             f"{actual_file_path}:\n",
-            lark_unexpected_input_to_str(e),
+            lark_unexpected_input_to_str(exception),
             sep="\n",
             file=sys.stderr,
         )

gdtoolkit/parser/parser.py

@@ -21,7 +21,8 @@ class Indenter(indenter.Indenter):
 
 
 # TODO: when upgrading to Python 3.8, replace with functools.cached_property
-class cached_property:
+# pylint: disable=too-few-public-methods
+class CachedProperty:
     """A property that is only computed once per instance and then replaces
     itself with an ordinary attribute. Deleting the attribute resets the
     property.
@@ -53,6 +54,7 @@ def parse(self, code: str, gather_metadata: bool = False) -> Tree:
         If gather_metadata is True, parsing is slower but the returned Tree comes with
         line and column numbers for statements and rules.
         """
+        # pylint: disable=no-member
         return (
             self._parser_with_metadata.parse(code)
             if gather_metadata
@@ -61,6 +63,7 @@ def parse(self, code: str, gather_metadata: bool = False) -> Tree:
 
     def parse_comments(self, code: str) -> Tree:
         """Parses GDScript code and returns comments - both standalone, and inline."""
+        # pylint: disable=no-member
         return self._comment_parser.parse(code)
 
     def disable_grammar_caching(self) -> None:
@@ -94,15 +97,15 @@ def _get_parser(
 
         return a_parser
 
-    @cached_property
+    @CachedProperty
     def _parser(self) -> Lark:
         return self._get_parser("parser")
 
-    @cached_property
+    @CachedProperty
     def _parser_with_metadata(self) -> Lark:
         return self._get_parser("parser_with_metadata", add_metadata=True)
 
-    @cached_property
+    @CachedProperty
     def _comment_parser(self) -> Lark:
         return self._get_parser(
             "parser_comments", add_metadata=True, grammar_filename="comments.lark"

pylintrc

@@ -1,14 +1,8 @@
 [MESSAGES CONTROL]
 disable =
-    fixme,                      # TODO: check
-    global-statement,           # TODO: check
-    too-few-public-methods,     # TODO: check
+    fixme,
     missing-function-docstring, # too pedantic
-    unspecified-encoding,       # TODO: check
-    consider-using-with,        # TODO: check
     missing-module-docstring,   # too pedantic
     missing-class-docstring,    # too pedantic
-    consider-using-f-string,    # TODO: check
-    invalid-name,               # TODO: check
-    consider-using-enumerate,   # TODO: check
-    duplicate-code              # TODO: check
+    consider-using-f-string,    # TODO: fix only cases that make sense
+    duplicate-code              # TODO: check (fails on CI)