yerba 0.9.2-arm-linux-gnu → 0.10.1-arm-linux-gnu

data/rust/src/document/style.rs

@@ -49,10 +49,7 @@ impl Document {
             if let Some(ref entry) = entry_node {
               let entry_start: usize = entry.text_range().start().into();
               let key_indent = column_at(&source, entry_start);
-              let entry_text = entry.text().to_string();
-
-              if let Some(colon_offset) = entry_text.find(':') {
-                let colon_position = entry_start + colon_offset;
+              if let Some(colon_position) = entry_colon_position(entry) {
                 let value_indent = key_indent + 2;
                 let block_text = crate::yaml_writer::yaml_value_to_block_text(&value, value_indent);
                 let replace_range = TextRange::new(rowan::TextSize::from((colon_position + 1) as u32), node.text_range().end());
@@ -212,11 +209,11 @@ impl Document {
     self.apply_edits(edits)
   }
 
-  pub fn enforce_collection_style(&mut self, style: &str, dot_path: Option<&str>) -> Result<(), YerbaError> {
-    let scope_path = dot_path.unwrap_or("");
+  pub fn enforce_collection_style(&mut self, style: &str, selector: Option<&str>) -> Result<(), YerbaError> {
+    let scope_selector = selector.unwrap_or("");
 
-    if scope_path.contains("[]") {
-      let concrete_selectors = self.resolve_selectors(scope_path);
+    if scope_selector.contains("[]") {
+      let concrete_selectors = self.resolve_selectors(scope_selector);
 
       for selector in concrete_selectors.iter().rev() {
         self.enforce_collection_style(style, Some(selector))?;
@@ -246,18 +243,18 @@ impl Document {
       }
     }
 
-    let value = match self.get_value(scope_path) {
+    let value = match self.get_value(scope_selector) {
       Some(value) => value,
       None => return Ok(()),
     };
 
     let mut selectors = Vec::new();
 
-    if !scope_path.is_empty() {
-      selectors.push(scope_path.to_string());
+    if !scope_selector.is_empty() {
+      selectors.push(scope_selector.to_string());
     }
 
-    collect_selectors(&value, scope_path, &mut selectors);
+    collect_selectors(&value, scope_selector, &mut selectors);
 
     let mut collection_selectors: Vec<String> = selectors
       .into_iter()
@@ -273,11 +270,11 @@ impl Document {
     Ok(())
   }
 
-  pub fn enforce_sequence_indent(&mut self, style: &str, dot_path: Option<&str>) -> Result<(), YerbaError> {
-    let scope_path = dot_path.unwrap_or("");
+  pub fn enforce_sequence_indent(&mut self, style: &str, selector: Option<&str>) -> Result<(), YerbaError> {
+    let scope_selector = selector.unwrap_or("");
 
-    if scope_path.contains("[]") {
-      let concrete_selectors = self.resolve_selectors(scope_path);
+    if scope_selector.contains("[]") {
+      let concrete_selectors = self.resolve_selectors(scope_selector);
 
       for selector in concrete_selectors.iter().rev() {
         self.enforce_sequence_indent(style, Some(selector))?;
@@ -286,10 +283,10 @@ impl Document {
       return Ok(());
     }
 
-    let scope_node = if scope_path.is_empty() {
+    let scope_node = if scope_selector.is_empty() {
       self.root.clone()
     } else {
-      match self.navigate(scope_path) {
+      match self.navigate(scope_selector) {
         Ok(node) => node,
         Err(_) => return Ok(()),
       }
@@ -333,10 +330,10 @@ impl Document {
     loop {
       let source = self.source_text();
 
-      let scope_node = if scope_path.is_empty() {
+      let scope_node = if scope_selector.is_empty() {
         self.root.clone()
       } else {
-        match self.navigate(scope_path) {
+        match self.navigate(scope_selector) {
           Ok(node) => node,
           Err(_) => return Ok(()),
         }
@@ -437,10 +434,10 @@ impl Document {
     }
   }
 
-  pub fn set_sequence_indent(&mut self, dot_path: &str, style: &str) -> Result<(), YerbaError> {
+  pub fn set_sequence_indent(&mut self, selector: &str, style: &str) -> Result<(), YerbaError> {
     let current_style = self
-      .get_sequence_indent(dot_path)
-      .ok_or_else(|| YerbaError::ParseError(format!("'{}' is not a block sequence", dot_path)))?;
+      .get_sequence_indent(selector)
+      .ok_or_else(|| YerbaError::ParseError(format!("'{}' is not a block sequence", selector)))?;
 
     if current_style == style {
       return Ok(());
@@ -453,7 +450,7 @@ impl Document {
       )));
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = self.navigate(selector)?;
     let source = self.source_text();
 
     let entry_node = current_node
@@ -510,16 +507,16 @@ impl Document {
     self.apply_edit(replace_range, &reindented)
   }
 
-  pub fn set_collection_style(&mut self, dot_path: &str, style: &str) -> Result<(), YerbaError> {
+  pub fn set_collection_style(&mut self, selector: &str, style: &str) -> Result<(), YerbaError> {
     let current_style = self
-      .get_collection_style(dot_path)
-      .ok_or_else(|| YerbaError::ParseError(format!("'{}' is not a collection (sequence or map)", dot_path)))?;
+      .get_collection_style(selector)
+      .ok_or_else(|| YerbaError::ParseError(format!("'{}' is not a collection (sequence or map)", selector)))?;
 
     if current_style == style {
       return Ok(());
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = self.navigate(selector)?;
     let value = node_to_yaml_value(&current_node);
 
     match &value {
@@ -536,10 +533,7 @@ impl Document {
       let entry_start: usize = entry.text_range().start().into();
       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);
-
-      (indent, colon_offset)
+      (indent, entry_colon_position(entry))
     } else {
       (0, None)
     };
@@ -594,15 +588,15 @@ impl Document {
     }
   }
 
-  pub fn enforce_blank_lines(&mut self, dot_path: &str, blank_lines: usize) -> Result<(), YerbaError> {
-    self.enforce_blank_lines_with(dot_path, blank_lines, &BlankLineOptions::default())
+  pub fn enforce_blank_lines(&mut self, selector: &str, blank_lines: usize) -> Result<(), YerbaError> {
+    self.enforce_blank_lines_with(selector, blank_lines, &BlankLineOptions::default())
   }
 
-  pub fn enforce_blank_lines_with(&mut self, dot_path: &str, blank_lines: usize, options: &BlankLineOptions) -> Result<(), YerbaError> {
-    let nodes = if dot_path.contains('[') {
-      self.navigate_all_compact(dot_path)
+  pub fn enforce_blank_lines_with(&mut self, selector: &str, blank_lines: usize, options: &BlankLineOptions) -> Result<(), YerbaError> {
+    let nodes = if selector.contains('[') {
+      self.navigate_all_compact(selector)
     } else {
-      vec![self.navigate(dot_path)?]
+      vec![self.navigate(selector)?]
     };
 
     let mut edits: Vec<(TextRange, String)> = Vec::new();
@@ -666,7 +660,7 @@ impl Document {
       .map(|element| {
         let offset: usize = element.text_range().start().into();
 
-        (line_at(&source, offset), column_at(&source, offset) + 1)
+        (line_at(&source, offset), column_at(&source, offset))
       })
       .collect()
   }
@@ -709,9 +703,9 @@ impl Document {
     }
   }
 
-  pub fn enforce_key_style(&mut self, style: &crate::KeyStyle, dot_path: Option<&str>) -> Result<(), YerbaError> {
-    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(),
+  pub fn enforce_key_style(&mut self, style: &crate::KeyStyle, selector: Option<&str>) -> Result<(), YerbaError> {
+    let scope_ranges: Vec<TextRange> = match selector {
+      Some(scope) if !scope.is_empty() => self.navigate_all_compact(scope).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
     };
 
@@ -779,9 +773,9 @@ impl Document {
     self.enforce_quotes_at(style, None)
   }
 
-  pub fn decode_escapes(&mut self, dot_path: Option<&str>) -> Result<usize, YerbaError> {
-    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(),
+  pub fn decode_escapes(&mut self, selector: Option<&str>) -> Result<usize, YerbaError> {
+    let scope_ranges: Vec<TextRange> = match selector {
+      Some(scope) if !scope.is_empty() => self.navigate_all_compact(scope).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
     };
 
@@ -814,11 +808,11 @@ impl Document {
     Ok(count)
   }
 
-  pub fn enforce_quotes_at(&mut self, style: &QuoteStyle, dot_path: Option<&str>) -> Result<Vec<String>, YerbaError> {
+  pub fn enforce_quotes_at(&mut self, style: &QuoteStyle, selector: Option<&str>) -> Result<Vec<String>, YerbaError> {
     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(),
+    let scope_ranges: Vec<TextRange> = match selector {
+      Some(scope) if !scope.is_empty() => self.navigate_all_compact(scope).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
     };
 
@@ -869,7 +863,7 @@ impl Document {
         }
 
         if is_block_scalar_text && !is_block_scalar_target {
-          if dot_path.is_none() || dot_path == Some("") {
+          if selector.is_none() || selector == Some("") {
             continue;
           }
 
@@ -1075,3 +1069,10 @@ fn inline_quote_replacement(raw_value: &str, current_kind: SyntaxKind, style: &Q
     _ => None,
   }
 }
+
+fn entry_colon_position(entry: &SyntaxNode) -> Option<usize> {
+  entry
+    .children_with_tokens()
+    .find(|element| element.kind() == SyntaxKind::COLON)
+    .map(|colon| colon.text_range().start().into())
+}

data/rust/src/document/unique.rs

@@ -11,12 +11,12 @@ pub struct DuplicateInfo {
 }
 
 impl Document {
-  pub fn unique(&mut self, dot_path: &str, by: &str, remove: bool) -> Result<Vec<DuplicateInfo>, YerbaError> {
-    self.unique_with_options(dot_path, by, remove, false)
+  pub fn unique(&mut self, selector: &str, by: &str, remove: bool) -> Result<Vec<DuplicateInfo>, YerbaError> {
+    self.unique_with_options(selector, by, remove, false)
   }
 
-  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)?;
+  pub fn unique_with_options(&mut self, selector: &str, by: &str, remove: bool, allow_blank_duplicates: bool) -> Result<Vec<DuplicateInfo>, YerbaError> {
+    let current_node = self.navigate(selector)?;
     let source = self.source_text();
 
     let sequence = match find_block_sequence(&current_node) {
@@ -76,7 +76,7 @@ impl Document {
 
     if remove && !duplicate_indices.is_empty() {
       for &index in duplicate_indices.iter().rev() {
-        self.remove_at(dot_path, index)?;
+        self.remove_at(selector, index)?;
       }
     }
 

data/rust/src/error.rs

@@ -27,13 +27,13 @@ impl std::fmt::Display for YerbaError {
       YerbaError::ParseError(msg) => write!(f, "parse error: {}", msg),
       YerbaError::IoError(err) => write!(f, "io error: {}", err),
       YerbaError::SelectorNotFound(selector) => write!(f, "selector not found: {}", selector),
-      YerbaError::NotASequence(path) => write!(f, "not a sequence: {}", path),
+      YerbaError::NotASequence(selector) => write!(f, "not a sequence: {}", selector),
 
-      YerbaError::FlowCollectionNotWritable(path) => {
+      YerbaError::FlowCollectionNotWritable(selector) => {
         write!(
           f,
           "cannot write to \"{}\": flow collections are not writable yet. Convert it to block style first, with `collection_style` or `yerba collection-style`",
-          path
+          selector
         )
       }
 
@@ -170,7 +170,11 @@ impl GitHubAnnotations for YerbaError {
           level: "error ",
           file: file.to_string(),
           line: Some(control.line),
-          message: format!("control character U+{:04X} at column {}", control.character as u32, control.column),
+          message: format!(
+            "control character U+{:04X} at column {}",
+            control.character as u32,
+            control.character_column + 1
+          ),
         })
         .collect(),