yerba 0.7.2 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f244827c16c50ecb2f86a8ba94220e92dd49967527330a5a9d0544517b88d7
-  data.tar.gz: 1be11c5a28e591c0511851144508d85e0df4a0b423087affc3f62f4166491713
+  metadata.gz: bfa98c0309844cc745efbdea0a559825a797ca9eba6eaf2d63e39b2e5098333c
+  data.tar.gz: 270f11efd66edf472dba1a5a524db66bcdc24f1eba081c4e5b267853f275111b
 SHA512:
-  metadata.gz: e34070fd0393841cebee7d98a86f6fd7e1608585acb0047a5456f0411813aecdc3ccda1798a83302bcf7859c4efc116fd72d3deeadfeb9ca3fbeb5e5e1ee4d33
-  data.tar.gz: 1378d5c099549a33d415d2dc754fba875449c1a440bb71487e697f0e2591635d998db4a7373f4633523d1e1a3c84b8bcf3738f0290c3cc9e5a3c6c918c007a09
+  metadata.gz: 2bf52ab64c03b3eaeafaefe547b4cbe3cf67c21c19025aa21da00afe4e36edbc2d8bf3ae33ce06d744fa8616da37aed189e7e91afab3cc904fec63151aeef667
+  data.tar.gz: edc83ce4ee21753401e258deb33e54c7a206c13ab8b909a9d54595295e396caf0a3eaa58a33746205d5a955d8b62d04da0e9473423adcf118bc1a1cd6a955d67

data/ext/yerba/yerba.c

@@ -986,10 +986,12 @@ static VALUE collection_s_get(VALUE self, VALUE pattern, VALUE path) {
 
     VALUE line = rb_hash_aref(item, rb_str_new_cstr("line"));
     VALUE kwargs = rb_hash_new();
+    VALUE location = rb_hash_aref(item, rb_str_new_cstr("location"));
 
     rb_hash_aset(kwargs, ID2SYM(rb_intern("selector")), selector);
     if (!NIL_P(file_path)) rb_hash_aset(kwargs, ID2SYM(rb_intern("file_path")), file_path);
     if (!NIL_P(line)) rb_hash_aset(kwargs, ID2SYM(rb_intern("line")), line);
+    if (!NIL_P(location)) rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
 
     if (strcmp(type_str, "scalar") == 0) {
       VALUE text = rb_hash_aref(item, rb_str_new_cstr("text"));

data/lib/yerba/map.rb

@@ -123,6 +123,28 @@ module Yerba
       end
     end
 
+    # Deletes a key from the map, or deletes the entire map node from the document.
+    #
+    # When +key+ is given and the map is connected to a document, deletes that key
+    # from the map in the YAML document. When no +key+ is given and the map is
+    # connected, removes the entire map node at its selector path. When not connected
+    # to a document, delegates to the underlying Hash.
+    #
+    # Returns +self+.
+    #
+    #   # Delete a specific key from a connected map:
+    #   document = Yerba::Document.parse(<<~YAML)
+    #     database:
+    #       host: localhost
+    #       pool: 10
+    #   YAML
+    #
+    #   document["database"].delete("pool")
+    #   document.to_s # => "database:\n  host: localhost\n"
+    #
+    #   # Delete the entire map node:
+    #   document["database"].delete
+    #   document.to_s # => "{}\n"
     def delete(key = nil)
       if key && connected?
         new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"

data/lib/yerba/node.rb

@@ -36,14 +36,20 @@ module Yerba
         instance
       end
 
-      def from(file_path:, selector:, line: nil, **attributes)
+      def from(file_path:, selector:, line: nil, location: nil, **attributes)
         instance = allocate
 
-        instance.send(:init_node, nil, selector, nil, nil, file_path, line)
+        instance.send(:init_node, nil, selector, coerce_location(location), nil, file_path, line)
         instance.send(:init_from, **attributes) if instance.respond_to?(:init_from, true)
 
         instance
       end
+
+      def coerce_location(location)
+        return location unless location.is_a?(Hash)
+
+        Location.new(**location.transform_keys(&:to_sym))
+      end
     end
 
     def self.included(base)

data/lib/yerba/sequence.rb

@@ -258,6 +258,21 @@ module Yerba
       self
     end
 
+    # Deletes the entire sequence node from the YAML document.
+    #
+    # Removes the sequence at its selector path from the parent document.
+    # Has no effect if the sequence is not connected to a document.
+    #
+    # Returns the document, or +nil+ if the sequence is not connected to a document.
+    #
+    #   document = Yerba::Document.parse(<<~YAML)
+    #     items:
+    #       - name: Ruby
+    #       - name: Rust
+    #   YAML
+    #
+    #   document["items"].delete
+    #   document.to_s # => "{}\n"
     def delete
       document&.delete(@selector)
     end

data/lib/yerba/version.rb

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

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.7.2"
+version = "0.7.4"
 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

@@ -11,12 +11,9 @@ impl Document {
 
     if source_parent == destination_parent {
       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 parent_node = self.navigate(parent_path)?;
+      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()))?;
@@ -42,14 +39,12 @@ impl Document {
 
     match last_segment {
       crate::selector::SelectorSegment::Key(last_key) => {
-        let has_wildcard = selector.has_wildcard() || selector.has_brackets();
+        let has_wildcard = selector.has_wildcard();
+        let has_brackets = selector.has_brackets();
 
-        if parent_path.is_empty() && !has_wildcard {
+        if parent_path.is_empty() && (!has_wildcard || !has_brackets) {
           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()))?;
 
@@ -66,38 +61,30 @@ impl Document {
           return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
         }
 
-        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()))?;
-
+        if parent_nodes.len() == 1 && (!has_wildcard || !has_brackets) {
+          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()))?;
 
+          if map.entries().count() == 1 {
+            return self.collapse_to_empty_flow_map(&parent_nodes[0]);
+          }
+
           return self.remove_map_entry(&entry);
         }
 
         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(());
-        }
+        let edits = ranges.into_iter().map(|range| (range, String::new())).collect();
 
-        ranges.reverse();
-
-        for range in ranges {
-          self.apply_edit(range, "")?;
-        }
-
-        Ok(())
+        self.apply_edits(edits)
       }
 
       crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_path, *index),
@@ -108,10 +95,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()
@@ -124,6 +108,10 @@ impl Document {
       })
       .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, value)))?;
 
+    if sequence.entries().count() == 1 {
+      return self.collapse_to_empty_flow_sequence(&current_node);
+    }
+
     self.remove_node(target_entry.syntax())
   }
 
@@ -132,10 +120,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();
 
@@ -143,6 +128,67 @@ impl Document {
       return Err(YerbaError::IndexOutOfBounds(index, entries.len()));
     }
 
+    if entries.len() == 1 {
+      return self.collapse_to_empty_flow_sequence(&current_node);
+    }
+
     self.remove_node(entries[index].syntax())
   }
+
+  fn collapse_to_empty_flow_map(&mut self, current_node: &SyntaxNode) -> Result<(), YerbaError> {
+    let map_value = current_node
+      .descendants()
+      .find(|descendant| descendant.kind() == SyntaxKind::BLOCK_MAP_VALUE)
+      .ok_or_else(|| YerbaError::SelectorNotFound("Expected a map value".to_string()))?;
+
+    let mut range = map_value.text_range();
+
+    if let Some(previous) = map_value.prev_sibling_or_token().and_then(|element| element.into_token()) {
+      if previous.kind() == SyntaxKind::WHITESPACE && previous.text().contains('\n') {
+        range = TextRange::new(previous.text_range().start(), range.end());
+      }
+    }
+
+    self.apply_edit(range, " {}")
+  }
+
+  fn collapse_to_empty_flow_sequence(&mut self, current_node: &SyntaxNode) -> Result<(), YerbaError> {
+    if current_node.kind() == SyntaxKind::BLOCK_MAP_VALUE {
+      let mut range = current_node.text_range();
+      let mut comment_text: Option<String> = None;
+      let mut sibling = current_node.prev_sibling_or_token();
+
+      while let Some(ref element) = sibling {
+        match element {
+          rowan::NodeOrToken::Token(token) => {
+            if token.kind() == SyntaxKind::COMMENT {
+              comment_text = Some(token.text().to_string());
+              range = TextRange::new(token.text_range().start(), range.end());
+              sibling = token.prev_sibling_or_token();
+            } else if token.kind() == SyntaxKind::WHITESPACE {
+              range = TextRange::new(token.text_range().start(), range.end());
+              sibling = token.prev_sibling_or_token();
+            } else {
+              break;
+            }
+          }
+          _ => break,
+        }
+      }
+
+      let replacement = match comment_text {
+        Some(comment) => format!(" [] {}", comment),
+        None => " []".to_string(),
+      };
+
+      return self.apply_edit(range, &replacement);
+    }
+
+    let sequence = current_node
+      .descendants()
+      .find_map(BlockSeq::cast)
+      .ok_or_else(|| YerbaError::NotASequence("Expected a sequence".to_string()))?;
+
+    self.apply_edit(removal_range(sequence.syntax()), "[]")
+  }
 }

data/rust/src/document/get.rs

@@ -83,15 +83,17 @@ 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
       .navigate_all_compact(dot_path)
       .iter()
       .map(|node| {
-        let offset: usize = node.text_range().start().into();
-        let line = source[..offset].matches('\n').count() + 1;
+        let range = node.text_range();
+        let offset: usize = range.start().into();
+        let line = line_at(&source, offset);
+        let location = compute_location(&source, offset, range.end().into());
         let selector = node_selector(node);
         let is_scalar = !node
           .descendants()
@@ -108,13 +110,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",
           }
         };
@@ -126,6 +123,7 @@ impl Document {
           file_path: file_path.clone(),
           selector,
           line,
+          location,
         }
       })
       .collect()
@@ -142,7 +140,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 +362,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 +373,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 +401,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")