def link_info(link, l10n_data, ui_l10n_data, language):
name = link["name"]
a = {}
link["uri"] = invoke_plugins("link_pre_uri_convert", link["uri"], link,
l10n_data, ui_l10n_data, language)
a["href"] = uri_to_src(link["uri"])
icon = '<i class="fas fa-external-link-alt fa-fw"></i>'
if name[0] == '.':
if name[1:] in icons:
icon = icons[name[1:]]
a["content"] = ui_l10n_data["stock-link-" + name[1:]]
else:
l10n_name = l10n_data.get(language, {}).get("links-tr", {}).get(name)
if l10n_name is not None:
a["content"] = l10n_name
else:
a["content"] = name
if "icon" in link:
icon = icons[link["icon"]]
a["content"] = icon + "<span>" + a["content"] + "</span>"
if "rel" in link:
a["rel"] = link["rel"]
invoke_plugins("link_post_process", a, link, l10n_data, ui_l10n_data,
language)
return a
def local_res_href(rr, path, hc_uquery=None):
query = ""
if hc_uquery:
query = f"?hc=uquery&t={hc_uquery}"
mod = invoke_plugins("html_local_res_href",
None,
rr=rr,
path=path,
hc_uquery=hc_uquery)
if mod:
mod_value = mod["new_uri"]
if "query_mode" in mod:
if mod["query_mode"] == "unmanaged":
mod_value = mod_value + query
elif mod["query_mode"] == "origin-first":
if query != "":
mod_value = mod_value + query
else:
mod_value = mod_value + mod["query_fb"]
elif mod["query_mode"] == "managed":
pass
else:
raise ValueError(f"unkown query_mode: {mode['query_mode']}")
return mod_value
else:
return rr + path + query
def get_languages_list(dbdir):
ll = [f for f in os.listdir(os.path.join(dbdir, "l10n"))]
ll.append("en")
# FIXME: uncompleted languages is blacklisted
if not args.args.next:
ll.remove("ja")
ll = invoke_plugins("i18n_post_ll_done", ll)
return ll
def uil10n_load_base(l10ndir):
base_l10n = None
with open(os.path.join(l10ndir, "en.yaml")) as stream:
base_l10n = yaml.safe_load(stream)
keywords.preprocess_keywords(base_l10n)
if args.args.extra_ui is not None:
with open(os.path.join(args.args.extra_ui, "en.yaml")) as stream:
base_l10n.update(yaml.safe_load(stream))
base_l10n = invoke_plugins("i18n_post_load_uil10n_base_data", base_l10n)
return base_l10n
def ui10n_load_language(l10ndir, base_l10n, language):
ui = None
with open(os.path.join(l10ndir, language + ".yaml")) as stream:
ui = base_l10n.copy()
ui.update(yaml.safe_load(stream))
keywords.preprocess_keywords(ui)
puifn = os.path.join(l10ndir, language + "_PRIVATE.yaml")
if os.path.isfile(puifn):
with open(puifn) as stream:
ui.update(yaml.safe_load(stream))
if args.args.extra_ui is not None:
euifn = os.path.join(args.args.extra_ui, language + ".yaml")
if os.path.isfile(euifn):
with open(euifn) as stream:
ui.update(yaml.safe_load(stream))
ui = invoke_plugins("i18n_post_load_uil10n_language_data", ui, language=language, base_l10n=base_l10n)
return ui
def main(argv):
argv = argv[1:]
parse(argv)
from fgi.args import args
dbdir = "games"
output = args.output
sitemap.ignore = args.no_sitemap
renderer_files = list_pymod("renderers")
renderer_nonl10n_files = list_pymod(os.path.join("renderers", "nonl10n"))
with open("tag-dependencies.yaml") as f:
tagmgr.loaddep(yaml.safe_load(f))
with open("tags.yaml") as f:
tagmgr.load(yaml.safe_load(f))
sdb = searchdb(no_data=args.no_searchdb)
sdb.add_extra_data("tagalias", tagmgr.tagalias)
sdb.add_extra_data("tagns", tagmgr.tagns)
if os.path.exists(output) and not args.no_purge_prev_builds:
shutil.rmtree(output)
dir_util._path_created = {}
dir_util.copy_tree("webroot", output)
dir_util.copy_tree("assets", os.path.join(output, "assets"))
games = load_game_all(dbdir, sdb)
env = Environment(loader=FileSystemLoader("templates"))
sdb.write_to_file(output)
languages = get_languages_list(dbdir)
base_l10n = uil10n_load_base("uil10n")
lctx = {
"args": args,
"searchdb": sdb,
"os": os,
"webrootdir": "webroot",
"time": time,
"res": local_res_href,
}
for language in languages:
ui = ui10n_load_language("uil10n", base_l10n, language)
Path(os.path.join(output, language, "games")).mkdir(parents=True,
exist_ok=True)
lctx["lang"] = language
lctx["ui"] = ui
for f in renderer_files:
print("Rendering %s %s" % (language, f))
renderer = importlib.import_module(".renderers." + f,
package=__package__)
renderer.render(games, env, lctx, output)
lctx["ui"] = base_l10n
for f in renderer_nonl10n_files:
print(f"Rendering nonl10n {f}")
renderer = importlib.import_module(".renderers.nonl10n." + f,
package=__package__)
renderer.render(games, env, lctx, output)
sitemap.write_to_file(output)
invoke_plugins("post_build", None, output_path=output)
with open(os.path.join(output, "_buildinfo.txt"), "w") as f:
f.write("# FGI BUILD INFO START\n")
f.write(
f"base revision: {run_cmd(['git', 'rev-parse', 'HEAD'], failback='unknown')}\n"
)
f.write(f"options: {' '.join(argv[:-1])}\n")
f.write(f"build datetime: {datetime.utcnow()}\n")
f.write(f"builder: {getpass.getuser()}@{platform.uname()[1]}\n")
f.write("interpreter: ")
f.write(sys.version.replace("\n", " "))
f.write("\n")
f.write(f"jinja2 version: {jinja2.__version__}\n")
f.write(f"pyyaml version: {yaml.__version__}\n")
f.write(f"markdown2 version: {markdown2.__version__}\n")
f.write(
f"webp utils version: {run_cmd(['cwebp', '-version'], failback='unknown')}\n"
)
f.write("# ADDITIONAL PATCHES\n")
if os.path.exists(".patches_info"):
with open(".patches_info") as pi:
f.write(pi.read())
f.write("# FGI BUILD INFO END\n")
def uri_to_html_image(rr, imageuri, gameid, alt=None):
image = Image(imageuri)
if image.is_remote:
if args.args.download_external_images:
sum = hashlib.sha1(image.uri.encode("utf-8")).hexdigest()
path = "assets/" + gameid + "/" + sum + os.path.splitext(
image.uri)[1]
image.path = os.path.join(args.args.output, path)
if not os.path.isfile(image.path):
if args.args.use_external_images_cache is not None:
cached_image = os.path.join(
args.args.use_external_images_cache, path)
if os.path.isfile(cached_image):
copyfile(cached_image, image.path)
else:
print("cache missing, downloading %s %s" %
(sum, image.uri))
dl(image.uri, image.path)
else:
print("downloading %s %s" % (sum, image.uri))
dl(image.uri, os.path.join(args.args.output, path))
image.is_remote = False
image.uri = rr + "/" + path
else:
path = "assets/" + gameid + "/" + image.uri
image.path = os.path.join(args.args.output, path)
image.uri = rr + "/" + path
path = image.path
if args.args.images_to_webp \
and not image.is_remote \
and webp.can_convert(path):
image.uri += ".webp"
image.path += ".webp"
if os.path.exists(path):
if not os.path.exists(image.path):
try:
webp.cwebp(path, image.path)
except:
print(f"[warning] {path} can not be converted to webp")
os.remove(path)
hi = HTMLImage.from_image(image)
hi.alt = alt
if args.args.images_candidate_webp \
and not image.is_remote \
and webp.can_convert(path) \
and os.path.exists(path):
webpfn = image.path + ".webp"
if not os.path.exists(webpfn):
webp.cwebp(path, webpfn)
wpi = Image(image.uri + ".webp")
wpi.path = webpfn
hi.add_source(wpi, "image/webp", False)
invoke_plugins("image_post_html_image_done",
hi,
origin_uri=imageuri,
gameid=gameid,
alt=alt)
return hi