yerba 0.2.2 → 0.4.0

data/rust/src/document/get.rs

@@ -0,0 +1,262 @@
+use super::*;
+
+impl Document {
+  pub fn get(&self, dot_path: &str) -> Option<String> {
+    if dot_path.contains('[') {
+      return self.get_all(dot_path).into_iter().next();
+    }
+
+    let current_node = self.navigate(dot_path).ok()?;
+
+    extract_scalar_text(&current_node)
+  }
+
+  pub fn get_all(&self, dot_path: &str) -> Vec<String> {
+    self.navigate_all(dot_path).iter().filter_map(extract_scalar_text).collect()
+  }
+
+  pub fn get_typed(&self, dot_path: &str) -> Option<ScalarValue> {
+    if crate::selector::Selector::parse(dot_path).has_wildcard() {
+      return self.get_all_typed(dot_path).into_iter().next();
+    }
+
+    let current_node = self.navigate(dot_path).ok()?;
+
+    if current_node
+      .descendants()
+      .any(|child| child.kind() == SyntaxKind::BLOCK_MAP || child.kind() == SyntaxKind::BLOCK_SEQ)
+    {
+      return None;
+    }
+
+    extract_scalar(&current_node)
+  }
+
+  pub fn get_all_typed(&self, dot_path: &str) -> Vec<ScalarValue> {
+    self
+      .navigate_all(dot_path)
+      .iter()
+      .filter(|node| {
+        !node
+          .descendants()
+          .any(|child| child.kind() == SyntaxKind::BLOCK_MAP || child.kind() == SyntaxKind::BLOCK_SEQ)
+      })
+      .filter_map(extract_scalar)
+      .collect()
+  }
+
+  pub fn node_type(&self, dot_path: &str) -> NodeType {
+    match self.navigate(dot_path) {
+      Ok(node) => {
+        if let Some(first_structural) = node
+          .descendants()
+          .find(|child| BlockMap::can_cast(child.kind()) || BlockSeq::can_cast(child.kind()))
+        {
+          if BlockMap::can_cast(first_structural.kind()) {
+            NodeType::Map
+          } else {
+            NodeType::Sequence
+          }
+        } else if extract_scalar(&node).is_some() {
+          NodeType::Scalar
+        } else {
+          NodeType::NotFound
+        }
+      }
+      Err(_) => NodeType::NotFound,
+    }
+  }
+
+  pub fn get_node_info(&self, dot_path: &str) -> NodeInfo {
+    let selector = crate::selector::Selector::parse(dot_path);
+    let source = self.root.text().to_string();
+
+    let (location, key_name, key_location) = self.resolve_location(dot_path, &source);
+
+    if selector.has_wildcard() {
+      let values = self.get_all_typed(dot_path);
+
+      return NodeInfo {
+        node_type: NodeType::Sequence,
+        is_list: true,
+        value: None,
+        list_values: values,
+        location,
+        key_name,
+        key_location,
+      };
+    }
+
+    match self.get_typed(dot_path) {
+      Some(scalar) => NodeInfo {
+        node_type: NodeType::Scalar,
+        is_list: false,
+        value: Some(scalar),
+        list_values: vec![],
+        location,
+        key_name,
+        key_location,
+      },
+      None => NodeInfo {
+        node_type: self.node_type(dot_path),
+        is_list: false,
+        value: None,
+        list_values: vec![],
+        location,
+        key_name,
+        key_location,
+      },
+    }
+  }
+
+  fn resolve_location(&self, dot_path: &str, source: &str) -> (Location, Option<String>, Location) {
+    match self.navigate(dot_path) {
+      Ok(node) => {
+        let range = node.text_range();
+        let location = compute_location(source, range.start().into(), range.end().into());
+
+        let (key_name, key_location) = node
+          .parent()
+          .and_then(|parent| {
+            use yaml_parser::ast::BlockMapEntry;
+
+            BlockMapEntry::cast(parent).and_then(|entry| {
+              entry.key().and_then(|key_node| {
+                let key_text = extract_scalar_text(key_node.syntax())?;
+                let key_range = key_node.syntax().text_range();
+                let key_location = compute_location(source, key_range.start().into(), key_range.end().into());
+
+                Some((key_text, key_location))
+              })
+            })
+          })
+          .map(|(name, location)| (Some(name), location))
+          .unwrap_or((None, Location::default()));
+
+        (location, key_name, key_location)
+      }
+      Err(_) => (Location::default(), None, Location::default()),
+    }
+  }
+
+  pub fn find_items(&self, dot_path: &str, condition: Option<&str>, select: Option<&str>) -> Vec<serde_json::Value> {
+    let values = match condition {
+      Some(cond) => self.filter(dot_path, cond),
+      None => self.get_values(dot_path),
+    };
+
+    let select_fields: Option<Vec<&str>> = select.map(|s| s.split(',').collect());
+
+    values
+      .iter()
+      .map(|value| match &select_fields {
+        Some(fields) => {
+          let mut result = serde_json::Map::new();
+
+          for field in fields {
+            let json_value = crate::json::resolve_select_field(value, field);
+            let json_key = crate::json::select_field_key(field);
+            result.insert(json_key, json_value);
+          }
+
+          serde_json::Value::Object(result)
+        }
+        None => crate::json::yaml_to_json(value),
+      })
+      .collect()
+  }
+
+  pub fn get_value(&self, dot_path: &str) -> Option<serde_yaml::Value> {
+    if dot_path.is_empty() {
+      return Some(node_to_yaml_value(&self.root));
+    }
+
+    let nodes = self.navigate_all(dot_path);
+
+    if nodes.is_empty() {
+      return None;
+    }
+
+    if nodes.len() == 1 {
+      return Some(node_to_yaml_value(&nodes[0]));
+    }
+
+    let values: Vec<serde_yaml::Value> = nodes.iter().map(node_to_yaml_value).collect();
+
+    Some(serde_yaml::Value::Sequence(values))
+  }
+
+  pub fn get_values(&self, dot_path: &str) -> Vec<serde_yaml::Value> {
+    self.navigate_all(dot_path).iter().map(node_to_yaml_value).collect()
+  }
+
+  pub fn selectors(&self) -> Vec<String> {
+    let Some(value) = self.get_value("") else {
+      return Vec::new();
+    };
+
+    let mut selectors = Vec::new();
+
+    collect_selectors(&value, "", &mut selectors);
+    selectors.sort();
+    selectors.dedup();
+
+    selectors
+  }
+
+  pub fn exists(&self, dot_path: &str) -> bool {
+    if dot_path.contains('[') {
+      return !self.navigate_all(dot_path).is_empty();
+    }
+
+    self.get(dot_path).is_some()
+  }
+
+  pub fn get_sequence_values(&self, dot_path: &str) -> Vec<String> {
+    let current_node = match self.navigate(dot_path) {
+      Ok(node) => node,
+      Err(_) => return Vec::new(),
+    };
+
+    let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
+      Some(sequence) => sequence,
+      None => return Vec::new(),
+    };
+
+    sequence
+      .entries()
+      .filter_map(|entry| entry.flow().and_then(|flow| extract_scalar_text(flow.syntax())))
+      .collect()
+  }
+
+  pub fn get_quote_style(&self, dot_path: &str) -> Option<&'static str> {
+    let current_node = self.navigate(dot_path).ok()?;
+
+    for element in current_node.descendants_with_tokens() {
+      match element.kind() {
+        SyntaxKind::PLAIN_SCALAR => return Some("plain"),
+        SyntaxKind::SINGLE_QUOTED_SCALAR => return Some("single"),
+        SyntaxKind::DOUBLE_QUOTED_SCALAR => return Some("double"),
+
+        SyntaxKind::BLOCK_SCALAR => {
+          let text = element.as_node()?.text().to_string();
+          let header = text.lines().next().unwrap_or("").trim();
+
+          return match header {
+            "|-" => Some("literal"),
+            "|" => Some("literal-clip"),
+            "|+" => Some("literal-keep"),
+            ">-" => Some("folded"),
+            ">" => Some("folded-clip"),
+            ">+" => Some("folded-keep"),
+            _ => None,
+          };
+        }
+
+        _ => {}
+      }
+    }
+
+    None
+  }
+}

data/rust/src/document/insert.rs

@@ -0,0 +1,314 @@
+use super::*;
+
+impl Document {
+  pub fn append(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    self.insert_into(dot_path, value, InsertPosition::Last)
+  }
+
+  pub fn detect_sequence_quote_style(&self, dot_path: &str) -> QuoteStyle {
+    let try_paths = if dot_path.is_empty() {
+      vec!["[]".to_string(), "[0]".to_string()]
+    } else {
+      vec![format!("{}[]", dot_path), format!("{}[0]", dot_path)]
+    };
+
+    for try_path in &try_paths {
+      for scalar in self.get_all_typed(try_path) {
+        if scalar.kind == SyntaxKind::DOUBLE_QUOTED_SCALAR {
+          return QuoteStyle::Double;
+        } else if scalar.kind == SyntaxKind::SINGLE_QUOTED_SCALAR {
+          return QuoteStyle::Single;
+        }
+      }
+    }
+
+    if let Some(serde_yaml::Value::Sequence(sequence)) = self.get_value(dot_path).as_ref() {
+      if let Some(serde_yaml::Value::Mapping(map)) = sequence.first() {
+        if let Some((serde_yaml::Value::String(key_name), _)) = map.iter().next() {
+          let deep_path = if dot_path.is_empty() {
+            format!("[].{}", key_name)
+          } else {
+            format!("{}[].{}", dot_path, key_name)
+          };
+
+          for scalar in self.get_all_typed(&deep_path) {
+            if scalar.kind == SyntaxKind::DOUBLE_QUOTED_SCALAR {
+              return QuoteStyle::Double;
+            } else if scalar.kind == SyntaxKind::SINGLE_QUOTED_SCALAR {
+              return QuoteStyle::Single;
+            }
+          }
+        }
+      }
+    }
+
+    QuoteStyle::Plain
+  }
+
+  pub fn insert_object(&mut self, dot_path: &str, json_value: &serde_json::Value, position: InsertPosition) -> Result<(), YerbaError> {
+    let quote_style = self.detect_sequence_quote_style(dot_path);
+    let yaml_text = crate::yaml_writer::json_to_yaml_text(json_value, &quote_style, 0);
+
+    self.insert_into(dot_path, &yaml_text, position)
+  }
+
+  pub fn insert_into(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
+    Self::validate_path(dot_path)?;
+
+    if let Ok(current_node) = self.navigate(dot_path) {
+      if current_node.descendants().find_map(BlockSeq::cast).is_some() {
+        return self.insert_sequence_item(dot_path, value, position);
+      }
+    }
+
+    let (parent_path, key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
+
+    self.insert_map_key(parent_path, key, value, position)
+  }
+
+  fn insert_sequence_item(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
+    let current_node = self.navigate(dot_path)?;
+
+    let sequence = current_node
+      .descendants()
+      .find_map(BlockSeq::cast)
+      .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+
+    let entries: Vec<_> = sequence.entries().collect();
+
+    if entries.is_empty() {
+      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+    }
+
+    let indent = entries
+      .get(1)
+      .or(entries.first())
+      .map(|entry| preceding_whitespace_indent(entry.syntax()))
+      .unwrap_or_default();
+
+    let new_item = if value.contains('\n') {
+      let item_indent = format!("{}  ", indent);
+      let lines: Vec<&str> = value.split('\n').collect();
+
+      let min_indent = lines
+        .iter()
+        .skip(1)
+        .filter(|line| !line.trim().is_empty())
+        .map(|line| line.len() - line.trim_start().len())
+        .min()
+        .unwrap_or(0);
+
+      let indented: Vec<String> = lines
+        .iter()
+        .enumerate()
+        .map(|(index, line)| {
+          if index == 0 {
+            line.to_string()
+          } else if line.trim().is_empty() {
+            String::new()
+          } else {
+            let relative = &line[min_indent..];
+            format!("{}{}", item_indent, relative)
+          }
+        })
+        .collect();
+
+      format!("- {}", indented.join("\n"))
+    } else {
+      format!("- {}", value)
+    };
+
+    match position {
+      InsertPosition::Last => {
+        let last_entry = entries.last().unwrap();
+        let new_text = format!("\n{}{}", indent, new_item);
+
+        self.insert_after_node(last_entry.syntax(), &new_text)
+      }
+
+      InsertPosition::At(index) => {
+        if index >= entries.len() {
+          let last_entry = entries.last().unwrap();
+          let new_text = format!("\n{}{}", indent, new_item);
+
+          self.insert_after_node(last_entry.syntax(), &new_text)
+        } else {
+          let target_entry = &entries[index];
+          let target_range = target_entry.syntax().text_range();
+          let replacement = format!("{}\n{}", new_item, indent);
+          let insert_range = TextRange::new(target_range.start(), target_range.start());
+
+          self.apply_edit(insert_range, &replacement)
+        }
+      }
+
+      InsertPosition::Before(target_value) => {
+        let target_entry = entries
+          .iter()
+          .find(|entry| {
+            entry
+              .flow()
+              .and_then(|flow| extract_scalar_text(flow.syntax()))
+              .map(|text| text == target_value)
+              .unwrap_or(false)
+          })
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, target_value)))?;
+
+        let target_range = target_entry.syntax().text_range();
+        let replacement = format!("{}\n{}", new_item, indent);
+        let insert_range = TextRange::new(target_range.start(), target_range.start());
+
+        self.apply_edit(insert_range, &replacement)
+      }
+
+      InsertPosition::After(target_value) => {
+        let target_entry = entries
+          .iter()
+          .find(|entry| {
+            entry
+              .flow()
+              .and_then(|flow| extract_scalar_text(flow.syntax()))
+              .map(|text| text == target_value)
+              .unwrap_or(false)
+          })
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, target_value)))?;
+
+        let new_text = format!("\n{}{}", indent, new_item);
+
+        self.insert_after_node(target_entry.syntax(), &new_text)
+      }
+
+      InsertPosition::BeforeCondition(condition) => {
+        let target_entry = entries
+          .iter()
+          .find(|entry| self.evaluate_condition_on_node(entry.syntax(), &condition))
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} condition '{}'", dot_path, condition)))?;
+
+        let target_range = target_entry.syntax().text_range();
+        let replacement = format!("{}\n{}", new_item, indent);
+        let insert_range = TextRange::new(target_range.start(), target_range.start());
+
+        self.apply_edit(insert_range, &replacement)
+      }
+
+      InsertPosition::AfterCondition(condition) => {
+        let target_entry = entries
+          .iter()
+          .find(|entry| self.evaluate_condition_on_node(entry.syntax(), &condition))
+          .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} condition '{}'", dot_path, condition)))?;
+
+        let new_text = format!("\n{}{}", indent, new_item);
+
+        self.insert_after_node(target_entry.syntax(), &new_text)
+      }
+
+      InsertPosition::FromSortOrder(_) => {
+        let last_entry = entries.last().unwrap();
+        let new_text = format!("\n{}{}", indent, new_item);
+
+        self.insert_after_node(last_entry.syntax(), &new_text)
+      }
+    }
+  }
+
+  fn insert_map_key(&mut self, dot_path: &str, key: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
+    let current_node = self.navigate(dot_path)?;
+
+    let map = current_node
+      .descendants()
+      .find_map(BlockMap::cast)
+      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+    let entries: Vec<_> = map.entries().collect();
+
+    if entries.is_empty() {
+      let indent = preceding_whitespace_indent(map.syntax());
+      let new_entry = format!("\n{}{}: {}", indent, key, value);
+
+      return self.insert_after_node(map.syntax(), &new_entry);
+    }
+
+    if find_entry_by_key(&map, key).is_some() {
+      return Err(YerbaError::ParseError(format!("key '{}' already exists at '{}'", key, dot_path)));
+    }
+
+    let indent = entries
+      .get(1)
+      .or(entries.first())
+      .map(|entry| preceding_whitespace_indent(entry.syntax()))
+      .unwrap_or_default();
+
+    let new_entry_text = format!("{}: {}", key, value);
+
+    match position {
+      InsertPosition::Last => {
+        let last_entry = entries.last().unwrap();
+        let new_text = format!("\n{}{}", indent, new_entry_text);
+
+        self.insert_after_node(last_entry.syntax(), &new_text)
+      }
+
+      InsertPosition::At(index) => {
+        if index >= entries.len() {
+          let last_entry = entries.last().unwrap();
+          let new_text = format!("\n{}{}", indent, new_entry_text);
+
+          self.insert_after_node(last_entry.syntax(), &new_text)
+        } else {
+          let target_entry = &entries[index];
+          let target_range = target_entry.syntax().text_range();
+          let replacement = format!("{}\n{}", new_entry_text, indent);
+          let insert_range = TextRange::new(target_range.start(), target_range.start());
+
+          self.apply_edit(insert_range, &replacement)
+        }
+      }
+
+      InsertPosition::Before(target_key) => {
+        let target_entry = find_entry_by_key(&map, &target_key).ok_or_else(|| YerbaError::SelectorNotFound(format!("{}.{}", dot_path, target_key)))?;
+
+        let target_range = target_entry.syntax().text_range();
+        let replacement = format!("{}\n{}", new_entry_text, indent);
+        let insert_range = TextRange::new(target_range.start(), target_range.start());
+
+        self.apply_edit(insert_range, &replacement)
+      }
+
+      InsertPosition::After(target_key) => {
+        let target_entry = find_entry_by_key(&map, &target_key).ok_or_else(|| YerbaError::SelectorNotFound(format!("{}.{}", dot_path, target_key)))?;
+
+        let new_text = format!("\n{}{}", indent, new_entry_text);
+
+        self.insert_after_node(target_entry.syntax(), &new_text)
+      }
+
+      InsertPosition::BeforeCondition(_) | InsertPosition::AfterCondition(_) => self.insert_map_key(dot_path, key, value, InsertPosition::Last),
+
+      InsertPosition::FromSortOrder(order) => {
+        let new_key_position = order.iter().position(|ordered_key| ordered_key == key);
+
+        let resolved = match new_key_position {
+          Some(new_position) => {
+            let mut insert_after: Option<String> = None;
+
+            for ordered_key in order.iter().take(new_position).rev() {
+              if find_entry_by_key(&map, ordered_key).is_some() {
+                insert_after = Some(ordered_key.clone());
+                break;
+              }
+            }
+
+            match insert_after {
+              Some(after_key) => InsertPosition::After(after_key),
+              None => InsertPosition::At(0),
+            }
+          }
+
+          None => InsertPosition::Last,
+        };
+
+        self.insert_map_key(dot_path, key, value, resolved)
+      }
+    }
+  }
+}