blob: 5d0d5c9ae5cb8aa3117798bc3992ebd45d474402 [file] [log] [blame]
use regex;
use url;
use serde_json::{Value, to_value};
use serde::{Serialize};
use super::super::json_schema;
use super::builder;
use super::coercers;
use super::validators;
pub struct Param {
pub name: String,
pub coercer: Option<Box<coercers::Coercer + Send + Sync>>,
pub nest: Option<builder::Builder>,
pub description: Option<String>,
pub allow_null: bool,
pub validators: validators::Validators,
pub default: Option<Value>,
pub schema_builder: Option<Box<Fn(&mut json_schema::Builder) + Send + Sync>>,
pub schema_id: Option<url::Url>
}
unsafe impl Send for Param { }
impl Param {
pub fn new(name: &str) -> Param {
Param {
name: name.to_string(),
description: None,
coercer: None,
nest: None,
allow_null: false,
validators: vec![],
default: None,
schema_builder: None,
schema_id: None
}
}
pub fn new_with_coercer(name: &str, coercer: Box<coercers::Coercer + Send + Sync>) -> Param {
Param {
name: name.to_string(),
description: None,
coercer: Some(coercer),
nest: None,
allow_null: false,
validators: vec![],
default: None,
schema_builder: None,
schema_id: None
}
}
pub fn new_with_nest(name: &str, coercer: Box<coercers::Coercer + Send + Sync>, nest: builder::Builder) -> Param {
Param {
name: name.to_string(),
description: None,
coercer: Some(coercer),
nest: Some(nest),
allow_null: false,
validators: vec![],
default: None,
schema_builder: None,
schema_id: None
}
}
pub fn build<F>(name: &str, build_def: F) -> Param where F: FnOnce(&mut Param) {
let mut param = Param::new(name);
build_def(&mut param);
param
}
pub fn desc(&mut self, description: &str) {
self.description = Some(description.to_string());
}
pub fn schema_id(&mut self, id: url::Url) {
self.schema_id = Some(id);
}
pub fn schema<F>(&mut self, build: F) where F: Fn(&mut json_schema::Builder,) + 'static + Send + Sync {
self.schema_builder = Some(Box::new(build));
}
pub fn coerce(&mut self, coercer: Box<coercers::Coercer + Send + Sync>) {
self.coercer = Some(coercer);
}
pub fn nest<F>(&mut self, nest_def: F) where F: FnOnce(&mut builder::Builder) -> () {
self.nest = Some(builder::Builder::build(nest_def));
}
pub fn allow_null(&mut self) {
self.allow_null = true;
}
pub fn regex(&mut self, regex: regex::Regex) {
self.validators.push(Box::new(regex));
}
pub fn validate(&mut self, validator: Box<validators::Validator + 'static + Send + Sync>) {
self.validators.push(validator);
}
pub fn validate_with<F>(&mut self, validator: F) where F: Fn(&Value, &str) -> super::validators::ValidatorResult + 'static + Send+Sync {
self.validators.push(Box::new(validator));
}
fn process_validators(&self, val: &Value, path: &str) -> super::super::ValicoErrors {
let mut errors = vec![];
for validator in self.validators.iter() {
match validator.validate(val, path) {
Ok(()) => (),
Err(validation_errors) => errors.extend(validation_errors)
}
};
errors
}
pub fn process(&self, val: &mut Value, path: &str, scope: &Option<&json_schema::Scope>) -> super::ExtendedResult<Option<Value>> {
if val.is_null() && self.allow_null {
return super::ExtendedResult::new(None)
}
let mut result = super::ExtendedResult::new(None);
let mut return_value = None;
{
let val = if self.coercer.is_some() {
match self.coercer.as_ref().unwrap().coerce(val, path) {
Ok(None) => val,
Ok(Some(new_value)) => {
return_value = Some(new_value);
return_value.as_mut().unwrap()
},
Err(errors) => {
result.state.errors.extend(errors);
return result;
}
}
} else {
val
};
if self.nest.is_some() {
let process_state = self.nest.as_ref().unwrap().process_nest(val, path, scope);
result.append(process_state);
}
let validation_errors = self.process_validators(val, path);
result.state.errors.extend(validation_errors);
if self.schema_id.is_some() && scope.is_some() {
let id = self.schema_id.as_ref().unwrap();
let schema = scope.as_ref().unwrap().resolve(id);
match schema {
Some(schema) => result.append(schema.validate_in(val, path)),
None => result.state.missing.push(id.clone())
}
}
}
if return_value.is_some() {
result.value = return_value;
}
result
}
}
impl Param {
pub fn allow_values<T: Serialize>(&mut self, values: &[T]) {
self.validators.push(Box::new(validators::AllowedValues::new(
values.iter().map(|v| to_value(v).unwrap()).collect()
)));
}
pub fn reject_values<T: Serialize>(&mut self, values: &[T]) {
self.validators.push(Box::new(validators::RejectedValues::new(
values.iter().map(|v| to_value(v).unwrap()).collect()
)));
}
pub fn default<T: Serialize>(&mut self, default: T) {
self.default = Some(to_value(&default).unwrap());
}
}