Use WindowCommands to reduce some hazzle

FileManager shouldn't abuse the ApplicationCommand class but use the
WindowCommand which is designed to be used for window related commands.

By doing so some of the hazzle in the different commands used to
retrieve the active window and/or file can be omitted.

It helps to make the commands a bit more pythonic.

Note:

1. This commit is a suggestion and may some review before merging.
2. It may break compatibility with Sublime Text 2.

Author: deathaxe

FileManager.sublime-commands Default.sublime-commandsFileManager.sublime-commands renamed to Default.sublime-commands

@@ -14,7 +14,6 @@
     del sys.modules[module_name]
 prefix = None
 
-from .libs.sublimefunctions import *
 from .commands.copy import FmCopyCommand
 from .commands.create import FmCreaterCommand, FmCreateCommand
 from .commands.create_from_selection import FmCreateFileFromSelectionCommand
@@ -31,7 +30,7 @@
 
 
 def plugin_loaded():
-    settings = get_settings()
+    settings = sublime.load_settings("FileManager.sublime-settings")
     # this use to be a supported setting, but we dropped it. (see #27)
     if settings.get("auto_close_empty_groups") is not None:
         # we could remove the setting automatically, and install the
@@ -66,7 +65,9 @@ def on_load(self, view):
         if snippet:
             view.run_command("insert_snippet", {"contents": snippet})
             settings.erase("fm_insert_snippet_on_load")
-            if get_settings().get("save_after_creating"):
+            if sublime.load_settings("FileManager.sublime-settings").get(
+                "save_after_creating"
+            ):
                 view.run_command("save")
             if settings.get("fm_reveal_in_sidebar"):
                 view.window().run_command("reveal_in_side_bar")

FileManager.py

@@ -1,20 +1,17 @@
 # -*- encoding: utf-8 -*-
-from ..libs.sublimefunctions import *
-from .appcommand import AppCommand
+import os
 
+import sublime
 
-class FmCopyCommand(AppCommand):
-    def run(self, which, paths=None):
-        self.view = get_view()
-        self.window = get_window()
+from .fmcommand import FmWindowCommand
 
-        if paths is None:
-            paths = [self.view.file_name()]
 
+class FmCopyCommand(FmWindowCommand):
+    def run(self, which, paths=None):
         text = []
         folders = self.window.folders()
 
-        for path in paths:
+        for path in paths or [self.window.active_view().file_name()]:
             if which == "name":
                 text.append(os.path.basename(path))
             elif which == "absolute path":
@@ -30,4 +27,4 @@ def run(self, which, paths=None):
                         text[-1] = text[-1][1:]
                     break
 
-        copy("\n".join(bit.replace(os.path.sep, "/") for bit in text))
+        sublime.set_clipboard("\n".join(bit.replace(os.path.sep, "/") for bit in text))

commands/copy.py

@@ -1,54 +1,62 @@
 # -*- encoding: utf-8 -*-
+import os
+
+import sublime
+
 from ..libs.input_for_path import InputForPath
-from ..libs.sublimefunctions import *
-from .appcommand import AppCommand
+from ..libs.sublimefunctions import (
+    get_template,
+    refresh_sidebar,
+    transform_aliases,
+)
+from ..libs.pathhelper import user_friendly
+from .fmcommand import FmWindowCommand
 
 
-class FmCreaterCommand(AppCommand):
+class FmCreaterCommand(FmWindowCommand):
     """Create folder(s)/files that might be required and the
     final ones if it doesn't exists. Finaly, opens the file"""
 
     def run(self, abspath, input_path):
         input_path = user_friendly(input_path)
         if input_path[-1] == "/":
-            return makedirs(abspath, exist_ok=True)
+            return os.makedirs(abspath, exist_ok=True)
         if not os.path.isfile(abspath):
-            makedirs(os.path.dirname(abspath), exist_ok=True)
+            os.makedirs(os.path.dirname(abspath), exist_ok=True)
             with open(abspath, "w") as fp:
                 pass
             template = get_template(abspath)
         else:
             template = None
-        window = get_window()
-        view = window.open_file(abspath)
-        settings = view.settings()
+
+        settings = self.window.open_file(abspath).settings()
         if template:
             settings.set("fm_insert_snippet_on_load", template)
-        refresh_sidebar(settings, window)
-        if get_settings().get("reveal_in_sidebar"):
+
+        refresh_sidebar(settings, self.window)
+
+        if self.settings.get("reveal_in_sidebar"):
             settings.set("fm_reveal_in_sidebar", True)
-            sublime.set_timeout_async(
-                lambda: window.run_command("reveal_in_side_bar"), 500
+            sublime.set_timeout(
+                lambda: self.window.run_command("reveal_in_side_bar"), 500
             )
 
 
-class FmCreateCommand(AppCommand):
+class FmCreateCommand(FmWindowCommand):
     def run(
         self,
         paths=None,
         initial_text="",
         start_with_browser=False,
         no_browser_action=False,
     ):
-        self.settings = get_settings()
-        self.window = sublime.active_window()
+        view = self.window.active_view()
+
         self.index_folder_separator = self.settings.get("index_folder_" + "separator")
         self.default_index = self.settings.get("default_index")
 
         self.folders = self.window.folders()
 
-        self.view = get_view()
-
         self.know_where_to_create_from = paths is not None
 
         if paths is not None:
@@ -64,8 +72,8 @@ def run(
             # it is going to be interactive, so it'll be
             # understood from the input itself
             create_from = None
-        elif self.view.file_name() is not None:
-            create_from = os.path.dirname(self.view.file_name())
+        elif view.file_name() is not None:
+            create_from = os.path.dirname(view.file_name())
             self.know_where_to_create_from = True
         else:
             # from home
@@ -97,10 +105,12 @@ def on_change(self, input_path, path_to_create_choosed_from_browsing):
             splited_input = input_path.split(self.index_folder_separator, 1)
             if len(splited_input) == 1:
                 index = self.default_index
-            elif isdigit(splited_input[0]):
-                index = int(splited_input[0])
             else:
-                return None, input_path
+                try:
+                    index = int(splited_input[0])
+                except ValueError:
+                    return None, input_path
+
             return self.folders[index], splited_input[-1]
         return "~", input_path
 

commands/create.py

@@ -5,7 +5,7 @@
 import sublime
 import sublime_plugin
 
-from ..libs.sublimefunctions import *
+from ..libs.pathhelper import computer_friendly, user_friendly
 
 """ This command has been inspired at 90% by the open_url_context command
 AND the vintage open_file_under_selection. Thanks John!"""
@@ -139,7 +139,7 @@ def is_visible(self, event=None):
         if event is None:
             return False
         return (
-            get_settings().get("show_create_from_selection_command")
+            self.settings.get("show_create_from_selection_command")
             and self.view.file_name() is not None
             and self.get_path(event) is not None
         )

commands/create_from_selection.py

@@ -1,17 +1,18 @@
 # -*- encoding: utf-8 -*-
-from ..libs.sublimefunctions import *
+import os
+
+import sublime
+
+from ..libs.sublimefunctions import refresh_sidebar
 from ..libs.send2trash import send2trash
-from .appcommand import AppCommand
+from .fmcommand import FmWindowCommand
 
 
-class FmDeleteCommand(AppCommand):
-    def run(self, paths=None, *args, **kwargs):
-        self.settings = get_settings()
-        self.window = get_window()
-        self.view = get_view()
+class FmDeleteCommand(FmWindowCommand):
+    def run(self, paths=None):
+        self.paths = paths or [self.window.active_view().file_name()]
 
-        self.paths = paths or [self.view.file_name()]
-        if get_settings().get("ask_for_confirmation_on_delete"):
+        if self.settings.get("ask_for_confirmation_on_delete"):
             paths_to_display = [
                 [
                     "Confirm",
@@ -41,7 +42,8 @@ def delete(self, index):
                 for window in sublime.windows():
                     view = window.find_open_file(path)
                     while view is not None:
-                        close_view(view, dont_prompt_save=True)
+                        view.set_scratch(True)
+                        view.close()
                         view = window.find_open_file(path)
 
                 try:

commands/delete.py

@@ -1,38 +1,38 @@
 # -*- encoding: utf-8 -*-
+import os
 import shutil
+
+import sublime
+
 from ..libs.input_for_path import InputForPath
-from ..libs.sublimefunctions import *
+from ..libs.sublimefunctions import refresh_sidebar, yes_no_cancel_panel
+from ..libs.pathhelper import user_friendly
 from ..libs.send2trash import send2trash
-from .appcommand import AppCommand
+from .fmcommand import FmWindowCommand
 
 
-class FmDuplicateCommand(AppCommand):
+class FmDuplicateCommand(FmWindowCommand):
     def run(self, paths=None):
-        self.settings = get_settings()
-
-        self.window = get_window()
-
         if paths is None:
             self.origin = self.window.active_view().file_name()
         else:
             self.origin = paths[0]
 
         initial_path = user_friendly(self.origin)
 
-        args = {}
-        args["caption"] = "Duplicate to: "
-        args["initial_text"] = initial_path
-        args["on_done"] = self.duplicate
-        args["on_change"] = None
-        args["on_cancel"] = None
-        args["create_from"] = ""
-        args["with_files"] = False
-        args["pick_first"] = self.settings.get("pick_first")
-        args["case_sensitive"] = self.settings.get("case_sensitive")
-        args["log_in_status_bar"] = self.settings.get("log_in_status_bar")
-        args["log_template"] = "Duplicating at {0}"
-
-        self.input = InputForPath(**args)
+        self.input = InputForPath(
+            caption="Duplicate to: ",
+            initial_text=initial_path,
+            on_done=self.duplicate,
+            on_change=None,
+            on_cancel=None,
+            create_from="",
+            with_files=False,
+            pick_first=self.settings.get("pick_first"),
+            case_sensitive=self.settings.get("case_sensitive"),
+            log_in_status_bar=self.settings.get("log_in_status_bar"),
+            log_template="Duplicating at {0}",
+        )
 
         head = len(os.path.dirname(initial_path)) + 1
         filename = len(os.path.splitext(os.path.basename(initial_path))[0])

commands/duplicate.py

@@ -1,50 +1,38 @@
 # -*- encoding: utf-8 -*-
-from ..libs.sublimefunctions import *
-from .appcommand import AppCommand
+from .fmcommand import FmWindowCommand
 
 
-class FmEditToTheRightCommand(AppCommand):
+class FmEditToTheRightCommand(FmWindowCommand):
     def run(self, files=None):
-        v = get_view()
-        w = get_window()
-
-        if files is None:
-            files = [v.file_name()]
-
-        w.set_layout(
+        self.window.set_layout(
             {
                 "cols": [0.0, 0.5, 1.0],
                 "rows": [0.0, 1.0],
                 "cells": [[0, 0, 1, 1], [1, 0, 2, 1]],
             }
         )
-        for i, file in enumerate(files, 1):
-            w.set_view_index(w.open_file(file), 1, 0)
-        w.focus_group(1)
+        for file in files or [self.window.active_view().file_name()]:
+            self.window.set_view_index(self.window.open_file(file), 1, 0)
+
+        self.window.focus_group(1)
 
     def is_enabled(self, files=None):
-        return (files is None or len(files) >= 1) and get_window().active_group() != 1
+        return (files is None or len(files) >= 1) and self.window.active_group() != 1
 
 
-class FmEditToTheLeftCommand(AppCommand):
+class FmEditToTheLeftCommand(FmWindowCommand):
     def run(self, files=None):
-        v = get_view()
-        w = get_window()
-
-        if files is None:
-            files = [v.file_name()]
-
-        w.set_layout(
+        self.window.set_layout(
             {
                 "cols": [0.0, 0.5, 1.0],
                 "rows": [0.0, 1.0],
                 "cells": [[0, 0, 1, 1], [1, 0, 2, 1]],
             }
         )
-        for file in files:
-            w.set_view_index(w.open_file(file), 0, 0)
+        for file in files or [self.window.active_view().file_name()]:
+            self.window.set_view_index(self.window.open_file(file), 0, 0)
 
-        w.focus_group(0)
+        self.window.focus_group(0)
 
     def is_enabled(self, files=None):
-        return (files is None or len(files) >= 1) and get_window().active_group() != 0
+        return (files is None or len(files) >= 1) and self.window.active_group() != 1

commands/editto.py

@@ -1,18 +1,18 @@
 # -*- encoding: utf-8 -*-
-from ..libs.sublimefunctions import *
-from .appcommand import AppCommand
+import os
 
+from .fmcommand import FmWindowCommand
 
-class FmFindInFilesCommand(AppCommand):
+
+class FmFindInFilesCommand(FmWindowCommand):
     def run(self, paths=None):
-        if paths is None:
-            paths = [get_view().file_name()]
         valid_paths = set()
-        for i, path in enumerate(paths):
+        for path in paths or self.windows.active_view().file_name():
             if os.path.isfile(path):
                 valid_paths.add(os.path.dirname(path))
             else:
                 valid_paths.add(path)
-        get_window().run_command(
+
+        self.window.run_command(
             "show_panel", {"panel": "find_in_files", "where": ", ".join(valid_paths)}
         )