def testParser(self): p2 = Parser({"START_TAG": r"\[\*", "END_TAG": r"\*\]", "ANYCASE": 1, "PRE_CHOMP": 1, "V1DOLLAR": 1}) # Test new/old styles. s1 = p2.new_style({"TAG_STYLE": "metatext", "PRE_CHOMP": 0, "POST_CHOMP": 1}) self.assert_(s1) self.assertEquals(r"%%", s1["START_TAG"]) self.assertEquals(0, s1["PRE_CHOMP"]) self.assertEquals(1, s1["POST_CHOMP"]) s2 = p2.old_style() self.assert_(s2) self.assertEquals(r"\[\*", s2["START_TAG"]) self.assertEquals(1, s2["PRE_CHOMP"]) self.assertEquals(0, s2["POST_CHOMP"]) p3 = Config.parser( {"TAG_STYLE": "html", "POST_CHOMP": 1, "ANYCASE": 1, "INTERPOLATE": 1}) p4 = Config.parser({"ANYCASE": 0}) tt = (("tt1", Template({"ANYCASE": 1})), ("tt2", Template({"PARSER": p2})), ("tt3", Template({"PARSER": p3})), ("tt4", Template({"PARSER": p4}))) replace = self._callsign() replace["alist"] = ["foo", 0, "bar", 0] replace["wintxt"] = "foo\r\n\r\nbar\r\n\r\nbaz" self.Expect(DATA, tt, replace)
def testPrefix(self): src_prov = Config.provider({"INCLUDE_PATH": "test/src"}) lib_prov = Config.provider({"INCLUDE_PATH": "test/lib"}) config = { "LOAD_TEMPLATES": [src_prov, lib_prov], "PREFIX_MAP": { "src": "0", "lib": "1", "all": "0, 1" } } self.Expect(DATA, config)
def _compile(self, data, compfile=None): """Private method called to parse the template text and compile it into a runtime form. Creates and delegates a template.parser.Parser object to handle the compilation, or uses the object passed in PARSER. On success, the compiled template is stored in the 'data' attribute of the 'data' object and returned. On error, an exception is raised, or None is returned if the TOLERANT flag is set. The optional 'compiled' parameter may be passed to specify the name of a compiled template file to which the generated Python code should be written. Errors are (for now...) silently ignored, assuming that failures to open a file for writing are intentional (e.g directory write permission). """ if data is None: return None text = data.text error = None if not self.__parser: self.__parser = Config.parser(self.__params) # discard the template text - we don't need it any more # del data.text parsedoc = self.__parser.parse(text, data) parsedoc["METADATA"].setdefault("name", data.name) parsedoc["METADATA"].setdefault("modtime", data.time) # write the Python code to the file compfile, if defined if compfile: basedir = os.path.dirname(compfile) if not os.path.isdir(basedir): try: os.makedirs(basedir) except IOError as e: error = Error("failed to create compiled templates " "directory: %s (%s)" % (basedir, e)) if not error: try: self.__document.write_python_file(compfile, parsedoc) except Exception as e: error = Error("cache failed to write %s: %s" % (os.path.basename(compfile), e)) if error is None and data.time is not None: if not compfile: raise Error("invalid null filename") ctime = int(data.time) os.utime(compfile, (ctime, ctime)) if not error: data.data = Document(parsedoc) return data if self.__tolerant: return None else: raise error
def __init__(self, config=None): config = config or {} # Prepare a namespace handler for any CONSTANTS definition. constants = config.get("CONSTANTS") if constants: namespace = config.get("CONSTANTS_NAMESPACE", "constants") config.setdefault("NAMESPACE", {})[namespace] = ( Config.constants(constants)) self.__service = Service(config) self.__output = config.get("OUTPUT") self.__output_path = config.get("OUTPUT_PATH")
def __init__(self, config=None): config = config or {} # Prepare a namespace handler for any CONSTANTS definition. constants = config.get("CONSTANTS") if constants: namespace = config.get("CONSTANTS_NAMESPACE", "constants") config.setdefault("NAMESPACE", {})[namespace] = (Config.constants(constants)) self.__service = Service(config) self.__output = config.get("OUTPUT") self.__output_path = config.get("OUTPUT_PATH")
def testParser(self): p2 = Parser({ "START_TAG": r"\[\*", "END_TAG": r"\*\]", "ANYCASE": 1, "PRE_CHOMP": 1, "V1DOLLAR": 1 }) # Test new/old styles. s1 = p2.new_style({ "TAG_STYLE": "metatext", "PRE_CHOMP": 0, "POST_CHOMP": 1 }) self.assert_(s1) self.assertEquals(r"%%", s1["START_TAG"]) self.assertEquals(0, s1["PRE_CHOMP"]) self.assertEquals(1, s1["POST_CHOMP"]) s2 = p2.old_style() self.assert_(s2) self.assertEquals(r"\[\*", s2["START_TAG"]) self.assertEquals(1, s2["PRE_CHOMP"]) self.assertEquals(0, s2["POST_CHOMP"]) p3 = Config.parser({ "TAG_STYLE": "html", "POST_CHOMP": 1, "ANYCASE": 1, "INTERPOLATE": 1 }) p4 = Config.parser({"ANYCASE": 0}) tt = (("tt1", Template({"ANYCASE": 1})), ("tt2", Template({"PARSER": p2})), ("tt3", Template({"PARSER": p3})), ("tt4", Template({"PARSER": p4}))) replace = self._callsign() replace["alist"] = ["foo", 0, "bar", 0] replace["wintxt"] = "foo\r\n\r\nbar\r\n\r\nbaz" self.Expect(DATA, tt, replace)
def _compile(self, data, compfile=None): """Private method called to parse the template text and compile it into a runtime form. Creates and delegates a template.parser.Parser object to handle the compilation, or uses the object passed in PARSER. On success, the compiled template is stored in the 'data' attribute of the 'data' object and returned. On error, an exception is raised, or None is returned if the TOLERANT flag is set. The optional 'compiled' parameter may be passed to specify the name of a compiled template file to which the generated Python code should be written. Errors are (for now...) silently ignored, assuming that failures to open a file for writing are intentional (e.g directory write permission). """ if data is None: return None text = data.text error = None if not self.__parser: self.__parser = Config.parser(self.__params) # discard the template text - we don't need it any more # del data.text parsedoc = self.__parser.parse(text, data) parsedoc["METADATA"].setdefault("name", data.name) parsedoc["METADATA"].setdefault("modtime", data.time) # write the Python code to the file compfile, if defined if compfile: basedir = os.path.dirname(compfile) if not os.path.isdir(basedir): try: os.makedirs(basedir) except IOError, e: error = Error("failed to create compiled templates " "directory: %s (%s)" % (basedir, e)) if not error: try: self.__document.write_python_file(compfile, parsedoc) except Exception, e: error = Error("cache failed to write %s: %s" % ( os.path.basename(compfile), e))
def __init__(self, config=None): config = config or {} delim = config.get("DELIMITER", ":") # coerce PRE_PROCESS, PROCESS, and POST_PROCESS to lists if necessary, # by splitting on non-word characters self.__preprocess = Split(config.get("PRE_PROCESS"), delim) self.__process = Split(config.get("PROCESS"), delim) self.__postprocess = Split(config.get("POST_PROCESS"), delim) self.__wrapper = Split(config.get("WRAPPER"), delim) # unset PROCESS option unless explicitly specified in config if config.get("PROCESS") is None: self.__process = None self.__error = config.get("ERROR") or config.get("ERRORS") self.__autoreset = config.get("AUTO_RESET") is None or \ config.get("AUTO_RESET") self.__debug = config.get("DEBUG", 0) & DEBUG_SERVICE self.__context = config.get("CONTEXT") or Config.context(config) if not self.__context: raise TemplateException()
def testProvider(self): dir = "test/src" lib = "test/lib" file = "foo" relfile = os.path.join(".", dir, file) absfile = os.path.join(os.path.abspath(dir), file) newfile = os.path.join(dir, "foobar") def update_file(*args): time.sleep(2) # ensure file time stamps are different f = open(newfile, "w") for arg in args: f.write(str(arg)) f.close() vars = { "file": file, "relfile": relfile, "absfile": absfile, "fixfile": update_file } update_file("This is the old content") #------------------------------------------------------------------------ # instantiate a bunch of providers, using various different techniques, # with different load options but sharing the same parser; then set them # to work fetching some files and check they respond as expected #------------------------------------------------------------------------ parser = Config.parser({"POST_CHOMP": 1}) provinc = Config.provider({ "INCLUDE_PATH": dir, "PARSER": parser, "TOLERANT": 1 }) provabs = Config.provider({"ABSOLUTE": 1, "PARSER": parser}) provrel = Config.provider({"RELATIVE": 1, "PARSER": parser}) self.assertTrue(provinc.parser() is provabs.parser()) self.assertTrue(provabs.parser() is provrel.parser()) self.assertTrue(delivered(provinc, file)) self.assertTrue(declined(provinc, absfile)) self.assertTrue(declined(provinc, relfile)) self.assertTrue(declined(provabs, file)) self.assertTrue(delivered(provabs, absfile)) self.assertTrue(denied(provabs, relfile)) self.assertTrue(declined(provrel, file)) self.assertTrue(denied(provrel, absfile)) self.assertTrue(delivered(provrel, relfile)) # Test if can fetch from a file handle. ttfile = Template() path = os.path.join(os.path.abspath(dir), "baz") file = open(path) outstr = ttfile.process(file, {"a": "filetest"}) file.close() self.assertEqual("This is the baz file, a: filetest\n", outstr) #------------------------------------------------------------------------ # now we'll fold those providers up into some Template objects that # we can pass to text_expect() to do some template driven testing #------------------------------------------------------------------------ ttinc = Template({"LOAD_TEMPLATES": [provinc]}) ttabs = Template({"LOAD_TEMPLATES": [provabs]}) ttrel = Template({"LOAD_TEMPLATES": [provrel]}) def dpaths(): return [os.path.join(lib, x) for x in ["one", "two"]] def badpaths(): return [badpaths] ttd1 = Template({"INCLUDE_PATH": [dpaths, dir], "PARSER": parser}) ttd2 = Template({ "INCLUDE_PATH": [ DynamicPaths(os.path.join(lib, "two"), os.path.join(lib, "one")), dir ], "PARSER": parser }) ttd3 = Template({"INCLUDE_PATH": [badpaths], "PARSER": parser}) uselist = (("ttinc", ttinc), ("ttabs", ttabs), ("ttrel", ttrel), ("ttd1", ttd1), ("ttd2", ttd2), ("ttdbad", ttd3)) self.Expect(DATA, uselist, vars)
def Create(expr): expr = unscalar(expr) if isinstance(expr, Iterator): return expr else: return Config.iterator(expr)
def __init__(self, config): self.__stash = Config.stash(config)
def testProvider(self): dir = "test/src" lib = "test/lib" file = "foo" relfile = os.path.join(".", dir, file) absfile = os.path.join(os.path.abspath(dir), file) newfile = os.path.join(dir, "foobar") def update_file(*args): time.sleep(2) # ensure file time stamps are different f = open(newfile, "w") for arg in args: f.write(str(arg)) f.close() vars = { "file": file, "relfile": relfile, "absfile": absfile, "fixfile": update_file } update_file("This is the old content") #------------------------------------------------------------------------ # instantiate a bunch of providers, using various different techniques, # with different load options but sharing the same parser; then set them # to work fetching some files and check they respond as expected #------------------------------------------------------------------------ parser = Config.parser({"POST_CHOMP": 1}) provinc = Config.provider({ "INCLUDE_PATH": dir, "PARSER": parser, "TOLERANT": 1 }) provabs = Config.provider({ "ABSOLUTE": 1, "PARSER": parser }) provrel = Config.provider({ "RELATIVE": 1, "PARSER": parser }) self.assert_(provinc.parser() is provabs.parser()) self.assert_(provabs.parser() is provrel.parser()) self.assert_(delivered(provinc, file)) self.assert_(declined(provinc, absfile)) self.assert_(declined(provinc, relfile)) self.assert_(declined(provabs, file)) self.assert_(delivered(provabs, absfile)) self.assert_(denied(provabs, relfile)) self.assert_(declined(provrel, file)) self.assert_(denied(provrel, absfile)) self.assert_(delivered(provrel, relfile)) # Test if can fetch from a file handle. ttfile = Template() path = os.path.join(os.path.abspath(dir), "baz") file = open(path) outstr = ttfile.process(file, { "a": "filetest" }) file.close() self.assertEquals("This is the baz file, a: filetest\n", outstr) #------------------------------------------------------------------------ # now we'll fold those providers up into some Template objects that # we can pass to text_expect() to do some template driven testing #------------------------------------------------------------------------ ttinc = Template({ "LOAD_TEMPLATES": [provinc] }) ttabs = Template({ "LOAD_TEMPLATES": [provabs] }) ttrel = Template({ "LOAD_TEMPLATES": [provrel] }) def dpaths(): return [os.path.join(lib, x) for x in "one", "two"] def badpaths(): return [badpaths] ttd1 = Template({ "INCLUDE_PATH": [dpaths, dir], "PARSER": parser }) ttd2 = Template( { "INCLUDE_PATH": [DynamicPaths(os.path.join(lib, "two"), os.path.join(lib, "one")), dir], "PARSER": parser }) ttd3 = Template({ "INCLUDE_PATH": [ badpaths ], "PARSER": parser }) uselist = (("ttinc", ttinc), ("ttabs", ttabs), ("ttrel", ttrel), ("ttd1", ttd1), ("ttd2", ttd2), ("ttdbad", ttd3)) self.Expect(DATA, uselist, vars)
def testPrefix(self): src_prov = Config.provider({ "INCLUDE_PATH": "test/src" }) lib_prov = Config.provider({ "INCLUDE_PATH": "test/lib" }) config = { "LOAD_TEMPLATES": [ src_prov, lib_prov ], "PREFIX_MAP": { "src": "0", "lib": "1", "all": "0, 1" } } self.Expect(DATA, config)