messages.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
import inspect
import sys
import traceback
from .. import utils
 
from robotide import utils
 
 
 
class RideMessage:
 
    
    _topic = None
    data = []
 
    
    def __init__(self, **kwargs):
        if sorted(kwargs.keys()) != sorted(self.datadata):
            raise TypeError('Argument mismatch, expected: %s' % self.datadata)
        self.__dict__.update(kwargs)
 
    @classmethod
    def topic(cls):
        if not cls._topic_topic:
            cls_name = cls.__name__
            if cls_name.endswith('Message'):
                cls_name = cls_name[:-len('Message')]
            topic_name = utils.printable_name(cls_name, code_style=True).replace(' ', '.')
        else:
            topic_name = cls._topic_topic
        return topic_name.lower()
 
    
    def publish(self):
        from robotide.publish.publisher import PUBLISHER
        PUBLISHER.publish(self.__class__, self)
 
 
 
class RideLog(RideMessage):
    data = ['message', 'level', 'timestamp', 'notify_user']
 
 
 
class RideLogMessage(RideLog):
    data = ['message', 'level', 'timestamp', 'notify_user']
 
    
    def __init__(self, message, level='INFO', notify_user=False):
        RideMessage.__init__(
            self, message=message, level=level,
            timestamp=utils.get_timestamp(), notify_user=notify_user)
 
 
 
class RideLogException(RideLog):
    data = ['message', 'level', 'timestamp', 'exception', 'notify_user']
 
    
    def __init__(self, message, exception, level='INFO', notify_user=False):
        exc_type, exc_value, exc_traceback = sys.exc_info()
        if exc_traceback:
            tb = traceback.extract_tb(exc_traceback)
            message += '\n\nTraceback (most recent call last):\n%s\n%s' % \
                (str(exception), ''.join(traceback.format_list(tb)))
        RideMessage.__init__(
            self, message=message, level=level, notify_user=notify_user,
            timestamp=utils.get_timestamp(), exception=exception)
 
 
 
class RideParserLogMessage(RideMessage):
    data = ['message', 'level', 'timestamp', 'notify_user']
 
    
    def __init__(self, message, level='', notify_user=False):
        RideMessage.__init__(
            self, message=message, level=level,
            timestamp=utils.get_timestamp(), notify_user=notify_user)
 
 
 
class RideInputValidationError(RideMessage):
    data = ['message']
 
 
 
class RideModificationPrevented(RideMessage):
    data = ['controller']
 
 
 
class RideSettingsChanged(RideMessage):
    data = ['keys', 'old', 'new']
 
 
 
class RideExecuteSpecXmlImport(RideMessage):
 
 
 
class RideTreeSelection(RideMessage):
    data = ['node', 'item', 'silent']
 
 
 
class RideOpenVariableDialog(RideMessage):
    data = ['controller']
 
 
 
class RideTestExecutionStarted(RideMessage):
    data = ['results']
 
 
 
class RideTestSelectedForRunningChanged(RideMessage):
    data = ['tests']
 
 
 
class RideTestRunning(RideMessage):
    data = ['item']
 
 
 
class RideTestPaused(RideMessage):
    data = ['item']
 
 
 
class RideTestPassed(RideMessage):
    data = ['item']
 
 
 
class RideTestFailed(RideMessage):
    data = ['item']
 
 
 
class RideTestSkipped(RideMessage):
    data = ['item']
 
 
 
class RideTestStopped(RideMessage):
    data = ['item']
 
 
 
class RideNotebookTabChanging(RideMessage):
    data = ['oldtab', 'newtab']
 
 
 
class RideNotebookTabChanged(RideMessage):
    pass
 
 
 
class RideSaving(RideMessage):
    data = ['path', 'datafile']
 
 
 
class RideBeforeSaving(RideMessage):
    pass
 
 
 
class RideSaved(RideMessage):
    data = ['path']
 
 
 
class RideSaveAll(RideMessage):
    pass
 
 
 
class RideDataDirtyCleared(RideMessage):
    data = ['datafile']
 
 
 
class RideNewProject(RideMessage):
    data = ['path', 'datafile']
 
 
 
class RideClosing(RideMessage):
    pass
 
 
 
class RideOpenSuite(RideMessage):
    data = ['path', 'datafile']
 
 
 
class RideOpenResource(RideMessage):
    data = ['path', 'datafile']
 
 
 
class RideSelectResource(RideMessage):
    data = ['item']
 
 
 
class RideDataChanged(RideMessage):
    pass
 
 
 
class RideFileNameChanged(RideDataChanged):
    data = ['datafile', 'old_filename']
 
 
class RideDataFileRemoved(RideDataChanged):
    data = ['path', 'datafile']
 
 
class RideSuiteAdded(RideDataChanged):
    data = ['parent', 'suite']
 
 
class RideInitFileRemoved(RideDataChanged):
    data = ['path', 'datafile']
 
 
 
class RideImportSetting(RideDataChanged):
    data = ['datafile', 'type', 'import_controller']
 
    def is_resource(self):
        return self.typetype == 'resource'
 
    @property
    name = property
    
    def name(self):
        return self.import_controller.name
 
 
class _RideExcludes(RideMessage):
    data = ['old_controller', 'new_controller']
 
 
class RideIncludesChanged(_RideExcludes):
    pass
 
 
class RideExcludesChanged(_RideExcludes):
    pass
 
 
 
class RideImportSettingAdded(RideImportSetting):
    pass
 
 
 
class RideImportSettingChanged(RideImportSetting):
    pass
 
 
 
class RideImportSettingRemoved(RideImportSetting):
    pass
 
 
 
class RideDataChangedToDirty(RideDataChanged):
    data = ['datafile']
 
 
 
class RideDataFileSet(RideDataChanged):
    data = ['item']
 
 
 
class RideUserKeyword(RideDataChanged):
    pass
 
 
 
class RideUserKeywordAdded(RideUserKeyword):
    data = ['datafile', 'name', 'item']
 
 
 
class RideUserKeywordRemoved(RideUserKeyword):
    data = ['datafile', 'name', 'item']
 
 
 
class RideItem(RideDataChanged):
    data = ['item']
 
 
class RideItemStepsChanged(RideItem):
    """"""
    pass
 
 
class RideItemNameChanged(RideItem):
    """"""
    data = ['item', 'old_name']
 
 
class RideItemSettingsChanged(RideItem):
    """"""
    pass
 
 
 
class RideTestCaseAdded(RideDataChanged):
    data = ['datafile', 'name', 'item']
 
 
 
class RideTestCaseRemoved(RideDataChanged):
    data = ['datafile', 'name', 'item']
 
 
 
class RideItemMovedUp(RideDataChanged):
    data = ['item']
 
 
 
class RideItemMovedDown(RideDataChanged):
    data = ['item']
 
 
 
class RideVariableAdded(RideDataChanged):
    data = ['datafile', 'name', 'item', 'index']
 
 
 
class RideVariableRemoved(RideDataChanged):
    data = ['datafile', 'name', 'item']
 
 
 
class RideVariableMovedUp(RideItemMovedUp):
    data = ['item', 'other']
 
 
 
class RideVariableMovedDown(RideItemMovedDown):
    data = ['item', 'other']
 
 
 
class RideVariableUpdated(RideDataChanged):
    data = ['item']
 
 
 
class RideOpenTagSearch(RideMessage):
    data = ['includes', 'excludes']
 
 
class RideTreeAwarePluginAdded(RideMessage):
    data = ['plugin']
 
 
__all__ = [name for name, cls in globals().items()
           if inspect.isclass(cls) and issubclass(cls, RideMessage)]