valico 3.1.0

use serde_json::Value;
use std::collections;
use url;

use super::super::errors;
use super::super::scope;

#[derive(Debug)]
pub enum DepKind {
    Schema(url::Url),
    Property(Vec<String>),
}

#[allow(missing_copy_implementations)]
pub struct Dependencies {
    pub items: collections::HashMap<String, DepKind>,
}

impl super::Validator for Dependencies {
    fn validate(&self, object: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
        if !object.is_object() {
            return super::ValidationState::new();
        }

        let mut state = super::ValidationState::new();

        for (key, dep) in self.items.iter() {
            if object.get(&key).is_some() {
                match dep {
                    DepKind::Schema(ref url) => {
                        let schema = scope.resolve(url);
                        if schema.is_some() {
                            state.append(schema.unwrap().validate_in(object, path));
                        } else {
                            state.missing.push(url.clone())
                        }
                    }
                    DepKind::Property(ref keys) => {
                        for key in keys.iter() {
                            if object.get(&key).is_none() {
                                state.errors.push(Box::new(errors::Required {
                                    path: [path, key.as_ref()].join("/"),
                                }))
                            }
                        }
                    }
                }
            }
        }

        state
    }
}