keyword.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 itertools import chain
from operator import attrgetter
 
from robotide.lib.robot.utils import setter
 
from .itemlist import ItemList
from .message import Message, Messages
from .modelobject import ModelObject
from .tags import Tags
 
 
 
class Keyword(ModelObject):
    __slots__ = ['_name', 'doc', 'args', 'assign', 'timeout', 'type',
                 '_sort_key', '_next_child_sort_key']
    KEYWORD_TYPE = 'kw'         #: Normal keyword :attr:`type`.
    SETUP_TYPE = 'setup'        #: Setup :attr:`type`.
    TEARDOWN_TYPE = 'teardown'  #: Teardown :attr:`type`.
    FOR_LOOP_TYPE = 'for'       #: For loop :attr:`type`.
    FOR_ITEM_TYPE = 'foritem'   #: Single for loop iteration :attr:`type`.
    keyword_class = None        #: Internal usage only.
    message_class = Message     #: Internal usage only.
 
    def __init__(self, name='', doc='', args=(), assign=(), tags=(),
                 timeout=None, type=KEYWORD_TYPE):
        self.parentparentparent = None
        self._name_name = name
        self.docdoc = doc
        self.argsargs = args      #: Keyword arguments as a list of strings.
        self.assignassign = assign  #: Assigned variables as a list of strings.
        self.tagstagstags = tags
        self.timeouttimeout = timeout
        #: Keyword type as a string. The value is either :attr:`KEYWORD_TYPE`,
        #: :attr:`SETUP_TYPE`, :attr:`TEARDOWN_TYPE`, :attr:`FOR_LOOP_TYPE` or
        #: :attr:`FOR_ITEM_TYPE` constant defined on the class level.
        self.typetype = type
        self.messagesmessagesmessages = None
        self.keywordskeywordskeywords = None
        self._sort_key_sort_key = -1
        self._next_child_sort_key_next_child_sort_key = 0
 
    @property
    name = property
    
    def name(self):
        return self._name_name
 
    @name.setter
    
    def name(self, name):
        self._name_name = name
 
    @setter
    
    def parent(self, parent):
        if parent and parent is not self.parentparentparent:
            self._sort_key_sort_key = getattr(parent, '_child_sort_key', -1)
        return parent
 
    @property
    _child_sort_key = property
    
    def _child_sort_key(self):
        self._next_child_sort_key_next_child_sort_key += 1
        return self._next_child_sort_key_next_child_sort_key
 
    @setter
    
    def tags(self, tags):
        return Tags(tags)
 
    @setter
    
    def keywords(self, keywords):
        return Keywords(self.keyword_classkeyword_class or self.__class__, self, keywords)
 
    @setter
    
    def messages(self, messages):
        return Messages(self.message_classmessage_class, self, messages)
 
    @property
    
    children = property
    
    def children(self):
        # It would be cleaner to store keywords/messages in same `children`
        # list and turn `keywords` and `messages` to properties that pick items
        # from it. That would require bigger changes to the model, though.
        return sorted(chain(self.keywordskeywordskeywords, self.messagesmessagesmessages),
                      key=attrgetter('_sort_key'))
 
    @property
    
    id = property
    
    def id(self):
        if not self.parentparentparent:
            return 'k1'
        return '%s-k%d' % (self.parentparentparent.id, self.parentparentparent.keywords.index(self)+1)
 
    
    def visit(self, visitor):
        visitor.visit_keyword(self)
 
 
 
class Keywords(ItemList):
    __slots__ = []
 
    def __init__(self, keyword_class=Keyword, parent=None, keywords=None):
        ItemList.__init__(self, keyword_class, {'parent': parent}, keywords)
 
    @property
    
    setup = property
    
    def setup(self):
        return self[0] if (self and self[0].type == 'setup') else None
 
    @setup.setter
    
    def setup(self, kw):
        if kw is not None and kw.type != 'setup':
            raise TypeError("Setup keyword type must be 'setup', "
                            "got '%s'." % kw.type)
        if self.setupsetupsetupsetup is not None:
            self.poppop(0)
        if kw is not None:
            self.insertinsert(0, kw)
 
    @property
    
    teardown = property
    
    def teardown(self):
        return self[-1] if (self and self[-1].type == 'teardown') else None
 
    @teardown.setter
    
    def teardown(self, kw):
        if kw is not None and kw.type != 'teardown':
            raise TypeError("Teardown keyword type must be 'teardown', "
                            "got '%s'." % kw.type)
        if self.teardownteardownteardownteardown is not None:
            self.poppop()
        if kw is not None:
            self.appendappend(kw)
 
    @property
    
    all = property
    
    def all(self):
        return self
 
    @property
    
    normal = property
    
    def normal(self):
        kws = [kw for kw in self if kw.type not in ('setup', 'teardown')]
        return Keywords(self._item_class_item_class, self._common_attrs_common_attrs['parent'], kws)
 
    def __setitem__(self, index, item):
        old = self[index]
        ItemList.__setitem__(self, index, item)
        self[index]._sort_key = old._sort_key