iteminfo.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 os
from functools import total_ordering
 
from .. import utils
from ..lib.robot.libdocpkg.htmlwriter import DocToHtml
 
 
 
class ItemInfo():
 
    
    def __init__(self, name, source, details):
        self.namename = name
        self.sourcesource = source
        if details is not None:
            self.detailsdetails = details
        self._priority_priority = PRIORITIES.get(self.__class__, PRIORITIES[ItemInfo])
 
    @property
    longname = property
    
    def longname(self):
        return '%s.%s' % (self.sourcesource, self.namename)
 
    def name_begins_with(self, prefix):
        return utils.normalize(self.namename).startswith(prefix)
 
    def longname_begins_with(self, prefix):
        return utils.normalize(self.longnamelongnamelongname).startswith(prefix)
 
    def is_library_keyword(self):
        return False
 
    def is_user_keyword(self):
        return not self.is_library_keywordis_library_keyword()
 
    @staticmethod
    def m_cmp(a, b):
        return (a > b) - (a < b)
 
    def __cmp__(self, other):
        if self._priority_priority == other._priority:
            name_cmp = self.m_cmpm_cmp(self.namename.upper(),other.name.upper())
            return name_cmp if name_cmp else self.m_cmpm_cmp(self.sourcesource, other.source)
        return self.m_cmpm_cmp(self._priority_priority, other._priority)
 
    def __eq__(self, other):
        return not self.__cmp____cmp__(other) if isinstance(other, ItemInfo) else False
 
    def __hash__(self):
        return hash((self.namename, self.sourcesource))
 
 
@total_ordering
class VariableInfo(ItemInfo):
 
    def __init__(self, name, value, source):
        ItemInfo.__init__(self, name, self._source_name_source_name(source), None)
        self._original_source_original_source = source
        self._value_value = value
 
    def _source_name(self, source):
        return os.path.basename(source) if source else ''
 
    def name_matches(self, pattern):
        normalized = utils.normalize(self._undecorate_undecorate(pattern))
        return utils.normalize(self.namename[2:-1]).startswith(normalized)
 
    def _undecorate(self, pattern):
        def get_prefix_length():
            if pattern[0] not in ['$', '@', '&']:
                return 0
            elif len(pattern) > 1 and pattern[1] == '{':
                return 2
            else:
                return 1
        if not pattern:
            return pattern
        without_prefix = pattern[get_prefix_length():]
        if pattern[-1] == '}':
            return without_prefix[:-1]
        else:
            return without_prefix
 
    @property
    details = property
    
    def details(self):
        value = self._value_value
        if self.namename.startswith('@'):
            if value is None:
                value = '[ ]'
        return ('<table>'
                '<tr><td><i>Name:</i></td><td>%s</td></tr>'
                '<tr><td><i>Source:</i></td><td>%s</td></tr>'
                '<tr><td valign=top><i>Value:</i></td><td>%s</td></tr>'
                '</table>') % (self.namename, self._original_source_original_source, str(value))
 
    def __eq__(self, other):
        return self.namename.lower() == other.name.lower()
 
    def __hash__(self):
        return hash(repr(self))
 
    def __lt__(self, other):
        return self.namename.lower() < other.name.lower()
 
 
@total_ordering
class ArgumentInfo(VariableInfo):
 
    SOURCE = 'Argument'
 
    def __init__(self, name, value):
        VariableInfo.__init__(self, name, value, self.SOURCESOURCE)
 
    def __eq__(self, other):
        return self.longnamelongnamelongname.lower() == other.longname.lower()
 
    def __hash__(self):
        return hash(repr(self))
 
    def __lt__(self, other):
        return self.longnamelongnamelongname.lower() < other.longname.lower()
 
 
class LocalVariableInfo(VariableInfo):
 
    SOURCE = 'Local variable'
 
    def __init__(self, name):
        VariableInfo.__init__(self, name, '', self.SOURCESOURCE)
 
 
@total_ordering
class _KeywordInfo(ItemInfo):
 
    def __init__(self, item):
        self.docdoc = self._doc(item).strip()
        self.doc_formatdoc_format = "ROBOT"
        ItemInfo.__init__(self, self._name_name(item), self._source(item),
                          None)
        self.shortdocshortdoc = self.docdoc.splitlines()[0] if self.docdoc else ''
        self.itemitem = item
 
    @property
    arguments = property
    
    def arguments(self):
        return self._parse_args(self.itemitem)
 
    @property
    details = property
    
    def details(self):
        formatter = DocToHtml(self.doc_formatdoc_format)
        return ('<table>'
                '<tr><td><i>Name:</i></td><td>%s</td></tr>'
                '<tr><td><i>Source:</i></td><td>%s &lt;%s&gt;</td></tr>'
                '<tr><td><i>Arguments:</i></td><td>%s</td></tr>'
                '</table>'
                '<table>'
                '<tr><td>%s</td></tr>'
                '</table>') % \
                (self._name_name(self.itemitem), self._source(self.itemitem), self._type,
                 self._format_args_format_args(self.argumentsargumentsarguments),
                 formatter(self.docdoc))
 
    def _format_args(self, args):
        return '[ %s ]' % ' | '.join(args)
 
    def __str__(self):
        return 'KeywordInfo[name: %s, source: %s, doc: %s]' %(self.namename,
                                                              self.sourcesource,
                                                              self.docdoc)
 
    def _name(self, item):
        return item.name
 
    def __eq__(self, other):
        return self.namename.lower() == other.name.lower()
 
    def __hash__(self):
        return hash(repr(self))
 
    def __lt__(self, other):
        return self.namename.lower() < other.name.lower()
 
 
class _XMLKeywordContent(_KeywordInfo):
 
    def __init__(self, item, source, source_type, doc_format):
        self._type_type = source_type
        self._source_source = lambda x: source
        _KeywordInfo.__init__(self, item)
        self.argsargs = self._format_args_format_args(self._parse_args_parse_args(item))
        if doc_format in ("TEXT", "ROBOT", "REST", "HTML"):
            self.doc_formatdoc_formatdoc_format = doc_format
        else:
            self.doc_formatdoc_formatdoc_format = "ROBOT"
 
    def with_alias(self, alias):
        if alias:
            self.sourcesourcesource = alias
        return self
 
    def _name(self, node):
        return node.get('name')
 
    def _doc(self, node):
        return node.find('doc').text or ''
 
    def _parse_args(self, node):
        args_node = node.find('arguments')
        return [arg_node.text for arg_node in args_node.findall('arg')]
 
    def is_library_keyword(self):
        return True
 
 
@total_ordering
class LibraryKeywordInfo(_KeywordInfo):
    
    _type = 'test library'
    
    _library_alias = None
    item = None
 
    def __init__(self, name, doc, doc_format, library_name, args):
        self._item_name_item_name = name
        self.docdocdoc = doc.strip()
        self._item_library_name_item_library_name = library_name
        self._args_args = args
        ItemInfo.__init__(self, self._item_name_item_name, library_name, None)
        self.shortdocshortdocshortdoc = self.docdocdoc.splitlines()[0] if self.docdocdoc else ''
 
        if doc_format in ("TEXT", "ROBOT", "REST", "HTML"):
            self.doc_formatdoc_formatdoc_format = doc_format
        else:
            self.doc_formatdoc_formatdoc_format = "ROBOT"
 
    def with_alias(self, alias):
        self._library_alias_library_alias = alias
        self.sourcesourcesource = self._source_source(self.itemitemitem)
        return self
 
    def _source(self, item):
        if self._library_alias_library_alias:
            return self._library_alias_library_alias
        return self._item_library_name_item_library_name
 
    @property
    arguments = property
    
    def arguments(self):
        return self._args_args
 
    def is_library_keyword(self):
        return True
 
    def __eq__(self, other):
        if isinstance(other, str):   # DEBUG
           return self.namename.lower() == other.name.lower()  # and self.__hash__ == other.__hash__
 
    def __hash__(self):
        return hash(repr(self))  # self.name)  #
 
    def __lt__(self, other):
        return self.namename.lower() < other.name.lower()
 
    def _name(self, item):
        return self._item_name_item_name
 
 
@total_ordering
 
class BlockKeywordInfo(_KeywordInfo):
    
    _type = 'test library'
    
    _library_alias = None
    item = None
 
    def __init__(self, name, doc, doc_format='ROBOT', library_name='BuiltIn',
                 *args):
        self._item_name_item_name = name
        self.docdocdoc = doc.strip()
        self._item_library_name_item_library_name = library_name
        self.doc_formatdoc_formatdoc_format = doc_format
        self._args_args = args
        ItemInfo.__init__(self, self._item_name_item_name, library_name, None)
        self.shortdocshortdocshortdoc = self.docdocdoc.splitlines()[0] if self.docdocdoc else ''
 
    def with_alias(self, alias):
        self._library_alias_library_alias = alias
        self.sourcesourcesource = self._source_source(self.itemitemitem)
        return self
 
    def _source(self, item):
        if self._library_alias_library_alias:
            return self._library_alias_library_alias
        return self._item_library_name_item_library_name
 
    @property
    arguments = property
    
    def arguments(self):
        return self._args_args
 
    def is_library_keyword(self):
        return True
 
    def __eq__(self, other):
        if isinstance(other, str):   # DEBUG
           return self.namenamename == other.name  # must match Capital case
 
    def __hash__(self):
        return hash(repr(self))  # self.name)  #
 
    def __lt__(self, other):
        return self.namenamename < other.name
 
    def _name(self, item):
        return self._item_name_item_name
 
 
class _UserKeywordInfo(_KeywordInfo):
 
    def _source(self, item):
        return os.path.basename(item.source) if item.source else ''
 
    def _doc(self, item):
        return utils.unescape(item.doc.value)
 
    def _parse_args(self, uk):
        parsed = []
        for arg in uk.args.value:
            if self._is_scalar_is_scalar(arg):
                parsed.append(self._parse_name_and_default_parse_name_and_default(arg))
            elif self._is_list_is_list(arg):
                parsed.append(self._parse_vararg_parse_vararg(arg))
            elif self._is_dict_is_dict(arg):
                parsed.append(self._parse_kwarg_parse_kwarg(arg))
        return parsed
 
    def _is_scalar(self, arg):
        return arg.startswith('$')
 
    def _parse_name_and_default(self, arg):
        parts = arg.split('=', 1)
        name = self._strip_var_syntax_chars_strip_var_syntax_chars(parts[0])
        if len(parts) == 1:
            return name
        return name + '=' + parts[1]
 
    def _strip_var_syntax_chars(self, string):
        return string[2:-1]
 
    def _is_list(self, arg):
        return arg.startswith('@')
 
    def _is_dict(self, arg):
        return arg.startswith('&')
 
    def _parse_vararg(self, arg):
        return '*' + self._strip_var_syntax_chars_strip_var_syntax_chars(arg)
 
    def _parse_kwarg(self, arg):
        return '**' + self._strip_var_syntax_chars_strip_var_syntax_chars(arg)
 
 
@total_ordering
class TestCaseUserKeywordInfo(_UserKeywordInfo):
    
    _type = 'test case file'
 
    @property
    longname = property
    
    def longname(self):
        return self.namename
 
    def __eq__(self, other):
        if isinstance(other, str):  # DEBUG
            return self.namename.lower() == other.name.lower()  # and self.__hash__ == other.__hash__
 
    def __hash__(self):
        return hash(self.longnamelongnamelongnamelongnamelongname)  # repr(self))
 
    def __lt__(self, other):
        return self.namename.lower() < other.name.lower()
 
 
@total_ordering
class ResourceUserKeywordInfo(_UserKeywordInfo):
    
    _type = 'resource file'
 
    @property
    longname = property
    
    def longname(self):
        return self.itemitem.parent.parent.rawname + '.' + self.namename
 
    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.namename.lower() == other.name.lower()
        else:
            return False
 
    def __hash__(self):
        return hash(self.longnamelongnamelongnamelongnamelongname)  # repr(self))
 
    def __lt__(self, other):
        return self.namename.lower() < other.name.lower()
 
 
PRIORITIES = {ItemInfo: 50,
              LibraryKeywordInfo: 40,
              BlockKeywordInfo: 35,
              ResourceUserKeywordInfo: 30,
              TestCaseUserKeywordInfo: 20,
              VariableInfo: 10,
              ArgumentInfo: 5,
              LocalVariableInfo: 5}