refactor: add ruff linting & fix initial violations

Author: vergenzt

.github/workflows/ci.yml

@@ -25,6 +25,12 @@ jobs:
         with:
           args: 'format --check'
 
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: chartboost/ruff-action@v1
+
   tests:
     name: "Python ${{ matrix.python }} on ${{ matrix.os }}"
     runs-on: "${{ matrix.os }}-${{ matrix.os-version || 'latest' }}"

.pre-commit-config.yaml

@@ -4,3 +4,4 @@ repos:
   rev: v0.4.1
   hooks:
   - id: ruff-format
+  - id: ruff

cogapp/__init__.py

@@ -4,4 +4,4 @@
 Copyright 2004-2024, Ned Batchelder.
 """
 
-from .cogapp import Cog, CogUsageError, main
+from .cogapp import Cog as Cog, CogUsageError as CogUsageError, main as main

cogapp/cogapp.py

@@ -114,11 +114,11 @@ def __init__(self, options=None):
         self.lines = []
         self.options = options or CogOptions()
 
-    def parseMarker(self, l):
-        self.markers.append(l)
+    def parseMarker(self, line):
+        self.markers.append(line)
 
-    def parseLine(self, l):
-        self.lines.append(l.strip("\n"))
+    def parseLine(self, line):
+        self.lines.append(line.strip("\n"))
 
     def getCode(self):
         """Extract the executable Python code from the generator."""
@@ -127,8 +127,8 @@ def getCode(self):
         # then remove it from all the lines.
         prefIn = commonPrefix(self.markers + self.lines)
         if prefIn:
-            self.markers = [l.replace(prefIn, "", 1) for l in self.markers]
-            self.lines = [l.replace(prefIn, "", 1) for l in self.lines]
+            self.markers = [line.replace(prefIn, "", 1) for line in self.markers]
+            self.lines = [line.replace(prefIn, "", 1) for line in self.lines]
 
         return reindentBlock(self.lines, "")
 
@@ -160,7 +160,7 @@ def evaluate(self, cog, globals, fname):
             eval(code, globals)
         except CogError:
             raise
-        except:
+        except:  # noqa: E722 (we're just wrapping in CogUserException and rethrowing)
             typ, err, tb = sys.exc_info()
             frames = (tuple(fr) for fr in traceback.extract_tb(tb.tb_next))
             frames = find_cog_source(frames, prologue)
@@ -433,106 +433,106 @@ def processFile(self, fIn, fOut, fname=None, globals=None):
             globals.update(self.options.defines)
 
             # loop over generator chunks
-            l = fIn.readline()
-            while l:
+            line = fIn.readline()
+            while line:
                 # Find the next spec begin
-                while l and not self.isBeginSpecLine(l):
-                    if self.isEndSpecLine(l):
+                while line and not self.isBeginSpecLine(line):
+                    if self.isEndSpecLine(line):
                         raise CogError(
                             f"Unexpected {self.options.sEndSpec!r}",
                             file=sFileIn,
                             line=fIn.linenumber(),
                         )
-                    if self.isEndOutputLine(l):
+                    if self.isEndOutputLine(line):
                         raise CogError(
                             f"Unexpected {self.options.sEndOutput!r}",
                             file=sFileIn,
                             line=fIn.linenumber(),
                         )
-                    fOut.write(l)
-                    l = fIn.readline()
-                if not l:
+                    fOut.write(line)
+                    line = fIn.readline()
+                if not line:
                     break
                 if not self.options.bDeleteCode:
-                    fOut.write(l)
+                    fOut.write(line)
 
                 # l is the begin spec
                 gen = CogGenerator(options=self.options)
                 gen.setOutput(stdout=self.stdout)
-                gen.parseMarker(l)
+                gen.parseMarker(line)
                 firstLineNum = fIn.linenumber()
                 self.cogmodule.firstLineNum = firstLineNum
 
                 # If the spec begin is also a spec end, then process the single
                 # line of code inside.
-                if self.isEndSpecLine(l):
-                    beg = l.find(self.options.sBeginSpec)
-                    end = l.find(self.options.sEndSpec)
+                if self.isEndSpecLine(line):
+                    beg = line.find(self.options.sBeginSpec)
+                    end = line.find(self.options.sEndSpec)
                     if beg > end:
                         raise CogError(
                             "Cog code markers inverted", file=sFileIn, line=firstLineNum
                         )
                     else:
-                        sCode = l[beg + len(self.options.sBeginSpec) : end].strip()
+                        sCode = line[beg + len(self.options.sBeginSpec) : end].strip()
                         gen.parseLine(sCode)
                 else:
                     # Deal with an ordinary code block.
-                    l = fIn.readline()
+                    line = fIn.readline()
 
                     # Get all the lines in the spec
-                    while l and not self.isEndSpecLine(l):
-                        if self.isBeginSpecLine(l):
+                    while line and not self.isEndSpecLine(line):
+                        if self.isBeginSpecLine(line):
                             raise CogError(
                                 f"Unexpected {self.options.sBeginSpec!r}",
                                 file=sFileIn,
                                 line=fIn.linenumber(),
                             )
-                        if self.isEndOutputLine(l):
+                        if self.isEndOutputLine(line):
                             raise CogError(
                                 f"Unexpected {self.options.sEndOutput!r}",
                                 file=sFileIn,
                                 line=fIn.linenumber(),
                             )
                         if not self.options.bDeleteCode:
-                            fOut.write(l)
-                        gen.parseLine(l)
-                        l = fIn.readline()
-                    if not l:
+                            fOut.write(line)
+                        gen.parseLine(line)
+                        line = fIn.readline()
+                    if not line:
                         raise CogError(
                             "Cog block begun but never ended.",
                             file=sFileIn,
                             line=firstLineNum,
                         )
 
                     if not self.options.bDeleteCode:
-                        fOut.write(l)
-                    gen.parseMarker(l)
+                        fOut.write(line)
+                    gen.parseMarker(line)
 
-                l = fIn.readline()
+                line = fIn.readline()
 
                 # Eat all the lines in the output section.  While reading past
                 # them, compute the md5 hash of the old output.
                 previous = []
                 hasher = md5()
-                while l and not self.isEndOutputLine(l):
-                    if self.isBeginSpecLine(l):
+                while line and not self.isEndOutputLine(line):
+                    if self.isBeginSpecLine(line):
                         raise CogError(
                             f"Unexpected {self.options.sBeginSpec!r}",
                             file=sFileIn,
                             line=fIn.linenumber(),
                         )
-                    if self.isEndSpecLine(l):
+                    if self.isEndSpecLine(line):
                         raise CogError(
                             f"Unexpected {self.options.sEndSpec!r}",
                             file=sFileIn,
                             line=fIn.linenumber(),
                         )
-                    previous.append(l)
-                    hasher.update(l.encode("utf-8"))
-                    l = fIn.readline()
+                    previous.append(line)
+                    hasher.update(line.encode("utf-8"))
+                    line = fIn.readline()
                 curHash = hasher.hexdigest()
 
-                if not l and not self.options.bEofCanBeEnd:
+                if not line and not self.options.bEofCanBeEnd:
                     # We reached end of file before we found the end output line.
                     raise CogError(
                         f"Missing {self.options.sEndOutput!r} before end of file.",
@@ -557,7 +557,7 @@ def processFile(self, fIn, fOut, fname=None, globals=None):
                 bSawCog = True
 
                 # Write the ending output line
-                hashMatch = self.reEndOutput.search(l)
+                hashMatch = self.reEndOutput.search(line)
                 if self.options.bHashOutput:
                     if hashMatch:
                         oldHash = hashMatch["hash"]
@@ -568,20 +568,20 @@ def processFile(self, fIn, fOut, fname=None, globals=None):
                                 line=fIn.linenumber(),
                             )
                         # Create a new end line with the correct hash.
-                        endpieces = l.split(hashMatch.group(0), 1)
+                        endpieces = line.split(hashMatch.group(0), 1)
                     else:
                         # There was no old hash, but we want a new hash.
-                        endpieces = l.split(self.options.sEndOutput, 1)
-                    l = (self.sEndFormat % newHash).join(endpieces)
+                        endpieces = line.split(self.options.sEndOutput, 1)
+                    line = (self.sEndFormat % newHash).join(endpieces)
                 else:
                     # We don't want hashes output, so if there was one, get rid of
                     # it.
                     if hashMatch:
-                        l = l.replace(hashMatch["hashsect"], "", 1)
+                        line = line.replace(hashMatch["hashsect"], "", 1)
 
                 if not self.options.bDeleteCode:
-                    fOut.write(l)
-                l = fIn.readline()
+                    fOut.write(line)
+                line = fIn.readline()
 
             if not bSawCog and self.options.bWarnEmpty:
                 self.showWarning(f"no cog code found in {sFileIn}")
@@ -712,9 +712,9 @@ def processFileList(self, sFileList):
         flist = self.openInputFile(sFileList)
         lines = flist.readlines()
         flist.close()
-        for l in lines:
+        for line in lines:
             # Use shlex to parse the line like a shell.
-            lex = shlex.shlex(l, posix=True)
+            lex = shlex.shlex(line, posix=True)
             lex.whitespace_split = True
             lex.commenters = "#"
             # No escapes, so that backslash can be part of the path

cogapp/test_cogapp.py

@@ -709,7 +709,7 @@ def setUp(self):
         # the functions we're going to use.
         self.gen = CogGenerator()
         self.m = self.gen.parseMarker
-        self.l = self.gen.parseLine
+        self.parseLine = self.gen.parseLine
 
     def testEmpty(self):
         self.m("// [[[cog")
@@ -718,50 +718,50 @@ def testEmpty(self):
 
     def testSimple(self):
         self.m("// [[[cog")
-        self.l('  print "hello"')
-        self.l('  print "bye"')
+        self.parseLine('  print "hello"')
+        self.parseLine('  print "bye"')
         self.m("// ]]]")
         self.assertEqual(self.gen.getCode(), 'print "hello"\nprint "bye"')
 
     def testCompressed1(self):
         # For a while, I supported compressed code blocks, but no longer.
         self.m('// [[[cog: print """')
-        self.l("// hello")
-        self.l("// bye")
+        self.parseLine("// hello")
+        self.parseLine("// bye")
         self.m('// """)]]]')
         self.assertEqual(self.gen.getCode(), "hello\nbye")
 
     def testCompressed2(self):
         # For a while, I supported compressed code blocks, but no longer.
         self.m('// [[[cog: print """')
-        self.l("hello")
-        self.l("bye")
+        self.parseLine("hello")
+        self.parseLine("bye")
         self.m('// """)]]]')
         self.assertEqual(self.gen.getCode(), "hello\nbye")
 
     def testCompressed3(self):
         # For a while, I supported compressed code blocks, but no longer.
         self.m("// [[[cog")
-        self.l('print """hello')
-        self.l("bye")
+        self.parseLine('print """hello')
+        self.parseLine("bye")
         self.m('// """)]]]')
         self.assertEqual(self.gen.getCode(), 'print """hello\nbye')
 
     def testCompressed4(self):
         # For a while, I supported compressed code blocks, but no longer.
         self.m('// [[[cog: print """')
-        self.l("hello")
-        self.l('bye""")')
+        self.parseLine("hello")
+        self.parseLine('bye""")')
         self.m("// ]]]")
         self.assertEqual(self.gen.getCode(), 'hello\nbye""")')
 
     def testNoCommonPrefixForMarkers(self):
         # It's important to be able to use #if 0 to hide lines from a
         # C++ compiler.
         self.m("#if 0 //[[[cog")
-        self.l("\timport cog, sys")
-        self.l("")
-        self.l("\tprint sys.argv")
+        self.parseLine("\timport cog, sys")
+        self.parseLine("")
+        self.parseLine("\tprint sys.argv")
         self.m("#endif //]]]")
         self.assertEqual(self.gen.getCode(), "import cog, sys\n\nprint sys.argv")
 

cogapp/test_makefiles.py

@@ -26,7 +26,7 @@ def exists(self, dname, fname):
     def checkFilesExist(self, d, dname):
         for fname in d.keys():
             assert self.exists(dname, fname)
-            if type(d[fname]) == type({}):
+            if isinstance(d[fname], dict):
                 self.checkFilesExist(d[fname], os.path.join(dname, fname))
 
     def checkFilesDontExist(self, d, dname):

cogapp/utils.py

@@ -44,10 +44,10 @@ def __init__(self, f):
         self.n = 0
 
     def readline(self):
-        l = self.f.readline()
-        if l:
+        line = self.f.readline()
+        if line:
             self.n += 1
-        return l
+        return line
 
     def linenumber(self):
         return self.n

cogapp/whiteutils.py

@@ -43,12 +43,12 @@ def reindentBlock(lines, newIndent=""):
         lines = lines.split(sep)
     oldIndent = whitePrefix(lines)
     outLines = []
-    for l in lines:
+    for line in lines:
         if oldIndent:
-            l = l.replace(oldIndent, nothing, 1)
-        if l and newIndent:
-            l = newIndent + l
-        outLines.append(l)
+            line = line.replace(oldIndent, nothing, 1)
+        if line and newIndent:
+            line = newIndent + line
+        outLines.append(line)
     return sep.join(outLines)