yerba 0.2.2-arm-linux-gnu → 0.4.0-arm-linux-gnu

data/lib/yerba/document.rb

@@ -48,6 +48,22 @@ module Yerba
       end
     end
 
+    def find_by(...)
+      root.find_by(...)
+    end
+
+    def where(...)
+      root.where(...)
+    end
+
+    def pluck(...)
+      root.pluck(...)
+    end
+
+    def <<(item)
+      root << item
+    end
+
     def inspect
       if path
         "#<Yerba::Document path=#{path.inspect}>"

data/lib/yerba/sequence.rb

@@ -58,7 +58,100 @@ module Yerba
     def each
       return enum_for(:each) unless block_given?
 
-      length.times { |i| yield self[i] }
+      length.times { |index| yield self[index] }
+    end
+
+    def find_by(selector = nil, value = nil, **criteria)
+      index = index_of(selector, value, **criteria)
+
+      self[index] if index
+    end
+
+    def where(selector = nil, value = nil, **criteria)
+      indices_of(selector, value, **criteria).map { |index| self[index] }
+    end
+
+    def pluck(*fields)
+      return [] unless @document
+
+      all_values = @document.get_value(@selector)
+      return [] unless all_values.is_a?(Array)
+
+      if fields.length == 1
+
+        all_values.map { |item| item.is_a?(Hash) ? item[fields.first.to_s] : item }
+      else
+
+        all_values.map { |item| fields.map(&:to_s).map { |field| item.is_a?(Hash) ? item[field] : nil } }
+      end
+    end
+
+    def index_of(selector = nil, value = nil, **criteria)
+      if selector && value.nil? && criteria.empty?
+        values = @document&.get("#{@selector}[]")
+
+        return values.index(selector) if values.is_a?(Array)
+
+        return nil
+      end
+
+      criteria[selector] = value if selector && value
+      pairs = expand_nested_criteria(criteria)
+
+      indices = nil
+
+      pairs.each do |field, expected|
+        field_string = field.to_s
+
+        if field_string.include?("[]")
+          matching = nested_indices_for(field_string, expected)
+        else
+          values = @document&.get("#{@selector}[].#{field_string}")
+
+          next unless values.is_a?(Array)
+
+          matching = values.each_with_index.filter_map { |actual, index| index if actual == expected }
+        end
+
+        indices = indices ? indices & matching : matching
+      end
+
+      indices&.first
+    end
+
+    def indices_of(selector = nil, value = nil, **criteria)
+      if selector && value.nil? && criteria.empty?
+        values = @document&.get("#{@selector}[]")
+
+        if values.is_a?(Array)
+          return values.each_with_index.filter_map { |actual, index| index if actual == selector }
+        end
+
+        return []
+      end
+
+      criteria[selector] = value if selector && value
+      pairs = expand_nested_criteria(criteria)
+
+      indices = nil
+
+      pairs.each do |field, expected|
+        field_string = field.to_s
+
+        if field_string.include?("[]")
+          matching = nested_indices_for(field_string, expected)
+        else
+          values = @document&.get("#{@selector}[].#{field_string}")
+
+          next unless values.is_a?(Array)
+
+          matching = values.each_with_index.filter_map { |actual, index| index if actual == expected }
+        end
+
+        indices = indices ? indices & matching : matching
+      end
+
+      indices || []
     end
 
     def length
@@ -69,6 +162,7 @@ module Yerba
           scalar_items.length
         else
           data = @document.get_value(@selector)
+
           data.is_a?(Array) ? data.length : 0
         end
       else
@@ -156,6 +250,79 @@ module Yerba
 
     private
 
+    def expand_nested_criteria(criteria)
+      expanded = []
+
+      criteria.each do |field, value|
+        if value.is_a?(Hash)
+          flatten_hash("#{field}[]", value).each do |path, leaf_value|
+            expanded << [path, leaf_value]
+          end
+        elsif value.is_a?(Array)
+          value.each do |item|
+            expanded << ["#{field}[]", item]
+          end
+        else
+          expanded << [field, value]
+        end
+      end
+
+      expanded
+    end
+
+    def flatten_hash(prefix, hash)
+      result = {}
+
+      hash.each do |key, value|
+        path = "#{prefix}.#{key}"
+
+        if value.is_a?(Hash)
+          flatten_hash("#{path}[]", value).each { |nested_path, leaf| result[nested_path] = leaf }
+        else
+          result[path] = value
+        end
+      end
+
+      result
+    end
+
+    def nested_indices_for(field, expected)
+      all_values = @document&.get_value(@selector)
+      return [] unless all_values.is_a?(Array)
+
+      all_values.each_with_index.filter_map do |item, index|
+        next unless item.is_a?(Hash)
+
+        nested_values = dig_values(item, field)
+        index if nested_values.include?(expected)
+      end
+    end
+
+    def dig_values(hash, path)
+      parts = path.split(".")
+      current = [hash]
+
+      parts.each do |part|
+        next_values = []
+
+        current.each do |value|
+          if part == "[]" && value.is_a?(Array)
+            next_values.concat(value)
+          elsif part.end_with?("[]")
+            key = part.chomp("[]")
+            child = value.is_a?(Hash) ? value[key] : nil
+            next_values.concat(child) if child.is_a?(Array)
+          elsif value.is_a?(Hash)
+            next_values << value[part] if value.key?(part)
+          end
+        end
+
+        current = next_values
+      end
+
+      current
+    end
+
     def format_for_insert(value)
       Formatting.quote(value, detect_quote_style)
     end
@@ -172,6 +339,7 @@ module Yerba
           result
         else
           data = @document.get_value(@selector)
+
           data.is_a?(Array) ? data : []
         end
       else

data/lib/yerba/version.rb

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

data/lib/yerba.rb

@@ -12,9 +12,14 @@ require_relative "yerba/document"
 require_relative "yerba/collection"
 
 begin
-  require "yerba/yerba"
+  major, minor, = RUBY_VERSION.split(".")
+  require "yerba/#{major}.#{minor}/yerba"
 rescue LoadError
-  # C extension not available, fall back to CLI mode
+  begin
+    require "yerba/yerba"
+  rescue LoadError
+    # C extension not available, fall back to CLI mode
+  end
 end
 
 module Yerba

data/rust/Cargo.lock

@@ -784,7 +784,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.2.2"
+version = "0.4.0"
 dependencies = [
  "cbindgen",
  "clap",

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.2.2"
+version = "0.4.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -13,7 +13,7 @@ categories = ["parser-implementations", "development-tools"]
 [lib]
 name = "yerba"
 path = "src/lib.rs"
-crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib", "staticlib", "rlib"]
 
 [[bin]]
 name = "yerba"

data/rust/cbindgen.toml

@@ -9,6 +9,7 @@ no_includes = true
 
 [export]
 include = [
+  "NodeType",
   "YerbaValueType",
   "YerbaResult",
   "YerbaTypedValue",

data/rust/rustfmt.toml

@@ -1,2 +1,2 @@
 tab_spaces = 2
-max_width = 120
+max_width = 160

data/rust/src/commands/blank_lines.rs

@@ -39,10 +39,7 @@ impl Args {
     } else {
       use super::color::*;
 
-      eprintln!(
-        "{RED}Error:{RESET} expected a number for blank line count, got '{}'",
-        self.first
-      );
+      eprintln!("{RED}Error:{RESET} expected a number for blank line count, got '{}'", self.first);
 
       std::process::exit(1);
     };

data/rust/src/commands/delete.rs

@@ -3,12 +3,13 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
     yerba delete config.yml "database.pool"
     yerba delete videos.yml "[0].description"
+    yerba delete "data/**/event.yml" "date_precision"
     yerba delete config.yml "database.pool" --dry-run
   "#})
 });
@@ -28,8 +29,12 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    let mut document = parse_file(&self.file);
-    run_op(|| document.delete(&self.selector));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.delete(&self.selector);
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }

data/rust/src/commands/directives.rs

@@ -0,0 +1,61 @@
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{output, parse_file, resolve_files};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba directives config.yml --ensure
+    yerba directives config.yml --remove
+    yerba directives "data/**/*.yml" --ensure
+    yerba directives config.yml --ensure --dry-run
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Add or remove the document start marker (---)",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  /// Add --- if missing
+  #[arg(long)]
+  ensure: bool,
+  /// Remove --- if present
+  #[arg(long)]
+  remove: bool,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    if !self.ensure && !self.remove {
+      use super::color::*;
+      eprintln!("{RED}Error:{RESET} specify --ensure or --remove");
+      std::process::exit(1);
+    }
+
+    if self.ensure && self.remove {
+      use super::color::*;
+      eprintln!("{RED}Error:{RESET} --ensure and --remove are mutually exclusive");
+      std::process::exit(1);
+    }
+
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+
+      if self.ensure {
+        let _ = document.ensure_directives();
+      } else if self.remove {
+        let _ = document.remove_directives();
+      }
+
+      output(&resolved_file, &document, self.dry_run);
+    }
+  }
+}

data/rust/src/commands/get.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 
 use indoc::indoc;
 
-use super::{colorize_examples, parse_file, resolve_files};
+use super::{colorize_examples, parse_file, resolve_files, show_similar_selectors};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -64,9 +64,42 @@ impl Args {
 
     let search_path_string = search_path.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;
 
-    for resolved_file in resolve_files(&self.file) {
-      let document = parse_file(&resolved_file);
+    for resolved_file in &files {
+      let document = parse_file(resolved_file);
+
+      if normalized_condition.is_none() && !document.exists(&self.selector) {
+        if is_glob {
+          continue;
+        }
+
+        use super::color::*;
+
+        eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, resolved_file);
+
+        show_similar_selectors(resolved_file, &document, &self.selector);
+        process::exit(1);
+      }
+
+      if let Some(fields) = &select_fields {
+        for field in fields {
+          let field_trimmed = field.trim().trim_start_matches('.');
+          let full_selector = if search_path_string.is_empty() {
+            field_trimmed.to_string()
+          } else {
+            format!("{}.{}", search_path_string, field_trimmed)
+          };
+
+          if !document.exists(&full_selector) {
+            use super::color::*;
+            eprintln!("{RED}Error:{RESET} select field \"{}\" not found in {}", field.trim(), resolved_file);
+            show_similar_selectors(resolved_file, &document, &full_selector);
+            process::exit(1);
+          }
+        }
+      }
 
       let values: Vec<serde_yaml::Value> = if let Some(condition) = &normalized_condition {
         document.filter(&search_path_string, condition)
@@ -74,16 +107,6 @@ impl Args {
         document.get_values(&search_path_string)
       };
 
-      if values.is_empty()
-        && !selector.has_brackets()
-        && normalized_condition.is_none()
-        && !document.exists(&self.selector)
-      {
-        use super::color::*;
-        eprintln!("{RED}Error:{RESET} path not found: {}", self.selector);
-        process::exit(1);
-      }
-
       for value in values {
         if let Some(field) = &extract_field {
           let field_string = field.to_selector_string();
@@ -121,6 +144,19 @@ impl Args {
       }
     }
 
+    if is_glob && all_results.is_empty() && normalized_condition.is_none() {
+      use super::color::*;
+
+      eprintln!(
+        "{RED}Error:{RESET} selector \"{}\" not found in any of the {} files matching \"{}\"",
+        self.selector,
+        files.len(),
+        self.file
+      );
+
+      process::exit(1);
+    }
+
     if self.raw {
       for value in &all_results {
         match value {
@@ -132,23 +168,13 @@ impl Args {
         }
       }
     } else if all_results.len() == 1 {
-      println!(
-        "{}",
-        serde_json::to_string_pretty(&all_results[0]).unwrap_or_else(|_| "null".to_string())
-      );
+      println!("{}", serde_json::to_string_pretty(&all_results[0]).unwrap_or_else(|_| "null".to_string()));
     } else {
-      println!(
-        "{}",
-        serde_json::to_string_pretty(&all_results).unwrap_or_else(|_| "[]".to_string())
-      );
+      println!("{}", serde_json::to_string_pretty(&all_results).unwrap_or_else(|_| "[]".to_string()));
     }
   }
 
-  fn resolve_search_scope(
-    &self,
-    selector: &yerba::Selector,
-    condition_path: Option<&yerba::Selector>,
-  ) -> (yerba::Selector, Option<yerba::Selector>) {
+  fn resolve_search_scope(&self, selector: &yerba::Selector, condition_path: Option<&yerba::Selector>) -> (yerba::Selector, Option<yerba::Selector>) {
     if let Some(condition) = condition_path {
       if condition.is_relative() {
         let (container, field) = selector.split_at_last_bracket();

data/rust/src/commands/insert.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use indoc::indoc;
 
 use super::colorize_examples;
-use super::{output, parse_file, run_op};
+use super::{output, parse_file, resolve_files, run_op};
 
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
@@ -99,8 +99,12 @@ impl Args {
         .unwrap_or(yerba::InsertPosition::Last)
     };
 
-    let mut document = parse_file(&self.file);
-    run_op(|| document.insert_into(&self.selector, &resolved_value, position));
-    output(&self.file, &document, self.dry_run);
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+      let result = document.insert_into(&self.selector, &resolved_value, position.clone());
+
+      run_op(&resolved_file, &document, result);
+      output(&resolved_file, &document, self.dry_run);
+    }
   }
 }

data/rust/src/commands/mod.rs

@@ -2,6 +2,7 @@ pub mod apply;
 pub mod blank_lines;
 pub mod check;
 pub mod delete;
+pub mod directives;
 pub mod get;
 pub mod init;
 pub mod insert;
@@ -11,6 +12,7 @@ pub mod move_key;
 pub mod quote_style;
 pub mod remove;
 pub mod rename;
+pub mod selectors;
 pub mod set;
 pub mod sort;
 pub mod sort_keys;
@@ -125,10 +127,7 @@ pub(crate) fn colorize_help(input: &str) -> String {
     }
 
     if columns.len() == 3 {
-      output.push_str(&format!(
-        "  \x1b[36m{:<20}{RESET} {:<21} {DIM}{}{RESET}\n",
-        columns[0], columns[1], columns[2]
-      ));
+      output.push_str(&format!("  \x1b[36m{:<20}{RESET} {:<21} {DIM}{}{RESET}\n", columns[0], columns[1], columns[2]));
     } else if columns.len() == 2 {
       output.push_str(&format!("  \x1b[36m{:<20}{RESET} {}\n", columns[0], columns[1]));
     } else {
@@ -153,6 +152,8 @@ pub enum Command {
   Sort(sort::Args),
   QuoteStyle(quote_style::Args),
   BlankLines(blank_lines::Args),
+  Directives(directives::Args),
+  Selectors(selectors::Args),
   #[command(about = "Create a new Yerbafile in the current directory")]
   Init,
   #[command(about = "Apply all rules from the Yerbafile and write changes")]
@@ -180,6 +181,8 @@ impl Command {
       Command::Sort(args) => args.run(),
       Command::QuoteStyle(args) => args.run(),
       Command::BlankLines(args) => args.run(),
+      Command::Directives(args) => args.run(),
+      Command::Selectors(args) => args.run(),
       Command::Init => init::run(),
       Command::Apply => apply::run(),
       Command::Check => check::run(),
@@ -224,7 +227,7 @@ pub(crate) fn run_yerbafile(write: bool) {
   }
 
   if !has_changes && !has_errors {
-    eprintln!("  {GREEN}All files match the rules.{RESET}");
+    eprintln!("\n{BOLD}{GREEN}All files match the rules.{RESET}");
   }
 
   if !write && has_changes {
@@ -327,13 +330,72 @@ pub(crate) fn parse_file(file: &str) -> yerba::Document {
   })
 }
 
-pub(crate) fn run_op(operation: impl FnOnce() -> Result<(), yerba::YerbaError>) {
+pub(crate) fn run_op(file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>) {
+  run_op_with_hint(file, document, result, None);
+}
+
+pub(crate) fn run_op_with_hint(file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>, hint: Option<&str>) {
   use color::*;
 
-  operation().unwrap_or_else(|error| {
-    eprintln!("{RED}Error:{RESET} {}", error);
+  if let Err(error) = result {
+    if let yerba::YerbaError::SelectorNotFound(selector) = &error {
+      eprintln!("{RED}Error:{RESET} selector \"{selector}\" not found in {file}");
+
+      show_similar_selectors(file, document, selector);
+    } else {
+      eprintln!("{RED}Error:{RESET} {}", error);
+    }
+
+    if let Some(hint) = hint {
+      if matches!(error, yerba::YerbaError::SelectorNotFound(_)) {
+        eprintln!();
+        eprintln!("  {DIM}Hint: {hint}{RESET}");
+      }
+    }
+
     process::exit(1);
-  });
+  }
+}
+
+pub(crate) fn show_similar_selectors(file: &str, document: &yerba::Document, invalid_path: &str) {
+  use color::*;
+  use yerba::didyoumean::didyoumean_ranked;
+
+  let selectors = document.selectors();
+
+  if selectors.is_empty() {
+    return;
+  }
+
+  let query = invalid_path.split_whitespace().next().unwrap_or(invalid_path);
+  let threshold = query.len() / 2 + 3;
+  let close = didyoumean_ranked(query, &selectors, threshold);
+
+  eprintln!();
+
+  if close.is_empty() {
+    eprintln!("  {BOLD}Available selectors in {file}:{RESET}");
+
+    for selector in selectors.iter().take(10) {
+      eprintln!("    {DIM}{selector}{RESET}");
+    }
+
+    if selectors.len() > 10 {
+      eprintln!("    {DIM}... and {} more{RESET}", selectors.len() - 10);
+    }
+  } else if close.len() == 1 {
+    eprintln!("  {BOLD}Did you mean this selector?{RESET} {}", close[0]);
+  } else {
+    eprintln!("  {BOLD}Did you mean one of these selectors?{RESET}");
+
+    for selector in close.iter().take(5) {
+      eprintln!("    {selector}");
+    }
+  }
+
+  eprintln!();
+  eprintln!("  {BOLD}To see all valid selectors, run:{RESET}");
+  eprintln!("    yerba selectors \"{file}\"{RESET}");
 }
 
 pub(crate) fn output(file: &str, document: &yerba::Document, dry_run: bool) {

data/rust/src/commands/move_item.rs

@@ -48,7 +48,8 @@ impl Args {
       |document, path, reference| document.resolve_sequence_index(path, reference),
     );
 
-    run_op(|| document.move_item(&self.selector, from_index, to_index));
+    let result = document.move_item(&self.selector, from_index, to_index);
+    run_op(&self.file, &document, result);
     output(&self.file, &document, self.dry_run);
   }
 }

data/rust/src/commands/move_key.rs

@@ -81,7 +81,8 @@ impl Args {
       |document, parent_path, reference| document.resolve_key_index(parent_path, reference),
     );
 
-    run_op(|| document.move_key(parent_path, from_index, to_index));
+    let result = document.move_key(parent_path, from_index, to_index);
+    run_op(&self.file, &document, result);
     output(&self.file, &document, self.dry_run);
   }
 }