Struct Spec 

pub struct Spec { /* private fields */ }

A loaded OpenAPI document plus its source path (for diagnostics).

Implementations

impl Spec

pub fn load(path: &Path) -> Result<Self>

Load and parse an OpenAPI document from a YAML or JSON file, for a run that generates models only and filters nothing.

pub fn load_for( path: &Path, server: bool, options: &OutputOptions, ) -> Result<Self>

Load and parse an OpenAPI document from a YAML or JSON file, for a run that generates the server when server is set and nothing else beside the models. Spec::load_with states the run in full.

pub fn load_with( path: &Path, generate: &Generate, options: &OutputOptions, ) -> Result<Self>

Load and parse an OpenAPI document from a YAML or JSON file.

generate states what the run generates, and options holds the filters it applies. The inspection reads both: a server checks a query parameter’s constraints in the generated query struct, and a run that lowers operations reads their parameters and bodies by type.

pub fn from_parts(inner: OpenAPI, source: PathBuf) -> Self

Construct a spec directly from an already-parsed document (test helper).

pub fn source(&self) -> &Path

The source path the spec was loaded from.

pub fn apply_filters(&mut self, opts: &OutputOptions)

Apply the configured operation and schema filters, mutating the spec in place before lowering (see crate::filter).

pub fn schemas(&self) -> &IndexMap<String, ReferenceOr<Schema>>

The component schemas declared in the document, in document order.

pub fn paths(&self) -> &Paths

The paths (operations) declared in the document, in document order.

pub fn servers(&self) -> &[Server]

The top-level servers declared in the document, in document order.

pub fn global_security(&self) -> Option<&[SecurityRequirement]>

The document’s global security requirements, if declared. An operation with no security of its own inherits these.

pub fn security_schemes(&self) -> &IndexMap<String, ReferenceOr<SecurityScheme>>

The security schemes declared under components.securitySchemes, in document order.

pub fn resolve_response(&self, reference: &str) -> Result<Resolved<Response>>

Resolve a #/components/responses/<name> (possibly cross-file) reference to an owned component response plus the file it came from, following reference chains within and across documents.

pub fn resolve_parameter(&self, reference: &str) -> Result<Resolved<Parameter>>

Resolve a #/components/parameters/<name> (possibly cross-file) reference to an owned component parameter plus the file it came from, following reference chains within and across documents.

pub fn resolve_request_body( &self, reference: &str, ) -> Result<Resolved<RequestBody>>

Resolve a #/components/requestBodies/<name> (possibly cross-file) reference to an owned component request body plus the file it came from, following reference chains within and across documents.

pub fn resolve(&self, reference: &str) -> Result<&Schema>

Resolve a $ref string to the concrete schema it names, following chains of references within this document.

pub fn resolve_schema( &self, origin: Option<&str>, reference: &str, ) -> Result<Schema>

Resolve a same-document schema $ref to an owned schema, against the main document when origin is None or a referenced document otherwise.

A cross-file (file#/...) inner schema ref is intentionally rejected: a schema type reference is emitted as a named external type through the import-mapping (see the lowering pass’s schema_ref_type), never read and inlined. This method only resolves refs that stay within one document’s own #/components/schemas.

pub fn external_schema_name( &self, file: &str, name: &str, reference: &str, ) -> Result<String>

The name a schema in a referenced file takes in the crate the import-mapping points at.

The two runs read the same document, so an x-rust-name there reaches both. Without this the run that generates the models emits the name the key gives, the run that generates the operations emits the schema name, and the composed crate does not build.

A miss is an error. The name would otherwise reach the output and name a type the other crate never declares.

Two names in the referenced file that give one Rust name are an error too. The run that writes the models separates them with a type-name-suffix it takes from its own config. This run cannot see that config, so it emits the plain name and reaches whichever of the two schemas kept it. That builds, and it carries the wrong type.

A schema the direction pass splits is an error for the same reason. The other run emits two names there, and this one cannot tell which of the two an import-mapping reference means.

Trait Implementations

impl Debug for Spec

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.