waalge
/
aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Factor out error (schema mismatch) creation during blueprint validation.

This commit is contained in:
KtorZ 2023-04-07 16:20:51 +02:00
parent 7d6612b108
commit 176cb45524
No known key found for this signature in database
GPG Key ID: 33173CB6F77F4277
1 changed files with 49 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
crates/aiken-project/src/blueprint/parameter.rs
View File

@ -50,6 +50,13 @@ impl Parameter {
} }
} }
fn mismatch(term: &Constant, schema: Schema) -> Error {
Error::SchemaMismatch {
schema,
term: term.clone(),
}
}
fn validate_schema( fn validate_schema(
schema: &Schema, schema: &Schema,
definitions: &Definitions<Annotated<Schema>>, definitions: &Definitions<Annotated<Schema>>,
@ -247,8 +254,9 @@ fn validate_data(
} }
} }
Err(Error::SchemaMismatch { Err(mismatch(
schema: Schema::Data(Data::AnyOf( term,
Schema::Data(Data::AnyOf(
constructors constructors
.iter() .iter()
.map(|(index, fields)| { .map(|(index, fields)| {
@ -263,8 +271,7 @@ fn validate_data(
}) })
.collect(), .collect(),
)), )),
term: term.clone(), ))
})
} }
} }
} }
@ -274,10 +281,7 @@ fn expect_data(term: &Constant) -> Result<(), Error> {
return Ok(()); return Ok(());
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::Data(Data::Opaque)))
schema: Schema::Data(Data::Opaque),
term: term.clone(),
})
} }
fn expect_data_integer(term: &Constant) -> Result<(), Error> { fn expect_data_integer(term: &Constant) -> Result<(), Error> {
@ -287,10 +291,7 @@ fn expect_data_integer(term: &Constant) -> Result<(), Error> {
} }
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::Data(Data::Integer)))
schema: Schema::Data(Data::Integer),
term: term.clone(),
})
} }
fn expect_data_bytes(term: &Constant) -> Result<(), Error> { fn expect_data_bytes(term: &Constant) -> Result<(), Error> {
@ -300,10 +301,7 @@ fn expect_data_bytes(term: &Constant) -> Result<(), Error> {
} }
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::Data(Data::Bytes)))
schema: Schema::Data(Data::Bytes),
term: term.clone(),
})
} }
fn expect_data_list(term: &Constant) -> Result<Vec<Constant>, Error> { fn expect_data_list(term: &Constant) -> Result<Vec<Constant>, Error> {
@ -314,12 +312,12 @@ fn expect_data_list(term: &Constant) -> Result<Vec<Constant>, Error> {
.collect()); .collect());
} }
let inner_schema = Items::One(Declaration::Inline(Box::new(Data::Opaque))); Err(mismatch(
term,
Err(Error::SchemaMismatch { Schema::Data(Data::List(Items::One(Declaration::Inline(Box::new(
schema: Schema::Data(Data::List(inner_schema)), Data::Opaque,
term: term.clone(), ))))),
}) ))
} }
fn expect_data_map(term: &Constant) -> Result<Vec<(Constant, Constant)>, Error> { fn expect_data_map(term: &Constant) -> Result<Vec<(Constant, Constant)>, Error> {
@ -330,13 +328,13 @@ fn expect_data_map(term: &Constant) -> Result<Vec<(Constant, Constant)>, Error>
.collect()); .collect());
} }
let key_schema = Declaration::Inline(Box::new(Data::Opaque)); Err(mismatch(
let value_schema = Declaration::Inline(Box::new(Data::Opaque)); term,
Schema::Data(Data::Map(
Err(Error::SchemaMismatch { Declaration::Inline(Box::new(Data::Opaque)),
schema: Schema::Data(Data::Map(key_schema, value_schema)), Declaration::Inline(Box::new(Data::Opaque)),
term: term.clone(), )),
}) ))
} }
fn expect_data_constr(term: &Constant, index: usize) -> Result<Vec<Constant>, Error> { fn expect_data_constr(term: &Constant, index: usize) -> Result<Vec<Constant>, Error> {
@ -352,14 +350,14 @@ fn expect_data_constr(term: &Constant, index: usize) -> Result<Vec<Constant>, Er
} }
} }
Err(Error::SchemaMismatch { Err(mismatch(
schema: Schema::Data(Data::AnyOf(vec![Constructor { term,
Schema::Data(Data::AnyOf(vec![Constructor {
index, index,
fields: vec![], fields: vec![],
} }
.into()])), .into()])),
term: term.clone(), ))
})
} }
fn expect_unit(term: &Constant) -> Result<(), Error> { fn expect_unit(term: &Constant) -> Result<(), Error> {
@ -367,10 +365,7 @@ fn expect_unit(term: &Constant) -> Result<(), Error> {
return Ok(()); return Ok(());
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::Unit))
schema: Schema::Unit,
term: term.clone(),
})
} }
fn expect_integer(term: &Constant) -> Result<(), Error> { fn expect_integer(term: &Constant) -> Result<(), Error> {
@ -378,10 +373,7 @@ fn expect_integer(term: &Constant) -> Result<(), Error> {
return Ok(()); return Ok(());
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::Integer))
schema: Schema::Integer,
term: term.clone(),
})
} }
fn expect_bytes(term: &Constant) -> Result<(), Error> { fn expect_bytes(term: &Constant) -> Result<(), Error> {
@ -389,10 +381,7 @@ fn expect_bytes(term: &Constant) -> Result<(), Error> {
return Ok(()); return Ok(());
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::Bytes))
schema: Schema::Bytes,
term: term.clone(),
})
} }
fn expect_string(term: &Constant) -> Result<(), Error> { fn expect_string(term: &Constant) -> Result<(), Error> {
@ -400,10 +389,7 @@ fn expect_string(term: &Constant) -> Result<(), Error> {
return Ok(()); return Ok(());
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::String))
schema: Schema::String,
term: term.clone(),
})
} }
fn expect_boolean(term: &Constant) -> Result<(), Error> { fn expect_boolean(term: &Constant) -> Result<(), Error> {
@ -411,10 +397,7 @@ fn expect_boolean(term: &Constant) -> Result<(), Error> {
return Ok(()); return Ok(());
} }
Err(Error::SchemaMismatch { Err(mismatch(term, Schema::Boolean))
schema: Schema::Boolean,
term: term.clone(),
})
} }
fn expect_pair(term: &Constant) -> Result<(Constant, Constant), Error> { fn expect_pair(term: &Constant) -> Result<(Constant, Constant), Error> {
@ -422,13 +405,13 @@ fn expect_pair(term: &Constant) -> Result<(Constant, Constant), Error> {
return Ok((left.deref().clone(), right.deref().clone())); return Ok((left.deref().clone(), right.deref().clone()));
} }
let left_schema = Declaration::Inline(Box::new(Schema::Data(Data::Opaque))); Err(mismatch(
let right_schema = Declaration::Inline(Box::new(Schema::Data(Data::Opaque))); term,
Schema::Pair(
Err(Error::SchemaMismatch { Declaration::Inline(Box::new(Schema::Data(Data::Opaque))),
schema: Schema::Pair(left_schema, right_schema), Declaration::Inline(Box::new(Schema::Data(Data::Opaque))),
term: term.clone(), ),
}) ))
} }
fn expect_list(term: &Constant) -> Result<Vec<Constant>, Error> { fn expect_list(term: &Constant) -> Result<Vec<Constant>, Error> {
@ -436,10 +419,10 @@ fn expect_list(term: &Constant) -> Result<Vec<Constant>, Error> {
return Ok(elems.to_owned()); return Ok(elems.to_owned());
} }
let inner_schema = Items::One(Declaration::Inline(Box::new(Schema::Data(Data::Opaque)))); Err(mismatch(
term,
Err(Error::SchemaMismatch { Schema::List(Items::One(Declaration::Inline(Box::new(Schema::Data(
schema: Schema::List(inner_schema), Data::Opaque,
term: term.clone(), ))))),
}) ))
} }