string_parser.py

#String Building algorithm for the Overwatch Workshop
#
#Heavily inspired by Deltins ParseString algorithm
#https://github.com/ItsDeltin/Overwatch-Script-To-Workshop/blob/91f6d89cae2dda77d40139a589c22077def7654f/Deltinteger/Deltinteger/Elements/Values.cs#L729
#Parts copied are used with permission.

import logging
import re

class StringParser():

    SYMBOLS = "-></*-+=()!?"
    PARAM_REPLACE_RE = re.compile("(\\\\{[0-9]+?\\\\})")
    PARAM_MATCH_RE = re.compile("^\\{([0-9]+?)\\}")
    PARAM_ONLY_RE = re.compile("^\\{([0-9]+?)\\}$")

    logger = logging.getLogger("OS.StringParser")

    def __init__(self, db_file="res/strings.txt"):
        
        self.words = []
        self.us_words = []
        if db_file:
            self.loadWords(db_file)

    def loadWords(self, path):

        """
        Load words from a file.
        """

        with open(path, "r") as f:
            for line in f.readlines():
                if line.startswith("//"):
                    continue
                self.words.append(line.strip("\n").lower())

        self.sort()

    def sort(self):

        """
        Sort the internal list of words after
        certain criteria.
        """

        #Right so I don't have fancy incremental sorting like C# does.
        #What I *can* do is split the list into multiple lists, then merge

        #TODO: temporary fix
        for i in self.words:
            if "_" in i:
                j = i.replace("_", " ")
                self.us_words.append((i, j))

        hasParam = []
        for i in self.words[:]:
            if "{0}" in i:
                hasParam.append(i)
                self.words.remove(i)

        hasParamAndSymbol = []
        for i in hasParam[:]:
            for char in self.SYMBOLS:
                if char in i:
                    hasParamAndSymbol.append(i)
                    hasParam.remove(i)
                    break

        hasSymbol = []
        for i in self.words[:]:
            for char in self.SYMBOLS:
                if char in i:
                    hasSymbol.append(i)
                    self.words.remove(i)
                    break

        #Sorting key function
        def f(x):
            return len(x)

        hasParam.sort(key=f)
        hasParamAndSymbol.sort(key=f)
        hasSymbol.sort(key=f)
        self.words.sort(key=f)

        self.words.extend(hasSymbol)
        self.words.extend(hasParam)
        self.words.extend(hasParamAndSymbol)

        self.words.reverse()

    def parse(self, s, params, depth=0):

        """
        Parse a string into a value understood by OWW.

        s should be an instance of str.
        You can specify parameters inside your string using 
        the {n} syntax. Parameters will be substituted in order
        of occurance.
        If s contains words or phrases not recognized by the parser,
        ValueError is raised.
        If params contains more items than s has parameters, the remaining
        items are silently dropped.
        If params contains less items than s has parameters, TypeError is raised.

        The returned value will be a string consisting of one or multiple calls
        to the String() OWW function.
        """

        final_string = ""

        #TODO: temporary fix
        if not depth:
            for template, phrase in self.us_words:
                s = s.replace(phrase, template)

        #special case for when the string passed to the parse() method
        #is literally just "{n}"
        m = self.PARAM_ONLY_RE.fullmatch(s)
        if m is not None:
            return params[int(m.group(1))]

        for template in self.words:
            temp_re = "^%s$" % re.sub(self.PARAM_REPLACE_RE, "(.+)", re.escape(template))
            self.logger.debug("Testing string template '%s' (-> RE template '%s')..." % (template, temp_re))

            match = re.match(temp_re, s)
            if match is not None:
                try:
                    self.logger.debug("Match found: %s" % template)

                    #TODO: Temporary fix
                    #string_args = ['"%s"' % template]
                    string_args = ['"%s"' % template.replace("_", " ")]
                    #check parameters
                    for group in match.groups():
                        #is parameter formatted?
                        self.logger.debug("Parsing group '%s'..." % group)
                        paramStr = re.fullmatch(self.PARAM_MATCH_RE, group)
                        if paramStr:
                            #substitute parameter
                            try:
                                string_args.append(params[int(paramStr.group(1))])
                            except IndexError:
                                raise TypeError("Not enough arguments to format string.")
                        else:
                            #keep parsing
                            string_args.append(self.parse(group, params))
                
                    string_args.extend(["null"] * (4 - len(string_args)))
                    final_string += "String(%s)" % ", ".join(string_args)

                    break
                except ValueError as e:
                    self.logger.debug("%s. Trying next template..." % str(e))
                    continue

        else:
            raise ValueError("Can't match string '%s': No matching template found." % s)

        return final_string