yerba 0.3.0 → 0.4.0

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.3.0"
+  VERSION = "0.4.0"
 end

data/rust/Cargo.lock

@@ -0,0 +1 @@
+../Cargo.lock

data/rust/Cargo.toml

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

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/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

@@ -77,10 +77,7 @@ impl Args {
 
         use super::color::*;
 
-        eprintln!(
-          "{RED}Error:{RESET} selector \"{}\" not found in {}",
-          self.selector, resolved_file
-        );
+        eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, resolved_file);
 
         show_similar_selectors(resolved_file, &document, &self.selector);
         process::exit(1);
@@ -97,11 +94,7 @@ impl Args {
 
           if !document.exists(&full_selector) {
             use super::color::*;
-            eprintln!(
-              "{RED}Error:{RESET} select field \"{}\" not found in {}",
-              field.trim(),
-              resolved_file
-            );
+            eprintln!("{RED}Error:{RESET} select field \"{}\" not found in {}", field.trim(), resolved_file);
             show_similar_selectors(resolved_file, &document, &full_selector);
             process::exit(1);
           }
@@ -175,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/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;
@@ -126,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 {
@@ -154,6 +152,7 @@ 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,
@@ -182,6 +181,7 @@ 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(),
@@ -334,12 +334,7 @@ pub(crate) fn run_op(file: &str, document: &yerba::Document, result: Result<(),
   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>,
-) {
+pub(crate) fn run_op_with_hint(file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>, hint: Option<&str>) {
   use color::*;
 
   if let Err(error) = result {

data/rust/src/commands/quote_style.rs

@@ -11,7 +11,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
     yerba quote-style config.yml --keys plain
     yerba quote-style config.yml --keys plain --values double
     yerba quote-style config.yml "[].speakers" --values plain
-    yerba quote-style "data/**/*.yml" --keys plain --values double 
+    yerba quote-style "data/**/*.yml" --keys plain --values double
   "#})
 });
 
@@ -25,12 +25,12 @@ pub struct Args {
   file: String,
   /// Selector to scope the operation (optional — omit for whole file)
   selector: Option<String>,
-  /// Quote style for values (plain, single, double, literal, folded)
+  /// Quote style for keys
   #[arg(long)]
-  values: Option<yerba::QuoteStyle>,
-  /// Quote style for keys (plain, single, double)
+  keys: Option<yerba::KeyStyle>,
+  /// Quote style for values
   #[arg(long)]
-  keys: Option<yerba::QuoteStyle>,
+  values: Option<yerba::QuoteStyle>,
   #[arg(long)]
   dry_run: bool,
 }
@@ -53,7 +53,13 @@ impl Args {
       }
 
       if let Some(style) = &self.values {
-        let _ = document.enforce_quotes_at(style, selector);
+        if let Ok(warnings) = document.enforce_quotes_at(style, selector) {
+          for warning in warnings {
+            use super::color::*;
+
+            eprintln!("{YELLOW}Warning:{RESET} {} — {}", resolved_file, warning);
+          }
+        }
       }
 
       output(&resolved_file, &document, self.dry_run);

data/rust/src/commands/selectors.rs

@@ -81,11 +81,7 @@ impl Args {
 
     for resolved_file in resolve_files(&self.file) {
       let document = parse_file(&resolved_file);
-      let prefix = if selector.is_empty() {
-        String::new()
-      } else {
-        selector.to_string()
-      };
+      let prefix = if selector.is_empty() { String::new() } else { selector.to_string() };
 
       let values = if selector.is_empty() {
         document.get_value("").into_iter().collect::<Vec<_>>()
@@ -112,14 +108,7 @@ impl Args {
       if let Some(label) = info.count_label() {
         let padding = max_selector_len - selector.len() + 2;
 
-        println!(
-          "{}{}{}{}{}",
-          selector,
-          " ".repeat(padding),
-          color::DIM,
-          label,
-          color::RESET
-        );
+        println!("{}{}{}{}{}", selector, " ".repeat(padding), color::DIM, label, color::RESET);
       } else {
         println!("{}", selector);
       }
@@ -127,12 +116,7 @@ impl Args {
   }
 }
 
-fn collect_selectors(
-  value: &serde_yaml::Value,
-  prefix: &str,
-  selectors: &mut BTreeMap<String, SelectorInfo>,
-  counter: &mut usize,
-) {
+fn collect_selectors(value: &serde_yaml::Value, prefix: &str, selectors: &mut BTreeMap<String, SelectorInfo>, counter: &mut usize) {
   match value {
     serde_yaml::Value::Mapping(map) => {
       for (key, child) in map {