yerba 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f244827c16c50ecb2f86a8ba94220e92dd49967527330a5a9d0544517b88d7
-  data.tar.gz: 1be11c5a28e591c0511851144508d85e0df4a0b423087affc3f62f4166491713
+  metadata.gz: 4305ac41ddb57b2c537679a4924163c87b715418e2e4c9d80ce9f4dc2979ebd4
+  data.tar.gz: 425313784c600c32d9b3a054beaaf152550772a804fa40c22f96bd052852ec72
 SHA512:
-  metadata.gz: e34070fd0393841cebee7d98a86f6fd7e1608585acb0047a5456f0411813aecdc3ccda1798a83302bcf7859c4efc116fd72d3deeadfeb9ca3fbeb5e5e1ee4d33
-  data.tar.gz: 1378d5c099549a33d415d2dc754fba875449c1a440bb71487e697f0e2591635d998db4a7373f4633523d1e1a3c84b8bcf3738f0290c3cc9e5a3c6c918c007a09
+  metadata.gz: bf1fdc98836e461bd02830a07008ba86df5fd71d22d8ff478e042c5c36e89caad9cb006e5c20ac191a3c24c11fe33add62d12109e1269225464247093d549142
+  data.tar.gz: 85fa2fac4eff2cf7662a2549b6b5dac953e4a3646e71b405774ebd39ec2200604429ea8cd11724385ae801248a7250e94c53a4cd41b9c4f126b6d93f6ec8fa71

data/lib/yerba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yerba
-  VERSION = "0.7.2"
+  VERSION = "0.7.3"
 end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.7.2"
+version = "0.7.3"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"

data/rust/src/document/condition.rs

@@ -11,7 +11,7 @@ impl Document {
   }
 
   pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(yaml_serde::Value, String, usize)> {
-    let source = self.root.text().to_string();
+    let source = self.source_text();
 
     self
       .navigate_all_compact(dot_path)
@@ -19,7 +19,7 @@ impl Document {
       .filter(|node| self.evaluate_condition_on_node(node, condition))
       .map(|node| {
         let offset: usize = node.text_range().start().into();
-        let line = source[..offset].matches('\n').count() + 1;
+        let line = line_at(&source, offset);
 
         (node_to_yaml_value(node), super::get::node_selector(node), line)
       })
@@ -52,7 +52,7 @@ impl Document {
         }
 
         for node in &target_nodes {
-          if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+          if let Some(sequence) = find_block_sequence(node) {
             for entry in sequence.entries() {
               if let Some(text) = entry.flow().and_then(|flow| extract_scalar_text(flow.syntax())) {
                 if text == right {
@@ -67,7 +67,7 @@ impl Document {
       }
       "not_contains" => {
         for node in &target_nodes {
-          if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+          if let Some(sequence) = find_block_sequence(node) {
             for entry in sequence.entries() {
               if let Some(text) = entry.flow().and_then(|flow| extract_scalar_text(flow.syntax())) {
                 if text == right {

data/rust/src/document/delete.rs

@@ -13,10 +13,7 @@ impl Document {
       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()
-        .find_map(BlockMap::cast)
-        .ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+      let map = find_block_map(&parent_node).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
 
       let entry = find_entry_by_key(&map, source_key).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
       let key_node = entry.key().ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
@@ -46,10 +43,7 @@ impl Document {
 
         if parent_path.is_empty() && !has_wildcard {
           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, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
@@ -67,10 +61,7 @@ impl Document {
         }
 
         if parent_nodes.len() == 1 && !has_wildcard {
-          let map = parent_nodes[0]
-            .descendants()
-            .find_map(BlockMap::cast)
-            .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+          let map = find_block_map(&parent_nodes[0]).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
           let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
@@ -80,24 +71,16 @@ impl Document {
         let mut ranges: Vec<TextRange> = Vec::new();
 
         for parent_node in &parent_nodes {
-          if let Some(map) = parent_node.descendants().find_map(BlockMap::cast) {
+          if let Some(map) = find_block_map(parent_node) {
             if let Some(entry) = find_entry_by_key(&map, last_key) {
               ranges.push(removal_range(entry.syntax()));
             }
           }
         }
 
-        if ranges.is_empty() {
-          return Ok(());
-        }
-
-        ranges.reverse();
-
-        for range in ranges {
-          self.apply_edit(range, "")?;
-        }
+        let edits = ranges.into_iter().map(|range| (range, String::new())).collect();
 
-        Ok(())
+        self.apply_edits(edits)
       }
 
       crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_path, *index),
@@ -108,10 +91,7 @@ impl Document {
   pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
     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 target_entry = sequence
       .entries()
@@ -132,10 +112,7 @@ impl Document {
 
     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();
 

data/rust/src/document/get.rs

@@ -83,7 +83,7 @@ impl Document {
   }
 
   pub fn get_all_located(&self, dot_path: &str) -> Vec<LocatedNode> {
-    let source = self.root.text().to_string();
+    let source = self.source_text();
     let file_path = self.path.as_ref().map(|p| p.to_string_lossy().to_string());
 
     self
@@ -91,7 +91,7 @@ impl Document {
       .iter()
       .map(|node| {
         let offset: usize = node.text_range().start().into();
-        let line = source[..offset].matches('\n').count() + 1;
+        let line = line_at(&source, offset);
         let selector = node_selector(node);
         let is_scalar = !node
           .descendants()
@@ -108,13 +108,8 @@ impl Document {
         let node_type = if is_scalar {
           "scalar"
         } else {
-          let map_pos = node.descendants().find_map(BlockMap::cast).map(|m| m.syntax().text_range().start());
-          let seq_pos = node.descendants().find_map(BlockSeq::cast).map(|s| s.syntax().text_range().start());
-
-          match (map_pos, seq_pos) {
-            (Some(m), Some(s)) if s < m => "sequence",
-            (Some(_), _) => "map",
-            (None, Some(_)) => "sequence",
+          match first_collection(node) {
+            Some(FirstCollection::Sequence(_)) => "sequence",
             _ => "map",
           }
         };
@@ -142,7 +137,7 @@ impl Document {
 
   pub fn get_node_info(&self, dot_path: &str) -> NodeInfo {
     let selector = crate::selector::Selector::parse(dot_path);
-    let source = self.root.text().to_string();
+    let source = self.source_text();
 
     let (location, key_name, key_location) = self.resolve_location(dot_path, &source);
 
@@ -364,7 +359,7 @@ impl Document {
       self.navigate(parent_path).ok()?
     };
 
-    let map = parent_node.descendants().find_map(BlockMap::cast)?;
+    let map = find_block_map(&parent_node)?;
 
     find_entry_by_key(&map, last_key).map(|entry| entry.syntax().clone())
   }
@@ -375,7 +370,7 @@ impl Document {
       Err(_) => return Vec::new(),
     };
 
-    let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
+    let sequence = match find_block_sequence(&current_node) {
       Some(sequence) => sequence,
       None => return Vec::new(),
     };
@@ -403,17 +398,16 @@ impl Document {
   pub fn get_sequence_indent(&self, dot_path: &str) -> Option<&'static str> {
     let current_node = self.navigate(dot_path).ok()?;
 
-    let sequence = current_node.descendants().find_map(BlockSeq::cast)?;
+    let sequence = find_block_sequence(&current_node)?;
     let first_entry = sequence.entries().next()?;
 
     let entry_indent = preceding_whitespace_indent(first_entry.syntax());
 
     let entry_node = current_node.ancestors().find(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_ENTRY)?;
 
-    let source = self.root.text().to_string();
+    let source = self.source_text();
     let entry_start: usize = entry_node.text_range().start().into();
-    let line_start = source[..entry_start].rfind('\n').map(|position| position + 1).unwrap_or(0);
-    let key_indent = &source[line_start..entry_start];
+    let key_indent = &source[line_start_at(&source, entry_start)..entry_start];
 
     if entry_indent.len() > key_indent.len() {
       Some("indented")

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);