yerba 0.2.0-arm-linux-gnu

data/rust/src/commands/mod.rs

@@ -0,0 +1,349 @@
+pub mod apply;
+pub mod blank_lines;
+pub mod check;
+pub mod delete;
+pub mod get;
+pub mod init;
+pub mod insert;
+pub mod mate;
+pub mod move_item;
+pub mod move_key;
+pub mod quote_style;
+pub mod remove;
+pub mod rename;
+pub mod set;
+pub mod sort;
+pub mod sort_keys;
+pub mod version;
+
+use std::fs;
+use std::process;
+
+use clap::Subcommand;
+
+pub(crate) mod color {
+  pub const GREEN: &str = "\x1b[32m";
+  pub const RED: &str = "\x1b[31m";
+  pub const YELLOW: &str = "\x1b[33m";
+  pub const DIM: &str = "\x1b[2m";
+  pub const BOLD: &str = "\x1b[1m";
+  pub const RESET: &str = "\x1b[0m";
+}
+
+// Compile-time ANSI macros for use in concat!() / clap attributes (used in main.rs)
+#[allow(unused_macros)]
+macro_rules! h {
+  () => {
+    "\x1b[1;32m"
+  };
+} // header (bold green)
+#[allow(unused_macros)]
+macro_rules! b {
+  () => {
+    "\x1b[1m"
+  };
+} // bold
+#[allow(unused_macros)]
+macro_rules! c {
+  () => {
+    "\x1b[36m"
+  };
+} // cyan
+#[allow(unused_macros)]
+macro_rules! d {
+  () => {
+    "\x1b[2m"
+  };
+} // dim
+#[allow(unused_macros)]
+macro_rules! r {
+  () => {
+    "\x1b[0m"
+  };
+} // reset
+#[allow(unused_imports)]
+pub(crate) use {b, c, d, h, r};
+
+pub(crate) fn colorize_examples(input: &str) -> String {
+  colorize_help(&format!("Examples:\n{}", input.trim()))
+}
+
+pub(crate) fn colorize_help(input: &str) -> String {
+  use color::*;
+
+  let mut output = String::new();
+
+  for line in input.lines() {
+    let trimmed = line.trim();
+
+    if trimmed.is_empty() {
+      output.push('\n');
+      continue;
+    }
+
+    if trimmed.ends_with(':') && !trimmed.contains(' ') {
+      output.push_str(&format!("{GREEN}{BOLD}{trimmed}{RESET}\n"));
+      continue;
+    }
+
+    if trimmed.starts_with("yerba ") {
+      let mut parts = trimmed.splitn(3, ' ');
+
+      match (parts.next(), parts.next(), parts.next()) {
+        (Some(cmd), Some(sub), Some(rest)) => {
+          output.push_str(&format!("  {BOLD}{cmd}{RESET} \x1b[36m{sub}{RESET} {rest}\n"));
+        }
+
+        (Some(cmd), Some(sub), None) => {
+          output.push_str(&format!("  {BOLD}{cmd}{RESET} \x1b[36m{sub}{RESET}\n"));
+        }
+
+        _ => {
+          output.push_str(&format!("  {trimmed}\n"));
+        }
+      }
+
+      continue;
+    }
+
+    let mut columns: Vec<&str> = Vec::new();
+    let mut rest = trimmed;
+
+    while !rest.is_empty() {
+      let column_end = rest.find("  ").unwrap_or(rest.len());
+      let column = rest[..column_end].trim();
+
+      if !column.is_empty() {
+        columns.push(column);
+      }
+
+      if column_end >= rest.len() {
+        break;
+      }
+
+      rest = rest[column_end..].trim_start();
+    }
+
+    if columns.len() == 3 {
+      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 {
+      output.push_str(&format!("  {trimmed}\n"));
+    }
+  }
+
+  output.trim_end().to_string()
+}
+
+#[derive(Subcommand)]
+pub enum Command {
+  Get(get::Args),
+  Set(set::Args),
+  Insert(insert::Args),
+  Rename(rename::Args),
+  Delete(delete::Args),
+  Remove(remove::Args),
+  Move(move_item::Args),
+  MoveKey(move_key::Args),
+  SortKeys(sort_keys::Args),
+  Sort(sort::Args),
+  QuoteStyle(quote_style::Args),
+  BlankLines(blank_lines::Args),
+  #[command(about = "Create a new Yerbafile in the current directory")]
+  Init,
+  #[command(about = "Apply all rules from the Yerbafile and write changes")]
+  Apply,
+  #[command(about = "Check if all files match Yerbafile rules (exits 1 if not)")]
+  Check,
+  #[command(about = "Print the yerba version")]
+  Version,
+  #[command(about = "\u{1f9c9}")]
+  Mate,
+}
+
+impl Command {
+  pub fn run(self) {
+    match self {
+      Command::Get(args) => args.run(),
+      Command::Set(args) => args.run(),
+      Command::Insert(args) => args.run(),
+      Command::Rename(args) => args.run(),
+      Command::Delete(args) => args.run(),
+      Command::Remove(args) => args.run(),
+      Command::Move(args) => args.run(),
+      Command::MoveKey(args) => args.run(),
+      Command::SortKeys(args) => args.run(),
+      Command::Sort(args) => args.run(),
+      Command::QuoteStyle(args) => args.run(),
+      Command::BlankLines(args) => args.run(),
+      Command::Init => init::run(),
+      Command::Apply => apply::run(),
+      Command::Check => check::run(),
+      Command::Version => version::run(),
+      Command::Mate => mate::run(),
+    }
+  }
+}
+
+pub(crate) fn run_yerbafile(write: bool) {
+  use color::*;
+
+  let yerbafile_path = yerba::Yerbafile::find().unwrap_or_else(|| {
+    eprintln!("{RED}No Yerbafile found.{RESET} Run {BOLD}yerba init{RESET} to create one.");
+    process::exit(1);
+  });
+
+  let yerbafile = yerba::Yerbafile::load(&yerbafile_path).unwrap_or_else(|error| {
+    eprintln!("{RED}Error loading {}:{RESET} {}", yerbafile_path.display(), error);
+    process::exit(1);
+  });
+
+  eprintln!("🧉 {BOLD}Using{RESET} {}", yerbafile_path.display());
+
+  let results = yerbafile.apply(write);
+  let mut has_changes = false;
+  let mut has_errors = false;
+
+  for result in &results {
+    if let Some(error) = &result.error {
+      eprintln!("  {RED}error:{RESET} {} {DIM}—{RESET} {}", result.file, error);
+      has_errors = true;
+    } else if result.changed {
+      if write {
+        eprintln!("  {GREEN}updated:{RESET} {}", result.file);
+      } else {
+        eprintln!("  {YELLOW}would change:{RESET} {}", result.file);
+      }
+
+      has_changes = true;
+    }
+  }
+
+  if !has_changes && !has_errors {
+    eprintln!("  {GREEN}All files match the rules.{RESET}");
+  }
+
+  if !write && has_changes {
+    process::exit(1);
+  }
+
+  if has_errors {
+    process::exit(1);
+  }
+}
+
+pub(crate) fn resolve_move_indexes(
+  document: &yerba::Document,
+  path: &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) {
+  use color::*;
+
+  let from_index = resolve(document, path, item).unwrap_or_else(|error| {
+    eprintln!("{RED}Error:{RESET} {}", error);
+    process::exit(1);
+  });
+
+  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| {
+      eprintln!("{RED}Error:{RESET} {}", error);
+      process::exit(1);
+    });
+
+    if from_index < target_index {
+      target_index - 1
+    } else {
+      target_index
+    }
+  } else if let Some(target) = &after {
+    let target_index = resolve(document, path, target).unwrap_or_else(|error| {
+      eprintln!("{RED}Error:{RESET} {}", error);
+      process::exit(1);
+    });
+
+    if from_index <= target_index {
+      target_index
+    } else {
+      target_index + 1
+    }
+  } else {
+    eprintln!("{RED}Error:{RESET} specify --before, --after, or --to");
+    process::exit(1);
+  };
+
+  (from_index, to_index)
+}
+
+pub(crate) fn resolve_files(pattern: &str) -> Vec<String> {
+  use color::*;
+
+  if pattern.contains('*') || pattern.contains('?') || pattern.contains('[') {
+    let paths: Vec<String> = glob::glob(pattern)
+      .unwrap_or_else(|error| {
+        eprintln!("{RED}Error:{RESET} invalid glob pattern '{}': {}", pattern, error);
+        process::exit(1);
+      })
+      .filter_map(|entry| entry.ok())
+      .map(|path| path.to_string_lossy().to_string())
+      .collect();
+
+    if paths.is_empty() {
+      eprintln!("{RED}Error:{RESET} no files matched pattern: {}", pattern);
+      process::exit(1);
+    }
+
+    paths
+  } else {
+    vec![pattern.to_string()]
+  }
+}
+
+pub(crate) fn parse_file(file: &str) -> yerba::Document {
+  use color::*;
+
+  yerba::parse_file(file).unwrap_or_else(|error| {
+    match &error {
+      yerba::YerbaError::IoError(io_error) => match io_error.kind() {
+        std::io::ErrorKind::NotFound => eprintln!("{RED}Error:{RESET} file not found: {}", file),
+        std::io::ErrorKind::PermissionDenied => {
+          eprintln!("{RED}Error:{RESET} permission denied: {}", file)
+        }
+        _ => eprintln!("{RED}Error:{RESET} reading {}: {}", file, io_error),
+      },
+      _ => eprintln!("{RED}Error:{RESET} parsing {}: {}", file, error),
+    }
+
+    process::exit(1);
+  })
+}
+
+pub(crate) fn run_op(operation: impl FnOnce() -> Result<(), yerba::YerbaError>) {
+  use color::*;
+
+  operation().unwrap_or_else(|error| {
+    eprintln!("{RED}Error:{RESET} {}", error);
+    process::exit(1);
+  });
+}
+
+pub(crate) fn output(file: &str, document: &yerba::Document, dry_run: bool) {
+  if dry_run {
+    println!("--- {}", file);
+    print!("{}", document);
+  } else {
+    fs::write(file, document.to_string()).unwrap_or_else(|error| {
+      eprintln!("Error writing {}: {}", file, error);
+      process::exit(1);
+    });
+  }
+}

data/rust/src/commands/move_item.rs

@@ -0,0 +1,54 @@
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{output, parse_file, resolve_move_indexes, run_op};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba move config.yml "tags" "rust" --before "ruby"
+    yerba move config.yml "tags" "rust" --after "yaml"
+    yerba move config.yml "tags" 2 --to 0
+    yerba move videos.yml "" ".id == talk-2" --after ".id == talk-1"
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Move a sequence item to a new position",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  selector: String,
+  #[arg(help = "Item to move: name, index, or condition (e.g. \".id == talk-1\")")]
+  item: String,
+  #[arg(long, help = "Move before this item or condition (e.g. \".id == talk-2\")")]
+  before: Option<String>,
+  #[arg(long, help = "Move after this item or condition (e.g. \".id == talk-2\")")]
+  after: Option<String>,
+  #[arg(long)]
+  to: Option<usize>,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    let mut document = parse_file(&self.file);
+    let (from_index, to_index) = resolve_move_indexes(
+      &document,
+      &self.selector,
+      &self.item,
+      self.before,
+      self.after,
+      self.to,
+      |document, path, reference| document.resolve_sequence_index(path, reference),
+    );
+
+    run_op(|| document.move_item(&self.selector, from_index, to_index));
+    output(&self.file, &document, self.dry_run);
+  }
+}

data/rust/src/commands/move_key.rs

@@ -0,0 +1,87 @@
+use std::process;
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{output, parse_file, resolve_move_indexes, run_op};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba move-key config.yml "database.name" --to 0
+    yerba move-key config.yml "database.pool" --before "database.host"
+    yerba move-key config.yml "database.pool" --after "database.name"
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Move a key to a new position within a map",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  selector: String,
+  #[arg(long, help = "Move before this key")]
+  before: Option<String>,
+  #[arg(long, help = "Move after this key")]
+  after: Option<String>,
+  #[arg(long)]
+  to: Option<usize>,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    let (parent_path, 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 {
+        use super::color::*;
+        eprintln!(
+          "{RED}Error:{RESET} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
+          self.selector, target
+        );
+
+        process::exit(1);
+      }
+
+      target_key.to_string()
+    });
+
+    let after_key = self.after.map(|target| {
+      let (target_parent, target_key) = target.rsplit_once('.').unwrap_or(("", &target));
+
+      if target_parent != parent_path {
+        use super::color::*;
+        eprintln!(
+          "{RED}Error:{RESET} cannot move key across different maps ({} \u{2192} {})\n\n  Use 'yerba rename' to relocate keys to a different path.",
+          self.selector, target
+        );
+
+        process::exit(1);
+      }
+
+      target_key.to_string()
+    });
+
+    let (from_index, to_index) = resolve_move_indexes(
+      &document,
+      parent_path,
+      key,
+      before_key,
+      after_key,
+      self.to,
+      |document, parent_path, reference| document.resolve_key_index(parent_path, reference),
+    );
+
+    run_op(|| document.move_key(parent_path, from_index, to_index));
+    output(&self.file, &document, self.dry_run);
+  }
+}

data/rust/src/commands/quote_style.rs

@@ -0,0 +1,62 @@
+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 quote-style config.yml --values double
+    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 
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Enforce a consistent quote style on keys and/or values",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+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)
+  #[arg(long)]
+  values: Option<yerba::QuoteStyle>,
+  /// Quote style for keys (plain, single, double)
+  #[arg(long)]
+  keys: Option<yerba::QuoteStyle>,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    if self.values.is_none() && self.keys.is_none() {
+      use super::color::*;
+      eprintln!("{RED}Error:{RESET} specify --values, --keys, or both");
+      std::process::exit(1);
+    }
+
+    let selector = self.selector.as_deref().filter(|s| !s.is_empty());
+
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+
+      if let Some(style) = &self.keys {
+        let _ = document.enforce_key_style(style, selector);
+      }
+
+      if let Some(style) = &self.values {
+        let _ = document.enforce_quotes_at(style, selector);
+      }
+
+      output(&resolved_file, &document, self.dry_run);
+    }
+  }
+}

data/rust/src/commands/remove.rs

@@ -0,0 +1,35 @@
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{output, parse_file, run_op};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba remove config.yml "tags" "rust"
+    yerba remove videos.yml "[0].speakers" "Alice"
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Remove an item from a sequence by its value",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  selector: String,
+  value: String,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    let mut document = parse_file(&self.file);
+    run_op(|| document.remove(&self.selector, &self.value));
+    output(&self.file, &document, self.dry_run);
+  }
+}

data/rust/src/commands/rename.rs

@@ -0,0 +1,37 @@
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{output, parse_file, run_op};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba rename config.yml "database.host" "database.hostname"
+    yerba rename config.yml "database.host" "hostname"
+    yerba rename config.yml "database.host" "settings.db_host"
+    yerba rename videos.yml "[0].old_name" "[0].name"
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Rename a key in a map (preserves value and position)",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  source: String,
+  destination: String,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    let mut document = parse_file(&self.file);
+    run_op(|| document.rename(&self.source, &self.destination));
+    output(&self.file, &document, self.dry_run);
+  }
+}

data/rust/src/commands/set.rs

@@ -0,0 +1,59 @@
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{output, parse_file, run_op};
+
+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.host" "0.0.0.0" --condition ".port == 5432"
+    yerba set videos.yml "[0].title" "New Title"
+    yerba set "data/**/event.yml" "website" "" --if-exists
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Update an existing value at a path (preserves quote style)",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  selector: String,
+  value: String,
+  #[arg(long)]
+  if_exists: bool,
+  #[arg(long)]
+  if_missing: bool,
+  #[arg(long)]
+  condition: Option<String>,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    let mut document = parse_file(&self.file);
+    let parent_path = self.selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
+
+    let should_set = if self.if_exists {
+      document.exists(&self.selector)
+    } else if self.if_missing {
+      !document.exists(&self.selector)
+    } else if let Some(condition) = &self.condition {
+      document.evaluate_condition(parent_path, condition)
+    } else {
+      true
+    };
+
+    if should_set {
+      run_op(|| document.set(&self.selector, &self.value));
+    }
+
+    output(&self.file, &document, self.dry_run);
+  }
+}