use super::funejson::Value; use super::text_pattern_match::matches_pattern; use super::validation_email::is_email; // ASCII whitespace only, so all three languages trim the same characters // (str::trim would also take Unicode spaces). fn trim_ascii(value: &str) -> &str { value.trim_matches(|c: char| matches!(c, ' ' | '\t' | '\n' | '\r' | '\x0c' | '\x0b')) } // "Full name" starts a sentence; after "Enter" it is "full name". A label that // starts with an acronym ("UK phone number") is left as it is. fn lower_first(label: &str) -> String { let bytes = label.as_bytes(); let upper = |i: usize| i < bytes.len() && bytes[i].is_ascii_uppercase(); if upper(0) && !upper(1) { let mut out = String::with_capacity(label.len()); out.push(bytes[0].to_ascii_lowercase() as char); out.push_str(&label[1..]); out } else { label.to_string() } } /// A decimal: sign, whole digits without leading zeros, fraction digits /// without trailing zeros; zero is (false, "", ""). struct Decimal { negative: bool, whole: String, fraction: String, } // ASCII digits only: "٣" is not a digit in any of the three languages. fn is_digits(s: &str) -> bool { !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit()) } // -12, 12.5, .5 and 0.50: ASCII digits, one optional point, an optional // leading minus. No exponent, no grouping, no plus: what a person types. fn parse_decimal(text: &str, integer: bool) -> Option { let mut s = text; let mut negative = false; if let Some(rest) = s.strip_prefix('-') { negative = true; s = rest; } let (whole, fraction) = match s.find('.') { Some(point) => { if integer { return None; } let (whole, fraction) = (&s[..point], &s[point + 1..]); if !is_digits(fraction) || (!whole.is_empty() && !is_digits(whole)) { return None; } (whole, fraction) } None => { if !is_digits(s) { return None; } (s, "") } }; let whole = whole.trim_start_matches('0').to_string(); let fraction = fraction.trim_end_matches('0').to_string(); if whole.is_empty() && fraction.is_empty() { negative = false; // -0 is 0 } Some(Decimal { negative, whole, fraction }) } fn compare_magnitude(a: &Decimal, b: &Decimal) -> i32 { if a.whole.len() != b.whole.len() { return if a.whole.len() < b.whole.len() { -1 } else { 1 }; } if a.whole != b.whole { return if a.whole < b.whole { -1 } else { 1 }; } let width = a.fraction.len().max(b.fraction.len()); let fa = format!("{:0 i32 { if a.negative != b.negative { return if a.negative { -1 } else { 1 }; } let m = compare_magnitude(a, b); if a.negative { -m } else { m } } fn bound(name: &str, text: &Option) -> Option { let text = text.as_deref()?; match parse_decimal(text, false) { Some(d) => Some(d), None => panic!("rules.{} must be a decimal number, such as \"0\" or \"-2.5\" (got \"{}\")", name, text), } } fn fail(code: &str, message: String) -> InputCheck { InputCheck { valid: false, value: None, code: Some(code.to_string()), message: Some(message) } } /// One input checked as a GOV.UK form checks it: empty first, then length, /// then the format its kind needs, then the pattern, then the range, each /// failure with the message to show. /// /// # Panics /// The rules are the caller's, so a bad one panics whatever was typed: an /// empty label, an unknown kind, a negative or crossed length, min or max on a /// text or email input or not a decimal, min above max, or a pattern /// text.pattern-match refuses. pub fn validate_input(value: &str, rules: &InputRules) -> InputCheck { let label = trim_ascii(&rules.label); if label.is_empty() { panic!("an input needs a label, such as \"Full name\", to write its error messages"); } let kind = rules.kind.as_str(); let numeric = kind == "number" || kind == "integer"; if kind != "text" && kind != "email" && !numeric { panic!("unknown input kind \"{}\"", kind); } if matches!(rules.min_length, Some(n) if n < 0) { panic!("rules.minLength must not be negative"); } if matches!(rules.max_length, Some(n) if n < 0) { panic!("rules.maxLength must not be negative"); } if let (Some(lo), Some(hi)) = (rules.min_length, rules.max_length) { if lo > hi { panic!("rules.minLength must not be more than rules.maxLength"); } } if !numeric && rules.min.is_some() { panic!("rules.min only applies to number and integer inputs"); } if !numeric && rules.max.is_some() { panic!("rules.max only applies to number and integer inputs"); } let low_bound = bound("min", &rules.min); let high_bound = bound("max", &rules.max); if let (Some(lo), Some(hi)) = (&low_bound, &high_bound) { if compare_decimal(lo, hi) > 0 { panic!("rules.min must not be more than rules.max"); } } // A bad pattern fails here, on every call, not only when someone types. if let Some(pattern) = &rules.pattern { matches_pattern(pattern, ""); } let text = trim_ascii(value); if text.is_empty() { if rules.required { return fail("required", format!("Enter {}", lower_first(label))); } return InputCheck { valid: true, value: Some(String::new()), code: None, message: None }; } let length = text.chars().count() as i64; if let Some(max) = rules.max_length { if length > max { return fail("too-long", format!("{} must be {} characters or less", label, max)); } } if let Some(min) = rules.min_length { if length < min { return fail("too-short", format!("{} must be {} characters or more", label, min)); } } let mut number: Option = None; if kind == "email" && !is_email(text) { return fail("email", "Enter an email address in the correct format, like name@example.com".to_string()); } if kind == "number" { number = parse_decimal(text, false); if number.is_none() { return fail("number", format!("{} must be a number", label)); } } if kind == "integer" { number = parse_decimal(text, true); if number.is_none() { return fail("integer", format!("{} must be a whole number", label)); } } if let Some(pattern) = &rules.pattern { if !matches_pattern(pattern, text) { let message = match &rules.pattern_message { Some(m) => m.clone(), None => format!("Enter {} in the correct format", lower_first(label)), }; return fail("pattern", message); } } if let Some(n) = &number { let low = low_bound.as_ref().is_some_and(|lo| compare_decimal(n, lo) < 0); let high = high_bound.as_ref().is_some_and(|hi| compare_decimal(n, hi) > 0); if low || high { let code = if low { "too-small" } else { "too-large" }; let min = rules.min.as_deref().unwrap_or(""); let max = rules.max.as_deref().unwrap_or(""); if low_bound.is_some() && high_bound.is_some() { return fail(code, format!("{} must be between {} and {}", label, min, max)); } if low { return fail(code, format!("{} must be {} or more", label, min)); } return fail(code, format!("{} must be {} or less", label, max)); } } InputCheck { valid: true, value: Some(text.to_string()), code: None, message: None } } pub fn input_check_to_value(check: &InputCheck) -> Value { let text = |v: &Option| v.as_deref().map(Value::str).unwrap_or(Value::Null); Value::obj(vec![ ("valid", Value::Bool(check.valid)), ("value", text(&check.value)), ("code", text(&check.code)), ("message", text(&check.message)), ]) } pub fn input_rules_from_value(v: &Value) -> InputRules { let text = |key: &str| match v.get(key) { Value::Str(s) => Some(s.clone()), _ => None, }; let int = |key: &str| match v.get(key) { Value::Int(n) => Some(*n), Value::Float(f) if f.fract() == 0.0 => Some(*f as i64), Value::Float(_) => panic!("rules.{} must be an integer", key), _ => None, }; InputRules { label: text("label").unwrap_or_default(), kind: text("kind").unwrap_or_default(), required: v.get("required").as_bool(), min_length: int("minLength"), max_length: int("maxLength"), pattern: text("pattern"), pattern_message: text("patternMessage"), min: text("min"), max: text("max"), } } pub fn fune_vector(args: &[Value]) -> Value { input_check_to_value(&validate_input(args[0].as_str(), &input_rules_from_value(&args[1]))) }