specta-elm 0.0.1

use specta::{Types, datatype::Tuple};

use crate::{
    Error, Exporter,
    module::ModuleImports,
    types::{NDT, primitive::NULL},
};

pub fn render<E: Exporter>(
    s: &mut String,
    imports: &mut ModuleImports,
    exporter: &E,
    types: &Types,
    ndt: &NDT,
    t: &Tuple,
) -> Result<(), Error> {
    match t.elements.as_slice() {
        [] => s.push_str(NULL),
        elements => {
            s.push('[');
            for (idx, dt) in elements.iter().enumerate() {
                if idx != 0 {
                    s.push_str(", ");
                }
                let mut element_location = Vec::from([ndt.rust_type_path()]);
                element_location.push(idx.to_string().into());
                ndt.render(s, imports, exporter, types, dt, None)?;
            }
            s.push(']');
        }
    }

    Ok(())
}

#[cfg(test)]
#[allow(dead_code)]
mod test {
    use specta::{Type, Types};

    use crate::{Elm, SingleFileExporter};

    #[derive(Type)]
    struct One(String);
    #[derive(Type)]
    struct Two(String, String);
    #[derive(Type)]
    struct Three(String, String, String);
    #[derive(Type)]
    struct MetaThree(One, Two, Three);

    #[test]
    fn tuples() {
        let types = Types::default()
            .register::<One>()
            .register::<Two>()
            .register::<Three>()
            .register::<MetaThree>();
        let mut elm = Elm::init(types, "gen/test_ok");
        elm.export(SingleFileExporter("Tuples.elm")).unwrap();
    }
}