use crate::config::Config;
use crate::decode::SuffixPolicy;
use crate::grammar::{self, is_left_boundary};
#[derive(Debug, Clone)]
pub struct Candidate {
pub start: usize,
pub end: usize,
pub kind: CandKind,
pub children: Vec<Candidate>,
}
#[derive(Debug, Clone)]
pub enum CandKind {
Tag {
name: String,
},
Category {
path: String,
},
Reference {
id: String,
specifier: Option<String>,
annotations: String,
},
CrossReference {
space: String,
id: String,
specifier: Option<String>,
annotations: String,
},
FileReference {
filepath: String,
specifier: Option<String>,
annotations: String,
},
CrossFileReference {
space: String,
filepath: String,
specifier: Option<String>,
annotations: String,
},
Resource {
filename: String,
specifier: Option<String>,
annotations: String,
},
InterJotResource {
space: Option<String>,
id: Option<String>,
filepath: Option<String>,
filename: String,
specifier: Option<String>,
annotations: String,
},
Url {
url: String,
label: Option<String>,
},
Bookmark {
name: String,
},
Todo {
body: String,
},
Reject {
code: &'static str,
message: String,
},
}
impl CandKind {
fn rank(&self) -> u8 {
match self {
CandKind::Reject { .. } => 0,
CandKind::InterJotResource { .. } => 1,
CandKind::CrossFileReference { .. } => 2,
CandKind::FileReference { .. } => 3,
CandKind::CrossReference { .. } => 4,
CandKind::Reference { .. } => 5,
CandKind::Resource { .. } => 6,
CandKind::Url { .. } => 7,
CandKind::Bookmark { .. } => 8,
CandKind::Todo { .. } => 9,
CandKind::Category { .. } => 10,
CandKind::Tag { .. } => 11,
}
}
pub fn is_todo(&self) -> bool {
matches!(self, CandKind::Todo { .. })
}
pub fn is_bookmark(&self) -> bool {
matches!(self, CandKind::Bookmark { .. })
}
}
pub struct ScanOutput {
pub winners: Vec<Candidate>,
pub dropped_bookmarks: Vec<Candidate>,
}
pub fn scan(text: &str, cfg: &Config) -> ScanOutput {
let g = grammar::grammar(cfg.unicode);
let do_tags = cfg.enabled("parse_tags", true);
let do_cats = cfg.enabled("parse_categories", true);
let do_refs = cfg.enabled("parse_references", true);
let do_fref = cfg.enabled("parse_file_references", true);
let do_res = cfg.enabled("parse_resources", true);
let do_todos = cfg.enabled("parse_todos", true);
let do_urls = cfg.enabled("parse_urls", true);
let do_bm = cfg.enabled("parse_bookmarks", true);
let do_hash = cfg.enabled("parse_hashtags_as_tags", false);
let mut cand: Vec<Candidate> = Vec::new();
let mut full_spans: Vec<(usize, usize)> = Vec::new();
if do_res && do_refs {
for caps in g.inter_jot_cross_id.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::InterJotResource {
space: Some(caps[1].to_string()),
id: Some(caps[2].to_string()),
filepath: None,
filename: caps[3].to_string(),
specifier: caps.get(4).map(|x| x.as_str().to_string()),
annotations: caps.get(5).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
for caps in g.inter_jot_same_id.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::InterJotResource {
space: None,
id: Some(caps[1].to_string()),
filepath: None,
filename: caps[2].to_string(),
specifier: caps.get(3).map(|x| x.as_str().to_string()),
annotations: caps.get(4).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
}
if do_res && do_fref {
for caps in g.inter_jot_cross_file.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::InterJotResource {
space: Some(caps[1].to_string()),
id: None,
filepath: Some(caps[2].to_string()),
filename: caps[3].to_string(),
specifier: caps.get(4).map(|x| x.as_str().to_string()),
annotations: caps.get(5).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
for caps in g.inter_jot_same_file.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::InterJotResource {
space: None,
id: None,
filepath: Some(caps[1].to_string()),
filename: caps[2].to_string(),
specifier: caps.get(3).map(|x| x.as_str().to_string()),
annotations: caps.get(4).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
}
if do_fref {
for caps in g.cross_file_ref.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::CrossFileReference {
space: caps[1].to_string(),
filepath: caps[2].to_string(),
specifier: caps.get(3).map(|x| x.as_str().to_string()),
annotations: caps.get(4).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
for caps in g.file_ref.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::FileReference {
filepath: caps[1].to_string(),
specifier: caps.get(2).map(|x| x.as_str().to_string()),
annotations: caps.get(3).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
}
if do_refs {
for caps in g.cross_id_ref.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::CrossReference {
space: caps[1].to_string(),
id: caps[2].to_string(),
specifier: caps.get(3).map(|x| x.as_str().to_string()),
annotations: caps.get(4).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
for caps in g.id_ref.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::Reference {
id: caps[1].to_string(),
specifier: caps.get(2).map(|x| x.as_str().to_string()),
annotations: caps.get(3).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
}
if do_res {
for caps in g.resource.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::Resource {
filename: caps[1].to_string(),
specifier: caps.get(2).map(|x| x.as_str().to_string()),
annotations: caps.get(3).map(|x| x.as_str().to_string()).unwrap_or_default(),
},
children: Vec::new(),
});
}
}
if do_urls {
for caps in grammar::URL_RE.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
let (label, url_str) = if let Some(u) = caps.get(2) {
(caps.get(1).map(|s| s.as_str().to_string()), u.as_str())
} else if let Some(u) = caps.get(4) {
(caps.get(3).map(|s| s.as_str().to_string()), u.as_str())
} else {
(None, caps.get(5).unwrap().as_str())
};
let (trimmed, trim_len) = trim_url_punct(url_str);
cand.push(Candidate {
start: m.start(),
end: m.end() - trim_len,
kind: CandKind::Url {
url: trimmed,
label,
},
children: Vec::new(),
});
}
}
if do_bm {
for caps in g.bookmark_decl.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::Bookmark {
name: caps[1].to_string(),
},
children: Vec::new(),
});
}
}
if do_tags {
for chain_m in g.tagstring.find_iter(text).flatten() {
if !is_left_boundary(text, chain_m.start()) {
continue;
}
let chain_off = chain_m.start();
let chain = chain_m.as_str();
for seg in g.tag.captures_iter(chain).flatten() {
let s = seg.get(0).unwrap();
cand.push(Candidate {
start: chain_off + s.start(),
end: chain_off + s.end(),
kind: CandKind::Tag {
name: seg[1].to_lowercase(),
},
children: Vec::new(),
});
}
}
if do_hash {
for caps in g.hashtag.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::Tag {
name: caps[1].to_lowercase(),
},
children: Vec::new(),
});
}
}
}
if do_cats {
let policy = SuffixPolicy::from_config(cfg);
for caps in g.category.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
let path = caps[1].to_lowercase();
if let Some(root) = &policy.root
&& path.split("::").next() != Some(root.as_str())
{
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::Category { path },
children: Vec::new(),
});
}
}
if do_todos {
for caps in grammar::TODO_LINE.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
cand.push(Candidate {
start: m.start(),
end: m.end(),
kind: CandKind::Todo {
body: caps[1].to_string(),
},
children: Vec::new(),
});
}
}
trim_greedy_tails(text, &mut cand);
collect_full_spans(text, &cand, &mut full_spans);
apply_suffix_policy(g, &SuffixPolicy::from_config(cfg), &mut cand);
push_rejects(text, cfg, &mut cand);
push_generic_payload_rejects(text, &full_spans, &mut cand);
let (winners, dropped_bookmarks) = resolve_overlaps(cand);
ScanOutput {
winners,
dropped_bookmarks,
}
}
fn trim_url_punct(url: &str) -> (String, usize) {
let trim_chars = [
'.', ',', ';', ':', '"', '\'', '!', '?', ')', ']', '}',
];
let bytes = url.as_bytes();
let mut end = bytes.len();
let mut count = 0;
while end > 0 && trim_chars.contains(&(bytes[end - 1] as char)) {
end -= 1;
count += 1;
}
(url[..end].to_string(), count)
}
const TRIM_SET: &[u8] = b".,;:\"'!?)]}";
fn trim_greedy_tails(_text: &str, cand: &mut Vec<Candidate>) {
cand.retain_mut(|c| {
let payload: &mut String = match &mut c.kind {
CandKind::Resource {
filename,
specifier: None,
annotations,
} if annotations.is_empty() => filename,
CandKind::FileReference {
filepath,
specifier: None,
annotations,
} if annotations.is_empty() => filepath,
CandKind::CrossFileReference {
filepath,
specifier: None,
annotations,
..
} if annotations.is_empty() => filepath,
CandKind::InterJotResource {
filename,
specifier: None,
annotations,
..
} if annotations.is_empty() => filename,
_ => return true,
};
let mut cut = 0;
while cut < payload.len() && TRIM_SET.contains(&payload.as_bytes()[payload.len() - 1 - cut])
{
cut += 1;
}
if cut == 0 {
return true;
}
if cut == payload.len() {
return false;
}
payload.truncate(payload.len() - cut);
c.end -= cut;
true
});
}
fn apply_suffix_policy(g: &grammar::Grammar, policy: &SuffixPolicy, cand: &mut [Candidate]) {
if policy.categories && policy.tags && policy.root.is_none() {
return;
}
for c in cand.iter_mut() {
let annotations: &mut String = match &mut c.kind {
CandKind::Reference { annotations, .. }
| CandKind::CrossReference { annotations, .. }
| CandKind::FileReference { annotations, .. }
| CandKind::CrossFileReference { annotations, .. }
| CandKind::Resource { annotations, .. }
| CandKind::InterJotResource { annotations, .. } => annotations,
_ => continue,
};
if annotations.is_empty() {
continue;
}
let cut = policy.cut(g, annotations);
if cut < annotations.len() {
c.end -= annotations.len() - cut;
annotations.truncate(cut);
}
}
}
fn collect_full_spans(text: &str, cand: &[Candidate], spans: &mut Vec<(usize, usize)>) {
let bytes = text.as_bytes();
let mut open_tag: Option<(usize, usize)> = None;
for c in cand {
if matches!(c.kind, CandKind::Tag { .. }) {
if bytes[c.start] == b'#' {
continue;
}
match open_tag {
Some((s, e)) if e == c.start => open_tag = Some((s, c.end)),
Some(span) => {
spans.push(span);
open_tag = Some((c.start, c.end));
}
None => open_tag = Some((c.start, c.end)),
}
continue;
}
if let Some(span) = open_tag.take() {
spans.push(span);
}
spans.push((c.start, c.end));
}
if let Some(span) = open_tag {
spans.push(span);
}
}
fn push_generic_payload_rejects(
text: &str,
spans: &[(usize, usize)],
cand: &mut Vec<Candidate>,
) {
let bytes = text.as_bytes();
for &(s, e) in spans {
let mut ext = e;
while ext < bytes.len() && !matches!(bytes[ext], b' ' | b'\t' | b'\r' | b'\n') {
ext += 1;
}
if ext == e {
continue;
}
if bytes[e..ext].iter().all(|b| TRIM_SET.contains(b)) {
continue; }
if spans.iter().any(|&(s2, e2)| {
(s2, e2) != (s, e)
&& s2 <= s
&& e2 >= e
&& (e2 >= ext || bytes[e2..ext].iter().all(|b| TRIM_SET.contains(b)))
}) {
continue;
}
cand.push(Candidate {
start: s,
end: ext,
kind: CandKind::Reject {
code: "Jots/Parsing/InvalidPayloadChars",
message: "payload contains characters the construct grammar cannot consume"
.to_string(),
},
children: Vec::new(),
});
}
}
fn push_rejects(text: &str, cfg: &Config, cand: &mut Vec<Candidate>) {
let g = grammar::grammar(cfg.unicode);
let do_cats = cfg.enabled("parse_categories", true);
let do_refs = cfg.enabled("parse_references", true);
let do_fref = cfg.enabled("parse_file_references", true);
let do_res = cfg.enabled("parse_resources", true);
let do_todos = cfg.enabled("parse_todos", true);
let do_urls = cfg.enabled("parse_urls", true);
let do_bm = cfg.enabled("parse_bookmarks", true);
let do_tags = cfg.enabled("parse_tags", true);
let mut push_reject = |start, end, code: &'static str, message: String| {
cand.push(Candidate {
start,
end,
kind: CandKind::Reject { code, message },
children: Vec::new(),
});
};
if do_res && (do_refs || do_fref) {
let pairs: &[(&grammar::Regex, bool)] = &[
(&g.rej_annot_before_sep_file_cross, do_fref),
(&g.rej_annot_before_sep_file_same, do_fref),
(&g.rej_annot_before_sep_id, do_refs),
];
for (re, on) in pairs {
if !*on {
continue;
}
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/AnnotationBeforeInterJotSep",
"annotation suffix between locator and ';;' is not allowed in an inter-jot resource reference"
.to_string(),
);
}
}
}
if do_res && (do_refs || do_fref) {
let pairs: &[(&grammar::Regex, bool)] = &[
(&g.rej_spec_on_loc_file_cross, do_fref),
(&g.rej_spec_on_loc_file_same, do_fref),
(&g.rej_spec_on_loc_id, do_refs),
];
for (re, on) in pairs {
if !*on {
continue;
}
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/SpecifierOnInterJotLocator",
"specifier on locator prefix of inter-jot resource reference is not allowed"
.to_string(),
);
}
}
}
if do_cats {
for caps in g.rej_cat_run.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
let full = &caps[1];
if !full.contains(":::") {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/EmptyCategorySegment",
format!("empty category segment in '{}'", full),
);
}
}
if do_res {
for caps in g.rej_filename_doubledot.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/ConsecutiveDotsInFilename",
format!("consecutive dots in filename ';;{}'", &caps[1]),
);
}
}
if do_urls {
for caps in grammar::REJ_URL_BARE.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
let payload = &caps[1];
if is_valid_url_payload(payload) {
continue;
}
if has_unmatched_label_paren(payload) || has_unmatched_label_bracket(payload) {
continue;
}
let (_, trim) = trim_url_punct(payload);
push_reject(
m.start(),
m.end() - trim,
"Jots/Parsing/UrlMissingScheme",
format!("URL '=={}' is missing http:// or https:// scheme", payload),
);
}
}
if do_urls {
for m in grammar::REJ_URL_UNMATCHED_PAREN.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/UnmatchedLabelDelimiter",
"URL parenthesized label contains stray ')'".to_string(),
);
}
for m in grammar::REJ_URL_UNMATCHED_BRACKET.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/UnmatchedLabelDelimiter",
"URL bracketed label contains stray ']'".to_string(),
);
}
}
let empty_pairs: &[(&grammar::Regex, bool, &str)] = &[
(&grammar::REJ_EMPTY_DOT, do_tags, ".."),
(&grammar::REJ_EMPTY_COLON, do_cats, "::"),
(&grammar::REJ_EMPTY_DASH, do_refs, "--"),
(&grammar::REJ_EMPTY_SLASH, do_fref, "//"),
(&grammar::REJ_EMPTY_SEMI, do_res, ";;"),
(&grammar::REJ_EMPTY_EQ, do_urls, "=="),
];
for (re, on, sigil) in empty_pairs {
if !*on {
continue;
}
for caps in re.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
let sig = &caps[1];
let _ = sigil;
push_reject(
m.start(),
m.start() + sig.len(),
"Jots/Parsing/EmptyPayload",
format!("construct '{}' has no payload following the sigil", sig),
);
}
}
if do_bm {
for m in grammar::REJ_EMPTY_BANG.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.start() + 2,
"Jots/Parsing/EmptyBookmarkName",
"bookmark declaration '!!' is missing a name".to_string(),
);
}
}
if do_res {
for caps in grammar::REJ_FILENAME_START_RES.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/InvalidFilenameStart",
format!("filename ';;{}' starts with '-' or '.'", &caps[1]),
);
}
}
if do_fref {
for caps in grammar::REJ_FILENAME_START_FILE_SAME.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/InvalidFilenameStart",
format!("filename '//{}' starts with '-' or '.'", &caps[1]),
);
}
for m in g.rej_filename_start_file_cross.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/InvalidFilenameStart",
"filename starts with '-' or '.'".to_string(),
);
}
}
if do_refs {
for m in g.rej_frag_nonnum_id.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/NonNumericFragment",
"fragment specifier is non-numeric".to_string(),
);
}
}
if do_fref {
for re in [
&g.rej_frag_nonnum_file_cross,
&g.rej_frag_nonnum_file_same,
] {
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/NonNumericFragment",
"fragment specifier is non-numeric".to_string(),
);
}
}
}
if do_res {
for m in g.rej_frag_nonnum_res.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/NonNumericFragment",
"fragment specifier is non-numeric".to_string(),
);
}
}
if do_refs {
for m in g.rej_mutex_id.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/MutuallyExclusiveSpecifiers",
"multiple specifiers on the same reference are not allowed".to_string(),
);
}
}
if do_fref {
for re in [
&g.rej_mutex_file_cross,
&g.rej_mutex_file_same,
] {
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/MutuallyExclusiveSpecifiers",
"multiple specifiers on the same reference are not allowed".to_string(),
);
}
}
}
if do_res {
for m in g.rej_mutex_res.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/MutuallyExclusiveSpecifiers",
"multiple specifiers on the same reference are not allowed".to_string(),
);
}
if do_refs {
for m in g.rej_mutex_inter_id.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/MutuallyExclusiveSpecifiers",
"multiple specifiers on the same reference are not allowed".to_string(),
);
}
}
if do_fref {
for re in [
&g.rej_mutex_inter_file_cross,
&g.rej_mutex_inter_file_same,
] {
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/MutuallyExclusiveSpecifiers",
"multiple specifiers on the same reference are not allowed".to_string(),
);
}
}
}
}
if do_refs {
for m in g.rej_empty_bmr_id.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/EmptyBookmarkRange",
"bookmark range '##,' has no bookmark names".to_string(),
);
}
}
if do_fref {
for re in [
&g.rej_empty_bmr_file_cross,
&g.rej_empty_bmr_file_same,
] {
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/EmptyBookmarkRange",
"bookmark range '##,' has no bookmark names".to_string(),
);
}
}
}
if do_res {
for m in g.rej_empty_bmr_res.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/EmptyBookmarkRange",
"bookmark range '##,' has no bookmark names".to_string(),
);
}
}
{
let sets: &[(&grammar::Regex, bool)] = &[
(&g.rej_bmr_nocomma_file_cross, do_fref),
(&g.rej_bmr_nocomma_file_same, do_fref),
(&g.rej_bmr_nocomma_id, do_refs),
(&g.rej_bmr_nocomma_res, do_res),
];
for (re, on) in sets {
if !*on {
continue;
}
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/EmptyBookmarkRange",
"bookmark range '##' has no bookmark names or comma".to_string(),
);
}
}
}
{
let sets: &[(&grammar::Regex, bool)] = &[
(&g.rej_empty_bm_spec_file_cross, do_fref),
(&g.rej_empty_bm_spec_file_same, do_fref),
(&g.rej_empty_bm_spec_id, do_refs),
(&g.rej_empty_bm_spec_res, do_res),
];
for (re, on) in sets {
if !*on {
continue;
}
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/EmptyBookmarkSpecifier",
"bookmark specifier '#' is missing a name".to_string(),
);
}
}
}
if do_refs {
for m in g.rej_tags_before_cat_id.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/TagsBeforeCategoryRef",
"tags must follow category in annotated reference".to_string(),
);
}
}
if do_fref {
for re in [
&g.rej_tags_before_cat_file_cross,
&g.rej_tags_before_cat_file_same,
] {
for m in re.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/TagsBeforeCategoryRef",
"tags must follow category in annotated reference".to_string(),
);
}
}
}
if do_res {
for m in g.rej_tags_before_cat_res.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/TagsBeforeCategoryResource",
"tags must follow category in annotated resource reference".to_string(),
);
}
}
if do_todos {
for m in g.rej_tags_before_cat_todo.find_iter(text).flatten() {
if !is_left_boundary(text, m.start()) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/TagsBeforeCategoryTodo",
"tags must follow category in annotated todo".to_string(),
);
}
}
if do_res {
for caps in g.rej_invalid_filename_chars.captures_iter(text).flatten() {
let m = caps.get(0).unwrap();
if !is_left_boundary(text, m.start()) {
continue;
}
let payload = &caps[1];
if payload.contains("..") {
continue; }
if g.valid_res_token.is_match(payload).unwrap_or(false) {
continue;
}
push_reject(
m.start(),
m.end(),
"Jots/Parsing/InvalidFilenameChars",
format!("filename ';;{}' contains invalid characters", payload),
);
}
}
}
fn is_valid_url_payload(payload: &str) -> bool {
if let Some(rest) = strip_paren_label(payload) {
return rest.starts_with("http://") || rest.starts_with("https://");
}
if let Some(rest) = strip_bracket_label(payload) {
return rest.starts_with("http://") || rest.starts_with("https://");
}
payload.starts_with("http://") || payload.starts_with("https://")
}
fn strip_paren_label(payload: &str) -> Option<&str> {
let bytes = payload.as_bytes();
if !bytes.starts_with(b"(") {
return None;
}
let close = payload[1..].find(')')?;
Some(&payload[1 + close + 1..])
}
fn strip_bracket_label(payload: &str) -> Option<&str> {
let bytes = payload.as_bytes();
if !bytes.starts_with(b"[") {
return None;
}
let close = payload[1..].find(']')?;
Some(&payload[1 + close + 1..])
}
fn has_unmatched_label_paren(payload: &str) -> bool {
let Some(rest) = strip_paren_label(payload) else {
return false;
};
if rest.starts_with("http://") || rest.starts_with("https://") {
return false;
}
let bytes = rest.as_bytes();
bytes.iter().any(|&b| b == b')')
&& bytes
.iter()
.take_while(|&&b| b != b' ' && b != b'\t' && b != b'\r' && b != b'\n')
.any(|&b| b == b')')
}
fn has_unmatched_label_bracket(payload: &str) -> bool {
let Some(rest) = strip_bracket_label(payload) else {
return false;
};
if rest.starts_with("http://") || rest.starts_with("https://") {
return false;
}
let bytes = rest.as_bytes();
bytes.iter().any(|&b| b == b']')
&& bytes
.iter()
.take_while(|&&b| b != b' ' && b != b'\t' && b != b'\r' && b != b'\n')
.any(|&b| b == b']')
}
fn resolve_overlaps(mut cand: Vec<Candidate>) -> (Vec<Candidate>, Vec<Candidate>) {
cand.sort_by(|a, b| {
a.start
.cmp(&b.start)
.then_with(|| (b.end - b.start).cmp(&(a.end - a.start)))
.then_with(|| a.kind.rank().cmp(&b.kind.rank()))
});
let mut winners: Vec<Candidate> = Vec::new();
let mut dropped_bookmarks: Vec<Candidate> = Vec::new();
let mut last_end: usize = 0;
let mut last_end_initialized = false;
let mut open_todo_idx: Option<usize> = None;
let mut open_todo_end: usize = 0;
let mut inside_last_end: usize = 0;
for c in cand {
if let Some(_idx) = open_todo_idx
&& c.start >= open_todo_end
{
open_todo_idx = None;
}
if let Some(idx) = open_todo_idx {
if c.kind.is_bookmark() {
dropped_bookmarks.push(c);
continue;
}
if c.end > open_todo_end {
continue;
}
if c.start < inside_last_end {
continue;
}
inside_last_end = c.end;
winners[idx].children.push(c);
continue;
}
if last_end_initialized && c.start < last_end {
continue;
}
let is_todo = c.kind.is_todo();
let span_end = c.end;
let span_start = c.start;
winners.push(c);
last_end = span_end;
last_end_initialized = true;
if is_todo {
open_todo_idx = Some(winners.len() - 1);
open_todo_end = span_end;
inside_last_end = span_start;
}
}
(winners, dropped_bookmarks)
}