Grammalecte  Check-in [a80c085797]

#! python3
# coding: UTF-8

import unittest
import os
import re
import time

try:
    import grammalecte.ibdawg as ibdawg
    import grammalecte.fr as gce
    import grammalecte.fr.conj as conj
    import grammalecte.fr.phonet as phonet
    import grammalecte.fr.mfsp as mfsp
    from grammalecte.echo import echo
except ImportError:
    import sys
    sys.path.append(os.path.abspath('.'))
    sys.path.append(os.path.abspath('..'))
    import grammalecte.ibdawg as ibdawg
    import grammalecte.fr as gce
    import grammalecte.fr.conj as conj
    import grammalecte.fr.phonet as phonet
    import grammalecte.fr.mfsp as mfsp
    from grammalecte.echo import echo




def _fuckBackslashUTF8 (s):
    "fuck that shit"
    return s.replace("\u2019", "'").replace("\u2013", "–").replace("\u2014", "—")

    def setUpClass (cls):
        gce.load()
        cls._zError = re.compile(r"\{\{.*?\}\}")
        cls._aRuleTested = set()

    def test_parse (self):
        zOption = re.compile("^__([a-zA-Z0-9]+)__ ")
        bShowUntested = False
        for sf in [ "gc_test.txt" ]:
            with self.subTest(msg=sf):
                with open("./tests/fr/"+sf, "r", encoding="utf-8") as hSrc:
                    for sLine in ( s for s in hSrc if not s.startswith("#") and s.strip() ):
                        sLineNum = sLine[:10].strip()
                        sLine = sLine[10:].strip()
                        sOption = None
                        m = zOption.search(sLine)
                        if m:
                            sLine = sLine[m.end():]
                            sOption = m.group(1)
                        if "->>" in sLine:
                            sErrorText, sExceptedSuggs = self._splitTestLine(sLine)
                            if sExceptedSuggs.startswith('"') and sExceptedSuggs.endswith('"'):
                                sExceptedSuggs = sExceptedSuggs[1:-1]
                        else:
                            sErrorText = sLine.strip()
                            sExceptedSuggs = ""
                        sExpectedErrors = self._getExpectedErrors(sErrorText)
                        sTextToCheck = sErrorText.replace("}}", "").replace("{{", "")
                        sFoundErrors, sListErr, sFoundSuggs = self._getFoundErrors(sTextToCheck, sOption)
                        self.assertEqual(sExpectedErrors, sFoundErrors, \
                                         "\n# Line num: " + sLineNum + \
                                         "\n> to check: " + _fuckBackslashUTF8(sTextToCheck) + \
                                         "\n  expected: " + sExpectedErrors + \
                                         "\n  found:    " + sFoundErrors + \
                                         "\n  errors:   \n" + sListErr)
                        if sExceptedSuggs:
                            self.assertEqual(sExceptedSuggs, sFoundSuggs, "\n# Line num: " + sLineNum + "\n> to check: " + _fuckBackslashUTF8(sTextToCheck) + "\n  errors:   \n" + sListErr)
                bShowUntested = True
        if bShowUntested:
            i = 0
            for sOpt, sLineId, sRuleId in gce.listRules():
                if sLineId not in self._aRuleTested and not re.match("[0-9]+[sp]$", sRuleId):
                    echo(sRuleId, end= ", ")
                    i += 1
            if i:
                echo("\n[{} untested rules]".format(i))

    def _splitTestLine (self, sLine):
        sText, sSugg = sLine.split("->>")
        return (sText.strip(), sSugg.strip())

    def _getFoundErrors (self, sLine, sOption):
        if sOption:

    with open("./tests/fr/perf.txt", "r", encoding="utf-8") as hSrc, \
         open("./tests/fr/perf_memo.txt", "a", encoding="utf-8", newline="\n") as hDst:
        hDst.write("{:<12}{:<20}".format(sVersion, time.strftime("%Y.%m.%d %H:%M")))
        for sText in ( s.strip() for s in hSrc if not s.startswith("#") and s.strip() ):
            with timeblock(sText[:sText.find(".")], hDst):
                aErrs = gce.parse(sText)
        hDst.write("\n")


def main():
    unittest.main()


if __name__ == '__main__':
    main()

    try:
        lRules = open(spLang + "/rules.grx", 'r', encoding="utf-8").readlines()
    except:
        print("Rules file in project [" + sLang + "] not found")
        return
    dVars.update(compile_rules.make(lRules, dVars['lang'], bJavaScript))

    # generating test files
    with open("tests/"+sLang+"/gc_test.txt", "w", encoding="utf-8", newline="\n") as hDstPy:
        hDstPy.write("# TESTS FOR LANG [" + sLang + "]\n\n")
        hDstPy.write(dVars['gctests'])

    ## READ GRAMMAR CHECKER PLUGINS
    print("PYTHON:")
    print("+ Plugins: ", end="")
    sCodePlugins = ""
    for sf in os.listdir(spLang+"/modules"):
        if re.match(r"gce_\w+[.]py$", sf):
            sCodePlugins += "\n\n" + open(spLang+'/modules/'+sf, "r", encoding="utf-8").read()

    print("+ Modules: ", end="")
    for sf in os.listdir(spLang+"/modules"):
        if not sf.endswith(".tpl.py") and not sf.startswith("gce_"):
            file_util.copy_file(spLang+"/modules/"+sf, spLangPack)
            print(sf, end=", ")
    print()






    createOXT(spLang, dVars, xConfig._sections['oxt'], spLangPack, bInstallOXT)

    createServerOptions(sLang, dVars)
    createServerZip(sLang, dVars, spLangPack)

    #### JAVASCRIPT
    if bJavaScript:

            # make
            sVersion = create(sLang, xConfig, xArgs.install, xArgs.javascript, )

            # tests
            if xArgs.tests or xArgs.perf:
                print("> Running tests")
                try:
                    tests = importlib.import_module("tests."+sLang+"_test")
                    print(tests.__file__)
                except ImportError:
                    print("# Error. Couldn't import file {}_test.py in folder tests".format(sLang))
                else:
                    if xArgs.tests:
                        xTestSuite = unittest.TestLoader().loadTestsFromModule(tests)
                        unittest.TextTestRunner().run(xTestSuite)