Use logger for debugging messages

Author: dave3d

comment_spell_check/comment_spell_check.py

@@ -27,6 +27,7 @@
 import argparse
 import re
 import unicodedata
+import logging
 from pathlib import Path
 from importlib.metadata import version, PackageNotFoundError
 
@@ -167,7 +168,7 @@ def spell_check_words(spell_checker: SpellChecker, words: list[str]):
 
 
 def find_misspellings(
-    spell: SpellChecker, line: str, verbose: bool = False
+    spell: SpellChecker, line: str, logger: logging.Logger
 ) -> list[str]:
     """Find misspellings in a line of text."""
 
@@ -177,23 +178,16 @@ def find_misspellings(
 
     for word in words:
         if not (word.lower() in spell or word in spell):
-            print(f"Misspelled word: {word}\n" if verbose else "", end="")
+            logger.info(f"Misspelled word: {word}")
             mistakes.append(word)
     return mistakes
 
 
-def remove_contractions(word: str, verbose: bool = False):
+def remove_contractions(word: str, logger: logging.Logger):
     """Remove contractions from the word."""
     for contraction in CONTRACTIONS:
         if word.endswith(contraction):
-            print(
-                (
-                    f"    Contraction: {word} -> {word[: -len(contraction)]}\n"
-                    if verbose
-                    else ""
-                ),
-                end="",
-            )
+            logger.info(f"Contraction: {word} -> {word[: -len(contraction)]}")
             return word[: -len(contraction)]
     return word
 
@@ -209,25 +203,25 @@ def remove_prefix(word: str, prefixes: list[str]):
 def spell_check_comment(
     spell: SpellChecker,
     c: comment_parser.common.Comment,
+    logger: logging.Logger,
     prefixes: list[str] = None,
-    output_lvl=2,
 ) -> list[str]:
     """Check comment and return list of identified issues if any."""
 
-    print(f"Line {c.line_number()}: {c}\n" if output_lvl > 1 else "", end="")
+    logger.info(f"Line {c.line_number()}: {c}")
 
     line = c.text()
     if "https://" in line or "http://" in line:
         line = url_remove.remove_urls(line)
-        print(f"    Removed URLs: {line}\n" if output_lvl > 1 else "", end="")
+        logger.debug(f"    Removed URLs: {line}")
 
-    bad_words = find_misspellings(spell, line, verbose=output_lvl > 1)
+    bad_words = find_misspellings(spell, line, logger)
 
     mistakes = []
     for error_word in bad_words:
-        print(f"    Error: {error_word}\n" if output_lvl > 1 else "", end="")
+        logger.debug(f"    Error: {error_word}")
 
-        error_word = remove_contractions(error_word, output_lvl > 1)
+        error_word = remove_contractions(error_word, logger)
 
         prefixes = prefixes or []
         error_word = remove_prefix(error_word, prefixes)
@@ -237,14 +231,9 @@ def spell_check_comment(
 
         # Try splitting camel case words and checking each sub-word
         sub_words = split_camel_case(error_word)
-        print(
-            (
-                f"    Trying splitting camel case word: {error_word}\n"
-                + f"    Sub-words: {sub_words}\n"
-                if output_lvl > 1
-                else ""
-            ),
-            end="",
+        logger.debug(
+            f"    Trying splitting camel case word: {error_word}\n"
+            + f"    Sub-words: {sub_words}\n"
         )
 
         if len(sub_words) > 1 and spell_check_words(spell, sub_words):
@@ -257,16 +246,18 @@ def spell_check_comment(
 
 
 def spell_check_file(
-    filename, spell_checker, mime_type="", output_lvl=1, prefixes=None
+    filename: str,
+    spell_checker: SpellChecker,
+    logger: logging.Logger,
+    mime_type: str = "",
+    prefixes=None,
 ):
     """Check spelling in ``filename``."""
 
     if len(mime_type) == 0:
         mime_type = get_mime_type(filename)
 
-    print(
-        f"spell_check_file: {filename}, {mime_type}\n" if output_lvl > 0 else "", end=""
-    )
+    logger.info(f"spell_check_file: {filename}, {mime_type}")
 
     # Returns a list of comment_parser.parsers.common.Comments
     if mime_type == "text/plain":
@@ -275,37 +266,32 @@ def spell_check_file(
         try:
             clist = comment_parser.extract_comments(filename, mime=mime_type)
         except TypeError:
-            print(f"Parser failed, skipping file {filename}")
+            logger.error(f"Parser failed, skipping file {filename}")
             return []
 
     bad_words = []
     line_count = 0
 
     for c in clist:
-        mistakes = spell_check_comment(
-            spell_checker, c, prefixes=prefixes, output_lvl=output_lvl
-        )
+        mistakes = spell_check_comment(spell_checker, c, logger, prefixes=prefixes)
         if len(mistakes) > 0:
-            if output_lvl > 0:
-                print(f"\nLine number {c.line_number()}")
-            if output_lvl > 0:
-                print(c.text())
+            logger.info(f"\nLine number {c.line_number()}")
+            logger.info(c.text())
             for m in mistakes:
-                print(f"    {m}" if output_lvl >= 0 else "")
+                logger.info(f"    {m}")
                 bad_words.append([m, filename, c.line_number()])
         line_count = line_count + 1
 
     bad_words = sorted(bad_words)
 
-    if output_lvl > 1:
-        print("\nResults")
-        for x in bad_words:
-            print(x)
+    logger.info("Results")
+    for x in bad_words:
+        logger.info(x)
 
     return bad_words, line_count
 
 
-def exclude_check(name, exclude_list):
+def exclude_check(name: str, exclude_list: list[str] = None):
     """Return True if ``name`` matches any of the regular expressions listed in
     ``exclude_list``."""
     if exclude_list is None:
@@ -317,7 +303,7 @@ def exclude_check(name, exclude_list):
     return False
 
 
-def skip_check(name, skip_list):
+def skip_check(name: str, skip_list: list[str] = None):
     """Return True if ``name`` matches any of the glob pattern listed in
     ``skip_list``."""
     if skip_list is None:
@@ -451,34 +437,15 @@ def parse_args():
     return args
 
 
-def add_dict(enchant_dict, filename, verbose=False):
-    """Update ``enchant_dict`` spell checking dictionary with the words listed
-    in ``filename`` (one word per line)."""
-    print(f"Additional dictionary: {filename}" if verbose else "", end="")
-
-    with open(filename, encoding="utf-8") as f:
-        lines = f.read().splitlines()
-
-    # You better not have more than 1 word in a line
-    for wrd in lines:
-        if not wrd.replace("'", "").isidentifier():
-            print(
-                "Warning: adding word with non-alphanumeric characters to dictionary:",
-                wrd,
-            )
-        if not enchant_dict.check(wrd):
-            enchant_dict.add(wrd)
-
-
-def build_dictionary_list(args):
+def build_dictionary_list(args, logger):
     """build a list of dictionaries to use for spell checking."""
     dict_list = []
     initial_dct = Path(__file__).parent / "additional_dictionary.txt"
 
     if initial_dct.exists():
         dict_list.append(initial_dct)
     else:
-        print("Warning: initial dictionary not found.", initial_dct)
+        logger.warning(f"Initial dictionary not found: {initial_dct}")
 
     if not isinstance(args.dict, list):
         return dict_list
@@ -491,24 +458,17 @@ def build_dictionary_list(args):
     return dict_list
 
 
-def add_bibtex_words(spell, bibtex_files, verbose=False):
+def add_bibtex_words(
+    spell: SpellChecker, bibtex_files: list = None, logger: logging.Logger = None
+):
     """Add words from bibtex files to the spell checker."""
-    for bibtex_file in bibtex_files:
-        print(f"Loading bibtex file: {bibtex_file}\n" if verbose else "", end="")
-        bibtex_loader.add_bibtex(spell, bibtex_file, verbose=verbose)
 
+    if list is None:
+        return
 
-def get_output_lvl(args):
-    """Set the amount of debugging messages to print."""
-    output_lvl = 1
-    if args.brief:
-        output_lvl = 0
-    else:
-        if args.verbose:
-            output_lvl = 2
-    if args.miss:
-        output_lvl = -1
-    return output_lvl
+    for bibtex_file in bibtex_files:
+        logger.info(f"Loading bibtex file: {bibtex_file}")
+        bibtex_loader.add_bibtex(spell, bibtex_file, logger)
 
 
 def output_results(args, bad_words):
@@ -539,18 +499,49 @@ def output_results(args, bad_words):
     print(f"\n{len(bad_words)} misspellings found")
 
 
+def setup_logger(name, args):
+    """Sets up a logger that outputs to the console."""
+
+    level = logging.INFO
+    if args.verbose:
+        level = logging.DEBUG
+    if args.miss:
+        level = logging.ERROR
+    if args.brief:
+        level = logging.WARNING
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    # Create a console handler
+    ch = logging.StreamHandler()
+    ch.setLevel(level)
+
+    # Create a formatter
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+    # Add formatter to ch
+    ch.setFormatter(formatter)
+
+    # Add ch to logger
+    logger.addHandler(ch)
+
+    return logger
+
+
 def main():
     """comment_spell_check main function."""
     args = parse_args()
+    logger = setup_logger("comment_spell_check", args)
 
-    output_lvl = get_output_lvl(args)
+    dict_list = build_dictionary_list(args, logger)
 
-    dict_list = build_dictionary_list(args)
-
-    spell = create_checker.create_checker(dict_list, output_lvl > 1)
+    spell = create_checker.create_checker(dict_list, logger)
 
     if args.bibtex:
-        add_bibtex_words(spell, args.bibtex, verbose=output_lvl > 1)
+        add_bibtex_words(spell, args.bibtex, logger)
 
     file_list = []
     if len(args.filenames):
@@ -564,23 +555,14 @@ def main():
 
     suffixes = [*set(args.suffix)]  # remove duplicates
 
-    print(
-        (
-            f"Prefixes: {prefixes}\nSuffixes: {suffixes}\n"
-            if any([args.brief, output_lvl >= 0])
-            else ""
-        ),
-        end="",
-    )
+    logger.info("Prefixes: %s\nSuffixes: %s", prefixes, suffixes)
 
-    file_count = 0
-    line_count = 0
+    counts = [0, 0]
 
     #
     # Spell check the files
     #
     for f in file_list:
-        print(f"\nChecking {f}\n" if not args.miss else "", end="")
 
         # If f is a directory, recursively check for files in it.
         if os.path.isdir(f):
@@ -589,54 +571,47 @@ def main():
             for s in suffixes:
                 dir_entries = dir_entries + glob.glob(f + "/**/*" + s, recursive=True)
 
-            print(dir_entries if output_lvl > 0 else "", end="")
+            logger.info(dir_entries)
 
             # spell check the files found in f
             for x in dir_entries:
                 if exclude_check(x, args.exclude) or skip_check(x, args.skip):
-                    print(f"\nExcluding {x}\n" if not args.miss else "", end="")
+                    logger.info("Excluding %s", x)
                     continue
 
-                print(f"\nChecking {x}\n" if not args.miss else "", end="")
+                logger.info("Checking %s", x)
                 result, lc = spell_check_file(
                     x,
                     spell,
+                    logger,
                     args.mime_type,
-                    output_lvl=output_lvl,
                     prefixes=prefixes,
                 )
                 bad_words = sorted(bad_words + result)
-                file_count = file_count + 1
-                line_count = line_count + lc
+                counts[0] = counts[0] + 1
+                counts[1] = counts[1] + lc
 
         else:
             # f is a file
             if exclude_check(f, args.exclude) or skip_check(f, args.skip):
-                print(f"\nExcluding {x}\n" if not args.miss else "", end="")
+                logger.info("Excluding %s", f)
                 continue
 
             # f is a file, so spell check it
             result, lc = spell_check_file(
                 f,
                 spell,
+                logger,
                 args.mime_type,
-                output_lvl=output_lvl,
                 prefixes=prefixes,
             )
             bad_words = sorted(bad_words + result)
-            file_count = file_count + 1
-            line_count = line_count + lc
+            counts[0] = counts[0] + 1
+            counts[1] = counts[1] + lc
 
     output_results(args, bad_words)
 
-    print(
-        (
-            f"{file_count} files checked, {line_count} lines checked\n"
-            if not args.miss
-            else ""
-        ),
-        end="",
-    )
+    logger.info("%s files checked, %s lines checked", counts[0], counts[1])
 
     sys.exit(len(bad_words))