"""Example Google style docstrings."""
import json
import os
import shlex
import subprocess
from subprocess import PIPE, Popen
import sublime
import sublime_plugin
from . import auralint
from . import semver
IS_WINDOWS = os.name == 'nt'
PROJECT_DIRECTORY = os.getcwd()
def plugin_loaded():
"""Make me put in a doc string."""
print("WE ARE TOTALLY LOADED!")
try:
p = popen_force_cli(["version"])
version, err = p.communicate()
if err:
sublime.error_message(err.decode("utf-8"))
else:
ver = version.decode("utf-8").replace("\n", "")
if ver != "dev":
ver = ver[1:]
if semver.match(ver, "<0.22.26"):
message = (u"Sublime Lightning\n\n" +
u"You are using version " + ver + " of the " +
u"Force CLI.\n\nThis version of Sublime Lightning" +
u" requires version 0.22.26 or greater.\n\n" +
u"Please download the latest version from " +
u"force-cli.herokuapp.com")
sublime.error_message(message)
except:
sublime.error_message("Sublime Lightning requires the " +
"Force.com CLI to function.\n\n" +
"Please visit force-cli.herokuapp.com to " +
"install the Force.com CLI.\n\n" +
"If you’ve already installed it, make sure " +
"that you saved it or created a " +
"symlink to it in Sublime’s default path.")
return
def log(msg, level=None):
"""Log to ST python console.
If log level 'debug' (or None) print only if debug setting is enabled.
"""
if level is None:
level = 'debug'
print("[Flake8Lint {0}] {1}".format(level.upper(), msg))
def quote(subprocess_arg):
return shlex.quote(subprocess_arg) if IS_WINDOWS else subprocess_arg
def popen_force_cli(quoted_args):
args = ['force']
args.extend(quoted_args)
return subprocess.Popen(args,
stdout=subprocess.PIPE,
stderr=open(os.devnull, 'w'),
shell=IS_WINDOWS)
class Helper(sublime_plugin.WindowCommand):
"""Sample doc string."""
def foo(self):
"""Sample doc string."""
return
def install_cli(self):
"""Sample doc string."""
return
def get_xml_snippet(self, md_type):
return '<?xml version="1.0" encoding="UTF-8"?>\n' \
+ '<' + md_type \
+ ' xmlns="http://soap.sforce.com/2006/04/metadata">\n' \
+ '<apiVersion>38.0</apiVersion>\n' \
+ '<status>Active</status>\n' \
+ '</' + md_type + '>'
def get_page_xml_snippet(self, page_name):
return '<?xml version="1.0" encoding="UTF-8"?>\n' \
+ '<ApexPage xmlns="http://soap.sforce.com/2006/04/metadata">\n' \
+ '\t<apiVersion>36.0</apiVersion>\n' \
+ '\t<availableInTouch>false</availableInTouch>\n' \
+ '\t<confirmationTokenRequired>false' \
+ '</confirmationTokenRequired>\n' \
+ '\t<label>' + page_name + '</label>\n' \
+ '</ApexPage>'
def get_immediate_subdirectories(self, dir):
return [name for name in os.listdir(dir)
if os.path.isdir(os.path.join(dir, name))]
def bundle_op_is_visible(self, dirs):
"""Sample doc string."""
cdpath = Helper(self.window).get_md_child_name(dirs[0])
ismetadata = os.path.basename(dirs[0]) in ["metadata", "src"]
isclasses = os.path.basename(dirs[0]) == "classes"
if cdpath == "":
cdpath = Helper(self.window).find_upstram_md(dirs[0])
if (cdpath != "") or ismetadata or isclasses:
return True
def file_op_is_visible(self, dirs):
"""Sample doc string."""
return self.parent_dir_is_aura(dirs[0])
def dir_is_aura(self, working_dir):
"""Sample doc string."""
return os.path.basename(working_dir) == "aura"
def parent_dir_is_aura(self, working_dir):
"""Sample doc string."""
return os.path.basename(os.path.dirname(working_dir)) == "aura"
def get_md_child_name(self, dir):
for dirname in self.get_immediate_subdirectories(dir):
if dirname in ["metadata", "src"]:
return os.path.join(dir, dirname)
return ""
def get_md_dir(self, dir):
working_dir = self.get_md_child_name(dir)
if working_dir == "":
working_dir = Helper.find_upstram_md(self, dir)
if working_dir == "not found":
if sublime.ok_cancel_dialog(
"Could not locate a src or metadata directory. "
"Create a metadata directory at " + dir + "?",
"Create Metadata"):
working_dir = os.path.join(dir, "metadata")
os.mkdir(working_dir)
return working_dir
def is_metadata(self, working_dir):
"""Sample doc string."""
wd = os.path.dirname(working_dir)
print("Working dir: " + working_dir)
print("wd: " + wd)
return os.path.basename(wd) in ["metadata", "src"]
def is_static_resource(self, file):
"""Sample doc string."""
for root, dirs, files in Helper.walk_up(self, file):
if "staticresources" in dirs:
return True
return False
def get_resource_name(self, file):
"""Sample doc string."""
for root, dirs, files in Helper.walk_up(self, os.path.dirname(file)):
if os.path.basename(os.path.dirname(root)) == "staticresources":
return os.path.basename(root)
def is_bundle_type(self, working_dir, comp_type):
"""Sample doc string."""
files = os.listdir(working_dir[0])
for filename in files:
fname, fext = os.path.splitext(filename)
if (fext == "." + comp_type):
return True
return False
def has_this_file(self, working_dir, filename):
"""Sample doc string."""
return os.path.exists(os.path.join(working_dir, filename))
def do_login(self, username, password, instance):
"""Sample doc string."""
if username == "interactive":
self.window.run_command(
'exec',
{'cmd': ["force", "login"]})
else:
if instance == "":
self.window.run_command(
'exec',
{'cmd': ["force",
"login",
"-u",
username, "-p", password]})
else:
self.window.run_command(
'exec',
{'cmd': ["force", "login", "-u", username, "-p", password,
"-i", instance]})
return
def do_aura_query(self):
"""Sample doc string."""
return
def do_fetch(self, bundle, adir):
"""Sample doc string."""
os.chdir(adir)
if (bundle == 'all'):
self.window.run_command(
'exec',
{'cmd': ["force", "fetch", "-t", "aura", "-d", adir],
'working_dir': adir})
else:
self.window.run_command(
'exec',
{'cmd': ["force", "fetch", "-t", "aura", "-n", bundle, "-d",
adir], 'working_dir': adir})
return
def get_instance_url(self):
"""Sample doc string."""
p = popen_force_cli(['active', '-j'])
out = p.communicate()[0]
data = json.loads(out.decode("utf-8"))
return data["instanceUrl"]
def get_namespace(self):
"""Sample doc string."""
p = popen_force_cli(['active', '-j'])
out = p.communicate()[0]
data = json.loads(out.decode("utf-8"))
return data["namespace"]
def get_app_name(self, adir):
"""Sample doc string."""
os.chdir(adir)
return os.path.basename(adir)
def open_selected_bundle(self, index):
"""Sample doc string."""
if (index == -1):
return
if (index == 0):
self.do_fetch("all", self.activedir)
else:
self.do_fetch(self.messages[index][2], self.activedir)
return
def open_selected_metadata(self, index):
"""Sample doc string."""
if (index == -1):
return
self.show_metadata_instance_list(self.messages[index][0],
self.activedir)
return
def fetch_selected_metadata(self, index):
"""Sample doc string."""
if index == -1:
return
item = self.messages[index][0]
print("Type: " + self.type)
print("Item: " + item)
self.window.run_command(
'exec',
{'cmd': ["force", "fetch", "-t", self.type, "-n", item, "-unpack"],
'working_dir': self.activedir})
return
def meets_forcecli_version(self, minversion):
"""Sample doc string."""
version = Helper.get_forcecli_version(self)
# version = version[1:]
print("Version: " + version + ", min: " + minversion)
if version == "dev":
return version == "dev"
return semver.match(version, ">=" + minversion)
def lint_error_to_message(self, linterror):
"""Sample doc string."""
return
def get_forcecli_version(self):
"""Sample doc string."""
try:
p = popen_force_cli(["version"])
version, err = p.communicate()
if err:
sublime.error_message(err.decode("utf-8"))
else:
ver = version.decode("utf-8").replace("\n", "")
if ver != "dev":
ver = ver[1:]
if semver.match(ver, "<0.22.26"):
message = (u"Sublime Lightning\n\n" +
u"You are using version " + ver + " of the " +
u"Force CLI.\n\nThis version of Sublime " +
u"Lightning" +
u" requires version 0.22.26 or greater.\n\n" +
u"Please download the latest version from " +
u"force-cli.herokuapp.com")
sublime.error_message(message)
except:
sublime.error_message("Sublime Lightning requires the " +
"Force.com CLI to function.\n\n" +
"Please visit force-cli.herokuapp.com to " +
"install the Force.com CLI.\n\n" +
"If you’ve already installed, make sure " +
"that you saved it or created a " +
"symlink to it in Sublime’s default path.")
return ver.replace("\n", "")
def show_metadata_instance_list(self, metaname, activedir):
"""Sample doc string."""
self.type = metaname
self.activedir = activedir
self.messages = []
p = popen_force_cli(["describe", "-t", "metadata", "-n",
quote(metaname), "-j"])
result, err = p.communicate()
if err:
sublime.error_message(err.decode("utf-8"))
else:
try:
m = json.loads(result.decode("utf-8"))
if str(m) == "None":
sublime.message_dialog(
"There are no instances of " + metaname +
" in this org.")
return
for mm in m:
x = [mm['FullName'], "Modified by: " +
mm['LastModifiedByName'],
"File name: " + mm['FileName'],
"Id: " + mm['Id']]
self.messages.append(x)
print(x)
self.window = sublime.active_window()
sublime.set_timeout(
lambda:
self.window.show_quick_panel(
self.messages,
self.fetch_selected_metadata,
sublime.MONOSPACE_FONT), 10)
except:
return
def open_url(self, url):
"""Sample doc string."""
self.window.run_command(
'exec',
{'cmd': ["open", url]}
)
def show_metadata_type_list(self, activedir):
"""Sample doc string."""
working_dir = self.get_md_dir(activedir)
if working_dir == "not found":
self.open_selected_bundle(-1)
return
self.activedir = activedir
self.messages = []
p = popen_force_cli(["describe", "-t", "metadata", "-j"])
result, err = p.communicate()
if err:
sublime.error_message(err.decode("utf-8"))
else:
try:
m = json.loads(result.decode("utf-8"))
for mm in m:
x = [mm['XmlName'], "In folder: " + mm['DirectoryName'],
"Suffix: " + mm['Suffix']]
self.messages.append(x)
self.window = sublime.active_window()
self.window.show_quick_panel(self.messages,
self.open_selected_metadata,
sublime.MONOSPACE_FONT)
except:
print("There was some kind of error...")
return
def show_package_list(self):
"""Sample doc string."""
self.messages = []
p = popen_force_cli(["describe", "-t", "metadata", "-j"])
result, err = p.communicate()
if err:
sublime.error_message(err.decode("utf-8"))
else:
try:
m = json.loads(result.decode("utf-8"))
for mm in m:
x = [mm['XmlName'], "In folder: " + mm['DirectoryName'],
"Suffix: " + mm['Suffix']]
self.messages.append(x)
self.window = sublime.active_window()
self.window.show_quick_panel(self.messages,
self.open_selected_metadata,
sublime.MONOSPACE_FONT)
except:
return
def show_bundle_list(self, activedir):
"""Sample doc string."""
self.messages = []
working_dir = self.get_md_dir(activedir)
if working_dir == "not found":
self.open_selected_bundle(-1)
return
self.activedir = activedir
if Helper.meets_forcecli_version(self, "0.22.36"):
print("Using --tooling and show list")
p = popen_force_cli(["query", "Select Id,DeveloperName, "
"MasterLabel, Description From "
"AuraDefinitionBundle",
"--format:json", "-t"])
else:
print("NOT using -t")
p = popen_force_cli(["query", "Select Id,DeveloperName, "
"MasterLabel, Description From "
"AuraDefinitionBundle",
"--format:json", "--tooling"])
result, err = p.communicate()
# if err:
# errmessage = err.decode("utf-8")
# if "Deprecated" in errmessage:
# self.show_list(result.decode("utf-8"))
# else:
# sublime.error_message(err.decode("utf-8"))
# else:
m = result.decode("utf-8")
print("Data " + m)
self.show_list(m)
def show_list(self, data):
m = json.loads(data)
if len(m) == 0:
sublime.message_dialog(
"There aren't any lightning components "
" in this org.")
return
print("data: " + str(m))
self.messages.append(["All Bundles", "*", "Every Bundle",
"All the lightning bundles "
"in your org!"])
print("And now here")
for mm in m:
x = [mm['MasterLabel'], mm['Id'], mm["DeveloperName"],
mm["Description"]]
self.messages.append(x)
self.window = sublime.active_window()
self.window.show_quick_panel(self.messages,
self.open_selected_bundle,
sublime.MONOSPACE_FONT)
def make_bundle_file(self, file_name,
bundle_type, extension, snippet, dirs):
"""Sample doc string."""
metadata_dir = self.get_md_dir(dirs[0])
if metadata_dir == "not found":
return
aura_dir = os.path.join(metadata_dir, "aura")
if not os.path.isdir(aura_dir):
os.mkdir(aura_dir)
bundle_dir = os.path.join(aura_dir, file_name)
e = extension
if e == "cmp" or e == "app" or e == "intf" or e == "evt":
fn, ex = os.path.splitext(file_name)
os.mkdir(os.path.join(bundle_dir))
file_path = os.path.join(bundle_dir,
file_name + bundle_type + "." + extension)
app = open(file_path, "wb")
print("Writing " + snippet + " \nto: " + file_path)
if int(sublime.version()) >= 3000:
app.write(bytes(snippet, 'UTF-8'))
else: # To support Sublime Text 2
app.write(bytes(snippet))
app.close()
self.window.open_file(file_path)
cmd = 'push -f="' + file_path + '"'
self.window.run_command(
'exec',
{'cmd': ["force", "aura", cmd]})
return app
def find_upstram_md(self, start_dir):
print("start_dir: " + start_dir)
for root, dirss, files in Helper.walk_up(self, start_dir):
print("Root: " + root)
print("Dirname for root: " + os.path.dirname(root))
print(str(dirss))
if "metadata" in dirss:
working_dir = os.path.join(root, "metadata")
print("Found metadata above: " + working_dir)
return working_dir
elif "src" in dirss:
working_dir = os.path.join(root, "src")
print("Found src above: " + working_dir)
return working_dir
elif os.path.dirname(root) == start_dir:
print("Not found root and start_dir are the same.")
return "not found"
else:
self.find_upstram_md(os.path.dirname(root))
def do_quick_create(self, file_name, type, title_case_type, metadata_dir):
res, err = Popen(['force', 'create',
'-w', type,
'-n', file_name],
stdout=PIPE,
stderr=PIPE).communicate()
if len(err) != 0:
sublime.error_message(str(err))
else:
self.window.run_command('exec',
{'cmd': ["force", "fetch",
"-t", title_case_type,
"-n", file_name, "-unpack"],
'working_dir': metadata_dir})
def make_class_file(self, file_name, dirs):
"""Sample doc string."""
metadata_dir = self.get_md_dir(dirs[0])
if metadata_dir == "not found":
return
classes_dir = os.path.join(metadata_dir, "classes")
if not os.path.isdir(classes_dir):
os.mkdir(classes_dir)
cls_file_path = os.path.join(classes_dir, file_name + ".cls")
# xml_file_path = cls_file_path + "-meta.xml"
if os.path.exists(cls_file_path):
sublime.error_message("The class " +
file_name +
"already exists.")
return
self.do_quick_create(
file_name,
"apexclass",
"ApexClass",
metadata_dir)
def make_page_file(self, file_name, dirs):
"""Sample doc string."""
metadata_dir = self.get_md_dir(dirs[0])
if metadata_dir == "not found":
return
pages_dir = os.path.join(metadata_dir, "pages")
if not os.path.isdir(pages_dir):
os.mkdir(pages_dir)
page_file_path = os.path.join(pages_dir, file_name + ".cls")
# xml_file_path = page_file_path + "-meta.xml"
if os.path.exists(page_file_path):
sublime.error_message("The class " +
file_name +
"already exists.")
return
self.do_quick_create(
file_name,
"visualforce",
"ApexPage",
metadata_dir)
def make_vf_file(self, file_name, dirs):
"""Sample doc string."""
working_dir = self.get_md_child_name(dirs[0])
print("Metadata dir: " + working_dir)
classes_dir = os.path.join(working_dir, "pages")
if not os.path.isdir(classes_dir):
os.mkdir(classes_dir)
cls_file_path = os.path.join(classes_dir, file_name + ".page")
xml_file_path = cls_file_path + "-meta.xml"
print("cls_file_path: " + cls_file_path)
print("xml_file_path: " + xml_file_path)
if os.path.exists(cls_file_path):
sublime.error_message("The class " +
file_name +
"already exists.")
return
cls = open(cls_file_path, "wb")
cls_snippet = "public with sharing class " + file_name + " {"
cls_snippet = cls_snippet + "\n\n}"
if int(sublime.version()) >= 3000:
cls.write(bytes(cls_snippet, 'UTF-8'))
else: # To support Sublime Text 2
cls.write(bytes(cls_snippet))
xml = open(xml_file_path, "wb")
xml_snippet = self.get_xml_snippet("ApexClass")
if int(sublime.version()) >= 3000:
xml.write(bytes(xml_snippet, 'UTF-8'))
else: # To support Sublime Text 2
xml.write(bytes(xml_snippet))
xml.close()
cls.close()
self.window.open_file(cls_file_path)
self.window.run_command(
'exec',
{'cmd': ["force", "push", "-f", cls_file_path]})
return cls
def get_aura_dir(self):
"""Sample doc string."""
self.folders = self.window.folders()
print(self.folders)
return self.folders
def walk_up(self, bottom):
"""
Mimic os.walk, but walk 'up'.
instead of down the directory tree
"""
bottom = os.path.realpath(bottom)
# get files in current dir
try:
names = os.listdir(bottom)
except Exception as e:
print(e)
return
dirs, nondirs = [], []
for name in names:
if os.path.isdir(os.path.join(bottom, name)):
dirs.append(name)
else:
nondirs.append(name)
yield bottom, dirs, nondirs
new_path = os.path.realpath(os.path.join(bottom, '..'))
# see if we are at the top
if new_path == bottom:
return
for x in Helper.walk_up(self, new_path):
yield x
class LoginCommand(sublime_plugin.WindowCommand):
"""This is my docstring."""
def run(self):
"""Sample doc string."""
version = Helper(self.window).get_forcecli_version()
print("Checking the aura dir...")
Helper(self.window).get_aura_dir()
print("Running version " + version + " of Force CLI!")
self.window.show_input_panel(
"Username: ",
"",
self.get_password,
None,
None)
pass
def get_password(self, username):
"""Sample doc string."""
if len(username) == 0:
Helper(self.window).do_login("interactive", "", "")
else:
self.username = username
self.window.show_input_panel(
"Password: ",
"",
self.get_instance,
None,
None)
pass
def get_instance(self, password):
"""Sample doc string."""
if (len(password) == 0) or (len(self.username) == 0):
Helper(self.window).do_login("interactive", "", "")
else:
self.password = password
self.window.show_input_panel(
"Instance Url: ",
"",
self.do_login,
None,
None)
pass
def do_login(self, instance):
"""Sample doc string."""
Helper(self.window).do_login(self.username, self.password, instance)
return
def is_visible(self):
"""Sample doc string."""
return True
class FetchMetaCommand(sublime_plugin.WindowCommand):
"""This is my docstring."""
def run(self, dirs):
"""Sample doc string."""
print("Running FetchMetaCommand")
Helper(self.window).show_metadata_type_list(dirs[0])
def is_visible(self):
"""Sample doc string."""
return True
class FetchPackageCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self):
"""Sample doc string."""
print("Running FetchPackageCommand")
Helper(self.window).show_package_list()
def is_visible(self):
"""Sample doc string."""
return True
class FetchCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
print("Running FetchLightningCommand")
Helper(self.window).show_bundle_list(dirs[0])
# def do_fetch(self, bundle):
# self.dirs = self.window.folders()
# Helper(self.window).show_bundle_list()
# return
def is_visible(self):
"""Sample doc string."""
return True
class ApexNewClassCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
if (Helper(self.window).meets_forcecli_version("0.22.62")):
self.dirs = dirs
self.window.show_input_panel("Class Name:",
"", self.on_done, None, None)
pass
else:
sublime.message_dialog("This feature requires at least version"
" 62 of the Force")
def on_done(self, file_name):
"""Sample doc string."""
Helper(self.window).make_class_file(file_name, self.dirs)
return
def is_visible(self, dirs):
"""Sample doc string."""
return Helper(self.window).bundle_op_is_visible(dirs)
class VisualforceNewPageCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
if (Helper(self.window).meets_forcecli_version("0.22.62")):
self.dirs = dirs
self.window.show_input_panel("Page Name:",
"", self.on_done, None, None)
pass
else:
sublime.message_dialog("This feature requires at least version"
" 62 of the Force")
def on_done(self, file_name):
"""Sample doc string."""
Helper(self.window).make_page_file(file_name, self.dirs)
return
def is_visible(self, dirs):
"""Sample doc string."""
return Helper(self.window).bundle_op_is_visible(dirs)
class LightningNewAppCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
self.window.show_input_panel("App Name:", "", self.on_done, None, None)
pass
def on_done(self, file_name):
"""Sample doc string."""
Helper(self.window).make_bundle_file(
file_name,
"",
"app",
"<aura:application>\n\n</aura:application>",
self.dirs)
return
def is_visible(self, dirs):
"""Sample doc string."""
return Helper(self.window).bundle_op_is_visible(dirs)
class LightningNewComponentCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
self.window.show_input_panel(
"Component Name:",
"",
self.on_done,
None,
None)
pass
def on_done(self, file_name):
"""Sample doc string."""
Helper(self.window).make_bundle_file(
file_name,
"",
"cmp",
"<aura:component>\n\n</aura:component>",
self.dirs)
return
def is_visible(self, dirs):
"""Sample doc string."""
return Helper(self.window).bundle_op_is_visible(dirs)
class LightningNewEventCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
self.window.show_input_panel(
"Event Name:",
"",
self.on_done,
None,
None)
pass
def on_done(self, file_name):
"""Sample doc string."""
Helper(self.window).make_bundle_file(
file_name,
"",
"evt",
'<aura:event type="APPLICATION">\n\n</aura:event>',
self.dirs)
return
def is_visible(self, dirs):
"""Sample doc string."""
return Helper(self.window).bundle_op_is_visible(dirs)
class LightningNewInterfaceCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
self.window.show_input_panel(
"Interface Name:",
"",
self.on_done,
None,
None)
pass
def on_done(self, file_name):
"""Sample doc string."""
Helper(self.window).make_bundle_file(
file_name,
"",
"intf",
'<aura:interface description="Interface template">'
'\n\t<aura:attribute name="example" type="String" default="" '
'description="An example attribute."/>'
'\n</aura:interface>',
self.dirs)
return
def is_visible(self, dirs):
"""Sample doc string."""
return Helper(self.window).bundle_op_is_visible(dirs)
class LightningPreviewCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
appname = Helper.get_app_name(self, dirs[0])
url = Helper.get_instance_url(self)
namespace = Helper.get_namespace(self)
if len(namespace) == 0:
url = url + "/c/" + appname + ".app"
else:
url = url + "/" + namespace + "/" + appname + ".app"
Helper.open_url(self, url)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
isvalidbundle = helper.is_bundle_type(dirs, "app")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle
class LightningNewControllerCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
name = os.path.basename(dirs[0])
Helper(self.window).make_bundle_file(
name,
"Controller",
"js",
"({\n"
"\tmyAction: function(component, event, helper) {\n"
"\t}\n"
"})",
self.dirs)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
hasfile = helper.has_this_file(
dirs[0],
os.path.basename(dirs[0]) + "Controller.js")
isvalidbundle = helper.is_bundle_type(dirs, "app") or \
helper.is_bundle_type(dirs, "cmp")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle and not hasfile
class LightningNewSvgCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
name = os.path.basename(dirs[0])
Helper(self.window).make_bundle_file(
name,
"",
"svg",
'<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n'
'<svg width="120px" height="120px" viewBox="0 0 120 120" '
'version="1.1" xmlns="http://www.w3.org/2000/svg" '
'xmlns:xlink="http://www.w3.org/1999/xlink">\n'
'\t<g stroke="none" stroke-width="1" fill="none" '
'fill-rule="evenodd">\n'
'\t\t<path d="M120,108 C120,114.6 114.6,120 108,120 L12,120 '
'C5.4,120 '
'0,114.6 0,108 L0,12 C0,5.4 5.4,0 12,0 L108,0 C114.6,0 120,5.4 '
'120,12 L120,108 L120,108 Z" id="Shape" fill="#2A739E"/>\n'
'\t\t<path d="M77.7383308,20 L61.1640113,20 '
'L44.7300055,63.2000173 '
'L56.0543288,63.2000173 L40,99.623291 L72.7458388,54.5871812 '
'L60.907727,54.5871812 L77.7383308,20 Z" id="Path-1" '
'fill="#FFFFFF"/>\n'
'\t</g>\n'
'</svg>\n',
self.dirs)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
hasfile = helper.has_this_file(
dirs[0],
os.path.basename(dirs[0]) + ".svg")
isvalidbundle = helper.is_bundle_type(dirs, "app") or \
helper.is_bundle_type(dirs, "cmp")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle and not hasfile
class LightningNewDesignCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
name = os.path.basename(dirs[0])
Helper(self.window).make_bundle_file(
name,
"",
"design",
'<design:component>\n'
'</design:component>',
self.dirs)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
hasfile = helper.has_this_file(
dirs[0],
os.path.basename(dirs[0]) + ".design")
isvalidbundle = helper.is_bundle_type(dirs, "cmp")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle and not hasfile
class LightningNewRendererCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
name = os.path.basename(dirs[0])
Helper(self.window).make_bundle_file(
name,
"Renderer",
"js",
"({\n"
"\trender: function(component, helper) {\n"
"\t\treturn this.superRender();\n"
"\t}\n"
"})",
self.dirs)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
hasfile = helper.has_this_file(
dirs[0],
os.path.basename(dirs[0]) + "Renderer.js")
isvalidbundle = helper.is_bundle_type(dirs, "app") or \
helper.is_bundle_type(dirs, "cmp")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle and not hasfile
class LightningNewHelperCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
name = os.path.basename(dirs[0])
Helper(self.window).make_bundle_file(
name,
"Helper",
"js",
"({\n"
"\thelperMethod: function() {\n"
"\n\t}\n"
"})",
self.dirs)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
hasfile = helper.has_this_file(
dirs[0],
os.path.basename(dirs[0]) + "Helper.js")
isvalidbundle = helper.is_bundle_type(dirs, "app") or \
helper.is_bundle_type(dirs, "cmp")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle and not hasfile
class LightningNewDocumentationCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
name = os.path.basename(dirs[0])
Helper(self.window).make_bundle_file(
name,
"Documentation",
"auradoc",
'<aura:documentation>\n'
'\t<aura:description>Documentation</aura:description>\n'
'\t<aura:example name="ExampleName" '
'ref="exampleComponentName" label="Label">\n'
'\t\tExample Description\n'
'\t</aura:example>\n'
'</aura:documentation>',
self.dirs)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
print("looking for " + os.path.basename(dirs[0]) +
"Documentation.auradoc")
hasfile = helper.has_this_file(
dirs[0],
os.path.basename(dirs[0]) + "Documentation.auradoc")
isvalidbundle = helper.is_bundle_type(dirs, "app") or \
helper.is_bundle_type(dirs, "cmp")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle and not hasfile
class LightningNewStyleCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
self.dirs = dirs
name = os.path.basename(dirs[0])
Helper(self.window).make_bundle_file(
name,
"Style",
"css",
'.THIS.container {'
'\twidth: 100%;\n'
'\tpadding: 10px 0px;\n'
'\tmargin: 0px;\n'
'}\n\n'
'.THIS .center {\n'
'\tmargin: 0px auto;\n'
'}\n\n'
'.THIS .content {\n'
'\tmax-width: 768px;\n'
'\tfont-size: 12px;\n'
'\tcolor: #3c3d3e;\n'
'}',
self.dirs)
def is_visible(self, dirs):
"""Sample doc string."""
helper = Helper(self.window)
if len(dirs) == 0:
return False
hasfile = helper.has_this_file(
dirs[0],
os.path.basename(dirs[0]) + "Style.css")
isvalidbundle = helper.is_bundle_type(dirs, "app") or \
helper.is_bundle_type(dirs, "cmp")
return Helper(self.window).file_op_is_visible(dirs) and \
isvalidbundle and not hasfile
class LightningDeleteCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, files):
"""Sample doc string."""
for f in files:
command = "delete -p=" + f
self.window.run_command(
'exec',
{'cmd': ["force", "aura", command]})
self.window.find_open_file(f).close()
return
def is_visible(self, files):
"""Sample doc string."""
for f in files:
p = os.path.dirname(f)
if os.path.basename(p) == "aura":
return True
else:
p = os.path.dirname(p)
if os.path.basename(p) == "aura":
return True
else:
return False
return False
class LightningDeleteBundleCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
# comment
for d in dirs:
command = 'delete -p=' + d
self.window.run_command(
'exec',
{'cmd': ["force", "aura", command]})
for root, dirs, files in os.walk(d):
for name in files:
v = self.window.find_open_file(os.path.join(root, name))
if not (v is None):
v.close()
return
def is_visible(self, dirs):
"""Sample doc string."""
for d in dirs:
p = os.path.dirname(d)
if os.path.basename(p) == "aura":
return 1 == 1
else:
p = os.path.dirname(p)
if os.path.basename(p) == "aura":
return 1 == 1
else:
return 1 == 2
return False
class LightningSave(sublime_plugin.EventListener):
"""Sample doc string."""
def on_post_save(self, view):
"""Sample doc string."""
self.view = view
filename = view.file_name()
print("Check to see if this an aura thingy.")
if Helper.parent_dir_is_aura(self, os.path.dirname(filename)):
print("Check to see if the file ends in .JS. " + filename)
_, ext = os.path.splitext(filename)
if ext == ".js":
view.run_command('lightning_lint')
command = "push -f='" + filename + "'"
view.window().run_command(
'exec',
{'cmd': ["force", "aura", "push", "-f",
'\'' + filename + '\'']})
elif Helper.is_metadata(self, os.path.dirname(filename)):
if Helper.is_static_resource(self, filename):
print("is static resource")
else:
view.window().run_command(
'exec',
{
'working_dir':
os.path.dirname(
os.path.dirname(
os.path.dirname(filename))),
'cmd': ["force", "push", "-f", filename]
})
elif Helper.is_static_resource(self, os.path.dirname(filename)):
resource_name = Helper.get_resource_name(self, filename)
command = '-t=StaticResource'
command2 = '-n="' + resource_name + '"'
view.window().run_command(
'exec',
{'cmd': ["force", "push", command, command2]})
return
def on_selection_modified(self, view):
"""Selection was modified: update status bar."""
auralint.update_statusbar(view)
class LightningSaveBundleCommand(sublime_plugin.WindowCommand):
"""Sample doc string."""
def run(self, dirs):
"""Sample doc string."""
print(dirs)
command = 'push -f="' + dirs[0] + '"'
self.window.run_command(
'exec',
{'cmd': ["force", "aura", command]})
return
def is_visible(self, dirs):
"""Sample doc string."""
for d in dirs:
p = os.path.dirname(d)
if os.path.basename(p) == "aura":
return 1 == 1
else:
p = os.path.dirname(p)
if os.path.basename(p) == "aura":
return 1 == 1
else:
return 1 == 2
return False
