yerba 0.4.2

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use super::*;

impl Document {
  pub fn set(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
    let current_node = self.navigate(dot_path)?;

    if let Some(block_scalar) = current_node.descendants().find(|node| node.kind() == SyntaxKind::BLOCK_SCALAR) {
      let new_text = if value.is_empty() {
        "\"\"".to_string()
      } else if value.contains('\n') {
        format!("|-\n  {}", value.replace('\n', "\n  "))
      } else {
        format!("\"{}\"", value.replace('"', "\\\""))
      };

      let range = block_scalar.text_range();

      return self.apply_edit(range, &new_text);
    }

    let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;

    let new_text = format_scalar_value(value, scalar_token.kind());

    self.replace_token(&scalar_token, &new_text)
  }

  pub fn set_all(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
    let nodes = self.navigate_all(dot_path);

    if nodes.is_empty() {
      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
    }

    for node in nodes.into_iter().rev() {
      if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
        let new_text = if value.is_empty() {
          "\"\"".to_string()
        } else if value.contains('\n') {
          format!("|-\n  {}", value.replace('\n', "\n  "))
        } else {
          format!("\"{}\"", value.replace('"', "\\\""))
        };

        self.apply_edit(block_scalar.text_range(), &new_text)?;
      } else if let Some(scalar_token) = find_scalar_token(&node) {
        let new_text = format_scalar_value(value, scalar_token.kind());

        self.replace_token(&scalar_token, &new_text)?;
      }
    }

    Ok(())
  }

  pub fn set_scalar_style(&mut self, dot_path: &str, style: &QuoteStyle) -> Result<(), YerbaError> {
    let current_node = self.navigate(dot_path)?;
    let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;

    let current_kind = scalar_token.kind();
    let target_kind = style.to_syntax_kind();

    if current_kind == target_kind {
      return Ok(());
    }

    let raw_value = match current_kind {
      SyntaxKind::DOUBLE_QUOTED_SCALAR => {
        let text = scalar_token.text();
        unescape_double_quoted(&text[1..text.len() - 1])
      }

      SyntaxKind::SINGLE_QUOTED_SCALAR => {
        let text = scalar_token.text();
        unescape_single_quoted(&text[1..text.len() - 1])
      }

      SyntaxKind::PLAIN_SCALAR => scalar_token.text().to_string(),

      _ => return Ok(()),
    };

    let new_text = format_scalar_value(&raw_value, target_kind);

    self.replace_token(&scalar_token, &new_text)
  }

  pub fn set_plain(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
    let current_node = self.navigate(dot_path)?;

    if let Some(block_scalar) = current_node.descendants().find(|node| node.kind() == SyntaxKind::BLOCK_SCALAR) {
      let range = block_scalar.text_range();
      return self.apply_edit(range, value);
    }

    let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;

    self.replace_token(&scalar_token, value)
  }
}