use serde::{Serialize, Serializer};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Type {
String,
Number,
Bool,
Array(Box<Type>),
Object(Vec<(String, Type)>),
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct Param {
pub name: String,
#[serde(rename = "type")]
pub ty: Type,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct ExitCode {
pub code: i32,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub desc: Option<String>,
}
impl Type {
pub fn parse(s: &str) -> Result<Type, String> {
let mut parser = Parser {
chars: s.chars().collect(),
pos: 0,
};
let ty = parser.parse_type()?;
parser.skip_ws();
if parser.pos != parser.chars.len() {
return Err(format!("unexpected trailing characters in type `{s}`"));
}
Ok(ty)
}
pub fn to_schema(&self) -> serde_json::Value {
match self {
Type::String => serde_json::json!({ "type": "string" }),
Type::Number => serde_json::json!({ "type": "number" }),
Type::Bool => serde_json::json!({ "type": "boolean" }),
Type::Array(inner) => serde_json::json!({
"type": "array",
"items": inner.to_schema(),
}),
Type::Object(fields) => {
let properties: serde_json::Map<String, serde_json::Value> = fields
.iter()
.map(|(key, ty)| (key.clone(), ty.to_schema()))
.collect();
let required: Vec<&String> = fields.iter().map(|(key, _)| key).collect();
serde_json::json!({
"type": "object",
"properties": properties,
"required": required,
})
}
}
}
}
impl std::fmt::Display for Type {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Type::String => f.write_str("string"),
Type::Number => f.write_str("number"),
Type::Bool => f.write_str("bool"),
Type::Array(inner) => write!(f, "[{inner}]"),
Type::Object(fields) if fields.is_empty() => f.write_str("{}"),
Type::Object(fields) => {
f.write_str("{ ")?;
for (i, (key, ty)) in fields.iter().enumerate() {
if i > 0 {
f.write_str(", ")?;
}
write!(f, "\"{key}\": {ty}")?;
}
f.write_str(" }")
}
}
}
}
impl Serialize for Type {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&self.to_string())
}
}
struct Parser {
chars: Vec<char>,
pos: usize,
}
impl Parser {
fn peek(&self) -> Option<char> {
self.chars.get(self.pos).copied()
}
fn bump(&mut self) -> Option<char> {
let c = self.peek();
if c.is_some() {
self.pos += 1;
}
c
}
fn skip_ws(&mut self) {
while matches!(self.peek(), Some(c) if c.is_whitespace()) {
self.pos += 1;
}
}
fn expect(&mut self, want: char) -> Result<(), String> {
match self.bump() {
Some(got) if got == want => Ok(()),
Some(got) => Err(format!("expected `{want}`, found `{got}`")),
None => Err(format!("expected `{want}`, reached end of input")),
}
}
fn parse_type(&mut self) -> Result<Type, String> {
self.skip_ws();
match self.peek() {
Some('[') => self.parse_array(),
Some('{') => self.parse_object(),
Some(c) if c.is_ascii_alphabetic() => self.parse_scalar(),
Some(c) => Err(format!("unexpected character `{c}` in type")),
None => Err("expected a type but reached end of input".to_string()),
}
}
fn parse_scalar(&mut self) -> Result<Type, String> {
let start = self.pos;
while matches!(self.peek(), Some(c) if c.is_ascii_alphabetic()) {
self.pos += 1;
}
let word: String = self.chars[start..self.pos].iter().collect();
match word.as_str() {
"string" => Ok(Type::String),
"number" => Ok(Type::Number),
"bool" => Ok(Type::Bool),
other => Err(format!("unknown type `{other}`")),
}
}
fn parse_array(&mut self) -> Result<Type, String> {
self.expect('[')?;
let inner = self.parse_type()?;
self.skip_ws();
self.expect(']')?;
Ok(Type::Array(Box::new(inner)))
}
fn parse_object(&mut self) -> Result<Type, String> {
self.expect('{')?;
self.skip_ws();
let mut fields = Vec::new();
if self.peek() == Some('}') {
self.bump();
return Ok(Type::Object(fields));
}
loop {
self.skip_ws();
let key = self.parse_string_key()?;
self.skip_ws();
self.expect(':')?;
let ty = self.parse_type()?;
fields.push((key, ty));
self.skip_ws();
match self.bump() {
Some(',') => continue,
Some('}') => break,
Some(c) => return Err(format!("expected `,` or `}}` in object type, found `{c}`")),
None => return Err("unterminated object type".to_string()),
}
}
Ok(Type::Object(fields))
}
fn parse_string_key(&mut self) -> Result<String, String> {
self.expect('"')?;
let start = self.pos;
while let Some(c) = self.peek() {
if c == '"' {
let key: String = self.chars[start..self.pos].iter().collect();
self.bump();
return Ok(key);
}
self.pos += 1;
}
Err("unterminated string key in object type".to_string())
}
}
#[cfg(test)]
#[path = "types_tests.rs"]
mod tests;