def on_done(self, idx):
if idx == -1:
return
name = self.browsers[idx][0]
sdk = SDK()
sdk.path_to_default_user_browser = name
def generate(self, path=None, template=None):
assert path and template, 'wrong call'
try:
if not os.path.exists(path):
os.mkdir(path)
except OSError as e:
_logger.error(e)
sublime.status_message('Dart: Error. Check console for details.')
return
with pushd(path):
was_empty_dir = len(glob.glob("*")) == 0
sdk = SDK()
self.window.run_command(
'dart_exec', {
'cmd':
[sdk.path_to_pub, 'global', 'run', 'stagehand', template],
'preamble':
"Running stagehand...\n",
'working_dir':
path,
})
if was_empty_dir:
after(2000, self.create_sublime_project, path)
def start_stdout_watcher(self):
sdk = SDK()
t = StdoutWatcher(self, sdk.path)
# Thread dies with the main thread.
t.daemon = True
# XXX: This is necessary. If we call t.start() directly, ST hangs.
sublime.set_timeout_async(t.start, 0)
def plugin_loaded():
sdk = SDK()
if not sdk.enable_analysis_server:
return
try:
sdk.check_for_critical_configuration_errors()
except ConfigError as e:
print("Dart: " + str(e))
_logger.error(e)
return
# FIXME(guillermooo): Ignoring, then de-ignoring this package throws
# errors. (Potential ST3 bug: https://github.com/SublimeTextIssues/Core/issues/386)
# Make ST more responsive on startup.
sublime.set_timeout(_init, 500)
def start(self):
if AnalysisServer.ping():
_logger.info('AnalysisServer is already running')
return
self.send_get_version()
sdk = SDK()
_logger.info('starting AnalysisServer')
AnalysisServer.server = PipeServer([
sdk.path_to_dart,
sdk.path_to_analysis_snapshot,
'--sdk={0}'.format(sdk.path),
'--file-read-mode normalize-eol-always',
])
def do_start():
try:
AnalysisServer.server.start(working_dir=sdk.path)
self.start_handlers()
self.start_stdout_watcher()
except Exception as e:
_logger.error('could not start server properly')
_logger.error(e)
return
threading.Thread(target=do_start).start()
def dart_pub_get(self, path_to_pubspec):
path_to_pubspec = path_to_pubspec or self.window.active_view(
).file_name()
if not path_to_pubspec:
_logger.error('no pubspec specified for "pub get"')
return
package = PubPackage.from_path(path_to_pubspec)
if not package:
_logger.info(
"can't 'pub get' if project hasn't a pubspec.yaml file")
return
path_to_pubspec = package.pubspec.path
sdk = SDK()
if not sdk.path_to_pub:
_logger.debug("`sdk.path_to_pub` missing; aborting pub")
return
self.execute(
**{
'working_dir': os.path.dirname(path_to_pubspec),
'cmd': [sdk.path_to_pub, 'get'],
'preamble': 'Running pub get...\n',
})
def get_templates(self):
sdk = SDK()
try:
out = check_output([sdk.path_to_pub, 'global', 'run', 'stagehand', '--machine'],
startupinfo=supress_window()).decode('utf-8')
except CalledProcessError as e:
error_panel = ErrorPanel()
error_panel.write('\n')
error_panel.write('Could not run Stagehand.\n')
error_panel.write('\n')
error_panel.write('Stagehand is a tool to help you get started with new projects.\n')
error_panel.write('\n')
error_panel.write('To enable Stagehand, run the following command from a terminal:\n')
error_panel.write('\n')
error_panel.write('$ pub global activate stagehand')
error_panel.show()
msg = 'Could not run stagehand:\n {0}'.format(str(e))
_logger.debug(msg)
return None
decoded = json.loads(out)
entries = []
for tpl in decoded:
entry = [tpl['name'], tpl['description'],
"entrypoint: {}".format(tpl['entrypoint'])]
entries.append(entry)
return entries
def run(self, action, file_name):
'''
@action
One of: primary, secondary
@file_name
A valid path.
'''
working_dir = os.path.dirname(file_name)
if action == 'primary':
self.execute(
cmd=[SDK().path_to_pub] + ['get'],
working_dir=working_dir,
preamble="Running pub...\n",
panel_name='dart.out',
)
return
if action != 'secondary':
_logger.error('not implemented')
return
f = lambda i: self.on_done(i, file_name, working_dir)
self.window.show_quick_panel(self.PUB_CMDS, f)
def run_web_app(self, dart_view, working_dir, action):
sdk = SDK()
if action == 'secondary':
if not sdk.path_to_default_user_browser:
print("Dart: No default browser found")
_logger.info('no default browser found')
return
cmd = [sdk.path_to_pub, 'serve']
if dart_view.is_example:
cmd.append('example')
self.execute(cmd=cmd, working_dir=working_dir)
DartRunFileCommand.is_server_running = True
self.start_default_browser(dart_view.path)
return
self.panel = OutputPanel('dart.out')
self.panel.write('=' * 80)
self.panel.write('\n')
self.panel.write('Running pub serve...\n')
self.panel.write('=' * 80)
self.panel.write('\n')
self.panel.show()
DartRunFileCommand.pub_serve = PubServe(
cwd=working_dir,
is_example=dart_view.is_example,
)
pub_serve_listener = PubServeListener(DartRunFileCommand.pub_serve,
self.panel, dart_view.url_path)
DartRunFileCommand.pub_serve.listener = pub_serve_listener
DartRunFileCommand.pub_serve.start()
DartRunFileCommand.is_server_running = True
def install(self):
sdk = SDK()
self.window.run_command(
'dart_exec', {
'cmd': [sdk.path_to_pub, 'global', 'activate', 'stagehand'],
'preamble':
"Installing stagehand... (This may take a few seconds.)\n"
})
def RunPub(view, file_name):
# FIXME: Infefficient. We should store the path to the sdk away.
dartsdk_path = SDK().path
if not dartsdk_path:
_logger.debug("`dartsdk_path` missing; aborting pub")
return
PubThread(view.window(), dartsdk_path, file_name).start()
def should_ignore_file(self, path):
project = DartProject.from_path(path)
is_a_third_party_file = (project and is_path_under(project.path_to_packages, path))
if is_a_third_party_file:
return True
sdk = SDK()
return is_path_under(sdk.path, path)
def browsers(self):
sdk = SDK()
browsers = sdk.user_browsers
self.BROWSERS = [k for k in sorted(browsers.keys()) if
k != 'default']
final = []
for k in self.BROWSERS:
final.append([k, '' if k != browsers['default'] else 'default'])
return final
def user_agent(self):
# FIXME(guillermooo): This is probably wrong.
ua = "ST-Dart-Plugin/{version} ({os}; {os}; {os}; {language})"
data = {
'os': os.name,
'language': os.environ.get('LANG', 'unknown'),
'version': SDK().check_version().strip(),
}
return ua.format(**data)
def on_done(self, idx, file_name, working_dir):
if idx == -1:
return
self.execute(
cmd=[SDK().path_to_pub] + [self.PUB_CMDS[idx]],
working_dir=os.path.dirname(file_name),
preamble="Running pub...\n",
panel_name='dart.out',
)
def run(self, working_dir=None, **kwargs):
assert working_dir is not None, 'wrong call'
self.raise_event(self, EventSource.ON_PUB_BUILD)
sdk = SDK()
self.execute(
**{
'working_dir': working_dir,
'cmd': [sdk.path_to_pub, 'build'],
'preamble': 'Running pub build...\n',
})
def __init__(self, view, fileName, our_settings, show_popup, force=False):
# TODO(guillermooo): In Python 3k, we should be able to simplify this.
super(DartLintThread, self).__init__()
self.settings = our_settings
self.show_popup = show_popup
self.daemon = True
self.view = view
self.window = view.window()
self.dartsdk_path = SDK().path
self.fileName = fileName
self.force = force
def RunDartanalyzer(view,
fileName,
our_settings,
show_popup=True,
force=False):
# FIXME: Inefficient. We should store the SDK away and reuse it.
dartsdk_path = SDK().path
if dartsdk_path:
DartLintThread(view, fileName, our_settings, show_popup,
force=force).start()
def should_ignore_file(self, path):
project = DartProject.from_path(path)
if project and project.path_to_packages is not None:
is_a_third_party_file = is_path_under(project.path_to_packages,
path)
else:
is_a_third_party_file = False
if is_a_third_party_file:
return True
sdk = SDK()
return is_path_under(sdk.path, path)
def get_templates(self):
sdk = SDK()
out = check_output(
[sdk.path_to_pub, 'global', 'run', 'stagehand', '--machine'],
startupinfo=supress_window()).decode('utf-8')
decoded = json.loads(out)
entries = []
for tpl in decoded:
entry = [
tpl['name'], tpl['description'],
"entrypoint: {}".format(tpl['entrypoint'])
]
entries.append(entry)
return entries
def plugin_loaded():
sdk = SDK()
if not sdk.enable_experimental_features:
return
try:
sdk.path_to_analysis_snapshot
except ConfigError as e:
print("Dart: " + str(e))
_logger.error(e)
return
# FIXME(guillermooo): Ignoring, then de-ignoring this package throws
# errors.
# Make ST more responsive on startup --- also helps the logger get ready.
sublime.set_timeout(init, START_DELAY)
def plugin_loaded():
sdk = SDK()
if not sdk.enable_analysis_server:
return
try:
sdk.path_to_analysis_snapshot
except ConfigError as e:
print("Dart: " + str(e))
_logger.error(e)
return
# FIXME(guillermooo): Ignoring, then de-ignoring this package throws
# errors. (Potential ST3 bug: https://github.com/SublimeTextIssues/Core/issues/386)
# Make ST more responsive on startup.
sublime.set_timeout(init, START_DELAY)
def start_default_browser(self, file_name):
sdk = SDK()
if not sdk.path_to_default_user_browser:
_logger.info('no default user browser defined')
print("Dart: No default user browser defined "
"in Dart plugin settings")
return
dart_view = DartFile.from_path(file_name)
url = 'http://localhost:8080'
if dart_view.url_path:
url = url + "/" + dart_view.url_path
# TODO(guillermooo): make GUIProcess wrapper to abstract out some of
# the stuff below?
if sublime.platform() == 'osx':
bin_ = GenericBinary('open', sdk.path_to_default_user_browser)
after(1000, lambda: bin_.start(args=[url]))
return
elif sublime.platform() == 'windows':
# FIXME(guillermooo): On Windows, Firefox won't work when started
# from the cmdline only. If it's started first from the shell, it
# will work here as well.
path = sdk.path_to_default_user_browser
bin_ = GenericBinary(path)
after(
1000, lambda: bin_.start(
args=[url],
shell=True,
cwd=os.path.dirname(path),
))
return
path = sdk.path_to_default_user_browser
bin_ = GenericBinary(path)
after(
1000, lambda: bin_.start(
args=[url],
shell=True,
cwd=os.path.dirname(path),
))
def run_server_app(self, file_name, working_dir, action):
if action == 'secondary':
# run with observatory
# we need to do additional processing in this case, so we don't
# use the regular .execute() method to manage the subprocess.
self.panel = OutputPanel('dart.out')
self.panel.write('=' * 80)
self.panel.write('\n')
self.panel.write('Running dart with Observatory.\n')
self.panel.write('=' * 80)
self.panel.write('\n')
self.panel.show()
DartRunFileCommand.observatory = RunDartWithObservatory(
file_name,
cwd=working_dir,
listener=self)
DartRunFileCommand.observatory.start()
def start_dartium():
d = Dartium()
port = DartRunFileCommand.observatory.port
if port is None:
_logger.debug('could not capture observatory port')
print("Dart: Cannot start Observatory "
"because its port couldn't be retrieved")
return
d.start('http://localhost:{}'.format(port))
after(1000, lambda: start_dartium())
return
preamble = '''* Running {0}
* (output starts below the next line)
==============================================================================
'''
# TODO(guillermooo): improve event args
self.execute(
cmd=[SDK().path_to_dart, '--checked', file_name],
working_dir=working_dir,
file_regex=r"'file:///(.+)': error: line (\d+) pos (\d+): (.*)$",
preamble=preamble.format(file_name),
)
DartRunFileCommand.is_script_running = True
def start(self):
if AnalysisServer.ping():
return
sdk = SDK()
_logger.info('starting AnalysisServer')
AnalysisServer.server = PipeServer([
'dart', sdk.path_to_analysis_snapshot, '--sdk={0}'.format(sdk.path)
])
AnalysisServer.server.start(working_dir=sdk.path)
self.start_stdout_watcher()
try:
# Server is ready.
self.ready_barrier.wait()
except threading.BrokenBarrierError:
_logger.error('could not start server properly')
return
def check():
try:
SDK()
except FatalConfigError as e:
sublime.active_window().run_command('_dart_report_config_errors',
{'message': str(e)})
def check_installed(self):
sdk = SDK()
out = check_output([sdk.path_to_pub, 'global', 'list'],
startupinfo=supress_window())
return 'stagehand' in out.decode('utf-8')
def start_stdout_watcher(self):
sdk = SDK()
t = StdoutWatcher(self, sdk.path)
# Thread dies with the main thread.
t.daemon = True
t.start()
def run(self):
sdk = SDK()
previous_view = self.window.active_view()
report = self.window.new_file()
report.set_name('Dart - Configuration Report')
report.set_scratch(True)
self.append(report, 'Sublime Text Information\n')
self.append(report, '=' * 80)
self.add_newline(report)
self.append(report, 'version: ')
self.append(report, sublime.version())
self.append(report, ' (')
self.append(report, sublime.channel())
self.append(report, ' channel)')
self.add_newline(report)
self.append(report, 'platform: ')
self.append(report, sublime.platform())
self.add_newline(report)
self.append(report, 'architecture: ')
self.append(report, sublime.arch())
self.add_newline(report)
self.add_newline(report)
self.append(report, 'Dart SDK Information\n')
self.append(report, '=' * 80)
self.add_newline(report)
self.append(report, 'version: ')
dart_version = sdk.check_version()
self.append(report, dart_version)
self.add_newline(report)
self.append(report, 'Dart Package Settings\n')
self.append(report, '=' * 80)
self.add_newline(report)
self.append(report, 'dart_sdk_path: ')
self.append(report, sdk.path)
self.add_newline(report)
self.append(report, 'dart_dartium_path: ')
self.append(report, sdk.path_to_dartium)
self.add_newline(report)
self.append(report, 'dart_user_browsers: ')
self.add_newline(report)
self.append(report, pprint.pformat(sdk.user_browsers))
self.add_newline(report)
self.add_newline(report)
self.append(report, 'Project Information\n')
self.append(report, '=' * 80)
self.add_newline(report)
if previous_view:
try:
self.append(
report,
str(PubspecFile.from_path(
previous_view.file_name()).path)
)
except Exception as e:
self.append(report, 'No pubspec found\n')
self.add_newline(report)
