fix test

Author: klion26

parquet-variant/src/path.rs

@@ -33,7 +33,7 @@ use std::{borrow::Cow, ops::Deref};
 /// ```rust
 /// # use parquet_variant::{VariantPath, VariantPathElement};
 /// // access the field "foo" in a variant object value
-/// let path = VariantPath::from("foo");
+/// let path = VariantPath::try_from("foo").unwrap();
 /// // access the first element in a variant list vale
 /// let path = VariantPath::from(0);
 /// ```
@@ -43,7 +43,7 @@ use std::{borrow::Cow, ops::Deref};
 /// # use parquet_variant::{VariantPath, VariantPathElement};
 /// /// You can also create a path by joining elements together:
 /// // access the field "foo" and then the first element in a variant list value
-/// let path = VariantPath::from("foo").join(0);
+/// let path = VariantPath::try_from("foo").unwrap().join(0);
 /// // this is the same as the previous one
 /// let path2 = VariantPath::from_iter(["foo".into(), 0.into()]);
 /// assert_eq!(path, path2);
@@ -59,8 +59,8 @@ use std::{borrow::Cow, ops::Deref};
 /// ```
 /// # use parquet_variant::{VariantPath, VariantPathElement};
 /// /// You can also convert strings directly into paths using dot notation
-/// let path = VariantPath::from("foo.bar.baz");
-/// let expected = VariantPath::from("foo").join("bar").join("baz");
+/// let path = VariantPath::try_from("foo.bar.baz").unwrap();
+/// let expected = VariantPath::try_from("foo").unwrap().join("bar").join("baz");
 /// assert_eq!(path, expected);
 /// ```
 ///
@@ -69,11 +69,21 @@ use std::{borrow::Cow, ops::Deref};
 /// # use parquet_variant::{VariantPath, VariantPathElement};
 /// /// You can access the paths using slices
 /// // access the field "foo" and then the first element in a variant list value
-/// let path = VariantPath::from("foo")
+/// let path = VariantPath::try_from("foo").unwrap()
 ///   .join("bar")
 ///   .join("baz");
 /// assert_eq!(path[1], VariantPathElement::field("bar"));
 /// ```
+///
+/// # Example: Accessing filed with bracket
+/// ```
+/// # use parquet_variant::{VariantPath, VariantPathElement};
+/// let path = VariantPath::try_from("a[b.c].d[2]").unwrap();
+/// let expected = VariantPath::from_iter([VariantPathElement::field("a"),
+///     VariantPathElement::field("b.c"),
+///     VariantPathElement::field("d"),
+///     VariantPathElement::index(2)]);
+/// assert_eq!(path, expected)
 #[derive(Debug, Clone, PartialEq, Default)]
 pub struct VariantPath<'a>(Vec<VariantPathElement<'a>>);
 

parquet-variant/src/variant.rs

@@ -1459,9 +1459,9 @@ impl<'m, 'v> Variant<'m, 'v> {
     /// // given a variant like `{"foo": ["bar", "baz"]}`
     /// let variant = Variant::new(&metadata, &value);
     /// // Accessing a non existent path returns None
-    /// assert_eq!(variant.get_path(&VariantPath::from("non_existent")), None);
+    /// assert_eq!(variant.get_path(&VariantPath::try_from("non_existent").unwrap()), None);
     /// // Access obj["foo"]
-    /// let path = VariantPath::from("foo");
+    /// let path = VariantPath::try_from("foo").unwrap();
     /// let foo = variant.get_path(&path).expect("field `foo` should exist");
     /// assert!(foo.as_list().is_some(), "field `foo` should be a list");
     /// // Access foo[0]
@@ -1470,7 +1470,7 @@ impl<'m, 'v> Variant<'m, 'v> {
     /// // bar is a string
     /// assert_eq!(bar.as_string(), Some("bar"));
     /// // You can also access nested paths
-    /// let path = VariantPath::from("foo").join(0);
+    /// let path = VariantPath::try_from("foo").unwrap().join(0);
     /// assert_eq!(variant.get_path(&path).unwrap(), bar);
     /// ```
     pub fn get_path(&self, path: &VariantPath) -> Option<Variant<'_, '_>> {