Esempio n. 1
0
def test_SyntaxFactory_index_definitions():
    from editxt.valuetrans import SyntaxDefTransformer
    class FakeDef(object):
        def __init__(self, name):
            self.name = name
        def __repr__(self):
            return "<%s %x>" % (self.name, id(self))
    text1 = FakeDef("Plain Text")
    text2 = FakeDef("Plain Text")
    python = FakeDef("Python")
    sf = SyntaxFactory()
    sf.registry = {
        "*.txt": text1,
        "*.text": text2,
        "*.txtx": text1,
        "*.py": python,
    }
    defs = sorted([text1, text2, python], key=lambda d:(d.name, id(d)))
    m = Mocker()
    vt = m.replace(NSValueTransformer, passthrough=False)
    st = vt.valueTransformerForName_("SyntaxDefTransformer") >> \
        m.mock(SyntaxDefTransformer)
    st.update_definitions(defs)
    with m:
        sf.index_definitions()
    eq_(sf.definitions, defs)
Esempio n. 2
0
def test_SyntaxFactory_index_definitions():
    from editxt.valuetrans import SyntaxDefTransformer
    class FakeDef(object):
        def __init__(self, name):
            self.name = name
        def __repr__(self):
            return "<%s %x>" % (self.name, id(self))
    text1 = FakeDef("Plain Text")
    text2 = FakeDef("Plain Text")
    python = FakeDef("Python")
    sf = SyntaxFactory()
    sf.registry = {
        "*.txt": text1,
        "*.text": text2,
        "*.txtx": text1,
        "*.py": python,
    }
    defs = sorted([text1, text2, python], key=lambda d:(d.name, id(d)))
    m = Mocker()
    vt = m.replace(mod, 'NSValueTransformer')
    st = vt.valueTransformerForName_("SyntaxDefTransformer") >> \
        m.mock(SyntaxDefTransformer)
    st.update_definitions(defs)
    with m:
        sf.index_definitions()
    eq_(sf.definitions, defs)
Esempio n. 3
0
    def test(c):
        m = Mocker()
        sf = SyntaxFactory()
        log = m.replace("editxt.syntax.log", passthrough=False)
        glob = m.replace("glob.glob", passthrough=False)
        exists = m.replace("os.path.exists", passthrough=False)
        load = sf.load_definition = m.mock()
        if c.path and exists(c.path) >> c.exists:
            info = {
                "disabled": dict(name="dis", disabled=True, filepatterns=[]), # should cause info log

                # these should cause error log
                "incomplete1": {},
                "incomplete2": dict(name="none"),
                "incomplete3": dict(filepatterns=[]),

                # should only register twice despite duplication
                "python": dict(name="python", filepatterns=["*.py", "*.py", "*.pyw"]),

                "sql": dict(name="sequel", filepatterns=["*.sql"]),
                "text": dict(name="text", filepatterns=["*.txt"]),
                "text2": dict(name="text", filepatterns=["*.txt", "*.text"]),
                "text3": dict(name="text", disabled=True, filepatterns=["*.txt", "*.text"]),
            }
            glob(os.path.join(c.path, "*" + const.SYNTAX_DEF_EXTENSION)) >> sorted(info)
            def do(name):
                data = dict(info[name])
                if name.startswith("incomplete"):
                    raise Exception("incomplete definition: %r" % (data,))
                data.setdefault("disabled", False)
                if "filepatterns" in data:
                    data["filepatterns"] = set(data["filepatterns"])
                return type("sdef", (object,), data)()
            expect(load(ANY)).count(len(info)).call(do)
            for fname, data in sorted(info.iteritems()):
                if fname.startswith("incomplete"):
                    log.error(ANY, fname, exc_info=True)
                else:
                    pats = ", ".join(sorted(set(data.get("filepatterns", []))))
                    stat = [data["name"], "[%s]" % pats]
                    if fname in ("text", "text2", "text4"):
                        stat.extend(["overrides", "*.txt"])
                    elif fname in ("disabled", "text3"):
                        stat.append("DISABLED")
                    stat.append(fname)
                    log.info(ANY, " ".join(stat))
            patterns = set(["*.py", "*.pyw", "*.sql", "*.text", "*.txt"])
        else:
            patterns = set(["*.txt"])
        with m:
            sf.load_definitions(c.path)
            eq_(set(sf.registry), patterns)
Esempio n. 4
0
    def test(c):
        m = Mocker()
        sf = SyntaxFactory()
        log = m.replace("editxt.syntax.log")
        glob = m.replace("glob.glob")
        exists = m.replace("os.path.exists")
        load = sf.load_definition = m.mock()
        if c.path and exists(c.path) >> c.exists:
            info = {
                "disabled": dict(name="dis", disabled=True, filepatterns=[]), # should cause info log

                # these should cause error log
                "incomplete1": {},
                "incomplete2": dict(name="none"),
                "incomplete3": dict(filepatterns=[]),

                # should only register twice despite duplication
                "python": dict(name="python", filepatterns=["*.py", "*.py", "*.pyw"]),

                "sql": dict(name="sequel", filepatterns=["*.sql"]),
                "text": dict(name="text", filepatterns=["*.txt"]),
                "text2": dict(name="text", filepatterns=["*.txt", "*.text"]),
                "text3": dict(name="text", disabled=True, filepatterns=["*.txt", "*.text"]),
            }
            glob(os.path.join(c.path, "*" + const.SYNTAX_DEF_EXTENSION)) >> sorted(info)
            def do(name):
                data = dict(info[name])
                if name.startswith("incomplete"):
                    raise Exception("incomplete definition: %r" % (data,))
                data.setdefault("disabled", False)
                if "filepatterns" in data:
                    data["filepatterns"] = set(data["filepatterns"])
                return type("sdef", (object,), data)()
            expect(load(ANY)).count(len(info)).call(do)
            for fname, data in sorted(info.items()):
                if fname.startswith("incomplete"):
                    log.error(ANY, fname, exc_info=True)
                else:
                    pats = ", ".join(sorted(set(data.get("filepatterns", []))))
                    stat = [data["name"], "[%s]" % pats]
                    if fname in ("text", "text2", "text4"):
                        stat.extend(["overrides", "*.txt"])
                    elif fname in ("disabled", "text3"):
                        stat.append("DISABLED")
                    stat.append(fname)
                    log.info(ANY, " ".join(stat))
            patterns = set(["*.py", "*.pyw", "*.sql", "*.text", "*.txt"])
        else:
            patterns = set(["*.txt"])
        with m:
            sf.load_definitions(c.path)
            eq_(set(sf.registry), patterns)
Esempio n. 5
0
def test_init_syntax_definitions():
    import editxt.syntax as syntax
    m = Mocker()
    app = Application(profile='/editxtdev')
    rsrc_path = m.method(app.resource_path)() >> "/tmp/resources"
    SyntaxFactory = m.replace(syntax, 'SyntaxFactory', spec=False)
    sf = SyntaxFactory() >> m.mock(syntax.SyntaxFactory)
    app_log = m.replace("editxt.application.log")
    for path, info in [(rsrc_path, False), ('/editxtdev', True)]:
        sf.load_definitions(join(path, const.SYNTAX_DEFS_DIR), info)
    sf.index_definitions()
    with m:
        app.init_syntax_definitions()
Esempio n. 6
0
def get_syntax_definition(name, cache={}):
    if isinstance(name, NoHighlight):
        return name
    try:
        return cache[name].get(name)
    except KeyError:
        pass
    from os.path import abspath, dirname, join

    root = dirname(dirname(dirname(abspath(__file__))))
    loader = SyntaxFactory()
    loader.load_definitions(join(root, "resources/syntax"), False)
    cache[name] = loader
    return loader.get(name)
Esempio n. 7
0
 def test(c):
     with tempdir() as tmp:
         sf = SyntaxFactory()
         filename = os.path.join(tmp, "file")
         with open(filename, "w", encoding="utf-8") as fh:
             if c.error is not Exception:
                 fh.write("\n".join("{} = {!r}".format(k, v) for k, v in c.info.items()))
             else:
                 fh.write("raise {}".format(c.error.__name__))
         values = dict(defaults)
         values.update(c.info)
         if c.error is None:
             res = sf.load_definition(filename)
             for name, value in values.items():
                 eq_(getattr(res, name), value, name)
         else:
             assert_raises(c.error, sf.load_definition, filename)
Esempio n. 8
0
 def init_syntax_definitions(self):
     from editxt.syntax import SyntaxFactory
     self.syntax_factory = sf = SyntaxFactory()
     paths = [(self.resource_path(), False), (self.profile_path, True)]
     for path, log_info in paths:
         path = os.path.join(path, const.SYNTAX_DEFS_DIR)
         sf.load_definitions(path, log_info)
     sf.index_definitions()
Esempio n. 9
0
 def test(c):
     with tempdir() as tmp:
         sf = SyntaxFactory()
         filename = os.path.join(tmp, "file")
         with open(filename, "w", encoding="utf-8") as fh:
             if c.error is not Exception:
                 fh.write("\n".join("{} = {!r}".format(k, v)
                     for k, v in c.info.items()))
             else:
                 fh.write("raise {}".format(c.error.__name__))
         values = dict(defaults)
         values.update(c.info)
         if c.error is None:
             res = sf.load_definition(filename)
             for name, value in values.items():
                 if name == "filepatterns":
                     value = set(value)
                 eq_(getattr(res, name), value, name)
         else:
             assert_raises(c.error, sf.load_definition, filename)
Esempio n. 10
0
 def test(c):
     m = Mocker()
     sf = SyntaxFactory()
     execf = m.replace(execfile, passthrough=False)
     def do(filename, ns):
         ns.update(__builtins__="__builtins__")
         return ns.update(c.info)
     if c.error is not Exception:
         expect(execf("<filename>", ANY)).call(do)
     else:
         expect(execf("<filename>", ANY)).throw(c.error)
     values = dict(defaults)
     values.update(c.info)
     with m:
         if c.error is None:
             res = sf.load_definition("<filename>")
             for name, value in values.iteritems():
                 if name == "filepatterns":
                     value = set(value)
                 eq_(getattr(res, name), value, name)
         else:
             assert_raises(c.error, sf.load_definition, "<filename>")
Esempio n. 11
0
def test_init_syntax_definitions():
    import editxt.syntax as syntax
    m = Mocker()
    app = Application(profile='/editxtdev')
    rsrc_path = m.method(app.resource_path)() >> "/tmp/resources"
    SyntaxFactory = m.replace(syntax, 'SyntaxFactory', spec=False)
    sf = SyntaxFactory() >> m.mock(syntax.SyntaxFactory)
    app_log = m.replace("editxt.application.log")
    for path, info in [(rsrc_path, False), ('/editxtdev', True)]:
        sf.load_definitions(os.path.join(path, const.SYNTAX_DEFS_DIR), info)
    sf.index_definitions()
    with m:
        app.init_syntax_definitions()
Esempio n. 12
0
def test_SyntaxFactory_get_definition():
    sf = SyntaxFactory()
    sf.registry["*.txt"] = "<syntax def>"
    eq_(sf.get_definition("somefile.txt"), "<syntax def>")
    eq_(sf.get_definition("somefile.text"), PLAIN_TEXT)
Esempio n. 13
0
def test_SyntaxFactory_init():
    sf = SyntaxFactory()
    eq_(sf.registry, {"*.txt": PLAIN_TEXT})
    eq_(sf.definitions, [PLAIN_TEXT])
Esempio n. 14
0
def test_SyntaxFactory_get_definition():
    sf = SyntaxFactory()
    sf.registry["*.txt"] = "<syntax def>"
    eq_(sf.get_definition("somefile.txt"), "<syntax def>")
    eq_(sf.get_definition("somefile.text"), PLAIN_TEXT)