adding make script

.gitignore

@@ -1 +1,2 @@
-*.pyc
+*.pyc
+udep.bat

make.py

@@ -0,0 +1,259 @@
+
+
+# intentions
+# ::pseudo code::
+# get file names
+
+# open & parse
+# check if template; if output should I stop for some random reason
+
+# for templates get input files
+# run and save
+
+
+import chevron
+import os
+from os.path import isfile,islink,isdir
+p=print
+
+class Eobj:pass
+
+C = Eobj
+C.isTemplateStr = '{{{"makestache_template"}}}'
+C.isTemplateStr2 = 'THIS_FILE_IS_A_MAKESTACHE_TEMPLATE'
+C.isNotTemplateStr =  'this_file_is_not_a_makestache_template'
+
+# this string prolly shouldn't appear in any files you wouldn't want to actually overwrite
+C.ALLOW_TEMPLATE_OVERWRITE =  "BUILT_FILE_" + "OVERWRITE_ALLOWED"
+
+
+
+
+
+
+# output_filename # mustache_var
+
+
+p("MAKE.PY")
+p("MAKESTACHE")
+
+def wfile(file_name,out):
+	f = open(file_name,"w")
+	f.write(out)
+	f.close()
+def rfile(file_name):
+	f = open(file_name,"r")
+	ftxt = f.read()
+	f.close()
+	return ftxt
+
+
+# TODO:rename this class
+class JsObj(dict):
+	pass
+	def __init__(self,*a,**kw):
+		super().__init__(*a,**kw)
+		self._template_paths = []
+	def _maybe_path(self,name, *a,**kw):
+		# p("_maybe_path",name)
+		if "*" in name:
+			if name not in self._template_paths:
+				p("possible dependency",name)
+				self._template_paths.append(name)
+	def __getattr__(self, name):
+		# p(">>>>",name,self)
+		return self.__getitem__(name)
+	def __getitem__(self, name):
+		self._maybe_path(name)
+		# p("__getitem__","*" in name,name)
+		ret = super().__getitem__(name)
+		return ret
+	def __setattr__(self, name, val):
+		return self.__setitem__(name, val)
+	def __delattr__(self, name):
+		return self.__delitem__(name)
+
+
+
+# yeah yeah I know where reading the same junk
+def is_template_file(file_name):
+	r={
+	"is_template":0
+	}
+	ftxt = ""
+	try:
+		# ftxt = rfile(file_name)
+		# with open(file_path, "r") as file:
+		with open(file_name, "r") as file:
+			ftxt = file.read()
+			r["is_template"] = is_template_ftxt(ftxt)
+	except Exception as excp:
+		p("\t\\t\tFILE ERR:::",file_name)
+		p("")
+
+	p("LRN",len(ftxt))
+	return r
+
+
+
+def is_template_ftxt(ftxt):
+	ret = 0
+	if C.isTemplateStr in ftxt or C.isTemplateStr2 in ftxt:
+		ret =1
+	if C.isNotTemplateStr in ftxt:
+		ret = 0
+	return ret
+
+
+
+# this should be called render or somthing
+def parse(ftxt):
+	p("PARSE")
+	# o={}
+	_o={
+	}
+
+
+	o=JsObj(_o)
+	out = chevron.render(ftxt,o)
+	# p(out)
+	p("o.idk?")
+	p("~",o._template_paths,"~")
+	mdict = get_calculated_templates(o._template_paths)
+	o2 = {**o,**mdict["file_stache_dict"],
+	"output_filename":mdict["outfile"]["path"],
+	}
+	out2 = chevron.render(ftxt,o2)
+	if C.isTemplateStr in ftxt:
+		p("IS A TEMPLATE!!!!!!!!!!!!!!!!!!!")
+	else:
+		p("IS NOT A TEMPLATE!!!!!!!!!!!!!!!!!!!")
+		p("THE WE WILL NOT write")
+		return ""
+
+	os.chdir(tglob["OUT_DIR"])
+
+	# dbg_out
+	wfile("mgen1.js",out)
+	wfile("mgen2.js",out2)
+	p()
+	if mdict["output_ok"]:
+		p(mdict["outfile"]["_path"])
+		p("WRITING TO:",mdict["outfile"]["path"])
+		wfile(mdict["outfile"]["path"],out2)
+		p("FILE WRITTEN")
+	else:
+		p("BUILD_NOT FINALIZED")
+
+
+
+def get_calculated_templates(arr):
+	# we assume we're in the right dir and don't worry about anything
+	ret = {}
+	file_deps = {}
+	for en in arr:
+		file_content_path = en.replace("@*","",1)
+		file_content_path = file_content_path.replace("*",".")
+		file_deps[en] = {
+		"path":file_content_path,
+		"content":":::__BAD_PATH__::: does the show go on?",
+		}
+
+
+	# now we get our paths
+	file_stache_dict = {}
+	for var_name,file_data in file_deps.items():
+		if ">" in var_name:continue
+		ftxt = rfile(file_data["path"])
+		file_stache_dict[var_name]=ftxt
+		# file_deps[var_name]["content"]=ftxt
+
+
+	# get_out_put_path and set output_ok key
+	for en in (_en for _en in file_deps if (">" in _en or 0)):
+		v = file_deps[en]
+		ret["outfile"]= {
+		"_path":v["path"].split(">")[-1],
+		}
+
+
+	os.chdir(tglob["OUT_DIR"]) 
+	ret["output_ok"]=None
+	current_output_contents=None
+
+
+	assert ret["outfile"]["_path"][0] not in r"\/" , "\033[36m \n\twe won't allow absolute paths that easily\033[0m"
+	full_path = os.path.abspath(ret["outfile"]["_path"])
+	ret["outfile"]["path"] = full_path
+	if os.path.isfile(ret["outfile"]["path"]):
+		current_output_contents = rfile(ret["outfile"]["path"])
+		if C.ALLOW_TEMPLATE_OVERWRITE in current_output_contents:
+			ret["output_ok"]="ALLOW_TEMPLATE_OVERWRITE"
+		else:
+			ret["output_ok"]= False
+
+	else:
+		ret["output_ok"]=1
+	p("current_output_ EXIST?",bool(current_output_contents))
+	p(":ALLOW_TEMPLATE_OVERWRITE??",ret["output_ok"])
+
+
+	return {
+	"file_deps":file_deps,
+	"file_stache_dict":file_stache_dict,
+	**ret
+	}
+
+def parse_possible_template(fn):
+	ftxt = rfile(fn)
+	parse(ftxt)
+
+
+
+def dev_main():
+	p("DEV_MAIN")
+
+	os.chdir(tglob["IN_DIR"])  
+
+	# for en in os.walk(r"C:\ws\repos\script_utils\makestache"):
+	# for en in os.listdir(r"C:\ws\repos\script_utils\makestache"):
+
+	# for now lets skip links you're not really safe im not checking of thinking about junctions or whatever
+
+
+	o = {}
+	# for en in os.scandir(r"C:\ws\repos\script_utils\makestache"):
+	for en in os.scandir():
+		if isfile(en):
+			o[en] = is_template_file(en)
+			p([en],isfile(en))
+			r'''
+			for en2 in dir(en):
+				if en2[:2]=="__":
+					continue
+				p(en2)
+			return
+			# '''
+
+	p("parse_possible_template")
+	p()
+	for k,v in o.items():
+		if not v["is_template"]:continue
+		p(k)
+		p(v)
+		p()
+		parse_possible_template(k)
+# this will prolly be a pain later
+tglob = {
+	# "file_cache":{}
+}
+tglob["OUT_DIR"] = r"C:\ws\repos\script_utils\makestache\test_out"
+tglob["IN_DIR"] = r"C:\ws\repos\script_utils\makestache\test_src"
+tglob["OUT_DIR"] = r"C:\ws\repos\script_utils\makestache\test_src"
+
+
+
+
+
+
+dev_main()

old.make.py

@@ -0,0 +1,38 @@
+import chevron
+
+
+
+files={
+"jsync_dep"  : "jsync_dep.js",
+"jsync_ord"  : "jsync_ord.js",
+"jsync_ws"   : "jsync_ws.js",
+"jsync_sto"  : "jsync_sto.js",
+"jsync_test" : "jsync_test.js",
+"jsync_test2" : "jsync_test2.js",
+"jsync_init" : "jsync_init.js",
+}
+
+def wfile(file_name,out):
+	f = open(file_name,"w")
+	f.write(out)
+	f.close()
+def rfile(file_name):
+	f = open(file_name,"r")
+	ftxt = f.read()
+	f.close()
+	return ftxt
+
+# C:\bspace\repos\jc4\ign4\indx\jsyncdb\jsync_lib_template.js
+def run_now():
+	path = r"C:\bspace\repos\jc4\ign4\indx\jsyncdb" + "\\"
+	files2 = {}
+	for k,v in files.items():
+		ftxt = rfile(path+v)
+		files2[k] = ftxt
+	template = rfile(path+"jsync_lib_template.js")
+	out = chevron.render(template,files2)
+	# wfile("jsync_lib_out.js",out)
+	wfile(path+"jsync_lib.js",out)
+
+# run_now()
+print("This was the old file I used to render the template the new one should keep all (or) most logic in the template")