Copilot

Author: expede

ucan/src/delegation/policy/predicate.rs

@@ -186,6 +186,13 @@ impl<'de> Deserialize<'de> for Predicate {
                             de::Error::invalid_length(2, &"expected an Ipld value")
                         })?,
                     )),
+                    "!=" => Ok(Predicate::Not(Box::new(Predicate::Equal(
+                        seq.next_element()?
+                            .ok_or_else(|| de::Error::invalid_length(1, &"expected a selector"))?,
+                        seq.next_element()?.ok_or_else(|| {
+                            de::Error::invalid_length(2, &"expected an Ipld value")
+                        })?,
+                    )))),
                     ">" => Ok(Predicate::GreaterThan(
                         seq.next_element()?
                             .ok_or_else(|| de::Error::invalid_length(1, &"expected a selector"))?,
@@ -249,7 +256,8 @@ impl<'de> Deserialize<'de> for Predicate {
                     _ => Err(de::Error::unknown_variant(
                         &op,
                         &[
-                            "==", ">", ">=", "<", "<=", "like", "not", "and", "or", "all", "any",
+                            "==", "!=", ">", ">=", "<", "<=", "like", "not", "and", "or", "all",
+                            "any",
                         ],
                     )),
                 }
@@ -1413,4 +1421,36 @@ mod tests {
             Ok(())
         }
     }
+
+    mod roundtrip {
+        use super::*;
+
+        #[test_log::test]
+        fn test_not_equal_dagcbor_roundtrip() -> TestResult {
+            let pred = Predicate::Not(Box::new(Predicate::Equal(
+                Select::from_str(".foo")?,
+                Ipld::Integer(42),
+            )));
+
+            let cbor = serde_ipld_dagcbor::to_vec(&pred)?;
+            let back: Predicate = serde_ipld_dagcbor::from_slice(&cbor)?;
+
+            assert_eq!(back, pred);
+            Ok(())
+        }
+
+        #[test_log::test]
+        fn test_not_equal_ipld_roundtrip() -> TestResult {
+            let pred = Predicate::Not(Box::new(Predicate::Equal(
+                Select::from_str(".bar")?,
+                Ipld::String("hello".into()),
+            )));
+
+            let ipld: Ipld = pred.clone().into();
+            let back = Predicate::try_from(ipld)?;
+
+            assert_eq!(back, pred);
+            Ok(())
+        }
+    }
 }

ucan/src/delegation/policy/selector/filter.rs

@@ -189,10 +189,10 @@ pub fn parse_try_dot_field(input: &str) -> IResult<&str, Filter> {
 }
 
 fn parse_opt_signed_int(i: &str) -> IResult<&str, Option<i32>> {
-    nom::combinator::opt(
-        nom::combinator::recognize(preceded(nom::combinator::opt(tag("-")), digit1))
-            .map(|s: &str| i32::from_str(s).unwrap_or(0)),
-    )
+    nom::combinator::opt(map_res(
+        nom::combinator::recognize(preceded(nom::combinator::opt(tag("-")), digit1)),
+        i32::from_str,
+    ))
     .parse(i)
 }
 

ucan/src/time/timestamp.rs

@@ -116,7 +116,7 @@ impl Timestamp {
     }
 }
 
-#[cfg(feature = "wasm")]
+#[cfg(all(feature = "wasm", target_arch = "wasm32"))]
 impl Timestamp {
     /// Lift a [`js_sys::Date`] into a Rust [`Timestamp`].
     ///
@@ -130,11 +130,18 @@ impl Timestamp {
     }
 
     /// Lower the [`Timestamp`] to a [`js_sys::Date`].
-    #[must_use]
-    pub fn to_date(&self) -> js_sys::Date {
+    ///
+    /// # Errors
+    ///
+    /// Returns [`OutOfRangeError`] if the timestamp exceeds the 2⁵³ second
+    /// bound, which would cause precision loss in the JavaScript `Date`.
+    pub fn to_date(&self) -> Result<js_sys::Date, OutOfRangeError> {
+        if self.0 > 0x001F_FFFF_FFFF_FFFF {
+            return Err(OutOfRangeError::TooLarge(self.0));
+        }
         #[allow(clippy::cast_precision_loss)]
         let millis = self.0 as f64 * 1000.0;
-        js_sys::Date::new(&wasm_bindgen::JsValue::from(millis))
+        Ok(js_sys::Date::new(&wasm_bindgen::JsValue::from(millis)))
     }
 }