yerba 0.9.2-arm-linux-gnu → 0.10.1-arm-linux-gnu

data/rust/src/document/mod.rs

@@ -2,6 +2,7 @@ mod condition;
 mod delete;
 mod get;
 mod insert;
+mod nodes;
 mod set;
 mod sort;
 mod unique;
@@ -32,6 +33,7 @@ pub struct LocatedNode {
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::OnceLock;
 
 use rowan::ast::AstNode;
 use rowan::{TextRange, TextSize};
@@ -46,34 +48,34 @@ use crate::syntax::{
   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,
+  FirstCollection, LineIndex, ScalarValue,
 };
 
 #[derive(Debug, Clone)]
 pub struct SortField {
-  pub path: String,
+  pub selector: String,
   pub ascending: bool,
 }
 
 impl SortField {
-  pub fn asc(path: &str) -> Self {
+  pub fn asc(selector: &str) -> Self {
     SortField {
-      path: path.to_string(),
+      selector: selector.to_string(),
       ascending: true,
     }
   }
 
-  pub fn desc(path: &str) -> Self {
+  pub fn desc(selector: &str) -> Self {
     SortField {
-      path: path.to_string(),
+      selector: selector.to_string(),
       ascending: false,
     }
   }
 
   pub fn parse(input: &str) -> Self {
-    if let Some((path, direction)) = input.rsplit_once(':') {
+    if let Some((selector, direction)) = input.rsplit_once(':') {
       match direction {
-        "desc" | "descending" => SortField::desc(path),
+        "desc" | "descending" => SortField::desc(selector),
         _ => SortField::asc(input),
       }
     } else {
@@ -82,7 +84,58 @@ impl SortField {
   }
 
   pub fn parse_list(input: &str) -> Vec<Self> {
-    input.split(',').map(|field| SortField::parse(field.trim())).collect()
+    let mut fields = Vec::new();
+    let mut current = String::new();
+    let mut depth = 0usize;
+    let mut quote: Option<char> = None;
+
+    for character in input.chars() {
+      match (quote, character) {
+        (Some(open), _) if character == open => quote = None,
+        (Some(_), _) => {}
+        (None, '"' | '\'') => quote = Some(character),
+        (None, '[') => depth += 1,
+        (None, ']') => depth = depth.saturating_sub(1),
+        (None, ',') if depth == 0 => {
+          fields.push(std::mem::take(&mut current));
+          continue;
+        }
+        (None, _) if character.is_whitespace() && depth == 0 => {
+          fields.push(std::mem::take(&mut current));
+          continue;
+        }
+        _ => {}
+      }
+
+      current.push(character);
+    }
+
+    fields.push(current);
+
+    fields.iter().filter(|field| !field.is_empty()).map(|field| SortField::parse(field)).collect()
+  }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SortMissing {
+  First,
+  Last,
+  Keep,
+  Skip,
+}
+
+impl std::str::FromStr for SortMissing {
+  type Err = String;
+
+  fn from_str(input: &str) -> Result<Self, Self::Err> {
+    match input {
+      "first" => Ok(SortMissing::First),
+      "last" => Ok(SortMissing::Last),
+      "keep" => Ok(SortMissing::Keep),
+      "skip" => Ok(SortMissing::Skip),
+      _ => Err(format!("unknown missing: {} (expected first, last, keep or skip)", input)),
+    }
   }
 }
 
@@ -103,6 +156,8 @@ pub struct Location {
   pub end_column: usize,
   pub start_offset: usize,
   pub end_offset: usize,
+  pub start_character_column: usize,
+  pub end_character_column: usize,
 }
 
 #[derive(Debug)]
@@ -127,6 +182,28 @@ pub enum InsertPosition {
   FromSortOrder(Vec<String>),
 }
 
+impl InsertPosition {
+  pub fn before(target: impl Into<String>) -> Self {
+    let target = target.into();
+
+    if target.starts_with('.') {
+      InsertPosition::BeforeCondition(target)
+    } else {
+      InsertPosition::Before(target)
+    }
+  }
+
+  pub fn after(target: impl Into<String>) -> Self {
+    let target = target.into();
+
+    if target.starts_with('.') {
+      InsertPosition::AfterCondition(target)
+    } else {
+      InsertPosition::After(target)
+    }
+  }
+}
+
 static NEXT_GENERATION: AtomicU64 = AtomicU64::new(1);
 
 #[derive(Debug)]
@@ -134,6 +211,7 @@ pub struct Document {
   root: SyntaxNode,
   path: Option<PathBuf>,
   generation: u64,
+  line_index: OnceLock<LineIndex>,
 }
 
 impl Document {
@@ -146,6 +224,7 @@ impl Document {
       root: tree,
       path: None,
       generation: NEXT_GENERATION.fetch_add(1, Ordering::Relaxed),
+      line_index: OnceLock::new(),
     })
   }
 
@@ -181,49 +260,49 @@ impl Document {
     Ok(())
   }
 
-  pub fn source(&self, dot_path: &str) -> Result<String, YerbaError> {
-    let node = self.navigate(dot_path)?;
+  pub fn source(&self, selector: &str) -> Result<String, YerbaError> {
+    let node = self.navigate(selector)?;
     Ok(node.text().to_string())
   }
 
-  pub fn navigate(&self, dot_path: &str) -> Result<SyntaxNode, YerbaError> {
-    Self::validate_path(dot_path)?;
+  pub fn navigate(&self, selector: &str) -> Result<SyntaxNode, YerbaError> {
+    Self::validate_selector(selector)?;
 
-    if dot_path.is_empty() {
-      let root = Root::cast(self.root.clone()).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    if selector.is_empty() {
+      let root = Root::cast(self.root.clone()).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
-      let document = root.documents().next().ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+      let document = root.documents().next().ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
       return Ok(document.syntax().clone());
     }
 
-    let nodes = self.navigate_all_compact(dot_path);
+    let nodes = self.navigate_all_compact(selector);
 
     match nodes.len() {
-      0 => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
+      0 => Err(YerbaError::SelectorNotFound(selector.to_string())),
       1 => Ok(nodes.into_iter().next().unwrap()),
-      _ => Err(YerbaError::AmbiguousSelector(dot_path.to_string(), nodes.len())),
+      _ => Err(YerbaError::AmbiguousSelector(selector.to_string(), nodes.len())),
     }
   }
 
-  pub fn navigate_all_compact(&self, dot_path: &str) -> Vec<SyntaxNode> {
-    self.navigate_all(dot_path).into_iter().flatten().collect()
+  pub fn navigate_all_compact(&self, selector: &str) -> Vec<SyntaxNode> {
+    self.navigate_all(selector).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()));
+  pub(crate) fn refuse_flow_target(&self, selector: &str) -> Result<(), YerbaError> {
+    if self.navigate_all_compact(selector).iter().any(in_flow_collection) {
+      return Err(YerbaError::FlowCollectionNotWritable(selector.to_string()));
     }
 
     Ok(())
   }
 
-  pub fn navigate_all(&self, dot_path: &str) -> Vec<Option<SyntaxNode>> {
-    if Document::validate_path(dot_path).is_err() {
+  pub fn navigate_all(&self, selector: &str) -> Vec<Option<SyntaxNode>> {
+    if Document::validate_selector(selector).is_err() {
       return Vec::new();
     }
 
-    let parsed = crate::selector::Selector::parse(dot_path);
+    let parsed = crate::selector::Selector::parse(selector);
 
     let root = match Root::cast(self.root.clone()) {
       Some(root) => root,
@@ -299,21 +378,21 @@ impl Document {
     current_nodes
   }
 
-  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)));
+  pub fn validate_selector(selector: &str) -> Result<(), YerbaError> {
+    if selector.ends_with('.') {
+      return Err(YerbaError::ParseError(format!("invalid selector: trailing dot in '{}'", selector)));
     }
 
-    if dot_path.contains("..") {
-      return Err(YerbaError::ParseError(format!("invalid path: double dot in '{}'", dot_path)));
+    if selector.contains("..") {
+      return Err(YerbaError::ParseError(format!("invalid selector: double dot in '{}'", selector)));
     }
 
-    if dot_path.starts_with('.') {
-      return Err(YerbaError::ParseError(format!("invalid path: leading dot in '{}'", dot_path)));
+    if selector.starts_with('.') {
+      return Err(YerbaError::ParseError(format!("invalid selector: leading dot in '{}'", selector)));
     }
 
-    if dot_path.contains('[') && !dot_path.contains(']') {
-      return Err(YerbaError::ParseError(format!("invalid path: unclosed bracket in '{}'", dot_path)));
+    if selector.contains('[') && !selector.contains(']') {
+      return Err(YerbaError::ParseError(format!("invalid selector: unclosed bracket in '{}'", selector)));
     }
 
     Ok(())
@@ -487,6 +566,10 @@ impl Document {
     self.root.text().to_string()
   }
 
+  fn line_index(&self) -> &LineIndex {
+    self.line_index.get_or_init(|| LineIndex::new(&self.source_text()))
+  }
+
   fn reparse(&mut self, new_source: &str) -> Result<(), YerbaError> {
     let document = Self::parse(new_source)?;
     let path = self.path.take();
@@ -538,17 +621,19 @@ fn check_duplicate_keys(root: &SyntaxNode) -> Result<(), YerbaError> {
   Ok(())
 }
 
-pub(crate) fn compute_location(source: &str, start_offset: usize, end_offset: usize) -> Location {
-  let start = start_offset.min(source.len());
-  let end = end_offset.min(source.len());
+pub(crate) fn compute_location(index: &LineIndex, start_offset: usize, end_offset: usize) -> Location {
+  let start = start_offset.min(index.source_length());
+  let end = end_offset.min(index.source_length());
 
   Location {
     start_offset: start,
     end_offset: end,
-    start_line: line_at(source, start),
-    start_column: column_at(source, start),
-    end_line: line_at(source, end),
-    end_column: column_at(source, end),
+    start_line: index.line_at(start),
+    start_column: index.column_at(start),
+    end_line: index.line_at(end),
+    end_column: index.column_at(end),
+    start_character_column: index.character_column_at(start),
+    end_character_column: index.character_column_at(end),
   }
 }
 
@@ -635,25 +720,17 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::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 => yaml_serde::Value::Null,
-      YerbaValueType::Boolean => yaml_serde::Value::Bool(is_yaml_truthy(&scalar.text)),
-
-      YerbaValueType::Integer => scalar
-        .text
-        .parse::<i64>()
-        .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| yaml_serde::Value::Number(yaml_serde::Number::from(n)))
-        .unwrap_or(yaml_serde::Value::String(scalar.text)),
-
-      YerbaValueType::String => yaml_serde::Value::String(scalar.text),
+    use crate::syntax::{resolve_scalar, PlainScalar};
+
+    return match resolve_scalar(&scalar) {
+      PlainScalar::Null => yaml_serde::Value::Null,
+      PlainScalar::Boolean(boolean) => yaml_serde::Value::Bool(boolean),
+      PlainScalar::Integer(integer) => yaml_serde::Value::Number(match i64::try_from(integer) {
+        Ok(integer) => yaml_serde::Number::from(integer),
+        Err(_) => yaml_serde::Number::from(integer as u64),
+      }),
+      PlainScalar::Float(float) => yaml_serde::Value::Number(yaml_serde::Number::from(float)),
+      PlainScalar::String => yaml_serde::Value::String(scalar.text),
     };
   }
 
@@ -728,6 +805,26 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
       }
     }
 
+    SelectorSegment::IndexFromEnd(_) => {
+      if let Some(sequence) = find_block_sequence(node) {
+        segment
+          .sequence_index(sequence.entries().count())
+          .and_then(|index| sequence.entries().nth(index))
+          .map(|entry| vec![entry.syntax().clone()])
+          .unwrap_or_default()
+      } else if let Some(sequence) = find_flow_sequence(node) {
+        let entries = flow_sequence_entries(&sequence);
+
+        segment
+          .sequence_index(entries.len())
+          .and_then(|index| entries.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()
@@ -765,8 +862,8 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
   }
 }
 
-pub(crate) fn navigate_from_node(node: &SyntaxNode, path: &str) -> Vec<SyntaxNode> {
-  let parsed = crate::selector::Selector::parse(path);
+pub(crate) fn navigate_from_node(node: &SyntaxNode, selector: &str) -> Vec<SyntaxNode> {
+  let parsed = crate::selector::Selector::parse(selector);
 
   navigate_remaining(node, parsed.segments())
 }
@@ -775,6 +872,7 @@ pub(crate) fn navigate_from_node(node: &SyntaxNode, path: &str) -> Vec<SyntaxNod
 pub(crate) struct EntryGroup {
   pub(crate) separator: String,
   pub(crate) preceding: String,
+  pub(crate) gap: String,
   pub(crate) body: String,
 }
 
@@ -783,7 +881,7 @@ impl EntryGroup {
     if self.preceding.is_empty() {
       self.body.clone()
     } else {
-      format!("{}\n{}", self.preceding, self.body)
+      format!("{}{}{}", self.preceding, self.gap, self.body)
     }
   }
 }
@@ -818,15 +916,17 @@ fn collect_entry_groups(parent: &SyntaxNode) -> Vec<EntryGroup> {
       let entry_text = child.as_node().unwrap().text().to_string();
 
       if groups.is_empty() {
-        let preceding = buffer.trim_start_matches('\n').to_string();
+        let (preceding, gap) = split_gap(buffer.trim_start_matches('\n'));
 
         groups.push(EntryGroup {
           separator: String::new(),
           preceding,
+          gap,
           body: entry_text,
         });
       } else {
         let (trailing, separator, preceding) = split_at_blank_line(&buffer);
+        let (preceding, gap) = split_gap(&preceding);
 
         if let Some(last) = groups.last_mut() {
           last.body.push_str(&trailing);
@@ -835,6 +935,7 @@ fn collect_entry_groups(parent: &SyntaxNode) -> Vec<EntryGroup> {
         groups.push(EntryGroup {
           separator,
           preceding,
+          gap,
           body: entry_text,
         });
       }
@@ -873,7 +974,7 @@ fn split_at_blank_line(text: &str) -> (String, String, 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();
+    let preceding = rest[content_start..].to_string();
 
     (trailing, separator, preceding)
   } else {
@@ -881,8 +982,16 @@ fn split_at_blank_line(text: &str) -> (String, String, String) {
   }
 }
 
-pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String, Option<rowan::TextSize>) {
-  let mut comments: Vec<String> = Vec::new();
+fn split_gap(text: &str) -> (String, String) {
+  let content = text.trim_end_matches(['\n', ' ', '\t']);
+  let newlines = text[content.len()..].matches('\n').count().max(1);
+
+  (content.to_string(), "\n".repeat(newlines))
+}
+
+pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String, String, Option<rowan::TextSize>) {
+  let mut comments: Vec<(String, usize)> = Vec::new();
+  let mut newlines = 0;
   let mut earliest_start = None;
   let mut node = parent.clone();
 
@@ -893,10 +1002,11 @@ pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String
       match element {
         rowan::NodeOrToken::Token(token) => {
           if token.kind() == SyntaxKind::COMMENT {
-            comments.push(token.text().to_string());
+            comments.push((token.text().to_string(), newlines));
+            newlines = 0;
             earliest_start = Some(token.text_range().start());
           } else if token.kind() == SyntaxKind::WHITESPACE {
-            // Keep looking past whitespace
+            newlines += token.text().matches('\n').count();
           } else {
             break;
           }
@@ -910,7 +1020,7 @@ pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String
       };
     }
 
-    if !comments.is_empty() {
+    if !comments.is_empty() || sibling.is_some() {
       break;
     }
 
@@ -922,21 +1032,37 @@ pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String
     }
   }
 
+  let gap = "\n".repeat(comments.first().map_or(1, |(_, newlines)| (*newlines).max(1)));
+
   comments.reverse();
-  (comments.join("\n"), earliest_start)
+
+  let text = comments
+    .iter()
+    .enumerate()
+    .map(|(index, (comment, newlines))| {
+      if index + 1 < comments.len() {
+        format!("{}{}", comment, "\n".repeat((*newlines).max(1)))
+      } else {
+        comment.clone()
+      }
+    })
+    .collect();
+
+  (text, gap, earliest_start)
 }
 
 pub(crate) 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);
+  let (sibling_comments, sibling_gap, 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;
+        first.gap = sibling_gap;
       } else {
-        first.preceding = format!("{}\n{}", sibling_comments, first.preceding);
+        first.preceding = format!("{}{}{}", sibling_comments, sibling_gap, first.preceding);
       }
     }
   }
@@ -976,7 +1102,7 @@ pub(crate) fn rebuild_from_groups(groups: &[EntryGroup], indent: &str, preserve_
         if group.preceding.is_empty() {
           format!("{}{}{}", separator, indent, group.body)
         } else {
-          format!("{}{}\n{}{}", separator, group.preceding, indent, group.body)
+          format!("{}{}{}{}{}", separator, group.preceding, group.gap, indent, group.body)
         }
       }
     })

data/rust/src/document/nodes.rs

@@ -0,0 +1,162 @@
+use super::*;
+
+#[derive(Debug)]
+pub struct NodeRecord {
+  pub parent: Option<usize>,
+  pub node_type: NodeType,
+  pub selector: String,
+  pub key_name: Option<String>,
+  pub scalar: Option<ScalarValue>,
+  pub has_value: bool,
+  pub location: Location,
+  pub key_location: Location,
+}
+
+fn location_of(lines: &LineIndex, range: TextRange) -> Location {
+  compute_location(lines, range.start().into(), range.end().into())
+}
+
+fn collection_type(node: &SyntaxNode) -> Option<NodeType> {
+  let mut flow = None;
+
+  for descendant in node.descendants() {
+    match descendant.kind() {
+      SyntaxKind::BLOCK_SEQ => return Some(NodeType::Sequence),
+      SyntaxKind::BLOCK_MAP => return Some(NodeType::Map),
+      SyntaxKind::FLOW_SEQ if flow.is_none() => flow = Some(NodeType::Sequence),
+      SyntaxKind::FLOW_MAP if flow.is_none() => flow = Some(NodeType::Map),
+      _ => {}
+    }
+  }
+
+  flow
+}
+
+struct Walker<'a> {
+  lines: &'a LineIndex,
+  records: Vec<NodeRecord>,
+}
+
+impl Walker<'_> {
+  fn push(&mut self, parent: Option<usize>, node: Option<&SyntaxNode>, selector: String, key: Option<(String, Location)>) {
+    let collection = node.and_then(collection_type);
+    let scalar = match (node, collection) {
+      (Some(node), None) => extract_scalar(node),
+      _ => None,
+    };
+    let node_type = match (collection, &scalar) {
+      (Some(node_type), _) => node_type,
+      (None, Some(_)) => NodeType::Scalar,
+      (None, None) => NodeType::NotFound,
+    };
+    let location = match node {
+      Some(node) if parent.is_some() || !matches!(node_type, NodeType::Sequence) => location_of(self.lines, node.text_range()),
+      _ => Location::default(),
+    };
+    let (key_name, key_location) = key.map(|(name, location)| (Some(name), location)).unwrap_or((None, Location::default()));
+
+    let index = self.records.len();
+
+    self.records.push(NodeRecord {
+      parent,
+      node_type,
+      selector: selector.clone(),
+      key_name,
+      scalar,
+      has_value: true,
+      location,
+      key_location,
+    });
+
+    if let Some(node) = node {
+      match node_type {
+        NodeType::Sequence => self.sequence_children(index, node, &selector),
+        NodeType::Map => self.map_children(index, node, &selector),
+        _ => {}
+      }
+    }
+  }
+
+  fn sequence_children(&mut self, index: usize, node: &SyntaxNode, selector: &str) {
+    let entries: Vec<SyntaxNode> = 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()
+    };
+
+    for (position, entry) in entries.iter().enumerate() {
+      self.push(Some(index), Some(entry), format!("{}[{}]", selector, position), None);
+    }
+  }
+
+  fn map_children(&mut self, index: usize, node: &SyntaxNode, selector: &str) {
+    let entries: Vec<(SyntaxNode, Option<SyntaxNode>, Option<SyntaxNode>)> = if let Some(map) = find_block_map(node) {
+      map
+        .entries()
+        .map(|entry| {
+          (
+            entry.syntax().clone(),
+            entry.key().map(|key| key.syntax().clone()),
+            entry.value().map(|value| value.syntax().clone()),
+          )
+        })
+        .collect()
+    } else if let Some(map) = find_flow_map(node) {
+      flow_map_entries(&map)
+        .into_iter()
+        .map(|entry| {
+          (
+            entry.syntax().clone(),
+            entry.key().map(|key| key.syntax().clone()),
+            entry.value().map(|value| value.syntax().clone()),
+          )
+        })
+        .collect()
+    } else {
+      Vec::new()
+    };
+
+    for (entry_node, key_node, value_node) in entries {
+      let Some(key_node) = key_node else { continue };
+      let Some(key_name) = extract_scalar_text(&key_node) else { continue };
+
+      let key_location = location_of(self.lines, key_node.text_range());
+      let child_selector = if selector.is_empty() {
+        key_name.clone()
+      } else {
+        format!("{}.{}", selector, key_name)
+      };
+
+      match value_node {
+        Some(value_node) => self.push(Some(index), Some(&value_node), child_selector, Some((key_name, key_location))),
+        None => self.records.push(NodeRecord {
+          parent: Some(index),
+          node_type: NodeType::Scalar,
+          selector: child_selector,
+          key_name: Some(key_name),
+          scalar: None,
+          has_value: false,
+          location: location_of(self.lines, entry_node.text_range()),
+          key_location,
+        }),
+      }
+    }
+  }
+}
+
+impl Document {
+  pub fn node_records(&self) -> Vec<NodeRecord> {
+    let mut walker = Walker {
+      lines: self.line_index(),
+      records: Vec::new(),
+    };
+
+    if let Some(document) = Root::cast(self.root.clone()).and_then(|root| root.documents().next()) {
+      walker.push(None, Some(document.syntax()), String::new(), None);
+    }
+
+    walker.records
+  }
+}