Vendor things

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

@@ -0,0 +1,62 @@
+use winnow::prelude::*;
+
+mod parser;
+
+use parser::hex_color;
+
+fn main() -> Result<(), lexopt::Error> {
+    let args = Args::parse()?;
+
+    let input = args.input.as_deref().unwrap_or("#AAAAAA");
+
+    println!("{} =", input);
+    match hex_color.parse(input) {
+        Ok(result) => {
+            println!("  {:?}", result);
+        }
+        Err(err) => {
+            println!("  {}", err);
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Default)]
+struct Args {
+    input: Option<String>,
+}
+
+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 {
+                Value(input) => {
+                    res.input = Some(input.string()?);
+                }
+                _ => return Err(arg.unexpected()),
+            }
+        }
+        Ok(res)
+    }
+}
+
+#[test]
+fn parse_color() {
+    assert_eq!(
+        hex_color.parse_peek("#2F14DF"),
+        Ok((
+            "",
+            parser::Color {
+                red: 47,
+                green: 20,
+                blue: 223,
+            }
+        ))
+    );
+}

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

@@ -0,0 +1,35 @@
+use winnow::combinator::seq;
+use winnow::prelude::*;
+use winnow::token::take_while;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Color {
+    pub red: u8,
+    pub green: u8,
+    pub blue: u8,
+}
+
+impl std::str::FromStr for Color {
+    // The error must be owned
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        hex_color.parse(s).map_err(|e| e.to_string())
+    }
+}
+
+pub fn hex_color(input: &mut &str) -> PResult<Color> {
+    seq!(Color {
+        _: '#',
+        red: hex_primary,
+        green: hex_primary,
+        blue: hex_primary
+    })
+    .parse_next(input)
+}
+
+fn hex_primary(input: &mut &str) -> PResult<u8> {
+    take_while(2, |c: char| c.is_ascii_hexdigit())
+        .try_map(|input| u8::from_str_radix(input, 16))
+        .parse_next(input)
+}