src/parser.rs

@@ -20,74 +20,68 @@ impl From<nom::Err<nom::error::Error<&str>>> for SaveEntityParseError {
     }
 }
 
-
+fn parse_bool(i: &str) -> IResult<&str, bool> {
-#[derive(Debug, PartialEq)]
+    alt((tag("true"), tag("false")))(i).map(|(s, val)| match val {
-enum Token {
+        "true" => (s, true),
-    Tag(String),
+        "false" => (s, false),
-    Str(String),
+        _ => panic!("Bools must be `true` or `false`!"),
-    Num(f32),
+    })
 }
 
-///
+fn parse_xyz(i: &str) -> IResult<&str, (f32, f32, f32)> {
-/// Simple function to tokenize a string into an array of Token values
+    tuple((float, space1, float, space1, float))(i).map(|(s, (x, _, y, _, z))| (s, (x, y, z)))
-///
-pub(crate) fn tokenize(line: &str) -> Vec<Token> {
-    line.split(" ")
-        .map(|piece| {
-            if let Ok(n) = piece.parse::<f32>() {
-                Token::Num(n)
-            } else if let Ok((_, (_, s, _))) = tuple((
-                tag::<&str, &str, ()>("\""),
-                take_until1("\""),
-                tag::<&str, &str, ()>("\""),
-            ))(piece)
-            {
-                Token::Str(s.into())
-            } else {
-                Token::Tag(piece.into())
-            }
-        })
-        .collect()
 }
 
-#[test]
+fn parse_wxyz(i: &str) -> IResult<&str, (f32, f32, f32, f32)> {
-fn test_tokenize() {
+    tuple((float, space1, float, space1, float, space1, float))(i)
-    let line = "foo \"bar\" 1.23 baz \"asdf\" etc";
+        .map(|(s, (w, _, x, _, y, _, z))| (s, (w, x, y, z)))
-    assert_eq!(
-        tokenize(line),
-        vec![
-            Token::Tag("foo".into()),
-            Token::Str("bar".into()),
-            Token::Num(1.23),
-            Token::Tag("baz".into()),
-            Token::Str("asdf".into()),
-            Token::Tag("etc".into())
-        ]
-    );
 }
 
+fn parse_string(i: &str) -> IResult<&str, &str> {
+    let (rem, (_, out, _)) = tuple((tag("\""), take_until1("\""), tag("\"")))(i)?;
+    Ok((rem, out))
+}
 
 ///
 /// Returns reflected `Transform`
 ///
-pub(crate) fn parse_save_transform(tokens: &Vec<Token>) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_transform(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+    let (rem, _) = tag("transform")(line)?;
+
     let mut transform = Transform::default();
 
-    // Tag(Transform),
+    let mut curr = rem.trim_start();
-    //      Tag(Translation), Number, Number, Number
+    for _ in 0..3 {
-    //      Tag(Rotation), Number, Number, Number, Number
+        if let Ok((rem, (_, _, (x, y, z)))) =
-    //      Tag(Scale), Number, Number, Number
+            tuple((tag("translation"), space1, parse_xyz))(curr.trim_start())
+        {
+            transform.translation = Vec3::new(x, y, z);
+            curr = rem.trim_start();
+        } else if let Ok((rem, (_, _, (x, y, z, w)))) =
+            tuple((tag("rotation"), space1, parse_wxyz))(curr.trim_start())
+        {
+            transform.rotation = Quat::from_xyzw(x, y, z, w);
+            curr = rem.trim_start();
+        } else if let Ok((rem, (_, _, (x, y, z)))) =
+            tuple((tag("scale"), space1, parse_xyz))(curr.trim_start())
+        {
+            transform.scale = Vec3::new(x, y, z);
+            curr = rem.trim_start();
+        } else {
+            return Err(SaveEntityParseError::Transform);
+        }
+    }
 
-    // return Err(SaveEntityParseError::Transform);
+    // Assert there are no trailing characters on the line
+    debug_assert_eq!(curr, "");
 
-    todo!("parse_save_transform");
+    Ok(transform.clone_value())
 }
 
 #[test]
 fn test_parse_transform() {
     let line = "transform translation 1.0 2.0 3.0 rotation 0.1 0.2 0.3 1.0 scale 1.1 1.2 1.3";
-    let tokens = tokenize(line);
+    let parsed = parse_save_transform(line).unwrap();
-    let parsed = parse_save_transform(&tokens).unwrap();
     let expected = Transform {
         translation: Vec3::new(1.0, 2.0, 3.0),
         rotation: Quat::from_xyzw(0.1, 0.2, 0.3, 1.0),
@@ -103,18 +97,22 @@ fn test_parse_transform() {
 ///
 /// Returns a reflected `Name`
 ///
-pub(crate) fn parse_save_name(tokens: &Vec<Token>) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_name(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    todo!("parse_save_name");
+    let (remainder, _) = tag("name")(line)?;
-
+    let n = remainder.trim().to_string();
-    // Err(SaveEntityParseError::Name)
+    if n.is_empty() {
+        Err(SaveEntityParseError::Name)
+    } else {
+        let name = Name::new(n);
+        Ok(name.clone_value())
+    }
 }
 
 #[test]
 fn test_parse_name() {
     {
         let line = "name Van";
-        let tokens = tokenize(line);
+        let parsed = parse_save_name(line).unwrap();
-        let parsed = parse_save_name(&tokens).unwrap();
         let expected = Name::new("Van");
 
         assert!(expected
@@ -124,8 +122,7 @@ fn test_parse_name() {
     }
     {
         let line = "name Big Mike";
-        let tokens = tokenize(line);
+        let parsed = parse_save_name(line).unwrap();
-        let parsed = parse_save_name(&tokens).unwrap();
         let expected = Name::new("Big Mike");
 
         assert!(expected
@@ -153,23 +150,23 @@ impl Component for SaveModel {
 ///
 /// Returns a reflected `SaveModel`
 ///
-pub(crate) fn parse_save_model(tokens: &Vec<Token>) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_model(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    todo!("parse_save_model");
+    let (rem, (_, _, gltf_path, _, scene_name)) =
+        tuple((tag("model"), space1, parse_string, space1, parse_string))(line)?;
+
+    debug_assert!(rem == "");
 
-    /*
     Ok(SaveModel {
         gltf_file: gltf_path.into(),
         scene_name: scene_name.into(),
     }
     .clone_value())
-    */
 }
 
 #[test]
 fn test_parse_model() {
     let line = "model \"models/foo.glb\" \"My Scene\"";
-    let tokens = tokenize(line);
+    let parsed = parse_save_model(line).unwrap();
-    let parsed = parse_save_model(&tokens).unwrap();
     let expected = SaveModel {
         gltf_file: "models/foo.glb".into(),
         scene_name: "My Scene".into(),
@@ -200,19 +197,46 @@ impl Component for SaveCameraRenderTarget {
 ///
 /// Returns a reflected `SaveCameraRenderTarget
 ///
-pub(crate) fn parse_save_camera(tokens: &Vec<Token>) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_camera(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    todo!("parse_save_camera");
+    if let Ok((rem, _camera)) = tag::<&str, &str, ()>("camera")(line) {
+        if let Ok((rem, (_, _target))) = tuple((space1::<&str, ()>, tag("target")))(rem) {
+            if let Ok((rem, (_, _window))) = tuple((space1::<&str, ()>, tag("window")))(rem) {
+                // Camera + target + window + UUID
+                if let Ok((rem, (_, path))) =
+                    tuple((space1::<&str, nom::error::Error<&str>>, parse_string))(rem)
+                {
+                    debug_assert!(rem == "");
+
+                    Ok(SaveCameraRenderTarget::Window(path.into()).clone_value())
+                // Camera + target + widow
+                } else {
+                    debug_assert!(rem == "");
+
+                    Ok(SaveCameraRenderTarget::Default.clone_value())
+                }
+            // camera + target
+            } else {
+                debug_assert!(rem == "");
+
+                Err(SaveEntityParseError::Camera)
+            }
+        // Just camera
+        } else {
+            debug_assert!(rem == "");
 
+            Ok(SaveCameraRenderTarget::Default.clone_value())
+        }
     // Nothing parsed well
-    // Err(SaveEntityParseError::Camera)
+    } else {
+        Err(SaveEntityParseError::Camera)
+    }
 }
 
 #[test]
 fn test_parse_camera() {
     {
         let line = "camera";
-        let tokens = tokenize(line);
+        let parsed = parse_save_camera(line).unwrap();
-        let parsed = parse_save_camera(&tokens).unwrap();
         let expected = SaveCameraRenderTarget::Default;
         assert!(expected
             .clone_value()
@@ -221,8 +245,7 @@ fn test_parse_camera() {
     }
     {
         let line = "camera target window";
-        let tokens = tokenize(line);
+        let parsed = parse_save_camera(line).unwrap();
-        let parsed = parse_save_camera(&tokens).unwrap();
         let expected = SaveCameraRenderTarget::Default;
         assert!(expected
             .clone_value()
@@ -231,14 +254,12 @@ fn test_parse_camera() {
     }
     {
         let line = "camera target";
-        let tokens = tokenize(line);
+        let parsed = parse_save_camera(line);
-        let parsed = parse_save_camera(&tokens);
         assert!(parsed.is_err());
     }
     {
         let line = "camera target window \"some.entity\"";
-        let tokens = tokenize(line);
+        let parsed = parse_save_camera(line).unwrap();
-        let parsed = parse_save_camera(&tokens).unwrap();
         let expected = SaveCameraRenderTarget::Window("some.entity".into());
         assert!(expected
             .clone_value()
@@ -247,8 +268,7 @@ fn test_parse_camera() {
     }
     {
         let line = "notcamera";
-        let tokens = tokenize(line);
+        let parsed = parse_save_camera(line);
-        let parsed = parse_save_camera(&tokens);
         assert!(parsed.is_err());
     }
 }
@@ -275,17 +295,18 @@ impl Component for SaveParent {
 ///
 /// Returns a reflected `SaveParent`
 ///
-pub(crate) fn parse_save_parent(tokens: &Vec<Token>) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_parent(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    todo!("parse_save_parent");
+    let (rem, (_, _, parent_file)) = tuple((tag("parent"), space1, parse_string))(line)?;
 
-    // Ok(SaveParent(parent_file.into()).clone_value())
+    debug_assert!(rem.is_empty());
+
+    Ok(SaveParent(parent_file.into()).clone_value())
 }
 
 #[test]
 fn test_parse_parent() {
     let line = "parent \"some_other_file.entity\"";
-    let tokens = tokenize(line);
+    let parsed = parse_save_parent(line).unwrap();
-    let parsed = parse_save_parent(&tokens).unwrap();
     let expected = SaveParent("some_other_file.entity".into());
     assert!(expected
         .clone_value()
@@ -299,24 +320,25 @@ fn test_parse_parent() {
 ///
 /// Returns a reflected `Window`
 ///
-pub(crate) fn parse_save_window(tokens: &Vec<Token>) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_window(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    todo!("parse_save_window");
+    let (rem, (_, _, window_title)) = tuple((tag("window"), space1, parse_string))(line)?;
+
+    let (rem, (_, _, _, visibility)) = tuple((space1, tag("visible"), space1, parse_bool))(rem)?;
+
+    debug_assert!(rem.is_empty());
 
-    /*
     Ok(Window {
         title: window_title.into(),
         visible: visibility,
         ..default()
     }
     .clone_value())
-    */
 }
 
 #[test]
 fn test_parse_window() {
     let line = "window \"Editor\" visible false";
-    let tokens = tokenize(line);
+    let parsed = parse_save_window(line).unwrap();
-    let parsed = parse_save_window(&tokens).unwrap();
     let expected = Window {
         visible: false,
         title: "Editor".into(),
@@ -336,24 +358,29 @@ fn test_parse_window() {
 ///
 /// Returns a reflected `Text`
 ///
-pub(crate) fn parse_save_ui_text(tokens: &Vec<Token>) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_ui_text(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    todo!("parse_save_ui_text");
+    let (rem, (_tag_text, _space1, text)) = tuple((tag("uiText"), space1, parse_string))(line)?;
+
+    let (rem, (_space, _tag_color, _space1, _hash, hex_color)) =
+        tuple((space1, tag("color"), space1, char('#'), hex_digit1))(rem)?;
+
+    let (rem, (_space, _tag_size, _space1, font_size)) =
+        tuple((space1, tag("size"), space1, float))(rem)?;
+
+    debug_assert!(rem.is_empty());
 
-    /*
     let style = TextStyle {
         color: Color::Srgba(Srgba::hex(hex_color).unwrap()),
         font_size,
         ..default()
     };
     Ok(Text::from_section(text, style).clone_value())
-    */
 }
 
 #[test]
 fn test_save_ui_text() {
     let line = "uiText \"This is the text\" color #caffee size 14.6";
-    let tokens = tokenize(line);
+    let parsed = parse_save_ui_text(line).unwrap();
-    let parsed = parse_save_ui_text(&tokens).unwrap();
     let expected = Text::from_section(
         "This is the text",
         TextStyle {
@@ -375,8 +402,8 @@ fn test_save_ui_text() {
 pub(crate) fn parse_save_tag<T: Component + Reflect + Default>(
     t: &str,
 ) -> impl FnOnce(&str) -> Result<Box<dyn Reflect>, SaveEntityParseError> + '_ {
-    move |tokens: &Vec<Token>| -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+    move |line: &str| -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-        todo!("parse_save_tag")
+        Ok(tag(t)(line).map(|_| T::default().clone_value())?)
     }
 }
 
@@ -387,8 +414,7 @@ struct TestingTag;
 #[test]
 fn test_save_tag() {
     let line = "testing";
-    let tokens = tokenize(line);
+    let parsed = parse_save_tag::<TestingTag>("testing")(line).unwrap();
-    let parsed = parse_save_tag::<TestingTag>("testing")(&tokens).unwrap();
     let expected = TestingTag;
     assert!(expected
         .clone_value()
@@ -415,16 +441,21 @@ impl Component for SaveTargetCamera {
 ///
 /// Returns reflected `SaveTargetCamera`
 pub(crate) fn parse_save_target_camera(
-    tokens: &Vec<Token>,
+    line: &str,
 ) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    todo!("parse_save_target_camera")
+    Ok(
+        tuple((tag("targetCamera"), space1, parse_string))(line).map(
+            |(_, (_, _, target_camera_entity_file))| {
+                SaveTargetCamera(target_camera_entity_file.into()).clone_value()
+            },
+        )?,
+    )
 }
 
 #[test]
 fn test_target_camera() {
     let line = "targetCamera \"./level-camera.entity\"";
-    let tokens = tokenize(line);
+    let parsed = parse_save_target_camera(line).unwrap();
-    let parsed = parse_save_target_camera(&tokens).unwrap();
     let expected = SaveTargetCamera("./level-camera.entity".into());
 
     assert!(expected

src/save.rs

@@ -54,12 +54,9 @@ impl SaveEntity {
                 // track if this line matched any components
                 let mut good = false;
 
-                // Tokenize the line
-                let tokens = parser::tokenize(line);
-
                 // Run line against all parsers
                 for f in fns {
-                    if let Ok(v) = f(&tokens) {
+                    if let Ok(v) = f(line) {
                         entity.components.push(v);
                         good = true;
                     }