Bring better linting

nsiqcppstyle_checker.py

@@ -378,7 +378,7 @@ def t_CPPCOMMENT(t):
 
 
 def t_error(t):
-    console.Out.Verbose("Illegal character '%s'" % t.value[0], t.lexer.lineno)
+    console.Out.Verbose(f"Illegal character '{t.value[0]}'", t.lexer.lineno)
     t.lexer.skip(1)
 
 
@@ -406,7 +406,7 @@ def __init__(self, filename, data=None):
                 except UnicodeDecodeError as ex:
                     console.Out.Ci("[ERROR] UnicodeDecodeError in CppLexerNavigator: " + str(ex))
                     console.Out.Ci(
-                        "[ERROR] Exception occurred reading file '%s', convert from UTF16LE to UTF8" % (filename),
+                        f"[ERROR] Exception occurred reading file '{filename}', convert from UTF16LE to UTF8",
                     )
                     raise
         self.lines = self.data.splitlines()
@@ -917,9 +917,7 @@ def HasBody(self):
 
         if token_id3 is None and token_id2 is not None:
             return True
-        if token_id2 is not None and token_id2.lexpos < token_id3.lexpos:
-            return True
-        return False
+        return bool(token_id2 is not None and token_id2.lexpos < token_id3.lexpos)
 
 
 class Context:
@@ -941,9 +939,7 @@ def IsContextEnd(self, token):
         return token == self.endToken
 
     def InScope(self, token):
-        if token.lexpos >= self.startToken.lexpos and token.lexpos <= self.endToken.lexpos:
-            return True
-        return False
+        return bool(token.lexpos >= self.startToken.lexpos and token.lexpos <= self.endToken.lexpos)
 
 
 class ContextStack:

nsiqcppstyle_exe.py

@@ -259,7 +259,7 @@ def main():
             extLangMapCopy = copy.deepcopy(extLangMap)
             targetName = targetPath.name
             console.Out.Ci(console.Separator)
-            console.Out.Ci("=  Analyzing %s " % targetName)
+            console.Out.Ci(f"=  Analyzing {targetName} ")
 
             if filterPath != "":
                 filefilterPath = filterPath
@@ -281,7 +281,7 @@ def main():
             # Load Rule
 
             if len(filter.nsiqCppStyleRules) == 0:
-                ShowMessageAndExit("Error!. Rules must be set in %s" % filefilterPath, False)
+                ShowMessageAndExit(f"Error!. Rules must be set in {filefilterPath}", False)
                 continue
 
             ruleManager.LoadRules(filter.nsiqCppStyleRules)
@@ -293,7 +293,7 @@ def main():
 
             console.Out.Info(filter.to_string())
             console.Out.Ci(console.Separator)
-            console.Out.Verbose("* run nsiqcppstyle analysis on %s" % targetName)
+            console.Out.Verbose(f"* run nsiqcppstyle analysis on {targetName}")
 
             # if the target is file, analyze it without condition
             if targetPath.is_file():
@@ -363,7 +363,7 @@ def GetRealTargetPaths(args):
         targetPaths.append(realPath)
         #       CheckPathPermission(realPath, "Target directory")
         if not realPath.exists():
-            ShowMessageAndExit("Error!: Target directory %s does not exist" % eachTarget)
+            ShowMessageAndExit(f"Error!: Target directory {eachTarget} does not exist")
     return targetPaths
 
 
@@ -578,7 +578,7 @@ def AddVarMap(self, keyValuePairString, where):
 
 
 def GetCliKeyValueMap(kvList):
-    if kvList == None:
+    if kvList is None:
         return {}
 
     varMap = {}

nsiqcppstyle_lexer.py

@@ -186,11 +186,11 @@ def clone(self, object=None):
     # ------------------------------------------------------------
     def _writetab_impl(self, tabfile, tf):
         tf.write(f"# {tabfile}.py. This file automatically created by PLY (version {__version__}). Don't edit!\n")
-        tf.write("_tabversion   = %s\n" % repr(__version__))
-        tf.write("_lextokens    = %s\n" % repr(self.lextokens))
-        tf.write("_lexreflags   = %s\n" % repr(self.lexreflags))
-        tf.write("_lexliterals  = %s\n" % repr(self.lexliterals))
-        tf.write("_lexstateinfo = %s\n" % repr(self.lexstateinfo))
+        tf.write(f"_tabversion   = {__version__!r}\n")
+        tf.write(f"_lextokens    = {self.lextokens!r}\n")
+        tf.write(f"_lexreflags   = {self.lexreflags!r}\n")
+        tf.write(f"_lexliterals  = {self.lexliterals!r}\n")
+        tf.write(f"_lexstateinfo = {self.lexstateinfo!r}\n")
 
         tabre = {}
         # Collect all functions in the initial state
@@ -207,16 +207,16 @@ def _writetab_impl(self, tabfile, tf):
                 titem.append((self.lexstateretext[key][i], _funcs_to_names(lre[i][1], self.lexstaterenames[key][i])))
             tabre[key] = titem
 
-        tf.write("_lexstatere   = %s\n" % repr(tabre))
-        tf.write("_lexstateignore = %s\n" % repr(self.lexstateignore))
+        tf.write(f"_lexstatere   = {tabre!r}\n")
+        tf.write(f"_lexstateignore = {self.lexstateignore!r}\n")
 
         taberr = {}
         for key, ef in self.lexstateerrorf.items():
             if ef:
                 taberr[key] = ef.__name__
             else:
                 taberr[key] = None
-        tf.write("_lexstateerrorf = %s\n" % repr(taberr))
+        tf.write(f"_lexstateerrorf = {taberr!r}\n")
 
     # ------------------------------------------------------------
     # writetab() - Write lexer information to a table file
@@ -236,10 +236,10 @@ def readtab(self, tabfile, fdict):
         if isinstance(tabfile, types.ModuleType):
             lextab = tabfile
         elif sys.version_info[0] < 3:
-            exec("import %s as lextab" % tabfile)
+            exec(f"import {tabfile} as lextab")
         else:
             env = {}
-            exec("import %s as lextab" % tabfile, env, env)
+            exec(f"import {tabfile} as lextab", env, env)
             lextab = env["lextab"]
 
         if getattr(lextab, "_tabversion", "0.0") != __version__:
@@ -414,7 +414,8 @@ def token(self):
                     if lexpos == self.lexpos:
                         # Error method didn't change text position at all. This
                         # is an error.
-                        raise LexError("Scanning error. Illegal character '%s'" % (lexdata[lexpos]), lexdata[lexpos:])
+                        msg = f"Scanning error. Illegal character '{lexdata[lexpos]}'"
+                        raise LexError(msg, lexdata[lexpos:])
                     lexpos = self.lexpos
                     if not newtok:
                         continue
@@ -656,7 +657,7 @@ def validate_literals(self):
                     continue
 
         except TypeError:
-            self.log.error("Invalid literals specification. literals must be a sequence of characters")
+            self.log.exception("Invalid literals specification. literals must be a sequence of characters")
             self.error = 1
 
     def get_states(self):
@@ -680,7 +681,7 @@ def get_states(self):
                         self.log.error("State name %s must be a string", repr(name))
                         self.error = 1
                         continue
-                    if not (statetype == "inclusive" or statetype == "exclusive"):
+                    if statetype not in ("inclusive", "exclusive"):
                         self.log.error("State type for state %s must be 'inclusive' or 'exclusive'", name)
                         self.error = 1
                         continue
@@ -803,9 +804,9 @@ def validate_rules(self):
                         self.error = 1
                 except re.error:
                     _etype, e, _etrace = sys.exc_info()
-                    self.log.error("%s:%d: Invalid regular expression for rule '%s'. %s", file, line, f.__name__, e)
+                    self.log.exception("%s:%d: Invalid regular expression for rule '%s'. %s", file, line, f.__name__, e)
                     if "#" in f.__doc__:
-                        self.log.error(
+                        self.log.exception(
                             "%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'",
                             file,
                             line,
@@ -833,9 +834,9 @@ def validate_rules(self):
                         self.error = 1
                 except re.error:
                     _etype, e, _etrace = sys.exc_info()
-                    self.log.error("Invalid regular expression for rule '%s'. %s", name, e)
+                    self.log.exception("Invalid regular expression for rule '%s'. %s", name, e)
                     if "#" in r:
-                        self.log.error("Make sure '#' in rule '%s' is escaped with '\\#'", name)
+                        self.log.exception("Make sure '#' in rule '%s' is escaped with '\\#'", name)
                     self.error = 1
 
             if not self.funcsym[state] and not self.strsym[state]:
@@ -883,7 +884,7 @@ def validate_file(self, filename):
                 lines = f.readlines()
         except UnicodeDecodeError as ex:
             console.Out.Ci("[ERROR] UnicodeDecodeError in validate_file: " + str(ex))
-            console.Out.Ci("[ERROR] Exception occurred reading file '%s', convert from UTF16LE to UTF8" % (filename))
+            console.Out.Ci(f"[ERROR] Exception occurred reading file '{filename}', convert from UTF16LE to UTF8")
             raise
         except OSError:
             return  # Couldn't find the file.  Don't worry about it

nsiqcppstyle_reporter.py

@@ -75,7 +75,7 @@ def ReportSummaryToScreen(analyzedFiles, nsiqcppstyle_state, filter):
     console.Out.Ci(" ** Total Errors Occurs       : %d" % nsiqcppstyle_state.error_count)
     console.Out.Ci(" ** Total Analyzed Files      : %d" % len(analyzedFiles))
     console.Out.Ci(" ** Total Violated Files Count: %d" % violatedFileCount)
-    console.Out.Ci(" ** Build Quality             : %.2f%%" % buildQuality)
+    console.Out.Ci(f" ** Build Quality             : {buildQuality:.2f}%")
     if console.IsLevelDisplayed(console.Level.Info):
         console.Out.Info("\n================================ Violated Rule Details ===============================")
         for checker in nsiqcppstyle_state.errorPerChecker:
@@ -159,7 +159,7 @@ def EndTarget():
 
 def StartFile(dirname, filename):
     if _nsiqcppstyle_state.output_format == "xml":
-        writer.write("<file name='%s'>\n" % (os.path.join(target, dirname[1:], filename)))
+        writer.write(f"<file name='{os.path.join(target, dirname[1:], filename)}'>\n")
 
 
 def EndFile():

nsiqcppstyle_rulehelper.py

@@ -97,6 +97,4 @@ def IsConstructor(value, fullName, context):
 
 def IsOperator(value):
     """Check if the passed value is 'operator'"""
-    if value is not None and value == "operator":
-        return True
-    return False
+    return bool(value is not None and value == "operator")

nsiqcppstyle_rulemanager.py

@@ -85,7 +85,7 @@ def LoadRules(self, checkingRuleNames):
         for ruleName in checkingRuleNames:
             count = self.availRuleNames.count(ruleName)
             if count == 0:
-                console.Out.Error("%s does not exist or incompatible." % ruleName)
+                console.Out.Error(f"{ruleName} does not exist or incompatible.")
                 continue
             console.Out.Info("  - ", ruleName, "is applied.")
             ruleModule = __import__("rules." + ruleName)

pyproject.toml

@@ -168,6 +168,8 @@ ignore = [
   "PLR0912",
   "PLR0913",
   "PLR0915",
+  # Print is used heavily
+  "T201",
 ]
 unfixable = [
   # Don't touch unused imports

rules/RULE_10_1_A_do_not_use_bufferoverflow_risky_function_for_unix.py

@@ -66,12 +66,12 @@ def RunRule(lexer, contextStack):
                     unsafe_alternative = True
                 # elif unknown namespace => unknown safety
             if unsafe_alternative:
-                nsiqcppstyle_reporter.Error(t, __name__, "Do not use bufferoverflow risky function(%s)" % t.value)
+                nsiqcppstyle_reporter.Error(t, __name__, f"Do not use bufferoverflow risky function({t.value})")
             elif not safe_alternative:
                 nsiqcppstyle_reporter.Error(
                     t,
                     __name__,
-                    "Caution: Uknown imlementation of a bufferoverflow risky function(%s)" % t.value,
+                    f"Caution: Uknown imlementation of a bufferoverflow risky function({t.value})",
                 )
 
 

rules/RULE_10_1_B_do_not_use_bufferoverflow_risky_function_for_windows.py

@@ -92,7 +92,7 @@ def RunRule(lexer, contextStack):
         if t2 is not None and t2.type == "LPAREN":
             t3 = lexer.PeekPrevTokenSkipWhiteSpaceAndComment()
             if t3 is None or t3.type != "PERIOD":
-                nsiqcppstyle_reporter.Error(t, __name__, "Do not use burfferoverflow risky function(%s)" % t.value)
+                nsiqcppstyle_reporter.Error(t, __name__, f"Do not use buffer-overflow risky function({t.value})")
 
 
 ruleManager.AddFunctionScopeRule(RunRule)

rules/RULE_3_1_A_do_not_start_filename_with_underbar.py

@@ -22,7 +22,7 @@ def RunRule(lexer, filename, dirname):
         nsiqcppstyle_reporter.Error(
             nsiqcppstyle_reporter.DummyToken(lexer.filename, "", 0, 0),
             __name__,
-            "File name(%s) should not start with underbar." % filename,
+            f"File name({filename}) should not start with underbar.",
         )
 
 

rules/RULE_3_2_CD_do_not_use_special_characters_in_filename.py

@@ -24,7 +24,7 @@ def RunRule(lexer, filename, dirname):
         nsiqcppstyle_reporter.Error(
             DummyToken(lexer.filename, "", 0, 0),
             __name__,
-            "Do not use special characters in file name (%s)." % filename,
+            f"Do not use special characters in file name ({filename}).",
         )
 
 

rules/RULE_3_2_F_use_representitive_classname_for_cpp_filename.py

@@ -76,7 +76,7 @@ def RunFileEndRule(lexer, filename, dirname):
         nsiqcppstyle_reporter.Error(
             DummyToken(lexer.filename, "", 0, 0),
             __name__,
-            "The filename does not represent the classnames (%s)" % (classname),
+            f"The filename does not represent the classnames ({classname})",
         )
 
 

rules/RULE_3_2_H_do_not_use_underbars_for_cpp_filename.py

@@ -30,7 +30,7 @@ def RunRule(lexer, filename, dirname):
         nsiqcppstyle_reporter.Error(
             DummyToken(lexer.filename, "", 0, 0),
             __name__,
-            "Do not use underbar for cpp file name (%s)." % filename,
+            f"Do not use underbar for cpp file name ({filename}).",
         )
 
 

rules/RULE_3_2_H_do_not_use_uppercase_for_c_filename.py

@@ -24,7 +24,7 @@ def RunRule(lexer, filename, dirname):
         nsiqcppstyle_reporter.Error(
             DummyToken(lexer.filename, "", 0, 0),
             __name__,
-            "Do not use uppercase for c file name (%s)." % filename,
+            f"Do not use uppercase for c file name ({filename}).",
         )
 
 

rules/RULE_3_3_A_start_function_name_with_is_or_has_when_return_bool.py

@@ -40,7 +40,7 @@ def RunRule(lexer, fullName, decl, contextStack, context):
                 nsiqcppstyle_reporter.Error(
                     t,
                     __name__,
-                    "The function name(%s) should start with has or is when returinning bool" % fullName,
+                    f"The function name({fullName}) should start with has or is when returinning bool",
                 )
             break
         k += 1

rules/RULE_3_3_A_start_function_name_with_lowercase_unix.py

@@ -38,7 +38,7 @@ def RunRule(lexer, fullName, decl, contextStack, context):
             return
         if IsOperator(value):
             return
-        nsiqcppstyle_reporter.Error(t, __name__, "Do not start function name(%s) with uppercase" % fullName)
+        nsiqcppstyle_reporter.Error(t, __name__, f"Do not start function name({fullName}) with uppercase")
 
 
 ruleManager.AddFunctionNameRule(RunRule)

rules/RULE_3_3_A_start_function_name_with_upperrcase_windows.py

@@ -42,7 +42,7 @@ def RunRule(lexer, fullName, decl, contextStack, context):
     if value.startswith("~"):
         value = value[1:]
     if Search("^[a-z]", value) and not IsOperator(value) and t.value not in keywords:
-        nsiqcppstyle_reporter.Error(t, __name__, "Do not start function name(%s) with lowercase" % fullName)
+        nsiqcppstyle_reporter.Error(t, __name__, f"Do not start function name({fullName}) with lowercase")
 
 
 ruleManager.AddFunctionNameRule(RunRule)

rules/RULE_3_3_B_start_private_function_name_with_underbar.py

@@ -36,7 +36,7 @@ def RunRule(lexer, fullName, decl, contextStack, context):
     if IsOperator(value):
         return
     if upperBlock is not None and upperBlock.additional == "PRIVATE" and not value.startswith("_"):
-        nsiqcppstyle_reporter.Error(t, __name__, "Start private function name(%s) with underbar" % fullName)
+        nsiqcppstyle_reporter.Error(t, __name__, f"Start private function name({fullName}) with underbar")
 
 
 def RunTypeScopeRule(lexer, contextStack):

rules/RULE_4_1_B_indent_each_enum_item_in_enum_block.py

@@ -37,7 +37,7 @@ def RunRule(lexer, typeName, typeFullName, decl, contextStack, typeContext):
                 nsiqcppstyle_reporter.Error(
                     t,
                     __name__,
-                    "Enum block should be indented. But the token(%s) seems to be unindented" % t.value,
+                    f"Enum block should be indented. But the token({t.value}) seems to be unindented",
                 )
 
 

rules/RULE_4_1_B_locate_each_enum_item_in_seperate_line.py

@@ -40,7 +40,7 @@ def RunRule(lexer, typeName, typeFullName, decl, contextStack, typeContext):
                     nsiqcppstyle_reporter.Error(
                         nt2,
                         __name__,
-                        "Each enum item(%s) should be located in the different line" % nt2.value,
+                        f"Each enum item({nt2.value}) should be located in the different line",
                     )
 
 

rules/RULE_4_2_A_A_space_around_operator.py

@@ -79,15 +79,15 @@ def RunRule(lexer, contextStack):
             if t2.type not in ["SPACE", "LINEFEED", "PREPROCESSORNEXT"] or t3.type not in ["SPACE", "LINEFEED"]:
                 t3 = lexer.GetPrevTokenSkipWhiteSpaceAndComment()
                 if t3 is not None and t3.type != "OPERATOR" and not Match(r"^\w*#include", t.line):
-                    nsiqcppstyle_reporter.Error(t, __name__, "Provide spaces b/w operator '%s'" % t.value)
+                    nsiqcppstyle_reporter.Error(t, __name__, f"Provide spaces b/w operator '{t.value}'")
     elif t.type in nextoperator:
         t2 = lexer.PeekNextToken()
         if (
             t2 is not None
             and t2.type not in ["SPACE", "LINEFEED", "PREPROCESSORNEXT"]
             and not Match(r"^\w*#include", t.line)
         ):
-            nsiqcppstyle_reporter.Error(t, __name__, "Provide spaces after operator '%s'" % t.value)
+            nsiqcppstyle_reporter.Error(t, __name__, f"Provide spaces after operator '{t.value}'")
     elif t.type in unaryoperator:
         t2 = lexer.PeekPrevToken()
         t3 = lexer.PeekNextToken()
@@ -109,7 +109,7 @@ def RunRule(lexer, contextStack):
             ]
             and t3.type not in ["SEMI", "SPACE", "LINEFEED", "RBRACE", "RPAREN", "RBRACKET"]
         ):
-            nsiqcppstyle_reporter.Error(t, __name__, "Provide spaces before operator '%s'" % t.value)
+            nsiqcppstyle_reporter.Error(t, __name__, f"Provide spaces before operator '{t.value}'")
 
         if (
             t2 is not None
@@ -126,7 +126,7 @@ def RunRule(lexer, contextStack):
             ]
             and t3.type not in ["SEMI", "SPACE", "LINEFEED", "RBRACE", "RPAREN", "RBRACKET"]
         ):
-            nsiqcppstyle_reporter.Error(t, __name__, "Provide spaces after operator '%s'" % t.value)
+            nsiqcppstyle_reporter.Error(t, __name__, f"Provide spaces after operator '{t.value}'")
 
 
 ruleManager.AddRule(RunRule)