SQLTools.py

__version__ = "v0.9.12"

import sys
import os
import re
import logging
from collections import OrderedDict

import sublime
from sublime_plugin import WindowCommand, EventListener, TextCommand
from Default.paragraph import expand_to_paragraph

from .SQLToolsAPI import Utils
from .SQLToolsAPI.Storage import Storage, Settings
from .SQLToolsAPI.Connection import Connection
from .SQLToolsAPI.History import History
from .SQLToolsAPI.Completion import Completion

MESSAGE_RUNNING_CMD = 'Executing SQL command...'
SYNTAX_PLAIN_TEXT = 'Packages/Text/Plain text.tmLanguage'
SYNTAX_SQL = 'Packages/SQL/SQL.tmLanguage'
SQLTOOLS_SETTINGS_FILE = 'SQLTools.sublime-settings'
SQLTOOLS_CONNECTIONS_FILE = 'SQLToolsConnections.sublime-settings'
SQLTOOLS_QUERIES_FILE = 'SQLToolsSavedQueries.sublime-settings'

USER_FOLDER                  = None
DEFAULT_FOLDER               = None
SETTINGS_FILENAME            = None
SETTINGS_FILENAME_DEFAULT    = None
CONNECTIONS_FILENAME         = None
CONNECTIONS_FILENAME_DEFAULT = None
QUERIES_FILENAME             = None
QUERIES_FILENAME_DEFAULT     = None
settingsStore                = None
queriesStore                 = None
connectionsStore             = None
historyStore                 = None

# create pluggin logger
DEFAULT_LOG_LEVEL = logging.WARNING
plugin_logger = logging.getLogger(__package__)
# some plugins are not playing by the rules and configure the root loger
plugin_logger.propagate = False
if not plugin_logger.handlers:
    plugin_logger_handler = logging.StreamHandler()
    plugin_logger_formatter = logging.Formatter("[{name}] {levelname}: {message}", style='{')
    plugin_logger_handler.setFormatter(plugin_logger_formatter)
    plugin_logger.addHandler(plugin_logger_handler)
plugin_logger.setLevel(DEFAULT_LOG_LEVEL)
logger = logging.getLogger(__name__)


def getSublimeUserFolder():
    return os.path.join(sublime.packages_path(), 'User')


def startPlugin():
    global USER_FOLDER, DEFAULT_FOLDER
    global SETTINGS_FILENAME, SETTINGS_FILENAME_DEFAULT
    global CONNECTIONS_FILENAME, CONNECTIONS_FILENAME_DEFAULT
    global QUERIES_FILENAME, QUERIES_FILENAME_DEFAULT
    global settingsStore, queriesStore, connectionsStore, historyStore

    USER_FOLDER = getSublimeUserFolder()
    DEFAULT_FOLDER = os.path.dirname(__file__)

    SETTINGS_FILENAME            = os.path.join(USER_FOLDER, SQLTOOLS_SETTINGS_FILE)
    SETTINGS_FILENAME_DEFAULT    = os.path.join(DEFAULT_FOLDER, SQLTOOLS_SETTINGS_FILE)
    CONNECTIONS_FILENAME         = os.path.join(USER_FOLDER, SQLTOOLS_CONNECTIONS_FILE)
    CONNECTIONS_FILENAME_DEFAULT = os.path.join(DEFAULT_FOLDER, SQLTOOLS_CONNECTIONS_FILE)
    QUERIES_FILENAME             = os.path.join(USER_FOLDER, SQLTOOLS_QUERIES_FILE)
    QUERIES_FILENAME_DEFAULT     = os.path.join(DEFAULT_FOLDER, SQLTOOLS_QUERIES_FILE)

    try:
        settingsStore = Settings(SETTINGS_FILENAME, default=SETTINGS_FILENAME_DEFAULT)
    except Exception as e:
        msg = '{0}: Failed to parse {1} file'.format(__package__, SQLTOOLS_SETTINGS_FILE)
        logging.exception(msg)
        Window().status_message(msg)

    try:
        connectionsStore = Settings(CONNECTIONS_FILENAME, default=CONNECTIONS_FILENAME_DEFAULT)
    except Exception as e:
        msg = '{0}: Failed to parse {1} file'.format(__package__, SQLTOOLS_CONNECTIONS_FILE)
        logging.exception(msg)
        Window().status_message(msg)

    queriesStore = Storage(QUERIES_FILENAME, default=QUERIES_FILENAME_DEFAULT)
    historyStore = History(settingsStore.get('history_size', 100))

    if settingsStore.get('debug', False):
        plugin_logger.setLevel(logging.DEBUG)
    else:
        plugin_logger.setLevel(DEFAULT_LOG_LEVEL)

    Connection.setTimeout(settingsStore.get('thread_timeout', 15))
    Connection.setHistoryManager(historyStore)

    logger.info('plugin (re)loaded')
    logger.info('version %s', __version__)


def readConnections():
    mergedConnections = {}

    # fixes #39 and #45
    if not connectionsStore:
        startPlugin()

    # global connections
    globalConnectionsDict = connectionsStore.get('connections', {})
    # project-specific connections
    projectConnectionsDict = {}
    projectData = Window().project_data()
    if projectData:
        projectConnectionsDict = projectData.get('connections', {})

    # merge connections
    mergedConnections = globalConnectionsDict.copy()
    mergedConnections.update(projectConnectionsDict)

    ordered = OrderedDict(sorted(mergedConnections.items()))

    return ordered


def getDefaultConnectionName():
    default = connectionsStore.get('default', False)
    if not default:
        return
    return default


def createOutput(panel=None, syntax=None, prependText=None):
    onInitialOutput = None
    if not panel:
        panel, onInitialOutput = getOutputPlace(syntax)
    if prependText:
        panel.run_command('append', {'characters': str(prependText)})

    initial = True

    def append(outputContent):
        nonlocal initial
        if initial:
            initial = False
            if onInitialOutput:
                onInitialOutput()

        # append content
        panel.set_read_only(False)
        panel.run_command('append', {'characters': outputContent})
        panel.set_read_only(True)

    return append


def toNewTab(content, name="", suffix="SQLTools Saved Query"):
    resultContainer = Window().new_file()
    resultContainer.set_name(
        ((name + " - ") if name != "" else "") + suffix)
    resultContainer.set_syntax_file(SYNTAX_SQL)
    resultContainer.run_command('append', {'characters': content})


def insertContent(content):
    view = View()
    # getting the settings local to this view/tab
    viewSettings = view.settings()
    # saving the original settings for "auto_indent", or True if none set
    autoIndent = viewSettings.get('auto_indent', True)
    # turn off automatic indenting otherwise the tabbing of the original
    # string is not respected after a newline is encountered
    viewSettings.set('auto_indent', False)
    view.run_command('insert', {'characters': content})
    # restore "auto_indent" setting
    viewSettings.set('auto_indent', autoIndent)


def getOutputPlace(syntax=None, name="SQLTools Result"):
    showResultOnWindow = settingsStore.get('show_result_on_window', False)
    if not showResultOnWindow:
        resultContainer = Window().find_output_panel(name)
        if resultContainer is None:
            resultContainer = Window().create_output_panel(name)
    else:
        resultContainer = None
        views = Window().views()
        for view in views:
            if view.name() == name:
                resultContainer = view
                break
        if not resultContainer:
            resultContainer = Window().new_file()
            resultContainer.set_name(name)

    resultContainer.set_scratch(True)  # avoids prompting to save
    resultContainer.set_read_only(True)
    resultContainer.settings().set("word_wrap", "false")

    def onInitialOutputCallback():
        if settingsStore.get('clear_output', False):
            resultContainer.set_read_only(False)
            resultContainer.run_command('select_all')
            resultContainer.run_command('left_delete')
            resultContainer.set_read_only(True)

        # set custom syntax highlight, only if one was passed explicitly,
        # otherwise use Plain Text syntax
        if syntax:
            # if custom and SQL related, use that, otherwise defaults to SQL
            if 'sql' in syntax.lower():
                resultContainer.set_syntax_file(syntax)
            else:
                resultContainer.set_syntax_file(SYNTAX_SQL)
        else:
            resultContainer.set_syntax_file(SYNTAX_PLAIN_TEXT)

        # hide previously set command running message (if any)
        Window().status_message('')

        if not showResultOnWindow:
            # if case this is an output pannel, show it
            Window().run_command("show_panel", {"panel": "output." + name})

        if settingsStore.get('focus_on_result', False):
            Window().focus_view(resultContainer)

    return resultContainer, onInitialOutputCallback


def getSelectionText():
    text = []

    selectionRegions = getSelectionRegions()

    if not selectionRegions:
        return text

    for region in selectionRegions:
        text.append(View().substr(region))

    return text


def getSelectionRegions():
    expandedRegions = []

    if not View().sel():
        return None

    # If we would need to expand the empty selection, then which type:
    #   'file', 'view' = use text of current view
    #   'paragraph' =  paragraph(s) (text between newlines)
    #   'line' = current line(s)
    expandTo = settingsStore.get('expand_to', 'file')
    if not expandTo:
        expandTo = 'file'

    # keep compatibility with previous settings
    expandToParagraph = settingsStore.get('expand_to_paragraph')
    if expandToParagraph is True:
        expandTo = 'paragraph'

    expandTo = str(expandTo).strip()
    if expandTo not in ['file', 'view', 'paragraph', 'line']:
        expandTo = 'file'

    for region in View().sel():
        # if user did not select anything - expand selection,
        # otherwise use the currently selected region
        if region.empty():
            if expandTo in ['file', 'view']:
                region = sublime.Region(0, View().size())
                # no point in further iterating over selections, just use entire file
                return [region]
            elif expandTo == 'paragraph':
                region = expand_to_paragraph(View(), region.b)
            else:
                # expand to line
                region = View().line(region)

        # even if we could not expand, avoid adding empty regions
        if not region.empty():
            expandedRegions.append(region)

    return expandedRegions


def getCurrentSyntax():
    view = View()
    currentSyntax = None
    if view:
        currentSyntax = view.settings().get('syntax')
    return currentSyntax


class ST(EventListener):
    connectionDict   = None
    conn             = None
    tables           = []
    columns          = []
    functions        = []
    completion       = None

    @staticmethod
    def bootstrap():
        ST.connectionDict = readConnections()
        ST.setDefaultConnection()

    @staticmethod
    def setDefaultConnection():
        default = getDefaultConnectionName()
        if not default:
            return
        if default not in ST.connectionDict:
            logger.error('connection "%s" set as default, but it does not exists', default)
            return
        logger.info('default connection is set to "%s"', default)
        ST.setConnection(default)

    @staticmethod
    def setConnection(connectionName, callback=None):
        if not connectionName:
            return

        if connectionName not in ST.connectionDict:
            return

        settings = settingsStore.all()
        config = ST.connectionDict.get(connectionName)

        promptKeys = [key for key, value in config.items() if value is None]
        promptDict = {}
        logger.info('[setConnection] prompt keys {}'.format(promptKeys))

        def mergeConfig(config, promptedKeys=None):
            merged = config.copy()
            if promptedKeys:
                merged.update(promptedKeys)
            return merged

        def createConnection(connectionName, config, settings, callback=None):
            # if DB cli binary could not be found in path a FileNotFoundError is thrown
            try:
                ST.conn = Connection(connectionName, config, settings=settings)
            except FileNotFoundError as e:
                # use only first line of the Exception in status message
                Window().status_message(__package__ + ": " + str(e).splitlines()[0])
                raise e
            ST.loadConnectionData(callback)

        if not promptKeys:
            createConnection(connectionName, config, settings, callback)
            return


        def setMissingKey(key, value):
            nonlocal promptDict
            if value is None:
                return
            promptDict[key] = value
            if promptKeys:
                promptNext()
            else:
                merged = mergeConfig(config, promptDict)
                createConnection(connectionName, merged, settings, callback)

        def promptNext():
            nonlocal promptKeys
            if not promptKeys:
                merged = mergeConfig(config, promptDict)
                createConnection(connectionName, merged, settings, callback)
            key = promptKeys.pop();
            Window().show_input_panel(
                    'Connection ' + key,
                    '',
                    lambda userInput: setMissingKey(key, userInput),
                    None,
                    None)

        promptNext()

    @staticmethod
    def loadConnectionData(callback=None):
        # clear the list of identifiers (in case connection is changed)
        ST.tables = []
        ST.columns = []
        ST.functions = []
        ST.completion = None
        objectsLoaded = 0

        if not ST.conn:
            return

        def afterAllDataHasLoaded():
            ST.completion = Completion(ST.tables, ST.columns, ST.functions, settings=settingsStore)
            logger.info('completions loaded')
            if (callback):
                callback()

        def tablesCallback(tables):
            ST.tables = tables
            nonlocal objectsLoaded
            objectsLoaded += 1
            logger.info('loaded tables : "{0}"'.format(tables))
            if objectsLoaded == 3:
                afterAllDataHasLoaded()

        def columnsCallback(columns):
            ST.columns = columns
            nonlocal objectsLoaded
            objectsLoaded += 1
            logger.info('loaded columns : "{0}"'.format(columns))
            if objectsLoaded == 3:
                afterAllDataHasLoaded()

        def functionsCallback(functions):
            ST.functions = functions
            nonlocal objectsLoaded
            objectsLoaded += 1
            logger.info('loaded functions: "{0}"'.format(functions))
            if objectsLoaded == 3:
                logger.info('all objects loaded')
                afterAllDataHasLoaded()

        ST.conn.getTables(tablesCallback)
        ST.conn.getColumns(columnsCallback)
        ST.conn.getFunctions(functionsCallback)

    @staticmethod
    def selectConnectionQuickPanel(callback=None):
        ST.connectionDict = readConnections()
        if len(ST.connectionDict) == 0:
            sublime.message_dialog('You need to setup your connections first.')
            return

        def connectionMenuList(connDictionary):
            menuItemsList = []
            template = '{dbtype}://{user}{host}{port}{db}'
            for name, config in ST.connectionDict.items():
                dbtype = config.get('type', '')
                user = '{}@'.format(config.get('username', '')) if 'username' in config else ''
                # user = config.get('username', '')
                host=config.get('host', '')
                port = ':{}'.format(config.get('port', '')) if 'port' in config else ''
                db = '/{}'.format(config.get('database', '')) if 'database' in config else ''
                connectionInfo = template.format(
                    dbtype=dbtype,
                    user=user,
                    host=host,
                    port=port,
                    db=db)
                menuItemsList.append([name, connectionInfo])
                menuItemsList.sort()
            return menuItemsList

        def onConnectionSelected(index, callback):
            menuItemsList = connectionMenuList(ST.connectionDict)
            if index < 0 or index >= len(menuItemsList):
                return
            connectionName = menuItemsList[index][0]
            ST.setConnection(connectionName, callback)
            logger.info('Connection "{0}" selected'.format(connectionName))

        menu = connectionMenuList(ST.connectionDict)
        # show pannel with callback above
        Window().show_quick_panel(menu, lambda index: onConnectionSelected(index, callback))

    @staticmethod
    def showTablesQuickPanel(callback):
        if len(ST.tables) == 0:
            sublime.message_dialog('Your database has no tables.')
            return

        ST.showQuickPanelWithSelection(ST.tables, callback)

    @staticmethod
    def showFunctionsQuickPanel(callback):
        if len(ST.functions) == 0:
            sublime.message_dialog('Your database has no functions.')
            return

        ST.showQuickPanelWithSelection(ST.functions, callback)

    @staticmethod
    def showQuickPanelWithSelection(arrayOfValues, callback):
        w = Window();
        view = w.active_view()
        selection = view.sel()[0]

        initialText = ''
        # ignore obvious non-identifier selections
        if selection.size() <= 128:
            (row_begin,_) = view.rowcol(selection.begin())
            (row_end,_) = view.rowcol(selection.end())
            # only consider selections within same line
            if row_begin == row_end:
                initialText = view.substr(selection)

        w.show_quick_panel(arrayOfValues, callback)
        w.run_command('insert', {'characters': initialText})
        w.run_command("select_all")

    @staticmethod
    def on_query_completions(view, prefix, locations):
        # skip completions, if no connection
        if ST.conn is None:
            return None

        if ST.completion is None:
            return None

        if ST.completion.isDisabled():
            return None

        if not len(locations):
            return None

        ignoreSelectors = ST.completion.getIgnoreSelectors()
        if ignoreSelectors:
            for selector in ignoreSelectors:
                if view.match_selector(locations[0], selector):
                    return None

        activeSelectors = ST.completion.getActiveSelectors()
        if activeSelectors:
            for selector in activeSelectors:
                if view.match_selector(locations[0], selector):
                    break
            else:
                return None

        # sublimePrefix = prefix
        # sublimeCompletions = view.extract_completions(sublimePrefix, locations[0])

        # preferably get prefix ourselves instead of using default sublime "prefix".
        # Sublime will return only last portion of this preceding text. Given:
        # SELECT table.col|
        # sublime will return: "col", and we need: "table.col"
        # to know more precisely which completions are more appropriate

        # get a Region that starts at the beginning of current line
        # and ends at current cursor position
        currentPoint = locations[0]
        lineStartPoint = view.line(currentPoint).begin()
        lineStartToLocation = sublime.Region(lineStartPoint, currentPoint)
        try:
            lineStr = view.substr(lineStartToLocation)
            prefix = re.split('[^`\"\w.\$]+', lineStr).pop()
        except Exception as e:
            logger.debug(e)

        # use current paragraph as sql text to parse
        sqlRegion = expand_to_paragraph(view, currentPoint)
        sql = view.substr(sqlRegion)
        sqlToCursorRegion = sublime.Region(sqlRegion.begin(), currentPoint)
        sqlToCursor = view.substr(sqlToCursorRegion)

        # get completions
        autoCompleteList, inhibit = ST.completion.getAutoCompleteList(prefix, sql, sqlToCursor)

        # safe check here, so even if we return empty completions and inhibit is true
        # we return empty completions to show default sublime completions
        if autoCompleteList is None or len(autoCompleteList) == 0:
            return None

        if inhibit:
            return (autoCompleteList, sublime.INHIBIT_WORD_COMPLETIONS)

        return autoCompleteList


# #
# # Commands
# #


# Usage for old keybindings defined by users
class StShowConnectionMenu(WindowCommand):
    @staticmethod
    def run():
        Window().run_command('st_select_connection')


class StSelectConnection(WindowCommand):
    @staticmethod
    def run():
        ST.selectConnectionQuickPanel()


class StShowRecords(WindowCommand):
    @staticmethod
    def run():
        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_show_records'))
            return

        def onTableSelected(index):
            if index < 0:
                return None
            Window().status_message(MESSAGE_RUNNING_CMD)
            tableName = ST.tables[index]
            prependText = 'Table "{tableName}"\n'.format(tableName=tableName)
            return ST.conn.getTableRecords(
                tableName,
                createOutput(prependText=prependText))

        ST.showTablesQuickPanel(callback=onTableSelected)


class StDescTable(WindowCommand):
    @staticmethod
    def run():
        currentSyntax = getCurrentSyntax()

        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_desc_table'))
            return

        def onTableSelected(index):
            if index < 0:
                return None
            Window().status_message(MESSAGE_RUNNING_CMD)
            return ST.conn.getTableDescription(ST.tables[index], createOutput(syntax=currentSyntax))

        ST.showTablesQuickPanel(callback=onTableSelected)


class StDescFunction(WindowCommand):
    @staticmethod
    def run():
        currentSyntax = getCurrentSyntax()

        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_desc_function'))
            return

        def onFunctionSelected(index):
            if index < 0:
                return None
            Window().status_message(MESSAGE_RUNNING_CMD)
            functionName = ST.functions[index].split('(', 1)[0]
            return ST.conn.getFunctionDescription(functionName, createOutput(syntax=currentSyntax))

        # get everything until first occurrence of "(", e.g. get "function_name"
        # from "function_name(int)"
        ST.showFunctionsQuickPanel(callback=onFunctionSelected)


class StRefreshConnectionData(WindowCommand):
    @staticmethod
    def run():
        if not ST.conn:
            return
        ST.loadConnectionData()


class StExplainPlan(WindowCommand):
    @staticmethod
    def run():
        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_explain_plan'))
            return

        Window().status_message(MESSAGE_RUNNING_CMD)
        ST.conn.explainPlan(getSelectionText(), createOutput())


class StExecute(WindowCommand):
    @staticmethod
    def run():
        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_execute'))
            return

        Window().status_message(MESSAGE_RUNNING_CMD)
        ST.conn.execute(getSelectionText(), createOutput())


class StExecuteAll(WindowCommand):
    @staticmethod
    def run():
        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_execute_all'))
            return

        Window().status_message(MESSAGE_RUNNING_CMD)
        allText = View().substr(sublime.Region(0, View().size()))
        ST.conn.execute(allText, createOutput())


class StFormat(TextCommand):
    @staticmethod
    def run(edit):
        selectionRegions = getSelectionRegions()

        if not selectionRegions:
            return

        for region in selectionRegions:
            textToFormat = View().substr(region)
            View().replace(edit, region, Utils.formatSql(textToFormat, settingsStore.get('format', {})))


class StFormatAll(TextCommand):
    @staticmethod
    def run(edit):
        region = sublime.Region(0, View().size())
        textToFormat = View().substr(region)
        View().replace(edit, region, Utils.formatSql(textToFormat, settingsStore.get('format', {})))


class StVersion(WindowCommand):
    @staticmethod
    def run():
        sublime.message_dialog('Using {0} {1}'.format(__package__, __version__))


class StHistory(WindowCommand):
    @staticmethod
    def run():
        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_history'))
            return

        if len(historyStore.all()) == 0:
            sublime.message_dialog('History is empty.')
            return

        def cb(index):
            if index < 0:
                return None
            return ST.conn.execute(historyStore.get(index), createOutput())

        Window().show_quick_panel(historyStore.all(), cb)


class StSaveQuery(WindowCommand):
    @staticmethod
    def run():
        query = getSelectionText()

        def cb(alias):
            queriesStore.add(alias, query)
        Window().show_input_panel('Query alias', '', cb, None, None)


class StListQueries(WindowCommand):
    @staticmethod
    def run(mode="run"):
        if mode == "run" and not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_list_queries',
                                                                               {'mode': mode}))
            return

        queriesList = queriesStore.all()
        if len(queriesList) == 0:
            sublime.message_dialog('No saved queries.')
            return

        options = []
        for alias, query in queriesList.items():
            options.append([str(alias), str(query)])
        options.sort()

        def cb(index):
            if index < 0:
                return None

            alias, query = options[index]
            if mode == "run":
                ST.conn.execute(query, createOutput())
            elif mode == "insert":
                insertContent(query)
            else:
                toNewTab(query, alias)

            return

        try:
            Window().show_quick_panel(options, cb)
        except Exception:
            pass


class StRemoveSavedQuery(WindowCommand):
    @staticmethod
    def run():
        if not ST.conn:
            ST.selectConnectionQuickPanel(callback=lambda: Window().run_command('st_remove_saved_query'))
            return

        queriesList = queriesStore.all()
        if len(queriesList) == 0:
            sublime.message_dialog('No saved queries.')
            return

        options = []
        for alias, query in queriesList.items():
            options.append([str(alias), str(query)])
        options.sort()

        def cb(index):
            if index < 0:
                return None

            return queriesStore.delete(options[index][0])
        try:
            Window().show_quick_panel(options, cb)
        except Exception:
            pass


def Window():
    return sublime.active_window()


def View():
    return Window().active_view()


def reload():
    try:
        # python 3.0 to 3.3
        import imp
        imp.reload(sys.modules[__package__ + ".SQLToolsAPI"])
        imp.reload(sys.modules[__package__ + ".SQLToolsAPI.Utils"])
        imp.reload(sys.modules[__package__ + ".SQLToolsAPI.Completion"])
        imp.reload(sys.modules[__package__ + ".SQLToolsAPI.Storage"])
        imp.reload(sys.modules[__package__ + ".SQLToolsAPI.History"])
        imp.reload(sys.modules[__package__ + ".SQLToolsAPI.Command"])
        imp.reload(sys.modules[__package__ + ".SQLToolsAPI.Connection"])
    except Exception as e:
        raise (e)

    try:
        ST.bootstrap()
    except Exception:
        pass


def plugin_loaded():

    try:
        from package_control import events

        if events.install(__name__):
            logger.info('Installed %s!' % events.install(__name__))
        elif events.post_upgrade(__name__):
            logger.info('Upgraded to %s!' % events.post_upgrade(__name__))
            sublime.message_dialog(('{0} was upgraded.' +
                                    'If you have any problem,' +
                                    'just restart your Sublime Text.'
                                    ).format(__name__)
                                   )

    except Exception:
        pass

    startPlugin()
    reload()


def plugin_unloaded():
    if plugin_logger.handlers:
        plugin_logger.handlers.pop()