@Test
public void Bidi() {
fxt.Init_ttl("A" + String_.new_u8(Bry_.ints_(226, 128, 142)) + "B").Expd_page_txt("AB").Test();
fxt.Init_ttl("A" + String_.new_u8(Bry_.ints_(226, 128, 97)) + "B")
.Expd_page_txt("A" + String_.new_u8(Bry_.ints_(226, 128, 97)) + "B")
.Test();
}
public Mustache_doc_itm[] Mustache__subs(String key) {
if (String_.Eq(key, "is_dir")) return Mustache_doc_itm_.Ary__bool(is_dir);
else if (String_.Eq(key, "dir_cmd_exists"))
return Mustache_doc_itm_.Ary__bool(Bry_.Len_gt_0(dir_cmd));
else if (String_.Eq(key, "is_core_xowa")) return Mustache_doc_itm_.Ary__bool(is_core_xowa);
else if (String_.Eq(key, "subs")) return subs;
return Mustache_doc_itm_.Ary__empty;
}
public boolean Chk(Xowe_wiki wiki) {
if (!wiki.App().App_type().Uid_is_gui())
return true; // NOTE: ignore during Server / Console modes; DATE:2015-04-01
if (in_progress_hash.Has(wiki.Domain_bry()))
return true; // NOTE: ignore if currently building; different bldr commands call
// wiki.Init_assert() which may lead to fals checks;
Io_url url = url_(wiki);
if (!Io_mgr.I.ExistsFil(url)) return true;
Xoae_app app = wiki.Appe();
app.Usr_dlg().Log_many("", "", "import.marker: marker found: url=~{0}", url.Raw());
byte[] incompete_msg_bry =
app.Usere()
.Msg_mgr()
.Val_by_key_args(Bry_.new_a7("api-xowa.import.core.incomplete"), wiki.Domain_str());
int rslt = app.Gui_mgr().Kit().Ask_yes_no_cancel("", "", String_.new_u8(incompete_msg_bry));
switch (rslt) {
case Gfui_dlg_msg_.Btn_yes:
Xob_cleanup_cmd.Delete_wiki_sql(wiki);
End(wiki);
return false; // delete wiki
case Gfui_dlg_msg_.Btn_no:
End(wiki);
return true; // delete marker
case Gfui_dlg_msg_.Btn_cancel:
return true; // noop
default:
throw Err_.unhandled(rslt);
}
}
public void Init_by_wiki() {
if (!init_needed) return;
init_needed = false;
if (String_.Eq(domain_str, "xowa"))
return; // HACK: ignore "xowa" for now; WHEN:converting xowa to sqlitedb
data_mgr__core_mgr = new Xow_db_mgr(this, fsys_mgr.Root_dir());
data_mgr__core_mgr.Init_by_load(gplx.xowa.wikis.data.Xow_db_file__core_.Find_core_fil(this));
app.Html__css_installer()
.Install(this, Xowd_css_core_mgr.Key_mobile); // must init after data_mgr
this.db_core_mgr = Fsdb_db_mgr_.new_detect(this, fsys_mgr.Root_dir(), fsys_mgr.File_dir());
if (db_core_mgr
== null) // no fsdb; occurs during merge; also, will be null for xowa_db; DATE:2016-05-31
db_core_mgr = Fsdb_db_mgr__v2_bldr.Get_or_make(this, true);
else // fsdb exists; load it
fsdb_mgr.Mnt_mgr().Ctor_by_load(db_core_mgr);
file_mgr__repo_mgr.Add_repo(
app, fsys_mgr.File_dir(), Xow_domain_itm_.Bry__commons, Xow_domain_itm_.Bry__commons);
file_mgr__repo_mgr.Add_repo(app, fsys_mgr.File_dir(), domain_bry, domain_bry);
Xof_orig_tbl[] orig_tbls =
db_core_mgr == null ? new Xof_orig_tbl[0] : db_core_mgr.File__orig_tbl_ary();
orig_mgr.Init_by_wiki(this, file_mgr__fsdb_mode, orig_tbls, Xof_url_bldr.new_v2());
fsdb_mgr.Init_by_wiki(this);
data_mgr__core_mgr.Db__core().Tbl__ns().Select_all(ns_mgr);
data_mgr__core_mgr.Db__core().Tbl__site_stats().Select(stats);
html__hdump_mgr.Init_by_db(this);
app.Addon_mgr().Load_by_wiki(this);
ctg_pagebox_wtr.Init_by_wiki(this);
}
public Xowv_wiki(Xoav_app app, byte[] domain_bry, Io_url wiki_root_dir) {
this.app = app;
this.domain_bry = domain_bry;
this.domain_str = String_.new_u8(domain_bry);
this.domain_itm = Xow_domain_itm_.parse(domain_bry);
this.domain_tid = domain_itm.Domain_type_id();
this.domain_abrv = Xow_abrv_wm_.To_abrv(Xow_domain_itm_.parse(domain_bry));
this.ns_mgr = Xow_ns_mgr_.default_(app.Utl_case_mgr());
this.lang =
app.Lang_mgr()
.Get_by_or_en(
domain_itm
.Lang_actl_key()); // NOTE: must not be null, or causes null ref exception on
// redlinks in drd; DATE:2016-06-28
this.msg_mgr = new Xow_msg_mgr(this, lang);
this.html__hdump_mgr = new Xow_hdump_mgr(this);
this.special_mgr = new Xosp_special_mgr(this);
this.fsys_mgr =
new Xow_fsys_mgr(wiki_root_dir, app.Fsys_mgr().File_dir().GenSubDir(domain_str));
this.fsdb_mgr = new Xof_fsdb_mgr__sql();
this.url__parser = new Xow_url_parser(this);
this.xwiki_mgr = new Xow_xwiki_mgr(this);
this.stats = new Xow_site_stats_mgr(this);
this.lnki_bldr = new Xoh_lnki_bldr(app, href_wtr);
this.ctg_catpage_mgr = new Xoctg_catpage_mgr(this);
}
public static Xob_db_file New__deletion_db(Xow_wiki wiki) {
String name =
String_.Format(
"{0}-file-deletion-{1}.xowa",
wiki.Domain_str(), Datetime_now.Get().XtoStr_fmt("yyyy.MM"));
return New(wiki.Fsys_mgr().Root_dir(), name);
}
public static Xog_history_itm Srl_load(byte[] raw) {
byte[][] atrs = Bry_split_.Split(raw, Byte_ascii.Pipe);
byte[] bmk_bry = atrs.length == 6 ? atrs[5] : Bry_.Empty;
bmk_bry = Bry_.Replace(bmk_bry, Byte_ascii.Tilde, Byte_ascii.Pipe);
return new Xog_history_itm(
atrs[0], atrs[1], atrs[2], atrs[3], atrs[4] == Bool_.Y_bry, String_.new_a7(bmk_bry));
}
public byte[] Bld(Xowe_wiki cur_wiki, Xoae_page page, Xow_popup_itm popup_itm, Bry_bfr wrdx_bfr) {
if (output_js_clean) cur_wiki.Html_mgr().Js_cleaner().Clean_bfr(wiki, page.Ttl(), wrdx_bfr, 0);
if (output_tidy)
cur_wiki.Html_mgr().Tidy_mgr().Exec_tidy(wrdx_bfr, Bool_.Y, page.Url_bry_safe());
byte[] hdom_bry = wrdx_bfr.To_bry_and_clear();
String page_url =
wrdx_bfr.Add(page.Wiki().Domain_bry())
.Add(gplx.xowa.htmls.hrefs.Xoh_href_.Bry__wiki)
.Add(
gplx.langs.htmls.encoders.Gfo_url_encoder_.Href.Encode(
page.Ttl()
.Full_db())) // NOTE: was page.Url().Raw(), but that doesn't work for
// Special:Search; PAGE:en.w:Earth and "Quotations";
// DATE:2014-06-29
.To_str_and_clear();
fmtr_popup.Bld_bfr_many(
wrdx_bfr,
hdom_bry,
wiki.Lang().Dir_ltr_bry(),
page_url,
String_.new_u8(page.Ttl().Full_txt_w_ttl_case()),
popup_itm.Popup_id(),
Xow_popup_html_bldr_.Bld_fmtr_wiki(
fmtr_wiki,
wrdx_bfr,
cur_wiki.Domain_bry(),
page.Wiki().Domain_bry()) // NOTE: use cur_wiki, not page_wiki; DATE:2014-06-28
,
gplx.core.ios.Io_size_.To_str(page.Db().Text().Text_bry().length),
page.Db().Page().Modified_on().XtoStr_fmt_yyyy_MM_dd_HH_mm_ss(),
Xow_popup_html_bldr_.Bld_fmtr_viewed(fmtr_viewed, app, wiki, wrdx_bfr, page.Ttl()),
app.Fsys_mgr().Root_dir().To_http_file_bry());
return wrdx_bfr.To_bry_and_clear();
}
public class Xob_xfer_regy_log_tbl {
public static void Create_table(Db_conn p) {
gplx.dbs.engines.sqlite.Sqlite_engine_.Tbl_create_and_delete(p, Tbl_name, Tbl_sql);
}
public static Db_stmt Insert_stmt(Db_conn p) {
return Db_stmt_.new_insert_(
p, Tbl_name, Fld_lnki_id, Fld_xfer_status, Fld_xfer_bin_tid, Fld_xfer_bin_msg);
}
public static void Insert(Db_stmt stmt, byte status, int id, byte wkr_tid, String wkr_msg) {
stmt.Clear().Val_int(id).Val_byte(status).Val_byte(wkr_tid).Val_str(wkr_msg).Exec_insert();
}
private static final String Tbl_sql =
String_.Concat_lines_nl(
"CREATE TABLE IF NOT EXISTS xfer_regy_log",
"( lnki_id integer NOT NULL",
", xfer_status tinyint NOT NULL" // 0=todo; 1=fail; 2=pass; 3=done
,
", xfer_bin_tid tinyint NOT NULL",
", xfer_bin_msg varchar(255) NOT NULL",
");");
public static final String Tbl_name = "xfer_regy_log",
Fld_lnki_id = "lnki_id",
Fld_xfer_status = "xfer_status",
Fld_xfer_bin_tid = "xfer_bin_tid",
Fld_xfer_bin_msg = "xfer_bin_msg";
}
public void Select_tasks_steps(
Xobc_task_step_hash task_step_hash,
Xobc_step_map_tbl step_map_tbl,
byte[] wiki_abrv,
String wiki_date) {
task_step_hash.Clear();
Db_rdr rdr =
conn.Stmt_sql(
String_.Concat_lines_nl_skip_last(
"SELECT DISTINCT sm.task_id, sm.step_id",
"FROM " + tbl_name + " imps",
" JOIN " + step_map_tbl.Tbl_name() + " sm ON sm.step_id = imps.step_id",
"WHERE imps.wiki_abrv = ?",
"AND imps.wiki_date = ?"))
.Crt_bry_as_str(fld_wiki_abrv, wiki_abrv)
.Crt_str(fld_wiki_date, wiki_date)
.Exec_select__rls_auto();
try {
while (rdr.Move_next()) {
task_step_hash.Add(rdr.Read_int("task_id"), rdr.Read_int("step_id"));
}
} finally {
rdr.Rls();
}
}
private int Load_from_db(List_adp list, int uid_prv) {
// prepare for page_tbl
String sql =
String_.Format(
String_.Concat_lines_nl_skip_last // ANSI.Y
(
"SELECT mp.xomp_uid",
", pp.page_id",
", pp.page_namespace",
", pp.page_title",
", pp.page_text_db_id",
"FROM xomp_page mp",
" JOIN <page_db>page pp ON mp.page_id = pp.page_id",
"WHERE mp.xomp_uid > {0}",
"AND mp.page_status = 0",
"LIMIT {1}"),
uid_prv,
num_pages_per_load);
this.attach_mgr.Conn_links_(
new Db_attach_itm("page_db", wiki.Data__core_mgr().Db__core().Conn()));
sql = attach_mgr.Resolve_sql(sql);
// run page_tbl
int rv = -1;
Xomp_text_db_loader text_db_loader = new Xomp_text_db_loader(wiki);
attach_mgr.Attach();
Db_rdr rdr = make_conn.Stmt_sql(sql).Exec_select__rls_auto();
try {
while (rdr.Move_next()) {
rv = rdr.Read_int("xomp_uid");
int text_db_id = rdr.Read_int("page_text_db_id");
Xomp_page_itm ppg = new Xomp_page_itm(rdr.Read_int("page_id"));
ppg.Init_by_page(
rdr.Read_int("page_namespace"), rdr.Read_bry_by_str("page_title"), text_db_id);
list.Add(ppg);
text_db_loader.Add(text_db_id, ppg);
}
} finally {
rdr.Rls();
}
attach_mgr.Detach();
text_db_loader.Load();
return rv;
}
public static String Resolve_file(boolean use_file_protocol, Io_url root_dir, String file) {
String rv = file;
// resolve relative urls; EX: "./a.js" -> "/xowa/wiki/simple.wikipedia.org/bin/script/a.js"
if (String_.Has_at_bgn(rv, "./")) {
// remove "./"
rv = String_.Mid(rv, 2);
if (use_file_protocol) rv = root_dir.To_http_file_str() + rv;
else {
// if fsys_url && wnt, replace "\" with "/"
if (Op_sys.Cur().Tid_is_wnt())
rv = String_.Replace(rv, Op_sys.Lnx.Fsys_dir_spr_str(), Op_sys.Wnt.Fsys_dir_spr_str());
rv = root_dir.Xto_api() + Op_sys.Cur().Fsys_dir_spr_str() + rv;
}
}
return rv;
}
public void Save_as() {
if (this.Active_tab_is_null()) return;
Xog_tab_itm tab = win.Tab_mgr().Active_tab();
String file_name =
Xoa_app_.Utl__encoder_mgr()
.Fsys_safe()
.Encode_str(String_.new_u8(tab.Page().Ttl().Full_url()))
+ ".html";
String file_url =
app.Gui_mgr()
.Kit()
.New_dlg_file(Gfui_kit_.File_dlg_type_save, "Select file to save to:")
.Init_file_(file_name)
.Ask();
if (String_.Len_eq_0(file_url)) return;
Io_mgr.I.SaveFilStr(file_url, tab.Html_box().Text());
app.Usr_dlg().Prog_many("", "", "saved page: file=~{0}", file_url);
}
Xof_repo_itm Ini_repo_add(Xof_file_mgr file_mgr, byte[] key, String root, String wiki, boolean trg) {
Xof_repo_itm repo = file_mgr.Repo_mgr().Set(String_.new_u8(key), root, wiki).Ext_rules_(Xof_rule_grp.Grp_app_default).Dir_depth_(2);
if (trg) {
byte[][] ary = repo.Mode_names();
ary[0] = Bry_.new_a7("raw");
ary[1] = Bry_.new_a7("fit");
}
return repo;
}
public static Xopg_tag_itm New_js_file(Io_url src_url) {
byte[] src = src_url.To_http_file_bry();
return new Xopg_tag_itm(
Tid__js_file,
Gfh_tag_.Bry__script,
src,
null,
Tag__type_js,
Keyval_.new_("src", String_.new_u8(src)));
}
public boolean Mustache__write(String key, Mustache_bfr bfr) {
if (String_.Eq(key, "path")) bfr.Add_bry(path);
else if (String_.Eq(key, "path_enc"))
bfr.Add_bry(gplx.langs.htmls.encoders.Gfo_url_encoder_.Href.Encode(path));
else if (String_.Eq(key, "owner_dir_enc")) bfr.Add_bry(owner_dir_enc);
else if (String_.Eq(key, "name")) bfr.Add_bry(name);
else if (String_.Eq(key, "date")) bfr.Add_bry(date);
else if (String_.Eq(key, "size")) bfr.Add_bry(size);
else if (String_.Eq(key, "color")) bfr.Add_bry(color);
else if (String_.Eq(key, "dir_cmd")) bfr.Add_bry(dir_cmd);
else if (String_.Eq(key, "dir_cmd_arg")) {
bfr.Add_str_u8("&dir_cmd=");
bfr.Add_bry(dir_cmd);
} else return false;
return true;
}
public Xow_search_tkn[] Scan(byte[] src) {
this.src = src;
this.src_len = src.length;
tkns.Clear();
pos = 0;
txt_bgn = -1;
while (pos < src_len) {
byte cur_b = src[pos];
Object cur_obj = trie.Match_bgn_w_byte(cur_b, src, pos, src_len);
if (cur_obj == null) { // text character
if (txt_bgn == -1) txt_bgn = pos; // 1st character not set; set it
++pos;
} else { // AND, OR, (, ), -, \s, "
int pos_end = trie.Match_pos();
byte cur_tid = ((Byte_obj_val) cur_obj).Val();
if (Cur_join_is_word(cur_tid, pos_end))
continue; // ignore words containing "and", "or"; EX: "random"; "for"
if (txt_bgn != -1) { // pending word; create
Tkns_add_word(Xow_search_tkn.Tid_word, txt_bgn, pos);
txt_bgn = -1;
}
switch (cur_tid) {
case Xow_search_tkn.Tid_space: // discard spaces
pos = Bry_finder.Find_fwd_while(src, pos, src_len, Byte_ascii.Space);
break;
case Xow_search_tkn.Tid_quote: // find end quote and add as word
int quote_bgn = pos + 1;
int quote_end = Bry_finder.Find_fwd(src, Byte_ascii.Quote, quote_bgn, src_len);
if (quote_end == Bry_.NotFound)
throw Err_.new_fmt_("could not find end quote: {0}", String_.new_u8(src));
Tkns_add_word(Xow_search_tkn.Tid_word_quoted, quote_bgn, quote_end);
pos = quote_end + 1; // +1 to place after quote
break;
case Xow_search_tkn.Tid_not:
Tkns_add_word(Xow_search_tkn.Tid_not, pos, pos_end);
pos = pos_end;
break;
case Xow_search_tkn.Tid_paren_bgn:
case Xow_search_tkn.Tid_paren_end:
case Xow_search_tkn.Tid_and:
case Xow_search_tkn.Tid_or:
tkns.Add(new_tkn(cur_tid, pos, pos_end));
pos = pos_end;
break;
default:
throw Err_.unhandled(cur_tid);
}
}
}
if (txt_bgn != -1) { // pending word; create
Tkns_add_word(Xow_search_tkn.Tid_word, txt_bgn, pos);
txt_bgn = -1;
}
return (Xow_search_tkn[]) tkns.To_ary_and_clear(Xow_search_tkn.class);
}
private static boolean Navigate(
Gfo_usr_dlg usr_dlg,
Xoae_app app,
Wdata_wiki_mgr wdata_mgr,
Xoae_page page,
byte[] site_bry,
byte[] page_bry) {
page_bry =
Xoa_app_.Utl__encoder_mgr()
.Http_url()
.Decode(page_bry); // NOTE: space is converted to + on postback to url; decode
byte[] wiki_domain = Xow_wiki_alias.Parse_wmf_key(site_bry);
if (wiki_domain == null) {
usr_dlg.Warn_many("", "", "site_bry parse failed; site_bry:~{0}", String_.new_u8(site_bry));
return false;
}
Xowe_wiki wiki = app.Wiki_mgr().Get_by_key_or_make(wiki_domain);
if (wiki == null) {
usr_dlg.Warn_many(
"", "", "wiki_domain does not exist; wiki_domain:~{0}", String_.new_u8(wiki_domain));
return false;
}
Xoa_ttl wdata_ttl = Xoa_ttl.parse_(wiki, page_bry);
if (wdata_ttl == null) {
usr_dlg.Warn_many("", "", "ttl is invalid; ttl:~{0}", String_.new_u8(page_bry));
return false;
}
Wdata_doc doc = wdata_mgr.Pages_get(wiki, wdata_ttl);
if (doc == null) {
usr_dlg.Warn_many(
"", "", "ttl cannot be found in wikidata; ttl:~{0}", String_.new_u8(wdata_ttl.Raw()));
return false;
}
byte[] qid_bry = doc.Qid();
Xoae_page qid_page = wdata_mgr.Wdata_wiki().Data_mgr().Redirect(page, qid_bry);
if (qid_page.Missing()) {
usr_dlg.Warn_many(
"", "", "qid cannot be found in wikidata; qid:~{0}", String_.new_u8(qid_bry));
return false;
}
return true;
}
public static Fsdb_db_mgr new_src_bin_db_mgr(Xow_wiki wiki, String version) {
String domain_str = wiki.Domain_str();
Fsdb_db_mgr rv = null;
Io_url url = null;
if (String_.Eq(version, "v1")) {
url =
wiki.Fsys_mgr()
.File_dir()
.OwnerDir()
.GenSubDir(domain_str + "-prv"); // v1: EX: /xowa/file/en.wikipedia.org-prv/
rv = new Fsdb_db_mgr__v1(url);
} else if (String_.Eq(version, "v2")) {
url = wiki.Fsys_mgr().Root_dir().GenSubDir("prv"); // v2: EX: /xowa/wiki/en.wikipedia.org/prv/
rv = Fsdb_db_mgr_.new_detect(wiki, url, url); // note that v2 is prioritized over v1
} else throw Err_.new_wo_type("fsdb.make:unknown fsdb_type", "version", version);
if (rv == null)
throw Err_.new_wo_type(
"fsdb.make:source fsdb not found", "version", version, "url", url.Raw());
return rv;
}
public void New_href(boolean focus) {
Xog_tab_itm tab = tab_mgr.Active_tab();
if (tab == Xog_tab_itm_.Null) return;
String link = tab.Html_itm().Html_selected_get_href_or_text();
if (String_.Len_eq_0(link)) {
tab_mgr.Win().Usr_dlg().Prog_many("", "", "no link or text selected");
return;
}
tab_mgr.Tabs_new_dflt(true);
tab_mgr.Win().Page__navigate_by_url_bar(link);
}
private int Import_url_chk(
byte[] rel_url_prefix,
byte[] src,
int src_len,
int old_pos,
int find_bgn,
byte[] url_raw,
Bry_bfr bfr) {
if (find_bgn < Bry_import_len) return Bry_find_.Not_found;
if (!Bry_.Match(src, find_bgn - Bry_import_len, find_bgn, Bry_import))
return Bry_find_.Not_found;
byte[] css_url = url_raw;
int css_url_len = css_url.length;
if (css_url_len > 0
&& css_url[0]
== Byte_ascii
.Slash) { // css_url starts with "/"; EX: "/page" or "//site/page" DATE:2014-02-03
if (css_url_len > 1
&& css_url[1] != Byte_ascii.Slash) // skip if css_url starts with "//"; EX: "//site/page"
css_url = Bry_.Add(rel_url_prefix, css_url); // "/w/a.css" -> "//en.wikipedia.org/w/a.css"
}
css_url =
Bry_.Replace(
css_url,
Byte_ascii.Space,
Byte_ascii
.Underline); // NOTE: must replace spaces with underlines else download will fail;
// EX:https://it.wikivoyage.org/w/index.php?title=MediaWiki:Container e
// Infobox.css&action=raw&ctype=text/css; DATE:2015-03-08
byte[] css_src_bry = Import_url_build(stylesheet_prefix, rel_url_prefix, css_url);
String css_src_str = String_.new_u8(css_src_bry);
download_wkr.Download_xrg()
.Prog_fmt_hdr_(
usr_dlg.Log_many(
GRP_KEY, "logo.download", "downloading import for '~{0}'", css_src_str));
byte[] css_trg_bry = download_wkr.Download_xrg().Exec_as_bry(css_src_str);
if (css_trg_bry == null) {
usr_dlg.Warn_many("", "", "could not import css: url=~{0}", css_src_str);
return Bry_find_.Not_found; // css not found
}
bfr.Add_mid(src, old_pos, find_bgn - Bry_import_len).Add_byte_nl();
bfr.Add(Bry_comment_bgn).Add(css_url).Add(Bry_comment_end).Add_byte_nl();
if (Bry_find_.Find_fwd(css_url, Wikisource_dynimg_ttl) != -1)
css_trg_bry =
Bry_.Replace(
css_trg_bry,
Wikisource_dynimg_find,
Wikisource_dynimg_repl); // FreedImg hack;
// PAGE:en.s:Page:Notes_on_Osteology_of_Baptanodon._With_a_Description_of_a_New_Species.pdf/3 DATE:2014-09-06
bfr.Add(css_trg_bry).Add_byte_nl();
bfr.Add_byte_nl();
int semic_pos = Bry_find_.Find_fwd(src, Byte_ascii.Semic, find_bgn + url_raw.length, src_len);
return semic_pos + Int_.Const_dlm_len;
}
public static Xopg_tag_itm New_css_file(Io_url href_url) {
byte[] href = href_url.To_http_file_bry();
return new Xopg_tag_itm(
Tid__css_file,
Gfh_tag_.Bry__link,
href,
null,
Tag__type_css,
Tag__rel_stylesheet,
Keyval_.new_("href", String_.new_u8(href)));
}
public byte[] Cartouche_img(
Xoh_wtr_ctx hctx,
boolean bgn,
byte[] glyph) { // render open / close cartouche; note that MW has two branches, but they are
// both the same
int height = (int) ((Hiero_html_mgr.Max_height * Hiero_html_mgr.scale) / 100);
Hiero_phoneme_itm phoneme_itm = phoneme_mgr.Get_by_key(glyph);
if (phoneme_itm == null) throw Err_.new_fmt_("missing phoneme: {0}", String_.new_u8(glyph));
byte[] code = phoneme_itm.Gardiner_code();
byte[] title = bgn ? Html_entity_.Lt_bry : Html_entity_.Gt_bry;
return cartouche_img_fmtr.Bld_bry_many(temp_bfr, hiero_img_dir, code, height, title);
}
class Wdata_fmtr__json implements gplx.core.brys.Bfr_arg {
private final Bry_bfr tmp_bfr = Bry_bfr_.Reset(255);
private Xoapi_toggle_itm toggle_itm;
private Wdata_toc_data toc_data;
private Json_doc jdoc;
public void Init_by_ctor(Wdata_toc_data toc_data, Xoapi_toggle_mgr toggle_mgr) {
this.toc_data = toc_data.Itms_len_enable_n_();
this.toggle_itm =
toggle_mgr.Get_or_new("wikidatawiki-json")
.Html_toggle_hdr_cls_(Bry_.new_a7("overflow:auto;"));
}
public void Init_by_lang(Wdata_hwtr_msgs msgs) {
toc_data.Orig_(msgs.Json_div_hdr());
toggle_itm.Init_msgs(msgs.Toggle_title_y(), msgs.Toggle_title_n());
}
public void Init_by_wdoc(Json_doc jdoc) {
this.jdoc = jdoc;
toc_data.Make(0);
}
public void Bfr_arg__add(Bry_bfr bfr) {
if (jdoc == null) return; // TEST: wdoc doesn't have jdoc
jdoc.Root_nde().Print_as_json(tmp_bfr, 0);
fmtr.Bld_bfr_many(
bfr,
toc_data.Href(),
toc_data.Text(),
toggle_itm.Html_toggle_btn(),
toggle_itm.Html_toggle_hdr(),
tmp_bfr.To_bry_and_clear());
}
private final Bry_fmtr fmtr =
Bry_fmtr.new_(
String_.Concat_lines_nl_skip_last(
"",
" <h2 class='wb-section-heading' id='~{hdr_href}'>~{hdr_text}~{toggle_btn}</h2>",
" <div class='visualClear'></div>",
" <pre~{toggle_hdr}>~{json}",
" </pre>",
" </div>"),
"hdr_href",
"hdr_text",
"toggle_btn",
"toggle_hdr",
"json");
}
public Object Invk(GfsCtx ctx, int ikey, String k, GfoMsg m) {
if (ctx.Match(k, Invk_clear)) this.Clear();
else if (ctx.Match(k, Invk_separators)) return separators_mgr;
else if (ctx.Match(k, Invk_digits)) {
digits_translate = true;
return digits_mgr;
} // NOTE: only langes with a digit_transform_table will call digits; DATE:2014-05-28
else if (ctx.Match(k, Invk_digit_grouping_pattern))
return String_.new_u8(num_grp_fmtr.Digit_grouping_pattern());
else if (ctx.Match(k, Invk_digit_grouping_pattern_))
num_grp_fmtr.Digit_grouping_pattern_(m.ReadBry("v"));
else return Gfo_invk_.Rv_unhandled;
return this;
}
private void Download_exec(Xodb_tbl_oimg_xfer_itm fsdb) {
Io_stream_rdr src_rdr = src_bin_mgr.Find_as_rdr(Xof_exec_tid.Tid_wiki_page, fsdb);
try {
if (src_rdr == Io_stream_rdr_.Noop) { // download failed
++exec_fail;
usr_dlg.Warn_many(
"",
"",
"failed: ttl=~{0}",
String_.Format("[[File:{0}|{1}px]]", fsdb.Orig_ttl(), fsdb.Html_w()));
Print_progress(fsdb);
} else { // download passed
long src_rdr_len = src_rdr.Len();
int lnki_tier_id = fsdb.Lnki_tier_id();
if (src_rdr_len > download_size_max && !Int_.In(lnki_tier_id, download_keep_tier_ids)) {
usr_dlg.Warn_many(
"",
"",
"skipped; ttl=~{0} w=~{1} size=~{2} tier=~{3}",
fsdb.Orig_ttl(),
fsdb.Lnki_w(),
src_rdr_len,
lnki_tier_id);
return;
}
if (trg_bin_fil == null) // no trg_bin_fil
Make_trg_bin_file(Bool_.Y, fsdb, src_rdr_len);
else if (trg_bin_fil.Bin_len() + src_rdr_len
> trg_bin_db_max) // or trg_bin_fil is out of space
Make_trg_bin_file(Bool_.N, fsdb, src_rdr_len);
else if (prv_lnki_tier_id != lnki_tier_id) { // or tier has changed
if (prv_lnki_tier_id != -1 && !bin_db_mgr.Schema_is_1()) // do not increment dbs for v1
Make_trg_bin_file(Bool_.Y, fsdb, src_rdr_len);
prv_lnki_tier_id = lnki_tier_id;
}
trg_bin_updater.Save_bin(trg_mnt_itm, trg_atr_fil, trg_bin_fil, fsdb, src_rdr, src_rdr_len);
}
} finally {
src_rdr.Rls();
}
}
public Xobc_import_step_itm[] Select_by_task_id(int task_id) {
List_adp list = List_adp_.New();
Db_rdr rdr =
conn.Stmt_sql(
Db_sql_.Make_by_fmt(
String_.Ary(
"SELECT s.*",
"FROM import_step s",
" JOIN step_map sm ON s.step_id = sm.step_id",
"WHERE sm.task_id = {0}"),
task_id))
.Exec_select__rls_auto();
try {
while (rdr.Move_next()) {
list.Add(New_itm(rdr));
}
} finally {
rdr.Rls();
}
return (Xobc_import_step_itm[]) list.To_ary_and_clear(Xobc_import_step_itm.class);
}
public byte[] Convert_to_local_urls(byte[] rel_url_prefix, byte[] src, List_adp list) {
try {
int src_len = src.length;
int prv_pos = 0;
Bry_bfr bfr = Bry_bfr_.New_w_size(src_len);
Hash_adp img_hash = Hash_adp_bry.cs();
while (true) {
int url_pos = Bry_find_.Find_fwd(src, Bry_url, prv_pos);
if (url_pos == Bry_find_.Not_found) {
bfr.Add_mid(src, prv_pos, src_len);
break;
} // no more "url("; exit;
int bgn_pos = url_pos + Bry_url_len; // set bgn_pos after "url("
byte bgn_byte = src[bgn_pos];
byte end_byte = Byte_ascii.Null;
boolean quoted = true;
switch (bgn_byte) { // find end_byte
case Byte_ascii.Quote:
case Byte_ascii.Apos: // quoted; end_byte is ' or "
end_byte = bgn_byte;
++bgn_pos;
break;
default: // not quoted; end byte is ")"
end_byte = Byte_ascii.Paren_end;
quoted = false;
break;
}
int end_pos = Bry_find_.Find_fwd(src, end_byte, bgn_pos, src_len);
if (end_pos
== Bry_find_.Not_found) { // unclosed "url("; exit since nothing else will be found
usr_dlg.Warn_many(
GRP_KEY,
"parse.invalid_url.end_missing",
"could not find end_sequence for 'url(': bgn='~{0}' end='~{1}'",
prv_pos,
String_.new_u8__by_len(src, prv_pos, prv_pos + 25));
bfr.Add_mid(src, prv_pos, src_len);
break;
}
if (end_pos - bgn_pos == 0) { // empty; "url()"; ignore
usr_dlg.Warn_many(
GRP_KEY,
"parse.invalid_url.empty",
"'url(' is empty: bgn='~{0}' end='~{1}'",
prv_pos,
String_.new_u8__by_len(src, prv_pos, prv_pos + 25));
bfr.Add_mid(src, prv_pos, bgn_pos);
prv_pos = bgn_pos;
continue;
}
byte[] img_raw = Bry_.Mid(src, bgn_pos, end_pos);
int img_raw_len = img_raw.length;
if (Bry_.Has_at_bgn(img_raw, Bry_data_image, 0, img_raw_len)) { // base64
bfr.Add_mid(src, prv_pos, end_pos); // nothing to download; just add entire String
prv_pos = end_pos;
continue;
}
int import_url_end =
Import_url_chk(
rel_url_prefix,
src,
src_len,
prv_pos,
url_pos,
img_raw,
bfr); // check for embedded stylesheets via @import tag
if (import_url_end != Bry_find_.Not_found) {
prv_pos = import_url_end;
continue;
}
byte[] img_cleaned = Xob_url_fixer.Fix(wiki_domain, img_raw, img_raw_len);
if (img_cleaned == null) { // could not clean img
usr_dlg.Warn_many(
GRP_KEY,
"parse.invalid_url.clean_failed",
"could not extract valid http src: bgn='~{0}' end='~{1}'",
prv_pos,
String_.new_u8(img_raw));
bfr.Add_mid(src, prv_pos, bgn_pos);
prv_pos = bgn_pos;
continue;
}
if (!img_hash.Has(img_cleaned)) { // only add unique items for download;
img_hash.Add_as_key_and_val(img_cleaned);
list.Add(String_.new_u8(img_cleaned));
}
img_cleaned =
Replace_invalid_chars(
Bry_.Copy(
img_cleaned)); // NOTE: must call ByteAry.Copy else img_cleaned will change
// *inside* hash
bfr.Add_mid(src, prv_pos, bgn_pos);
if (!quoted) bfr.Add_byte(Byte_ascii.Quote);
bfr.Add(img_cleaned);
if (!quoted) bfr.Add_byte(Byte_ascii.Quote);
prv_pos = end_pos;
}
return bfr.To_bry_and_clear();
} catch (Exception e) {
usr_dlg.Warn_many(
"",
"",
"failed to convert local_urls: ~{0} ~{1}",
String_.new_u8(rel_url_prefix),
Err_.Message_gplx_full(e));
return src;
}
}
String Replace_invalid_chars_str(String raw_str) {
return String_.new_u8(Replace_invalid_chars(Bry_.new_u8(raw_str)));
}
public class Pfunc_scrib_lib implements Scrib_lib {
private Scrib_core core;
public Scrib_lua_mod Mod() {
return mod;
}
private Scrib_lua_mod mod;
public Scrib_lib Init() {
procs.Init_by_lib(this, Proc_names);
return this;
}
public void Core_(Scrib_core v) {
this.core = v;
} // TEST:
public Scrib_lib Clone_lib(Scrib_core core) {
return new Pfunc_scrib_lib();
}
public Scrib_lua_mod Register(Scrib_core core, Io_url script_dir) {
this.core = core;
Init();
mod =
core.RegisterInterface(
this,
core.App()
.Fsys_mgr()
.Bin_xtns_dir()
.GenSubFil_nest("ParserFunctions", "mw.ext.ParserFunctions.lua"));
return mod;
}
public Scrib_proc_mgr Procs() {
return procs;
}
private Scrib_proc_mgr procs = new Scrib_proc_mgr();
public boolean Procs_exec(int key, Scrib_proc_args args, Scrib_proc_rslt rslt) {
switch (key) {
case Proc_expr:
return Expr(args, rslt);
default:
throw Err_.new_unhandled(key);
}
}
private static final int Proc_expr = 0;
public static final String Invk_expr = "expr";
private static final String[] Proc_names = String_.Ary(Invk_expr);
public boolean Expr(Scrib_proc_args args, Scrib_proc_rslt rslt) {
byte[] expr_bry =
args.Xstr_bry_or_null(
0); // NOTE: some modules will pass in an int; PAGE:en.w:531_BC DATE:2016-04-29
Bry_bfr tmp_bfr = core.Wiki().Utl__bfr_mkr().Get_b128();
Pfunc_expr.Evaluate(tmp_bfr, core.Ctx(), expr_bry);
String expr_rslt = tmp_bfr.To_str_and_rls();
return rslt.Init_obj(
expr_rslt); // NOTE: always return rslt; don't throw error even if expr is invalid;
// EX:mw.ParserFuntion.expr('fail'); PAGE:es.w:Freer_(Texas) DATE:2015-07-28
}
}
