yerba 0.9.1-arm-linux-gnu → 0.10.0-arm-linux-gnu

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,12 +224,12 @@ 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> {
+    if selector.contains("[].") {
+      return self.sort_each_items(selector, sort_fields, case_sensitive);
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = self.navigate(selector)?;
 
     let sequence = match find_block_sequence(&current_node) {
       Some(sequence) => sequence,
@@ -242,21 +242,21 @@ impl Document {
     }
   }
 
-  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) -> 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 {
@@ -274,20 +274,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 +332,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 {
@@ -439,10 +439,10 @@ 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()
       }
     })
@@ -474,12 +474,12 @@ fn compare_sort_values(values_a: &[String], values_b: &[String], sort_fields: &[
   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("[]")
   }
 }

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())
+}