yerba 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4305ac41ddb57b2c537679a4924163c87b715418e2e4c9d80ce9f4dc2979ebd4
-  data.tar.gz: 425313784c600c32d9b3a054beaaf152550772a804fa40c22f96bd052852ec72
+  metadata.gz: bfa98c0309844cc745efbdea0a559825a797ca9eba6eaf2d63e39b2e5098333c
+  data.tar.gz: 270f11efd66edf472dba1a5a524db66bcdc24f1eba081c4e5b267853f275111b
 SHA512:
-  metadata.gz: bf1fdc98836e461bd02830a07008ba86df5fd71d22d8ff478e042c5c36e89caad9cb006e5c20ac191a3c24c11fe33add62d12109e1269225464247093d549142
-  data.tar.gz: 85fa2fac4eff2cf7662a2549b6b5dac953e4a3646e71b405774ebd39ec2200604429ea8cd11724385ae801248a7250e94c53a4cd41b9c4f126b6d93f6ec8fa71
+  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.3"
+  VERSION = "0.7.4"
 end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.7.3"
+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/delete.rs

@@ -11,8 +11,8 @@ 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 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()))?;
@@ -39,9 +39,10 @@ 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 = find_block_map(&parent_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
@@ -60,11 +61,14 @@ impl Document {
           return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
         }
 
-        if parent_nodes.len() == 1 && !has_wildcard {
+        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);
         }
 
@@ -104,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())
   }
 
@@ -120,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

@@ -90,8 +90,10 @@ impl Document {
       .navigate_all_compact(dot_path)
       .iter()
       .map(|node| {
-        let offset: usize = node.text_range().start().into();
+        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()
@@ -121,6 +123,7 @@ impl Document {
           file_path: file_path.clone(),
           selector,
           line,
+          location,
         }
       })
       .collect()

data/rust/src/document/mod.rs

@@ -19,6 +19,7 @@ pub struct LocatedNode {
   pub file_path: Option<String>,
   pub selector: String,
   pub line: usize,
+  pub location: Location,
 }
 
 use std::fs;

data/rust/src/ffi.rs

@@ -843,6 +843,14 @@ pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *cons
         "node_type": node.node_type,
         "selector": node.selector,
         "line": node.line,
+        "location": {
+          "start_line": node.location.start_line,
+          "start_column": node.location.start_column,
+          "end_line": node.location.end_line,
+          "end_column": node.location.end_column,
+          "start_offset": node.location.start_offset,
+          "end_offset": node.location.end_offset,
+        },
       });
 
       if let Some(file_path) = &node.file_path {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Marco Roth