Pylint alerts corrections as part of an intervention experiment 401

plugins/command_completions/__init__.py

@@ -165,7 +165,7 @@ class SublimeTextCommandCompletionPythonListener(sublime_plugin.EventListener):
     @inhibit_word_completions
     def on_query_completions(self, view, prefix, locations):
         loc = locations[0]
-        python_arg_scope = ("source.python meta.function-call.arguments.python string.quoted")
+        python_arg_scope = "source.python meta.function-call.arguments.python string.quoted"
         if not view.score_selector(loc, python_arg_scope) or not is_plugin(view):
             return None
 

plugins/create_package.py

@@ -37,7 +37,9 @@ def _create_package(name):
         os.mkdir(path)
     except FileExistsError:
         logger.error("Path exists already: %r", path)
-    except Exception:
+    except FileNotFoundError:
+        logger.error("Parent path does not exist: %r", path)
+    except OSError:
         logger.exception("Unknown error while creating path %r", path)
     else:
         return path

plugins/file_conversion.py

@@ -14,8 +14,9 @@
 __all__ = ('PackagedevConvertCommand',)
 
 
+
 # build command
 class PackagedevConvertCommand(sublime_plugin.WindowCommand):
     """Convert a file (view's buffer) of type ``source_format`` to type
     ``target_format``.
 
@@ -47,7 +48,105 @@
                      kwargs={"target_format": "yaml", "default_flow_style": False})
             )
 
+    def _auto_detect_file_type(self, source_format, target_format, output):
+        """Available parameters:
+
+        source_format (str) = None
+            The source format. Any of "yaml", "plist" or "json".
+            If `None`, attempt to automatically detect the format by extension, used syntax
+            highlight or (with plist) the actual contents.
+
+        target_format (str) = None
+            The target format. Any of "yaml", "plist" or "json".
+            If `None`, attempt to find an option set in the file to parse.
+            If unable to find an option, ask the user directly with all available format options.
+        output (OutputPanel) = None
+        """
+
+        type_handling = None
+
+        # Auto-detect the file type if it's not specified
+        if not source_format:
+            output.write("Input type not specified, auto-detecting...")
+            for Loader in loaders.get.values():
+                if Loader.file_is_valid(self.view):
+                    source_format = Loader.ext
+                    output.print(' %s\n' % Loader.name)
+                    break
+
+            if not source_format:
+                type_handling =  output.print("\nUnable to detect file type.")
+            elif target_format == source_format:
+                type_handling = output.print("File already is %s." % Loader.name)
+
+        return type_handling
+
+    def _validate_run(self, source_format=None, target_format=None):
+        """Available parameters:
+
+        source_format (str) = None
+            The source format. Any of "yaml", "plist" or "json".
+            If `None`, attempt to automatically detect the format by extension, used syntax
+            highlight or (with plist) the actual contents.
+
+        target_format (str) = None
+            The target format. Any of "yaml", "plist" or "json".
+            If `None`, attempt to find an option set in the file to parse.
+            If unable to find an option, ask the user directly with all available format options.
+        """
+
+        result = False
+
+        # Check the environment (view, args, ...)
+        if self.view.is_dirty():
+            # Save the file so that source and target file on the drive don't differ
+            self.view.run_command("save")
+            if self.view.is_dirty():
+                result =  sublime.error_message("The file could not be saved correctly. "
+                                             "The build was aborted")
+        elif source_format and target_format == source_format:
+            result = True
+            self.status("Target and source file format are identical. (%s)" % target_format)
+
+        elif source_format and source_format not in loaders.get:
+            result = True
+            self.status("Loader for '%s' not supported/implemented." % source_format)
+
+        elif target_format and target_format not in dumpers.get:
+            result = True
+            self.status("Dumper for '%s' not supported/implemented." % target_format)
+
+        return result
+
+    def _revalidate_run(self, output, source_format=None, target_format=None,):
+        """Available parameters:
+
+        source_format (str) = None
+            The source format. Any of "yaml", "plist" or "json".
+            If `None`, attempt to automatically detect the format by extension, used syntax
+            highlight or (with plist) the actual contents.
+
+        target_format (str) = None
+            The target format. Any of "yaml", "plist" or "json".
+            If `None`, attempt to find an option set in the file to parse.
+            If unable to find an option, ask the user directly with all available format options.
+        output (OutputPanel) = None
+        """
+        result = None
+        # Validate the shit again, but this time print to output panel
+        if source_format is not None and target_format == source_format:
+            result = output.print("\nTarget and source file format are identical. (%s)"
+                                % target_format)
+
+        if target_format not in dumpers.get:
+            result = output.print("\nDumper for '%s' not supported/implemented."
+                                % target_format)
+
+        return result
+
+
+
     def run(self, source_format=None, target_format=None, ext=None,
             open_new_file=False, rearrange_yaml_syntax_def=False, _output=None, **kwargs):
         """Available parameters:
 
@@ -96,47 +195,24 @@
         """
         self.view = self.window.active_view()
 
-        # Check the environment (view, args, ...)
-        if self.view.is_dirty():
-            # Save the file so that source and target file on the drive don't differ
-            self.view.run_command("save")
-            if self.view.is_dirty():
-                return sublime.error_message("The file could not be saved correctly. "
-                                             "The build was aborted")
-
+        result = self._validate_run(self, source_format, target_format)
+        if result:
+            return result
+
         file_path = self.view.file_name()
         if not file_path:
             return self.status("File does not exist.", file_path)
         file_path = Path(file_path)
 
-        if source_format and target_format == source_format:
-            return self.status("Target and source file format are identical. (%s)" % target_format)
-
-        if source_format and source_format not in loaders.get:
-            return self.status("Loader for '%s' not supported/implemented." % source_format)
-
-        if target_format and target_format not in dumpers.get:
-            return self.status("Dumper for '%s' not supported/implemented." % target_format)
-
         # Now the actual "building" starts (collecting remaining parameters)
         with OutputPanel.create(self.window, "package_dev",
                                 read_only=True, force_writes=True) as output:
             output.show()
 
-            # Auto-detect the file type if it's not specified
-            if not source_format:
-                output.write("Input type not specified, auto-detecting...")
-                for Loader in loaders.get.values():
-                    if Loader.file_is_valid(self.view):
-                        source_format = Loader.ext
-                        output.print(' %s\n' % Loader.name)
-                        break
-
-                if not source_format:
-                    return output.print("\nUnable to detect file type.")
-                elif target_format == source_format:
-                    return output.print("File already is %s." % Loader.name)
-
+            type_handling = self._auto_detect_file_type(source_format, target_format, output)
+            if type_handling:
+                return type_handling
+
             # Load inline options
             Loader = loaders.get[source_format]
             opts = Loader.load_options(self.view)
@@ -191,14 +267,12 @@
                     return
 
                 target_format = opts['target_format']
-                # Validate the shit again, but this time print to output panel
-                if source_format is not None and target_format == source_format:
-                    return output.print("\nTarget and source file format are identical. (%s)"
-                                        % target_format)
-
-                if target_format not in dumpers.get:
-                    return output.print("\nDumper for '%s' not supported/implemented."
-                                        % target_format)
+                result = self._revalidate_run(self, 
+                                              output, 
+                                              source_format, 
+                                              target_format)
+                if result:
+                    return result
 
                 output.print(' %s\n' % dumpers.get[target_format].name)
 
@@ -214,16 +288,18 @@
                 output.print("Unexpected error occurred while parsing, "
                              "please see the console for details.")
                 raise
-            if not data:
-                return
 
             # Determine new file name
             new_file_path = file_path.with_suffix(get_new_ext(target_format))
             new_dir = new_file_path.parent
+            valid_path = True
             try:
                 os.makedirs(str(new_dir), exist_ok=True)
             except OSError:
                 output.print("Could not create folder '%s'" % new_dir)
+                valid_path = False
+
+            if not data or not valid_path:
                 return
 
             # Now dump to new file

plugins/new_resource_file/__init__.py

@@ -116,4 +116,4 @@ def _is_package_path(self, file_path):
             for fp in (real_file_path, file_path):
                 if fp.startswith(pp):
                     leaf = fp[len(pp):].strip(os.sep)
-                    return (os.sep not in leaf)
+                    return os.sep not in leaf

plugins/syntax_dev/completions.py

@@ -232,42 +232,47 @@
             return all(self.view.match_selector(point + offset, selector)
                        for point in locations)
 
+        result = None
+
         # None of our business
         if not match_selector("- comment - (source.regexp - keyword.other.variable)"):
-            return None
+            result = None
 
         # Scope name completions based on our scope_data database
-        if match_selector("meta.expect-scope, meta.scope", -1):
-            return self._complete_scope(prefix, locations)
+        elif match_selector("meta.expect-scope, meta.scope", -1):
+            result = self._complete_scope(prefix, locations)
 
         # Auto-completion for include values using the 'contexts' keys and for
-        if match_selector(
+        elif match_selector(
             "meta.expect-context-list-or-content | meta.context-list-or-content",
             -1,
         ):
-            return ((self._complete_keyword(prefix, locations) or [])
+            result = ((self._complete_keyword(prefix, locations) or [])
                     + self._complete_context(prefix, locations))
 
         # Auto-completion for include values using the 'contexts' keys
-        if match_selector(
+        elif match_selector(
             "meta.expect-context-list | meta.expect-context | meta.include | meta.context-list",
             -1,
         ):
-            return self._complete_context(prefix, locations) or None
+            result = self._complete_context(prefix, locations) or None
 
         # Auto-completion for branch points with 'fail' key
-        if match_selector(
+        elif match_selector(
             "meta.expect-branch-point-reference | meta.branch-point-reference",
             -1,
         ):
-            return self._complete_branch_point()
+            result = self._complete_branch_point()
 
         # Auto-completion for variables in match patterns using 'variables' keys
-        if match_selector("keyword.other.variable"):
-            return self._complete_variable()
+        elif match_selector("keyword.other.variable"):
+            result = self._complete_variable()
 
-        # Standard completions for unmatched regions
-        return self._complete_keyword(prefix, locations)
+        else:
+            # Standard completions for unmatched regions
+            result = self._complete_keyword(prefix, locations)
+
+        return result
 
     def _line_prefix(self, point):
         _, col = self.view.rowcol(point)