Remove JsonSchemaError/Result

schemars/src/error.rs

@@ -1,29 +0,0 @@
-use crate::schema::Schema;
-use std::error::Error;
-use std::fmt;
-
-pub type Result<T> = std::result::Result<T, JsonSchemaError>;
-
-#[derive(Debug, Clone)]
-pub struct JsonSchemaError {
-    msg: &'static str,
-    schema: Schema,
-}
-
-impl JsonSchemaError {
-    pub fn new(msg: &'static str, schema: Schema) -> JsonSchemaError {
-        JsonSchemaError { msg, schema }
-    }
-
-    pub fn schema(&self) -> &Schema {
-        &self.schema
-    }
-}
-
-impl fmt::Display for JsonSchemaError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} Schema: {:?}", self.msg, self.schema)
-    }
-}
-
-impl Error for JsonSchemaError {}

schemars/src/gen.rs

@@ -1,5 +1,5 @@
 use crate::schema::*;
-use crate::{JsonSchema, JsonSchemaError, Map, Result};
+use crate::{JsonSchema, Map};
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct SchemaSettings {
@@ -133,42 +133,21 @@ impl SchemaGenerator {
         schema
     }
 
-    pub fn dereference_once<'a>(&'a self, schema: &'a Schema) -> Result<&'a Schema> {
+    pub fn dereference<'a>(&'a self, schema: &Schema) -> Option<&'a Schema> {
         match schema {
             Schema::Object(SchemaObject {
                 reference: Some(ref schema_ref),
                 ..
             }) => {
                 let definitions_path = &self.settings().definitions_path;
-                if !schema_ref.starts_with(definitions_path) {
+                let name = if schema_ref.starts_with(definitions_path) {
-                    return Err(JsonSchemaError::new(
+                    &schema_ref[definitions_path.len()..]
-                        "Could not extract referenced schema name.",
+                } else {
-                        schema.clone(),
+                    schema_ref
-                    ));
+                };
+                self.definitions.get(name)
             }
-
+            _ => None,
-                let name = &schema_ref[definitions_path.len()..];
-                self.definitions.get(name).ok_or_else(|| {
-                    JsonSchemaError::new("Could not find referenced schema.", schema.clone())
-                })
         }
-            s => Ok(s),
-        }
-    }
-
-    pub fn dereference<'a>(&'a self, mut schema: &'a Schema) -> Result<&'a Schema> {
-        if !schema.is_ref() {
-            return Ok(schema);
-        }
-        for _ in 0..100 {
-            schema = self.dereference_once(schema)?;
-            if !schema.is_ref() {
-                return Ok(schema);
-            }
-        }
-        Err(JsonSchemaError::new(
-            "Failed to dereference schema after 100 iterations - references may be cyclic.",
-            schema.clone(),
-        ))
     }
 }

schemars/src/lib.rs

@@ -3,7 +3,6 @@
 pub type Map<K, V> = std::collections::BTreeMap<K, V>;
 pub type Set<T> = std::collections::BTreeSet<T>;
 
-mod error;
 mod flatten;
 mod json_schema_impls;
 #[macro_use]
@@ -12,7 +11,6 @@ mod macros;
 pub mod gen;
 pub mod schema;
 
-pub use error::*;
 pub use schemars_derive::*;
 
 use schema::Schema;

schemars/tests/dereference.rs

@@ -1,20 +1,6 @@
-mod util;
 use schemars::{gen::SchemaGenerator, JsonSchema};
 use std::ptr;
 
-#[test]
-fn dereference_i32() -> util::TestResult {
-    let mut gen = SchemaGenerator::default();
-    let i32_schema = gen.subschema_for::<i32>();
-
-    let dereferenced_once = gen.dereference_once(&i32_schema)?;
-    assert!(ptr::eq(dereferenced_once, &i32_schema));
-
-    let dereferenced = gen.dereference(&i32_schema)?;
-    assert!(ptr::eq(dereferenced, &i32_schema));
-    Ok(())
-}
-
 #[derive(Debug, JsonSchema)]
 pub struct Struct {
     foo: i32,
@@ -22,15 +8,15 @@ pub struct Struct {
 }
 
 #[test]
-fn dereference_struct() -> util::TestResult {
+fn dereference_struct() {
     let mut gen = SchemaGenerator::default();
     let struct_ref_schema = gen.subschema_for::<Struct>();
     let struct_schema = gen.definitions().get(&<Struct>::schema_name()).unwrap();
 
-    let dereferenced_once = gen.dereference_once(&struct_ref_schema)?;
+    assert!(struct_ref_schema.is_ref());
-    assert!(ptr::eq(dereferenced_once, struct_schema));
+    assert!(!struct_schema.is_ref());
 
-    let dereferenced = gen.dereference(&struct_ref_schema)?;
+    let dereferenced = gen.dereference(&struct_ref_schema);
-    assert!(ptr::eq(dereferenced, struct_schema));
+    assert!(dereferenced.is_some());
-    Ok(())
+    assert!(ptr::eq(dereferenced.unwrap(), struct_schema));
 }