yerba 0.7.1-x86_64-linux-gnu → 0.7.3-x86_64-linux-gnu

data/rust/src/document/insert.rs

@@ -60,10 +60,7 @@ impl Document {
     let quote_style = self.detect_sequence_quote_style(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 sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
 
     let entries: Vec<_> = sequence.entries().collect();
 
@@ -81,38 +78,7 @@ impl Document {
 
     for json_value in json_values {
       let yaml_text = crate::yaml_writer::json_to_yaml_text(json_value, &quote_style, 0);
-
-      let new_item = if yaml_text.contains('\n') {
-        let item_indent = format!("{}  ", indent);
-        let lines: Vec<&str> = yaml_text.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!("- {}", yaml_text)
-      };
+      let new_item = Self::format_sequence_item(&yaml_text, &indent);
 
       new_text.push_str(&format!("\n{}{}", indent, new_item));
     }
@@ -126,7 +92,7 @@ impl Document {
     Self::validate_path(dot_path)?;
 
     if let Ok(current_node) = self.navigate(dot_path) {
-      if current_node.descendants().find_map(BlockSeq::cast).is_some()
+      if find_block_sequence(&current_node).is_some()
         || matches!(self.get_value(dot_path).as_ref(), Some(yaml_serde::Value::Sequence(sequence)) if sequence.is_empty())
       {
         return self.insert_sequence_item(dot_path, value, position);
@@ -152,7 +118,7 @@ impl Document {
           None => continue,
         };
 
-        let map = match node.descendants().find_map(BlockMap::cast) {
+        let map = match find_block_map(&node) {
           Some(map) => map,
           None => {
             let has_empty_flow_map = node
@@ -186,42 +152,13 @@ impl Document {
 
         let start_col = {
           let offset: usize = first_entry.syntax().text_range().start().into();
-          let source = self.to_string();
-          let before = &source[..offset];
+          let source = self.source_text();
 
-          offset - before.rfind('\n').map(|p| p + 1).unwrap_or(0)
+          column_at(&source, offset)
         };
 
         let indent = " ".repeat(start_col);
-
-        let is_block_value = value.contains('\n') || value.starts_with("- ");
-        let new_entry_text = if is_block_value {
-          let value_indent = format!("{}  ", indent);
-          let lines: Vec<&str> = value.lines().collect();
-
-          let min_indent = lines
-            .iter()
-            .filter(|line| !line.trim().is_empty())
-            .map(|line| line.len() - line.trim_start().len())
-            .min()
-            .unwrap_or(0);
-
-          let indented_lines: Vec<String> = lines
-            .iter()
-            .map(|line| {
-              if line.trim().is_empty() {
-                String::new()
-              } else {
-                let relative = &line[min_indent..];
-                format!("{}{}", value_indent, relative)
-              }
-            })
-            .collect();
-
-          format!("{}:\n{}", key, indented_lines.join("\n"))
-        } else {
-          format!("{}: {}", key, value)
-        };
+        let new_entry_text = Self::format_map_entry(key, value, &indent);
 
         match &position {
           InsertPosition::After(target_key) => {
@@ -265,7 +202,7 @@ impl Document {
   fn insert_sequence_item(&mut self, dot_path: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
 
-    let Some(sequence) = current_node.descendants().find_map(BlockSeq::cast) else {
+    let Some(sequence) = find_block_sequence(&current_node) else {
       if matches!(self.get_value(dot_path).as_ref(), Some(yaml_serde::Value::Sequence(sequence)) if sequence.is_empty()) {
         return self.replace_empty_inline_sequence(dot_path, value);
       }
@@ -285,37 +222,7 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    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)
-    };
+    let new_item = Self::format_sequence_item(value, &indent);
 
     match position {
       InsertPosition::Last => {
@@ -413,7 +320,7 @@ impl Document {
   fn insert_map_key(&mut self, dot_path: &str, key: &str, value: &str, position: InsertPosition) -> Result<(), YerbaError> {
     let current_node = self.navigate(dot_path)?;
 
-    let map = match current_node.descendants().find_map(BlockMap::cast) {
+    let map = match find_block_map(&current_node) {
       Some(map) => map,
       None => {
         let flow_map = current_node.descendants().find(|descendant| descendant.kind() == SyntaxKind::FLOW_MAP);
@@ -449,34 +356,7 @@ impl Document {
       .map(|entry| preceding_whitespace_indent(entry.syntax()))
       .unwrap_or_default();
 
-    let is_block_value = value.contains('\n') || value.starts_with("- ");
-    let new_entry_text = if is_block_value {
-      let value_indent = format!("{}  ", indent);
-      let lines: Vec<&str> = value.lines().collect();
-
-      let min_indent = lines
-        .iter()
-        .filter(|line| !line.trim().is_empty())
-        .map(|line| line.len() - line.trim_start().len())
-        .min()
-        .unwrap_or(0);
-
-      let indented_lines: Vec<String> = lines
-        .iter()
-        .map(|line| {
-          if line.trim().is_empty() {
-            String::new()
-          } else {
-            let relative = &line[min_indent..];
-            format!("{}{}", value_indent, relative)
-          }
-        })
-        .collect();
-
-      format!("{}:\n{}", key, indented_lines.join("\n"))
-    } else {
-      format!("{}: {}", key, value)
-    };
+    let new_entry_text = Self::format_map_entry(key, value, &indent);
 
     match position {
       InsertPosition::Last => {
@@ -561,7 +441,7 @@ impl Document {
 
       let range = flow_map.text_range();
 
-      let source = self.to_string();
+      let source = self.source_text();
       let start: usize = range.start().into();
       let before = &source[..start];
       let trimmed_length = before.trim_end_matches([' ', '\n']).len();
@@ -575,10 +455,7 @@ impl Document {
     let (parent_path, map_key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
     let parent_node = self.navigate(parent_path)?;
 
-    let map = parent_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = find_block_map(&parent_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
     let entry = find_entry_by_key(&map, map_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
     let entry_indent = preceding_whitespace_indent(entry.syntax());
@@ -601,14 +478,14 @@ impl Document {
   fn replace_empty_inline_sequence(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
     if dot_path.is_empty() {
       let current_node = self.navigate(dot_path)?;
-      let flow_seq = current_node
+      let flow_sequence = current_node
         .descendants()
         .find(|descendant| descendant.kind() == SyntaxKind::FLOW_SEQ)
         .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
 
       let new_item = Self::format_sequence_item(value, "");
-      let range = flow_seq.text_range();
-      let source = self.to_string();
+      let range = flow_sequence.text_range();
+      let source = self.source_text();
       let start: usize = range.start().into();
       let before = &source[..start];
 
@@ -624,10 +501,7 @@ impl Document {
     let (parent_path, key) = dot_path.rsplit_once('.').unwrap_or(("", dot_path));
     let parent_node = self.navigate(parent_path)?;
 
-    let map = parent_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+    let map = find_block_map(&parent_node).ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
 
     let entry = find_entry_by_key(&map, key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
     let item_indent = format!("{}  ", preceding_whitespace_indent(entry.syntax()));
@@ -656,7 +530,7 @@ impl Document {
   }
 
   fn trailing_inline_comment(&self, node: &SyntaxNode) -> Option<(String, rowan::TextSize)> {
-    let source = self.root.text().to_string();
+    let source = self.source_text();
     let start: usize = node.text_range().end().into();
     let rest = &source[start..];
     let line_end = rest.find('\n').unwrap_or(rest.len());
@@ -670,6 +544,38 @@ impl Document {
     Some((trailing[comment_start..].to_string(), rowan::TextSize::from((start + line_end) as u32)))
   }
 
+  fn format_map_entry(key: &str, value: &str, indent: &str) -> String {
+    let is_block_value = value.contains('\n') || value.starts_with("- ");
+
+    if !is_block_value {
+      return format!("{}: {}", key, value);
+    }
+
+    let value_indent = format!("{}  ", indent);
+    let lines: Vec<&str> = value.lines().collect();
+
+    let min_indent = lines
+      .iter()
+      .filter(|line| !line.trim().is_empty())
+      .map(|line| line.len() - line.trim_start().len())
+      .min()
+      .unwrap_or(0);
+
+    let indented_lines: Vec<String> = lines
+      .iter()
+      .map(|line| {
+        if line.trim().is_empty() {
+          String::new()
+        } else {
+          let relative = &line[min_indent..];
+          format!("{}{}", value_indent, relative)
+        }
+      })
+      .collect();
+
+    format!("{}:\n{}", key, indented_lines.join("\n"))
+  }
+
   fn format_sequence_item(value: &str, indent: &str) -> String {
     if value.contains('\n') {
       let item_indent = format!("{}  ", indent);

data/rust/src/document/mod.rs

@@ -34,8 +34,9 @@ use crate::error::YerbaError;
 use crate::QuoteStyle;
 
 use crate::syntax::{
-  dedent_block_scalar, extract_scalar, extract_scalar_text, find_entry_by_key, find_scalar_token, format_scalar_value, is_map_key, is_yaml_non_string,
-  preceding_whitespace_indent, preceding_whitespace_token, removal_range, unescape_double_quoted, unescape_single_quoted, ScalarValue,
+  column_at, dedent_block_scalar, extract_scalar, extract_scalar_text, find_block_map, find_block_sequence, find_entry_by_key, find_scalar_token,
+  first_collection, format_scalar_value, is_map_key, is_yaml_non_string, line_at, line_start_at, preceding_whitespace_indent, preceding_whitespace_token,
+  raw_scalar_value, removal_range, FirstCollection, ScalarValue,
 };
 
 #[derive(Debug, Clone)]
@@ -148,17 +149,22 @@ impl Document {
       .as_ref()
       .ok_or_else(|| YerbaError::IoError(std::io::Error::new(std::io::ErrorKind::NotFound, "no file path associated with this document")))?;
 
-    fs::write(path, self.to_string())?;
+    fs::write(path, self.source_text())?;
 
     Ok(())
   }
 
   pub fn save_to(&self, path: impl AsRef<Path>) -> Result<(), YerbaError> {
-    fs::write(path, self.to_string())?;
+    fs::write(path, self.source_text())?;
 
     Ok(())
   }
 
+  pub fn source(&self, dot_path: &str) -> Result<String, YerbaError> {
+    let node = self.navigate(dot_path)?;
+    Ok(node.text().to_string())
+  }
+
   pub fn navigate(&self, dot_path: &str) -> Result<SyntaxNode, YerbaError> {
     Self::validate_path(dot_path)?;
 
@@ -203,7 +209,7 @@ impl Document {
     let mut current_nodes: Vec<Option<SyntaxNode>> = vec![Some(document.syntax().clone())];
 
     if parsed.is_empty() {
-      if let Some(sequence) = document.syntax().descendants().find_map(BlockSeq::cast) {
+      if let Some(sequence) = find_block_sequence(document.syntax()) {
         current_nodes = sequence.entries().map(|entry| Some(entry.syntax().clone())).collect();
       }
 
@@ -291,7 +297,20 @@ impl Document {
   }
 
   fn insert_after_node(&mut self, node: &SyntaxNode, text: &str) -> Result<(), YerbaError> {
-    let position = node.text_range().end();
+    let end: usize = node.text_range().end().into();
+    let source = self.source_text();
+
+    let rest = &source[end..];
+    let line_end = rest.find('\n').unwrap_or(rest.len());
+    let trailing = &rest[..line_end];
+
+    let position = if let Some(comment_start) = trailing.find('#') {
+      let _ = comment_start;
+      rowan::TextSize::from((end + line_end) as u32)
+    } else {
+      node.text_range().end()
+    };
+
     let range = TextRange::new(position, position);
 
     self.apply_edit(range, text)
@@ -407,15 +426,37 @@ impl Document {
   }
 
   fn apply_edit(&mut self, range: TextRange, replacement: &str) -> Result<(), YerbaError> {
-    let source = self.root.text().to_string();
-    let start: usize = range.start().into();
-    let end: usize = range.end().into();
+    self.apply_edits(vec![(range, replacement.to_string())])
+  }
+
+  fn apply_edits(&mut self, mut edits: Vec<(TextRange, String)>) -> Result<(), YerbaError> {
+    if edits.is_empty() {
+      return Ok(());
+    }
+
+    edits.sort_by_key(|(range, _)| std::cmp::Reverse(range.start()));
+
+    let mut new_source = self.source_text();
 
-    let mut new_source = source;
-    new_source.replace_range(start..end, replacement);
+    for (range, replacement) in edits {
+      let start: usize = range.start().into();
+      let end: usize = range.end().into();
 
+      new_source.replace_range(start..end, &replacement);
+    }
+
+    self.reparse(&new_source)
+  }
+
+  fn source_text(&self) -> String {
+    self.root.text().to_string()
+  }
+
+  fn reparse(&mut self, new_source: &str) -> Result<(), YerbaError> {
+    let document = Self::parse(new_source)?;
     let path = self.path.take();
-    *self = Self::parse(&new_source)?;
+
+    *self = document;
     self.path = path;
 
     Ok(())
@@ -440,8 +481,8 @@ fn check_duplicate_keys(root: &SyntaxNode) -> Result<(), YerbaError> {
 
             if let Some(&first_offset) = seen.get(&key_text) {
               let source = root.text().to_string();
-              let first_line = source[..first_offset.into()].matches('\n').count() + 1;
-              let duplicate_line = source[..usize::from(offset)].matches('\n').count() + 1;
+              let first_line = line_at(&source, first_offset.into());
+              let duplicate_line = line_at(&source, offset.into());
               let line_content = source.lines().nth(duplicate_line - 1).unwrap_or("").to_string();
 
               return Err(YerbaError::DuplicateKey {
@@ -466,21 +507,13 @@ pub(crate) fn compute_location(source: &str, start_offset: usize, end_offset: us
   let start = start_offset.min(source.len());
   let end = end_offset.min(source.len());
 
-  let before_start = &source[..start];
-  let start_line = before_start.chars().filter(|c| *c == '\n').count() + 1;
-  let start_column = start - before_start.rfind('\n').map(|p| p + 1).unwrap_or(0);
-
-  let before_end = &source[..end];
-  let end_line = before_end.chars().filter(|c| *c == '\n').count() + 1;
-  let end_column = end - before_end.rfind('\n').map(|p| p + 1).unwrap_or(0);
-
   Location {
     start_offset: start,
     end_offset: end,
-    start_line,
-    start_column,
-    end_line,
-    end_column,
+    start_line: line_at(source, start),
+    start_column: column_at(source, start),
+    end_line: line_at(source, end),
+    end_column: column_at(source, end),
   }
 }
 
@@ -515,39 +548,31 @@ pub fn collect_selectors(value: &yaml_serde::Value, prefix: &str, selectors: &mu
 }
 
 pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::Value {
-  if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-    let map_position = node.descendants().find_map(BlockMap::cast).map(|map| map.syntax().text_range().start());
-
-    let sequence_position = sequence.syntax().text_range().start();
-
-    if map_position.is_none() || sequence_position <= map_position.unwrap() {
+  match first_collection(node) {
+    Some(FirstCollection::Sequence(sequence)) => {
       let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
       return yaml_serde::Value::Sequence(values);
     }
-  }
 
-  if let Some(map) = node.descendants().find_map(BlockMap::cast) {
-    let mut mapping = yaml_serde::Mapping::new();
+    Some(FirstCollection::Map(map)) => {
+      let mut mapping = yaml_serde::Mapping::new();
 
-    for entry in map.entries() {
-      let key = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
-
-      let value = entry
-        .value()
-        .map(|value_node| node_to_yaml_value(value_node.syntax()))
-        .unwrap_or(yaml_serde::Value::Null);
+      for entry in map.entries() {
+        let key = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
 
-      mapping.insert(yaml_serde::Value::String(key), value);
-    }
+        let value = entry
+          .value()
+          .map(|value_node| node_to_yaml_value(value_node.syntax()))
+          .unwrap_or(yaml_serde::Value::Null);
 
-    return yaml_serde::Value::Mapping(mapping);
-  }
+        mapping.insert(yaml_serde::Value::String(key), value);
+      }
 
-  if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-    let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+      return yaml_serde::Value::Mapping(mapping);
+    }
 
-    return yaml_serde::Value::Sequence(values);
+    None => {}
   }
 
   if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
@@ -603,17 +628,13 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::Value {
 }
 
 pub(crate) fn parse_condition(condition: &str) -> Option<(String, &str, String)> {
-  let (left, operator, right) = if let Some(index) = condition.find(" not_contains ") {
-    (condition[..index].trim(), "not_contains", condition[index + 14..].trim())
-  } else if let Some(index) = condition.find(" contains ") {
-    (condition[..index].trim(), "contains", condition[index + 10..].trim())
-  } else if let Some(index) = condition.find("!=") {
-    (condition[..index].trim(), "!=", condition[index + 2..].trim())
-  } else if let Some(index) = condition.find("==") {
-    (condition[..index].trim(), "==", condition[index + 2..].trim())
-  } else {
-    return None;
-  };
+  const OPERATORS: [(&str, &str); 4] = [(" not_contains ", "not_contains"), (" contains ", "contains"), ("!=", "!="), ("==", "==")];
+
+  let (left, operator, right) = OPERATORS.iter().find_map(|(pattern, operator)| {
+    condition
+      .find(pattern)
+      .map(|index| (condition[..index].trim(), *operator, condition[index + pattern.len()..].trim()))
+  })?;
 
   let right = right
     .trim_start_matches('"')
@@ -649,7 +670,7 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
 
   match segment {
     SelectorSegment::AllItems => {
-      if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+      if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().map(|entry| entry.syntax().clone()).collect()
       } else {
         Vec::new()
@@ -657,7 +678,7 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     }
 
     SelectorSegment::Index(index) => {
-      if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+      if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().nth(*index).map(|entry| vec![entry.syntax().clone()]).unwrap_or_default()
       } else {
         Vec::new()
@@ -665,7 +686,7 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     }
 
     SelectorSegment::Key(key) => {
-      if let Some(map) = node.descendants().find_map(BlockMap::cast) {
+      if let Some(map) = find_block_map(node) {
         if let Some(entry) = find_entry_by_key(&map, key) {
           if let Some(value) = entry.value() {
             return vec![value.syntax().clone()];
@@ -680,23 +701,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);
-  let mut current_nodes = vec![node.clone()];
-
-  for segment in parsed.segments() {
-    let mut next_nodes = Vec::new();
 
-    for current in &current_nodes {
-      next_nodes.extend(resolve_segment(current, segment));
-    }
-
-    current_nodes = next_nodes;
-
-    if current_nodes.is_empty() {
-      break;
-    }
-  }
-
-  current_nodes
+  navigate_remaining(node, parsed.segments())
 }
 
 #[derive(Debug, Clone)]

data/rust/src/document/schema.rs

@@ -31,7 +31,7 @@ impl Document {
       crate::schema::validate_value(&value, schema)
     };
 
-    let source = self.to_string();
+    let source = self.source_text();
 
     for error in &mut errors {
       if !error.path.is_empty() {