fmt

typify-impl/src/lib.rs

@@ -220,7 +220,6 @@ pub struct TypeSpace {
 }
 
 impl TypeSpace {
-
  /// Sets the file path for the `TypeSpace` instance.
  pub fn with_path<T: Into<PathBuf>>(&mut self, path: T) {
  self.file_path = path.into().canonicalize().unwrap();
@@ -1262,36 +1261,36 @@ impl<'a> TypeNewtype<'a> {
 }
 
 fn fetch_external_definitions(
- base_schema: &RootSchema,  // Reference to the base schema
- definition: &Schema, // The schema definition to process
- base_path: &PathBuf, // Base path for file operations
- base_id: &Option<String>,  // Optional base ID for schema
- external_references: &mut BTreeMap<RefKey, (Schema, PathBuf, Option<String>)>,  // Map to store external references
- first_run: bool,  // Flag to indicate if this is the first run of the function
+ base_schema: &RootSchema, // Reference to the base schema
+ definition: &Schema,  // The schema definition to process
+ base_path: &PathBuf,  // Base path for file operations
+ base_id: &Option<String>, // Optional base ID for schema
+ external_references: &mut BTreeMap<RefKey, (Schema, PathBuf, Option<String>)>, // Map to store external references
+ first_run: bool, // Flag to indicate if this is the first run of the function
 ) {
  // Iterate through each reference found in the given schema definition
  for mut reference in get_references(&definition) {
  if reference.is_empty() {
- continue;  // Skip empty references
+ continue; // Skip empty references
  }
  if reference.starts_with("#") {
  // Handle internal references
  if first_run {
- continue;  // Skip processing internal references on the first run
+ continue; // Skip processing internal references on the first run
  }
 
- reference.remove(0);  // Remove the '#' character from the reference
+ reference.remove(0); // Remove the '#' character from the reference
  let fragment = reference
- .split("/")
- .into_iter()
- .map(|s| s.to_string())
- .filter(|s| !s.is_empty())
- .collect();  // Split and collect the reference into a vector of strings
- let definition_schema = fetch_defenition(base_schema, &reference, &fragment);  // Fetch the internal schema definition
- let k = format!("{}{}", base_id.as_ref().unwrap(), reference);  // Create a key for the reference
+  .split("/")
+  .into_iter()
+  .map(|s| s.to_string())
+  .filter(|s| !s.is_empty())
+  .collect(); // Split and collect the reference into a vector of strings
+ let definition_schema = fetch_defenition(base_schema, &reference, &fragment); // Fetch the internal schema definition
+ let k = format!("{}{}", base_id.as_ref().unwrap(), reference); // Create a key for the reference
  let key = RefKey::Def(k);
  if external_references.contains_key(&key) {
- continue;  // Skip if the reference already exists in the map
+ continue; // Skip if the reference already exists in the map
  } else {
  // Insert the reference into the map and recursively fetch external definitions
  external_references.insert(
@@ -1314,34 +1313,34 @@ fn fetch_external_definitions(
  } else {
  // Handle external references
  let base_id = base_id
- .as_ref()
- .expect("missing 'id' attribute in schema definition");  // Ensure base_id is present
- let id = Iri::new(base_id).unwrap();  // Create an IRI from the base ID
- let reff = Iri::new(&reference).unwrap();  // Create an IRI from the reference
+  .as_ref()
+  .expect("missing 'id' attribute in schema definition"); // Ensure base_id is present
+ let id = Iri::new(base_id).unwrap(); // Create an IRI from the base ID
+ let reff = Iri::new(&reference).unwrap(); // Create an IRI from the reference
  let fragment = reff
- .fragment()
- .as_ref()
- .unwrap_or(&FragmentBuf::new("".to_string()).unwrap().as_fragment())
- .to_string()
- .split("/")
- .filter_map(|s| (!s.is_empty()).then_some(s.to_string()))
- .collect::<Vec<_>>();  // Process the fragment part of the reference
+  .fragment()
+  .as_ref()
+  .unwrap_or(&FragmentBuf::new("".to_string()).unwrap().as_fragment())
+  .to_string()
+  .split("/")
+  .filter_map(|s| (!s.is_empty()).then_some(s.to_string()))
+  .collect::<Vec<_>>(); // Process the fragment part of the reference
  let relpath =
- diff_paths(reff.path().as_str(), id.path().parent_or_empty().as_str()).unwrap();  // Determine the relative path
- let file_path = base_path.parent().unwrap().join(&relpath);  // Construct the file path
+  diff_paths(reff.path().as_str(), id.path().parent_or_empty().as_str()).unwrap(); // Determine the relative path
+ let file_path = base_path.parent().unwrap().join(&relpath); // Construct the file path
  let content = std::fs::read_to_string(&file_path).expect(&format!(
  "Failed to open input file: {}",
  &file_path.display()
- ));  // Read the file content
+ )); // Read the file content
 
  let root_schema = serde_json::from_str::<RootSchema>(&content)
- .expect("Failed to parse input file as JSON Schema");  // Parse the file content as JSON Schema
- let definition_schema = fetch_defenition(&root_schema, &reference, &fragment);  // Fetch the external schema definition
+  .expect("Failed to parse input file as JSON Schema"); // Parse the file content as JSON Schema
+ let definition_schema = fetch_defenition(&root_schema, &reference, &fragment); // Fetch the external schema definition
  let key = RefKey::Def(reference.clone());
  if external_references.contains_key(&key) {
- continue;  // Skip if the reference already exists in the map
+ continue; // Skip if the reference already exists in the map
  } else {
- let s_id = get_schema_id(&root_schema.schema);  // Get the schema ID
+ let s_id = get_schema_id(&root_schema.schema); // Get the schema ID
 
  // Insert the reference into the map and recursively fetch external definitions
  external_references.insert(

typify-impl/tests/test_external_references.rs

@@ -1,26 +1,26 @@
+use schemars::schema::RootSchema;
 use std::fs::File;
 use std::io::BufReader;
 use std::path::Path;
-use schemars::schema::RootSchema;
 use typify_impl::TypeSpace;
 
 #[test]
 fn test_external_references() {
- let mut type_space = TypeSpace::default();
+  let mut type_space = TypeSpace::default();
 
- let path = Path::new("tests/external_references.json");
- let file = File::open(path).unwrap();
- let reader = BufReader::new(file);
+  let path = Path::new("tests/external_references.json");
+  let file = File::open(path).unwrap();
+  let reader = BufReader::new(file);
 
- let schema: RootSchema = serde_json::from_reader(reader).unwrap();
- // schema.schema.metadata().title = Some("Everything".to_string());
- type_space.with_path("tests/external_references.json");
- type_space.add_root_schema(schema).unwrap();
+  let schema: RootSchema = serde_json::from_reader(reader).unwrap();
+  // schema.schema.metadata().title = Some("Everything".to_string());
+  type_space.with_path("tests/external_references.json");
+  type_space.add_root_schema(schema).unwrap();
 
- let file = type_space.to_stream();
+  let file = type_space.to_stream();
 
- let fmt = rustfmt_wrapper::rustfmt(file.to_string()).unwrap();
- println!("{fmt}");
+  let fmt = rustfmt_wrapper::rustfmt(file.to_string()).unwrap();
+  println!("{fmt}");
 
- expectorate::assert_contents("tests/external_references.out", fmt.as_str());
+  expectorate::assert_contents("tests/external_references.out", fmt.as_str());
 }