yerba 0.9.2-aarch64-linux-gnu → 0.10.0-aarch64-linux-gnu

data/rust/src/commands/get.rs

@@ -45,9 +45,9 @@ pub struct Args {
 impl Args {
   pub fn run(self) {
     let selector = yerba::Selector::parse(&self.selector);
-    let condition_path = self.condition.as_deref().map(yerba::Selector::parse);
+    let condition_selector = self.condition.as_deref().map(yerba::Selector::parse);
     let select_fields: Option<Vec<&str>> = self.select.as_deref().map(|fields| fields.split(',').collect());
-    let (search_path, extract_field) = self.resolve_search_scope(&selector, condition_path.as_ref());
+    let (search_selector, extract_field) = self.resolve_search_scope(&selector, condition_selector.as_ref());
 
     let normalized_condition = self.condition.as_ref().map(|condition| {
       if !condition.starts_with('.') {
@@ -73,7 +73,7 @@ impl Args {
       }
     }
 
-    let search_path_string = search_path.to_selector_string();
+    let search_selector_string = search_selector.to_selector_string();
     let mut all_results: Vec<serde_json::Value> = Vec::new();
     let files = resolve_files(&self.file);
     let is_glob = files.len() > 1;
@@ -97,10 +97,10 @@ impl Args {
 
         for field in fields {
           let field_trimmed = field.trim().trim_start_matches('.');
-          let full_selector = if search_path_string.is_empty() {
+          let full_selector = if search_selector_string.is_empty() {
             field_trimmed.to_string()
           } else {
-            format!("{}.{}", search_path_string, field_trimmed)
+            format!("{}.{}", search_selector_string, field_trimmed)
           };
 
           if !document.exists(&full_selector) {
@@ -122,24 +122,24 @@ impl Args {
 
       let (values, selectors, lines): (Vec<yaml_serde::Value>, Vec<String>, Vec<usize>) = if select_fields.is_some() {
         if let Some(condition) = &normalized_condition {
-          let triples = document.filter_with_selectors(&search_path_string, condition).unwrap_or_default();
+          let triples = document.filter_with_selectors(&search_selector_string, condition).unwrap_or_default();
           let (values, rest): (Vec<_>, Vec<_>) = triples.into_iter().map(|(v, s, l)| (v, (s, l))).unzip();
           let (selectors, lines): (Vec<_>, Vec<_>) = rest.into_iter().unzip();
 
           (values, selectors, lines)
         } else {
-          let located = document.get_all_located(&search_path_string);
+          let located = document.get_all_located(&search_selector_string);
           let selectors = located.iter().map(|n| n.selector.clone()).collect();
           let lines = located.iter().map(|n| n.line).collect();
-          let values = document.get_values(&search_path_string);
+          let values = document.get_values(&search_selector_string);
           let values: Vec<_> = values.into_iter().filter(|v| !v.is_null()).collect();
 
           (values, selectors, lines)
         }
       } else if let Some(condition) = &normalized_condition {
-        (document.filter(&search_path_string, condition).unwrap_or_default(), Vec::new(), Vec::new())
+        (document.filter(&search_selector_string, condition).unwrap_or_default(), Vec::new(), Vec::new())
       } else {
-        (document.get_values(&search_path_string), Vec::new(), Vec::new())
+        (document.get_values(&search_selector_string), Vec::new(), Vec::new())
       };
 
       for (index, value) in values.iter().enumerate() {
@@ -216,8 +216,8 @@ impl Args {
     }
   }
 
-  fn resolve_search_scope(&self, selector: &yerba::Selector, condition_path: Option<&yerba::Selector>) -> (yerba::Selector, Option<yerba::Selector>) {
-    if let Some(condition) = condition_path {
+  fn resolve_search_scope(&self, selector: &yerba::Selector, condition_selector: Option<&yerba::Selector>) -> (yerba::Selector, Option<yerba::Selector>) {
+    if let Some(condition) = condition_selector {
       if condition.is_relative() {
         let (container, field) = selector.split_at_last_bracket();
 

data/rust/src/commands/init.rs

@@ -25,12 +25,12 @@ pub fn run() {
     #
     #       # Override quote style for a specific selector
     #       - quote_style:
-    #           path: "[].speakers"
+    #           selector: "[].speakers"
     #           value_style: plain
     #
     #       # Sort keys in a predefined order (aborts on unknown keys)
     #       - sort_keys:
-    #           path: "[]"
+    #           selector: "[]"
     #           order:
     #             - id
     #             - title
@@ -38,7 +38,7 @@ pub fn run() {
     #
     #       # Sort items in a sequence by field(s)
     #       - sort:
-    #           path: ""
+    #           selector: ""
     #           by: name
     #           # case_sensitive: false
     #
@@ -54,19 +54,19 @@ pub fn run() {
     #
     #       # Set a value (with optional condition)
     #       - set:
-    #           path: "status"
+    #           selector: "status"
     #           value: "published"
     #           # condition: ".draft == true"
     #
     #       # Insert a new key or sequence item
     #       - insert:
-    #           path: "tags"
+    #           selector: "tags"
     #           value: "yaml"
     #           # condition: ".tags not_contains yaml"
     #
     #       # Delete a key (with optional condition)
     #       - delete:
-    #           path: "deprecated_field"
+    #           selector: "deprecated_field"
     #           # condition: ".deprecated_field == true"
     #
     #       # Rename a key
@@ -76,12 +76,12 @@ pub fn run() {
     #
     #       # Remove an item from a sequence
     #       - remove:
-    #           path: "tags"
+    #           selector: "tags"
     #           value: "obsolete"
     #
     #       # Get a value and store it as a variable
     #       - get:
-    #           path: "[].name"
+    #           selector: "[].name"
     #           as: "names"
     #           # file: "other_file.yml"
   "#};

data/rust/src/commands/insert.rs

@@ -4,7 +4,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, resolve_files, run_op};
+use super::{default_insert_position, output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -81,28 +81,14 @@ impl Args {
       std::process::exit(1);
     };
 
-    let parent_path = self.selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
-
     let position = if let Some(index) = self.at {
       yerba::InsertPosition::At(index)
     } else if let Some(target) = self.before {
-      if target.starts_with('.') {
-        yerba::InsertPosition::BeforeCondition(target)
-      } else {
-        yerba::InsertPosition::Before(target)
-      }
+      yerba::InsertPosition::before(target)
     } else if let Some(target) = self.after {
-      if target.starts_with('.') {
-        yerba::InsertPosition::AfterCondition(target)
-      } else {
-        yerba::InsertPosition::After(target)
-      }
+      yerba::InsertPosition::after(target)
     } else {
-      yerba::Yerbafile::find()
-        .and_then(|yerbafile_path| yerba::Yerbafile::load(&yerbafile_path).ok())
-        .and_then(|yerbafile| yerbafile.sort_order_for(&self.file, parent_path))
-        .map(yerba::InsertPosition::FromSortOrder)
-        .unwrap_or(yerba::InsertPosition::Last)
+      default_insert_position(&self.file, &self.selector)
     };
 
     for resolved_file in resolve_files(&self.file) {

data/rust/src/commands/location.rs

@@ -49,6 +49,8 @@ impl Args {
       "end_column": info.location.end_column,
       "start_offset": info.location.start_offset,
       "end_offset": info.location.end_offset,
+      "start_character_column": info.location.start_character_column,
+      "end_character_column": info.location.end_character_column,
     });
 
     println!("{}", serde_json::to_string_pretty(&json).unwrap_or_default());

data/rust/src/commands/mod.rs

@@ -196,6 +196,24 @@ pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
     ui::subtle(format!("(from {})", yerbafile_path.display()))
   );
 
+  if !yerbafile.deprecated_path_keys.is_empty() {
+    let keys = &yerbafile.deprecated_path_keys;
+    let mut places = keys.iter().take(3).cloned().collect::<Vec<_>>().join(", ");
+
+    if keys.len() > 3 {
+      places.push_str(&format!(" and {} more", keys.len() - 3));
+    }
+
+    eprintln!(
+      "{} {} is deprecated, use {} instead ({}: {})\n",
+      ui::pending("Warning:"),
+      ui::strong("path:"),
+      ui::strong("selector:"),
+      pluralize(keys.len(), "place", "places"),
+      places
+    );
+  }
+
   let started = std::time::Instant::now();
 
   let results = if files.is_empty() {
@@ -309,14 +327,14 @@ fn format_duration(elapsed: std::time::Duration) -> String {
 
 pub(crate) fn resolve_move_indexes(
   document: &yerba::Document,
-  path: &str,
+  selector: &str,
   item: &str,
   before: Option<String>,
   after: Option<String>,
   to: Option<usize>,
   resolve: impl Fn(&yerba::Document, &str, &str) -> Result<usize, yerba::YerbaError>,
 ) -> (usize, usize) {
-  let from_index = resolve(document, path, item).unwrap_or_else(|error| {
+  let from_index = resolve(document, selector, item).unwrap_or_else(|error| {
     eprintln!("{} {}", ui::failure("Error:"), error);
     process::exit(1);
   });
@@ -324,7 +342,7 @@ pub(crate) fn resolve_move_indexes(
   let to_index = if let Some(index) = to {
     index
   } else if let Some(target) = &before {
-    let target_index = resolve(document, path, target).unwrap_or_else(|error| {
+    let target_index = resolve(document, selector, target).unwrap_or_else(|error| {
       eprintln!("{} {}", ui::failure("Error:"), error);
       process::exit(1);
     });
@@ -335,7 +353,7 @@ pub(crate) fn resolve_move_indexes(
       target_index
     }
   } else if let Some(target) = &after {
-    let target_index = resolve(document, path, target).unwrap_or_else(|error| {
+    let target_index = resolve(document, selector, target).unwrap_or_else(|error| {
       eprintln!("{} {}", ui::failure("Error:"), error);
       process::exit(1);
     });
@@ -417,7 +435,7 @@ pub(crate) fn run_op_with_hint(display_file: &str, document: &yerba::Document, r
   }
 }
 
-pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, invalid_path: &str) {
+pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, invalid_selector: &str) {
   use yerba::didyoumean::didyoumean_ranked;
 
   let selectors = document.selectors();
@@ -426,7 +444,7 @@ pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, inv
     return;
   }
 
-  let query = invalid_path.split_whitespace().next().unwrap_or(invalid_path);
+  let query = invalid_selector.split_whitespace().next().unwrap_or(invalid_selector);
   let threshold = query.len() / 2 + 3;
   let close = didyoumean_ranked(query, &selectors, threshold);
 
@@ -468,3 +486,13 @@ pub(crate) fn output(file: &str, document: &yerba::Document, dry_run: bool) {
     });
   }
 }
+
+pub(crate) fn default_insert_position(file: &str, selector: &str) -> yerba::InsertPosition {
+  let parent_selector = selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+
+  yerba::Yerbafile::find()
+    .and_then(|yerbafile_path| yerba::Yerbafile::load(&yerbafile_path).ok())
+    .and_then(|yerbafile| yerbafile.sort_order_for(file, parent_selector))
+    .map(yerba::InsertPosition::FromSortOrder)
+    .unwrap_or(yerba::InsertPosition::Last)
+}

data/rust/src/commands/move_item.rs

@@ -45,7 +45,7 @@ impl Args {
       self.before,
       self.after,
       self.to,
-      |document, path, reference| document.resolve_sequence_index(path, reference),
+      |document, selector, reference| document.resolve_sequence_index(selector, reference),
     );
 
     let result = document.move_item(&self.selector, from_index, to_index);

data/rust/src/commands/move_key.rs

@@ -36,16 +36,16 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let (parent_path, key) = self.selector.rsplit_once('.').unwrap_or(("", &self.selector));
+    let (parent_selector, key) = self.selector.rsplit_once('.').unwrap_or(("", &self.selector));
 
     let mut document = parse_file(&self.file);
 
     let before_key = self.before.map(|target| {
       let (target_parent, target_key) = target.rsplit_once('.').unwrap_or(("", &target));
 
-      if target_parent != parent_path {
+      if target_parent != parent_selector {
         eprintln!(
-          "{} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
+          "{} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different map.",
           ui::failure("Error:"),
           self.selector,
           target
@@ -60,9 +60,9 @@ impl Args {
     let after_key = self.after.map(|target| {
       let (target_parent, target_key) = target.rsplit_once('.').unwrap_or(("", &target));
 
-      if target_parent != parent_path {
+      if target_parent != parent_selector {
         eprintln!(
-          "{} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
+          "{} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different map.",
           ui::failure("Error:"),
           self.selector,
           target
@@ -76,15 +76,15 @@ impl Args {
 
     let (from_index, to_index) = resolve_move_indexes(
       &document,
-      parent_path,
+      parent_selector,
       key,
       before_key,
       after_key,
       self.to,
-      |document, parent_path, reference| document.resolve_key_index(parent_path, reference),
+      |document, parent_selector, reference| document.resolve_key_index(parent_selector, reference),
     );
 
-    let result = document.move_key(parent_path, from_index, to_index);
+    let result = document.move_key(parent_selector, from_index, to_index);
     run_op(&self.file, &document, result);
     output(&self.file, &document, self.dry_run);
   }

data/rust/src/commands/rename.rs

@@ -16,7 +16,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
 
 #[derive(clap::Args)]
 #[command(
-  about = "Rename a key, or move it to another map (the destination is a full selector path)",
+  about = "Rename a key, or move it to another map (the destination is a full selector)",
   arg_required_else_help = true,
   after_help = EXAMPLES.as_str()
 )]

data/rust/src/commands/selectors.rs

@@ -25,7 +25,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
 )]
 pub struct Args {
   file: String,
-  /// Show selectors starting from this path
+  /// Show selectors starting from this selector
   selector: Option<String>,
   /// Sort selectors alphabetically (default: document order)
   #[arg(long)]

data/rust/src/commands/set.rs

@@ -3,12 +3,13 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, resolve_files, run_op_with_hint};
+use super::{default_insert_position, output, parse_file, resolve_files, run_op_with_hint};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
     yerba set config.yml "database.host" "0.0.0.0"
     yerba set config.yml "database.host" "0.0.0.0" --if-exists
+    yerba set config.yml "database.pool" 5 --plain --if-missing
     yerba set config.yml "database.host" "0.0.0.0" --condition ".port == 5432"
     yerba set videos.yml "[0].title" "New Title"
     yerba set videos.yml "[].title" "New Title" --condition ".id == talk-1"
@@ -21,7 +22,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
 
 #[derive(clap::Args)]
 #[command(
-  about = "Update an existing value at a path (preserves quote style)",
+  about = "Update an existing value at a selector (preserves quote style)",
   arg_required_else_help = true,
   after_help = EXAMPLES.as_str()
 )]
@@ -46,7 +47,7 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let parent_path = self.selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+    let parent_selector = self.selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
     if let Some(condition) = &self.condition {
       if let Err(error) = yerba::validate_condition(condition) {
@@ -59,7 +60,7 @@ impl Args {
     }
 
     let leaf = self.selector.rsplit_once('.').map(|(_, leaf)| leaf).unwrap_or(&self.selector);
-    let per_item = yerba::Selector::parse(parent_path).has_brackets();
+    let per_item = yerba::Selector::parse(parent_selector).has_brackets();
 
     for resolved_file in resolve_files(&self.file) {
       let mut document = parse_file(&resolved_file);
@@ -69,14 +70,21 @@ impl Args {
       } else if self.if_missing {
         !document.exists(&self.selector)
       } else if let Some(condition) = &self.condition {
-        per_item || document.evaluate_condition(parent_path, condition).unwrap_or(false)
+        per_item || document.evaluate_condition(parent_selector, condition).unwrap_or(false)
       } else {
         true
       };
 
       if should_set {
         let result = match &self.condition {
-          Some(condition) if per_item => document.set_where(parent_path, leaf, &self.value, condition, self.all, self.plain).map(|_| ()),
+          _ if self.if_missing => {
+            let value = if self.plain { self.value.clone() } else { yerba::quote_scalar(&self.value) };
+
+            document.insert_into(&self.selector, &value, default_insert_position(&self.file, &self.selector))
+          }
+          Some(condition) if per_item => document
+            .set_where(parent_selector, leaf, &self.value, condition, self.all, self.plain)
+            .map(|_| ()),
           _ if self.all && self.plain => document.set_all_plain(&self.selector, &self.value),
           _ if self.all => document.set_all(&self.selector, &self.value),
           _ if self.plain => document.set_plain(&self.selector, &self.value),

data/rust/src/document/condition.rs

@@ -47,12 +47,12 @@ pub fn validate_item_condition(condition: &str) -> Result<(), YerbaError> {
 }
 
 impl Document {
-  pub fn filter(&self, dot_path: &str, condition: &str) -> Result<Vec<yaml_serde::Value>, YerbaError> {
+  pub fn filter(&self, selector: &str, condition: &str) -> Result<Vec<yaml_serde::Value>, YerbaError> {
     validate_item_condition(condition)?;
 
     Ok(
       self
-        .navigate_all_compact(dot_path)
+        .navigate_all_compact(selector)
         .iter()
         .filter(|node| self.evaluate_condition_on_node(node, condition))
         .map(node_to_yaml_value)
@@ -60,14 +60,14 @@ impl Document {
     )
   }
 
-  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Result<Vec<(yaml_serde::Value, String, usize)>, YerbaError> {
+  pub fn filter_with_selectors(&self, selector: &str, condition: &str) -> Result<Vec<(yaml_serde::Value, String, usize)>, YerbaError> {
     validate_item_condition(condition)?;
 
     let source = self.source_text();
 
     Ok(
       self
-        .navigate_all_compact(dot_path)
+        .navigate_all_compact(selector)
         .iter()
         .filter(|node| self.evaluate_condition_on_node(node, condition))
         .map(|node| {
@@ -88,13 +88,13 @@ impl Document {
       None => return false,
     };
 
-    let path = crate::selector::Selector::parse(&left);
+    let parsed = crate::selector::Selector::parse(&left);
 
-    if !path.is_relative() {
+    if !parsed.is_relative() {
       return false;
     }
 
-    let target_nodes = navigate_from_node(node, &path.to_selector_string());
+    let target_nodes = navigate_from_node(node, &parsed.to_selector_string());
     let values: Vec<String> = target_nodes.iter().filter_map(extract_scalar_text).collect();
 
     match operator {
@@ -138,8 +138,8 @@ impl Document {
     }
   }
 
-  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> Result<bool, YerbaError> {
-    if parent_path.is_empty() {
+  pub fn evaluate_condition(&self, parent_selector: &str, condition: &str) -> Result<bool, YerbaError> {
+    if parent_selector.is_empty() {
       validate_condition(condition)?;
     } else {
       validate_item_condition(condition)?;
@@ -152,55 +152,55 @@ impl Document {
       None => return Ok(false),
     };
 
-    let path = crate::selector::Selector::parse(&left);
-    let path_string = path.to_selector_string();
+    let parsed = crate::selector::Selector::parse(&left);
+    let selector_string = parsed.to_selector_string();
 
-    let full_path = if parent_path.is_empty() {
-      path_string
+    let full_selector = if parent_selector.is_empty() {
+      selector_string
     } else {
-      format!("{}.{}", parent_path, path_string)
+      format!("{}.{}", parent_selector, selector_string)
     };
 
-    let has_brackets = crate::selector::Selector::parse(&full_path).has_brackets();
+    let has_brackets = crate::selector::Selector::parse(&full_selector).has_brackets();
 
     let result = match operator {
       "==" => {
         if has_brackets {
-          self.get_all(&full_path).iter().any(|value| value == &right)
+          self.get_all(&full_selector).iter().any(|value| value == &right)
         } else {
-          self.get(&full_path).unwrap_or_default() == right
+          self.get(&full_selector).unwrap_or_default() == right
         }
       }
       "!=" => {
         if has_brackets {
-          self.get_all(&full_path).iter().all(|value| value != &right)
+          self.get_all(&full_selector).iter().all(|value| value != &right)
         } else {
-          self.get(&full_path).unwrap_or_default() != right
+          self.get(&full_selector).unwrap_or_default() != right
         }
       }
       "contains" => {
         if has_brackets {
-          self.get_all(&full_path).iter().any(|value| value == &right || value.contains(&right))
+          self.get_all(&full_selector).iter().any(|value| value == &right || value.contains(&right))
         } else {
-          let items = self.get_sequence_values(&full_path);
+          let items = self.get_sequence_values(&full_selector);
 
           if !items.is_empty() {
             items.iter().any(|item| item == &right)
           } else {
-            self.get(&full_path).map(|value| value.contains(&right)).unwrap_or(false)
+            self.get(&full_selector).map(|value| value.contains(&right)).unwrap_or(false)
           }
         }
       }
       "not_contains" => {
         if has_brackets {
-          self.get_all(&full_path).iter().all(|value| value != &right && !value.contains(&right))
+          self.get_all(&full_selector).iter().all(|value| value != &right && !value.contains(&right))
         } else {
-          let items = self.get_sequence_values(&full_path);
+          let items = self.get_sequence_values(&full_selector);
 
           if !items.is_empty() {
             !items.iter().any(|item| item == &right)
           } else {
-            self.get(&full_path).map(|value| !value.contains(&right)).unwrap_or(true)
+            self.get(&full_selector).map(|value| !value.contains(&right)).unwrap_or(true)
           }
         }
       }