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

data/lib/yerba/sequence.rb

@@ -45,6 +45,9 @@ module Yerba
 
     def value_at(index)
       if connected?
+        child = current_children&.[](index) if index.is_a?(Integer) && !index.negative?
+        return child.value if child.is_a?(Scalar)
+
         new_path = "#{@selector}[#{index}]"
         document.value_at(new_path)
       else
@@ -73,15 +76,15 @@ module Yerba
 
     def concat(items)
       if connected?
-        hashes = items.map do |item|
+        values = items.map do |item|
           case item
           when Map then item.to_hash
-          when Hash then item
-          else { value: item.to_s }
+          when Scalar then item.value
+          else item
           end
         end
 
-        document.insert_objects(@selector, hashes)
+        document.insert_objects(@selector, values)
       else
         @data.concat(items)
       end
@@ -92,6 +95,12 @@ module Yerba
     def each(&)
       return enum_for(:each) unless block_given?
 
+      if connected? && (tree = current_children)
+        tree.each { |child| yield child&.dup }
+
+        return self
+      end
+
       if connected?
         items = document.get_all("#{@selector}[]")
 
@@ -114,7 +123,7 @@ module Yerba
     end
 
     def where(selector = nil, value = nil, **criteria)
-      QueryResult.new(self, indices_of(selector, value, **criteria))
+      QueryResult.new(self, indices_of(selector, value, **criteria)) { indices_of(selector, value, **criteria) }
     end
 
     def pluck(*fields)
@@ -211,28 +220,24 @@ module Yerba
     end
 
     def length
-      if connected?
-        scalar_items = document.value_at("#{@selector}[]")
+      return @data.length unless connected?
 
-        if scalar_items.is_a?(Array) && !scalar_items.empty?
-          scalar_items.length
-        else
-          data = document.value_at(@selector)
-
-          data.is_a?(Array) ? data.length : 0
-        end
-      else
-        @data.length
-      end
+      current_children&.size || document.length_at(@selector)
     end
     alias size length
 
-    def first
-      self[0]
+    def first(count = nil)
+      return self[0] if count.nil?
+
+      super
     end
 
-    def last
-      self[length - 1] # rubocop:disable Style/NegativeArrayIndex
+    def last(count = nil)
+      size = length
+      return self[size - 1] if count.nil?
+      raise ArgumentError, "negative array size" if count.negative?
+
+      ([size - count, 0].max...size).map { |index| self[index] }
     end
 
     def remove(value)
@@ -263,15 +268,15 @@ module Yerba
       self
     end
 
-    def sort(by: nil, case_sensitive: false)
-      document&.sort(@selector, by: by, case_sensitive: case_sensitive)
+    def sort(by: nil, order: nil, case_sensitive: false)
+      document&.sort(@selector, by: by, order: order, case_sensitive: case_sensitive)
 
       self
     end
 
     # Deletes the entire sequence node from the YAML document.
     #
-    # Removes the sequence at its selector path from the parent document.
+    # Removes the sequence at its selector from the parent document.
     # Has no effect if the sequence is not connected to a document.
     #
     # Returns the document, or +nil+ if the sequence is not connected to a document.
@@ -345,8 +350,8 @@ module Yerba
 
     private
 
-    def dig_into(hash, path)
-      keys = path.split(".")
+    def dig_into(hash, selector)
+      keys = selector.split(".")
 
       keys.reduce(hash) { |current, key| current.is_a?(Hash) ? current[key] : nil }
     end
@@ -356,8 +361,8 @@ module Yerba
 
       criteria.each do |field, value|
         if value.is_a?(Hash)
-          flatten_hash("#{field}[]", value).each do |path, leaf_value|
-            expanded << [path, leaf_value]
+          flatten_hash("#{field}[]", value).each do |selector, leaf_value|
+            expanded << [selector, leaf_value]
           end
         elsif value.is_a?(Array)
           value.each do |item|
@@ -375,12 +380,12 @@ module Yerba
       result = {}
 
       hash.each do |key, value|
-        path = "#{prefix}.#{key}"
+        selector = "#{prefix}.#{key}"
 
         if value.is_a?(Hash)
-          flatten_hash("#{path}[]", value).each { |nested_path, leaf| result[nested_path] = leaf }
+          flatten_hash("#{selector}[]", value).each { |nested_selector, leaf| result[nested_selector] = leaf }
         else
-          result[path] = value
+          result[selector] = value
         end
       end
 
@@ -399,8 +404,8 @@ module Yerba
       end
     end
 
-    def dig_values(hash, path)
-      parts = path.split(".")
+    def dig_values(hash, selector)
+      parts = selector.split(".")
       current = [hash]
 
       parts.each do |part|

data/lib/yerba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yerba
-  VERSION = "0.9.1"
+  VERSION = "0.10.0"
 end

data/lib/yerba.rb

@@ -4,6 +4,7 @@ require "fileutils"
 
 require_relative "yerba/version"
 require_relative "yerba/location"
+require_relative "yerba/selector"
 require_relative "yerba/formatting"
 require_relative "yerba/node"
 require_relative "yerba/scalar"

data/rust/Cargo.lock

@@ -1431,7 +1431,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "anstyle-query",
  "cbindgen",

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.9.1"
+version = "0.10.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"

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),