use sephera_core::config::CommentStyle;
use memchr::memmem;
use sephera_core::line_slices::LineSlices;
use super::types::LocMetrics;
#[derive(Clone, Copy)]
struct CommentTokens<'a> {
single_line: Option<&'a [u8]>,
multi_line_start: Option<&'a [u8]>,
multi_line_end: Option<&'a [u8]>,
}
impl<'a> From<&'a CommentStyle> for CommentTokens<'a> {
fn from(style: &'a CommentStyle) -> Self {
Self {
single_line: style.single_line.map(str::as_bytes),
multi_line_start: style.multi_line_start.map(str::as_bytes),
multi_line_end: style.multi_line_end.map(str::as_bytes),
}
}
}
impl<'a> CommentTokens<'a> {
#[must_use]
const fn is_commentless(self) -> bool {
self.single_line.is_none()
&& self.multi_line_start.is_none()
&& self.multi_line_end.is_none()
}
const fn openers(&self) -> [Option<&'a [u8]>; 2] {
[self.single_line, self.multi_line_start]
}
const fn block_delimiters(&self) -> [Option<&'a [u8]>; 2] {
[self.multi_line_start, self.multi_line_end]
}
}
fn shared_lead_byte(delimiters: &[Option<&[u8]>]) -> Option<u8> {
let mut candidates = delimiters
.iter()
.copied()
.flatten()
.filter(|delimiter| !delimiter.is_empty());
let first = candidates.next()?.first().copied()?;
candidates
.all(|delimiter| delimiter.first() == Some(&first))
.then_some(first)
}
fn find_delimiter(
rest: &[u8],
lead: u8,
delimiters: &[Option<&[u8]>],
) -> Option<usize> {
memchr::memchr_iter(lead, rest).find(|offset| {
delimiters
.iter()
.copied()
.flatten()
.any(|delimiter| rest[*offset..].starts_with(delimiter))
})
}
#[derive(Clone, Copy)]
enum CommentStartMatch {
SingleLine,
MultiLine(usize),
}
#[must_use]
pub fn scan_content(bytes: &[u8], style: &CommentStyle) -> LocMetrics {
if bytes.is_empty() {
return LocMetrics::zero();
}
let tokens = CommentTokens::from(style);
if tokens.is_commentless() {
return scan_commentless_content(bytes);
}
let mut metrics = LocMetrics::zero();
let mut block_comment_depth = 0_usize;
for line in LineSlices::new(bytes) {
classify_line(line, tokens, &mut block_comment_depth, &mut metrics);
}
metrics
}
fn next_block_delimiter(
rest: &[u8],
tokens: CommentTokens<'_>,
) -> Option<(usize, usize, bool)> {
let delimiters = tokens.block_delimiters();
let offset = shared_lead_byte(&delimiters).map_or_else(
|| fallback_delimiter(rest, &delimiters),
|lead| find_delimiter(rest, lead, &delimiters),
)?;
let here = &rest[offset..];
if let Some(close) = tokens
.multi_line_end
.filter(|close| here.starts_with(close))
{
return Some((offset, close.len(), false));
}
tokens
.multi_line_start
.filter(|open| here.starts_with(open))
.map(|open| (offset, open.len(), true))
}
fn fallback_delimiter(
rest: &[u8],
delimiters: &[Option<&[u8]>],
) -> Option<usize> {
let [first, second] = delimiters else {
return None;
};
let first_at = first
.filter(|token| !token.is_empty())
.and_then(|token| memmem::find(rest, token));
let second_at = second
.filter(|token| !token.is_empty())
.and_then(|token| memmem::find(rest, token));
match (first_at, second_at) {
(Some(first_at), Some(second_at)) if first_at < second_at => {
Some(first_at)
}
(_, Some(second_at)) => Some(second_at),
(Some(first_at), None) => Some(first_at),
(None, None) => None,
}
}
fn classify_line(
line: &[u8],
tokens: CommentTokens<'_>,
block_comment_depth: &mut usize,
metrics: &mut LocMetrics,
) {
let mut has_code = false;
let mut has_comment = false;
let mut index = 0_usize;
while index < line.len() {
if *block_comment_depth > 0 {
let rest = &line[index..];
let Some((offset, length, opens)) =
next_block_delimiter(rest, tokens)
else {
if rest.iter().any(|byte| !byte.is_ascii_whitespace()) {
has_comment = true;
}
break;
};
if opens {
*block_comment_depth += 1;
} else {
*block_comment_depth -= 1;
}
index += offset + length;
has_comment = true;
continue;
}
if has_code {
let rest = &line[index..];
let Some(offset) = find_comment_delimiter(rest, tokens) else {
break;
};
match match_comment_start(&rest[offset..], tokens) {
Some(CommentStartMatch::SingleLine) => {
has_comment = true;
break;
}
Some(CommentStartMatch::MultiLine(length)) => {
*block_comment_depth = 1;
has_comment = true;
index += offset + length;
}
None => break,
}
continue;
}
if line[index].is_ascii_whitespace() {
index += 1;
continue;
}
if let Some(comment_start) = match_comment_start(&line[index..], tokens)
{
match comment_start {
CommentStartMatch::SingleLine => {
has_comment = true;
break;
}
CommentStartMatch::MultiLine(length) => {
*block_comment_depth = 1;
has_comment = true;
index += length;
continue;
}
}
}
has_code = true;
index += 1;
}
if has_code {
metrics.code_lines += 1;
} else if has_comment {
metrics.comment_lines += 1;
} else {
metrics.empty_lines += 1;
}
}
#[must_use]
fn scan_commentless_content(bytes: &[u8]) -> LocMetrics {
let mut metrics = LocMetrics::zero();
for line in LineSlices::new(bytes) {
if line.iter().all(u8::is_ascii_whitespace) {
metrics.empty_lines += 1;
} else {
metrics.code_lines += 1;
}
}
metrics
}
fn find_comment_delimiter(
rest: &[u8],
tokens: CommentTokens<'_>,
) -> Option<usize> {
let delimiters = tokens.openers();
if let Some(lead) = shared_lead_byte(&delimiters) {
return find_delimiter(rest, lead, &delimiters);
}
let single_at = delimiters[0].and_then(|token| memmem::find(rest, token));
let multi_at = delimiters[1].and_then(|token| memmem::find(rest, token));
single_at.into_iter().chain(multi_at).min()
}
fn match_comment_start(
line: &[u8],
tokens: CommentTokens<'_>,
) -> Option<CommentStartMatch> {
let single_line_length = tokens
.single_line
.filter(|single_line| line.starts_with(single_line))
.map(<[u8]>::len);
let multi_line_length = tokens
.multi_line_start
.filter(|multi_line_start| line.starts_with(multi_line_start))
.map(<[u8]>::len);
match (single_line_length, multi_line_length) {
(Some(single_line_length), Some(multi_line_length))
if multi_line_length >= single_line_length =>
{
Some(CommentStartMatch::MultiLine(multi_line_length))
}
(Some(_), Some(_) | None) => Some(CommentStartMatch::SingleLine),
(None, Some(multi_line_length)) => {
Some(CommentStartMatch::MultiLine(multi_line_length))
}
(None, None) => None,
}
}