use indicatrix_formats::{
asc::{AscSchedule, to_asc_string},
gcs::{gcs_to_asc_schedule, parse_gcs_bytes},
gem::{gem_to_asc_schedule, parse_gem},
native::{
LEGACY_NATIVE_EXTENSION_SUFFIX, NATIVE_EXTENSION_SUFFIX,
design::{DESIGN_EXTENSION, FileKind, detect_kind},
},
};
#[cfg(test)]
mod tests;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InputFileKind {
Asc,
Design,
Sidecar,
Gem,
Gcs,
Hdr,
}
impl InputFileKind {
#[must_use]
pub fn from_file_name(file_name: &str) -> Option<Self> {
let lower = file_name.to_ascii_lowercase();
let extension = lower.rsplit_once('.').map(|(_, ext)| ext)?;
match extension {
"asc" => Some(Self::Asc),
ext if ext == DESIGN_EXTENSION => Some(Self::Design),
"toml" => Some(Self::Sidecar),
"gem" => Some(Self::Gem),
"gcs" => Some(Self::Gcs),
"hdr" => Some(Self::Hdr),
_ => None,
}
}
#[must_use]
pub fn classify(file_name: &str, bytes: &[u8]) -> Option<Self> {
let by_name = Self::from_file_name(file_name)?;
if !matches!(by_name, Self::Design | Self::Sidecar) {
return Some(by_name);
}
Some(match detect_kind(bytes) {
FileKind::Design => Self::Design,
FileKind::OverlaySidecar => Self::Sidecar,
FileKind::Unknown => by_name,
})
}
#[must_use]
pub const fn is_design(self) -> bool {
!matches!(self, Self::Hdr)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConvertedDesign {
pub asc_file_name: String,
pub asc_text: String,
pub warnings: Vec<String>,
}
#[must_use]
pub fn converted_asc_file_name(file_name: &str) -> String {
let base = file_name.rsplit(['/', '\\']).next().unwrap_or(file_name);
let stem = base.rsplit_once('.').map_or(base, |(stem, _)| stem);
if stem.is_empty() {
format!("{base}.asc")
} else {
format!("{stem}.asc")
}
}
pub fn convert_foreign_design(
file_name: &str,
kind: InputFileKind,
bytes: &[u8],
) -> Result<ConvertedDesign, String> {
let (mut schedule, dotted) = match kind {
InputFileKind::Gem => (
parse_gem(bytes)
.map(|design| gem_to_asc_schedule(&design))
.map_err(|e| format!("not a readable .gem file: {e}"))?,
".gem",
),
InputFileKind::Gcs => (
parse_gcs_bytes(bytes)
.map(|design| gcs_to_asc_schedule(&design))
.map_err(|e| format!("not a readable .gcs file: {e}"))?,
".gcs",
),
other => return Err(format!("{other:?} is not a .gem or .gcs design")),
};
if schedule.tiers.is_empty() {
return Err(format!("the {dotted} file describes no facets"));
}
flatten_line_breaks(&mut schedule);
let warnings = std::mem::take(&mut schedule.warnings);
let asc_text = to_asc_string(&schedule)
.map_err(|e| format!("its cutting instructions cannot be written as .asc: {e}"))?;
Ok(ConvertedDesign {
asc_file_name: converted_asc_file_name(file_name),
asc_text,
warnings,
})
}
fn flatten_line_breaks(schedule: &mut AscSchedule) {
let one_line = |text: &str| -> String {
text.split(['\r', '\n'])
.map(str::trim)
.filter(|part| !part.is_empty())
.collect::<Vec<_>>()
.join(" ")
};
for header in &mut schedule.headers {
*header = one_line(header);
}
for footnote in &mut schedule.footnotes {
*footnote = one_line(footnote);
}
for tier in &mut schedule.tiers {
tier.notes = one_line(&tier.notes);
}
}
#[must_use]
pub fn asc_name_for_native(native_file_name: &str) -> Option<String> {
let lower = native_file_name.to_ascii_lowercase();
[NATIVE_EXTENSION_SUFFIX, LEGACY_NATIVE_EXTENSION_SUFFIX]
.into_iter()
.find_map(|suffix| {
let dotted = format!(".{suffix}");
lower.ends_with(&dotted).then(|| {
format!(
"{}.asc",
&native_file_name[..native_file_name.len() - dotted.len()]
)
})
})
}
#[must_use]
pub fn paired_asc_index(
recorded_asc_name: &str,
native_file_name: &str,
asc_names: &[&str],
) -> Option<usize> {
let by_name = |wanted: &str| {
asc_names
.iter()
.position(|name| *name == wanted)
.or_else(|| {
asc_names
.iter()
.position(|name| name.eq_ignore_ascii_case(wanted))
})
};
by_name(recorded_asc_name)
.or_else(|| asc_name_for_native(native_file_name).and_then(|guess| by_name(&guess)))
.or_else(|| (asc_names.len() == 1).then_some(0))
}
#[must_use]
pub fn sanitize_file_name(title: &str) -> String {
let cleaned: String = title
.chars()
.map(|c| {
if matches!(c, '\\' | '/' | ':' | '*' | '?' | '"' | '<' | '>' | '|') {
'_'
} else {
c
}
})
.collect();
let trimmed = cleaned.trim();
if trimmed.is_empty() {
"design".to_string()
} else {
trimmed.to_string()
}
}
#[must_use]
pub fn suggested_asc_file_name(asc_filename: Option<&str>, headers: &[String]) -> String {
if let Some(name) = asc_filename {
return name.to_string();
}
match headers.first() {
Some(header) if !header.trim().is_empty() => {
format!("{}.asc", sanitize_file_name(header))
}
_ => "edited_design.asc".to_string(),
}
}
#[must_use]
pub fn native_file_name_for_asc(asc_file_name: &str) -> String {
let stem = asc_file_name
.rsplit_once('.')
.filter(|(stem, _)| !stem.is_empty())
.map_or(asc_file_name, |(stem, _)| stem);
format!("{stem}.{NATIVE_EXTENSION_SUFFIX}")
}
#[must_use]
pub fn cutting_sheet_file_name(asc_file_name: &str) -> String {
format!(
"{}_cutting_sheet.html",
asc_file_name.trim_end_matches(".asc")
)
}
#[must_use]
pub fn diagram_file_name(asc_file_name: &str) -> String {
format!("{}_diagram.png", asc_file_name.trim_end_matches(".asc"))
}
pub const NOT_CLOSED_SOLID_MARKER: &str = "NOT A CLOSED SOLID";
#[must_use]
pub fn degenerate_marker_header(headers: &[String], message: &str) -> Option<String> {
let already_marked = headers
.first()
.is_some_and(|h| h.starts_with(NOT_CLOSED_SOLID_MARKER));
(!already_marked).then(|| format!("{NOT_CLOSED_SOLID_MARKER} -- {message}"))
}