yerba 0.7.2-arm-linux-gnu → 0.7.3-arm-linux-gnu

data/rust/src/document/mod.rs

@@ -34,8 +34,9 @@ use crate::error::YerbaError;
 use crate::QuoteStyle;
 
 use crate::syntax::{
-  dedent_block_scalar, extract_scalar, extract_scalar_text, find_entry_by_key, find_scalar_token, format_scalar_value, is_map_key, is_yaml_non_string,
-  preceding_whitespace_indent, preceding_whitespace_token, removal_range, unescape_double_quoted, unescape_single_quoted, ScalarValue,
+  column_at, dedent_block_scalar, extract_scalar, extract_scalar_text, find_block_map, find_block_sequence, find_entry_by_key, find_scalar_token,
+  first_collection, format_scalar_value, is_map_key, is_yaml_non_string, line_at, line_start_at, preceding_whitespace_indent, preceding_whitespace_token,
+  raw_scalar_value, removal_range, FirstCollection, ScalarValue,
 };
 
 #[derive(Debug, Clone)]
@@ -148,13 +149,13 @@ impl Document {
       .as_ref()
       .ok_or_else(|| YerbaError::IoError(std::io::Error::new(std::io::ErrorKind::NotFound, "no file path associated with this document")))?;
 
-    fs::write(path, self.to_string())?;
+    fs::write(path, self.source_text())?;
 
     Ok(())
   }
 
   pub fn save_to(&self, path: impl AsRef<Path>) -> Result<(), YerbaError> {
-    fs::write(path, self.to_string())?;
+    fs::write(path, self.source_text())?;
 
     Ok(())
   }
@@ -208,7 +209,7 @@ impl Document {
     let mut current_nodes: Vec<Option<SyntaxNode>> = vec![Some(document.syntax().clone())];
 
     if parsed.is_empty() {
-      if let Some(sequence) = document.syntax().descendants().find_map(BlockSeq::cast) {
+      if let Some(sequence) = find_block_sequence(document.syntax()) {
         current_nodes = sequence.entries().map(|entry| Some(entry.syntax().clone())).collect();
       }
 
@@ -296,7 +297,20 @@ impl Document {
   }
 
   fn insert_after_node(&mut self, node: &SyntaxNode, text: &str) -> Result<(), YerbaError> {
-    let position = node.text_range().end();
+    let end: usize = node.text_range().end().into();
+    let source = self.source_text();
+
+    let rest = &source[end..];
+    let line_end = rest.find('\n').unwrap_or(rest.len());
+    let trailing = &rest[..line_end];
+
+    let position = if let Some(comment_start) = trailing.find('#') {
+      let _ = comment_start;
+      rowan::TextSize::from((end + line_end) as u32)
+    } else {
+      node.text_range().end()
+    };
+
     let range = TextRange::new(position, position);
 
     self.apply_edit(range, text)
@@ -412,15 +426,37 @@ impl Document {
   }
 
   fn apply_edit(&mut self, range: TextRange, replacement: &str) -> Result<(), YerbaError> {
-    let source = self.root.text().to_string();
-    let start: usize = range.start().into();
-    let end: usize = range.end().into();
+    self.apply_edits(vec![(range, replacement.to_string())])
+  }
 
-    let mut new_source = source;
-    new_source.replace_range(start..end, replacement);
+  fn apply_edits(&mut self, mut edits: Vec<(TextRange, String)>) -> Result<(), YerbaError> {
+    if edits.is_empty() {
+      return Ok(());
+    }
+
+    edits.sort_by_key(|(range, _)| std::cmp::Reverse(range.start()));
+
+    let mut new_source = self.source_text();
+
+    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.reparse(&new_source)
+  }
+
+  fn source_text(&self) -> String {
+    self.root.text().to_string()
+  }
+
+  fn reparse(&mut self, new_source: &str) -> Result<(), YerbaError> {
+    let document = Self::parse(new_source)?;
     let path = self.path.take();
-    *self = Self::parse(&new_source)?;
+
+    *self = document;
     self.path = path;
 
     Ok(())
@@ -445,8 +481,8 @@ fn check_duplicate_keys(root: &SyntaxNode) -> Result<(), YerbaError> {
 
             if let Some(&first_offset) = seen.get(&key_text) {
               let source = root.text().to_string();
-              let first_line = source[..first_offset.into()].matches('\n').count() + 1;
-              let duplicate_line = source[..usize::from(offset)].matches('\n').count() + 1;
+              let first_line = line_at(&source, first_offset.into());
+              let duplicate_line = line_at(&source, offset.into());
               let line_content = source.lines().nth(duplicate_line - 1).unwrap_or("").to_string();
 
               return Err(YerbaError::DuplicateKey {
@@ -471,21 +507,13 @@ pub(crate) fn compute_location(source: &str, start_offset: usize, end_offset: us
   let start = start_offset.min(source.len());
   let end = end_offset.min(source.len());
 
-  let before_start = &source[..start];
-  let start_line = before_start.chars().filter(|c| *c == '\n').count() + 1;
-  let start_column = start - before_start.rfind('\n').map(|p| p + 1).unwrap_or(0);
-
-  let before_end = &source[..end];
-  let end_line = before_end.chars().filter(|c| *c == '\n').count() + 1;
-  let end_column = end - before_end.rfind('\n').map(|p| p + 1).unwrap_or(0);
-
   Location {
     start_offset: start,
     end_offset: end,
-    start_line,
-    start_column,
-    end_line,
-    end_column,
+    start_line: line_at(source, start),
+    start_column: column_at(source, start),
+    end_line: line_at(source, end),
+    end_column: column_at(source, end),
   }
 }
 
@@ -520,39 +548,31 @@ pub fn collect_selectors(value: &yaml_serde::Value, prefix: &str, selectors: &mu
 }
 
 pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::Value {
-  if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-    let map_position = node.descendants().find_map(BlockMap::cast).map(|map| map.syntax().text_range().start());
-
-    let sequence_position = sequence.syntax().text_range().start();
-
-    if map_position.is_none() || sequence_position <= map_position.unwrap() {
+  match first_collection(node) {
+    Some(FirstCollection::Sequence(sequence)) => {
       let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
 
       return yaml_serde::Value::Sequence(values);
     }
-  }
-
-  if let Some(map) = node.descendants().find_map(BlockMap::cast) {
-    let mut mapping = yaml_serde::Mapping::new();
 
-    for entry in map.entries() {
-      let key = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
+    Some(FirstCollection::Map(map)) => {
+      let mut mapping = yaml_serde::Mapping::new();
 
-      let value = entry
-        .value()
-        .map(|value_node| node_to_yaml_value(value_node.syntax()))
-        .unwrap_or(yaml_serde::Value::Null);
+      for entry in map.entries() {
+        let key = entry.key().and_then(|key_node| extract_scalar_text(key_node.syntax())).unwrap_or_default();
 
-      mapping.insert(yaml_serde::Value::String(key), value);
-    }
+        let value = entry
+          .value()
+          .map(|value_node| node_to_yaml_value(value_node.syntax()))
+          .unwrap_or(yaml_serde::Value::Null);
 
-    return yaml_serde::Value::Mapping(mapping);
-  }
+        mapping.insert(yaml_serde::Value::String(key), value);
+      }
 
-  if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
-    let values: Vec<yaml_serde::Value> = sequence.entries().map(|entry| node_to_yaml_value(entry.syntax())).collect();
+      return yaml_serde::Value::Mapping(mapping);
+    }
 
-    return yaml_serde::Value::Sequence(values);
+    None => {}
   }
 
   if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
@@ -608,17 +628,13 @@ pub(crate) fn node_to_yaml_value(node: &SyntaxNode) -> yaml_serde::Value {
 }
 
 pub(crate) fn parse_condition(condition: &str) -> Option<(String, &str, String)> {
-  let (left, operator, right) = if let Some(index) = condition.find(" not_contains ") {
-    (condition[..index].trim(), "not_contains", condition[index + 14..].trim())
-  } else if let Some(index) = condition.find(" contains ") {
-    (condition[..index].trim(), "contains", condition[index + 10..].trim())
-  } else if let Some(index) = condition.find("!=") {
-    (condition[..index].trim(), "!=", condition[index + 2..].trim())
-  } else if let Some(index) = condition.find("==") {
-    (condition[..index].trim(), "==", condition[index + 2..].trim())
-  } else {
-    return None;
-  };
+  const OPERATORS: [(&str, &str); 4] = [(" not_contains ", "not_contains"), (" contains ", "contains"), ("!=", "!="), ("==", "==")];
+
+  let (left, operator, right) = OPERATORS.iter().find_map(|(pattern, operator)| {
+    condition
+      .find(pattern)
+      .map(|index| (condition[..index].trim(), *operator, condition[index + pattern.len()..].trim()))
+  })?;
 
   let right = right
     .trim_start_matches('"')
@@ -654,7 +670,7 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
 
   match segment {
     SelectorSegment::AllItems => {
-      if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+      if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().map(|entry| entry.syntax().clone()).collect()
       } else {
         Vec::new()
@@ -662,7 +678,7 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     }
 
     SelectorSegment::Index(index) => {
-      if let Some(sequence) = node.descendants().find_map(BlockSeq::cast) {
+      if let Some(sequence) = find_block_sequence(node) {
         sequence.entries().nth(*index).map(|entry| vec![entry.syntax().clone()]).unwrap_or_default()
       } else {
         Vec::new()
@@ -670,7 +686,7 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
     }
 
     SelectorSegment::Key(key) => {
-      if let Some(map) = node.descendants().find_map(BlockMap::cast) {
+      if let Some(map) = find_block_map(node) {
         if let Some(entry) = find_entry_by_key(&map, key) {
           if let Some(value) = entry.value() {
             return vec![value.syntax().clone()];
@@ -685,23 +701,8 @@ fn resolve_segment(node: &SyntaxNode, segment: &crate::selector::SelectorSegment
 
 pub(crate) fn navigate_from_node(node: &SyntaxNode, path: &str) -> Vec<SyntaxNode> {
   let parsed = crate::selector::Selector::parse(path);
-  let mut current_nodes = vec![node.clone()];
-
-  for segment in parsed.segments() {
-    let mut next_nodes = Vec::new();
 
-    for current in &current_nodes {
-      next_nodes.extend(resolve_segment(current, segment));
-    }
-
-    current_nodes = next_nodes;
-
-    if current_nodes.is_empty() {
-      break;
-    }
-  }
-
-  current_nodes
+  navigate_remaining(node, parsed.segments())
 }
 
 #[derive(Debug, Clone)]

data/rust/src/document/schema.rs

@@ -31,7 +31,7 @@ impl Document {
       crate::schema::validate_value(&value, schema)
     };
 
-    let source = self.to_string();
+    let source = self.source_text();
 
     for error in &mut errors {
       if !error.path.is_empty() {

data/rust/src/document/set.rs

@@ -5,17 +5,10 @@ impl Document {
     let current_node = self.navigate(dot_path)?;
 
     if let Some(block_scalar) = current_node.descendants().find(|node| node.kind() == SyntaxKind::BLOCK_SCALAR) {
-      let new_text = if value.is_empty() {
-        "\"\"".to_string()
-      } else if value.contains('\n') {
-        format!("|-\n  {}", value.replace('\n', "\n  "))
-      } else {
-        format!("\"{}\"", value.replace('"', "\\\""))
-      };
+      let source = self.source_text();
+      let new_text = Self::block_scalar_replacement(&source, &block_scalar, value);
 
-      let range = block_scalar.text_range();
-
-      return self.apply_edit(range, &new_text);
+      return self.apply_edit(block_scalar.text_range(), &new_text);
     }
 
     let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
@@ -32,25 +25,18 @@ impl Document {
       return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
     }
 
-    for node in nodes.into_iter().rev() {
-      if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
-        let new_text = if value.is_empty() {
-          "\"\"".to_string()
-        } else if value.contains('\n') {
-          format!("|-\n  {}", value.replace('\n', "\n  "))
-        } else {
-          format!("\"{}\"", value.replace('"', "\\\""))
-        };
+    let source = self.source_text();
+    let mut edits: Vec<(TextRange, String)> = Vec::new();
 
-        self.apply_edit(block_scalar.text_range(), &new_text)?;
+    for node in nodes {
+      if let Some(block_scalar) = node.descendants().find(|child| child.kind() == SyntaxKind::BLOCK_SCALAR) {
+        edits.push((block_scalar.text_range(), Self::block_scalar_replacement(&source, &block_scalar, value)));
       } else if let Some(scalar_token) = find_scalar_token(&node) {
-        let new_text = format_scalar_value(value, scalar_token.kind());
-
-        self.replace_token(&scalar_token, &new_text)?;
+        edits.push((scalar_token.text_range(), format_scalar_value(value, scalar_token.kind())));
       }
     }
 
-    Ok(())
+    self.apply_edits(edits)
   }
 
   pub fn set_scalar_style(&mut self, dot_path: &str, style: &QuoteStyle) -> Result<(), YerbaError> {
@@ -64,20 +50,9 @@ impl Document {
       return Ok(());
     }
 
-    let raw_value = match current_kind {
-      SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-        let text = scalar_token.text();
-        unescape_double_quoted(&text[1..text.len() - 1])
-      }
-
-      SyntaxKind::SINGLE_QUOTED_SCALAR => {
-        let text = scalar_token.text();
-        unescape_single_quoted(&text[1..text.len() - 1])
-      }
-
-      SyntaxKind::PLAIN_SCALAR => scalar_token.text().to_string(),
-
-      _ => return Ok(()),
+    let raw_value = match raw_scalar_value(&scalar_token) {
+      Some(value) => value,
+      None => return Ok(()),
     };
 
     let new_text = format_scalar_value(&raw_value, target_kind);
@@ -97,4 +72,33 @@ impl Document {
 
     self.replace_token(&scalar_token, value)
   }
+
+  fn block_scalar_replacement(source: &str, block_scalar: &SyntaxNode, value: &str) -> String {
+    if value.is_empty() {
+      return "\"\"".to_string();
+    }
+
+    if !value.contains('\n') {
+      return format!("\"{}\"", value.replace('"', "\\\""));
+    }
+
+    let offset: usize = block_scalar.text_range().start().into();
+    let line_start = line_start_at(source, offset);
+    let key_indent = source[line_start..offset].len() - source[line_start..offset].trim_start().len();
+    let indent = " ".repeat(key_indent + 2);
+
+    let indented_lines: Vec<String> = value
+      .split('\n')
+      .enumerate()
+      .map(|(index, line)| {
+        if line.is_empty() && index > 0 {
+          String::new()
+        } else {
+          format!("{}{}", indent, line)
+        }
+      })
+      .collect();
+
+    format!("|-\n{}", indented_lines.join("\n"))
+  }
 }