cellinfo.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.
 
from ..action.shortcut import localize_shortcuts
from ..utils import highlightmatcher, html_escape
 
CTRL_LABEL = localize_shortcuts('CtrlCmd')
 
 
class CellInfo():
 
    def __init__(self, cell_content, cell_position, for_loop=False):
        self._cell_content_cell_content = cell_content
        self._cell_position_cell_position = cell_position
        self.for_loopfor_loop = for_loop
 
    @property
    content_type = property
    
    def content_type(self):
        return self._cell_content_cell_content.type
 
    @property
    cell_type = property
    
    def cell_type(self):
        return self._cell_position_cell_position.type
 
    @property
    source = property
    
    def source(self):
        return self._cell_content_cell_content.source
 
    @property
    arg_name = property
    
    def arg_name(self):
        return self._cell_position_cell_position.argument_name
 
    def has_error(self):
        return self.argument_missingargument_missing() or self.too_many_argumentstoo_many_arguments()
 
    def argument_missing(self):
        return self.cell_typecell_typecell_type == CellType.MANDATORY \
            and self.content_typecontent_typecontent_type in [ContentType.EMPTY, ContentType.COMMENTED]
 
    def too_many_arguments(self):
        return self.cell_typecell_typecell_type == CellType.MUST_BE_EMPTY \
            and self.content_typecontent_typecontent_type not in \
            [ContentType.EMPTY, ContentType.COMMENTED]
 
    def matches(self, value):
        return highlightmatcher.highlight_matcher(value,
                                                  self._cell_content_cell_content.value)
 
 
def TipMessage(cell):
    if not cell:
        return ''
    tip = _TooltipMessage(cell)  #if not cell.for_loop else _ForLoopTooltipMessage(cell)
    return html_escape(str(tip)).replace('\n', '<br />')
 
 
class _TooltipMessage():
 
    TOO_MANY_ARGUMENTS = "Too many arguments"
    KEYWORD_NOT_FOUND = \
        "Keyword not found! For possible corrections press <%s>" % CTRL_LABEL
    VARIABLE_ASSIGMENT = "Variable assignment"
    UNKNOWN_VARIABLE = "\n\nUnknown variable"
 
    ARGUMENT = "Argument:  %s"
    OPTIONAL_ARGUMENT = "Optional argument:  %s"
    MISSING_ARGUMENT = "Missing argument:  %s"
 
    KEYWORD = "Keyword from:  %s\n\n" + ("Press <%s> for details" % CTRL_LABEL)
 
    def __init__(self, cell):
        self.messagemessage = self._get_message_get_message(cell)
 
    def _get_message(self, cell):
        message = '' if cell.content_type != ContentType.UNKNOWN_VARIABLE \
            else self.UNKNOWN_VARIABLEUNKNOWN_VARIABLE
        handlers = {
            CellType.ASSIGN: self._assign_assign,
            CellType.KEYWORD: self._keyword_keyword,
            CellType.MANDATORY: self._mandatory_mandatory,
            CellType.OPTIONAL: self._optional_optional,
            CellType.MUST_BE_EMPTY: self._must_be_empty_must_be_empty,
            CellType.UNKNOWN: self._unknown_unknown,
            CellType.END: self._keyword_keyword,
            CellType.FOR: self._keyword_keyword
        }
        return (handlers[cell.cell_type](cell) + message).strip()
 
    def _must_be_empty(self, cell):
        if cell.too_many_arguments():
            return self.TOO_MANY_ARGUMENTSTOO_MANY_ARGUMENTS
        return ''
 
    def _mandatory(self, cell):
        if cell.argument_missing():
            return self.MISSING_ARGUMENTMISSING_ARGUMENT % cell.arg_name
        return self.ARGUMENTARGUMENT % cell.arg_name
 
    def _optional(self, cell):
        return self.OPTIONAL_ARGUMENTOPTIONAL_ARGUMENT % cell.arg_name
 
    def _keyword(self, cell):
        if cell.content_type == ContentType.STRING:
            return self.KEYWORD_NOT_FOUNDKEYWORD_NOT_FOUND
        if cell.content_type in ContentType.KEYWORDS:
            return self.KEYWORDKEYWORD % cell.source
        return ''
 
    def _assign(self, cell):
        return self.VARIABLE_ASSIGMENTVARIABLE_ASSIGMENT
 
    def _unknown(self, cell):
        return ''
 
    def __nonzero__(self):
        return bool(self.messagemessage)
 
    def __str__(self):
        return self.messagemessage
 
    """
    class _ForLoopTooltipMessage(_TooltipMessage):
 
    TOO_MANY_ARGUMENTS = "Too many parameters in for loop"
 
    def _get_message(self, cell):
        if cell.too_many_arguments():
            return self.TOO_MANY_ARGUMENTS
        return ''
    """
 
 
class CellContent():
 
    def __init__(self, type, value, source=None):
        self.typetype = type
        self.valuevalue = value
        self.sourcesource = source
 
 
class CellPosition():
 
    def __init__(self, type, argument_name):
        self.typetype = type
        self.argument_nameargument_name = argument_name
 
 
class ContentType:
    USER_KEYWORD = 'USER_KEYWORD'
    LIBRARY_KEYWORD = 'LIBRARY_KEYWORD'
    END = 'END'
    FOR = 'FOR'
    IF = 'IF'
    ELSE = 'ELSE'
    ELSEIF = 'ELSE IF'
    WHILE = 'WHILE'
    TRY = 'TRY'
    EXCEPT = 'EXCEPT'
    BREAK = 'BREAK'
    CONTINUE = 'CONTINUE'
    KEYWORDS = (USER_KEYWORD, LIBRARY_KEYWORD, END, FOR, IF, ELSE, ELSEIF, WHILE, TRY, EXCEPT, BREAK, CONTINUE)
    VARIABLE = 'VARIABLE'
    UNKNOWN_VARIABLE = 'UNKNOWN_VARIABLE'
    COMMENTED = 'COMMENTED'
    STRING = 'STRING'
    EMPTY = 'EMPTY'
 
 
class CellType:
    ASSIGN = 'ASSIGN'
    KEYWORD = 'KEYWORD'
    MANDATORY = 'MANDATORY'
    OPTIONAL = 'OPTIONAL'
    MUST_BE_EMPTY = 'MUST_BE_EMPTY'
    UNKNOWN = 'UNKNOWN'
    FOR = 'KEYWORD'
    END = 'KEYWORD'
    IF = 'KEYWORD'
    ELSE = 'KEYWORD'
    ELSEIF = 'KEYWORD'
    WHILE = 'KEYWORD'
    TRY = 'KEYWORD'
    EXCEPT = 'KEYWORD'
    BREAK = 'KEYWORD'
    CONTINUE = 'KEYWORD'