tengri/dsl/src/lib.rs

#![feature(adt_const_params)]
#![feature(type_alias_impl_trait)]
#![feature(impl_trait_in_fn_trait_return)]

pub(crate) use self::Value::*;
pub(crate) use self::ParseError::*;
pub(crate) use konst::iter::{ConstIntoIter, IsIteratorKind};
pub(crate) use konst::string::{split_at, str_range, char_indices};
pub(crate) use std::fmt::Debug;

mod dsl_error;   pub use self::dsl_error::*;
mod dsl_token;   pub use self::dsl_token::*;
mod dsl_iter;    pub use self::dsl_iter::*;
mod dsl_context; pub use self::dsl_context::*;
mod dsl_macros;

#[cfg(test)] mod test_token_iter {
    use crate::*;
    //use proptest::prelude::*;
    #[test] fn test_iters () {
        let mut iter = crate::SourceIter::new(&":foo :bar");
        let _ = iter.next();
        let mut iter = crate::TokenIter::new(&":foo :bar");
        let _ = iter.next();
    }
    #[test] const fn test_const_iters () {
        let mut iter = crate::SourceIter::new(&":foo :bar");
        let _ = iter.next();
    }
    #[test] fn test_num () {
        let digit  = to_digit('0');
        let digit  = to_digit('x');
        let number = to_number(&"123");
        let number = to_number(&"12asdf3");
    }
    //proptest! {
        //#[test] fn proptest_source_iter (
            //source in "\\PC*"
        //) {
            //let mut iter = crate::SourceIter::new(&source);
            ////let _ = iter.next();
        //}
        //#[test] fn proptest_token_iter (
            //source in "\\PC*"
        //) {
            //let mut iter = crate::TokenIter::new(&source);
            ////let _ = iter.next();
        //}
    //}
}

#[cfg(test)] mod test_token_prop {
    use proptest::prelude::*;
    proptest! {
        #[test] fn test_token_prop (
            source in "\\PC*",
            start  in usize::MIN..usize::MAX,
            length in usize::MIN..usize::MAX,
        ) {
            let token = crate::Token {
                source: &source,
                start,
                length,
                value: crate::Value::Nil
            };
            let _ = token.slice();
        }
    }
}

#[cfg(test)] #[test] fn test_token () -> Result<(), Box<dyn std::error::Error>> {
    let source = ":f00";
    let mut token = Token { source, start: 0, length: 1, value: Sym(":") };
    token = token.grow_sym();
    assert_eq!(token, Token { source, start: 0, length: 2, value: Sym(":f") }); 
    token = token.grow_sym();
    assert_eq!(token, Token { source, start: 0, length: 3, value: Sym(":f0") }); 
    token = token.grow_sym();
    assert_eq!(token, Token { source, start: 0, length: 4, value: Sym(":f00") }); 

    let src = "";
    assert_eq!(None, SourceIter(src).next());

    let src = "  \n    \r   \t  ";
    assert_eq!(None, SourceIter(src).next());

    let src = "7";
    assert_eq!(Num(7), SourceIter(src).next().unwrap().0.value);

    let src = "     100         ";
    assert_eq!(Num(100), SourceIter(src).next().unwrap().0.value);

    let src = "     9a         ";
    assert_eq!(Err(Unexpected('a')), SourceIter(src).next().unwrap().0.value);

    let src = "     :123foo      ";
    assert_eq!(Sym(":123foo"), SourceIter(src).next().unwrap().0.value);

    let src = " \r\r\r\n\n\n@bar456\t\t\t\t\t\t";
    assert_eq!(Sym("@bar456"), SourceIter(src).next().unwrap().0.value);

    let src = "foo123";
    assert_eq!(Key("foo123"), SourceIter(src).next().unwrap().0.value);

    let src = "foo/bar";
    assert_eq!(Key("foo/bar"), SourceIter(src).next().unwrap().0.value);

    let src = "\"foo/bar\"";
    assert_eq!(Str("foo/bar"), SourceIter(src).next().unwrap().0.value);

    let src = "    \"foo/bar\"    ";
    assert_eq!(Str("foo/bar"), SourceIter(src).next().unwrap().0.value);

    Ok(())
}

#[cfg(test)] #[test] fn test_dsl_context () {
    struct Test;
    provide_bool!(bool: |self: Test|{
        ":provide-bool" => true
    });
    let test = Test;
    assert_eq!(test.get(&Value::Sym(":false")),        Some(false));
    assert_eq!(test.get(&Value::Sym(":true")),         Some(true));
    assert_eq!(test.get(&Value::Sym(":provide-bool")), Some(true));
    assert_eq!(test.get(&Value::Sym(":missing-bool")), None);
    assert_eq!(test.get(&Value::Num(0)), Some(false));
    assert_eq!(test.get(&Value::Num(1)), Some(true));
}

//#[cfg(test)] #[test] fn test_examples () -> Result<(), ParseError> {
    //// Let's pretend to render some view.
    //let source = include_str!("../../tek/src/view_arranger.edn");
    //// The token iterator allows you to get the tokens represented by the source text.
    //let mut view = TokenIter(source);
    //// The token iterator wraps a const token+source iterator.
    //assert_eq!(view.0.0, source);
    //let mut expr = view.peek();
    //assert_eq!(view.0.0, source);
    //assert_eq!(expr, Some(Token {
        //source, start: 0, length: source.len() - 1, value: Exp(0, SourceIter(&source[1..]))
    //}));
    ////panic!("{view:?}");
    ////panic!("{:#?}", expr);
    ////for example in [
        ////include_str!("../../tui/examples/edn01.edn"),
        ////include_str!("../../tui/examples/edn02.edn"),
    ////] {
        //////let items = Dsl::read_all(example)?;
        //////panic!("{layout:?}");
        //////let content = <dyn ViewContext<::tengri_engine::tui::Tui>>::from(&layout);
    ////}
    //Ok(())
//}