yerba 0.7.5-arm-linux-gnu → 0.8.0-arm-linux-gnu

data/rust/src/document/condition.rs

@@ -1,29 +1,83 @@
 use super::*;
 
+const CONDITION_OPERATORS: &str = "expected `<selector> <operator> <value>`, where operator is one of ==, !=, contains, not_contains";
+
+pub fn validate_condition(condition: &str) -> Result<(), YerbaError> {
+  let trimmed = condition.trim();
+
+  if trimmed.is_empty() {
+    return Err(YerbaError::InvalidCondition(condition.to_string(), "condition is empty".to_string()));
+  }
+
+  let Some((left, _operator, _right)) = parse_condition(trimmed) else {
+    return Err(YerbaError::InvalidCondition(condition.to_string(), CONDITION_OPERATORS.to_string()));
+  };
+
+  if crate::selector::Selector::parse(&left).is_empty() {
+    return Err(YerbaError::InvalidCondition(
+      condition.to_string(),
+      "condition is missing a selector on the left of the operator".to_string(),
+    ));
+  }
+
+  Ok(())
+}
+
+pub fn validate_item_condition(condition: &str) -> Result<(), YerbaError> {
+  validate_condition(condition)?;
+
+  let trimmed = condition.trim();
+
+  let Some((left, _operator, _right)) = parse_condition(trimmed) else {
+    return Ok(());
+  };
+
+  if !crate::selector::Selector::parse(&left).is_relative() {
+    return Err(YerbaError::InvalidCondition(
+      condition.to_string(),
+      format!(
+        "selector \"{}\" is absolute, but this condition is tested against each item, so it must be relative and start with `.` — did you mean \".{}\"?",
+        left.trim(),
+        left.trim()
+      ),
+    ));
+  }
+
+  Ok(())
+}
+
 impl Document {
-  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<yaml_serde::Value> {
-    self
-      .navigate_all_compact(dot_path)
-      .iter()
-      .filter(|node| self.evaluate_condition_on_node(node, condition))
-      .map(node_to_yaml_value)
-      .collect()
+  pub fn filter(&self, dot_path: &str, condition: &str) -> Result<Vec<yaml_serde::Value>, YerbaError> {
+    validate_item_condition(condition)?;
+
+    Ok(
+      self
+        .navigate_all_compact(dot_path)
+        .iter()
+        .filter(|node| self.evaluate_condition_on_node(node, condition))
+        .map(node_to_yaml_value)
+        .collect(),
+    )
   }
 
-  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(yaml_serde::Value, String, usize)> {
+  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Result<Vec<(yaml_serde::Value, String, usize)>, YerbaError> {
+    validate_item_condition(condition)?;
+
     let source = self.source_text();
 
-    self
-      .navigate_all_compact(dot_path)
-      .iter()
-      .filter(|node| self.evaluate_condition_on_node(node, condition))
-      .map(|node| {
-        let offset: usize = node.text_range().start().into();
-        let line = line_at(&source, offset);
-
-        (node_to_yaml_value(node), super::get::node_selector(node), line)
-      })
-      .collect()
+    Ok(
+      self
+        .navigate_all_compact(dot_path)
+        .iter()
+        .filter(|node| self.evaluate_condition_on_node(node, condition))
+        .map(|node| {
+          let offset: usize = node.text_range().start().into();
+          let line = line_at(&source, offset);
+
+          (node_to_yaml_value(node), super::get::node_selector(node), line)
+        })
+        .collect(),
+    )
   }
 
   pub(super) fn evaluate_condition_on_node(&self, node: &SyntaxNode, condition: &str) -> bool {
@@ -84,31 +138,32 @@ impl Document {
     }
   }
 
-  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> bool {
+  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> Result<bool, YerbaError> {
+    if parent_path.is_empty() {
+      validate_condition(condition)?;
+    } else {
+      validate_item_condition(condition)?;
+    }
+
     let condition = condition.trim();
 
     let (left, operator, right) = match parse_condition(condition) {
       Some(parts) => parts,
-      None => return false,
+      None => return Ok(false),
     };
 
     let path = crate::selector::Selector::parse(&left);
+    let path_string = path.to_selector_string();
 
-    let full_path = if path.is_relative() {
-      let path_string = path.to_selector_string();
-
-      if parent_path.is_empty() {
-        path_string
-      } else {
-        format!("{}.{}", parent_path, path_string)
-      }
+    let full_path = if parent_path.is_empty() {
+      path_string
     } else {
-      path.to_selector_string()
+      format!("{}.{}", parent_path, path_string)
     };
 
     let has_brackets = crate::selector::Selector::parse(&full_path).has_brackets();
 
-    match operator {
+    let result = match operator {
       "==" => {
         if has_brackets {
           self.get_all(&full_path).iter().any(|value| value == &right)
@@ -150,6 +205,8 @@ impl Document {
         }
       }
       _ => false,
-    }
+    };
+
+    Ok(result)
   }
 }

data/rust/src/document/delete.rs

@@ -31,6 +31,7 @@ impl Document {
 
   pub fn delete(&mut self, dot_path: &str) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
+    self.refuse_flow_target(dot_path)?;
 
     let selector = crate::selector::Selector::parse(dot_path);
     let segments = selector.segments();
@@ -88,13 +89,17 @@ impl Document {
       }
 
       crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_path, *index),
-      crate::selector::SelectorSegment::AllItems => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
+      crate::selector::SelectorSegment::AllItems | crate::selector::SelectorSegment::AllKeys => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
     }
   }
 
   pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
 
+    if find_flow_sequence(&current_node).is_some() {
+      return Err(YerbaError::FlowCollectionNotWritable(dot_path.to_string()));
+    }
+
     let sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
 
     let target_entry = sequence

data/rust/src/document/get.rs

@@ -1,5 +1,26 @@
 use super::*;
 
+fn key_of(node: &SyntaxNode, source: &str) -> (Option<String>, Location) {
+  node
+    .parent()
+    .and_then(|parent| {
+      use yaml_parser::ast::{BlockMapEntry, FlowMapEntry};
+
+      let key_node = match BlockMapEntry::cast(parent.clone()) {
+        Some(entry) => entry.key().map(|key| key.syntax().clone()),
+        None => FlowMapEntry::cast(parent).and_then(|entry| entry.key().map(|key| key.syntax().clone())),
+      }?;
+
+      let key_text = extract_scalar_text(&key_node)?;
+      let key_range = key_node.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()))
+}
+
 impl Document {
   pub fn is_valid_selector(&self, dot_path: &str) -> bool {
     if dot_path.is_empty() {
@@ -12,6 +33,10 @@ impl Document {
       return true;
     }
 
+    if crate::selector::Selector::parse(dot_path).has_wildcard() && !self.navigate_all_compact(dot_path).is_empty() {
+      return true;
+    }
+
     let wildcard_version = dot_path.replace(|c: char| c.is_ascii_digit(), "").replace("[.", "[");
 
     let mut normalized = String::new();
@@ -82,6 +107,49 @@ impl Document {
     self.navigate_all_compact(dot_path).iter().map(node_selector).collect()
   }
 
+  pub fn keys_at(&self, dot_path: &str) -> Vec<String> {
+    let node = if dot_path.is_empty() {
+      self.root.clone()
+    } else {
+      match self.navigate_all_compact(dot_path).into_iter().next() {
+        Some(node) => node,
+        None => return Vec::new(),
+      }
+    };
+
+    let collection = node.descendants().find(|descendant| {
+      matches!(
+        descendant.kind(),
+        SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ
+      )
+    });
+
+    let Some(collection) = collection else {
+      return Vec::new();
+    };
+
+    if let Some(map) = BlockMap::cast(collection.clone()) {
+      return map
+        .entries()
+        .filter_map(|entry| entry.key().and_then(|key| extract_scalar_text(key.syntax())))
+        .collect();
+    }
+
+    if let Some(map) = yaml_parser::ast::FlowMap::cast(collection) {
+      return map
+        .entries()
+        .map(|entries| {
+          entries
+            .entries()
+            .filter_map(|entry| entry.key().and_then(|key| extract_scalar_text(key.syntax())))
+            .collect()
+        })
+        .unwrap_or_default();
+    }
+
+    Vec::new()
+  }
+
   pub fn get_all_located(&self, dot_path: &str) -> Vec<LocatedNode> {
     let source = self.source_text();
     let file_path = self.path.as_ref().map(|p| p.to_string_lossy().to_string());
@@ -116,6 +184,8 @@ impl Document {
           }
         };
 
+        let (key_name, key_location) = key_of(node, &source);
+
         LocatedNode {
           node_type: node_type.to_string(),
           text,
@@ -124,6 +194,8 @@ impl Document {
           selector,
           line,
           location,
+          key_name,
+          key_location,
         }
       })
       .collect()
@@ -214,23 +286,7 @@ impl Document {
         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()));
+        let (key_name, key_location) = key_of(&node, source);
 
         (location, key_name, key_location)
       }
@@ -238,15 +294,15 @@ impl Document {
     }
   }
 
-  pub fn find_items(&self, dot_path: &str, condition: Option<&str>, select: Option<&str>) -> Vec<serde_json::Value> {
+  pub fn find_items(&self, dot_path: &str, condition: Option<&str>, select: Option<&str>) -> Result<Vec<serde_json::Value>, YerbaError> {
     let values = match condition {
-      Some(cond) => self.filter(dot_path, cond),
+      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
+    let items = values
       .iter()
       .map(|value| match &select_fields {
         Some(fields) => {
@@ -262,7 +318,9 @@ impl Document {
         }
         None => crate::json::yaml_to_json(value),
       })
-      .collect()
+      .collect();
+
+    Ok(items)
   }
 
   pub fn get_value(&self, dot_path: &str) -> Option<yaml_serde::Value> {
@@ -337,7 +395,7 @@ impl Document {
   }
 
   pub fn exists(&self, dot_path: &str) -> bool {
-    if dot_path.contains('[') {
+    if crate::selector::Selector::parse(dot_path).has_wildcard() {
       if !self.navigate_all_compact(dot_path).is_empty() {
         return true;
       }
@@ -455,11 +513,13 @@ pub(crate) fn node_selector(node: &SyntaxNode) -> String {
   let mut parts: Vec<String> = Vec::new();
   let mut current = node.clone();
 
-  if current.kind() == SyntaxKind::BLOCK_SEQ_ENTRY {
+  if matches!(current.kind(), SyntaxKind::BLOCK_SEQ_ENTRY | SyntaxKind::FLOW_SEQ_ENTRY) {
     if let Some(parent) = current.parent() {
+      let kind = current.kind();
+
       let index = parent
         .children()
-        .filter(|child| child.kind() == SyntaxKind::BLOCK_SEQ_ENTRY)
+        .filter(|child| child.kind() == kind)
         .position(|child| child == current)
         .unwrap_or(0);
 
@@ -474,11 +534,11 @@ pub(crate) fn node_selector(node: &SyntaxNode) -> String {
     };
 
     match parent.kind() {
-      SyntaxKind::BLOCK_SEQ_ENTRY => {
+      SyntaxKind::BLOCK_SEQ_ENTRY | SyntaxKind::FLOW_SEQ_ENTRY => {
         if let Some(grandparent) = parent.parent() {
           let index = grandparent
             .children()
-            .filter(|child| child.kind() == SyntaxKind::BLOCK_SEQ_ENTRY)
+            .filter(|child| child.kind() == parent.kind())
             .position(|child| child == parent)
             .unwrap_or(0);
 
@@ -494,6 +554,14 @@ pub(crate) fn node_selector(node: &SyntaxNode) -> String {
         }
       }
 
+      SyntaxKind::FLOW_MAP_ENTRY => {
+        if let Some(key_node) = parent.children().find(|child| child.kind() == SyntaxKind::FLOW_MAP_KEY) {
+          if let Some(key_text) = extract_scalar_text(&key_node) {
+            parts.push(key_text);
+          }
+        }
+      }
+
       _ => {}
     }
 

data/rust/src/document/insert.rs

@@ -90,6 +90,28 @@ impl Document {
 
   pub fn insert_into(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
     Self::validate_path(dot_path)?;
+    self.refuse_flow_target(dot_path)?;
+
+    if let Some((parent_path, _)) = dot_path.rsplit_once('.') {
+      if let Ok(parent) = self.navigate(parent_path) {
+        let occupied_flow = find_flow_map(&parent).map(|map| !flow_map_entries(&map).is_empty()).unwrap_or(false)
+          || find_flow_sequence(&parent)
+            .map(|sequence| !flow_sequence_entries(&sequence).is_empty())
+            .unwrap_or(false);
+
+        if occupied_flow {
+          return Err(YerbaError::FlowCollectionNotWritable(dot_path.to_string()));
+        }
+      }
+    }
+
+    if crate::selector::Selector::parse(dot_path)
+      .segments()
+      .iter()
+      .any(|segment| matches!(segment, crate::selector::SelectorSegment::AllKeys))
+    {
+      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+    }
 
     if let Ok(current_node) = self.navigate(dot_path) {
       if find_block_sequence(&current_node).is_some()

data/rust/src/document/mod.rs

@@ -1,4 +1,5 @@
 mod condition;
+pub use condition::{validate_condition, validate_item_condition};
 mod delete;
 mod get;
 mod insert;
@@ -20,6 +21,8 @@ pub struct LocatedNode {
   pub selector: String,
   pub line: usize,
   pub location: Location,
+  pub key_name: Option<String>,
+  pub key_location: Location,
 }
 
 use std::fs;
@@ -35,9 +38,10 @@ use crate::error::YerbaError;
 use crate::QuoteStyle;
 
 use crate::syntax::{
-  column_at, dedent_block_scalar, extract_scalar, extract_scalar_text, find_block_map, find_block_sequence, find_entry_by_key, find_scalar_token,
-  first_collection, format_scalar_value, is_map_key, is_yaml_non_string, line_at, line_start_at, preceding_whitespace_indent, preceding_whitespace_token,
-  raw_scalar_value, removal_range, FirstCollection, ScalarValue,
+  column_at, dedent_block_scalar, extract_scalar, extract_scalar_text, find_block_map, find_block_sequence, find_entry_by_key, find_flow_entry_by_key,
+  find_flow_map, find_flow_sequence, find_scalar_token, first_collection, flow_map_entries, flow_sequence_entries, format_scalar_value, in_flow_collection,
+  is_map_key, is_yaml_non_string, line_at, line_start_at, preceding_whitespace_indent, preceding_whitespace_token, raw_scalar_value, removal_range,
+  FirstCollection, ScalarValue,
 };
 
 #[derive(Debug, Clone)]
@@ -190,6 +194,14 @@ impl Document {
     self.navigate_all(dot_path).into_iter().flatten().collect()
   }
 
+  pub(crate) fn refuse_flow_target(&self, dot_path: &str) -> Result<(), YerbaError> {
+    if self.navigate_all_compact(dot_path).iter().any(in_flow_collection) {
+      return Err(YerbaError::FlowCollectionNotWritable(dot_path.to_string()));
+    }
+
+    Ok(())
+  }
+
   pub fn navigate_all(&self, dot_path: &str) -> Vec<Option<SyntaxNode>> {
     if Document::validate_path(dot_path).is_err() {
       return Vec::new();
@@ -220,7 +232,7 @@ impl Document {
     let segments = parsed.segments();
 
     for (i, segment) in segments.iter().enumerate() {
-      let is_wildcard = matches!(segment, crate::selector::SelectorSegment::AllItems);
+      let is_wildcard = matches!(segment, crate::selector::SelectorSegment::AllItems | crate::selector::SelectorSegment::AllKeys);
       let has_remaining = i + 1 < segments.len();
       let mut next_nodes: Vec<Option<SyntaxNode>> = Vec::new();
 
@@ -335,22 +347,28 @@ impl Document {
       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 source = self.source_text();
 
-    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();
+    let (start, end) = match preceding_whitespace_token(entry_node) {
+      Some(whitespace_token) => {
+        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()
+        let start = whitespace_text
+          .rfind('\n')
+          .map(|offset| whitespace_start + TextSize::from(offset as u32))
+          .unwrap_or(whitespace_start);
+
+        (start, entry_range.end())
+      }
+
+      None => {
+        let entry_end: usize = entry_range.end().into();
+        let line_start = line_start_at(&source, entry_range.start().into());
+        let after_entry = source[entry_end..].find('\n').map(|offset| entry_end + offset + 1).unwrap_or(entry_end);
+
+        (TextSize::from(line_start as u32), TextSize::from(after_entry as u32))
+      }
     };
 
     self.apply_edit(TextRange::new(start, end), "")
@@ -673,6 +691,8 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     SelectorSegment::AllItems => {
       if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().map(|entry| entry.syntax().clone()).collect()
+      } else if let Some(sequence) = find_flow_sequence(node) {
+        flow_sequence_entries(&sequence)
       } else {
         Vec::new()
       }
@@ -681,6 +701,25 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     SelectorSegment::Index(index) => {
       if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().nth(*index).map(|entry| vec![entry.syntax().clone()]).unwrap_or_default()
+      } else if let Some(sequence) = find_flow_sequence(node) {
+        flow_sequence_entries(&sequence)
+          .into_iter()
+          .nth(*index)
+          .map(|entry| vec![entry])
+          .unwrap_or_default()
+      } else {
+        Vec::new()
+      }
+    }
+
+    SelectorSegment::AllKeys => {
+      if let Some(map) = find_block_map(node) {
+        map.entries().filter_map(|entry| entry.value().map(|value| value.syntax().clone())).collect()
+      } else if let Some(map) = find_flow_map(node) {
+        flow_map_entries(&map)
+          .into_iter()
+          .filter_map(|entry| entry.value().map(|value| value.syntax().clone()))
+          .collect()
       } else {
         Vec::new()
       }
@@ -693,6 +732,16 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
             return vec![value.syntax().clone()];
           }
         }
+
+        return Vec::new();
+      }
+
+      if let Some(map) = find_flow_map(node) {
+        if let Some(entry) = find_flow_entry_by_key(&map, key) {
+          if let Some(value) = entry.value() {
+            return vec![value.syntax().clone()];
+          }
+        }
       }
 
       Vec::new()

data/rust/src/document/set.rs

@@ -1,5 +1,70 @@
 use super::*;
 
+fn holds_collection(node: &SyntaxNode) -> bool {
+  node.descendants().any(|descendant| {
+    matches!(
+      descendant.kind(),
+      SyntaxKind::BLOCK_MAP | SyntaxKind::BLOCK_SEQ | SyntaxKind::FLOW_MAP | SyntaxKind::FLOW_SEQ
+    )
+  })
+}
+
+struct ValueSpan {
+  range: TextRange,
+  separated: bool,
+  comment: Option<String>,
+}
+
+fn value_span(node: &SyntaxNode) -> Option<ValueSpan> {
+  let (container, separator_kind) = match node.kind() {
+    SyntaxKind::BLOCK_MAP_VALUE | SyntaxKind::FLOW_MAP_VALUE => (node.parent()?, SyntaxKind::COLON),
+    SyntaxKind::BLOCK_SEQ_ENTRY => (node.clone(), SyntaxKind::MINUS),
+
+    SyntaxKind::FLOW_SEQ_ENTRY => {
+      return Some(ValueSpan {
+        range: node.text_range(),
+        separated: false,
+        comment: None,
+      })
+    }
+
+    _ => return None,
+  };
+
+  let mut elements = container
+    .children_with_tokens()
+    .skip_while(|element| element.as_token().map(|token| token.kind() != separator_kind).unwrap_or(true));
+
+  let separator = elements.next()?.into_token()?;
+  let mut comment = None;
+
+  for element in elements {
+    match element.into_token() {
+      Some(token) if token.kind() == SyntaxKind::COMMENT => comment = Some(token.text().trim_end().to_string()),
+      Some(token) if token.kind() == SyntaxKind::WHITESPACE && token.text().contains('\n') => break,
+      Some(_) => {}
+      None => break,
+    }
+  }
+
+  Some(ValueSpan {
+    range: TextRange::new(separator.text_range().end(), node.text_range().end()),
+    separated: true,
+    comment,
+  })
+}
+
+fn replacement_text(span: &ValueSpan, value: &str) -> String {
+  let mut text = if span.separated { format!(" {}", value) } else { value.to_string() };
+
+  if let Some(comment) = &span.comment {
+    text.push(' ');
+    text.push_str(comment);
+  }
+
+  text
+}
+
 impl Document {
   pub fn set(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
@@ -11,6 +76,12 @@ impl Document {
       return self.apply_edit(block_scalar.text_range(), &new_text);
     }
 
+    if holds_collection(&current_node) {
+      let span = value_span(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+      return self.apply_edit(span.range, &replacement_text(&span, value));
+    }
+
     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());
@@ -31,6 +102,10 @@ impl Document {
     for node in nodes {
       if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
         edits.push((block_scalar.text_range(), Self::block_scalar_replacement(&source, &block_scalar, value)));
+      } else if holds_collection(&node) {
+        if let Some(span) = value_span(&node) {
+          edits.push((span.range, replacement_text(&span, value)));
+        }
       } else if let Some(scalar_token) = find_scalar_token(&node) {
         edits.push((scalar_token.text_range(), format_scalar_value(value, scalar_token.kind())));
       }
@@ -68,6 +143,12 @@ impl Document {
       return self.apply_edit(range, value);
     }
 
+    if holds_collection(&current_node) {
+      let span = value_span(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+
+      return self.apply_edit(span.range, &replacement_text(&span, value));
+    }
+
     let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     self.replace_token(&scalar_token, value)