Function resolve_refs_recurse

codegenr/src/resolver.rs:101–163

(
  current_doc: &DocumentPath,
  json: &mut Value,
  original: &Value,
  original_cache: &mut OriginalDocumentsHash,
  resolved_cache: &mut ResolvedDocumentsHash,
)

  original: &Value,
  original_cache: &mut OriginalDocumentsHash,
  resolved_cache: &mut ResolvedDocumentsHash,
) -> Result<(), ResolverError> {
  match json {
    Value::Array(a) => {
      for v in a {
        resolve_refs_recurse(current_doc, v, original, original_cache, resolved_cache)?;
      }
      Ok(())
    }
    Value::Object(obj) => {
      match obj.remove(REF) {
        Some(Value::String(ref_value)) => {
          let ref_info = RefInfo::parse(current_doc, &ref_value)?;

          let is_nested = ref_info.document_path == *current_doc;

          let new_value = if is_nested {
            let mut v = fetch_reference_value(original, &ref_info.path)?;
            resolve_refs_recurse(current_doc, &mut v, original, original_cache, resolved_cache)?;
            v
          } else {
            let doc_path = ref_info.document_path;
            let json = get_resolved_or_original(&doc_path, original_cache, resolved_cache)?;
            match json {
              Json::Resolved(j) => fetch_reference_value(&j, &ref_info.path)?,
              Json::Original(j) => {
                let mut v = fetch_reference_value(&j, &ref_info.path)?;
                resolve_refs_recurse(&doc_path, &mut v, &j, original_cache, resolved_cache)?;
                v
              }
            }
          };

          if let Value::Object(m) = new_value {
            for (k, v) in m {
              obj.insert(k, v);
            }
            obj.insert(FROM_REF.into(), Value::String(ref_value));
            obj.insert(
              REF_NAME.into(),
              Value::String(ref_info.path.map(|p| get_ref_name(&p)).unwrap_or_default()),
            );
          } else {
            return Err(ResolverError::ShouldBeObject);
          }
        }
        Some(_) => return Err(ResolverError::ShouldBeString),
        None => {}
      }

      for (_key, value) in obj.into_iter() {
        resolve_refs_recurse(current_doc, value, original, original_cache, resolved_cache)?;
      }
      Ok(())
    }
    _ => Ok(()),
  }
}