Vendor things

third-party/vendor/winnow/examples/ini/bench.rs

@@ -0,0 +1,61 @@
+use winnow::combinator::repeat;
+use winnow::prelude::*;
+
+mod parser;
+mod parser_str;
+
+fn bench_ini(c: &mut criterion::Criterion) {
+    let str = "[owner]
+name=John Doe
+organization=Acme Widgets Inc.
+
+[database]
+server=192.0.2.62
+port=143
+file=payroll.dat
+\0";
+
+    let mut group = c.benchmark_group("ini");
+    group.throughput(criterion::Throughput::Bytes(str.len() as u64));
+    group.bench_function(criterion::BenchmarkId::new("bytes", str.len()), |b| {
+        b.iter(|| parser::categories.parse_peek(str.as_bytes()).unwrap());
+    });
+    group.bench_function(criterion::BenchmarkId::new("str", str.len()), |b| {
+        b.iter(|| parser_str::categories.parse_peek(str).unwrap())
+    });
+}
+
+fn bench_ini_keys_and_values(c: &mut criterion::Criterion) {
+    let str = "server=192.0.2.62
+port=143
+file=payroll.dat
+\0";
+
+    fn acc<'s>(i: &mut parser::Stream<'s>) -> PResult<Vec<(&'s str, &'s str)>> {
+        repeat(0.., parser::key_value).parse_next(i)
+    }
+
+    let mut group = c.benchmark_group("ini keys and values");
+    group.throughput(criterion::Throughput::Bytes(str.len() as u64));
+    group.bench_function(criterion::BenchmarkId::new("bytes", str.len()), |b| {
+        b.iter(|| acc.parse_peek(str.as_bytes()).unwrap());
+    });
+}
+
+fn bench_ini_key_value(c: &mut criterion::Criterion) {
+    let str = "server=192.0.2.62\n";
+
+    let mut group = c.benchmark_group("ini key value");
+    group.throughput(criterion::Throughput::Bytes(str.len() as u64));
+    group.bench_function(criterion::BenchmarkId::new("bytes", str.len()), |b| {
+        b.iter(|| parser::key_value.parse_peek(str.as_bytes()).unwrap());
+    });
+}
+
+criterion::criterion_group!(
+    benches,
+    bench_ini,
+    bench_ini_keys_and_values,
+    bench_ini_key_value
+);
+criterion::criterion_main!(benches);

third-party/vendor/winnow/examples/ini/main.rs

@@ -0,0 +1,60 @@
+use winnow::prelude::*;
+
+mod parser;
+mod parser_str;
+
+fn main() -> Result<(), lexopt::Error> {
+    let args = Args::parse()?;
+
+    let input = args.input.as_deref().unwrap_or("1 + 1");
+
+    if args.binary {
+        match parser::categories.parse(input.as_bytes()) {
+            Ok(result) => {
+                println!("  {:?}", result);
+            }
+            Err(err) => {
+                println!("  {:?}", err);
+            }
+        }
+    } else {
+        match parser_str::categories.parse(input) {
+            Ok(result) => {
+                println!("  {:?}", result);
+            }
+            Err(err) => {
+                println!("  {}", err);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Default)]
+struct Args {
+    input: Option<String>,
+    binary: bool,
+}
+
+impl Args {
+    fn parse() -> Result<Self, lexopt::Error> {
+        use lexopt::prelude::*;
+
+        let mut res = Args::default();
+
+        let mut args = lexopt::Parser::from_env();
+        while let Some(arg) = args.next()? {
+            match arg {
+                Long("binary") => {
+                    res.binary = true;
+                }
+                Value(input) => {
+                    res.input = Some(input.string()?);
+                }
+                _ => return Err(arg.unexpected()),
+            }
+        }
+        Ok(res)
+    }
+}

third-party/vendor/winnow/examples/ini/parser.rs

@@ -0,0 +1,146 @@
+use std::collections::HashMap;
+use std::str;
+
+use winnow::prelude::*;
+use winnow::{
+    ascii::{alphanumeric1 as alphanumeric, multispace0 as multispace, space0 as space},
+    combinator::opt,
+    combinator::repeat,
+    combinator::{delimited, separated_pair, terminated},
+    token::take_while,
+};
+
+pub type Stream<'i> = &'i [u8];
+
+pub fn categories<'s>(i: &mut Stream<'s>) -> PResult<HashMap<&'s str, HashMap<&'s str, &'s str>>> {
+    repeat(
+        0..,
+        separated_pair(
+            category,
+            opt(multispace),
+            repeat(0.., terminated(key_value, opt(multispace))),
+        ),
+    )
+    .parse_next(i)
+}
+
+fn category<'s>(i: &mut Stream<'s>) -> PResult<&'s str> {
+    delimited('[', take_while(0.., |c| c != b']'), ']')
+        .try_map(str::from_utf8)
+        .parse_next(i)
+}
+
+pub fn key_value<'s>(i: &mut Stream<'s>) -> PResult<(&'s str, &'s str)> {
+    let key = alphanumeric.try_map(str::from_utf8).parse_next(i)?;
+    let _ = (opt(space), '=', opt(space)).parse_next(i)?;
+    let val = take_while(0.., |c| c != b'\n' && c != b';')
+        .try_map(str::from_utf8)
+        .parse_next(i)?;
+    let _ = opt((';', take_while(0.., |c| c != b'\n'))).parse_next(i)?;
+    Ok((key, val))
+}
+
+#[test]
+fn parse_category_test() {
+    let ini_file = &b"[category]
+
+parameter=value
+key = value2"[..];
+
+    let ini_without_category = &b"\n\nparameter=value
+key = value2"[..];
+
+    let res = category.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, o)) => println!("i: {:?} | o: {:?}", str::from_utf8(i), o),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_category, "category")));
+}
+
+#[test]
+fn parse_key_value_test() {
+    let ini_file = &b"parameter=value
+key = value2"[..];
+
+    let ini_without_key_value = &b"\nkey = value2"[..];
+
+    let res = key_value.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, (o1, o2))) => println!("i: {:?} | o: ({:?},{:?})", str::from_utf8(i), o1, o2),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
+}
+
+#[test]
+fn parse_key_value_with_space_test() {
+    let ini_file = &b"parameter = value
+key = value2"[..];
+
+    let ini_without_key_value = &b"\nkey = value2"[..];
+
+    let res = key_value.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, (o1, o2))) => println!("i: {:?} | o: ({:?},{:?})", str::from_utf8(i), o1, o2),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
+}
+
+#[test]
+fn parse_key_value_with_comment_test() {
+    let ini_file = &b"parameter=value;abc
+key = value2"[..];
+
+    let ini_without_key_value = &b"\nkey = value2"[..];
+
+    let res = key_value.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, (o1, o2))) => println!("i: {:?} | o: ({:?},{:?})", str::from_utf8(i), o1, o2),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
+}
+
+#[test]
+fn parse_multiple_categories_test() {
+    let ini_file = &b"[abcd]
+
+parameter=value;abc
+
+key = value2
+
+[category]
+parameter3=value3
+key4 = value4
+"[..];
+
+    let ini_after_parser = &b""[..];
+
+    let res = categories.parse_peek(ini_file);
+    //println!("{:?}", res);
+    match res {
+        Ok((i, ref o)) => println!("i: {:?} | o: {:?}", str::from_utf8(i), o),
+        _ => println!("error"),
+    }
+
+    let mut expected_1: HashMap<&str, &str> = HashMap::new();
+    expected_1.insert("parameter", "value");
+    expected_1.insert("key", "value2");
+    let mut expected_2: HashMap<&str, &str> = HashMap::new();
+    expected_2.insert("parameter3", "value3");
+    expected_2.insert("key4", "value4");
+    let mut expected_h: HashMap<&str, HashMap<&str, &str>> = HashMap::new();
+    expected_h.insert("abcd", expected_1);
+    expected_h.insert("category", expected_2);
+    assert_eq!(res, Ok((ini_after_parser, expected_h)));
+}

third-party/vendor/winnow/examples/ini/parser_str.rs

@@ -0,0 +1,208 @@
+use std::collections::HashMap;
+
+use winnow::prelude::*;
+use winnow::{
+    ascii::{alphanumeric1 as alphanumeric, space0 as space},
+    combinator::opt,
+    combinator::repeat,
+    combinator::{delimited, terminated},
+    token::{take_till, take_while},
+};
+
+pub type Stream<'i> = &'i str;
+
+pub fn categories<'s>(
+    input: &mut Stream<'s>,
+) -> PResult<HashMap<&'s str, HashMap<&'s str, &'s str>>> {
+    repeat(0.., category_and_keys).parse_next(input)
+}
+
+fn category_and_keys<'s>(i: &mut Stream<'s>) -> PResult<(&'s str, HashMap<&'s str, &'s str>)> {
+    (category, keys_and_values).parse_next(i)
+}
+
+fn category<'s>(i: &mut Stream<'s>) -> PResult<&'s str> {
+    terminated(
+        delimited('[', take_while(0.., |c| c != ']'), ']'),
+        opt(take_while(1.., [' ', '\r', '\n'])),
+    )
+    .parse_next(i)
+}
+
+fn keys_and_values<'s>(input: &mut Stream<'s>) -> PResult<HashMap<&'s str, &'s str>> {
+    repeat(0.., key_value).parse_next(input)
+}
+
+fn key_value<'s>(i: &mut Stream<'s>) -> PResult<(&'s str, &'s str)> {
+    let key = alphanumeric.parse_next(i)?;
+    let _ = (opt(space), "=", opt(space)).parse_next(i)?;
+    let val = take_till(0.., is_line_ending_or_comment).parse_next(i)?;
+    let _ = opt(space).parse_next(i)?;
+    let _ = opt((";", till_line_ending)).parse_next(i)?;
+    let _ = opt(space_or_line_ending).parse_next(i)?;
+
+    Ok((key, val))
+}
+
+fn is_line_ending_or_comment(chr: char) -> bool {
+    chr == ';' || chr == '\n'
+}
+
+fn till_line_ending<'s>(i: &mut Stream<'s>) -> PResult<&'s str> {
+    take_while(0.., |c| c != '\r' && c != '\n').parse_next(i)
+}
+
+fn space_or_line_ending<'s>(i: &mut Stream<'s>) -> PResult<&'s str> {
+    take_while(1.., [' ', '\r', '\n']).parse_next(i)
+}
+
+#[test]
+fn parse_category_test() {
+    let ini_file = "[category]
+
+parameter=value
+key = value2";
+
+    let ini_without_category = "parameter=value
+key = value2";
+
+    let res = category.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, o)) => println!("i: {} | o: {:?}", i, o),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_category, "category")));
+}
+
+#[test]
+fn parse_key_value_test() {
+    let ini_file = "parameter=value
+key = value2";
+
+    let ini_without_key_value = "key = value2";
+
+    let res = key_value.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, (o1, o2))) => println!("i: {} | o: ({:?},{:?})", i, o1, o2),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
+}
+
+#[test]
+fn parse_key_value_with_space_test() {
+    let ini_file = "parameter = value
+key = value2";
+
+    let ini_without_key_value = "key = value2";
+
+    let res = key_value.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, (o1, o2))) => println!("i: {} | o: ({:?},{:?})", i, o1, o2),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
+}
+
+#[test]
+fn parse_key_value_with_comment_test() {
+    let ini_file = "parameter=value;abc
+key = value2";
+
+    let ini_without_key_value = "key = value2";
+
+    let res = key_value.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, (o1, o2))) => println!("i: {} | o: ({:?},{:?})", i, o1, o2),
+        _ => println!("error"),
+    }
+
+    assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
+}
+
+#[test]
+fn parse_multiple_keys_and_values_test() {
+    let ini_file = "parameter=value;abc
+
+key = value2
+
+[category]";
+
+    let ini_without_key_value = "[category]";
+
+    let res = keys_and_values.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, ref o)) => println!("i: {} | o: {:?}", i, o),
+        _ => println!("error"),
+    }
+
+    let mut expected: HashMap<&str, &str> = HashMap::new();
+    expected.insert("parameter", "value");
+    expected.insert("key", "value2");
+    assert_eq!(res, Ok((ini_without_key_value, expected)));
+}
+
+#[test]
+fn parse_category_then_multiple_keys_and_values_test() {
+    //FIXME: there can be an empty line or a comment line after a category
+    let ini_file = "[abcd]
+parameter=value;abc
+
+key = value2
+
+[category]";
+
+    let ini_after_parser = "[category]";
+
+    let res = category_and_keys.parse_peek(ini_file);
+    println!("{:?}", res);
+    match res {
+        Ok((i, ref o)) => println!("i: {} | o: {:?}", i, o),
+        _ => println!("error"),
+    }
+
+    let mut expected_h: HashMap<&str, &str> = HashMap::new();
+    expected_h.insert("parameter", "value");
+    expected_h.insert("key", "value2");
+    assert_eq!(res, Ok((ini_after_parser, ("abcd", expected_h))));
+}
+
+#[test]
+fn parse_multiple_categories_test() {
+    let ini_file = "[abcd]
+
+parameter=value;abc
+
+key = value2
+
+[category]
+parameter3=value3
+key4 = value4
+";
+
+    let res = categories.parse_peek(ini_file);
+    //println!("{:?}", res);
+    match res {
+        Ok((i, ref o)) => println!("i: {} | o: {:?}", i, o),
+        _ => println!("error"),
+    }
+
+    let mut expected_1: HashMap<&str, &str> = HashMap::new();
+    expected_1.insert("parameter", "value");
+    expected_1.insert("key", "value2");
+    let mut expected_2: HashMap<&str, &str> = HashMap::new();
+    expected_2.insert("parameter3", "value3");
+    expected_2.insert("key4", "value4");
+    let mut expected_h: HashMap<&str, HashMap<&str, &str>> = HashMap::new();
+    expected_h.insert("abcd", expected_1);
+    expected_h.insert("category", expected_2);
+    assert_eq!(res, Ok(("", expected_h)));
+}