5a24289898fd
gps.rs
/// Coordinates typed by a person: "51.5072, -0.1276", "51.5072 N 0.1276 W",
/// "51°30'26\"N 0°7'39\"W" (degrees, minutes, seconds; N/S/E/W or signs).
pub(crate) fn parse_gps(t: &str) -> Option<(f64, f64)> {
// typographic minus signs and dashes mean a negative value, like ASCII '-'
let t = t.trim();
if t.is_empty() || t.chars().take(129).count() > 128 {
return None;
}
let normalized = t.replace(['\u{2212}', '\u{2012}', '\u{2013}', '\u{FE63}', '\u{FF0D}'], "-");
let t = normalized.as_str();
if let Some((a, b)) = t.split_once(',') {
if b.contains(',') {
return None;
}
return parse_gps_pair(a, b);
}
// A suffix N/S marks the end of latitude; a prefix N/S uses the next hemisphere prefix as
// the boundary. If only longitude has a hemisphere, the whitespace pass below handles it.
let mut parsed: Option<(f64, f64)> = None;
let mut latitude_markers = t.char_indices().filter(|(_, c)| matches!(c, 'N' | 'S' | 'n' | 's'));
if let Some((first, marker)) = latitude_markers.next() {
if first == 0 {
if let Some((second, _)) = t.char_indices().skip(1).find(|(_, c)| is_gps_hemisphere(*c))
&& let Some(pair) = parse_gps_pair(t.get(..second)?, t.get(second..)?)
{
parsed = Some(pair);
}
} else {
let end = first.checked_add(marker.len_utf8())?;
return parse_gps_pair(t.get(..end)?, t.get(end..)?);
}
}
// A comma-free pair can be separated by whitespace. Trying each boundary also permits spaces
// between DMS components without letting unconsumed text vanish. If multiple boundaries parse,
// they must agree so ambiguous text cannot be reinterpreted.
for (at, separator) in t.char_indices().filter(|(_, c)| c.is_whitespace()) {
let after = at.checked_add(separator.len_utf8())?;
if let Some(pair) = parse_gps_pair(t.get(..at)?, t.get(after..)?) {
match parsed {
Some(previous) if previous != pair => return None,
None => parsed = Some(pair),
Some(_) => {}
}
}
}
parsed
}
#[derive(Clone, Copy)]
enum GpsAxis {
Latitude,
Longitude,
}
fn is_gps_hemisphere(c: char) -> bool {
matches!(c, 'N' | 'S' | 'E' | 'W' | 'n' | 's' | 'e' | 'w')
}
fn parse_gps_pair(latitude: &str, longitude: &str) -> Option<(f64, f64)> {
Some((parse_gps_coordinate(latitude, GpsAxis::Latitude)?, parse_gps_coordinate(longitude, GpsAxis::Longitude)?))
}
fn parse_gps_coordinate(text: &str, axis: GpsAxis) -> Option<f64> {
let text = text.trim();
if text.is_empty() {
return None;
}
let prefix = ['N', 'S', 'E', 'W']
.into_iter()
.find_map(|h| text.strip_prefix(h).or_else(|| text.strip_prefix(h.to_ascii_lowercase())).map(|rest| (h, rest)));
let suffix = ['N', 'S', 'E', 'W']
.into_iter()
.find_map(|h| text.strip_suffix(h).or_else(|| text.strip_suffix(h.to_ascii_lowercase())).map(|rest| (rest, h)));
let (body, hemisphere) = if let Some((h, body)) = prefix {
(body, Some(h))
} else if let Some((body, h)) = suffix {
(body, Some(h))
} else {
(text, None)
};
if body.chars().any(is_gps_hemisphere) {
return None;
}
let body = body.trim();
if body.is_empty() {
return None;
}
let hemisphere_negative = match (axis, hemisphere) {
(_, None) => None,
(GpsAxis::Latitude, Some('N')) | (GpsAxis::Longitude, Some('E')) => Some(false),
(GpsAxis::Latitude, Some('S')) | (GpsAxis::Longitude, Some('W')) => Some(true),
_ => return None,
};
let mut components = Vec::with_capacity(3);
let mut token = String::new();
let mut explicit_sign = None;
let mut degree_mark = false;
let mut minute_mark = false;
let mut second_mark = false;
for c in body.chars() {
match c {
'0'..='9' | '.' => token.push(c),
'+' | '-' if components.is_empty() && token.is_empty() => token.push(c),
c if c.is_whitespace() => flush_gps_number(&mut token, &mut components, &mut explicit_sign)?,
'°' => {
flush_gps_number(&mut token, &mut components, &mut explicit_sign)?;
if components.len() != 1 || degree_mark || minute_mark || second_mark {
return None;
}
degree_mark = true;
}
'\'' | '′' => {
flush_gps_number(&mut token, &mut components, &mut explicit_sign)?;
if components.len() != 2 || minute_mark || second_mark {
return None;
}
minute_mark = true;
}
'"' | '″' => {
flush_gps_number(&mut token, &mut components, &mut explicit_sign)?;
if components.len() != 3 || !minute_mark || second_mark {
return None;
}
second_mark = true;
}
_ => return None,
}
}
flush_gps_number(&mut token, &mut components, &mut explicit_sign)?;
let [degrees, rest @ ..] = components.as_slice() else { return None };
if rest.iter().any(|v| *v < 0.0 || *v >= 60.0) {
return None;
}
let magnitude = degrees.abs() + rest.first().copied().unwrap_or(0.0) / 60.0 + rest.get(1).copied().unwrap_or(0.0) / 3600.0;
if !magnitude.is_finite() {
return None;
}
let negative = match (hemisphere_negative, explicit_sign) {
(Some(hemisphere_negative), Some(explicit_negative)) if hemisphere_negative != explicit_negative => return None,
(Some(hemisphere_negative), _) => hemisphere_negative,
(None, Some(explicit_negative)) => explicit_negative,
(None, None) => false,
};
let value = if negative { -magnitude } else { magnitude };
let limit = match axis {
GpsAxis::Latitude => 90.0,
GpsAxis::Longitude => 180.0,
};
(value.is_finite() && value.abs() <= limit).then_some(value)
}
fn flush_gps_number(token: &mut String, components: &mut Vec<f64>, explicit_sign: &mut Option<bool>) -> Option<()> {
if token.is_empty() {
return Some(());
}
if components.len() == 3 {
return None;
}
let value = token.parse::<f64>().ok()?;
if !value.is_finite() {
return None;
}
if components.is_empty() && (token.starts_with('-') || token.starts_with('+')) {
*explicit_sign = Some(token.starts_with('-'));
}
components.push(value);
token.clear();
Some(())
}
#[cfg(test)]
mod gps_tests {
use serde_json::json;
#[test]
fn coordinates_people_type() {
let p = super::parse_gps;
assert_eq!(p("51.5072, -0.1276"), Some((51.5072, -0.1276)));
assert_eq!(p("10 20 30"), None);
assert_eq!(p("10 20"), Some((10.0, 20.0)));
let (la, lo) = p("51°30'26\"N 0°7'39\"W").unwrap();
assert!((la - 51.50722).abs() < 1e-4 && (lo + 0.1275).abs() < 1e-4, "{la} {lo}");
let (la, lo) = p("33.8688 S, 151.2093 E").unwrap();
assert!((la + 33.8688).abs() < 1e-9 && (lo - 151.2093).abs() < 1e-9);
assert_eq!(p("51.5 N 0.1 W"), Some((51.5, -0.1)));
assert_eq!(p("N 51.5072 W 0.1276"), Some((51.5072, -0.1276)));
assert_eq!(p("S 33.8688 E 151.2093"), Some((-33.8688, 151.2093)));
assert_eq!(p("\u{2212}33.8688, 151.2093"), Some((-33.8688, 151.2093)));
assert_eq!(p("51.5072 -0.1276"), Some((51.5072, -0.1276)));
assert_eq!(p("51.5072 0.1276 W"), Some((51.5072, -0.1276)));
let (la, lo) = p("51° 30' 26\" 0° 7' 39\"").unwrap();
assert!((la - 51.50722).abs() < 1e-4 && (lo - 0.1275).abs() < 1e-4, "{la} {lo}");
assert_eq!(p("95, 10"), None);
assert_eq!(p("hello"), None);
assert_eq!(p("s 33.8688 e 151.2093"), Some((-33.8688, 151.2093)));
assert_eq!(p("0N, 0E"), Some((0.0, 0.0)));
assert_eq!(p("90N, 180E"), Some((90.0, 180.0)));
assert_eq!(p("90S, 180W"), Some((-90.0, -180.0)));
}
#[test]
fn gps_does_not_reinterpret_exponents() {
assert_eq!(super::parse_gps("1e-3, 2e-3"), None);
}
#[test]
fn gps_rejects_wrong_axis_or_conflicting_hemispheres() {
let p = super::parse_gps;
assert_eq!(p("45E, 7N"), None);
assert_eq!(p("45E 7N"), None);
assert_eq!(p("45NS, 7E"), None);
assert_eq!(p("-45N, 7E"), None);
assert_eq!(p("45N 7NE"), None);
}
#[test]
fn gps_tries_whitespace_split_when_prefix_marker_split_fails() {
assert_eq!(super::parse_gps("N51 0E"), Some((51.0, 0.0)));
}
#[test]
fn gps_rejects_unconsumed_coordinate_text() {
assert_eq!(super::parse_gps("garbage45, 7junk"), None);
}
#[test]
fn gps_rejects_oversized_coordinate_text() {
let input = format!("{}, 0", "0".repeat(129));
assert_eq!(super::parse_gps(&input), None);
}
#[test]
fn gps_rejects_invalid_dms_components() {
let p = super::parse_gps;
assert_eq!(p("45°60'0\"N, 7E"), None);
assert_eq!(p("45°0'60\"N, 7E"), None);
assert_eq!(p("45°-1'0\"N, 7E"), None);
assert_eq!(p("45°0'-1\"N, 7E"), None);
}
#[test]
fn gps_rejected_text_does_not_change_metadata() {
let mut s = crate::Session::with_demo();
let ids: Vec<_> = s.catalog.photos().take(2).map(|photo| photo.id).collect();
assert_eq!(ids.len(), 2, "demo has two records for the batch check");
let id_values: Vec<_> = ids.iter().map(|id| id.0).collect();
s.execute("library.select", &json!({"ids": id_values})).unwrap();
s.execute("photo.setMeta", &json!({"title": "Before"})).unwrap();
s.execute("develop.set", &json!({"control": "light.exposure", "value": 0.25})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert!(!s.redo.is_empty(), "rejection must preserve a populated redo history");
let snapshot = s.catalog.to_snapshot();
let revision = s.catalog.revision;
let selection = s.selection.clone();
let commits = s.commits();
let undo = format!("{:?}", s.undo);
let redo = format!("{:?}", s.redo);
let error = s.execute("photo.setMeta", &json!({"gps": "garbage45, 7junk", "title": "After"})).unwrap_err();
assert!(matches!(error, crate::EngineError::BadParams { ref cmd, .. } if cmd == "photo.setMeta"), "{error}");
assert_eq!(s.catalog.to_snapshot(), snapshot, "catalog data is unchanged");
assert_eq!(s.catalog.revision, revision, "catalog revision is unchanged");
assert_eq!(s.selection, selection, "selection is unchanged");
assert_eq!(s.commits(), commits, "commit count is unchanged");
assert_eq!(format!("{:?}", s.undo), undo, "undo history is unchanged");
assert_eq!(format!("{:?}", s.redo), redo, "redo history is unchanged");
for id in ids {
assert_eq!(s.catalog.photo(id).map(|photo| photo.meta.title.as_str()), Some("Before"));
}
}
#[test]
fn gps_valid_edit_is_one_undo_step() {
let mut s = crate::Session::with_demo();
let id = s.active().or_else(|| s.catalog.photos().next().map(|photo| photo.id)).unwrap();
let previous = s.catalog.photo(id).unwrap().meta.clone();
let commits = s.commits();
s.execute("photo.setMeta", &json!({"gps": "48°51'30\"N 2°17'40\"E", "title": "GPS edited"})).unwrap();
let photo = s.catalog.photo(id).unwrap();
assert_eq!(photo.meta.title, "GPS edited");
assert!(photo.meta.gps.is_some());
assert_eq!(s.commits(), commits + 1);
s.execute("edit.undo", &json!({})).unwrap();
let photo = s.catalog.photo(id).unwrap();
assert_eq!(photo.meta.title, previous.title);
assert_eq!(photo.meta.gps, previous.gps);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.