def run(self, edit, immediate=True):
# Whether RendererManager is finished loading?
if not RendererManager.ensure_started():
sublime.status_message('OmniMarkupPreviewer have not yet started')
return
buffer_id = self.view.buffer_id()
# Opened in a tab already?
opened = False
for view in self.view.window().views():
if view.buffer_id() == buffer_id:
opened = True
break
if not opened:
RendererManager.enqueue_view(self.view, immediate=True)
host = Setting.instance().server_host
port = Setting.instance().server_port
if host == '0.0.0.0':
host = '127.0.0.1'
url = 'http://%s:%d/view/%d' % (host, port, buffer_id)
# Open with the default browser
log.info('Launching web browser for %s', url)
launching_web_browser_for_url(
url,
success_msg_default='Preview launched in default web browser',
success_msg_user='******')
def write_to_file(self, html_content, setting):
target_folder = setting.export_options.get('target_folder', '.')
if target_folder is not None:
fullpath = self.view.file_name() or ''
timestamp_format = setting.export_options.get('timestamp_format', '_%y%m%d%H%M%S')
timestr = time.strftime(timestamp_format, time.localtime())
if (not os.path.exists(fullpath) and target_folder == '.') or \
not os.path.isdir(target_folder):
target_folder = None
elif target_folder == '.':
fn_base, _ = os.path.splitext(fullpath)
html_fn = '%s%s.html' % (fn_base, timestr)
elif not os.path.exists(fullpath):
html_fn = os.path.join(target_folder, 'Untitled%s.html' % timestr)
else:
fn_base = os.path.basename(fullpath)
html_fn = os.path.join(target_folder, '%s%s.html' % (fn_base, timestr))
# No target folder, create file in temporary directory
if target_folder is None:
with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as f:
html_fn = f.name
with codecs.open(html_fn, 'w', encoding='utf-8') as html_file:
html_file.write(html_content)
log.info('Successfully exported to: %s', html_fn)
return html_fn
def write_to_file(self, html_content, setting):
target_folder = setting.export_options.get('target_folder', '.')
if target_folder is not None:
fullpath = self.view.file_name() or ''
timestamp_format = setting.export_options.get('timestamp_format', '_%y%m%d%H%M%S')
timestr = time.strftime(timestamp_format, time.localtime())
if (not os.path.exists(fullpath) and target_folder == '.') or \
not os.path.isdir(target_folder):
target_folder = None
elif target_folder == '.':
fn_base, _ = os.path.splitext(fullpath)
html_fn = '%s%s.html' % (fn_base, timestr)
elif not os.path.exists(fullpath):
html_fn = os.path.join(target_folder, 'Untitled%s.html' % timestr)
else:
fn_base = os.path.basename(fullpath)
html_fn = os.path.join(target_folder, '%s%s.html' % (fn_base, timestr))
# No target folder, create file in temporary directory
if target_folder is None:
with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as f:
html_fn = f.name
with codecs.open(html_fn, 'w', encoding='utf-8') as html_file:
html_file.write(html_content)
log.info('Successfully exported to: %s', html_fn)
return html_fn
def run(self, edit, clipboard_only=False):
view = self.view
try:
html_content = RendererManager.render_view_as_html(view)
if clipboard_only:
self.copy_to_clipboard(html_content)
return
setting = Setting.instance()
html_fn = self.write_to_file(html_content, setting)
# Copy contents to clipboard
if setting.export_options.get('copy_to_clipboard', False):
self.copy_to_clipboard(html_content)
# Open output file if necessary
if setting.export_options.get('open_after_exporting', False):
log.info('Launching web browser for %s', html_fn)
launching_web_browser_for_url(html_fn)
except NotImplementedError:
pass
except:
sublime.error_message('Error while exporting, please check your console for more information.')
log.exception('Error while exporting')
def run(self, edit, immediate=True):
# Whether RendererManager is finished loading?
if not RendererManager.ensure_started():
sublime.status_message('OmniMarkupPreviewer have not yet started')
return
buffer_id = self.view.buffer_id()
# Opened in a tab already?
opened = False
for view in self.view.window().views():
if view.buffer_id() == buffer_id:
opened = True
break
if not opened:
RendererManager.enqueue_view(self.view, immediate=True)
host = Setting.instance().server_host
port = Setting.instance().server_port
if host == '0.0.0.0':
host = '127.0.0.1'
url = 'http://%s:%d/view/%d' % (host, port, buffer_id)
# Open with the default browser
log.info('Launching web browser for %s', url)
launching_web_browser_for_url(
url,
success_msg_default='Preview launched in default web browser',
success_msg_user='******')
def run(self, edit, clipboard_only=False):
view = self.view
try:
html_content = RendererManager.render_view_as_html(view)
if clipboard_only:
self.copy_to_clipboard(html_content)
return
setting = Setting.instance()
html_fn = self.write_to_file(html_content, setting)
# Copy contents to clipboard
if setting.export_options['copy_to_clipboard']:
self.copy_to_clipboard(html_content)
# Open output file if necessary
if setting.export_options['open_after_exporting']:
log.info('Launching web browser for %s', html_fn)
launching_web_browser_for_url(html_fn)
except NotImplementedError:
pass
except:
log.exception('Error while exporting')
def bottle_run(server):
try:
global app
log.info("Bottle v%s server starting up..." % (bottle.__version__))
log.info("Listening on http://%s:%d/" % (server.host, server.port))
server.run(app)
except:
raise
def bottle_run(server):
try:
global app
log.info("Bottle v%s server starting up..." % (bottle.__version__))
log.info("Listening on http://%s:%d/" % (server.host, server.port))
server.run(app)
except:
raise
def clean(self, keep_ids=set()):
with self.rwlock.writelock:
remove_ids = set(self.cache.keys())
remove_ids -= keep_ids
if len(remove_ids) == 0:
return
for buffer_id in remove_ids:
del self.cache[buffer_id]
log.info("Clean buffer ids in: %s" % list(remove_ids))
def clean(self, keep_ids=set()):
with self.rwlock.writelock:
remove_ids = set(self.cache.keys())
remove_ids -= keep_ids
if len(remove_ids) == 0:
return
for buffer_id in remove_ids:
del self.cache[buffer_id]
log.info("Clean buffer ids in: %s" % list(remove_ids))
def on_setting_changed(cls, setting):
# Unload ignored renderers
if cls.OLD_IGNORED_RENDERERS != setting.ignored_renderers:
# Reload renderers, of course
log.info('Reloading renderers...')
cls.load_renderers()
with cls.RW_LOCK.readlock:
for renderer_classname, renderer in cls.RENDERERS:
key = 'renderer_options-' + renderer_classname
try:
renderer_options = setting._sublime_settings.get(key, {})
renderer.load_settings(renderer_options, setting)
except:
log.exception('Error on setting renderer options for %s', renderer_classname)
def run(self, edit):
view = self.view
try:
html_content = RendererManager.render_view_to_string(view)
setting = Setting.instance()
target_folder = setting.export_options['target_folder']
if target_folder is not None:
fullpath = self.view.file_name() or ''
timestamp_format = setting.export_options['timestamp_format']
if (not os.path.exists(fullpath) and target_folder == ".") or \
not os.path.isdir(target_folder):
target_folder = None
elif target_folder == '.':
fn_base, _ = os.path.splitext(fullpath)
html_fn = '%s%s.html' % (
fn_base,
time.strftime(timestamp_format, time.localtime()))
elif not os.path.exists(fullpath):
html_fn = os.path.join(target_folder, 'Untitled%s.html' % \
time.strftime(timestamp_format, time.localtime()))
else:
fn_base = os.path.basename(fullpath)
html_fn = os.path.join(target_folder, '%s%s.html' % \
(fn_base, time.strftime(timestamp_format, time.localtime())))
if target_folder is None:
with tempfile.NamedTemporaryFile(delete=False,
suffix='.html') as f:
html_fn = f.name
with codecs.open(html_fn, 'w', encoding='utf-8') as html_file:
html_file.write(html_content)
# Copy contents to clipboard
if setting.export_options['copy_to_clipboard']:
sublime.set_clipboard(html_content)
sublime.status_message('Exported result copied to clipboard')
# Open output file if necessary
if setting.export_options['open_after_exporting']:
log.info('Launching web browser for %s', html_fn)
launching_web_browser_for_url(html_fn)
except NotImplementedError:
pass
except:
log.exception("Error while exporting")
def on_setting_changed(cls, setting):
# Unload ignored renderers
if cls.OLD_IGNORED_RENDERERS != setting.ignored_renderers:
# Reload renderers, of course
log.info('Reloading renderers...')
cls.load_renderers()
with cls.RW_LOCK.readlock:
for renderer_classname, renderer in cls.RENDERERS:
key = 'renderer_options-' + renderer_classname
try:
renderer_options = setting._sublime_settings.get(key, {})
renderer.load_settings(renderer_options, setting)
except:
log.exception('Error on setting renderer options for %s',
renderer_classname)
def run(self, edit):
view = self.view
try:
html_content = RendererManager.render_view_to_string(view)
setting = Setting.instance()
target_folder = setting.export_options['target_folder']
if target_folder is not None:
fullpath = self.view.file_name() or ''
timestamp_format = setting.export_options['timestamp_format']
if (not os.path.exists(fullpath) and target_folder == ".") or \
not os.path.isdir(target_folder):
target_folder = None
elif target_folder == '.':
fn_base, _ = os.path.splitext(fullpath)
html_fn = '%s%s.html' % (fn_base, time.strftime(timestamp_format,
time.localtime()))
elif not os.path.exists(fullpath):
html_fn = os.path.join(target_folder, 'Untitled%s.html' % \
time.strftime(timestamp_format, time.localtime()))
else:
fn_base = os.path.basename(fullpath)
html_fn = os.path.join(target_folder, '%s%s.html' % \
(fn_base, time.strftime(timestamp_format, time.localtime())))
if target_folder is None:
with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as f:
html_fn = f.name
with codecs.open(html_fn, 'w', encoding='utf-8') as html_file:
html_file.write(html_content)
# Copy contents to clipboard
if setting.export_options['copy_to_clipboard']:
sublime.set_clipboard(html_content)
sublime.status_message('Exported result copied to clipboard')
# Open output file if necessary
if setting.export_options['open_after_exporting']:
log.info('Launching web browser for %s', html_fn)
launching_web_browser_for_url(html_fn)
except NotImplementedError:
pass
except:
log.exception("Error while exporting")
def _load_renderer(cls, renderers, module_file, module_name):
try:
__import__(module_name)
mod = sys.modules[module_name] = reload(sys.modules[module_name])
# Get classes
classes = inspect.getmembers(mod, inspect.isclass)
for classname, classtype in classes:
# Register renderer into manager
if hasattr(classtype, 'IS_VALID_RENDERER__'):
try:
log.info('Loaded renderer: OmniMarkupLib.Renderers.%s', classname)
# Add both classname and its instance
renderers.append((classname, classtype()))
except:
log.exception('Failed to load renderer: %s', classname)
except:
log.exception('Failed to load renderer module: OmniMarkupLib/Renderers/%s', module_file)
def run(self, edit, immediate=True):
buffer_id = self.view.buffer_id()
# Is opened in a tab?
opened = False
for view in self.view.window().views():
if view.buffer_id == buffer_id:
opened = True
break
if not opened:
RendererManager.queue_view(self.view, immediate=True)
url = 'http://localhost:%d/view/%d' % (Setting.instance().server_port, buffer_id)
# Open with the default browser
log.info('Launching web browser for %s', url)
launching_web_browser_for_url(
url,
success_msg_default='Preview launched in default web browser',
success_msg_user='******'
)
def run(self, edit, immediate=True):
buffer_id = self.view.buffer_id()
# Is opened in a tab?
opened = False
for view in self.view.window().views():
if view.buffer_id == buffer_id:
opened = True
break
if not opened:
RendererManager.queue_view(self.view, immediate=True)
url = 'http://localhost:%d/view/%d' % (Setting.instance().server_port,
buffer_id)
# Open with the default browser
log.info('Launching web browser for %s', url)
launching_web_browser_for_url(
url,
success_msg_default='Preview launched in default web browser',
success_msg_user='******')
def download(self, url, error_message, timeout, tries):
http_proxy = self.settings.get('http_proxy')
https_proxy = self.settings.get('https_proxy')
if http_proxy or https_proxy:
proxies = {}
if http_proxy:
proxies['http'] = http_proxy
if not https_proxy:
proxies['https'] = http_proxy
if https_proxy:
proxies['https'] = https_proxy
proxy_handler = urllib2.ProxyHandler(proxies)
else:
proxy_handler = urllib2.ProxyHandler()
handlers = [proxy_handler]
# secure_url_match = re.match('^https://([^/]+)', url)
# if secure_url_match != None:
# secure_domain = secure_url_match.group(1)
# bundle_path = self.check_certs(secure_domain, timeout)
# if not bundle_path:
# return False
# handlers.append(VerifiedHTTPSHandler(ca_certs=bundle_path))
urllib2.install_opener(urllib2.build_opener(*handlers))
while tries > 0:
tries -= 1
try:
request = urllib2.Request(
url, headers={"User-Agent": "OmniMarkup Downloader"})
http_file = urllib2.urlopen(request, timeout=timeout)
return http_file.read()
except (urllib2.HTTPError) as (e):
# Bitbucket and Github ratelimit using 503 a decent amount
if str(e.code) == '503':
log.info('Downloading %s was rate limited, trying again',
url)
continue
log.info('%s HTTP error %s downloading %s.', error_message,
str(e.code), url)
except (urllib2.URLError) as (e):
# Bitbucket and Github timeout a decent amount
if str(e.reason) == 'The read operation timed out' or \
str(e.reason) == 'timed out':
log.info('Downloading %s timed out, trying again', url)
continue
log.info('%s URL error %s downloading %s.', error_message,
str(e.reason), url)
break
return False
def _load_renderer(cls, renderers, module_file, module_name):
try:
__import__(module_name)
mod = sys.modules[module_name] = reload(sys.modules[module_name])
# Get classes
classes = inspect.getmembers(mod, inspect.isclass)
for classname, classtype in classes:
# Register renderer into manager
if hasattr(classtype, 'IS_VALID_RENDERER__'):
try:
log.info('Loaded renderer: OmniMarkupLib.Renderers.%s',
classname)
# Add both classname and its instance
renderers.append((classname, classtype()))
except:
log.exception('Failed to load renderer: %s', classname)
except:
log.exception(
'Failed to load renderer module: OmniMarkupLib/Renderers/%s',
module_file)
def download(self, url, error_message, timeout, tries):
http_proxy = self.settings.get('http_proxy')
https_proxy = self.settings.get('https_proxy')
if http_proxy or https_proxy:
proxies = {}
if http_proxy:
proxies['http'] = http_proxy
if not https_proxy:
proxies['https'] = http_proxy
if https_proxy:
proxies['https'] = https_proxy
proxy_handler = urllib2.ProxyHandler(proxies)
else:
proxy_handler = urllib2.ProxyHandler()
handlers = [proxy_handler]
# secure_url_match = re.match('^https://([^/]+)', url)
# if secure_url_match != None:
# secure_domain = secure_url_match.group(1)
# bundle_path = self.check_certs(secure_domain, timeout)
# if not bundle_path:
# return False
# handlers.append(VerifiedHTTPSHandler(ca_certs=bundle_path))
urllib2.install_opener(urllib2.build_opener(*handlers))
while tries > 0:
tries -= 1
try:
request = urllib2.Request(url,
headers={"User-Agent": "OmniMarkup Downloader"}
)
http_file = urllib2.urlopen(request, timeout=timeout)
return http_file.read()
except (urllib2.HTTPError) as (e):
# Bitbucket and Github ratelimit using 503 a decent amount
if str(e.code) == '503':
log.info('Downloading %s was rate limited, trying again', url)
continue
log.info('%s HTTP error %s downloading %s.', error_message, str(e.code), url)
except (urllib2.URLError) as (e):
# Bitbucket and Github timeout a decent amount
if str(e.reason) == 'The read operation timed out' or \
str(e.reason) == 'timed out':
log.info('Downloading %s timed out, trying again', url)
continue
log.info('%s URL error %s downloading %s.', error_message, str(e.reason), url)
break
return False
def download(self, url, error_message, timeout, tries):
if not self.wget:
return False
self.tmp_file = tempfile.NamedTemporaryFile().name
command = [self.wget, '--connect-timeout=' + str(int(timeout)),
'-o', self.tmp_file, '-O', '-', '-U', 'OmniMarkup Downloader']
command.append(url)
if self.settings.get('http_proxy'):
os.putenv('http_proxy', self.settings.get('http_proxy'))
if not self.settings.get('https_proxy'):
os.putenv('https_proxy', self.settings.get('http_proxy'))
if self.settings.get('https_proxy'):
os.putenv('https_proxy', self.settings.get('https_proxy'))
while tries > 0:
tries -= 1
try:
result = self.execute(command)
self.clean_tmp_file()
return result
except (NonCleanExitError) as (e):
error_line = ''
with open(self.tmp_file) as f:
for line in list(f):
if re.search('ERROR[: ]|failed: ', line):
error_line = line
break
if e.returncode == 8:
regex = re.compile('^.*ERROR (\d+):.*', re.S)
if re.sub(regex, '\\1', error_line) == '503':
# GitHub and BitBucket seem to rate limit via 503
log.info('Downloading %s was rate limited, trying again', url)
continue
error_string = 'HTTP error ' + re.sub('^.*? ERROR ', '',
error_line)
elif e.returncode == 4:
error_string = re.sub('^.*?failed: ', '', error_line)
# GitHub and BitBucket seem to time out a lot
if error_string.find('timed out') != -1:
log.info('Downloading %s timed out, trying again', url)
continue
else:
error_string = re.sub('^.*?(ERROR[: ]|failed: )', '\\1',
error_line)
error_string = re.sub('\\.?\s*\n\s*$', '', error_string)
log.info('%s %s downloading %s.', error_message, error_string, url)
self.clean_tmp_file()
break
return False
def download(self, url, error_message, timeout, tries):
if not self.curl:
return False
command = [
self.curl, '-f', '--user-agent', 'OmniMarkup Downloader',
'--connect-timeout',
str(int(timeout)), '-sS'
]
command.append(url)
if self.settings.get('http_proxy'):
os.putenv('http_proxy', self.settings.get('http_proxy'))
if not self.settings.get('https_proxy'):
os.putenv('HTTPS_PROXY', self.settings.get('http_proxy'))
if self.settings.get('https_proxy'):
os.putenv('HTTPS_PROXY', self.settings.get('https_proxy'))
while tries > 0:
tries -= 1
try:
return self.execute(command)
except (NonCleanExitError) as (e):
if e.returncode == 22:
code = re.sub('^.*?(\d+)\s*$', '\\1', e.output)
if code == '503':
# GitHub and BitBucket seem to rate limit via 503
log.info(
'Downloading %s was rate limited, trying again',
url)
continue
error_string = 'HTTP error ' + code
elif e.returncode == 6:
error_string = 'URL error host not found'
elif e.returncode == 28:
# GitHub and BitBucket seem to time out a lot
log.info('Downloading %s timed out, trying again', url)
continue
else:
error_string = e.output.rstrip()
log.info('%s %s downloading %s.', error_message, error_string,
url)
break
return False
def download(self, url, error_message, timeout, tries):
if not self.curl:
return False
command = [self.curl, '-f', '--user-agent', 'OmniMarkup Downloader',
'--connect-timeout', str(int(timeout)), '-sS']
command.append(url)
if self.settings.get('http_proxy'):
os.putenv('http_proxy', self.settings.get('http_proxy'))
if not self.settings.get('https_proxy'):
os.putenv('HTTPS_PROXY', self.settings.get('http_proxy'))
if self.settings.get('https_proxy'):
os.putenv('HTTPS_PROXY', self.settings.get('https_proxy'))
while tries > 0:
tries -= 1
try:
return self.execute(command)
except (NonCleanExitError) as (e):
if e.returncode == 22:
code = re.sub('^.*?(\d+)\s*$', '\\1', e.output)
if code == '503':
# GitHub and BitBucket seem to rate limit via 503
log.info('Downloading %s was rate limited, trying again', url)
continue
error_string = 'HTTP error ' + code
elif e.returncode == 6:
error_string = 'URL error host not found'
elif e.returncode == 28:
# GitHub and BitBucket seem to time out a lot
log.info('Downloading %s timed out, trying again', url)
continue
else:
error_string = e.output.rstrip()
log.info('%s %s downloading %s.', error_message, error_string, url)
break
return False
def unload_handler():
log.info('Unloading plugin...')
# Cleaning up resources...
PluginManager.instance().stop_server()
# Stopping renderer worker
RendererManager.stop()
def sublime_settings_on_change(self):
log.info('Reloading settings...')
self.notify('changing', setting=self)
self.load_setting()
self.notify('changed', setting=self)
def unload_handler():
log.info('Unloading plugin...')
# Cleaning up resources...
PluginManager.instance().stop_server()
# Stopping renderer worker
RendererManager.WORKER.stop()
def stop(self):
log.info('Bottle server shuting down...')
self.server.shutdown()
self.runner.join()
def download(self, url, error_message, timeout, tries):
if not self.wget:
return False
self.tmp_file = tempfile.NamedTemporaryFile().name
command = [
self.wget, '--connect-timeout=' + str(int(timeout)), '-o',
self.tmp_file, '-O', '-', '-U', 'OmniMarkup Downloader'
]
command.append(url)
if self.settings.get('http_proxy'):
os.putenv('http_proxy', self.settings.get('http_proxy'))
if not self.settings.get('https_proxy'):
os.putenv('https_proxy', self.settings.get('http_proxy'))
if self.settings.get('https_proxy'):
os.putenv('https_proxy', self.settings.get('https_proxy'))
while tries > 0:
tries -= 1
try:
result = self.execute(command)
self.clean_tmp_file()
return result
except (NonCleanExitError) as (e):
error_line = ''
with open(self.tmp_file) as f:
for line in list(f):
if re.search('ERROR[: ]|failed: ', line):
error_line = line
break
if e.returncode == 8:
regex = re.compile('^.*ERROR (\d+):.*', re.S)
if re.sub(regex, '\\1', error_line) == '503':
# GitHub and BitBucket seem to rate limit via 503
log.info(
'Downloading %s was rate limited, trying again',
url)
continue
error_string = 'HTTP error ' + re.sub(
'^.*? ERROR ', '', error_line)
elif e.returncode == 4:
error_string = re.sub('^.*?failed: ', '', error_line)
# GitHub and BitBucket seem to time out a lot
if error_string.find('timed out') != -1:
log.info('Downloading %s timed out, trying again', url)
continue
else:
error_string = re.sub('^.*?(ERROR[: ]|failed: )', '\\1',
error_line)
error_string = re.sub('\\.?\s*\n\s*$', '', error_string)
log.info('%s %s downloading %s.', error_message, error_string,
url)
self.clean_tmp_file()
break
return False
def stop(self):
log.info('Bottle server shuting down...')
self.server.shutdown()
self.runner.join()
def sublime_settings_on_change(self):
log.info("Reloading settings...")
self.notify("changing", setting=self)
self.load_setting()
self.notify("changed", setting=self)
