yerba 0.4.2 → 0.5.0

data/rust/src/commands/get.rs

@@ -70,20 +70,22 @@ impl Args {
     for resolved_file in &files {
       let document = parse_file(resolved_file);
 
-      if normalized_condition.is_none() && !document.exists(&self.selector) {
+      if !document.exists(&self.selector) {
         if is_glob {
           continue;
         }
 
         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, self.file);
 
-        show_similar_selectors(resolved_file, &document, &self.selector);
+        show_similar_selectors(&self.file, &document, &self.selector);
         process::exit(1);
       }
 
       if let Some(fields) = &select_fields {
+        let mut missing_field = false;
+
         for field in fields {
           let field_trimmed = field.trim().trim_start_matches('.');
           let full_selector = if search_path_string.is_empty() {
@@ -93,24 +95,49 @@ impl Args {
           };
 
           if !document.exists(&full_selector) {
+            if is_glob {
+              missing_field = true;
+              break;
+            }
+
             use super::color::*;
-            eprintln!("{RED}Error:{RESET} select field \"{}\" not found in {}", field.trim(), resolved_file);
-            show_similar_selectors(resolved_file, &document, &full_selector);
+            eprintln!("{RED}Error:{RESET} select field \"{}\" not found in {}", field.trim(), self.file);
+            show_similar_selectors(&self.file, &document, &full_selector);
             process::exit(1);
           }
         }
+
+        if missing_field {
+          continue;
+        }
       }
 
-      let values: Vec<serde_yaml::Value> = if let Some(condition) = &normalized_condition {
-        document.filter(&search_path_string, condition)
+      let (values, selectors, lines): (Vec<serde_yaml::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);
+          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 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: 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), Vec::new(), Vec::new())
       } else {
-        document.get_values(&search_path_string)
+        (document.get_values(&search_path_string), Vec::new(), Vec::new())
       };
 
-      for value in values {
+      for (index, value) in values.iter().enumerate() {
         if let Some(field) = &extract_field {
           let field_string = field.to_selector_string();
-          let json_value = yerba::json::resolve_select_field(&value, &field_string);
+          let json_value = yerba::json::resolve_select_field(value, &field_string);
 
           if field.ends_with_bracket() {
             if let serde_json::Value::Array(items) = json_value {
@@ -128,8 +155,16 @@ impl Args {
 
           result.insert("__file".to_string(), serde_json::Value::String(resolved_file.clone()));
 
+          if let Some(selector) = selectors.get(index) {
+            result.insert("__selector".to_string(), serde_json::Value::String(selector.clone()));
+          }
+
+          if let Some(&line) = lines.get(index) {
+            result.insert("__line".to_string(), serde_json::Value::Number(line.into()));
+          }
+
           for field in fields {
-            let json_value = yerba::json::resolve_select_field(&value, field);
+            let json_value = yerba::json::resolve_select_field(value, field);
             let json_key = yerba::json::select_field_key(field);
 
             result.insert(json_key, json_value);
@@ -140,7 +175,7 @@ impl Args {
           continue;
         }
 
-        all_results.push(yerba::json::yaml_to_json(&value));
+        all_results.push(yerba::json::yaml_to_json(value));
       }
     }
 

data/rust/src/commands/insert.rs

@@ -103,7 +103,7 @@ impl Args {
       let mut document = parse_file(&resolved_file);
       let result = document.insert_into(&self.selector, &resolved_value, position.clone());
 
-      run_op(&resolved_file, &document, result);
+      run_op(&self.file, &document, result);
       output(&resolved_file, &document, self.dry_run);
     }
   }

data/rust/src/commands/location.rs

@@ -0,0 +1,56 @@
+use std::process;
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::parse_file;
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba location config.yml "database.host"
+    yerba location videos.yml "[0]"
+    yerba location videos.yml "[0].title"
+    yerba location videos.yml "[0].speakers"
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Show the location (line, column, offset) of a selector",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  selector: String,
+}
+
+impl Args {
+  pub fn run(self) {
+    use super::color::*;
+
+    let document = parse_file(&self.file);
+    let info = document.get_node_info(&self.selector);
+
+    if info.location.start_line == 0 && info.location.end_line == 0 {
+      eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, self.file);
+
+      super::show_similar_selectors(&self.file, &document, &self.selector);
+      process::exit(1);
+    }
+
+    let json = serde_json::json!({
+      "selector": self.selector,
+      "file": self.file,
+      "start_line": info.location.start_line,
+      "start_column": info.location.start_column,
+      "end_line": info.location.end_line,
+      "end_column": info.location.end_column,
+      "start_offset": info.location.start_offset,
+      "end_offset": info.location.end_offset,
+    });
+
+    println!("{}", serde_json::to_string_pretty(&json).unwrap_or_default());
+  }
+}

data/rust/src/commands/mod.rs

@@ -6,16 +6,19 @@ pub mod directives;
 pub mod get;
 pub mod init;
 pub mod insert;
+pub mod location;
 pub mod mate;
 pub mod move_item;
 pub mod move_key;
 pub mod quote_style;
 pub mod remove;
 pub mod rename;
+pub mod schema;
 pub mod selectors;
 pub mod set;
 pub mod sort;
 pub mod sort_keys;
+pub mod unique;
 pub mod version;
 
 use std::fs;
@@ -23,6 +26,10 @@ use std::process;
 
 use clap::Subcommand;
 
+pub(crate) fn is_github_actions() -> bool {
+  std::env::var("GITHUB_ACTIONS").is_ok()
+}
+
 pub(crate) mod color {
   pub const GREEN: &str = "\x1b[32m";
   pub const RED: &str = "\x1b[31m";
@@ -153,6 +160,9 @@ pub enum Command {
   QuoteStyle(quote_style::Args),
   BlankLines(blank_lines::Args),
   Directives(directives::Args),
+  Unique(unique::Args),
+  Location(location::Args),
+  Schema(schema::Args),
   Selectors(selectors::Args),
   #[command(about = "Create a new Yerbafile in the current directory")]
   Init,
@@ -180,6 +190,9 @@ impl Command {
       Command::QuoteStyle(args) => args.run(),
       Command::BlankLines(args) => args.run(),
       Command::Directives(args) => args.run(),
+      Command::Unique(args) => args.run(),
+      Command::Location(args) => args.run(),
+      Command::Schema(args) => args.run(),
       Command::Selectors(args) => args.run(),
       Command::Init => init::run(),
       Command::Apply(args) => args.run(),
@@ -214,15 +227,30 @@ pub(crate) fn run_yerbafile(write: bool, files: Vec<String>) {
   let mut has_changes = false;
   let mut has_errors = false;
 
+  let github = is_github_actions();
+
   for result in &results {
     if let Some(error) = &result.error {
       eprintln!("  {RED}error:{RESET} {} {DIM}—{RESET} {}", result.file, error);
+
+      if github {
+        use yerba::error::GitHubAnnotations;
+
+        for annotation in error.github_annotations(&result.file) {
+          eprintln!("{}", annotation);
+        }
+      }
+
       has_errors = true;
     } else if result.changed {
       if write {
         eprintln!("  {GREEN}updated:{RESET} {}", result.file);
       } else {
         eprintln!("  {YELLOW}would change:{RESET} {}", result.file);
+
+        if github {
+          eprintln!("::error file={}::File does not match Yerbafile rules", result.file);
+        }
       }
 
       has_changes = true;
@@ -333,18 +361,18 @@ pub(crate) fn parse_file(file: &str) -> yerba::Document {
   })
 }
 
-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(display_file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>) {
+  run_op_with_hint(display_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(display_file: &str, document: &yerba::Document, result: Result<(), yerba::YerbaError>, hint: Option<&str>) {
   use color::*;
 
   if let Err(error) = result {
     if let yerba::YerbaError::SelectorNotFound(selector) = &error {
-      eprintln!("{RED}Error:{RESET} selector \"{selector}\" not found in {file}");
+      eprintln!("{RED}Error:{RESET} selector \"{selector}\" not found in {display_file}");
 
-      show_similar_selectors(file, document, selector);
+      show_similar_selectors(display_file, document, selector);
     } else {
       eprintln!("{RED}Error:{RESET} {}", error);
     }

data/rust/src/commands/remove.rs

@@ -32,7 +32,7 @@ impl Args {
       let mut document = parse_file(&resolved_file);
       let result = document.remove(&self.selector, &self.value);
 
-      run_op(&resolved_file, &document, result);
+      run_op(&self.file, &document, result);
       output(&resolved_file, &document, self.dry_run);
     }
   }

data/rust/src/commands/rename.rs

@@ -34,7 +34,7 @@ impl Args {
       let mut document = parse_file(&resolved_file);
       let result = document.rename(&self.source, &self.destination);
 
-      run_op(&resolved_file, &document, result);
+      run_op(&self.file, &document, result);
       output(&resolved_file, &document, self.dry_run);
     }
   }

data/rust/src/commands/schema.rs

@@ -0,0 +1,84 @@
+use std::process;
+
+use super::color::*;
+use super::resolve_files;
+
+#[derive(clap::Args)]
+#[command(
+  about = "Validate YAML files against a JSON schema",
+  after_help = colorize_examples(indoc::indoc! {r#"
+    yerba schema data/speakers.yml --schema lib/schemas/speaker_schema.json
+    yerba schema "data/**/videos.yml" --schema lib/schemas/video_schema.json
+    yerba schema data/config.yml --schema schema.json --selector "database"
+  "#})
+)]
+pub struct Args {
+  /// YAML file(s) to validate (supports globs)
+  file: String,
+  /// Path to the JSON schema file
+  #[arg(long)]
+  schema: String,
+  /// Selector to scope validation (e.g. "[]", "tiers[]")
+  #[arg(long)]
+  selector: Option<String>,
+}
+
+fn colorize_examples(text: &str) -> String {
+  super::colorize_examples(text)
+}
+
+impl Args {
+  pub fn run(self) {
+    let schema = match yerba::schema::load_schema(&self.schema) {
+      Ok(schema) => schema,
+      Err(error) => {
+        eprintln!("{RED}Error:{RESET} {}", error);
+        process::exit(1);
+      }
+    };
+
+    let files = resolve_files(&self.file);
+
+    if files.is_empty() {
+      eprintln!("{RED}Error:{RESET} no files matching: {}", self.file);
+      process::exit(1);
+    }
+
+    let mut has_errors = false;
+    let selector = self.selector.as_deref();
+
+    for file in &files {
+      let document = match yerba::Document::parse_file(file) {
+        Ok(document) => document,
+        Err(error) => {
+          eprintln!("  {RED}error:{RESET} {} {DIM}—{RESET} {}", file, error);
+          has_errors = true;
+          continue;
+        }
+      };
+
+      let errors = document.validate_schema(&schema, false, selector);
+
+      if errors.is_empty() {
+        continue;
+      }
+
+      has_errors = true;
+
+      let relative = file.strip_prefix("./").unwrap_or(file);
+      eprintln!("  {RED}error:{RESET} {relative}");
+
+      for error in &errors {
+        eprintln!("    {error}");
+      }
+
+      eprintln!();
+    }
+
+    if has_errors {
+      process::exit(1);
+    } else {
+      eprintln!("{GREEN}All {count} files valid.{RESET}", count = files.len());
+    }
+  }
+}

data/rust/src/commands/set.rs

@@ -63,7 +63,7 @@ impl Args {
         };
 
         run_op_with_hint(
-          &resolved_file,
+          &self.file,
           &document,
           result,
           Some("Use --if-exists to skip files where the selector is missing"),

data/rust/src/commands/unique.rs

@@ -0,0 +1,80 @@
+use std::process;
+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 unique config.yml "tags"
+    yerba unique videos.yml --by ".id"
+    yerba unique speakers.yml --by ".name"
+    yerba unique speakers.yml --by ".name" --remove
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Find or remove duplicate items in a sequence",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  /// Selector (optional — omit for root-level sequence)
+  selector: Option<String>,
+  /// Field to check for uniqueness (omit for scalar arrays)
+  #[arg(long)]
+  by: Option<String>,
+  /// Remove duplicate items (default: report only)
+  #[arg(long)]
+  remove: bool,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    use super::color::*;
+
+    let selector = self.selector.as_deref().unwrap_or("");
+    let by = self.by.as_deref().unwrap_or(".");
+
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+
+      match document.unique(selector, by, self.remove) {
+        Ok(duplicates) => {
+          let noun = if duplicates.len() == 1 { "duplicate" } else { "duplicates" };
+
+          if duplicates.is_empty() {
+            eprintln!("{GREEN}No duplicates found{RESET} in {}", resolved_file);
+          } else if self.remove {
+            eprintln!("{YELLOW}Removed {} {noun}{RESET} from {}", duplicates.len(), resolved_file);
+
+            for duplicate in &duplicates {
+              eprintln!("  {DIM}line {}: {} == {}{RESET}", duplicate.line, by, duplicate.value);
+            }
+
+            output(&resolved_file, &document, self.dry_run);
+          } else {
+            eprintln!("{RED}Found {} {noun}{RESET} in {}", duplicates.len(), resolved_file);
+
+            for duplicate in &duplicates {
+              eprintln!("  {DIM}line {}: {} == {}{RESET}", duplicate.line, by, duplicate.value);
+            }
+
+            process::exit(1);
+          }
+        }
+
+        Err(error) => {
+          eprintln!("{RED}Error:{RESET} {}", error);
+          process::exit(1);
+        }
+      }
+    }
+  }
+}

data/rust/src/document/condition.rs

@@ -3,13 +3,29 @@ use super::*;
 impl Document {
   pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<serde_yaml::Value> {
     self
-      .navigate_all(dot_path)
+      .navigate_all_compact(dot_path)
       .iter()
       .filter(|node| self.evaluate_condition_on_node(node, condition))
       .map(node_to_yaml_value)
       .collect()
   }
 
+  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(serde_yaml::Value, String, usize)> {
+    let source = self.root.text().to_string();
+
+    self
+      .navigate_all_compact(dot_path)
+      .iter()
+      .filter(|node| self.evaluate_condition_on_node(node, condition))
+      .map(|node| {
+        let offset: usize = node.text_range().start().into();
+        let line = source[..offset].matches('\n').count() + 1;
+
+        (node_to_yaml_value(node), super::get::node_selector(node), line)
+      })
+      .collect()
+  }
+
   pub(super) fn evaluate_condition_on_node(&self, node: &SyntaxNode, condition: &str) -> bool {
     let condition = condition.trim();