Modify visibility of private methods to comply with PEP8

Author: cixtor

linter.py

@@ -12,61 +12,7 @@ class Golangcilint(NodeLinter):
     defaults = {"selector": "source.go"}
     axis_base = (1, 1)
 
-    def severity(self, issue):
-        """consider /dev/stderr as errors and /dev/stdout as warnings"""
-        return "error" if issue["FromLinter"] == "typecheck" else "warning"
-
-    def shortname(self, issue):
-        """find and return short filename"""
-        return os.path.basename(issue["Pos"]["Filename"])
-
-    def lintissue(self, issue):
-        return LintMatch(
-            match=issue,
-            message=issue["Text"],
-            error_type=self.severity(issue),
-            line=issue["Pos"]["Line"] - self.axis_base[0],
-            col=issue["Pos"]["Column"] - self.axis_base[1],
-            code=issue["FromLinter"]
-        )
-
-    def canonical(self, issue):
-        mark = issue["Text"].rfind("/")
-        package = issue["Text"][mark+1:-1]
-        # Go 1.4 introduces an annotation for package clauses in Go source that
-        # identify a canonical import path for the package. If an import is
-        # attempted using a path that is not canonical, the go command will
-        # refuse to compile the importing package.
-        #
-        # When the linter runs, it creates a temporary directory, for example,
-        # “.golangcilint-foobar”, then creates a symbolic link for all relevant
-        # files, and writes the content of the current buffer in the correct
-        # file. Unfortunately, canonical imports break this flow because the
-        # temporary directory differs from the expected location.
-        #
-        # The only way to deal with this for now is to detect the error, which
-        # may as well be a false positive, and then ignore all the warnings
-        # about missing packages in the current file. Hopefully, the user has
-        # “goimports” which will automatically resolve the dependencies for
-        # them. Also, if the false positives are not, the programmer will know
-        # about the missing packages during the compilation phase, so it’s not
-        # a bad idea to ignore these warnings for now.
-        #
-        # See: https://golang.org/doc/go1.4#canonicalimports
-        return {
-            "FromLinter": "typecheck",
-            "Text": "cannot lint package “{}” due to canonical import path".format(package),
-            "Replacement": issue["Replacement"],
-            "SourceLines": issue["SourceLines"],
-            "Level": "error",
-            "Pos": {
-                "Filename": self.filename,
-                "Offset": 0,
-                "Column": 0,
-                "Line": 1
-            }
-        }
-
+    """match regex against the command output"""
     def find_errors(self, output):
         current = os.path.basename(self.filename)
         exclude = False
@@ -101,8 +47,8 @@ def find_errors(self, output):
                 """detect broken canonical imports"""
                 if ("code in directory" in issue["Text"]
                     and "expects import" in issue["Text"]):
-                    issue = self.canonical(issue)
-                    yield self.lintissue(issue)
+                    issue = self._canonical(issue)
+                    yield self._lintissue(issue)
                     exclude = True
                     continue
 
@@ -113,7 +59,62 @@ def find_errors(self, output):
                     continue
 
                 """issues found in the current file are relevant"""
-                if self.shortname(issue) != current:
+                if self._shortname(issue) != current:
                     continue
 
-                yield self.lintissue(issue)
+                yield self._lintissue(issue)
+
+    def _shortname(self, issue):
+        """find and return short filename"""
+        return os.path.basename(issue["Pos"]["Filename"])
+
+    def _severity(self, issue):
+        """consider /dev/stderr as errors and /dev/stdout as warnings"""
+        return "error" if issue["FromLinter"] == "typecheck" else "warning"
+
+    def _canonical(self, issue):
+        mark = issue["Text"].rfind("/")
+        package = issue["Text"][mark+1:-1]
+        # Go 1.4 introduces an annotation for package clauses in Go source that
+        # identify a canonical import path for the package. If an import is
+        # attempted using a path that is not canonical, the go command will
+        # refuse to compile the importing package.
+        #
+        # When the linter runs, it creates a temporary directory, for example,
+        # “.golangcilint-foobar”, then creates a symbolic link for all relevant
+        # files, and writes the content of the current buffer in the correct
+        # file. Unfortunately, canonical imports break this flow because the
+        # temporary directory differs from the expected location.
+        #
+        # The only way to deal with this for now is to detect the error, which
+        # may as well be a false positive, and then ignore all the warnings
+        # about missing packages in the current file. Hopefully, the user has
+        # “goimports” which will automatically resolve the dependencies for
+        # them. Also, if the false positives are not, the programmer will know
+        # about the missing packages during the compilation phase, so it’s not
+        # a bad idea to ignore these warnings for now.
+        #
+        # See: https://golang.org/doc/go1.4#canonicalimports
+        return {
+            "FromLinter": "typecheck",
+            "Text": "cannot lint package “{}” due to canonical import path".format(package),
+            "Replacement": issue["Replacement"],
+            "SourceLines": issue["SourceLines"],
+            "Level": "error",
+            "Pos": {
+                "Filename": self.filename,
+                "Offset": 0,
+                "Column": 0,
+                "Line": 1
+            }
+        }
+
+    def _lintissue(self, issue):
+        return LintMatch(
+            match=issue,
+            message=issue["Text"],
+            error_type=self._severity(issue),
+            line=issue["Pos"]["Line"] - self.axis_base[0],
+            col=issue["Pos"]["Column"] - self.axis_base[1],
+            code=issue["FromLinter"]
+        )