yerba 0.5.0-aarch64-linux-gnu → 0.6.0-aarch64-linux-gnu

data/rust/src/document/get.rs

@@ -53,10 +53,12 @@ impl Document {
 
     let current_node = self.navigate(dot_path).ok()?;
 
-    if current_node
-      .descendants()
-      .any(|child| child.kind() == SyntaxKind::BLOCK_MAP || child.kind() == SyntaxKind::BLOCK_SEQ)
-    {
+    if current_node.descendants().any(|child| {
+      matches!(
+        child.kind(),
+        SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_SEQ | SyntaxKind::FLOW_MAP
+      )
+    }) {
       return None;
     }
 
@@ -130,24 +132,11 @@ impl Document {
   }
 
   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,
+    match self.get_value(dot_path) {
+      Some(yaml_serde::Value::Mapping(_)) => NodeType::Map,
+      Some(yaml_serde::Value::Sequence(_)) => NodeType::Sequence,
+      Some(_) => NodeType::Scalar,
+      None => NodeType::NotFound,
     }
   }
 
@@ -278,7 +267,7 @@ impl Document {
       .collect()
   }
 
-  pub fn get_value(&self, dot_path: &str) -> Option<serde_yaml::Value> {
+  pub fn get_value(&self, dot_path: &str) -> Option<yaml_serde::Value> {
     if dot_path.is_empty() {
       return Some(node_to_yaml_value(&self.root));
     }
@@ -292,15 +281,15 @@ impl Document {
         return None;
       }
 
-      let values: Vec<serde_yaml::Value> = padded
+      let values: Vec<yaml_serde::Value> = padded
         .iter()
         .map(|maybe_node| match maybe_node {
           Some(node) => node_to_yaml_value(node),
-          None => serde_yaml::Value::Null,
+          None => yaml_serde::Value::Null,
         })
         .collect();
 
-      Some(serde_yaml::Value::Sequence(values))
+      Some(yaml_serde::Value::Sequence(values))
     } else {
       let nodes = self.navigate_all_compact(dot_path);
 
@@ -312,13 +301,13 @@ impl Document {
         return Some(node_to_yaml_value(&nodes[0]));
       }
 
-      let values: Vec<serde_yaml::Value> = nodes.iter().map(node_to_yaml_value).collect();
+      let values: Vec<yaml_serde::Value> = nodes.iter().map(node_to_yaml_value).collect();
 
-      Some(serde_yaml::Value::Sequence(values))
+      Some(yaml_serde::Value::Sequence(values))
     }
   }
 
-  pub fn get_values(&self, dot_path: &str) -> Vec<serde_yaml::Value> {
+  pub fn get_values(&self, dot_path: &str) -> Vec<yaml_serde::Value> {
     let parsed = crate::selector::Selector::parse(dot_path);
 
     if parsed.has_wildcard() {
@@ -327,7 +316,7 @@ impl Document {
         .iter()
         .map(|maybe_node| match maybe_node {
           Some(node) => node_to_yaml_value(node),
-          None => serde_yaml::Value::Null,
+          None => yaml_serde::Value::Null,
         })
         .collect()
     } else {
@@ -397,6 +386,42 @@ impl Document {
       .collect()
   }
 
+  pub fn get_collection_style(&self, dot_path: &str) -> Option<&'static str> {
+    let current_node = self.navigate(dot_path).ok()?;
+
+    for descendant in current_node.descendants() {
+      match descendant.kind() {
+        SyntaxKind::FLOW_SEQ | SyntaxKind::FLOW_MAP => return Some("flow"),
+        SyntaxKind::BLOCK_SEQ | SyntaxKind::BLOCK_MAP => return Some("block"),
+        _ => {}
+      }
+    }
+
+    None
+  }
+
+  pub fn get_sequence_indent(&self, dot_path: &str) -> Option<&'static str> {
+    let current_node = self.navigate(dot_path).ok()?;
+
+    let sequence = current_node.descendants().find_map(BlockSeq::cast)?;
+    let first_entry = sequence.entries().next()?;
+
+    let entry_indent = preceding_whitespace_indent(first_entry.syntax());
+
+    let entry_node = current_node.ancestors().find(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_ENTRY)?;
+
+    let source = self.root.text().to_string();
+    let entry_start: usize = entry_node.text_range().start().into();
+    let line_start = source[..entry_start].rfind('\n').map(|position| position + 1).unwrap_or(0);
+    let key_indent = &source[line_start..entry_start];
+
+    if entry_indent.len() > key_indent.len() {
+      Some("indented")
+    } else {
+      Some("compact")
+    }
+  }
+
   pub fn get_quote_style(&self, dot_path: &str) -> Option<&'static str> {
     let current_node = self.navigate(dot_path).ok()?;
 

data/rust/src/document/insert.rs

@@ -22,9 +22,9 @@ impl Document {
       }
     }
 
-    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() {
+    if let Some(yaml_serde::Value::Sequence(sequence)) = self.get_value(dot_path).as_ref() {
+      if let Some(yaml_serde::Value::Mapping(map)) = sequence.first() {
+        if let Some((yaml_serde::Value::String(key_name), _)) = map.iter().next() {
           let deep_path = if dot_path.is_empty() {
             format!("[].{}", key_name)
           } else {
@@ -126,23 +126,109 @@ impl Document {
     Self::validate_path(dot_path)?;
 
     if let Ok(current_node) = self.navigate(dot_path) {
-      if current_node.descendants().find_map(BlockSeq::cast).is_some() {
+      if current_node.descendants().find_map(BlockSeq::cast).is_some()
+        || matches!(self.get_value(dot_path).as_ref(), Some(yaml_serde::Value::Sequence(sequence)) if sequence.is_empty())
+      {
         return self.insert_sequence_item(dot_path, value, position);
       }
     }
 
+    let selector = crate::selector::Selector::parse(dot_path);
+    let has_wildcard = selector.has_wildcard() || selector.has_brackets();
     let (parent_path, key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
 
+    if has_wildcard {
+      let count = self.navigate_all_compact(parent_path).len();
+
+      if count == 0 {
+        return Ok(());
+      }
+
+      for i in (0..count).rev() {
+        let nodes = self.navigate_all_compact(parent_path);
+
+        let node = match nodes.get(i) {
+          Some(node) => node.clone(),
+          None => continue,
+        };
+
+        let map = match node.descendants().find_map(BlockMap::cast) {
+          Some(map) => map,
+          None => continue,
+        };
+
+        if find_entry_by_key(&map, key).is_some() {
+          continue;
+        }
+
+        let entries: Vec<_> = map.entries().collect();
+
+        if entries.is_empty() {
+          continue;
+        }
+
+        let first_entry = entries.first().unwrap();
+
+        let start_col = {
+          let offset: usize = first_entry.syntax().text_range().start().into();
+          let source = self.to_string();
+          let before = &source[..offset];
+
+          offset - before.rfind('\n').map(|p| p + 1).unwrap_or(0)
+        };
+
+        let indent = " ".repeat(start_col);
+        let new_entry_text = format!("{}: {}", key, value);
+
+        match &position {
+          InsertPosition::After(target_key) => {
+            let target = find_entry_by_key(&map, target_key);
+            let after_node = target.map(|e| e.syntax().clone()).unwrap_or_else(|| entries.last().unwrap().syntax().clone());
+            let new_text = format!("\n{}{}", indent, new_entry_text);
+
+            self.insert_after_node(&after_node, &new_text)?;
+          }
+
+          InsertPosition::Before(target_key) => {
+            if let Some(target_entry) = find_entry_by_key(&map, 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)?;
+            } else {
+              let last_entry = entries.last().unwrap();
+              let new_text = format!("\n{}{}", indent, new_entry_text);
+
+              self.insert_after_node(last_entry.syntax(), &new_text)?;
+            }
+          }
+
+          _ => {
+            let last_entry = entries.last().unwrap();
+            let new_text = format!("\n{}{}", indent, new_entry_text);
+
+            self.insert_after_node(last_entry.syntax(), &new_text)?;
+          }
+        }
+      }
+
+      return Ok(());
+    }
+
     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 Some(sequence) = current_node.descendants().find_map(BlockSeq::cast) else {
+      if matches!(self.get_value(dot_path).as_ref(), Some(yaml_serde::Value::Sequence(sequence)) if sequence.is_empty()) {
+        return self.replace_empty_inline_sequence(dot_path, value);
+      }
+
+      return Err(YerbaError::NotASequence(dot_path.to_string()));
+    };
 
     let entries: Vec<_> = sequence.entries().collect();
 
@@ -308,7 +394,34 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    let new_entry_text = format!("{}: {}", key, value);
+    let is_block_value = value.contains('\n') || value.starts_with("- ");
+    let new_entry_text = if is_block_value {
+      let value_indent = format!("{}  ", indent);
+      let lines: Vec<&str> = value.lines().collect();
+
+      let min_indent = lines
+        .iter()
+        .filter(|line| !line.trim().is_empty())
+        .map(|line| line.len() - line.trim_start().len())
+        .min()
+        .unwrap_or(0);
+
+      let indented_lines: Vec<String> = lines
+        .iter()
+        .map(|line| {
+          if line.trim().is_empty() {
+            String::new()
+          } else {
+            let relative = &line[min_indent..];
+            format!("{}{}", value_indent, relative)
+          }
+        })
+        .collect();
+
+      format!("{}:\n{}", key, indented_lines.join("\n"))
+    } else {
+      format!("{}: {}", key, value)
+    };
 
     match position {
       InsertPosition::Last => {
@@ -381,4 +494,86 @@ impl Document {
       }
     }
   }
+
+  fn replace_empty_inline_sequence(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
+    let (parent_path, key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
+    let parent_node = self.navigate(parent_path)?;
+    let map = parent_node
+      .descendants()
+      .find_map(BlockMap::cast)
+      .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+    let entry = find_entry_by_key(&map, key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+    let item_indent = format!("{}  ", preceding_whitespace_indent(entry.syntax()));
+    let new_item = Self::format_sequence_item(value, &item_indent);
+    let current_node = self.navigate(dot_path)?;
+    let mut range = current_node.text_range();
+    let inline_comment = self.trailing_inline_comment(&current_node);
+
+    if let Some(previous) = current_node.prev_sibling_or_token().and_then(|element| element.into_token()) {
+      if previous.kind() == SyntaxKind::WHITESPACE && !previous.text().contains('\n') {
+        range = TextRange::new(previous.text_range().start(), range.end());
+      }
+    }
+
+    if let Some((_, comment_end)) = inline_comment {
+      range = TextRange::new(range.start(), comment_end);
+    }
+
+    let replacement = match inline_comment {
+      Some((comment_text, _)) => format!(" {}\n{}{}", comment_text, item_indent, new_item),
+      None => format!("\n{}{}", item_indent, new_item),
+    };
+
+    self.apply_edit(range, &replacement)
+  }
+
+  fn trailing_inline_comment(&self, node: &SyntaxNode) -> Option<(String, rowan::TextSize)> {
+    let source = self.root.text().to_string();
+    let start: usize = node.text_range().end().into();
+    let rest = &source[start..];
+    let line_end = rest.find('\n').unwrap_or(rest.len());
+    let trailing = &rest[..line_end];
+    let comment_start = trailing.find('#')?;
+
+    if !trailing[..comment_start].trim().is_empty() {
+      return None;
+    }
+
+    Some((trailing[comment_start..].to_string(), rowan::TextSize::from((start + line_end) as u32)))
+  }
+
+  fn format_sequence_item(value: &str, indent: &str) -> String {
+    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)
+    }
+  }
 }

data/rust/src/document/mod.rs

@@ -5,7 +5,7 @@ mod insert;
 mod schema;
 mod set;
 mod sort;
-mod style;
+pub mod style;
 mod unique;
 pub use unique::DuplicateInfo;
 
@@ -25,9 +25,9 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use rowan::ast::AstNode;
-use rowan::TextRange;
+use rowan::{TextRange, TextSize};
 
-use yaml_parser::ast::{BlockMap, BlockSeq, Root};
+use yaml_parser::ast::{BlockMap, BlockMapEntry, BlockSeq, Root};
 use yaml_parser::{SyntaxKind, SyntaxNode, SyntaxToken};
 
 use crate::error::YerbaError;
@@ -35,7 +35,7 @@ use crate::QuoteStyle;
 
 use crate::syntax::{
   dedent_block_scalar, extract_scalar, extract_scalar_text, find_entry_by_key, find_scalar_token, format_scalar_value, is_map_key, is_yaml_non_string,
-  preceding_whitespace_indent, removal_range, unescape_double_quoted, unescape_single_quoted, ScalarValue,
+  preceding_whitespace_indent, preceding_whitespace_token, removal_range, unescape_double_quoted, unescape_single_quoted, ScalarValue,
 };
 
 #[derive(Debug, Clone)]
@@ -297,6 +297,45 @@ impl Document {
     self.apply_edit(range, text)
   }
 
+  fn remove_map_entry(&mut self, entry: &BlockMapEntry) -> Result<(), YerbaError> {
+    let entry_node = entry.syntax();
+    let entry_range = entry_node.text_range();
+
+    let has_block_value = entry
+      .value()
+      .map(|value| {
+        value
+          .syntax()
+          .descendants()
+          .any(|descendant| descendant.kind() == SyntaxKind::BLOCK_SEQ || descendant.kind() == SyntaxKind::BLOCK_MAP)
+      })
+      .unwrap_or(false);
+
+    if !has_block_value {
+      return self.remove_node(entry_node);
+    }
+
+    let end = if let Some(next_sibling) = entry_node.next_sibling() {
+      next_sibling.text_range().start()
+    } else {
+      entry_node.parent().map(|parent| parent.text_range().end()).unwrap_or(entry_range.end())
+    };
+
+    let start = if let Some(whitespace_token) = preceding_whitespace_token(entry_node) {
+      let whitespace_text = whitespace_token.text();
+      let whitespace_start = whitespace_token.text_range().start();
+
+      whitespace_text
+        .rfind('\n')
+        .map(|offset| whitespace_start + TextSize::from(offset as u32))
+        .unwrap_or(whitespace_start)
+    } else {
+      entry_range.start()
+    };
+
+    self.apply_edit(TextRange::new(start, end), "")
+  }
+
   fn remove_node(&mut self, node: &SyntaxNode) -> Result<(), YerbaError> {
     let inline_comment = self.find_inline_comment(node);
     let range = removal_range(node);
@@ -445,11 +484,11 @@ pub(crate) fn compute_location(source: &str, start_offset: usize, end_offset: us
   }
 }
 
-pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut Vec<String>) {
+pub fn collect_selectors(value: &yaml_serde::Value, prefix: &str, selectors: &mut Vec<String>) {
   match value {
-    serde_yaml::Value::Mapping(map) => {
+    yaml_serde::Value::Mapping(map) => {
       for (key, child) in map {
-        if let serde_yaml::Value::String(key_string) = key {
+        if let yaml_serde::Value::String(key_string) = key {
           let selector = if prefix.is_empty() {
             key_string.clone()
           } else {
@@ -462,7 +501,7 @@ pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mu
       }
     }
 
-    serde_yaml::Value::Sequence(sequence) => {
+    yaml_serde::Value::Sequence(sequence) => {
       let bracket_prefix = format!("{}[]", prefix);
       selectors.push(bracket_prefix.clone());
 
@@ -475,21 +514,21 @@ pub fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mu
   }
 }
 
-pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
+pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::Value {
   if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
     let map_position = node.descendants().find_map(BlockMap::cast).map(|map| map.syntax().text_range().start());
 
     let sequence_position = sequence.syntax().text_range().start();
 
     if map_position.is_none() || sequence_position <= map_position.unwrap() {
-      let values: Vec<serde_yaml::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+      let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
-      return serde_yaml::Value::Sequence(values);
+      return yaml_serde::Value::Sequence(values);
     }
   }
 
   if let Some(map) = node.descendants().find_map(BlockMap::cast) {
-    let mut mapping = serde_yaml::Mapping::new();
+    let mut mapping = yaml_serde::Mapping::new();
 
     for entry in map.entries() {
       let key = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
@@ -497,18 +536,18 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
       let value = entry
         .value()
         .map(|value_node| node_to_yaml_value(value_node.syntax()))
-        .unwrap_or(serde_yaml::Value::Null);
+        .unwrap_or(yaml_serde::Value::Null);
 
-      mapping.insert(serde_yaml::Value::String(key), value);
+      mapping.insert(yaml_serde::Value::String(key), value);
     }
 
-    return serde_yaml::Value::Mapping(mapping);
+    return yaml_serde::Value::Mapping(mapping);
   }
 
   if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-    let values: Vec<serde_yaml::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+    let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
-    return serde_yaml::Value::Sequence(values);
+    return yaml_serde::Value::Sequence(values);
   }
 
   if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
@@ -521,35 +560,46 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::Value {
 
     let text = dedent_block_scalar(&text);
 
-    return serde_yaml::Value::String(text);
+    return yaml_serde::Value::String(text);
+  }
+
+  if node
+    .descendants()
+    .any(|descendant| descendant.kind() == SyntaxKind::FLOW_SEQ || descendant.kind() == SyntaxKind::FLOW_MAP)
+  {
+    let text = node.text().to_string().trim().to_string();
+
+    if let Ok(value) = yaml_serde::from_str(&text) {
+      return value;
+    }
   }
 
   if let Some(scalar) = extract_scalar(node) {
     use crate::syntax::{detect_yaml_type, is_yaml_truthy, YerbaValueType};
 
     return match detect_yaml_type(&scalar) {
-      YerbaValueType::Null => serde_yaml::Value::Null,
-      YerbaValueType::Boolean => serde_yaml::Value::Bool(is_yaml_truthy(&scalar.text)),
+      YerbaValueType::Null => yaml_serde::Value::Null,
+      YerbaValueType::Boolean => yaml_serde::Value::Bool(is_yaml_truthy(&scalar.text)),
 
       YerbaValueType::Integer => scalar
         .text
         .parse::<i64>()
-        .map(|n| serde_yaml::Value::Number(serde_yaml::Number::from(n)))
-        .unwrap_or(serde_yaml::Value::String(scalar.text)),
+        .map(|n| yaml_serde::Value::Number(yaml_serde::Number::from(n)))
+        .unwrap_or(yaml_serde::Value::String(scalar.text)),
 
       YerbaValueType::Float => scalar
         .text
         .parse::<f64>()
-        .map(|n| serde_yaml::Value::Number(serde_yaml::Number::from(n)))
-        .unwrap_or(serde_yaml::Value::String(scalar.text)),
+        .map(|n| yaml_serde::Value::Number(yaml_serde::Number::from(n)))
+        .unwrap_or(yaml_serde::Value::String(scalar.text)),
 
-      YerbaValueType::String => serde_yaml::Value::String(scalar.text),
+      YerbaValueType::String => yaml_serde::Value::String(scalar.text),
     };
   }
 
   let text = node.text().to_string();
 
-  serde_yaml::from_str(&text).unwrap_or(serde_yaml::Value::String(text))
+  yaml_serde::from_str(&text).unwrap_or(yaml_serde::Value::String(text))
 }
 
 pub(crate) fn parse_condition(condition: &str) -> Option<(String, &str, String)> {

data/rust/src/document/sort.rs

@@ -577,10 +577,10 @@ impl Document {
     };
 
     let labels: Vec<String> = match self.get_value(&items_selector) {
-      Some(serde_yaml::Value::Sequence(sequence)) => sequence
+      Some(yaml_serde::Value::Sequence(sequence)) => sequence
         .iter()
         .map(|value| match value {
-          serde_yaml::Value::String(string) => string.clone(),
+          yaml_serde::Value::String(string) => string.clone(),
           _ => String::new(),
         })
         .collect(),