Project Manager for Sublime Text 3 . mirror of https://github.com/budRich/ProjectManager
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
528 lines
19 KiB
528 lines
19 KiB
import sublime
|
|
import sublime_plugin
|
|
import subprocess
|
|
import os
|
|
import codecs
|
|
import platform
|
|
import re
|
|
|
|
|
|
def plugin_loaded():
|
|
t = sublime.load_settings("Project Manager.sublime-settings")
|
|
s = sublime.load_settings("project_manager.sublime-settings")
|
|
keys = [
|
|
"projects_path",
|
|
"use_local_projects_dir",
|
|
"show_open_files",
|
|
"show_recent_projects_first"
|
|
]
|
|
d = {}
|
|
for k in keys:
|
|
if t.has(k) and not s.has(k):
|
|
d.update({k: t.get(k)})
|
|
for key, value in d.items():
|
|
s.set(key, value)
|
|
if d:
|
|
sublime.save_settings("project_manager.sublime-settings")
|
|
|
|
old_file = os.path.join(sublime.packages_path(), "User", "Project Manager.sublime-settings")
|
|
if os.path.exists(old_file):
|
|
os.unlink(old_file)
|
|
|
|
|
|
class JsonFile:
|
|
def __init__(self, fpath, encoding="utf-8"):
|
|
self.encoding = encoding
|
|
self.fpath = fpath
|
|
|
|
def load(self, default=[]):
|
|
self.fdir = os.path.dirname(self.fpath)
|
|
if not os.path.isdir(self.fdir):
|
|
os.makedirs(self.fdir)
|
|
if os.path.exists(self.fpath):
|
|
f = codecs.open(self.fpath, "r+", encoding=self.encoding)
|
|
content = f.read()
|
|
try:
|
|
data = sublime.decode_value(content)
|
|
except:
|
|
sublime.message_dialog("%s is bad!" % self.fpath)
|
|
raise
|
|
if not data:
|
|
data = default
|
|
f.close()
|
|
else:
|
|
f = codecs.open(self.fpath, "w+", encoding=self.encoding)
|
|
data = default
|
|
f.close()
|
|
return data
|
|
|
|
def save(self, data, indent=4):
|
|
self.fdir = os.path.dirname(self.fpath)
|
|
if not os.path.isdir(self.fdir):
|
|
os.makedirs(self.fdir)
|
|
f = codecs.open(self.fpath, "w+", encoding=self.encoding)
|
|
f.write(sublime.encode_value(data, True))
|
|
f.close()
|
|
|
|
def remove(self):
|
|
if os.path.exists(self.fpath):
|
|
os.remove(self.fpath)
|
|
|
|
|
|
def subl(args=[]):
|
|
# learnt from SideBarEnhancements
|
|
executable_path = sublime.executable_path()
|
|
if sublime.platform() == 'osx':
|
|
app_path = executable_path[:executable_path.rfind(".app/") + 5]
|
|
executable_path = app_path + "Contents/SharedSupport/bin/subl"
|
|
subprocess.Popen([executable_path] + args)
|
|
if sublime.platform() == "windows":
|
|
def fix_focus():
|
|
window = sublime.active_window()
|
|
view = window.active_view()
|
|
window.run_command('focus_neighboring_group')
|
|
window.focus_view(view)
|
|
sublime.set_timeout(fix_focus, 300)
|
|
|
|
|
|
def expand_folder(folder, project_file):
|
|
root = os.path.dirname(project_file)
|
|
if not os.path.isabs(folder):
|
|
folder = os.path.abspath(os.path.join(root, folder))
|
|
return folder
|
|
|
|
|
|
def get_node():
|
|
if sublime.platform() == "osx":
|
|
node = subprocess.check_output(["scutil", "--get", "ComputerName"]).decode().strip()
|
|
else:
|
|
node = platform.node().split(".")[0]
|
|
return node
|
|
|
|
|
|
def dont_close_windows_when_empty(func):
|
|
def f(*args, **kwargs):
|
|
preferences = sublime.load_settings("Preferences.sublime-settings")
|
|
close_windows_when_empty = preferences.get("close_windows_when_empty")
|
|
preferences.set("close_windows_when_empty", False)
|
|
func(*args, **kwargs)
|
|
if close_windows_when_empty:
|
|
preferences.set("close_windows_when_empty", close_windows_when_empty)
|
|
return f
|
|
|
|
|
|
class Manager:
|
|
def __init__(self, window):
|
|
self.window = window
|
|
settings_file = 'project_manager.sublime-settings'
|
|
self.settings = sublime.load_settings(settings_file)
|
|
default_projects_dir = os.path.join(sublime.packages_path(), "User", "Projects")
|
|
self.projects_path = self.settings.get(
|
|
"projects_path", [self.settings.get("projects_dir", default_projects_dir)])
|
|
|
|
self.projects_path = [
|
|
os.path.normpath(os.path.expanduser(d)) for d in self.projects_path]
|
|
|
|
node = get_node()
|
|
if self.settings.get("use_local_projects_dir", False):
|
|
self.projects_path = \
|
|
[d + " - " + node for d in self.projects_path] + self.projects_path
|
|
|
|
self.primary_dir = self.projects_path[0]
|
|
self.projects_info = self.get_all_projects_info()
|
|
|
|
def list_project_files(self, folder):
|
|
pfiles = []
|
|
library = os.path.join(folder, "library.json")
|
|
if os.path.exists(library):
|
|
j = JsonFile(library)
|
|
for f in j.load([]):
|
|
if os.path.exists(f) and f not in pfiles:
|
|
pfiles.append(os.path.normpath(f))
|
|
pfiles.sort()
|
|
j.save(pfiles)
|
|
for path, dirs, files in os.walk(folder, followlinks=True):
|
|
for f in files:
|
|
f = os.path.join(path, f)
|
|
if f.endswith(".sublime-project") and f not in pfiles:
|
|
pfiles.append(os.path.normpath(f))
|
|
# remove empty directories
|
|
for d in dirs:
|
|
d = os.path.join(path, d)
|
|
if len(os.listdir(d)) == 0:
|
|
os.rmdir(d)
|
|
return pfiles
|
|
|
|
def get_info_from_project_file(self, pfile):
|
|
pdir = self.which_project_dir(pfile)
|
|
if pdir:
|
|
pname = re.sub("\.sublime-project$", "", os.path.relpath(pfile, pdir))
|
|
else:
|
|
pname = re.sub("\.sublime-project$", "", os.path.basename(pfile))
|
|
pd = JsonFile(pfile).load()
|
|
if pd and "folders" in pd and pd["folders"]:
|
|
folder = pd["folders"][0].get("path", "")
|
|
else:
|
|
folder = ""
|
|
star = False
|
|
for w in sublime.windows():
|
|
if w.project_file_name() == pfile:
|
|
star = True
|
|
break
|
|
return {
|
|
pname: {
|
|
"folder": expand_folder(folder, pfile),
|
|
"file": pfile,
|
|
"star": star
|
|
}
|
|
}
|
|
|
|
def get_all_projects_info(self):
|
|
ret = {}
|
|
for pdir in self.projects_path:
|
|
pfiles = self.list_project_files(pdir)
|
|
for f in pfiles:
|
|
ret.update(self.get_info_from_project_file(f))
|
|
return ret
|
|
|
|
def which_project_dir(self, pfile):
|
|
for pdir in self.projects_path:
|
|
if (os.path.realpath(os.path.dirname(pfile))+os.path.sep).startswith(
|
|
os.path.realpath(pdir)+os.path.sep):
|
|
return pdir
|
|
return None
|
|
|
|
def display_projects(self):
|
|
plist = [[key, key + "*" if value["star"] else key, value["folder"], value["file"]]
|
|
for key, value in self.projects_info.items()]
|
|
plist = sorted(plist)
|
|
if self.settings.get("show_recent_projects_first", True):
|
|
j = JsonFile(os.path.join(self.primary_dir, "recent.json"))
|
|
recent = j.load([])
|
|
plist = sorted(plist, key=lambda p: recent.index(p[3]) if p[3] in recent else -1,
|
|
reverse=True)
|
|
|
|
count = 0
|
|
for i in range(len(plist)):
|
|
if plist[i][0] is not plist[i][1]:
|
|
plist.insert(count, plist.pop(i))
|
|
count = count + 1
|
|
return [item[0] for item in plist], [[item[1], item[2]] for item in plist]
|
|
|
|
def project_file_name(self, project):
|
|
return self.projects_info[project]["file"]
|
|
|
|
def project_workspace(self, project):
|
|
return re.sub("\.sublime-project$", ".sublime-workspace", self.project_file_name(project))
|
|
|
|
def update_recent(self, project):
|
|
j = JsonFile(os.path.join(self.primary_dir, "recent.json"))
|
|
recent = j.load([])
|
|
pname = self.project_file_name(project)
|
|
if pname not in recent:
|
|
recent.append(pname)
|
|
else:
|
|
recent.append(recent.pop(recent.index(pname)))
|
|
# only keep the most recent 50 records
|
|
if len(recent) > 50:
|
|
recent = recent[(50-len(recent)):len(recent)]
|
|
j.save(recent)
|
|
|
|
def clear_recent_projects(self):
|
|
def clear_callback():
|
|
ok = sublime.ok_cancel_dialog("Clear Recent Projects?")
|
|
if ok:
|
|
j = JsonFile(os.path.join(self.primary_dir, "recent.json"))
|
|
j.remove()
|
|
|
|
sublime.set_timeout(clear_callback, 100)
|
|
|
|
def get_project_data(self, project):
|
|
return JsonFile(self.project_file_name(project)).load()
|
|
|
|
def check_project(self, project):
|
|
wsfile = self.project_workspace(project)
|
|
j = JsonFile(wsfile)
|
|
if not os.path.exists(wsfile):
|
|
j.save({})
|
|
elif self.settings.has("show_open_files"):
|
|
show_open_files = self.settings.get("show_open_files", False)
|
|
data = j.load({})
|
|
data["show_open_files"] = show_open_files
|
|
df = data.get("distraction_free", {})
|
|
df["show_open_files"] = show_open_files
|
|
data["distraction_free"] = df
|
|
j.save(data)
|
|
|
|
@dont_close_windows_when_empty
|
|
def close_project_by_window(self, window):
|
|
window.run_command("close_workspace")
|
|
|
|
def close_project_by_name(self, project):
|
|
pfile = os.path.realpath(self.project_file_name(project))
|
|
for w in sublime.windows():
|
|
if w.project_file_name():
|
|
if os.path.realpath(w.project_file_name()) == pfile:
|
|
self.close_project_by_window(w)
|
|
if w.id() != sublime.active_window().id():
|
|
w.run_command("close_window")
|
|
return True
|
|
return False
|
|
|
|
def add_project(self):
|
|
@dont_close_windows_when_empty
|
|
def close_all_files():
|
|
self.window.run_command("close_all")
|
|
|
|
def add_callback(project):
|
|
pd = self.window.project_data()
|
|
f = os.path.join(self.primary_dir, "%s.sublime-project" % project)
|
|
if pd:
|
|
JsonFile(f).save(pd)
|
|
else:
|
|
JsonFile(f).save({})
|
|
JsonFile(re.sub("\.sublime-project$", ".sublime-workspace", f)).save({})
|
|
self.close_project_by_window(self.window)
|
|
self.window.run_command("close_project")
|
|
close_all_files()
|
|
|
|
# reload projects info
|
|
self.__init__(self.window)
|
|
self.switch_project(project)
|
|
|
|
def show_input_panel():
|
|
project = "New Project"
|
|
pd = self.window.project_data()
|
|
pf = self.window.project_file_name()
|
|
try:
|
|
path = pd["folders"][0]["path"]
|
|
if pf:
|
|
project = os.path.basename(expand_folder(path, pf))
|
|
else:
|
|
project = os.path.basename(path)
|
|
except:
|
|
pass
|
|
|
|
v = self.window.show_input_panel("Project name:", project, add_callback, None, None)
|
|
v.run_command("select_all")
|
|
|
|
sublime.set_timeout(show_input_panel, 100)
|
|
|
|
def import_sublime_project(self):
|
|
pfile = self.window.project_file_name()
|
|
if not pfile:
|
|
sublime.message_dialog("Project file not found!")
|
|
return
|
|
if self.which_project_dir(pfile):
|
|
sublime.message_dialog("This project was created by Project Manager!")
|
|
return
|
|
ok = sublime.ok_cancel_dialog("Import %s?" % os.path.basename(pfile))
|
|
if ok:
|
|
j = JsonFile(os.path.join(self.primary_dir, "library.json"))
|
|
data = j.load([])
|
|
if pfile not in data:
|
|
data.append(pfile)
|
|
j.save(data)
|
|
|
|
def append_project(self, project):
|
|
self.update_recent(project)
|
|
pd = self.get_project_data(project)
|
|
paths = [expand_folder(f.get("path"), self.project_file_name(project))
|
|
for f in pd.get("folders")]
|
|
subl(["-a"] + paths)
|
|
|
|
def switch_project(self, project):
|
|
self.update_recent(project)
|
|
self.check_project(project)
|
|
self.close_project_by_window(self.window)
|
|
self.close_project_by_name(project)
|
|
subl([self.project_file_name(project)])
|
|
|
|
def open_in_new_window(self, project):
|
|
self.update_recent(project)
|
|
self.check_project(project)
|
|
self.close_project_by_name(project)
|
|
subl(["-n", self.project_file_name(project)])
|
|
|
|
def _remove_project(self, project):
|
|
ok = sublime.ok_cancel_dialog("Remove \"%s\" from Project Manager?" % project)
|
|
if ok:
|
|
pfile = self.project_file_name(project)
|
|
if self.which_project_dir(pfile):
|
|
self.close_project_by_name(project)
|
|
os.unlink(self.project_file_name(project))
|
|
os.unlink(self.project_workspace(project))
|
|
else:
|
|
for pdir in self.projects_path:
|
|
j = JsonFile(os.path.join(pdir, "library.json"))
|
|
data = j.load([])
|
|
if pfile in data:
|
|
data.remove(pfile)
|
|
j.save(data)
|
|
sublime.status_message("Project \"%s\" is removed." % project)
|
|
|
|
def remove_project(self, project):
|
|
sublime.set_timeout(lambda: self._remove_project(project), 100)
|
|
|
|
def clean_dead_projects(self):
|
|
projects_to_remove = []
|
|
for pname, pi in self.projects_info.items():
|
|
folder = pi["folder"]
|
|
if not os.path.exists(folder):
|
|
projects_to_remove.append(pname)
|
|
|
|
def remove_projects_iteratively():
|
|
pname = projects_to_remove[0]
|
|
self._remove_project(pname)
|
|
projects_to_remove.remove(pname)
|
|
if len(projects_to_remove) > 0:
|
|
sublime.set_timeout(remove_projects_iteratively, 100)
|
|
|
|
if len(projects_to_remove) > 0:
|
|
sublime.set_timeout(remove_projects_iteratively, 100)
|
|
else:
|
|
sublime.message_dialog("No Dead Projects.")
|
|
|
|
def edit_project(self, project):
|
|
def on_open():
|
|
self.window.open_file(self.project_file_name(project))
|
|
sublime.set_timeout_async(on_open, 100)
|
|
|
|
def rename_project(self, project):
|
|
def rename_callback(new_project):
|
|
if project == new_project:
|
|
return
|
|
pfile = self.project_file_name(project)
|
|
wsfile = self.project_workspace(project)
|
|
pdir = self.which_project_dir(pfile)
|
|
if not pdir:
|
|
pdir = os.path.dirname(pfile)
|
|
new_pfile = os.path.join(pdir, "%s.sublime-project" % new_project)
|
|
new_wsfile = re.sub("\.sublime-project$", ".sublime-workspace", new_pfile)
|
|
|
|
reopen = self.close_project_by_name(project)
|
|
os.rename(pfile, new_pfile)
|
|
os.rename(wsfile, new_wsfile)
|
|
|
|
j = JsonFile(new_wsfile)
|
|
data = j.load({})
|
|
if "project" in data:
|
|
data["project"] = "%s.sublime-project" % os.path.basename(new_project)
|
|
j.save(data)
|
|
|
|
if not self.which_project_dir(pfile):
|
|
for pdir in self.projects_path:
|
|
library = os.path.join(pdir, "library.json")
|
|
if os.path.exists(library):
|
|
j = JsonFile(library)
|
|
data = j.load([])
|
|
if pfile in data:
|
|
data.remove(pfile)
|
|
data.append(new_pfile)
|
|
j.save(data)
|
|
|
|
if reopen:
|
|
# reload projects info
|
|
self.__init__(self.window)
|
|
self.open_in_new_window(new_project)
|
|
|
|
def show_input_panel():
|
|
v = self.window.show_input_panel("New project name:",
|
|
project, rename_callback, None, None)
|
|
v.run_command("select_all")
|
|
|
|
sublime.set_timeout(show_input_panel, 100)
|
|
|
|
|
|
def cancellable(func):
|
|
def _ret(self, action):
|
|
if action >= 0:
|
|
func(self, action)
|
|
elif action < 0 and self.caller == "manager":
|
|
sublime.set_timeout(self.run, 10)
|
|
return _ret
|
|
|
|
|
|
class ProjectManager(sublime_plugin.WindowCommand):
|
|
|
|
def show_quick_panel(self, items, on_done):
|
|
sublime.set_timeout(
|
|
lambda: self.window.show_quick_panel(items, on_done),
|
|
10)
|
|
|
|
def run(self, action=None, caller=None):
|
|
self.manager = Manager(self.window)
|
|
|
|
if action is None:
|
|
self.show_options()
|
|
elif action == "add_project":
|
|
self.manager.add_project()
|
|
elif action == "import_sublime_project":
|
|
self.manager.import_sublime_project()
|
|
elif action == "clear_recent_projects":
|
|
self.manager.clear_recent_projects()
|
|
elif action == "remove_dead_projects":
|
|
self.manager.clean_dead_projects()
|
|
else:
|
|
self.caller = caller
|
|
callback = eval("self.on_" + action)
|
|
self.projects, display = self.manager.display_projects()
|
|
if not self.projects:
|
|
sublime.message_dialog("Project list is empty.")
|
|
return
|
|
self.show_quick_panel(display, callback)
|
|
|
|
def show_options(self):
|
|
items = [
|
|
["Open Project", "Open project in the current window"],
|
|
["Open Project in New Window", "Open project in a new window"],
|
|
["Append Project", "Append project to current window"],
|
|
["Edit Project", "Edit project settings"],
|
|
['Rename Project', "Rename project"],
|
|
["Remove Project", "Remove from Project Manager"],
|
|
["Add New Project", "Add current folders to Project Manager"],
|
|
["Import Project", "Import current .sublime-project file"],
|
|
["Clear Recent Projects", "Clear Recent Projects"],
|
|
["Remove Dead Projects", "Remove Dead Projects"]
|
|
]
|
|
|
|
def callback(a):
|
|
if a < 0:
|
|
return
|
|
elif a <= 5:
|
|
actions = ["switch", "new", "append", "edit", "rename", "remove"]
|
|
self.run(action=actions[a], caller="manager")
|
|
elif a == 6:
|
|
self.run(action="add_project")
|
|
elif a == 7:
|
|
self.run(action="import_sublime_project")
|
|
elif a == 8:
|
|
self.run(action="clear_recent_projects")
|
|
elif a == 9:
|
|
self.run(action="remove_dead_projects")
|
|
|
|
self.show_quick_panel(items, callback)
|
|
|
|
@cancellable
|
|
def on_new(self, action):
|
|
self.manager.open_in_new_window(self.projects[action])
|
|
|
|
@cancellable
|
|
def on_switch(self, action):
|
|
self.manager.switch_project(self.projects[action])
|
|
|
|
@cancellable
|
|
def on_append(self, action):
|
|
self.manager.append_project(self.projects[action])
|
|
|
|
@cancellable
|
|
def on_remove(self, action):
|
|
self.manager.remove_project(self.projects[action])
|
|
|
|
@cancellable
|
|
def on_edit(self, action):
|
|
self.manager.edit_project(self.projects[action])
|
|
|
|
@cancellable
|
|
def on_rename(self, action):
|
|
self.manager.rename_project(self.projects[action])
|