hecate/codegen/input_schema/

range.rs

use schemars::{JsonSchema, json_schema};
use std::borrow::Cow;
use std::str::FromStr;

use thiserror::Error;

use serde::{Deserialize, Serialize, de::Error};

use super::{RANGE_PATTERN, RawRepr};

#[derive(Clone, Debug, PartialEq)]
pub struct Range<T> {
    pub start: T,
    pub end: T,
    raw: String,
}

impl<T> Serialize for Range<T> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.raw)
    }
}
impl<T: JsonSchema> JsonSchema for Range<T> {
    fn schema_name() -> Cow<'static, str> {
        format!("Range<{}>", T::schema_name()).into()
    }

    fn schema_id() -> Cow<'static, str> {
        format!("{}::Range<{}>", module_path!(), T::schema_id()).into()
    }

    fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
        json_schema!({
            "type": "string",
            "pattern": RANGE_PATTERN
        })
    }

    fn inline_schema() -> bool {
        true
    }
}
// impl<T> JsonSchema for Range<T> {
//     fn schema_name() -> String {
//         String::from("Range")
//     }
//
//     fn json_schema(_gen: &mut schemars::r#gen::SchemaGenerator) -> schemars::schema::Schema {
//         let mut schema = SchemaObject::default();
//         //schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
//         schema.subschemas = Some(Box::new(SubschemaValidation {
//             one_of: Some(vec![
//                 // Schema for string type
//                 Schema::Object(SchemaObject {
//                     instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
//                     string: Some(Box::new(StringValidation {
//                         pattern: Some(RANGE_PATTERN.to_string()),
//                         ..Default::default()
//                     })),
//                     ..Default::default()
//                 }),
//                 // Schema for number type
//                 Schema::Object(SchemaObject {
//                     instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Number))),
//                     ..Default::default()
//                 }),
//             ]),
//             ..Default::default()
//         }));
//
//         Schema::Object(schema)
//     }
// }

impl<'de, T> Deserialize<'de> for Range<T>
where
    T: FromStr,
    T::Err: std::error::Error + 'static,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let raw: String = Deserialize::deserialize(deserializer)?;
        let range: Range<T> = raw.parse().map_err(|e| D::Error::custom(e))?;

        Ok(range)
    }
}

impl<T> RawRepr for Range<T> {
    /// Returns a raw string representation as written by the user.
    fn raw(&self) -> &str {
        &self.raw
    }
}

#[derive(Debug, Error, PartialEq)]
pub enum ParseRangeError<T: FromStr>
where
    T::Err: std::error::Error + 'static,
{
    #[error("Wrong number of elements for a range, it should be 2. Example: 0 .. 1")]
    WrongArgNumber,
    #[error("Failed to parse start bound: {0}")]
    InvalidStart(#[source] T::Err),
    #[error("Failed to parse end bound: {0}")]
    InvalidEnd(#[source] T::Err),
}

use super::quantity;

impl<T> FromStr for Range<T>
where
    T: FromStr,
    T::Err: std::error::Error + 'static,
{
    type Err = ParseRangeError<T>;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.split("..").map(|part| part.trim()).collect();

        if parts.len() != 2 {
            return Err(ParseRangeError::WrongArgNumber);
        }

        let start_unit = quantity::get_unit(parts[0]);
        let end_unit = quantity::get_unit(parts[1]);

        let mut start = parts[0].to_string();
        let mut end = parts[1].to_string();
        if start_unit.is_some() && end_unit.is_none() {
            end += start_unit.expect("already checked")
        } else if start_unit.is_none() && end_unit.is_some() {
            start += end_unit.expect("already checked")
        }

        let start: T = start
            .parse()
            .map_err(|e| ParseRangeError::InvalidStart(e))?;
        let end: T = end.parse().map_err(|e| ParseRangeError::InvalidEnd(e))?;

        Ok(Range {
            start,
            end,
            raw: s.to_string(),
        })
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    use super::quantity::*;

    #[test]
    fn same_unit_when_only_one() {
        let raw = "0..1dm2";
        let range: Range<Area> = raw.parse().expect("valid range should be parsed");
        assert_eq!(
            range,
            Range {
                start: "0dm2".parse().unwrap(),
                end: "1dm2".parse().unwrap(),
                raw: raw.to_string()
            }
        );
    }

    #[test]
    fn different_units() {
        let raw = "10km^+2..1m2";
        let range: Range<Area> = raw.parse().expect("valid range should be parsed");
        assert_eq!(
            range,
            Range {
                start: "10km^+2".parse().unwrap(),
                end: "1m2".parse().unwrap(),
                raw: raw.to_string()
            }
        );
    }

    #[test]
    fn parse_valid_range() {
        let raw = "0 .. 1";
        let range: Range<i32> = raw.parse().expect("Valid range should be parsed");
        assert_eq!(
            range,
            Range {
                start: 0,
                end: 1,
                raw: raw.to_string()
            }
        )
    }
    #[test]
    fn serialize_range() {
        let range = Range {
            start: 0,
            end: 1,
            raw: "0 .. 1".to_string(),
        };
        let serialized = serde_json::to_string(&range).expect("Serialization should succeed");
        assert_eq!(serialized, "\"0 .. 1\"");
    }
    //
    //#[test]
    //fn deserialize_range() {
    //    let raw = "\"0 .. 1\"";
    //    let range: Range<i32> = serde_json::from_str(raw).expect("Deserialization should succeed");
    //    assert_eq!(
    //        range,
    //        Range {
    //            start: 0,
    //            end: 1,
    //            raw: "0 .. 1".to_string()
    //        }
    //    );
    //}

    #[test]
    fn parse_invalid_range_wrong_arg_number() {
        let raw = "0 .. 1 .. 2";
        let result: Result<Range<i32>, _> = raw.parse();
        assert_eq!(result.unwrap_err(), ParseRangeError::WrongArgNumber);
    }

    #[test]
    fn parse_invalid_range_invalid_start() {
        let raw = "a .. 1";
        let result: Result<Range<i32>, _> = raw.parse();
        assert_eq!(
            result.unwrap_err(),
            ParseRangeError::InvalidStart("a".parse::<i32>().unwrap_err())
        );
    }

    #[test]
    fn parse_invalid_range_invalid_end() {
        let raw = "0 .. b";
        let result: Result<Range<i32>, _> = raw.parse();
        assert_eq!(
            result.unwrap_err(),
            ParseRangeError::InvalidEnd("b".parse::<i32>().unwrap_err())
        );
    }

    #[test]
    fn parse_length_range() {
        let raw = "-1 .. 1";
        let range: Range<Length> = raw.parse().expect("Valid range should be parsed");
        assert_eq!(
            range,
            Range {
                start: "-1".parse().unwrap(),
                end: "1".parse().unwrap(),
                raw: raw.to_string()
            }
        )
    }
}