yerba 0.1.1 → 0.2.0

data/rust/src/document.rs

@@ -11,18 +11,11 @@ use crate::error::YerbaError;
 use crate::QuoteStyle;
 
 use crate::syntax::{
-  extract_scalar_text, find_entry_by_key, find_scalar_token, format_scalar_value, is_map_key, is_yaml_non_string,
-  preceding_whitespace_indent, preceding_whitespace_token, removal_range, unescape_double_quoted,
-  unescape_single_quoted,
+  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, preceding_whitespace_token, removal_range, unescape_double_quoted,
+  unescape_single_quoted, ScalarValue,
 };
 
-#[derive(Debug)]
-pub struct FindResult {
-  pub text: String,
-  pub line: usize,
-  pub end_line: usize,
-}
-
 #[derive(Debug, Clone)]
 pub struct SortField {
   pub path: String,
@@ -66,6 +59,8 @@ pub enum InsertPosition {
   Last,
   Before(String),
   After(String),
+  BeforeCondition(String),
+  AfterCondition(String),
   FromSortOrder(Vec<String>),
 }
 
@@ -98,56 +93,79 @@ impl Document {
       return self.get_all(dot_path).into_iter().next();
     }
 
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys).ok()?;
+    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_to_many(dot_path)
+      .navigate_all(dot_path)
       .iter()
       .filter_map(extract_scalar_text)
       .collect()
   }
 
-  pub fn find_items(&self, dot_path: &str, condition: &str) -> Vec<FindResult> {
-    let source = self.root.text().to_string();
-    let nodes = self.navigate_to_many(dot_path);
+  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)
+  }
 
-    nodes
+  pub fn get_all_typed(&self, dot_path: &str) -> Vec<ScalarValue> {
+    self
+      .navigate_all(dot_path)
       .iter()
-      .filter(|node| self.evaluate_condition_on_node(node, condition))
-      .map(|node| {
-        let start_offset: usize = node.text_range().start().into();
-        let end_offset: usize = node.text_range().end().into();
-
-        FindResult {
-          text: node.text().to_string(),
-          line: byte_offset_to_line(&source, start_offset),
-          end_line: byte_offset_to_line(&source, end_offset),
-        }
+      .filter(|node| {
+        !node
+          .descendants()
+          .any(|child| child.kind() == SyntaxKind::BLOCK_MAP || child.kind() == SyntaxKind::BLOCK_SEQ)
       })
+      .filter_map(extract_scalar)
       .collect()
   }
 
-  pub fn find_all(&self, dot_path: &str) -> Vec<FindResult> {
-    let source = self.root.text().to_string();
+  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 filter(&self, dot_path: &str, condition: &str) -> Vec<serde_yaml::Value> {
     self
-      .navigate_to_many(dot_path)
+      .navigate_all(dot_path)
       .iter()
-      .map(|node| {
-        let start_offset: usize = node.text_range().start().into();
-        let end_offset: usize = node.text_range().end().into();
-
-        FindResult {
-          text: node.text().to_string(),
-          line: byte_offset_to_line(&source, start_offset),
-          end_line: byte_offset_to_line(&source, end_offset),
-        }
-      })
+      .filter(|node| self.evaluate_condition_on_node(node, condition))
+      .map(node_to_yaml_value)
       .collect()
   }
 
@@ -159,9 +177,13 @@ impl Document {
       None => return false,
     };
 
-    let left_path = left.strip_prefix('.').unwrap_or(&left);
-    let target_nodes = navigate_from_node(node, left_path);
+    let path = crate::selector::Selector::parse(&left);
 
+    if !path.is_relative() {
+      return false;
+    }
+
+    let target_nodes = navigate_from_node(node, &path.to_selector_string());
     let values: Vec<String> = target_nodes.iter().filter_map(extract_scalar_text).collect();
 
     match operator {
@@ -207,7 +229,7 @@ impl Document {
 
   pub fn exists(&self, dot_path: &str) -> bool {
     if dot_path.contains('[') {
-      return !self.navigate_to_many(dot_path).is_empty();
+      return !self.navigate_all(dot_path).is_empty();
     }
 
     self.get(dot_path).is_some()
@@ -221,17 +243,21 @@ impl Document {
       None => return false,
     };
 
-    let full_path = if let Some(relative_key) = left.strip_prefix('.') {
+    let path = crate::selector::Selector::parse(&left);
+
+    let full_path = if path.is_relative() {
+      let path_string = path.to_selector_string();
+
       if parent_path.is_empty() {
-        relative_key.to_string()
+        path_string
       } else {
-        format!("{}.{}", parent_path, relative_key)
+        format!("{}.{}", parent_path, path_string)
       }
     } else {
-      left.to_string()
+      path.to_selector_string()
     };
 
-    let has_brackets = full_path.contains('[');
+    let has_brackets = crate::selector::Selector::parse(&full_path).has_brackets();
 
     match operator {
       "==" => {
@@ -291,8 +317,7 @@ impl Document {
   }
 
   pub fn get_sequence_values(&self, dot_path: &str) -> Vec<String> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = match self.navigate_to_path(&keys) {
+    let current_node = match self.navigate(dot_path) {
       Ok(node) => node,
       Err(_) => return Vec::new(),
     };
@@ -309,8 +334,24 @@ impl Document {
   }
 
   pub fn set(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    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::PathNotFound(dot_path.to_string()))?;
@@ -320,14 +361,64 @@ impl Document {
     self.replace_token(&scalar_token, &new_text)
   }
 
+  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::PathNotFound(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::PathNotFound(dot_path.to_string()))?;
+
+    self.replace_token(&scalar_token, value)
+  }
+
   pub fn append(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
     self.insert_into(dot_path, value, InsertPosition::Last)
   }
 
   pub fn insert_into(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
+    Self::validate_path(dot_path)?;
 
-    if let Ok(current_node) = self.navigate_to_path(&keys) {
+    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);
       }
@@ -339,8 +430,7 @@ impl Document {
   }
 
   fn insert_sequence_item(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let sequence = current_node
       .descendants()
@@ -359,7 +449,37 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    let new_item = format!("- {}", value);
+    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 => {
@@ -421,6 +541,30 @@ impl Document {
         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::PathNotFound(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::PathNotFound(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);
@@ -437,8 +581,7 @@ impl Document {
     value: &str,
     position: InsertPosition,
   ) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let map = current_node
       .descendants()
@@ -513,6 +656,10 @@ impl Document {
         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);
 
@@ -542,6 +689,9 @@ impl Document {
   }
 
   pub fn rename(&mut self, source_path: &str, destination_path: &str) -> Result<(), YerbaError> {
+    Self::validate_path(source_path)?;
+    Self::validate_path(destination_path)?;
+
     let source_parent = source_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
     let destination_parent = destination_path
@@ -555,9 +705,8 @@ impl Document {
       .unwrap_or(destination_path);
 
     if source_parent == destination_parent {
-      let keys: Vec<&str> = source_path.split('.').collect();
-      let parent_node = self.navigate_to_path(&keys[..keys.len() - 1])?;
-      let source_key = keys.last().unwrap();
+      let (parent_path, source_key) = source_path.rsplit_once('.').unwrap_or(("", source_path));
+      let parent_node = self.navigate(parent_path)?;
 
       let map = parent_node
         .descendants()
@@ -588,9 +737,10 @@ impl Document {
   }
 
   pub fn delete(&mut self, dot_path: &str) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let parent_node = self.navigate_to_path(&keys[..keys.len() - 1])?;
-    let last_key = keys.last().unwrap();
+    Self::validate_path(dot_path)?;
+
+    let (parent_path, last_key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
+    let parent_node = self.navigate(parent_path)?;
 
     let map = parent_node
       .descendants()
@@ -603,8 +753,7 @@ impl Document {
   }
 
   pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let sequence = current_node
       .descendants()
@@ -625,13 +774,31 @@ impl Document {
     self.remove_node(target_entry.syntax())
   }
 
+  pub fn remove_at(&mut self, dot_path: &str, index: usize) -> Result<(), YerbaError> {
+    Self::validate_path(dot_path)?;
+
+    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 index >= entries.len() {
+      return Err(YerbaError::IndexOutOfBounds(index, entries.len()));
+    }
+
+    self.remove_node(entries[index].syntax())
+  }
+
   pub fn move_item(&mut self, dot_path: &str, from: usize, to: usize) -> Result<(), YerbaError> {
     if from == to {
       return Ok(());
     }
 
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let sequence = current_node
       .descendants()
@@ -640,14 +807,7 @@ impl Document {
 
     let entries: Vec<_> = sequence.entries().collect();
 
-    self.reorder_entries(
-      &entries,
-      from,
-      to,
-      |entry| entry.syntax().text().to_string(),
-      |entry| preceding_whitespace_indent(entry.syntax()),
-      sequence.syntax().text_range(),
-    )
+    self.reorder_entries(sequence.syntax(), &entries, from, to)
   }
 
   pub fn move_key(&mut self, dot_path: &str, from: usize, to: usize) -> Result<(), YerbaError> {
@@ -655,8 +815,7 @@ impl Document {
       return Ok(());
     }
 
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let map = current_node
       .descendants()
@@ -665,19 +824,11 @@ impl Document {
 
     let entries: Vec<_> = map.entries().collect();
 
-    self.reorder_entries(
-      &entries,
-      from,
-      to,
-      |entry| entry.syntax().text().to_string(),
-      |entry| preceding_whitespace_indent(entry.syntax()),
-      map.syntax().text_range(),
-    )
+    self.reorder_entries(map.syntax(), &entries, from, to)
   }
 
   pub fn resolve_key_index(&self, dot_path: &str, reference: &str) -> Result<usize, YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let map = current_node
       .descendants()
@@ -709,8 +860,7 @@ impl Document {
   }
 
   pub fn resolve_sequence_index(&self, dot_path: &str, reference: &str) -> Result<usize, YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let sequence = current_node
       .descendants()
@@ -727,6 +877,15 @@ impl Document {
       return Ok(index);
     }
 
+    if crate::selector::Selector::parse(reference).is_relative() {
+      return sequence
+        .entries()
+        .enumerate()
+        .find(|(_index, entry)| self.evaluate_condition_on_node(entry.syntax(), reference))
+        .map(|(index, _entry)| index)
+        .ok_or_else(|| YerbaError::PathNotFound(format!("{} condition '{}'", dot_path, reference)));
+    }
+
     sequence
       .entries()
       .enumerate()
@@ -752,8 +911,7 @@ impl Document {
       return self.validate_each_sort_keys(seq_path, key_order);
     }
 
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let map = current_node
       .descendants()
@@ -784,8 +942,7 @@ impl Document {
       return self.sort_each_keys(seq_path, key_order);
     }
 
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let map = current_node
       .descendants()
@@ -798,21 +955,23 @@ impl Document {
       return Ok(());
     }
 
-    let entry_data: Vec<(String, String)> = entries
+    let (groups, range) = collect_groups_with_range(map.syntax());
+
+    let mut keyed: Vec<(String, EntryGroup)> = entries
       .iter()
-      .map(|entry| {
+      .zip(groups)
+      .map(|(entry, group)| {
         let key_name = entry
           .key()
           .and_then(|key_node| extract_scalar_text(key_node.syntax()))
           .unwrap_or_default();
-        let text = entry.syntax().text().to_string();
-        (key_name, text)
+        (key_name, group)
       })
       .collect();
 
-    let mut sorted = entry_data.clone();
+    let original_keys: Vec<String> = keyed.iter().map(|(key, _)| key.clone()).collect();
 
-    sorted.sort_by(|(key_a, _), (key_b, _)| {
+    keyed.sort_by(|(key_a, _), (key_b, _)| {
       let position_a = key_order.iter().position(|&key| key == key_a);
       let position_b = key_order.iter().position(|&key| key == key_b);
 
@@ -821,16 +980,17 @@ impl Document {
         (Some(_), None) => std::cmp::Ordering::Less,
         (None, Some(_)) => std::cmp::Ordering::Greater,
         (None, None) => {
-          let original_a = entry_data.iter().position(|(key, _)| key == key_a).unwrap();
-          let original_b = entry_data.iter().position(|(key, _)| key == key_b).unwrap();
+          let original_a = original_keys.iter().position(|key| key == key_a).unwrap();
+          let original_b = original_keys.iter().position(|key| key == key_b).unwrap();
           original_a.cmp(&original_b)
         }
       }
     });
 
-    if sorted.iter().map(|(key, _)| key).collect::<Vec<_>>()
-      == entry_data.iter().map(|(key, _)| key).collect::<Vec<_>>()
-    {
+    let sorted_keys: Vec<&str> = keyed.iter().map(|(key, _)| key.as_str()).collect();
+    let orig_refs: Vec<&str> = original_keys.iter().map(|key| key.as_str()).collect();
+
+    if sorted_keys == orig_refs {
       return Ok(());
     }
 
@@ -839,15 +999,14 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    let map_text = rebuild_entries(sorted.iter().map(|(_key, text)| text.as_str()), &indent);
-    let map_range = map.syntax().text_range();
+    let sorted_groups: Vec<EntryGroup> = keyed.into_iter().map(|(_, group)| group).collect();
+    let map_text = rebuild_from_groups(&sorted_groups, &indent);
 
-    self.apply_edit(map_range, &map_text)
+    self.apply_edit(range, &map_text)
   }
 
   pub fn sort_each_keys(&mut self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
       Some(sequence) => sequence,
@@ -870,21 +1029,23 @@ impl Document {
         continue;
       }
 
-      let entry_data: Vec<(String, String)> = entries
+      let (groups, group_range) = collect_groups_with_range(map.syntax());
+
+      let mut keyed: Vec<(String, EntryGroup)> = entries
         .iter()
-        .map(|entry| {
+        .zip(groups)
+        .map(|(entry, group)| {
           let key_name = entry
             .key()
             .and_then(|key_node| extract_scalar_text(key_node.syntax()))
             .unwrap_or_default();
-          let text = entry.syntax().text().to_string();
-          (key_name, text)
+          (key_name, group)
         })
         .collect();
 
-      let mut sorted = entry_data.clone();
+      let original_keys: Vec<String> = keyed.iter().map(|(key, _)| key.clone()).collect();
 
-      sorted.sort_by(|(key_a, _), (key_b, _)| {
+      keyed.sort_by(|(key_a, _), (key_b, _)| {
         let position_a = key_order.iter().position(|&key| key == key_a);
         let position_b = key_order.iter().position(|&key| key == key_b);
 
@@ -894,17 +1055,18 @@ impl Document {
           (None, Some(_)) => std::cmp::Ordering::Greater,
 
           (None, None) => {
-            let original_a = entry_data.iter().position(|(key, _)| key == key_a).unwrap();
-            let original_b = entry_data.iter().position(|(key, _)| key == key_b).unwrap();
+            let original_a = original_keys.iter().position(|key| key == key_a).unwrap();
+            let original_b = original_keys.iter().position(|key| key == key_b).unwrap();
 
             original_a.cmp(&original_b)
           }
         }
       });
 
-      if sorted.iter().map(|(key, _)| key).collect::<Vec<_>>()
-        == entry_data.iter().map(|(key, _)| key).collect::<Vec<_>>()
-      {
+      let sorted_keys: Vec<&str> = keyed.iter().map(|(key, _)| key.as_str()).collect();
+      let orig_refs: Vec<&str> = original_keys.iter().map(|key| key.as_str()).collect();
+
+      if sorted_keys == orig_refs {
         continue;
       }
 
@@ -913,9 +1075,9 @@ impl Document {
         .map(|entry| preceding_whitespace_indent(entry.syntax()))
         .unwrap_or_default();
 
-      let map_text = rebuild_entries(sorted.iter().map(|(_key, text)| text.as_str()), &indent);
-
-      edits.push((map.syntax().text_range(), map_text));
+      let sorted_groups: Vec<EntryGroup> = keyed.into_iter().map(|(_, group)| group).collect();
+      let map_text = rebuild_from_groups(&sorted_groups, &indent);
+      edits.push((group_range, map_text));
     }
 
     if edits.is_empty() {
@@ -942,8 +1104,7 @@ impl Document {
   }
 
   pub fn validate_each_sort_keys(&self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
       Some(sequence) => sequence,
@@ -974,13 +1135,17 @@ impl Document {
     }
   }
 
-  pub fn sort_items(&mut self, dot_path: &str, sort_fields: &[SortField]) -> Result<(), YerbaError> {
+  pub fn sort_items(
+    &mut self,
+    dot_path: &str,
+    sort_fields: &[SortField],
+    case_sensitive: bool,
+  ) -> Result<(), YerbaError> {
     if dot_path.contains("[].") {
-      return self.sort_each_items(dot_path, sort_fields);
+      return self.sort_each_items(dot_path, sort_fields, case_sensitive);
     }
 
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
+    let current_node = self.navigate(dot_path)?;
 
     let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
       Some(sequence) => sequence,
@@ -993,9 +1158,12 @@ impl Document {
       return Ok(());
     }
 
-    let mut sortable: Vec<(Vec<String>, String)> = entries
+    let (groups, range) = collect_groups_with_range(sequence.syntax());
+
+    let mut sortable: Vec<(Vec<String>, EntryGroup)> = entries
       .iter()
-      .map(|entry| {
+      .zip(groups)
+      .map(|(entry, group)| {
         let sort_values = if sort_fields.is_empty() {
           vec![entry
             .flow()
@@ -1011,18 +1179,22 @@ impl Document {
             .collect()
         };
 
-        (sort_values, entry.syntax().text().to_string())
+        (sort_values, group)
       })
       .collect();
 
-    let original_order: Vec<String> = sortable.iter().map(|(_, text)| text.clone()).collect();
+    let original_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
     sortable.sort_by(|(values_a, _), (values_b, _)| {
       for (index, field) in sort_fields.iter().enumerate().take(values_a.len()) {
         let value_a = &values_a[index];
         let value_b = &values_b[index];
 
-        let ordering = value_a.cmp(value_b);
+        let ordering = if case_sensitive {
+          value_a.cmp(value_b)
+        } else {
+          value_a.to_lowercase().cmp(&value_b.to_lowercase())
+        };
 
         let ordering = if field.ascending { ordering } else { ordering.reverse() };
 
@@ -1032,15 +1204,19 @@ impl Document {
       }
 
       if sort_fields.is_empty() && !values_a.is_empty() && !values_b.is_empty() {
-        return values_a[0].cmp(&values_b[0]);
+        return if case_sensitive {
+          values_a[0].cmp(&values_b[0])
+        } else {
+          values_a[0].to_lowercase().cmp(&values_b[0].to_lowercase())
+        };
       }
 
       std::cmp::Ordering::Equal
     });
 
-    let sorted_texts: Vec<String> = sortable.into_iter().map(|(_, text)| text).collect();
+    let sorted_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
-    if sorted_texts == original_order {
+    if sorted_bodies == original_bodies {
       return Ok(());
     }
 
@@ -1049,20 +1225,25 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    let sequence_text = rebuild_entries(sorted_texts.iter().map(|text| text.as_str()), &indent);
-    let sequence_range = sequence.syntax().text_range();
+    let sorted_groups: Vec<EntryGroup> = sortable.into_iter().map(|(_, group)| group).collect();
+    let sequence_text = rebuild_from_groups(&sorted_groups, &indent);
 
-    self.apply_edit(sequence_range, &sequence_text)
+    self.apply_edit(range, &sequence_text)
   }
 
-  fn sort_each_items(&mut self, dot_path: &str, sort_fields: &[SortField]) -> Result<(), YerbaError> {
+  fn sort_each_items(
+    &mut self,
+    dot_path: &str,
+    sort_fields: &[SortField],
+    case_sensitive: bool,
+  ) -> Result<(), YerbaError> {
     let (parent_path, child_path) = if let Some(last_bracket) = dot_path.rfind("[].") {
       (&dot_path[..last_bracket + 2], &dot_path[last_bracket + 3..])
     } else {
       (dot_path, "")
     };
 
-    let parent_nodes = self.navigate_to_many(parent_path);
+    let parent_nodes = self.navigate_all(parent_path);
     let source = self.root.text().to_string();
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
@@ -1085,9 +1266,12 @@ impl Document {
           continue;
         }
 
-        let mut sortable: Vec<(Vec<String>, String)> = entries
+        let (groups, group_range) = collect_groups_with_range(sequence.syntax());
+
+        let mut sortable: Vec<(Vec<String>, EntryGroup)> = entries
           .iter()
-          .map(|entry| {
+          .zip(groups)
+          .map(|(entry, group)| {
             let sort_values = if sort_fields.is_empty() {
               vec![entry
                 .flow()
@@ -1103,18 +1287,23 @@ impl Document {
                 .collect()
             };
 
-            (sort_values, entry.syntax().text().to_string())
+            (sort_values, group)
           })
           .collect();
 
-        let original_order: Vec<String> = sortable.iter().map(|(_, text)| text.clone()).collect();
+        let original_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
         sortable.sort_by(|(values_a, _), (values_b, _)| {
           for (index, field) in sort_fields.iter().enumerate().take(values_a.len()) {
             let value_a = &values_a[index];
             let value_b = &values_b[index];
 
-            let ordering = value_a.cmp(value_b);
+            let ordering = if case_sensitive {
+              value_a.cmp(value_b)
+            } else {
+              value_a.to_lowercase().cmp(&value_b.to_lowercase())
+            };
+
             let ordering = if field.ascending { ordering } else { ordering.reverse() };
 
             if ordering != std::cmp::Ordering::Equal {
@@ -1123,15 +1312,19 @@ impl Document {
           }
 
           if sort_fields.is_empty() && !values_a.is_empty() && !values_b.is_empty() {
-            return values_a[0].cmp(&values_b[0]);
+            return if case_sensitive {
+              values_a[0].cmp(&values_b[0])
+            } else {
+              values_a[0].to_lowercase().cmp(&values_b[0].to_lowercase())
+            };
           }
 
           std::cmp::Ordering::Equal
         });
 
-        let sorted_texts: Vec<String> = sortable.into_iter().map(|(_, text)| text).collect();
+        let sorted_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
-        if sorted_texts == original_order {
+        if sorted_bodies == original_bodies {
           continue;
         }
 
@@ -1140,9 +1333,9 @@ impl Document {
           .map(|entry| preceding_whitespace_indent(entry.syntax()))
           .unwrap_or_default();
 
-        let sequence_text = rebuild_entries(sorted_texts.iter().map(|text| text.as_str()), &indent);
-
-        edits.push((sequence.syntax().text_range(), sequence_text));
+        let sorted_groups: Vec<EntryGroup> = sortable.into_iter().map(|(_, group)| group).collect();
+        let sequence_text = rebuild_from_groups(&sorted_groups, &indent);
+        edits.push((group_range, sequence_text));
       }
     }
 
@@ -1169,40 +1362,43 @@ impl Document {
   }
 
   pub fn enforce_blank_lines(&mut self, dot_path: &str, blank_lines: usize) -> Result<(), YerbaError> {
-    let keys: Vec<&str> = dot_path.split('.').collect();
-    let current_node = self.navigate_to_path(&keys)?;
-
-    let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
-      Some(sequence) => sequence,
-      None => return Ok(()),
+    let nodes = if dot_path.contains('[') {
+      self.navigate_all(dot_path)
+    } else {
+      vec![self.navigate(dot_path)?]
     };
 
-    let entries: Vec<_> = sequence.entries().collect();
+    let mut edits: Vec<(TextRange, String)> = Vec::new();
 
-    if entries.len() <= 1 {
-      return Ok(());
-    }
+    for current_node in &nodes {
+      let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
+        Some(sequence) => sequence,
+        None => continue,
+      };
 
-    let source = self.root.text().to_string();
-    let mut edits: Vec<(TextRange, String)> = Vec::new();
+      let entries: Vec<_> = sequence.entries().collect();
 
-    for entry in entries.iter().skip(1) {
-      if let Some(whitespace_token) = preceding_whitespace_token(entry.syntax()) {
-        let whitespace_text = whitespace_token.text();
+      if entries.len() <= 1 {
+        continue;
+      }
 
-        let newline_count = whitespace_text.chars().filter(|character| *character == '\n').count();
+      for entry in entries.iter().skip(1) {
+        if let Some(whitespace_token) = preceding_whitespace_token(entry.syntax()) {
+          let whitespace_text = whitespace_token.text();
+          let newline_count = whitespace_text.chars().filter(|character| *character == '\n').count();
 
-        let indent = whitespace_text
-          .rfind('\n')
-          .map(|position| &whitespace_text[position + 1..])
-          .unwrap_or("");
+          let indent = whitespace_text
+            .rfind('\n')
+            .map(|position| &whitespace_text[position + 1..])
+            .unwrap_or("");
 
-        let desired_newlines = blank_lines + 1;
+          let desired_newlines = blank_lines + 1;
 
-        if newline_count != desired_newlines {
-          let new_whitespace = format!("{}{}", "\n".repeat(desired_newlines), indent);
+          if newline_count != desired_newlines {
+            let new_whitespace = format!("{}{}", "\n".repeat(desired_newlines), indent);
 
-          edits.push((whitespace_token.text_range(), new_whitespace));
+            edits.push((whitespace_token.text_range(), new_whitespace));
+          }
         }
       }
     }
@@ -1211,8 +1407,9 @@ impl Document {
       return Ok(());
     }
 
-    edits.reverse();
+    edits.sort_by_key(|edit| std::cmp::Reverse(edit.0.start()));
 
+    let source = self.root.text().to_string();
     let mut new_source = source;
 
     for (range, replacement) in edits {
@@ -1232,20 +1429,19 @@ impl Document {
   pub fn enforce_key_style(&mut self, style: &QuoteStyle, dot_path: Option<&str>) -> Result<(), YerbaError> {
     let source = self.root.text().to_string();
 
-    let scope_node = match dot_path {
-      Some(path) if !path.is_empty() => {
-        let keys: Vec<&str> = path.split('.').collect();
-        self.navigate_to_path(&keys)?
-      }
-      _ => self.root.clone(),
+    let scope_ranges: Vec<TextRange> = match dot_path {
+      Some(path) if !path.is_empty() => self.navigate_all(path).iter().map(|node| node.text_range()).collect(),
+      _ => vec![self.root.text_range()],
     };
 
-    let scope_range = scope_node.text_range();
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
     for element in self.root.descendants_with_tokens() {
       if let Some(token) = element.into_token() {
-        if !scope_range.contains_range(token.text_range()) {
+        if !scope_ranges
+          .iter()
+          .any(|range| range.contains_range(token.text_range()))
+        {
           continue;
         }
 
@@ -1335,21 +1531,19 @@ impl Document {
   pub fn enforce_quotes_at(&mut self, style: &QuoteStyle, dot_path: Option<&str>) -> Result<(), YerbaError> {
     let source = self.root.text().to_string();
 
-    let scope_node = match dot_path {
-      Some(path) if !path.is_empty() => {
-        let keys: Vec<&str> = path.split('.').collect();
-        self.navigate_to_path(&keys)?
-      }
-      _ => self.root.clone(),
+    let scope_ranges: Vec<TextRange> = match dot_path {
+      Some(path) if !path.is_empty() => self.navigate_all(path).iter().map(|node| node.text_range()).collect(),
+      _ => vec![self.root.text_range()],
     };
 
-    let scope_range = scope_node.text_range();
-
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
     for element in self.root.descendants_with_tokens() {
       if let Some(token) = element.into_token() {
-        if !scope_range.contains_range(token.text_range()) {
+        if !scope_ranges
+          .iter()
+          .any(|range| range.contains_range(token.text_range()))
+        {
           continue;
         }
 
@@ -1466,8 +1660,71 @@ impl Document {
     Ok(())
   }
 
-  pub fn navigate_to_many(&self, dot_path: &str) -> Vec<SyntaxNode> {
-    let segments = parse_path_segments(dot_path);
+  pub fn navigate(&self, dot_path: &str) -> Result<SyntaxNode, YerbaError> {
+    Self::validate_path(dot_path)?;
+
+    if dot_path.is_empty() {
+      let root = Root::cast(self.root.clone()).ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+
+      let document = root
+        .documents()
+        .next()
+        .ok_or_else(|| YerbaError::PathNotFound(dot_path.to_string()))?;
+
+      return Ok(document.syntax().clone());
+    }
+
+    let nodes = self.navigate_all(dot_path);
+
+    match nodes.len() {
+      0 => Err(YerbaError::PathNotFound(dot_path.to_string())),
+      1 => Ok(nodes.into_iter().next().unwrap()),
+      _ => Err(YerbaError::PathNotFound(format!(
+        "{} (matched {} nodes, expected 1)",
+        dot_path,
+        nodes.len()
+      ))),
+    }
+  }
+
+  pub fn validate_path(dot_path: &str) -> Result<(), YerbaError> {
+    if dot_path.ends_with('.') {
+      return Err(YerbaError::ParseError(format!(
+        "invalid path: trailing dot in '{}'",
+        dot_path
+      )));
+    }
+
+    if dot_path.contains("..") {
+      return Err(YerbaError::ParseError(format!(
+        "invalid path: double dot in '{}'",
+        dot_path
+      )));
+    }
+
+    if dot_path.starts_with('.') {
+      return Err(YerbaError::ParseError(format!(
+        "invalid path: leading dot in '{}'",
+        dot_path
+      )));
+    }
+
+    if dot_path.contains('[') && !dot_path.contains(']') {
+      return Err(YerbaError::ParseError(format!(
+        "invalid path: unclosed bracket in '{}'",
+        dot_path
+      )));
+    }
+
+    Ok(())
+  }
+
+  pub fn navigate_all(&self, dot_path: &str) -> Vec<SyntaxNode> {
+    if Document::validate_path(dot_path).is_err() {
+      return Vec::new();
+    }
+
+    let parsed = crate::selector::Selector::parse(dot_path);
 
     let root = match Root::cast(self.root.clone()) {
       Some(root) => root,
@@ -1481,7 +1738,7 @@ impl Document {
 
     let mut current_nodes = vec![document.syntax().clone()];
 
-    if segments.is_empty() {
+    if parsed.is_empty() {
       if let Some(sequence) = document.syntax().descendants().find_map(BlockSeq::cast) {
         current_nodes = sequence.entries().map(|entry| entry.syntax().clone()).collect();
       }
@@ -1489,7 +1746,7 @@ impl Document {
       return current_nodes;
     }
 
-    for segment in &segments {
+    for segment in parsed.segments() {
       let mut next_nodes = Vec::new();
 
       for node in &current_nodes {
@@ -1506,37 +1763,6 @@ impl Document {
     current_nodes
   }
 
-  fn navigate_to_path(&self, keys: &[&str]) -> Result<SyntaxNode, YerbaError> {
-    let keys: Vec<&&str> = keys.iter().filter(|key| !key.is_empty()).collect();
-    let path_string = keys.iter().map(|key| **key).collect::<Vec<_>>().join(".");
-
-    let root = Root::cast(self.root.clone()).ok_or_else(|| YerbaError::PathNotFound(path_string.clone()))?;
-
-    let document = root
-      .documents()
-      .next()
-      .ok_or_else(|| YerbaError::PathNotFound(path_string.clone()))?;
-
-    let mut current_node = document.syntax().clone();
-
-    for key in &keys {
-      let map = current_node
-        .descendants()
-        .find_map(BlockMap::cast)
-        .ok_or_else(|| YerbaError::PathNotFound(path_string.clone()))?;
-
-      let entry = find_entry_by_key(&map, key).ok_or_else(|| YerbaError::PathNotFound(path_string.clone()))?;
-
-      let map_value = entry
-        .value()
-        .ok_or_else(|| YerbaError::PathNotFound(path_string.clone()))?;
-
-      current_node = map_value.syntax().clone();
-    }
-
-    Ok(current_node)
-  }
-
   fn replace_token(&mut self, token: &SyntaxToken, new_text: &str) -> Result<(), YerbaError> {
     let range = token.text_range();
 
@@ -1551,22 +1777,51 @@ impl Document {
   }
 
   fn remove_node(&mut self, node: &SyntaxNode) -> Result<(), YerbaError> {
+    let inline_comment = self.find_inline_comment(node);
     let range = removal_range(node);
 
-    self.apply_edit(range, "")
+    if let Some((comment_text, comment_end)) = inline_comment {
+      let indent = preceding_whitespace_indent(node);
+      let replacement = format!("\n{}{}", indent, comment_text);
+      let expanded_range = TextRange::new(range.start(), comment_end);
+
+      self.apply_edit(expanded_range, &replacement)
+    } else {
+      self.apply_edit(range, "")
+    }
   }
 
-  fn reorder_entries<T>(
-    &mut self,
-    entries: &[T],
-    from: usize,
-    to: usize,
-    get_text: impl Fn(&T) -> String,
-    get_indent: impl Fn(&T) -> String,
-    range: TextRange,
-  ) -> Result<(), YerbaError>
+  fn find_inline_comment(&self, node: &SyntaxNode) -> Option<(String, rowan::TextSize)> {
+    let mut sibling = node.next_sibling_or_token();
+
+    while let Some(ref element) = sibling {
+      match element {
+        rowan::NodeOrToken::Token(token) => {
+          if token.kind() == SyntaxKind::COMMENT {
+            return Some((token.text().to_string(), token.text_range().end()));
+          } else if token.kind() == SyntaxKind::WHITESPACE {
+            if token.text().contains('\n') {
+              return None;
+            }
+          } else {
+            return None;
+          }
+        }
+        _ => return None,
+      }
+
+      sibling = match element {
+        rowan::NodeOrToken::Token(token) => token.next_sibling_or_token(),
+        rowan::NodeOrToken::Node(node) => node.next_sibling_or_token(),
+      };
+    }
+
+    None
+  }
+
+  fn reorder_entries<T>(&mut self, parent: &SyntaxNode, entries: &[T], from: usize, to: usize) -> Result<(), YerbaError>
   where
-    T: rowan::ast::AstNode,
+    T: rowan::ast::AstNode<Language = yaml_parser::YamlLanguage>,
   {
     let length = entries.len();
 
@@ -1578,15 +1833,18 @@ impl Document {
       return Err(YerbaError::IndexOutOfBounds(to, length));
     }
 
-    let entry_texts: Vec<String> = entries.iter().map(&get_text).collect();
+    let (groups, range) = collect_groups_with_range(parent);
 
-    let mut reordered = entry_texts.clone();
+    let mut reordered = groups.clone();
     let item = reordered.remove(from);
-
     reordered.insert(to, item);
 
-    let indent = entries.get(1).map(&get_indent).unwrap_or_default();
-    let text = rebuild_entries(reordered.iter().map(|text| text.as_str()), &indent);
+    let indent = entries
+      .get(1)
+      .map(|entry| preceding_whitespace_indent(entry.syntax()))
+      .unwrap_or_default();
+
+    let text = rebuild_from_groups(&reordered, &indent);
 
     self.apply_edit(range, &text)
   }
@@ -1613,6 +1871,96 @@ impl std::fmt::Display for Document {
   }
 }
 
+pub fn node_to_yaml_value(node: &SyntaxNode) -> serde_yaml::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();
+
+      return serde_yaml::Value::Sequence(values);
+    }
+  }
+
+  if let Some(map) = node.descendants().find_map(BlockMap::cast) {
+    let mut mapping = serde_yaml::Mapping::new();
+
+    for entry in map.entries() {
+      let key = entry
+        .key()
+        .and_then(|key_node| extract_scalar_text(key_node.syntax()))
+        .unwrap_or_default();
+
+      let value = entry
+        .value()
+        .map(|value_node| node_to_yaml_value(value_node.syntax()))
+        .unwrap_or(serde_yaml::Value::Null);
+
+      mapping.insert(serde_yaml::Value::String(key), value);
+    }
+
+    return serde_yaml::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();
+
+    return serde_yaml::Value::Sequence(values);
+  }
+
+  if let Some(block_scalar) = node
+    .descendants()
+    .find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR)
+  {
+    let text = block_scalar
+      .descendants_with_tokens()
+      .filter_map(|element| element.into_token())
+      .find(|token| token.kind() == SyntaxKind::BLOCK_SCALAR_TEXT)
+      .map(|token| token.text().to_string())
+      .unwrap_or_default();
+
+    return serde_yaml::Value::String(text);
+  }
+
+  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::Integer => scalar
+        .text
+        .parse::<i64>()
+        .map(|n| serde_yaml::Value::Number(serde_yaml::Number::from(n)))
+        .unwrap_or(serde_yaml::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)),
+
+      YerbaValueType::String => serde_yaml::Value::String(scalar.text),
+    };
+  }
+
+  let text = node.text().to_string();
+
+  serde_yaml::from_str(&text).unwrap_or(serde_yaml::Value::String(text))
+}
+
 fn parse_condition(condition: &str) -> Option<(String, &str, String)> {
   let (left, operator, right) = if let Some(index) = condition.find(" not_contains ") {
     (
@@ -1639,140 +1987,250 @@ fn parse_condition(condition: &str) -> Option<(String, &str, String)> {
   Some((left.to_string(), operator, right.to_string()))
 }
 
-fn parse_path_segments(path: &str) -> Vec<&str> {
-  if path.is_empty() {
-    return Vec::new();
-  }
+fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment) -> Vec<SyntaxNode> {
+  use crate::selector::SelectorSegment;
 
-  let mut segments = Vec::new();
-  let mut rest = path;
+  match segment {
+    SelectorSegment::AllItems => {
+      if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+        sequence.entries().map(|entry| entry.syntax().clone()).collect()
+      } else {
+        Vec::new()
+      }
+    }
 
-  while !rest.is_empty() {
-    if rest.starts_with('[') {
-      if let Some(close) = rest.find(']') {
-        segments.push(&rest[..close + 1]);
-        rest = &rest[close + 1..];
+    SelectorSegment::Index(index) => {
+      if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+        sequence
+          .entries()
+          .nth(*index)
+          .map(|entry| vec![entry.syntax().clone()])
+          .unwrap_or_default()
+      } else {
+        Vec::new()
+      }
+    }
 
-        if rest.starts_with('.') {
-          rest = &rest[1..];
+    SelectorSegment::Key(key) => {
+      if let Some(map) = node.descendants().find_map(BlockMap::cast) {
+        if let Some(entry) = find_entry_by_key(&map, key) {
+          if let Some(value) = entry.value() {
+            return vec![value.syntax().clone()];
+          }
         }
-      } else {
-        segments.push(rest);
-        break;
       }
-    } else {
-      let dot_index = rest.find('.');
-      let bracket_index = rest.find('[');
-
-      let split_at = match (dot_index, bracket_index) {
-        (Some(dot), Some(bracket)) => Some(dot.min(bracket)),
-        (Some(dot), None) => Some(dot),
-        (None, Some(bracket)) => Some(bracket),
-        (None, None) => None,
-      };
 
-      match split_at {
-        Some(index) => {
-          let segment = &rest[..index];
+      Vec::new()
+    }
+  }
+}
 
-          if !segment.is_empty() {
-            segments.push(segment);
-          }
+fn navigate_from_node(node: &SyntaxNode, path: &str) -> Vec<SyntaxNode> {
+  let parsed = crate::selector::Selector::parse(path);
+  let mut current_nodes = vec![node.clone()];
 
-          rest = &rest[index..];
+  for segment in parsed.segments() {
+    let mut next_nodes = Vec::new();
 
-          if rest.starts_with('.') {
-            rest = &rest[1..];
-          }
-        }
+    for current in &current_nodes {
+      next_nodes.extend(resolve_segment(current, segment));
+    }
 
-        None => {
-          segments.push(rest);
-          break;
-        }
-      }
+    current_nodes = next_nodes;
+
+    if current_nodes.is_empty() {
+      break;
     }
   }
 
-  segments
+  current_nodes
 }
 
-fn parse_bracket_index(segment: &str) -> Option<usize> {
-  if segment == "[]" {
-    return None;
-  }
+#[derive(Debug, Clone)]
+struct EntryGroup {
+  separator: String,
+  preceding: String,
+  body: String,
+}
 
-  segment
-    .strip_prefix('[')
-    .and_then(|rest| rest.strip_suffix(']'))
-    .and_then(|inner| inner.parse::<usize>().ok())
+impl EntryGroup {
+  fn full_text(&self) -> String {
+    if self.preceding.is_empty() {
+      self.body.clone()
+    } else {
+      format!("{}\n{}", self.preceding, self.body)
+    }
+  }
 }
 
-fn resolve_segment(node: &SyntaxNode, segment: &str) -> Vec<SyntaxNode> {
-  if segment.starts_with('[') {
-    if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-      match parse_bracket_index(segment) {
-        None => sequence.entries().map(|entry| entry.syntax().clone()).collect(),
+fn collect_entry_groups(parent: &SyntaxNode) -> Vec<EntryGroup> {
+  let mut groups: Vec<EntryGroup> = Vec::new();
+  let mut buffer = String::new();
 
-        Some(index) => sequence
-          .entries()
-          .nth(index)
-          .map(|entry| vec![entry.syntax().clone()])
-          .unwrap_or_default(),
+  for child in parent.children_with_tokens() {
+    let is_entry = child.as_node().is_some()
+      && matches!(
+        child.as_node().unwrap().kind(),
+        SyntaxKind::BLOCK_MAP_ENTRY | SyntaxKind::BLOCK_SEQ_ENTRY
+      );
+
+    if is_entry {
+      let entry_text = child.as_node().unwrap().text().to_string();
+
+      if groups.is_empty() {
+        let preceding = buffer.trim_start_matches('\n').to_string();
+
+        groups.push(EntryGroup {
+          separator: String::new(),
+          preceding,
+          body: entry_text,
+        });
+      } else {
+        let (trailing, separator, preceding) = split_at_blank_line(&buffer);
+
+        if let Some(last) = groups.last_mut() {
+          last.body.push_str(&trailing);
+        }
+
+        groups.push(EntryGroup {
+          separator,
+          preceding,
+          body: entry_text,
+        });
       }
+
+      buffer.clear();
     } else {
-      Vec::new()
+      let text = match &child {
+        rowan::NodeOrToken::Node(node) => node.text().to_string(),
+        rowan::NodeOrToken::Token(token) => token.text().to_string(),
+      };
+
+      buffer.push_str(&text);
     }
-  } else {
-    if let Some(map) = node.descendants().find_map(BlockMap::cast) {
-      if let Some(entry) = find_entry_by_key(&map, segment) {
-        if let Some(value) = entry.value() {
-          return vec![value.syntax().clone()];
-        }
-      }
+  }
+
+  if let Some(last) = groups.last_mut() {
+    let trimmed = buffer.trim_end_matches(['\n', ' ', '\t']);
+
+    if !trimmed.is_empty() {
+      last.body.push_str(trimmed);
     }
+  }
 
-    Vec::new()
+  for group in &mut groups {
+    let trimmed = group.body.trim_end_matches(['\n', ' ', '\t']);
+
+    group.body = trimmed.to_string();
   }
+
+  groups
 }
 
-fn navigate_from_node(node: &SyntaxNode, path: &str) -> Vec<SyntaxNode> {
-  let segments = parse_path_segments(path);
-  let mut current_nodes = vec![node.clone()];
+fn split_at_blank_line(text: &str) -> (String, String, String) {
+  if let Some(position) = text.find("\n\n") {
+    let trailing = text[..position].to_string();
+    let rest = &text[position..];
+    let content_start = rest.len() - rest.trim_start_matches('\n').len();
+    let separator = rest[..content_start].to_string();
+    let preceding = rest[content_start..].trim_end_matches(['\n', ' ', '\t']).to_string();
 
-  for segment in &segments {
-    let mut next_nodes = Vec::new();
+    (trailing, separator, preceding)
+  } else {
+    (text.to_string(), String::new(), String::new())
+  }
+}
 
-    for current in &current_nodes {
-      next_nodes.extend(resolve_segment(current, segment));
-    }
+fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String, Option<rowan::TextSize>) {
+  let mut comments: Vec<String> = Vec::new();
+  let mut earliest_start = None;
+  let mut node = parent.clone();
+
+  loop {
+    let mut sibling = node.prev_sibling_or_token();
+
+    while let Some(ref element) = sibling {
+      match element {
+        rowan::NodeOrToken::Token(token) => {
+          if token.kind() == SyntaxKind::COMMENT {
+            comments.push(token.text().to_string());
+            earliest_start = Some(token.text_range().start());
+          } else if token.kind() == SyntaxKind::WHITESPACE {
+            // Keep looking past whitespace
+          } else {
+            break;
+          }
+        }
+        _ => break,
+      }
 
-    current_nodes = next_nodes;
+      sibling = match element {
+        rowan::NodeOrToken::Token(token) => token.prev_sibling_or_token(),
+        rowan::NodeOrToken::Node(node) => node.prev_sibling_or_token(),
+      };
+    }
 
-    if current_nodes.is_empty() {
+    if !comments.is_empty() {
       break;
     }
+
+    match node.parent() {
+      Some(parent)
+        if parent.kind() == SyntaxKind::BLOCK
+          || parent.kind() == SyntaxKind::DOCUMENT
+          || parent.kind() == SyntaxKind::BLOCK_MAP_VALUE
+          || parent.kind() == SyntaxKind::BLOCK_SEQ_ENTRY =>
+      {
+        node = parent
+      }
+      _ => break,
+    }
   }
 
-  current_nodes
+  comments.reverse();
+  (comments.join("\n"), earliest_start)
 }
 
-fn byte_offset_to_line(source: &str, offset: usize) -> usize {
-  source[..offset.min(source.len())]
-    .chars()
-    .filter(|character| *character == '\n')
-    .count()
-    + 1
+fn collect_groups_with_range(parent: &SyntaxNode) -> (Vec<EntryGroup>, TextRange) {
+  let mut groups = collect_entry_groups(parent);
+
+  let (sibling_comments, earliest_start) = collect_preceding_sibling_comments(parent);
+
+  if !sibling_comments.is_empty() {
+    if let Some(first) = groups.first_mut() {
+      if first.preceding.is_empty() {
+        first.preceding = sibling_comments;
+      } else {
+        first.preceding = format!("{}\n{}", sibling_comments, first.preceding);
+      }
+    }
+  }
+
+  let range = match earliest_start {
+    Some(start) => TextRange::new(start, parent.text_range().end()),
+    None => parent.text_range(),
+  };
+
+  (groups, range)
 }
 
-fn rebuild_entries<'a>(entries: impl Iterator<Item = &'a str>, indent: &str) -> String {
-  entries
+fn rebuild_from_groups(groups: &[EntryGroup], indent: &str) -> String {
+  let default_separator = groups
+    .iter()
+    .find(|group| !group.separator.is_empty())
+    .map(|group| group.separator.clone())
+    .unwrap_or_else(|| "\n".to_string());
+
+  groups
+    .iter()
     .enumerate()
-    .map(|(index, text)| {
+    .map(|(index, group)| {
       if index == 0 {
-        text.to_string()
+        group.full_text()
+      } else if group.preceding.is_empty() {
+        format!("{}{}{}", default_separator, indent, group.body)
       } else {
-        format!("\n{}{}", indent, text)
+        format!("{}{}\n{}{}", default_separator, group.preceding, indent, group.body)
       }
     })
     .collect()