yerba 0.9.1-arm-linux-gnu → 0.10.0-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,35 @@ 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()
   }
 }
 
@@ -103,6 +133,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 +159,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 +188,7 @@ pub struct Document {
   root: SyntaxNode,
   path: Option<PathBuf>,
   generation: u64,
+  line_index: OnceLock<LineIndex>,
 }
 
 impl Document {
@@ -146,6 +201,7 @@ impl Document {
       root: tree,
       path: None,
       generation: NEXT_GENERATION.fetch_add(1, Ordering::Relaxed),
+      line_index: OnceLock::new(),
     })
   }
 
@@ -181,49 +237,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 +355,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 +543,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 +598,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 +697,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 +782,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 +839,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())
 }

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
+  }
+}

data/rust/src/document/schema.rs

@@ -2,10 +2,10 @@ use super::*;
 
 impl Document {
   pub fn validate_schema(&self, schema: &serde_json::Value, items: bool, selector: Option<&str>) -> Vec<crate::schema::ValidationError> {
-    let path = selector.unwrap_or("");
-    let has_wildcard = crate::selector::Selector::parse(path).has_wildcard();
+    let selector = selector.unwrap_or("");
+    let has_wildcard = crate::selector::Selector::parse(selector).has_wildcard();
 
-    let value = match self.get_value(path) {
+    let value = match self.get_value(selector) {
       Some(value) => crate::json::yaml_to_json(&value),
       None => return vec![],
     };
@@ -62,12 +62,12 @@ fn json_pointer_to_selector(pointer: &str) -> String {
         segment.to_string()
       }
     })
-    .fold(String::new(), |mut path, segment| {
-      if !path.is_empty() && !segment.starts_with('[') {
-        path.push('.');
+    .fold(String::new(), |mut selector, segment| {
+      if !selector.is_empty() && !segment.starts_with('[') {
+        selector.push('.');
       }
 
-      path.push_str(&segment);
-      path
+      selector.push_str(&segment);
+      selector
     })
 }