yerba 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b0696495b8437f9deea398cba7c4e6af00a8983ffa0cb519492aca22426ba46
-  data.tar.gz: 42daabe671e951b350286a5ec6a63690466aff8f8b8828ebd8e570e8fc8758d3
+  metadata.gz: c659373d09accba735b75efdae48ee3c22a801f95f9669403bbc96220c29e80b
+  data.tar.gz: 28625aeb5c6939da11d4dfc9fd6de3d17e5f7923c4c49d2bfcb97b5dcf9ba9f0
 SHA512:
-  metadata.gz: 2e245101d150f74c63f49a8caaa7e78f7966f25934ee6678a42629b4633758d6f74e3e638892dd4972ec11f0f2c734f93df85debebe809abcbaad19ca67380f5
-  data.tar.gz: 289f195705e6d427bb6f263b8dc826b1107923cdd7022594d2806e47906f6acac3011ae9fb40802e6313bda281d66662168a93c525d5868e14e9435a99758f8b
+  metadata.gz: ade24547cfc1b6b9423dac87eef5a979c10aa5a1d0755912273d9504d928587447d876e693beba7ab6bc5ab7185c534ebd956e3cf7172ef3d308b8a112dfb3ec
+  data.tar.gz: 898d28671752d146d0da2f695839af841b75462c3aec72192f277349778aec635df9c9775fb8015124dae6973011af1ce996115d3a9c7fa1303fb031c50217c1

data/lib/yerba/version.rb

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

data/rust/Cargo.toml

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

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/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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Marco Roth