CLI

Author: flying-sheep

renderer/src/lib.rs

@@ -5,11 +5,10 @@ mod html;
 use std::io::Write;
 
 use anyhow::{Error, anyhow};
-use schemars::schema_for;
-
 use document_tree::Document;
 
-pub use html::render_html;
+pub use crate::html::render_html;
+pub use schemars::generate::SchemaSettings;
 
 /// Render a document tree as JSON.
 ///
@@ -25,12 +24,18 @@ where
 
 #[expect(clippy::missing_panics_doc, reason = "infallible")]
 /// Render the JSON schema for [`document_tree::Document`].
-pub fn render_json_schema_document<W>(stream: W)
+pub fn render_json_schema_document<W>(stream: W, settings: SchemaSettings, pretty: bool)
 where
     W: Write,
 {
-    let schema = schema_for!(document_tree::Document);
-    serde_json::to_writer(stream, &schema).unwrap();
+    let generator = settings.into_generator();
+    let schema = generator.into_root_schema_for::<document_tree::Document>();
+    let w = if pretty {
+        serde_json::to_writer_pretty
+    } else {
+        serde_json::to_writer
+    };
+    w(stream, &schema).unwrap();
 }
 
 /// Render a document tree as XML.

rst/src/main.rs

@@ -3,16 +3,31 @@
 use clap::Parser;
 
 use rst_parser::parse;
-use rst_renderer::{render_html, render_json, render_json_schema_document, render_xml};
+use rst_renderer::{
+    SchemaSettings, render_html, render_json, render_json_schema_document, render_xml,
+};
 
 use std::io::{self, Read};
 
 #[derive(Debug, Clone, clap::ValueEnum)]
-#[allow(non_camel_case_types)]
 enum Format {
-    json,
-    xml,
-    html,
+    Json,
+    Xml,
+    Html,
+}
+
+#[derive(Debug, Default, Clone, clap::ValueEnum)]
+enum SchemaVersion {
+    // tooling is hopelessly outdated, draft 7 is kind of the best bet
+    #[default]
+    #[value(name = "draft7")]
+    Draft07,
+    #[value(name = "2019-09")]
+    Draft2019_09,
+    #[value(name = "2020-12")]
+    Draft2020_12,
+    #[value(name = "openapi3")]
+    OpenApi3,
 }
 
 #[derive(Debug, Parser)]
@@ -25,32 +40,41 @@ struct Cli {
     #[command(flatten)]
     verbosity: clap_verbosity_flag::Verbosity,
     /// Print schema
-    #[arg(long)]
-    schema: bool,
+    #[arg(long, num_args = ..=1, require_equals = true, default_missing_value = "draft7")]
+    schema: Option<SchemaVersion>,
 }
 
 fn main() -> Result<(), anyhow::Error> {
     let args = Cli::parse();
 
-    let level_filter = args.verbosity.log_level().unwrap().to_level_filter();
+    let level_filter = args
+        .verbosity
+        .log_level()
+        .map_or(log::LevelFilter::Off, |l| l.to_level_filter());
     env_logger::Builder::new()
         .filter(Some("rst"), level_filter)
         .filter(None, log::Level::Warn.to_level_filter())
         .try_init()?;
 
     let stdout = std::io::stdout();
 
-    if args.schema {
-        render_json_schema_document(stdout);
+    if let Some(schema) = &args.schema {
+        let settings = match schema {
+            SchemaVersion::Draft07 => SchemaSettings::draft07(),
+            SchemaVersion::Draft2019_09 => SchemaSettings::draft2019_09(),
+            SchemaVersion::Draft2020_12 => SchemaSettings::draft2020_12(),
+            SchemaVersion::OpenApi3 => SchemaSettings::openapi3(),
+        };
+        render_json_schema_document(stdout, settings, level_filter.to_level().is_some());
         return Ok(());
     }
 
     let content = preprocess_content(args.file.as_deref())?;
     let document = parse(&content)?;
     match args.format {
-        Format::json => render_json(&document, stdout)?,
-        Format::xml => render_xml(&document, stdout)?,
-        Format::html => render_html(&document, stdout, true)?,
+        Format::Json => render_json(&document, stdout)?,
+        Format::Xml => render_xml(&document, stdout)?,
+        Format::Html => render_html(&document, stdout, true)?,
     }
     Ok(())
 }