yerba 0.5.0

YAML Editing and Refactoring with Better Accuracy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use super::*;

impl Document {
  pub fn validate_schema(&self, schema: &serde_json::Value, items: bool, selector: Option<&str>) -> Vec<crate::schema::ValidationError> {
    let path = selector.unwrap_or("");
    let has_wildcard = crate::selector::Selector::parse(path).has_wildcard();

    let value = match self.get_value(path) {
      Some(value) => crate::json::yaml_to_json(&value),
      None => return vec![],
    };

    let validate_items = items || has_wildcard;

    let mut errors = if validate_items {
      match value.as_array() {
        Some(array) => crate::schema::validate_array(array, schema),
        None if value.is_null() => vec![crate::schema::ValidationError {
          path: String::new(),
          message: "expected an array but document is empty or not a sequence".to_string(),
          item_label: None,
          line: None,
        }],
        None => crate::schema::validate_array(std::slice::from_ref(&value), schema),
      }
    } else {
      if value.is_null() {
        return vec![];
      }

      crate::schema::validate_value(&value, schema)
    };

    let source = self.to_string();

    for error in &mut errors {
      if !error.path.is_empty() {
        let selector = json_pointer_to_selector(&error.path);

        if let Ok(node) = self.navigate(&selector) {
          let offset: usize = node.text_range().start().into();
          let line = source[..offset].chars().filter(|c| *c == '\n').count() + 1;

          error.line = Some(line);
        }
      }
    }

    errors
  }
}

fn json_pointer_to_selector(pointer: &str) -> String {
  pointer
    .strip_prefix('/')
    .unwrap_or(pointer)
    .split('/')
    .map(|segment| {
      if let Ok(index) = segment.parse::<usize>() {
        format!("[{}]", index)
      } else {
        segment.to_string()
      }
    })
    .fold(String::new(), |mut path, segment| {
      if !path.is_empty() && !segment.starts_with('[') {
        path.push('.');
      }

      path.push_str(&segment);
      path
    })
}