yerba 0.9.2-aarch64-linux-gnu → 0.10.1-aarch64-linux-gnu

data/rust/src/document/schema.rs

@@ -2,10 +2,10 @@ use super::*;
 
 impl Document {
   pub fn validate_schema(&self, schema: &serde_json::Value, items: bool, selector: Option<&str>) -> Vec<crate::schema::ValidationError> {
-    let path = selector.unwrap_or("");
-    let has_wildcard = crate::selector::Selector::parse(path).has_wildcard();
+    let selector = selector.unwrap_or("");
+    let has_wildcard = crate::selector::Selector::parse(selector).has_wildcard();
 
-    let value = match self.get_value(path) {
+    let value = match self.get_value(selector) {
       Some(value) => crate::json::yaml_to_json(&value),
       None => return vec![],
     };
@@ -62,12 +62,12 @@ fn json_pointer_to_selector(pointer: &str) -> String {
         segment.to_string()
       }
     })
-    .fold(String::new(), |mut path, segment| {
-      if !path.is_empty() && !segment.starts_with('[') {
-        path.push('.');
+    .fold(String::new(), |mut selector, segment| {
+      if !selector.is_empty() && !segment.starts_with('[') {
+        selector.push('.');
       }
 
-      path.push_str(&segment);
-      path
+      selector.push_str(&segment);
+      selector
     })
 }

data/rust/src/document/set.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 fn is_plain_writable(value: &str) -> bool {
-  crate::syntax::is_plain_safe(value) && !crate::syntax::is_yaml_non_string(value)
+  crate::syntax::is_plain_safe(value) && !crate::syntax::is_yaml_non_string(value) && !crate::syntax::resolves_to_non_string_in_psych(value)
 }
 
 fn scalar_replacement_text(value: &str, kind: SyntaxKind) -> String {
@@ -112,23 +112,23 @@ fn replacement_text(span: &ValueSpan, value: &str) -> String {
 }
 
 impl Document {
-  pub fn set(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    self.set_with(dot_path, value, false)
+  pub fn set(&mut self, selector: &str, value: &str) -> Result<(), YerbaError> {
+    self.set_with(selector, value, false)
   }
 
-  pub fn set_all(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    self.set_all_with(dot_path, value, false)
+  pub fn set_all(&mut self, selector: &str, value: &str) -> Result<(), YerbaError> {
+    self.set_all_with(selector, value, false)
   }
 
-  pub fn set_all_plain(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    self.set_all_with(dot_path, value, true)
+  pub fn set_all_plain(&mut self, selector: &str, value: &str) -> Result<(), YerbaError> {
+    self.set_all_with(selector, value, true)
   }
 
-  fn set_all_with(&mut self, dot_path: &str, value: &str, plain: bool) -> Result<(), YerbaError> {
-    let nodes = self.navigate_all_compact(dot_path);
+  fn set_all_with(&mut self, selector: &str, value: &str, plain: bool) -> Result<(), YerbaError> {
+    let nodes = self.navigate_all_compact(selector);
 
     if nodes.is_empty() {
-      return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+      return Err(YerbaError::SelectorNotFound(selector.to_string()));
     }
 
     let source = self.source_text();
@@ -137,13 +137,21 @@ impl Document {
     self.apply_edits(edits)
   }
 
-  pub fn set_where(&mut self, container_path: &str, relative_path: &str, value: &str, condition: &str, all: bool, plain: bool) -> Result<usize, YerbaError> {
+  pub fn set_where(
+    &mut self,
+    container_selector: &str,
+    relative_selector: &str,
+    value: &str,
+    condition: &str,
+    all: bool,
+    plain: bool,
+  ) -> Result<usize, YerbaError> {
     validate_item_condition(condition)?;
 
-    let items = self.navigate_all_compact(container_path);
+    let items = self.navigate_all_compact(container_selector);
 
     if items.is_empty() {
-      return Err(YerbaError::SelectorNotFound(container_path.to_string()));
+      return Err(YerbaError::SelectorNotFound(container_selector.to_string()));
     }
 
     let source = self.source_text();
@@ -154,7 +162,7 @@ impl Document {
         continue;
       }
 
-      targets.extend(navigate_from_node(item, relative_path));
+      targets.extend(navigate_from_node(item, relative_selector));
     }
 
     if targets.is_empty() {
@@ -162,10 +170,10 @@ impl Document {
     }
 
     if !all && targets.len() > 1 {
-      let selector = if container_path.is_empty() {
-        relative_path.to_string()
+      let selector = if container_selector.is_empty() {
+        relative_selector.to_string()
       } else {
-        format!("{}.{}", container_path, relative_path)
+        format!("{}.{}", container_selector, relative_selector)
       };
 
       return Err(YerbaError::AmbiguousSelector(selector, targets.len()));
@@ -179,9 +187,9 @@ impl Document {
     Ok(count)
   }
 
-  pub fn set_scalar_style(&mut self, dot_path: &str, style: &QuoteStyle) -> Result<(), YerbaError> {
-    let current_node = self.navigate(dot_path)?;
-    let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+  pub fn set_scalar_style(&mut self, selector: &str, style: &QuoteStyle) -> Result<(), YerbaError> {
+    let current_node = self.navigate(selector)?;
+    let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
     let current_kind = scalar_token.kind();
     let target_kind = style.to_syntax_kind();
@@ -200,12 +208,15 @@ impl Document {
     self.replace_token(&scalar_token, &new_text)
   }
 
-  pub fn set_plain(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    self.set_with(dot_path, value, true)
+  pub fn set_plain(&mut self, selector: &str, value: &str) -> Result<(), YerbaError> {
+    self.set_with(selector, value, true)
   }
 
-  fn set_with(&mut self, dot_path: &str, value: &str, plain: bool) -> Result<(), YerbaError> {
-    let current_node = self.navigate(dot_path)?;
+  fn set_with(&mut self, selector: &str, value: &str, plain: bool) -> Result<(), YerbaError> {
+    let current_node = match self.navigate(selector) {
+      Ok(node) => node,
+      Err(error) => return self.set_valueless_entry(selector, value, plain).unwrap_or(Err(error)),
+    };
 
     if let Some(block_scalar) = current_node.descendants().find(|node| node.kind() == SyntaxKind::BLOCK_SCALAR) {
       if plain {
@@ -219,13 +230,13 @@ impl Document {
     }
 
     if holds_collection(&current_node) {
-      let span = value_span(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+      let span = value_span(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
       let replacement = if plain { value.to_string() } else { crate::syntax::quote_scalar(value) };
 
       return self.apply_edit(span.range, &replacement_text(&span, &replacement));
     }
 
-    let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
     if plain {
       return self.replace_token(&scalar_token, value);
@@ -236,6 +247,18 @@ impl Document {
     self.replace_token(&scalar_token, &new_text)
   }
 
+  fn set_valueless_entry(&mut self, selector: &str, value: &str, plain: bool) -> Option<Result<(), YerbaError>> {
+    let entry = self.find_entry(selector)?;
+    let colon = entry.children_with_tokens().find(|element| element.kind() == SyntaxKind::COLON)?;
+    let text = if plain {
+      value.to_string()
+    } else {
+      scalar_replacement_text(value, SyntaxKind::PLAIN_SCALAR)
+    };
+
+    Some(self.apply_edit(TextRange::empty(colon.text_range().end()), &format!(" {}", text)))
+  }
+
   fn block_scalar_replacement(source: &str, block_scalar: &SyntaxNode, value: &str) -> String {
     if value.is_empty() {
       return "\"\"".to_string();

data/rust/src/document/sort.rs

@@ -1,38 +1,38 @@
 use super::*;
 
 impl Document {
-  pub fn move_item(&mut self, dot_path: &str, from: usize, to: usize) -> Result<(), YerbaError> {
+  pub fn move_item(&mut self, selector: &str, from: usize, to: usize) -> Result<(), YerbaError> {
     if from == to {
       return Ok(());
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = self.navigate(selector)?;
 
-    let sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+    let sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::NotASequence(selector.to_string()))?;
 
     let entries: Vec<_> = sequence.entries().collect();
 
     self.reorder_entries(sequence.syntax(), &entries, from, to)
   }
 
-  pub fn move_key(&mut self, dot_path: &str, from: usize, to: usize) -> Result<(), YerbaError> {
+  pub fn move_key(&mut self, selector: &str, from: usize, to: usize) -> Result<(), YerbaError> {
     if from == to {
       return Ok(());
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = self.navigate(selector)?;
 
-    let map = find_block_map(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = find_block_map(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
     let entries: Vec<_> = map.entries().collect();
 
     self.reorder_entries(map.syntax(), &entries, from, to)
   }
 
-  pub fn resolve_key_index(&self, dot_path: &str, reference: &str) -> Result<usize, YerbaError> {
-    let current_node = self.navigate(dot_path)?;
+  pub fn resolve_key_index(&self, selector: &str, reference: &str) -> Result<usize, YerbaError> {
+    let current_node = self.navigate(selector)?;
 
-    let map = find_block_map(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = find_block_map(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
     if let Ok(index) = reference.parse::<usize>() {
       let length = map.entries().count();
@@ -55,13 +55,13 @@ impl Document {
           .unwrap_or(false)
       })
       .map(|(index, _entry)| index)
-      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} key '{}'", dot_path, reference)))
+      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} key '{}'", selector, reference)))
   }
 
-  pub fn resolve_sequence_index(&self, dot_path: &str, reference: &str) -> Result<usize, YerbaError> {
-    let current_node = self.navigate(dot_path)?;
+  pub fn resolve_sequence_index(&self, selector: &str, reference: &str) -> Result<usize, YerbaError> {
+    let current_node = self.navigate(selector)?;
 
-    let sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::NotASequence(dot_path.to_string()))?;
+    let sequence = find_block_sequence(&current_node).ok_or_else(|| YerbaError::NotASequence(selector.to_string()))?;
 
     if let Ok(index) = reference.parse::<usize>() {
       let length = sequence.entries().count();
@@ -79,7 +79,7 @@ impl Document {
         .enumerate()
         .find(|(_index, entry)| self.evaluate_condition_on_node(entry.syntax(), reference))
         .map(|(index, _entry)| index)
-        .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} condition '{}'", dot_path, reference)));
+        .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} condition '{}'", selector, reference)));
     }
 
     sequence
@@ -93,15 +93,15 @@ impl Document {
           .unwrap_or(false)
       })
       .map(|(index, _entry)| index)
-      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, reference)))
+      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", selector, reference)))
   }
 
-  pub fn validate_sort_keys(&self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    if let Some(sequence_path) = strip_bracket_suffix(dot_path) {
-      return self.validate_each_sort_keys(sequence_path, key_order);
+  pub fn validate_sort_keys(&self, selector: &str, key_order: &[&str]) -> Result<(), YerbaError> {
+    if let Some(sequence_selector) = strip_bracket_suffix(selector) {
+      return self.validate_each_sort_keys(sequence_selector, key_order);
     }
 
-    let current_node = match self.navigate(dot_path) {
+    let current_node = match self.navigate(selector) {
       Ok(node) => node,
       Err(_) => return Ok(()),
     };
@@ -124,12 +124,12 @@ impl Document {
     }
   }
 
-  pub fn sort_keys(&mut self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    if let Some(sequence_path) = strip_bracket_suffix(dot_path) {
-      return self.sort_each_keys(sequence_path, key_order);
+  pub fn sort_keys(&mut self, selector: &str, key_order: &[&str]) -> Result<(), YerbaError> {
+    if let Some(sequence_selector) = strip_bracket_suffix(selector) {
+      return self.sort_each_keys(sequence_selector, key_order);
     }
 
-    let current_node = match self.navigate(dot_path) {
+    let current_node = match self.navigate(selector) {
       Ok(node) => node,
       Err(_) => return Ok(()),
     };
@@ -145,14 +145,14 @@ impl Document {
     }
   }
 
-  pub fn sort_each_keys(&mut self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    let nodes = if dot_path.is_empty() {
-      match self.navigate(dot_path) {
+  pub fn sort_each_keys(&mut self, selector: &str, key_order: &[&str]) -> Result<(), YerbaError> {
+    let nodes = if selector.is_empty() {
+      match self.navigate(selector) {
         Ok(node) => vec![node],
         Err(_) => return Ok(()),
       }
     } else {
-      let found = self.navigate_all_compact(dot_path);
+      let found = self.navigate_all_compact(selector);
       if found.is_empty() {
         return Ok(());
       }
@@ -182,14 +182,14 @@ impl Document {
     self.apply_edits(edits)
   }
 
-  pub fn validate_each_sort_keys(&self, dot_path: &str, key_order: &[&str]) -> Result<(), YerbaError> {
-    let nodes = if dot_path.is_empty() {
-      match self.navigate(dot_path) {
+  pub fn validate_each_sort_keys(&self, selector: &str, key_order: &[&str]) -> Result<(), YerbaError> {
+    let nodes = if selector.is_empty() {
+      match self.navigate(selector) {
         Ok(node) => vec![node],
         Err(_) => return Ok(()),
       }
     } else {
-      let found = self.navigate_all_compact(dot_path);
+      let found = self.navigate_all_compact(selector);
       if found.is_empty() {
         return Ok(());
       }
@@ -224,39 +224,43 @@ impl Document {
     }
   }
 
-  pub fn sort_items(&mut self, dot_path: &str, sort_fields: &[SortField], case_sensitive: bool) -> Result<(), YerbaError> {
-    if dot_path.contains("[].") {
-      return self.sort_each_items(dot_path, sort_fields, case_sensitive);
+  pub fn sort_items(&mut self, selector: &str, sort_fields: &[SortField], case_sensitive: bool) -> Result<(), YerbaError> {
+    self.sort_items_with(selector, sort_fields, case_sensitive, None)
+  }
+
+  pub fn sort_items_with(&mut self, selector: &str, sort_fields: &[SortField], case_sensitive: bool, missing: Option<SortMissing>) -> Result<(), YerbaError> {
+    if selector.contains("[].") {
+      return self.sort_each_items(selector, sort_fields, case_sensitive, missing);
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = self.navigate(selector)?;
 
     let sequence = match find_block_sequence(&current_node) {
       Some(sequence) => sequence,
       None => return Ok(()),
     };
 
-    match sort_sequence_edit(&sequence, sort_fields, case_sensitive) {
+    match sort_sequence_edit(&sequence, sort_fields, case_sensitive, missing) {
       Some(edit) => self.apply_edits(vec![edit]),
       None => Ok(()),
     }
   }
 
-  fn sort_each_items(&mut self, dot_path: &str, sort_fields: &[SortField], case_sensitive: bool) -> Result<(), YerbaError> {
-    let (parent_path, child_path) = if let Some(last_bracket) = dot_path.rfind("[].") {
-      (&dot_path[..last_bracket + 2], &dot_path[last_bracket + 3..])
+  fn sort_each_items(&mut self, selector: &str, sort_fields: &[SortField], case_sensitive: bool, missing: Option<SortMissing>) -> Result<(), YerbaError> {
+    let (parent_selector, child_selector) = if let Some(last_bracket) = selector.rfind("[].") {
+      (&selector[..last_bracket + 2], &selector[last_bracket + 3..])
     } else {
-      (dot_path, "")
+      (selector, "")
     };
 
-    let parent_nodes = self.navigate_all_compact(parent_path);
+    let parent_nodes = self.navigate_all_compact(parent_selector);
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
     for parent_node in &parent_nodes {
-      let child_nodes = if child_path.is_empty() {
+      let child_nodes = if child_selector.is_empty() {
         vec![parent_node.clone()]
       } else {
-        navigate_from_node(parent_node, child_path)
+        navigate_from_node(parent_node, child_selector)
       };
 
       for child_node in &child_nodes {
@@ -265,7 +269,7 @@ impl Document {
           None => continue,
         };
 
-        if let Some(edit) = sort_sequence_edit(&sequence, sort_fields, case_sensitive) {
+        if let Some(edit) = sort_sequence_edit(&sequence, sort_fields, case_sensitive, missing) {
           edits.push(edit);
         }
       }
@@ -274,20 +278,20 @@ impl Document {
     self.apply_edits(edits)
   }
 
-  pub fn reorder_items(&mut self, dot_path: &str, by: &str, desired_order: &[&str]) -> Result<(), YerbaError> {
+  pub fn reorder_items(&mut self, selector: &str, by: &str, desired_order: &[&str]) -> Result<(), YerbaError> {
     let field = by.strip_prefix('.').unwrap_or(by);
     let is_scalar = field.is_empty() || field == ".";
 
     let items_selector = if is_scalar {
-      if dot_path.is_empty() {
+      if selector.is_empty() {
         "[]".to_string()
       } else {
-        format!("{}[]", dot_path)
+        format!("{}[]", selector)
       }
-    } else if dot_path.is_empty() {
+    } else if selector.is_empty() {
       format!("[].{}", field)
     } else {
-      format!("{}[].{}", dot_path, field)
+      format!("{}[].{}", selector, field)
     };
 
     let labels: Vec<String> = match self.get_value(&items_selector) {
@@ -332,7 +336,7 @@ impl Document {
       let source = moves[target];
 
       if source != target {
-        self.move_item(dot_path, source, target)?;
+        self.move_item(selector, source, target)?;
 
         for item in moves.iter_mut().skip(target + 1) {
           if *item >= target && *item < source {
@@ -398,7 +402,7 @@ fn sort_map_edit(map: &BlockMap, key_order: &[&str]) -> Option<(TextRange, Strin
   Some((range, rebuild_from_groups(&sorted_groups, &indent, false)))
 }
 
-fn sort_sequence_edit(sequence: &BlockSeq, sort_fields: &[SortField], case_sensitive: bool) -> Option<(TextRange, String)> {
+fn sort_sequence_edit(sequence: &BlockSeq, sort_fields: &[SortField], case_sensitive: bool, missing: Option<SortMissing>) -> Option<(TextRange, String)> {
   let entries: Vec<_> = sequence.entries().collect();
 
   if entries.len() <= 1 {
@@ -415,7 +419,30 @@ fn sort_sequence_edit(sequence: &BlockSeq, sort_fields: &[SortField], case_sensi
 
   let original_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
-  sortable.sort_by(|(values_a, _), (values_b, _)| compare_sort_values(values_a, values_b, sort_fields, case_sensitive));
+  let compare = |(values_a, _): &(Vec<String>, EntryGroup), (values_b, _): &(Vec<String>, EntryGroup)| {
+    compare_sort_values(values_a, values_b, sort_fields, case_sensitive, missing)
+  };
+
+  let is_absent = |(values, _): &(Vec<String>, EntryGroup)| values.iter().any(|value| value.is_empty());
+
+  match missing {
+    Some(SortMissing::Skip) if sortable.iter().any(is_absent) => return None,
+    Some(SortMissing::Keep) => {
+      let absent_positions: Vec<bool> = sortable.iter().map(is_absent).collect();
+      let (absent, mut present): (Vec<_>, Vec<_>) = sortable.into_iter().partition(is_absent);
+
+      present.sort_by(compare);
+
+      let mut present = present.into_iter();
+      let mut absent = absent.into_iter();
+
+      sortable = absent_positions
+        .iter()
+        .filter_map(|is_absent| if *is_absent { absent.next() } else { present.next() })
+        .collect();
+    }
+    _ => sortable.sort_by(compare),
+  }
 
   let sorted_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
@@ -439,17 +466,23 @@ fn entry_sort_values(entry: &yaml_parser::ast::BlockSeqEntry, sort_fields: &[Sor
   sort_fields
     .iter()
     .map(|field| {
-      if field.path.is_empty() {
+      if field.selector.is_empty() {
         scalar_value()
       } else {
-        let nodes = navigate_from_node(entry.syntax(), &field.path);
+        let nodes = navigate_from_node(entry.syntax(), &field.selector);
         nodes.first().and_then(extract_scalar_text).unwrap_or_default()
       }
     })
     .collect()
 }
 
-fn compare_sort_values(values_a: &[String], values_b: &[String], sort_fields: &[SortField], case_sensitive: bool) -> std::cmp::Ordering {
+fn compare_sort_values(
+  values_a: &[String],
+  values_b: &[String],
+  sort_fields: &[SortField],
+  case_sensitive: bool,
+  missing: Option<SortMissing>,
+) -> std::cmp::Ordering {
   let compare = |value_a: &String, value_b: &String| {
     if case_sensitive {
       value_a.cmp(value_b)
@@ -458,7 +491,19 @@ fn compare_sort_values(values_a: &[String], values_b: &[String], sort_fields: &[
     }
   };
 
+  let missing_ordering = |value_a: &String, value_b: &String| match (missing, value_a.is_empty(), value_b.is_empty()) {
+    (Some(SortMissing::First), true, false) => Some(std::cmp::Ordering::Less),
+    (Some(SortMissing::First), false, true) => Some(std::cmp::Ordering::Greater),
+    (Some(SortMissing::Last), true, false) => Some(std::cmp::Ordering::Greater),
+    (Some(SortMissing::Last), false, true) => Some(std::cmp::Ordering::Less),
+    _ => None,
+  };
+
   for (index, field) in sort_fields.iter().enumerate().take(values_a.len()) {
+    if let Some(ordering) = missing_ordering(&values_a[index], &values_b[index]) {
+      return ordering;
+    }
+
     let ordering = compare(&values_a[index], &values_b[index]);
     let ordering = if field.ascending { ordering } else { ordering.reverse() };
 
@@ -468,18 +513,18 @@ fn compare_sort_values(values_a: &[String], values_b: &[String], sort_fields: &[
   }
 
   if sort_fields.is_empty() && !values_a.is_empty() && !values_b.is_empty() {
-    return compare(&values_a[0], &values_b[0]);
+    return missing_ordering(&values_a[0], &values_b[0]).unwrap_or_else(|| compare(&values_a[0], &values_b[0]));
   }
 
   std::cmp::Ordering::Equal
 }
 
-fn strip_bracket_suffix(path: &str) -> Option<&str> {
-  if path == "[]" {
+fn strip_bracket_suffix(selector: &str) -> Option<&str> {
+  if selector == "[]" {
     Some("")
-  } else if let Some(stripped) = path.strip_suffix(".[]") {
+  } else if let Some(stripped) = selector.strip_suffix(".[]") {
     Some(stripped)
   } else {
-    path.strip_suffix("[]")
+    selector.strip_suffix("[]")
   }
 }