cli: `rad config schema` emits JSON Schema — heartwood

Leverage schemars to generate a JSON Schema from our structs for configurations and those occurring within them.

Regarding dependency on an alpha version of schemars: Reading the road to 1.0 issue I don’t expect that we would be affected by breakage. We use pretty standard/core parts of the API that probably are most stable.

The output of rad config schema can be used by editors to provide a smoother editing experience for the configuration file. Discovery of attributes (both keys and values) is greatly improved with the schema helping in the background.

Refer to:

https://json-schema.org
https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings
https://schemastore.org

Original description by did:key:z6MkjFMAoA3hUG6tM7Wprn7dh7bquLpmN1f3yECbwkyweQnJ follows:

This will be a great addition especially for LSP users who dont want to read through all the code to know what options can be changed where and how.

How it works: You simply pipe the output into xyz.json and then add to your config: “$schema”: “/path/to/xyz.json” and if you have a working json LSP you’ll get docs, etc. for your config, meaning we’ll have to write a lot less docs in the future :)

  "radicle-crypto",
  "radicle-git-ext",
  "radicle-ssh",
  "schemars",
  "serde",
  "serde_json",
  "siphasher 1.0.1",

  "radicle-node",
  "radicle-surf",
  "radicle-term",
  "schemars",
  "serde",
  "serde_json",
  "shlex",

 ]
 [[package]]
 name = "schemars"
 version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
 dependencies = [
  "dyn-clone",
  "schemars_derive",
  "serde",
  "serde_json",
 ]
 [[package]]
 name = "schemars_derive"
 version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
  "syn 2.0.89",
 ]
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 ]
 [[package]]
 name = "serde_derive_internals"
 version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.89",
 ]
 [[package]]
 name = "serde_json"
 version = "1.0.116"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 tree-sitter-go = { version = "0.23.4" }
 tree-sitter-md = { version = "0.3.2" }
 zeroize = { version = "1.1" }
 schemars = "0.8.22"
 [dependencies.radicle]
 version = "0"

 use std::path::Path;
 use std::str::FromStr;
 use schemars::schema_for;
 use anyhow::anyhow;
 use radicle::node::Alias;
 use radicle::profile::{Config, ConfigError, ConfigPath, RawConfig};

     rad config init --alias <alias> [<option>...]
     rad config edit [<option>...]
     rad config get <key> [<option>...]
     rad config schema [<option>...]
     rad config set <key> <value> [<option>...]
     rad config unset <key> [<option>...]
     rad config push <key> <value> [<option>...]

     #[default]
     Show,
     Get(String),
     Schema,
     Set(String, String),
     Push(String, String),
     Remove(String, String),

                 }
                 Value(val) if op.is_none() => match val.to_string_lossy().as_ref() {
                     "show" => op = Some(Operation::Show),
                     "schema" => op = Some(Operation::Schema),
                     "edit" => op = Some(Operation::Edit),
                     "init" => op = Some(Operation::Init),
                     "get" => {

             let profile = ctx.profile()?;
             term::json::to_pretty(&profile.config, path.as_path())?.print();
         }
         Operation::Schema => {
             let profile = ctx.profile()?;
             term::json::to_pretty(&schema_for!(Config), path.as_path())?.print();
         }
         Operation::Get(key) => {
             let mut temp_config = RawConfig::from_file(&path)?;
             let key: ConfigPath = key.into();

 tempfile = { version = "3.3.0" }
 thiserror = { version = "1" }
 unicode-normalization = { version = "0.1" }
 schemars = { version = "0.8.22", features = ["derive_json_schema", "impl_json_schema"] }
 [dependencies.chrono]
 version = "0.4.0"

 use schemars::JsonSchema;
 /// CLI configuration.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct Config {
     /// Whether to show hints or not in the CLI.

 }
 /// A public explorer, eg. `https://app.radicle.xyz`.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, JsonSchema)]
 #[serde(transparent)]
 pub struct Explorer(String);

 use std::{ffi::OsString, fmt, str::FromStr};
 use git_ext::ref_format::{Component, RefString};
 use schemars::JsonSchema;
 use thiserror::Error;
 use crate::git;

     Multibase(#[from] multibase::Error),
 }
 /// remote derive JsonSchema
 /// https://github.com/GREsau/schemars/blob/v0/schemars/examples/remote_derive.rs
 pub struct OidDef {}
 /// A repository identifier.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct RepoId(git::Oid);
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, JsonSchema)]
 pub struct RepoId(#[schemars(with = "str")] git::Oid);
 impl fmt::Display for RepoId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

 use amplify::WrapperMut;
 use cyphernet::addr::NetAddr;
 use localtime::{LocalDuration, LocalTime};
 use schemars::JsonSchema;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use serde_json as json;

 }
 /// Node alias.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, serde::Serialize, serde::Deserialize)]
 #[derive(
     Debug, PartialEq, Eq, PartialOrd, Ord, Clone, serde::Serialize, serde::Deserialize, JsonSchema,
 )]
 #[serde(try_from = "String", into = "String")]
 pub struct Alias(String);

 }
 /// Peer public protocol address.
 #[derive(Wrapper, WrapperMut, Clone, Eq, PartialEq, Debug, Hash, From, Serialize, Deserialize)]
 #[derive(
     Wrapper, WrapperMut, Clone, Eq, PartialEq, Debug, Hash, From, Serialize, Deserialize, JsonSchema,
 )]
 #[wrapper(Deref, Display, FromStr)]
 #[wrapper_mut(DerefMut)]
 pub struct Address(#[serde(with = "crate::serde_ext::string")] NetAddr<HostName>);
 pub struct Address(
     #[serde(with = "crate::serde_ext::string")]
     #[schemars(schema_with = "crate::serde_ext::string::make_schema")]
     NetAddr<HostName>,
 );
 impl Address {
     /// Check whether this address is from the local network.

 }
 /// Peer-to-peer network.
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 #[derive(
     Default, Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, JsonSchema,
 )]
 #[serde(rename_all = "camelCase")]
 pub enum Network {
     #[default]

 }
 /// Configuration parameters defining attributes of minima and maxima.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct Limits {
     /// Number of routing table entries before we start pruning.
     pub routing_max_size: usize,
     /// How long to keep a routing table entry before being pruned.
     #[serde(with = "crate::serde_ext::localtime::duration")]
     #[schemars(schema_with = "crate::serde_ext::localtime::duration::make_schema")]
     pub routing_max_age: LocalDuration,
     /// How long to keep a gossip message entry before pruning it.
     #[serde(with = "crate::serde_ext::localtime::duration")]
     #[schemars(schema_with = "crate::serde_ext::localtime::duration::make_schema")]
     pub gossip_max_age: LocalDuration,
     /// Maximum number of concurrent fetches per peer connection.
     pub fetch_concurrency: usize,

     }
 }
 /// for JsonSchema
 /// https://graham.cool/schemars/examples/5-remote_derive/
 #[derive(JsonSchema)]
 #[serde(remote = "ByteSize")]
 pub struct ByteSizeDef(pub u64);
 /// Limiter for byte streams.
 ///
 /// Default: 500MiB
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 #[serde(into = "String", try_from = "String")]
 pub struct FetchPackSizeLimit {
     #[serde(with = "ByteSizeDef")]
     limit: bytesize::ByteSize,
 }

 }
 /// Full address used to connect to a remote node.
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash)]
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, JsonSchema)]
 #[serde(transparent)]
 pub struct ConnectAddress(#[serde(with = "crate::serde_ext::string")] PeerAddr<NodeId, Address>);
 pub struct ConnectAddress(
     #[serde(with = "crate::serde_ext::string")]
     #[schemars(schema_with = "crate::serde_ext::string::make_schema")]
     PeerAddr<NodeId, Address>,
 );
 impl From<PeerAddr<NodeId, Address>> for ConnectAddress {
     fn from(value: PeerAddr<NodeId, Address>) -> Self {

 }
 /// Peer configuration.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase", tag = "type")]
 pub enum PeerConfig {
     /// Static peer set. Connect to the configured peers and maintain the connections.

 }
 /// Relay configuration.
 #[derive(Debug, Copy, Clone, Default, serde::Serialize, serde::Deserialize)]
 #[derive(Debug, Copy, Clone, Default, serde::Serialize, serde::Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub enum Relay {
     /// Always relay messages.

 }
 /// Proxy configuration.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase", tag = "mode")]
 pub enum AddressConfig {
     /// Proxy connections to this address type.

 }
 /// Default seeding policy. Applies when no repository policies for the given repo are found.
 #[derive(Debug, Copy, Clone, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 #[derive(
     Debug, Copy, Clone, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, JsonSchema,
 )]
 #[serde(rename_all = "camelCase", tag = "default")]
 pub enum DefaultSeedingPolicy {
     /// Allow seeding.

     /// Log level.
     #[serde(default = "defaults::log")]
     #[serde(with = "crate::serde_ext::string")]
     #[schemars(schema_with = "crate::serde_ext::string::make_schema")]
     pub log: log::Level,
     /// Whether or not our node should relay messages.
     #[serde(default, deserialize_with = "crate::serde_ext::ok_or_default")]

 pub mod config;
 pub mod store;
 use schemars::JsonSchema;
 use std::fmt;
 use std::str::FromStr;

 }
 /// Follow scope of a seeded repository.
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[derive(
     Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, JsonSchema,
 )]
 #[serde(rename_all = "camelCase")]
 pub enum Scope {
     /// Seed remotes that are explicitly followed.

             .parse()
             .map_err(de::Error::custom)
     }
     /// custom de-serialization needs custom JsonSchema generators
     /// source: https://graham.cool/schemars/examples/7-custom_serialization/
     use schemars::{schema::Schema, JsonSchema, SchemaGenerator};
     pub fn make_schema(generator: &mut SchemaGenerator) -> Schema {
         return String::json_schema(generator);
     }
 }
 /// Unlike the default `serde` instances from `localtime`, this encodes and decodes using seconds

             Ok(LocalDuration::from_secs(seconds))
         }
         use schemars::schema::{Schema, SchemaObject};
         use schemars::{r#gen::SchemaGenerator, schema_for, JsonSchema};
         pub fn make_schema(generator: &mut SchemaGenerator) -> Schema {
             let mut schema: SchemaObject = <String>::json_schema(generator).into();
             schema.format = Some("duration".to_owned());
             schema.into()
         }
     }
 }

 mod test {
     use super::*;
     use ::localtime::LocalTime;
     use localtime::LocalTime;
     #[test]
     fn test_localtime() {

 use std::collections::HashSet;
 use serde::{Deserialize, Serialize};
 use crate::prelude::RepoId;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 /// Web configuration.
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct Config {
     /// Pinned content.

 /// Pinned content. This can be used to pin certain content when
 /// listing, e.g. pin repositories on a web client.
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct Pinned {
     /// Pinned repositories.