yerba 0.7.0-arm-linux-gnu → 0.7.2-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9f073429d61bad4b0b383eef994cae92440f77481b6ba6a5f7b8f7a85f045db
-  data.tar.gz: c566361e8250a197c343e665fc53fe6cc3e8646a8a7160164b78d452f1e0b960
+  metadata.gz: 6b4a184098ccba1de65340ff7812ed2e99dd2c4e040f5091cb17a4a1301e55b3
+  data.tar.gz: 923fae627e8e773b8192e82d4860bfa2c2ea28db670c32a67a9125b61485c53f
 SHA512:
-  metadata.gz: e357f906c8546dc093f8ed2b66c4e5eb451995a6226fc8919a14385ca7ca95beddb5b78a7e09fbce1eb48806d4022c3a968aae476d2753329a60bfeebbc45b56
-  data.tar.gz: 6122502751c9844abb03a2fb264a76e9fcdd7b55339cf8882581aeb27fb7c00d6148a84266e94091260ddcd1260aa2a34e1d1a74c1914bbd70a0a55727015df6
+  metadata.gz: 65dcad11c2c0dc109ab61757c64b15724190a9d587e8b1bddc0a5f76d2cae1a7da84a52f2b785bbd2a9cbf22d8e42f07174b4e5383c0e4a54d3e8275aa6efb47
+  data.tar.gz: 5aa046c0d8357e3acbc732faacb7950a3db6e233780ed3a653f89405c8eef64998a918b72711a125a485dad5448ad8251f38b9b643250459d428d1b9d6df3428

data/ext/yerba/include/yerba.h

@@ -72,6 +72,11 @@ void yerba_document_free(struct Document *document);
 
 struct YerbaGetResult yerba_document_get(const struct Document *document, const char *path);
 
+/**
+ * Caller must free with yerba_string_free.
+ */
+char *yerba_document_source(const struct Document *document, const char *path);
+
 /**
  * Caller must free with yerba_string_free.
  */

data/ext/yerba/yerba.c

@@ -119,10 +119,12 @@ static VALUE document_initialize(int argc, VALUE *argv, VALUE self) {
   if (NIL_P(path)) {
     result = yerba_document_parse("---\n");
     rb_iv_set(self, "@path", Qnil);
+    rb_iv_set(self, "@loaded_mtime", Qnil);
   } else {
     const char *file_path = StringValueCStr(path);
     result = yerba_document_parse_file(file_path);
     rb_iv_set(self, "@path", path);
+    rb_iv_set(self, "@loaded_mtime", rb_funcall(rb_cFile, rb_intern("mtime"), 1, path));
   }
 
   if (!result.document) {
@@ -297,6 +299,19 @@ static VALUE document_valid_selector_p(VALUE self, VALUE path) {
   return yerba_document_valid_selector(document, StringValueCStr(path)) ? Qtrue : Qfalse;
 }
 
+/* document.source(path) → raw YAML text of the node at path */
+static VALUE document_source(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+  char *text = yerba_document_source(document, StringValueCStr(path));
+
+  if (!text) return Qnil;
+
+  VALUE result = make_utf8_string(text);
+  yerba_string_free(text);
+
+  return result;
+}
+
 /* document.get_value(path) → parsed Ruby object (Hash/Array/String/Integer/etc) */
 static VALUE document_get_value(VALUE self, VALUE path) {
   struct Document *document = get_document(self);
@@ -1091,6 +1106,7 @@ void Init_yerba(void) {
   rb_define_method(rb_cDocument, "blank_lines", document_blank_lines, 2);
   rb_define_method(rb_cDocument, "apply_yerbafile", document_apply_yerbafile, -1);
   rb_define_method(rb_cDocument, "validate_schema", document_validate_schema, -1);
+  rb_define_method(rb_cDocument, "source", document_source, 1);
   rb_define_method(rb_cDocument, "to_s", document_to_s, 0);
   rb_define_method(rb_cDocument, "write!", document_save, 0);
   rb_define_method(rb_cDocument, "changed?", document_changed_p, 0);

data/lib/yerba/document.rb

@@ -64,9 +64,16 @@ module Yerba
 
     def save_to!(path)
       @path = path
+      @loaded_mtime = nil
       save!
     end
 
+    def stale?
+      return false unless @path && @loaded_mtime
+
+      File.mtime(@path) != @loaded_mtime
+    end
+
     def dig(*keys)
       keys.reduce(self) { |node, key| node.nil? ? nil : node[key] }
     end
@@ -106,15 +113,18 @@ module Yerba
     end
 
     def save!(apply: false)
+      check_stale!
       Yerbafile.apply!(self, apply) if apply
       write!
-
+      @loaded_mtime = File.mtime(@path) if @path
       self
     end
 
     def apply!(yerbafile = nil)
+      check_stale!
       apply(yerbafile)
       write! if changed?
+      @loaded_mtime = File.mtime(@path) if @path
 
       self
     end
@@ -157,6 +167,16 @@ module Yerba
       raise Yerba::SelectorNotFoundError, message
     end
 
+    private
+
+    def check_stale!
+      return unless stale?
+
+      raise Yerba::StaleFileError, "#{@path} was modified externally since it was loaded"
+    end
+
+    public
+
     def inspect
       if path
         "#<Yerba::Document path=#{path.inspect}>"

data/lib/yerba/map.rb

@@ -161,6 +161,10 @@ module Yerba
     end
     alias to_hash to_h
 
+    def to_s
+      source || to_yaml
+    end
+
     def to_yaml
       to_hash.map do |key, val|
         formatted = format_value(val)

data/lib/yerba/node.rb

@@ -20,6 +20,12 @@ module Yerba
       !@document.nil? || !@file_path.nil?
     end
 
+    def source
+      return nil unless connected? && @selector
+
+      document.source(@selector)
+    end
+
     module ClassMethods
       def from_document(document, selector, location = nil, key = nil, **attributes)
         instance = allocate

data/lib/yerba/sequence.rb

@@ -281,6 +281,10 @@ module Yerba
       end.join("\n")
     end
 
+    def to_s
+      source || super
+    end
+
     def inspect
       list = items
       preview = list.first(5).map(&:inspect).join(", ")

data/lib/yerba/version.rb

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

data/lib/yerba.rb

@@ -30,6 +30,7 @@ module Yerba
   class ExecutableNotFoundError < StandardError; end
   class CompilationError < StandardError; end
   class SelectorNotFoundError < StandardError; end
+  class StaleFileError < StandardError; end
 
   GEM_NAME = "yerba"
   EXECUTABLE_NAME = "yerba"

data/rust/Cargo.lock

@@ -1772,7 +1772,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "cbindgen",
  "clap",

data/rust/Cargo.toml

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

data/rust/src/document/mod.rs

@@ -159,6 +159,11 @@ impl Document {
     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)?;
 

data/rust/src/document/style.rs

@@ -406,42 +406,120 @@ impl Document {
     }
 
     loop {
-      let value = match self.get_value(scope_path) {
-        Some(value) => value,
-        None => return Ok(()),
+      let source = self.root.text().to_string();
+
+      let scope_node = if scope_path.is_empty() {
+        self.root.clone()
+      } else {
+        match self.navigate(scope_path) {
+          Ok(node) => node,
+          Err(_) => return Ok(()),
+        }
       };
 
-      let mut selectors = Vec::new();
+      let mut mismatch_ranges: Vec<TextRange> = Vec::new();
+
+      for descendant in scope_node.descendants() {
+        if !BlockSeq::can_cast(descendant.kind()) {
+          continue;
+        }
+
+        let parent_entry = match descendant.ancestors().find(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_ENTRY) {
+          Some(entry) => entry,
+          None => continue,
+        };
+
+        let first_entry = match BlockSeq::cast(descendant.clone()).and_then(|sequence| sequence.entries().next()) {
+          Some(entry) => entry,
+          None => continue,
+        };
+
+        let key_indent = preceding_whitespace_indent(&parent_entry).len();
+        let entry_indent = preceding_whitespace_indent(first_entry.syntax()).len();
+        let is_indented = entry_indent > key_indent;
 
-      if !scope_path.is_empty() {
-        selectors.push(scope_path.to_string());
+        if (style == "indented" && !is_indented) || (style == "compact" && is_indented) {
+          mismatch_ranges.push(descendant.text_range());
+        }
       }
 
-      collect_selectors(&value, scope_path, &mut selectors);
+      if mismatch_ranges.is_empty() {
+        return Ok(());
+      }
 
-      let concrete_selectors: Vec<String> = selectors
-        .into_iter()
-        .flat_map(|selector| {
-          if selector.contains("[]") {
-            self.resolve_selectors(&selector)
-          } else {
-            vec![selector]
-          }
-        })
-        .collect();
+      let mut edits: Vec<(TextRange, String)> = Vec::new();
 
-      let mut sequence_selectors: Vec<String> = concrete_selectors
-        .into_iter()
-        .filter(|selector| self.get_sequence_indent(selector).is_some_and(|current_style| current_style != style))
-        .collect();
+      for range in &mismatch_ranges {
+        if mismatch_ranges.iter().any(|other| other != range && range.contains_range(*other)) {
+          continue;
+        }
 
-      if sequence_selectors.is_empty() {
+        let node = match scope_node
+          .descendants()
+          .find(|descendant| BlockSeq::can_cast(descendant.kind()) && descendant.text_range() == *range)
+        {
+          Some(node) => node,
+          None => continue,
+        };
+        let parent_entry = match node.ancestors().find(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_ENTRY) {
+          Some(entry) => entry,
+          None => continue,
+        };
+        let first_entry = match BlockSeq::cast(node).and_then(|seq| seq.entries().next()) {
+          Some(entry) => entry,
+          None => continue,
+        };
+
+        let key_indent = preceding_whitespace_indent(&parent_entry).len();
+        let entry_indent = preceding_whitespace_indent(first_entry.syntax()).len();
+
+        let indent_diff: i32 = match style {
+          "indented" => (key_indent as i32 + 2) - entry_indent as i32,
+          "compact" => key_indent as i32 - entry_indent as i32,
+          _ => continue,
+        };
+
+        if indent_diff == 0 {
+          continue;
+        }
+
+        let seq_start: usize = range.start().into();
+        let line_start = source[..seq_start].rfind('\n').map(|pos| pos + 1).unwrap_or(0);
+        let full_text = &source[line_start..usize::from(range.end())];
+
+        let reindented: String = full_text
+          .lines()
+          .map(|line| {
+            if line.trim().is_empty() {
+              String::new()
+            } else {
+              let current_indent = line.len() - line.trim_start().len();
+              let new_indent = (current_indent as i32 + indent_diff).max(0) as usize;
+              format!("{}{}", " ".repeat(new_indent), line.trim_start())
+            }
+          })
+          .collect::<Vec<_>>()
+          .join("\n");
+
+        edits.push((TextRange::new(rowan::TextSize::from(line_start as u32), range.end()), reindented));
+      }
+
+      if edits.is_empty() {
         return Ok(());
       }
 
-      sequence_selectors.sort_by_key(|selector| std::cmp::Reverse(selector.len()));
+      edits.sort_by_key(|edit| std::cmp::Reverse(edit.0.start()));
+
+      let mut new_source = source;
+      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.set_sequence_indent(&sequence_selectors[0], style)?;
+      let path = self.path.take();
+      *self = Self::parse(&new_source)?;
+      self.path = path;
     }
   }
 

data/rust/src/ffi.rs

@@ -278,6 +278,18 @@ fn location_to_ffi(location: crate::Location) -> YerbaLocation {
   }
 }
 
+/// Caller must free with yerba_string_free.
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_source(document: *const Document, path: *const c_char) -> *mut c_char {
+  let document = &*document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+
+  match document.source(selector_string) {
+    Ok(text) => CString::new(text).unwrap_or_default().into_raw(),
+    Err(_) => ptr::null_mut(),
+  }
+}
+
 /// Caller must free with yerba_string_free.
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_get_value(document: *const Document, path: *const c_char) -> *mut c_char {

data/rust/src/yerbafile.rs

@@ -439,6 +439,24 @@ impl Yerbafile {
     results
   }
 
+  fn relativize_path(&self, file_path: &str) -> Option<String> {
+    let path = Path::new(file_path);
+
+    if !path.is_absolute() {
+      return None;
+    }
+
+    if let Some(directory) = &self.directory {
+      if let Ok(relative) = path.strip_prefix(directory) {
+        return Some(relative.to_string_lossy().to_string());
+      }
+    }
+
+    std::env::current_dir()
+      .ok()
+      .and_then(|cwd| path.strip_prefix(&cwd).ok().map(|relative| relative.to_string_lossy().to_string()))
+  }
+
   fn should_run_global_pipeline(&self, file_path: &str) -> bool {
     if self.pipeline.is_empty() {
       return false;
@@ -454,15 +472,17 @@ impl Yerbafile {
 
   pub fn apply_to_document(&self, document: &mut Document, file_path: &str) -> Result<bool, YerbaError> {
     let original = document.to_string();
+    let relative_path = self.relativize_path(file_path);
+    let match_path = relative_path.as_deref().unwrap_or(file_path);
 
-    if self.should_run_global_pipeline(file_path) {
+    if self.should_run_global_pipeline(match_path) {
       execute_pipeline(document, &self.pipeline, None, file_path, self)?;
     }
 
     for rule in &self.rules {
-      if !file_path.is_empty() {
+      if !match_path.is_empty() {
         if let Ok(pattern) = glob::Pattern::new(&rule.files) {
-          if !pattern.matches(file_path) && !pattern.matches_path(Path::new(file_path)) {
+          if !pattern.matches(match_path) && !pattern.matches_path(Path::new(match_path)) {
             continue;
           }
         } else {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.2
 platform: arm-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-06-21 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies: []
 description: A CLI tool for editing YAML while preserving structure, comments, and
   format.