Support keyword aliases about robotframework HOT 4 OPEN

Illustrating some of the downsides of current available constructs:

Function reassignment
Can only be used on discovered keywords. breaks down when using @keyword decorator

def do_action(self):
"""docu for both singular and plural version goes here"""
    pass

do_actions = do_action

Regular expression
Yields an extra unused argument and looks very ugly in libdoc: Shout ${n} cheer${s:s?} for

@keyword("Shout ${n} cheer${s:s?} for")
def hurray(self, n:int, plural_s, person:str):

Redirection
Works, but fully duplicates all docu in libdoc and there is no way to actually know they are aliases other than writing it in the docu.

@keyword("Shout ${n} cheers for")
def hurray(self, n:int, person:str):
    """Cheer them on as much as you like!
    
    Example:
    | `Shout 1 cheer for` | Python |
    | `Shout 3 cheers for` | Robot |
    """

def shout_1_cheer(self, person:str):
    return self.hurray(1, person)
shout_1_cheer.__doc__ = hurray.__doc__

from robotframework.

It's true that creating aliases doesn't work with assignment if the keyword has a name set using the @keyword decorator. If aliases were to be supported in that case, I'd prefer adding a separate aliases=None to @keyword instead of adding a separate @alias decorator.

For some reason I'd prefer a possibility to specify the whole keyword name as a regexp instead of using an alias. We could allow something like regexp=True with the @keyword decorator, but that syntax wouldn't work with user keywords. A more generic solution would be considering names surrounded by forward slashes as regexps like /Shout \d cheers?/. We then needed to decide how to mark arguments. With libraries using normal regexp groups like /Shout (\d) cheers?/ would work, but with user keywords these groups need names and using Robot variables as we do nowadays like /Shout ${n} cheers?/ or /Shout ${n:\d} cheers?/ would probably be better.

from robotframework.

Apart from the regex part described above, maybe there's a possibility to somehow rewrite @keyword decorator in such a way that it might be used multiple times?

It might be easier to use and comprehend I think:

@keyword("Shout ${n} cheers for")
@keyword("Shout ${n} cheer for")
def hurray(self, n:int, person:str):
    """Cheer them on as much as you like!
    
    Example:
    | `Shout 1 cheer for` | Python |
    | `Shout 3 cheers for` | Robot |
    """

One potential issue I see here is the "recursive" character of such decorator that would either call wrapper from wrapper from wrapper or must be implemented as quite weird structure trying to differentiate base function / method from one already decorated.

from robotframework.

Having a regex as keyword specifier is more flexible than an alias, but, as is often the case with higher flexibility, usability can suffer. Before opting for this high degree of flexibility I would like to get clear what the impact will be on things like documentation and auto-completion of keywords.

Potential issues I see so far:

• When regexes are kept in the documentation, the user now needs to understand regexes as well
• Expanding the variants can become a huge list
• Higher risk of missing a variant when doing updates
• Accidentally creating duplicate keywords

from robotframework.