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

data/rust/src/document/delete.rs

@@ -1,70 +1,72 @@
 use super::*;
 
 impl Document {
-  pub fn rename(&mut self, source_path: &str, destination_path: &str) -> Result<(), YerbaError> {
-    Self::validate_path(source_path)?;
-    Self::validate_path(destination_path)?;
+  pub fn rename(&mut self, source_selector: &str, destination_selector: &str) -> Result<(), YerbaError> {
+    Self::validate_selector(source_selector)?;
+    Self::validate_selector(destination_selector)?;
 
-    let source_parent = source_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
-    let destination_parent = destination_path.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
-    let destination_key = destination_path.rsplit_once('.').map(|(_, key)| key).unwrap_or(destination_path);
+    let source_parent = source_selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+    let destination_parent = destination_selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+    let destination_key = destination_selector.rsplit_once('.').map(|(_, key)| key).unwrap_or(destination_selector);
 
     if source_parent == destination_parent {
-      let (parent_path, source_key) = source_path.rsplit_once('.').unwrap_or(("", source_path));
+      let (parent_selector, source_key) = source_selector.rsplit_once('.').unwrap_or(("", source_selector));
 
-      let parent_node = self.navigate(parent_path)?;
-      let map = find_block_map(&parent_node).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+      let parent_node = self.navigate(parent_selector)?;
+      let map = find_block_map(&parent_node).ok_or_else(|| YerbaError::SelectorNotFound(source_selector.to_string()))?;
 
-      let entry = find_entry_by_key(&map, source_key).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
-      let key_node = entry.key().ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
-      let key_token = find_scalar_token(key_node.syntax()).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+      let entry = find_entry_by_key(&map, source_key).ok_or_else(|| YerbaError::SelectorNotFound(source_selector.to_string()))?;
+      let key_node = entry.key().ok_or_else(|| YerbaError::SelectorNotFound(source_selector.to_string()))?;
+      let key_token = find_scalar_token(key_node.syntax()).ok_or_else(|| YerbaError::SelectorNotFound(source_selector.to_string()))?;
       let new_text = format_scalar_value(destination_key, key_token.kind());
 
       self.replace_token(&key_token, &new_text)
     } else {
-      let value = self.get(source_path).ok_or_else(|| YerbaError::SelectorNotFound(source_path.to_string()))?;
+      let value = self
+        .get(source_selector)
+        .ok_or_else(|| YerbaError::SelectorNotFound(source_selector.to_string()))?;
 
-      self.delete(source_path)?;
-      self.insert_into(destination_path, &value, InsertPosition::Last)
+      self.delete(source_selector)?;
+      self.insert_into(destination_selector, &value, InsertPosition::Last)
     }
   }
 
-  pub fn delete(&mut self, dot_path: &str) -> Result<(), YerbaError> {
-    Self::validate_path(dot_path)?;
-    self.refuse_flow_target(dot_path)?;
+  pub fn delete(&mut self, selector: &str) -> Result<(), YerbaError> {
+    Self::validate_selector(selector)?;
+    self.refuse_flow_target(selector)?;
 
-    let selector = crate::selector::Selector::parse(dot_path);
-    let segments = selector.segments();
-    let last_segment = segments.last().ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
-    let parent_path = selector.parent_path();
+    let parsed = crate::selector::Selector::parse(selector);
+    let segments = parsed.segments();
+    let last_segment = segments.last().ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
+    let parent_selector = parsed.parent_selector();
 
     match last_segment {
       crate::selector::SelectorSegment::Key(last_key) => {
-        let has_wildcard = selector.has_wildcard();
-        let has_brackets = selector.has_brackets();
+        let has_wildcard = parsed.has_wildcard();
+        let has_brackets = parsed.has_brackets();
 
-        if parent_path.is_empty() && (!has_wildcard || !has_brackets) {
-          let parent_node = self.navigate(&parent_path)?;
-          let map = find_block_map(&parent_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+        if parent_selector.is_empty() && (!has_wildcard || !has_brackets) {
+          let parent_node = self.navigate(&parent_selector)?;
+          let map = find_block_map(&parent_node).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
-          let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+          let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
           return self.remove_map_entry(&entry);
         }
 
-        let parent_nodes = self.navigate_all_compact(&parent_path);
+        let parent_nodes = self.navigate_all_compact(&parent_selector);
 
         if parent_nodes.is_empty() {
           if has_wildcard {
             return Ok(());
           }
 
-          return Err(YerbaError::SelectorNotFound(dot_path.to_string()));
+          return Err(YerbaError::SelectorNotFound(selector.to_string()));
         }
 
         if parent_nodes.len() == 1 && (!has_wildcard || !has_brackets) {
-          let map = find_block_map(&parent_nodes[0]).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
-          let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+          let map = find_block_map(&parent_nodes[0]).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
+          let entry = find_entry_by_key(&map, last_key).ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
 
           if map.entries().count() == 1 {
             return self.collapse_to_empty_flow_map(&parent_nodes[0]);
@@ -88,19 +90,31 @@ impl Document {
         self.apply_edits(edits)
       }
 
-      crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_path, *index),
-      crate::selector::SelectorSegment::AllItems | crate::selector::SelectorSegment::AllKeys => Err(YerbaError::SelectorNotFound(dot_path.to_string())),
+      crate::selector::SelectorSegment::Index(index) => self.remove_at(&parent_selector, *index),
+      crate::selector::SelectorSegment::IndexFromEnd(_) => {
+        let parent_node = self.navigate(&parent_selector)?;
+        let length = find_block_sequence(&parent_node)
+          .map(|sequence| sequence.entries().count())
+          .or_else(|| find_flow_sequence(&parent_node).map(|sequence| flow_sequence_entries(&sequence).len()))
+          .ok_or_else(|| YerbaError::NotASequence(parent_selector.clone()))?;
+        let index = last_segment
+          .sequence_index(length)
+          .ok_or_else(|| YerbaError::SelectorNotFound(selector.to_string()))?;
+
+        self.remove_at(&parent_selector, index)
+      }
+      crate::selector::SelectorSegment::AllItems | crate::selector::SelectorSegment::AllKeys => Err(YerbaError::SelectorNotFound(selector.to_string())),
     }
   }
 
-  pub fn remove(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    let current_node = self.navigate(dot_path)?;
+  pub fn remove(&mut self, selector: &str, value: &str) -> Result<(), YerbaError> {
+    let current_node = self.navigate(selector)?;
 
     if find_flow_sequence(&current_node).is_some() {
-      return Err(YerbaError::FlowCollectionNotWritable(dot_path.to_string()));
+      return Err(YerbaError::FlowCollectionNotWritable(selector.to_string()));
     }
 
-    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 target_entry = sequence
       .entries()
@@ -111,7 +125,7 @@ impl Document {
           .map(|text| text == value)
           .unwrap_or(false)
       })
-      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", dot_path, value)))?;
+      .ok_or_else(|| YerbaError::SelectorNotFound(format!("{} item '{}'", selector, value)))?;
 
     if sequence.entries().count() == 1 {
       return self.collapse_to_empty_flow_sequence(&current_node);
@@ -120,12 +134,12 @@ impl Document {
     self.remove_node(target_entry.syntax())
   }
 
-  pub fn remove_at(&mut self, dot_path: &str, index: usize) -> Result<(), YerbaError> {
-    Self::validate_path(dot_path)?;
+  pub fn remove_at(&mut self, selector: &str, index: usize) -> Result<(), YerbaError> {
+    Self::validate_selector(selector)?;
 
-    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();
 

data/rust/src/document/get.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-fn key_of(node: &SyntaxNode, source: &str) -> (Option<String>, Location) {
+fn key_of(node: &SyntaxNode, index: &LineIndex) -> (Option<String>, Location) {
   node
     .parent()
     .and_then(|parent| {
@@ -13,7 +13,7 @@ fn key_of(node: &SyntaxNode, source: &str) -> (Option<String>, Location) {
 
       let key_text = extract_scalar_text(&key_node)?;
       let key_range = key_node.text_range();
-      let key_location = compute_location(source, key_range.start().into(), key_range.end().into());
+      let key_location = compute_location(index, key_range.start().into(), key_range.end().into());
 
       Some((key_text, key_location))
     })
@@ -22,30 +22,39 @@ fn key_of(node: &SyntaxNode, source: &str) -> (Option<String>, Location) {
 }
 
 impl Document {
-  pub fn is_valid_selector(&self, dot_path: &str) -> bool {
-    if dot_path.is_empty() {
+  pub fn is_valid_selector(&self, selector: &str) -> bool {
+    if selector.is_empty() {
       return true;
     }
 
     let selectors = self.selectors();
 
-    if selectors.contains(&dot_path.to_string()) {
+    if selectors.contains(&selector.to_string()) {
       return true;
     }
 
-    if crate::selector::Selector::parse(dot_path).has_wildcard() && !self.navigate_all_compact(dot_path).is_empty() {
+    if crate::selector::Selector::parse(selector).has_wildcard() && !self.navigate_all_compact(selector).is_empty() {
       return true;
     }
 
-    let wildcard_version = dot_path.replace(|c: char| c.is_ascii_digit(), "").replace("[.", "[");
+    let wildcard_version = selector.replace(|c: char| c.is_ascii_digit(), "").replace("[.", "[");
 
     let mut normalized = String::new();
-    let mut chars = dot_path.chars().peekable();
+    let mut chars = selector.chars().peekable();
 
     while let Some(char) = chars.next() {
       if char == '[' {
         normalized.push('[');
 
+        if chars.peek() == Some(&'-') {
+          let mut lookahead = chars.clone();
+          lookahead.next();
+
+          if lookahead.peek().map(|char| char.is_ascii_digit()).unwrap_or(false) {
+            chars.next();
+          }
+        }
+
         while chars.peek().map(|char| char.is_ascii_digit()).unwrap_or(false) {
           chars.next();
         }
@@ -57,26 +66,26 @@ impl Document {
     selectors.contains(&normalized) || selectors.contains(&wildcard_version)
   }
 
-  pub fn get(&self, dot_path: &str) -> Option<String> {
-    if dot_path.contains('[') {
-      return self.get_all(dot_path).into_iter().next();
+  pub fn get(&self, selector: &str) -> Option<String> {
+    if selector.contains('[') {
+      return self.get_all(selector).into_iter().next();
     }
 
-    let current_node = self.navigate(dot_path).ok()?;
+    let current_node = self.navigate(selector).ok()?;
 
     extract_scalar_text(&current_node)
   }
 
-  pub fn get_all(&self, dot_path: &str) -> Vec<String> {
-    self.navigate_all_compact(dot_path).iter().filter_map(extract_scalar_text).collect()
+  pub fn get_all(&self, selector: &str) -> Vec<String> {
+    self.navigate_all_compact(selector).iter().filter_map(extract_scalar_text).collect()
   }
 
-  pub fn get_typed(&self, dot_path: &str) -> Option<ScalarValue> {
-    if crate::selector::Selector::parse(dot_path).has_wildcard() {
-      return self.get_all_typed(dot_path).into_iter().next();
+  pub fn get_typed(&self, selector: &str) -> Option<ScalarValue> {
+    if crate::selector::Selector::parse(selector).has_wildcard() {
+      return self.get_all_typed(selector).into_iter().next();
     }
 
-    let current_node = self.navigate(dot_path).ok()?;
+    let current_node = self.navigate(selector).ok()?;
 
     if current_node.descendants().any(|child| {
       matches!(
@@ -90,9 +99,9 @@ impl Document {
     extract_scalar(&current_node)
   }
 
-  pub fn get_all_typed(&self, dot_path: &str) -> Vec<ScalarValue> {
+  pub fn get_all_typed(&self, selector: &str) -> Vec<ScalarValue> {
     self
-      .navigate_all_compact(dot_path)
+      .navigate_all_compact(selector)
       .iter()
       .filter(|node| {
         !node
@@ -103,15 +112,15 @@ impl Document {
       .collect()
   }
 
-  pub fn resolve_selectors(&self, dot_path: &str) -> Vec<String> {
-    self.navigate_all_compact(dot_path).iter().map(node_selector).collect()
+  pub fn resolve_selectors(&self, selector: &str) -> Vec<String> {
+    self.navigate_all_compact(selector).iter().map(node_selector).collect()
   }
 
-  pub fn keys_at(&self, dot_path: &str) -> Vec<String> {
-    let node = if dot_path.is_empty() {
+  pub fn keys_at(&self, selector: &str) -> Vec<String> {
+    let node = if selector.is_empty() {
       self.root.clone()
     } else {
-      match self.navigate_all_compact(dot_path).into_iter().next() {
+      match self.navigate_all_compact(selector).into_iter().next() {
         Some(node) => node,
         None => return Vec::new(),
       }
@@ -150,19 +159,19 @@ impl Document {
     Vec::new()
   }
 
-  pub fn get_all_located(&self, dot_path: &str) -> Vec<LocatedNode> {
-    let source = self.source_text();
+  pub fn get_all_located(&self, selector: &str) -> Vec<LocatedNode> {
+    let index = self.line_index();
     let file_path = self.path.as_ref().map(|p| p.to_string_lossy().to_string());
 
     self
-      .navigate_all_compact(dot_path)
+      .navigate_all_compact(selector)
       .iter()
       .map(|node| {
         let range = node.text_range();
         let offset: usize = range.start().into();
-        let line = line_at(&source, offset);
-        let location = compute_location(&source, offset, range.end().into());
-        let selector = node_selector(node);
+        let line = index.line_at(offset);
+        let location = compute_location(index, offset, range.end().into());
+        let item_selector = node_selector(node);
         let is_scalar = !node
           .descendants()
           .any(|child| child.kind() == SyntaxKind::BLOCK_MAP || child.kind() == SyntaxKind::BLOCK_SEQ);
@@ -184,14 +193,14 @@ impl Document {
           }
         };
 
-        let (key_name, key_location) = key_of(node, &source);
+        let (key_name, key_location) = key_of(node, index);
 
         LocatedNode {
           node_type: node_type.to_string(),
           text,
           value_type,
           file_path: file_path.clone(),
-          selector,
+          selector: item_selector,
           line,
           location,
           key_name,
@@ -201,8 +210,8 @@ impl Document {
       .collect()
   }
 
-  pub fn node_type(&self, dot_path: &str) -> NodeType {
-    match self.get_value(dot_path) {
+  pub fn node_type(&self, selector: &str) -> NodeType {
+    match self.get_value(selector) {
       Some(yaml_serde::Value::Mapping(_)) => NodeType::Map,
       Some(yaml_serde::Value::Sequence(_)) => NodeType::Sequence,
       Some(_) => NodeType::Scalar,
@@ -210,14 +219,14 @@ impl Document {
     }
   }
 
-  pub fn get_node_info(&self, dot_path: &str) -> NodeInfo {
-    let selector = crate::selector::Selector::parse(dot_path);
-    let source = self.source_text();
+  pub fn get_node_info(&self, selector: &str) -> NodeInfo {
+    let parsed = crate::selector::Selector::parse(selector);
+    let index = self.line_index();
 
-    let (location, key_name, key_location) = self.resolve_location(dot_path, &source);
+    let (location, key_name, key_location) = self.resolve_location(selector);
 
-    if selector.has_wildcard() {
-      let values = self.get_all_typed(dot_path);
+    if parsed.has_wildcard() {
+      let values = self.get_all_typed(selector);
 
       return NodeInfo {
         node_type: NodeType::Sequence,
@@ -230,7 +239,7 @@ impl Document {
       };
     }
 
-    match self.get_typed(dot_path) {
+    match self.get_typed(selector) {
       Some(scalar) => NodeInfo {
         node_type: NodeType::Scalar,
         is_list: false,
@@ -241,17 +250,17 @@ impl Document {
         key_location,
       },
       None => {
-        let (node_type, entry_location, entry_key_name, entry_key_location) = if self.navigate(dot_path).is_err() {
-          if let Some(entry_node) = self.find_entry(dot_path) {
+        let (node_type, entry_location, entry_key_name, entry_key_location) = if self.navigate(selector).is_err() {
+          if let Some(entry_node) = self.find_entry(selector) {
             let range = entry_node.text_range();
-            let entry_location = compute_location(&source, range.start().into(), range.end().into());
+            let entry_location = compute_location(index, range.start().into(), range.end().into());
 
             let (node, location) = yaml_parser::ast::BlockMapEntry::cast(entry_node.clone())
               .and_then(|entry| {
                 entry.key().and_then(|key_node| {
                   let key_text = extract_scalar_text(key_node.syntax())?;
                   let key_range = key_node.syntax().text_range();
-                  let key_location = compute_location(&source, key_range.start().into(), key_range.end().into());
+                  let key_location = compute_location(index, key_range.start().into(), key_range.end().into());
 
                   Some((key_text, key_location))
                 })
@@ -261,10 +270,10 @@ impl Document {
 
             (NodeType::Scalar, entry_location, node, location)
           } else {
-            (self.node_type(dot_path), location, key_name, key_location)
+            (self.node_type(selector), location, key_name, key_location)
           }
         } else {
-          (self.node_type(dot_path), location, key_name, key_location)
+          (self.node_type(selector), location, key_name, key_location)
         };
 
         NodeInfo {
@@ -280,13 +289,13 @@ impl Document {
     }
   }
 
-  fn resolve_location(&self, dot_path: &str, source: &str) -> (Location, Option<String>, Location) {
-    match self.navigate(dot_path) {
+  fn resolve_location(&self, selector: &str) -> (Location, Option<String>, Location) {
+    match self.navigate(selector) {
       Ok(node) => {
         let range = node.text_range();
-        let location = compute_location(source, range.start().into(), range.end().into());
+        let location = compute_location(self.line_index(), range.start().into(), range.end().into());
 
-        let (key_name, key_location) = key_of(&node, source);
+        let (key_name, key_location) = key_of(&node, self.line_index());
 
         (location, key_name, key_location)
       }
@@ -294,10 +303,10 @@ impl Document {
     }
   }
 
-  pub fn find_items(&self, dot_path: &str, condition: Option<&str>, select: Option<&str>) -> Result<Vec<serde_json::Value>, YerbaError> {
+  pub fn find_items(&self, selector: &str, condition: Option<&str>, select: Option<&str>) -> Result<Vec<serde_json::Value>, YerbaError> {
     let values = match condition {
-      Some(cond) => self.filter(dot_path, cond)?,
-      None => self.get_values(dot_path),
+      Some(cond) => self.filter(selector, cond)?,
+      None => self.get_values(selector),
     };
 
     let select_fields: Option<Vec<&str>> = select.map(|s| s.split(',').collect());
@@ -323,15 +332,15 @@ impl Document {
     Ok(items)
   }
 
-  pub fn get_value(&self, dot_path: &str) -> Option<yaml_serde::Value> {
-    if dot_path.is_empty() {
+  pub fn get_value(&self, selector: &str) -> Option<yaml_serde::Value> {
+    if selector.is_empty() {
       return Some(node_to_yaml_value(&self.root));
     }
 
-    let parsed = crate::selector::Selector::parse(dot_path);
+    let parsed = crate::selector::Selector::parse(selector);
 
     if parsed.has_wildcard() {
-      let padded = self.navigate_all(dot_path);
+      let padded = self.navigate_all(selector);
 
       if padded.is_empty() {
         return None;
@@ -347,7 +356,7 @@ impl Document {
 
       Some(yaml_serde::Value::Sequence(values))
     } else {
-      let nodes = self.navigate_all_compact(dot_path);
+      let nodes = self.navigate_all_compact(selector);
 
       if nodes.is_empty() {
         return None;
@@ -363,12 +372,12 @@ impl Document {
     }
   }
 
-  pub fn get_values(&self, dot_path: &str) -> Vec<yaml_serde::Value> {
-    let parsed = crate::selector::Selector::parse(dot_path);
+  pub fn get_values(&self, selector: &str) -> Vec<yaml_serde::Value> {
+    let parsed = crate::selector::Selector::parse(selector);
 
     if parsed.has_wildcard() {
       self
-        .navigate_all(dot_path)
+        .navigate_all(selector)
         .iter()
         .map(|maybe_node| match maybe_node {
           Some(node) => node_to_yaml_value(node),
@@ -376,7 +385,7 @@ impl Document {
         })
         .collect()
     } else {
-      self.navigate_all_compact(dot_path).iter().map(node_to_yaml_value).collect()
+      self.navigate_all_compact(selector).iter().map(node_to_yaml_value).collect()
     }
   }
 
@@ -394,30 +403,30 @@ impl Document {
     selectors
   }
 
-  pub fn exists(&self, dot_path: &str) -> bool {
-    if crate::selector::Selector::parse(dot_path).has_wildcard() {
-      if !self.navigate_all_compact(dot_path).is_empty() {
+  pub fn exists(&self, selector: &str) -> bool {
+    if crate::selector::Selector::parse(selector).has_wildcard() {
+      if !self.navigate_all_compact(selector).is_empty() {
         return true;
       }
-    } else if self.navigate(dot_path).is_ok() {
+    } else if self.navigate(selector).is_ok() {
       return true;
     }
 
-    self.find_entry(dot_path).is_some()
+    self.find_entry(selector).is_some()
   }
 
-  fn find_entry(&self, dot_path: &str) -> Option<SyntaxNode> {
-    let (parent_path, last_key) = match dot_path.rsplit_once('.') {
+  pub(crate) fn find_entry(&self, selector: &str) -> Option<SyntaxNode> {
+    let (parent_selector, last_key) = match selector.rsplit_once('.') {
       Some((parent, key)) => (parent, key),
-      None => ("", dot_path),
+      None => ("", selector),
     };
 
-    let parent_node = if parent_path.is_empty() {
+    let parent_node = if parent_selector.is_empty() {
       let root = Root::cast(self.root.clone())?;
       let document = root.documents().next()?;
       document.syntax().clone()
     } else {
-      self.navigate(parent_path).ok()?
+      self.navigate(parent_selector).ok()?
     };
 
     let map = find_block_map(&parent_node)?;
@@ -425,8 +434,8 @@ impl Document {
     find_entry_by_key(&map, last_key).map(|entry| entry.syntax().clone())
   }
 
-  pub fn get_sequence_values(&self, dot_path: &str) -> Vec<String> {
-    let current_node = match self.navigate(dot_path) {
+  pub fn get_sequence_values(&self, selector: &str) -> Vec<String> {
+    let current_node = match self.navigate(selector) {
       Ok(node) => node,
       Err(_) => return Vec::new(),
     };
@@ -442,8 +451,8 @@ impl Document {
       .collect()
   }
 
-  pub fn get_collection_style(&self, dot_path: &str) -> Option<&'static str> {
-    let current_node = self.navigate(dot_path).ok()?;
+  pub fn get_collection_style(&self, selector: &str) -> Option<&'static str> {
+    let current_node = self.navigate(selector).ok()?;
 
     for descendant in current_node.descendants() {
       match descendant.kind() {
@@ -456,8 +465,8 @@ impl Document {
     None
   }
 
-  pub fn get_sequence_indent(&self, dot_path: &str) -> Option<&'static str> {
-    let current_node = self.navigate(dot_path).ok()?;
+  pub fn get_sequence_indent(&self, selector: &str) -> Option<&'static str> {
+    let current_node = self.navigate(selector).ok()?;
 
     let sequence = find_block_sequence(&current_node)?;
     let first_entry = sequence.entries().next()?;
@@ -477,8 +486,8 @@ impl Document {
     }
   }
 
-  pub fn get_quote_style(&self, dot_path: &str) -> Option<&'static str> {
-    let current_node = self.navigate(dot_path).ok()?;
+  pub fn get_quote_style(&self, selector: &str) -> Option<&'static str> {
+    let current_node = self.navigate(selector).ok()?;
 
     for element in current_node.descendants_with_tokens() {
       match element.kind() {