Fix docs

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+### Documentation
+
+- Fix documentation for `validate`
+
 ## [0.26.1] - 2024-10-29
 
 ### Fixed

crates/jsonschema-py/src/lib.rs

@@ -267,7 +267,7 @@ fn to_error_message(error: &jsonschema::ValidationError<'_>, mut message: String
 
 struct StringWriter<'a>(&'a mut String);
 
-impl<'a> Write for StringWriter<'a> {
+impl Write for StringWriter<'_> {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         // SAFETY: `serde_json` always produces valid UTF-8
         self.0

crates/jsonschema-referencing/src/anchors/keys.rs

@@ -74,7 +74,7 @@ impl PartialEq for (dyn BorrowDyn + '_) {
     }
 }
 
-impl<'a> Hash for (dyn BorrowDyn + 'a) {
+impl Hash for (dyn BorrowDyn + '_) {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.borrowed_key().hash(state);
     }

crates/jsonschema-referencing/src/resolver.rs

@@ -16,14 +16,14 @@ pub struct Resolver<'r> {
     scopes: List<Uri<String>>,
 }
 
-impl<'r> PartialEq for Resolver<'r> {
+impl PartialEq for Resolver<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.base_uri == other.base_uri
     }
 }
-impl<'r> Eq for Resolver<'r> {}
+impl Eq for Resolver<'_> {}
 
-impl<'r> fmt::Debug for Resolver<'r> {
+impl fmt::Debug for Resolver<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Resolver")
             .field("base_uri", &self.base_uri.as_str())

crates/jsonschema-referencing/src/segments.rs

@@ -37,7 +37,7 @@ impl<'a> From<Cow<'a, str>> for Segment<'a> {
     }
 }
 
-impl<'a> From<usize> for Segment<'a> {
+impl From<usize> for Segment<'_> {
     fn from(value: usize) -> Self {
         Segment::Index(value)
     }

crates/jsonschema/src/compiler.rs

@@ -130,9 +130,10 @@ impl<'a> Context<'a> {
         !matches!(self.draft, Draft::Draft4)
     }
     pub(crate) fn validates_formats_by_default(&self) -> bool {
-        self.config
-            .validate_formats()
-            .unwrap_or_else(|| matches!(self.draft, Draft::Draft4 | Draft::Draft6 | Draft::Draft7))
+        self.config.validate_formats().unwrap_or(matches!(
+            self.draft,
+            Draft::Draft4 | Draft::Draft6 | Draft::Draft7
+        ))
     }
     pub(crate) fn are_unknown_formats_ignored(&self) -> bool {
         self.config.are_unknown_formats_ignored()

crates/jsonschema/src/keywords/format.rs

@@ -720,12 +720,12 @@ impl Validate for CustomFormatValidator {
         if self.is_valid(instance) {
             Ok(())
         } else {
-            return Err(ValidationError::format(
+            Err(ValidationError::format(
                 self.location.clone(),
                 location.into(),
                 instance,
                 self.format_name.clone(),
-            ));
+            ))
         }
     }
 
@@ -797,12 +797,12 @@ pub(crate) fn compile<'a>(
                 if ctx.are_unknown_formats_ignored() {
                     None
                 } else {
-                    return Some(Err(ValidationError::format(
+                    Some(Err(ValidationError::format(
                         Location::new(),
                         ctx.location().clone(),
                         schema,
                         "unknown format",
-                    )));
+                    )))
                 }
             }
         }

crates/jsonschema/src/node.rs

@@ -402,7 +402,7 @@ impl<'a> Iterator for NodeValidatorsIter<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for NodeValidatorsIter<'a> {
+impl ExactSizeIterator for NodeValidatorsIter<'_> {
     fn len(&self) -> usize {
         match self {
             Self::NoValidator => 0,

crates/jsonschema/src/output.rs

@@ -30,7 +30,7 @@ pub struct Output<'a, 'b> {
     instance: &'b serde_json::Value,
 }
 
-impl<'a, 'b> Output<'a, 'b> {
+impl<'a> Output<'a, '_> {
     pub(crate) const fn new<'c, 'd>(
         schema: &'c Validator,
         root_node: &'c SchemaNode,
@@ -117,7 +117,7 @@ pub enum BasicOutput<'a> {
     Invalid(VecDeque<OutputUnit<ErrorDescription>>),
 }
 
-impl<'a> BasicOutput<'a> {
+impl BasicOutput<'_> {
     /// A shortcut to check whether the output represents passed validation.
     #[must_use]
     pub const fn is_valid(&self) -> bool {
@@ -136,7 +136,7 @@ impl<'a> From<OutputUnit<Annotations<'a>>> for BasicOutput<'a> {
     }
 }
 
-impl<'a> AddAssign for BasicOutput<'a> {
+impl AddAssign for BasicOutput<'_> {
     fn add_assign(&mut self, rhs: Self) {
         match (&mut *self, rhs) {
             (BasicOutput::Valid(ref mut anns), BasicOutput::Valid(anns_rhs)) => {
@@ -153,7 +153,7 @@ impl<'a> AddAssign for BasicOutput<'a> {
     }
 }
 
-impl<'a> Sum for BasicOutput<'a> {
+impl Sum for BasicOutput<'_> {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
         let result = BasicOutput::Valid(VecDeque::new());
         iter.fold(result, |mut acc, elem| {
@@ -163,7 +163,7 @@ impl<'a> Sum for BasicOutput<'a> {
     }
 }
 
-impl<'a> Default for BasicOutput<'a> {
+impl Default for BasicOutput<'_> {
     fn default() -> Self {
         BasicOutput::Valid(VecDeque::new())
     }
@@ -306,7 +306,7 @@ impl<'a> From<&'a serde_json::Value> for Annotations<'a> {
     }
 }
 
-impl<'a> From<serde_json::Value> for Annotations<'a> {
+impl From<serde_json::Value> for Annotations<'_> {
     fn from(v: serde_json::Value) -> Self {
         Annotations(AnnotationsInner::Value(Box::new(v)))
     }
@@ -342,7 +342,7 @@ impl<'a> From<&'a str> for ErrorDescription {
     }
 }
 
-impl<'a> serde::Serialize for BasicOutput<'a> {
+impl serde::Serialize for BasicOutput<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -362,7 +362,7 @@ impl<'a> serde::Serialize for BasicOutput<'a> {
     }
 }
 
-impl<'a> serde::Serialize for AnnotationsInner<'a> {
+impl serde::Serialize for AnnotationsInner<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -375,7 +375,7 @@ impl<'a> serde::Serialize for AnnotationsInner<'a> {
     }
 }
 
-impl<'a> serde::Serialize for OutputUnit<Annotations<'a>> {
+impl serde::Serialize for OutputUnit<Annotations<'_>> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,

crates/jsonschema/src/paths.rs

@@ -12,7 +12,7 @@ pub enum LocationSegment<'a> {
     Index(usize),
 }
 
-impl<'a> fmt::Display for LocationSegment<'a> {
+impl fmt::Display for LocationSegment<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             LocationSegment::Property(property) => f.write_str(property),
@@ -37,7 +37,7 @@ impl Default for LazyLocation<'_, '_> {
     }
 }
 
-impl<'a, 'b> LazyLocation<'a, 'b> {
+impl<'a> LazyLocation<'a, '_> {
     /// Create a root node of a JSON pointer.
     pub const fn new() -> Self {
         LazyLocation {

crates/jsonschema/src/validator.rs

@@ -193,7 +193,7 @@ impl Validator {
     pub fn new(schema: &Value) -> Result<Validator, ValidationError<'static>> {
         Self::options().build(schema)
     }
-    /// Run validation against `instance` and return an iterator over [`ValidationError`] in the error case.
+    /// Validate `instance` against `schema` and return the first error if any.
     #[inline]
     pub fn validate<'i>(&self, instance: &'i Value) -> Result<(), ValidationError<'i>> {
         self.root.validate(instance, &LazyLocation::new())