yerba 0.7.2 → 0.7.3

data/rust/src/document/style.rs

@@ -9,7 +9,7 @@ pub struct StyleEnforcement {
 
 impl Document {
   pub fn enforce_styles(&mut self, enforcement: &StyleEnforcement) -> Result<(), YerbaError> {
-    let source = self.root.text().to_string();
+    let source = self.source_text();
     let mut edits: Vec<(TextRange, String)> = Vec::new();
     let mut converted_ranges: Vec<TextRange> = Vec::new();
 
@@ -41,8 +41,7 @@ impl Document {
 
             if let Some(ref entry) = entry_node {
               let entry_start: usize = entry.text_range().start().into();
-              let entry_line_start = source[..entry_start].rfind('\n').map(|position| position + 1).unwrap_or(0);
-              let key_indent = entry_start - entry_line_start;
+              let key_indent = column_at(&source, entry_start);
               let entry_text = entry.text().to_string();
 
               if let Some(colon_offset) = entry_text.find(':') {
@@ -78,8 +77,7 @@ impl Document {
             };
 
             let entry_start: usize = parent_entry.text_range().start().into();
-            let line_start = source[..entry_start].rfind('\n').map(|position| position + 1).unwrap_or(0);
-            let key_indent_length = entry_start - line_start;
+            let key_indent_length = column_at(&source, entry_start);
             let entry_indent_length = preceding_whitespace_indent(first_entry.syntax()).len();
             let is_indented = entry_indent_length > key_indent_length;
             let needs_change = (want_indented && !is_indented) || (want_compact && is_indented);
@@ -101,8 +99,7 @@ impl Document {
               let sequence_start: usize = sequence_range.start().into();
               let sequence_end: usize = sequence_range.end().into();
 
-              let before_sequence = &source[..sequence_start];
-              let line_start_of_first_entry = before_sequence.rfind('\n').map(|position| position + 1).unwrap_or(0);
+              let line_start_of_first_entry = line_start_at(&source, sequence_start);
               let full_text = &source[line_start_of_first_entry..sequence_end];
 
               let reindented: String = full_text
@@ -143,39 +140,12 @@ impl Document {
               let target_kind = key_style.to_syntax_kind();
 
               if current_kind != target_kind {
-                let raw_value = match current_kind {
-                  SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-                    let text = token.text();
-
-                    unescape_double_quoted(&text[1..text.len() - 1])
-                  }
-
-                  SyntaxKind::SINGLE_QUOTED_SCALAR => {
-                    let text = token.text();
-
-                    unescape_single_quoted(&text[1..text.len() - 1])
-                  }
-
-                  SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
-
-                  _ => continue,
+                let raw_value = match raw_scalar_value(token) {
+                  Some(value) => value,
+                  None => continue,
                 };
 
-                let new_text = match key_style {
-                  crate::KeyStyle::Double => {
-                    let escaped = raw_value.replace('\\', "\\\\").replace('"', "\\\"");
-
-                    format!("\"{}\"", escaped)
-                  }
-
-                  crate::KeyStyle::Single => {
-                    let escaped = raw_value.replace('\'', "''");
-
-                    format!("'{}'", escaped)
-                  }
-
-                  crate::KeyStyle::Plain => raw_value,
-                };
+                let new_text = format_scalar_value(&raw_value, target_kind);
 
                 if new_text != token.text() {
                   edits.push((token.text_range(), new_text));
@@ -210,51 +180,18 @@ impl Document {
               continue;
             }
 
-            let raw_value = match current_kind {
-              SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-                let text = token.text();
-                unescape_double_quoted(&text[1..text.len() - 1])
-              }
-
-              SyntaxKind::SINGLE_QUOTED_SCALAR => {
-                let text = token.text();
-                unescape_single_quoted(&text[1..text.len() - 1])
-              }
-
-              SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
-
-              _ => continue,
+            let raw_value = match raw_scalar_value(token) {
+              Some(value) => value,
+              None => continue,
             };
 
             if current_kind == SyntaxKind::PLAIN_SCALAR && is_yaml_non_string(&raw_value) {
               continue;
             }
 
-            let new_text = match value_style {
-              QuoteStyle::Double => {
-                if raw_value.contains('"') && current_kind == SyntaxKind::SINGLE_QUOTED_SCALAR {
-                  continue;
-                }
-
-                let escaped = raw_value.replace('\\', "\\\\").replace('"', "\\\"");
-
-                format!("\"{}\"", escaped)
-              }
-
-              QuoteStyle::Single => {
-                let escaped = raw_value.replace('\'', "''");
-                format!("'{}'", escaped)
-              }
-
-              QuoteStyle::Plain => {
-                if raw_value.contains('"') || raw_value.contains('\'') || raw_value.contains(':') || raw_value.contains('#') {
-                  continue;
-                }
-
-                raw_value
-              }
-
-              _ => continue,
+            let new_text = match inline_quote_replacement(&raw_value, current_kind, value_style) {
+              Some(new_text) => new_text,
+              None => continue,
             };
 
             if new_text != token.text() {
@@ -265,26 +202,7 @@ impl Document {
       }
     }
 
-    if edits.is_empty() {
-      return Ok(());
-    }
-
-    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);
-    }
-
-    let path = self.path.take();
-    *self = Self::parse(&new_source)?;
-    self.path = path;
-
-    Ok(())
+    self.apply_edits(edits)
   }
 
   pub fn enforce_collection_style(&mut self, style: &str, dot_path: Option<&str>) -> Result<(), YerbaError> {
@@ -406,7 +324,7 @@ impl Document {
     }
 
     loop {
-      let source = self.root.text().to_string();
+      let source = self.source_text();
 
       let scope_node = if scope_path.is_empty() {
         self.root.clone()
@@ -465,7 +383,7 @@ impl Document {
           Some(entry) => entry,
           None => continue,
         };
-        let first_entry = match BlockSeq::cast(node).and_then(|seq| seq.entries().next()) {
+        let first_entry = match BlockSeq::cast(node).and_then(|sequence| sequence.entries().next()) {
           Some(entry) => entry,
           None => continue,
         };
@@ -483,8 +401,8 @@ impl Document {
           continue;
         }
 
-        let seq_start: usize = range.start().into();
-        let line_start = source[..seq_start].rfind('\n').map(|pos| pos + 1).unwrap_or(0);
+        let sequence_start: usize = range.start().into();
+        let line_start = line_start_at(&source, sequence_start);
         let full_text = &source[line_start..usize::from(range.end())];
 
         let reindented: String = full_text
@@ -508,18 +426,7 @@ impl Document {
         return Ok(());
       }
 
-      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);
-      }
-
-      let path = self.path.take();
-      *self = Self::parse(&new_source)?;
-      self.path = path;
+      self.apply_edits(edits)?;
     }
   }
 
@@ -540,7 +447,7 @@ impl Document {
     }
 
     let current_node = self.navigate(dot_path)?;
-    let source = self.to_string();
+    let source = self.source_text();
 
     let entry_node = current_node
       .ancestors()
@@ -548,13 +455,9 @@ impl Document {
       .ok_or_else(|| YerbaError::ParseError("could not find parent map entry".to_string()))?;
 
     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_length = entry_start - line_start;
+    let key_indent_length = column_at(&source, entry_start);
 
-    let sequence = current_node
-      .descendants()
-      .find_map(BlockSeq::cast)
-      .ok_or_else(|| YerbaError::ParseError("could not find block sequence".to_string()))?;
+    let sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::ParseError("could not find block sequence".to_string()))?;
 
     let first_entry = sequence.entries().next();
 
@@ -578,8 +481,7 @@ impl Document {
     let sequence_start: usize = sequence_range.start().into();
     let sequence_end: usize = sequence_range.end().into();
 
-    let before_sequence = &source[..sequence_start];
-    let line_start_of_first_entry = before_sequence.rfind('\n').map(|position| position + 1).unwrap_or(0);
+    let line_start_of_first_entry = line_start_at(&source, sequence_start);
     let full_text = &source[line_start_of_first_entry..sequence_end];
 
     let reindented: String = full_text
@@ -619,14 +521,13 @@ impl Document {
       _ => {}
     }
 
-    let source = self.to_string();
+    let source = self.source_text();
 
     let entry_node = current_node.ancestors().find(|ancestor| ancestor.kind() == SyntaxKind::BLOCK_MAP_ENTRY);
 
     let (key_indent, colon_in_line) = if let Some(ref entry) = entry_node {
       let entry_start: usize = entry.text_range().start().into();
-      let entry_line_start = source[..entry_start].rfind('\n').map(|position| position + 1).unwrap_or(0);
-      let indent = entry_start - entry_line_start;
+      let indent = column_at(&source, entry_start);
 
       let entry_text = entry.text().to_string();
       let colon_offset = entry_text.find(':').map(|offset| entry_start + offset);
@@ -696,56 +597,18 @@ impl Document {
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
     for current_node in &nodes {
-      let sequence = current_node.descendants().find_map(BlockSeq::cast);
-      let map = current_node.descendants().find_map(BlockMap::cast);
-
-      let use_sequence = match (&sequence, &map) {
-        (Some(sequence), Some(map)) => sequence.syntax().text_range().start() <= map.syntax().text_range().start(),
-        (Some(_), None) => true,
-        (None, Some(_)) => false,
-        (None, None) => continue,
+      let entry_nodes: Vec<SyntaxNode> = match first_collection(current_node) {
+        Some(FirstCollection::Sequence(sequence)) => sequence.entries().map(|entry| entry.syntax().clone()).collect(),
+        Some(FirstCollection::Map(map)) => map.entries().map(|entry| entry.syntax().clone()).collect(),
+        None => continue,
       };
 
-      if use_sequence {
-        let entries: Vec<_> = sequence.unwrap().entries().collect();
-
-        if entries.len() > 1 {
-          for entry in entries.iter().skip(1) {
-            collect_blank_line_edits(entry.syntax(), blank_lines, &mut edits);
-          }
-        }
-      } else {
-        let entries: Vec<_> = map.unwrap().entries().collect();
-
-        if entries.len() > 1 {
-          for entry in entries.iter().skip(1) {
-            collect_blank_line_edits(entry.syntax(), blank_lines, &mut edits);
-          }
-        }
+      for entry_node in entry_nodes.iter().skip(1) {
+        collect_blank_line_edits(entry_node, blank_lines, &mut edits);
       }
     }
 
-    if edits.is_empty() {
-      return Ok(());
-    }
-
-    edits.sort_by_key(|edit| std::cmp::Reverse(edit.0.start()));
-
-    let source = self.root.text().to_string();
-    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);
-    }
-
-    let path = self.path.take();
-    *self = Self::parse(&new_source)?;
-    self.path = path;
-
-    Ok(())
+    self.apply_edits(edits)
   }
 
   pub fn has_directives_marker(&self) -> bool {
@@ -753,7 +616,7 @@ impl Document {
   }
 
   pub fn directive_locations(&self) -> Vec<(usize, usize)> {
-    let source = self.root.text().to_string();
+    let source = self.source_text();
 
     self
       .root
@@ -761,10 +624,8 @@ impl Document {
       .filter(|element| element.kind() == SyntaxKind::DIRECTIVES_END)
       .map(|element| {
         let offset: usize = element.text_range().start().into();
-        let line = source[..offset].matches('\n').count() + 1;
-        let column = offset - source[..offset].rfind('\n').map(|position| position + 1).unwrap_or(0) + 1;
 
-        (line, column)
+        (line_at(&source, offset), column_at(&source, offset) + 1)
       })
       .collect()
   }
@@ -774,14 +635,10 @@ impl Document {
       return Ok(());
     }
 
-    let source = self.root.text().to_string();
+    let source = self.source_text();
     let new_source = format!("---\n{}", source);
 
-    let path = self.path.take();
-    *self = Self::parse(&new_source)?;
-    self.path = path;
-
-    Ok(())
+    self.reparse(&new_source)
   }
 
   pub fn remove_directives(&mut self) -> Result<(), YerbaError> {
@@ -789,23 +646,17 @@ impl Document {
       return Ok(());
     }
 
-    let source = self.root.text().to_string();
+    let source = self.source_text();
     let new_source = source
       .strip_prefix("---\n")
       .or_else(|| source.strip_prefix("---"))
       .unwrap_or(&source)
       .to_string();
 
-    let path = self.path.take();
-    *self = Self::parse(&new_source)?;
-    self.path = path;
-
-    Ok(())
+    self.reparse(&new_source)
   }
 
   pub fn enforce_key_style(&mut self, style: &crate::KeyStyle, dot_path: Option<&str>) -> Result<(), YerbaError> {
-    let source = self.root.text().to_string();
-
     let scope_ranges: Vec<TextRange> = match dot_path {
       Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
@@ -838,35 +689,12 @@ impl Document {
           continue;
         }
 
-        let raw_value = match current_kind {
-          SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-            let text = token.text();
-            unescape_double_quoted(&text[1..text.len() - 1])
-          }
-
-          SyntaxKind::SINGLE_QUOTED_SCALAR => {
-            let text = token.text();
-            unescape_single_quoted(&text[1..text.len() - 1])
-          }
-
-          SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
-
-          _ => continue,
+        let raw_value = match raw_scalar_value(&token) {
+          Some(value) => value,
+          None => continue,
         };
 
-        let new_text = match style {
-          crate::KeyStyle::Double => {
-            let escaped = raw_value.replace('\\', "\\\\").replace('"', "\\\"");
-            format!("\"{}\"", escaped)
-          }
-
-          crate::KeyStyle::Single => {
-            let escaped = raw_value.replace('\'', "''");
-            format!("'{}'", escaped)
-          }
-
-          crate::KeyStyle::Plain => raw_value,
-        };
+        let new_text = format_scalar_value(&raw_value, target_kind);
 
         if new_text != token.text() {
           edits.push((token.text_range(), new_text));
@@ -874,26 +702,7 @@ impl Document {
       }
     }
 
-    if edits.is_empty() {
-      return Ok(());
-    }
-
-    edits.reverse();
-
-    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);
-    }
-
-    let path = self.path.take();
-    *self = Self::parse(&new_source)?;
-    self.path = path;
-
-    Ok(())
+    self.apply_edits(edits)
   }
 
   pub fn enforce_quote_style(
@@ -918,7 +727,7 @@ impl Document {
   }
 
   pub fn enforce_quotes_at(&mut self, style: &QuoteStyle, dot_path: Option<&str>) -> Result<Vec<String>, YerbaError> {
-    let source = self.root.text().to_string();
+    let source = self.source_text();
 
     let scope_ranges: Vec<TextRange> = match dot_path {
       Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),
@@ -1007,7 +816,7 @@ impl Document {
                 QuoteStyle::Single => {
                   if is_multiline {
                     let offset: usize = token.text_range().start().into();
-                    let line = source[..offset].matches('\n').count() + 1;
+                    let line = line_at(&source, offset);
 
                     warnings.push(format!(
                       "line {}: skipped block scalar → single (multiline content can't be single-quoted)",
@@ -1025,7 +834,7 @@ impl Document {
                 QuoteStyle::Plain => {
                   if is_multiline || trimmed.contains(':') || trimmed.contains('#') || trimmed.contains('"') || trimmed.contains('\'') {
                     let offset: usize = token.text_range().start().into();
-                    let line = source[..offset].matches('\n').count() + 1;
+                    let line = line_at(&source, offset);
                     let reason = if is_multiline { "multiline content" } else { "special characters" };
 
                     warnings.push(format!("line {}: skipped block scalar → plain ({} can't be plain)", line, reason));
@@ -1047,22 +856,9 @@ impl Document {
         }
 
         if is_inline_scalar && is_block_scalar_target {
-          let raw_value = match current_kind {
-            SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-              let text = token.text();
-
-              unescape_double_quoted(&text[1..text.len() - 1])
-            }
-
-            SyntaxKind::SINGLE_QUOTED_SCALAR => {
-              let text = token.text();
-
-              unescape_single_quoted(&text[1..text.len() - 1])
-            }
-
-            SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
-
-            _ => continue,
+          let raw_value = match raw_scalar_value(&token) {
+            Some(value) => value,
+            None => continue,
           };
 
           if is_yaml_non_string(&raw_value) {
@@ -1070,8 +866,7 @@ impl Document {
           }
 
           let offset: usize = token.text_range().start().into();
-          let line_start = source[..offset].rfind('\n').map(|p| p + 1).unwrap_or(0);
-          let line_prefix = &source[line_start..offset];
+          let line_prefix = &source[line_start_at(&source, offset)..offset];
           let indent = line_prefix.len() - line_prefix.trim_start().len() + 2;
           let indent_str = " ".repeat(indent);
           let header = style.block_header();
@@ -1099,50 +894,18 @@ impl Document {
           continue;
         }
 
-        let raw_value = match current_kind {
-          SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-            let text = token.text();
-            unescape_double_quoted(&text[1..text.len() - 1])
-          }
-
-          SyntaxKind::SINGLE_QUOTED_SCALAR => {
-            let text = token.text();
-            unescape_single_quoted(&text[1..text.len() - 1])
-          }
-
-          SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
-
-          _ => continue,
+        let raw_value = match raw_scalar_value(&token) {
+          Some(value) => value,
+          None => continue,
         };
 
         if current_kind == SyntaxKind::PLAIN_SCALAR && is_yaml_non_string(&raw_value) {
           continue;
         }
 
-        let new_text = match style {
-          QuoteStyle::Double => {
-            if raw_value.contains('"') && current_kind == SyntaxKind::SINGLE_QUOTED_SCALAR {
-              continue;
-            }
-
-            let escaped = raw_value.replace('\\', "\\\\").replace('"', "\\\"");
-            format!("\"{}\"", escaped)
-          }
-
-          QuoteStyle::Single => {
-            let escaped = raw_value.replace('\'', "''");
-            format!("'{}'", escaped)
-          }
-
-          QuoteStyle::Plain => {
-            if raw_value.contains('"') || raw_value.contains('\'') || raw_value.contains(':') || raw_value.contains('#') {
-              continue;
-            }
-
-            raw_value
-          }
-
-          _ => continue,
+        let new_text = match inline_quote_replacement(&raw_value, current_kind, style) {
+          Some(new_text) => new_text,
+          None => continue,
         };
 
         if new_text != token.text() {
@@ -1151,25 +914,32 @@ impl Document {
       }
     }
 
-    if edits.is_empty() {
-      return Ok(warnings);
-    }
-
-    edits.reverse();
+    self.apply_edits(edits)?;
 
-    let mut new_source = source;
+    Ok(warnings)
+  }
+}
 
-    for (range, replacement) in edits {
-      let start: usize = range.start().into();
-      let end: usize = range.end().into();
+fn inline_quote_replacement(raw_value: &str, current_kind: SyntaxKind, style: &QuoteStyle) -> Option<String> {
+  match style {
+    QuoteStyle::Double => {
+      if raw_value.contains('"') && current_kind == SyntaxKind::SINGLE_QUOTED_SCALAR {
+        return None;
+      }
 
-      new_source.replace_range(start..end, &replacement);
+      Some(format_scalar_value(raw_value, SyntaxKind::DOUBLE_QUOTED_SCALAR))
     }
 
-    let path = self.path.take();
-    *self = Self::parse(&new_source)?;
-    self.path = path;
+    QuoteStyle::Single => Some(format_scalar_value(raw_value, SyntaxKind::SINGLE_QUOTED_SCALAR)),
 
-    Ok(warnings)
+    QuoteStyle::Plain => {
+      if raw_value.contains('"') || raw_value.contains('\'') || raw_value.contains(':') || raw_value.contains('#') {
+        return None;
+      }
+
+      Some(raw_value.to_string())
+    }
+
+    _ => None,
   }
 }

data/rust/src/document/unique.rs

@@ -1,9 +1,8 @@
-use yaml_parser::ast::BlockSeq;
-
 use rowan::ast::AstNode;
 
 use crate::document::{extract_scalar_text, navigate_from_node, Document};
 use crate::error::YerbaError;
+use crate::syntax::{find_block_sequence, line_at};
 
 #[derive(Debug, Clone)]
 pub struct DuplicateInfo {
@@ -18,9 +17,9 @@ impl Document {
 
   pub fn unique_with_options(&mut self, dot_path: &str, by: &str, remove: bool, allow_blank_duplicates: bool) -> Result<Vec<DuplicateInfo>, YerbaError> {
     let current_node = self.navigate(dot_path)?;
-    let source = self.root.text().to_string();
+    let source = self.source_text();
 
-    let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
+    let sequence = match find_block_sequence(&current_node) {
       Some(sequence) => sequence,
       None => return Ok(Vec::new()),
     };
@@ -37,7 +36,7 @@ impl Document {
       .iter()
       .map(|entry| {
         let offset: usize = entry.syntax().text_range().start().into();
-        let line = source[..offset].matches('\n').count() + 1;
+        let line = line_at(&source, offset);
 
         let value = if by_is_scalar {
           Some(entry.flow().and_then(|flow| extract_scalar_text(flow.syntax())).unwrap_or_default())

data/rust/src/selector.rs

@@ -87,9 +87,9 @@ impl Selector {
       .rposition(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)));
 
     match last_bracket {
-      Some(pos) => {
-        let container = segments[..=pos].to_vec();
-        let field = segments[pos + 1..].to_vec();
+      Some(position) => {
+        let container = segments[..=position].to_vec();
+        let field = segments[position + 1..].to_vec();
 
         (Selector::Absolute(container), Selector::Relative(field))
       }