yerba 0.1.2 → 0.2.1

data/rust/src/commands/get.rs

@@ -0,0 +1,194 @@
+use std::process;
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::{colorize_examples, parse_file, resolve_files};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba get config.yml "database.host"
+    yerba get videos.yml "[].title"
+    yerba get videos.yml "[0].title"
+    yerba get "data/**/videos.yml" "[].speakers[].name"
+    yerba get videos.yml "[]" --select ".title,.speakers"
+    yerba get videos.yml "[]" --condition ".kind == keynote"
+    yerba get videos.yml "[]" --select ".title" --condition ".kind == keynote"
+    yerba get videos.yml "[].speakers[]" --condition "[].video_provider == youtube"
+    yerba get videos.yml "[]" --condition ".speakers contains Matz" --raw
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Get values, filter items, and select fields from YAML files",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  selector: String,
+  /// Filter items by condition (e.g. '.kind == keynote', '[].video_provider == youtube')
+  #[arg(long)]
+  condition: Option<String>,
+  /// Comma-separated fields to include (e.g. '.title,.speakers')
+  #[arg(long)]
+  select: Option<String>,
+  /// Output raw values (one per line) instead of JSON
+  #[arg(long)]
+  raw: bool,
+  #[arg(long, hide = true)]
+  json: bool,
+}
+
+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 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 normalized_condition = self.condition.as_ref().map(|condition| {
+      if !condition.starts_with('.') {
+        if let Some(bracket_end) = condition.find(']') {
+          let after_bracket = &condition[bracket_end + 1..];
+
+          if after_bracket.starts_with('.') {
+            return after_bracket.to_string();
+          }
+        }
+      }
+
+      condition.clone()
+    });
+
+    let search_path_string = search_path.to_selector_string();
+    let mut all_results: Vec<serde_json::Value> = Vec::new();
+
+    for resolved_file in resolve_files(&self.file) {
+      let document = parse_file(&resolved_file);
+
+      let values: Vec<serde_yaml::Value> = if let Some(condition) = &normalized_condition {
+        document.filter(&search_path_string, condition)
+      } else {
+        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();
+          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 {
+              all_results.extend(items);
+            }
+          } else {
+            all_results.push(json_value);
+          }
+
+          continue;
+        }
+
+        if let Some(fields) = &select_fields {
+          let mut result = serde_json::Map::new();
+
+          result.insert("__file".to_string(), serde_json::Value::String(resolved_file.clone()));
+
+          for field in fields {
+            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);
+          }
+
+          all_results.push(serde_json::Value::Object(result));
+
+          continue;
+        }
+
+        all_results.push(yerba::json::yaml_to_json(&value));
+      }
+    }
+
+    if self.raw {
+      for value in &all_results {
+        match value {
+          serde_json::Value::String(string) => println!("{}", string),
+          serde_json::Value::Null => println!("null"),
+          serde_json::Value::Bool(boolean) => println!("{}", boolean),
+          serde_json::Value::Number(number) => println!("{}", number),
+          _ => println!("{}", serde_json::to_string(value).unwrap_or_default()),
+        }
+      }
+    } else if all_results.len() == 1 {
+      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())
+      );
+    }
+  }
+
+  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();
+
+        if container.is_empty() {
+          return (selector.clone(), None);
+        }
+
+        let extract = if field.is_empty() { None } else { Some(field) };
+
+        return (container, extract);
+      } else {
+        let (container, _) = condition.split_at_first_bracket();
+        let container_string = container.to_selector_string();
+        let selector_string = selector.to_selector_string();
+
+        if selector_string.starts_with(&container_string) {
+          let rest = selector_string[container_string.len()..].trim_start_matches('.');
+
+          if rest.is_empty() {
+            return (container, None);
+          }
+
+          return (container, Some(yerba::Selector::parse(&format!(".{}", rest))));
+        }
+
+        return (container, None);
+      }
+    }
+
+    if selector.has_brackets() && !selector.ends_with_bracket() {
+      let (container, field) = selector.split_at_last_bracket();
+
+      if !container.is_empty() {
+        let extract = if field.is_empty() { None } else { Some(field) };
+
+        return (container, extract);
+      }
+    }
+
+    (selector.clone(), None)
+  }
+}

data/rust/src/commands/init.rs

@@ -0,0 +1,89 @@
+use std::path::Path;
+use std::process;
+
+use indoc::indoc;
+
+use super::color::*;
+
+pub fn run() {
+  let filename = "Yerbafile";
+
+  if Path::new(filename).exists() {
+    eprintln!("🧉 {YELLOW}{BOLD}Yerbafile already exists.{RESET}");
+    process::exit(1);
+  }
+
+  let content = indoc! {r#"
+    # rules:
+    #   - files: "**/*.yml"
+    #     pipeline:
+    #
+    #       # Enforce quote style on values and keys
+    #       - quote_style:
+    #           key_style: plain        # plain, single, double
+    #           value_style: double     # plain, single, double
+    #
+    #       # Override quote style for a specific selector
+    #       - quote_style:
+    #           path: "[].speakers"
+    #           value_style: plain
+    #
+    #       # Sort keys in a predefined order (aborts on unknown keys)
+    #       - sort_keys:
+    #           path: "[]"
+    #           order:
+    #             - id
+    #             - title
+    #             - description
+    #
+    #       # Sort items in a sequence by field(s)
+    #       - sort:
+    #           path: ""
+    #           by: name
+    #           # case_sensitive: false
+    #
+    #       # Enforce blank lines between sequence entries
+    #       - blank_lines:
+    #           count: 1
+    #
+    #       # Set a value (with optional condition)
+    #       - set:
+    #           path: "status"
+    #           value: "published"
+    #           # condition: ".draft == true"
+    #
+    #       # Insert a new key or sequence item
+    #       - insert:
+    #           path: "tags"
+    #           value: "yaml"
+    #           # condition: ".tags not_contains yaml"
+    #
+    #       # Delete a key (with optional condition)
+    #       - delete:
+    #           path: "deprecated_field"
+    #           # condition: ".deprecated_field == true"
+    #
+    #       # Rename a key
+    #       - rename:
+    #           from: "old_name"
+    #           to: "new_name"
+    #
+    #       # Remove an item from a sequence
+    #       - remove:
+    #           path: "tags"
+    #           value: "obsolete"
+    #
+    #       # Get a value and store it as a variable
+    #       - get:
+    #           path: "[].name"
+    #           as: "names"
+    #           # file: "other_file.yml"
+  "#};
+
+  std::fs::write(filename, content).unwrap_or_else(|error| {
+    eprintln!("{RED}Error:{RESET} writing Yerbafile: {}", error);
+    process::exit(1);
+  });
+
+  eprintln!("🧉 {GREEN}{BOLD}Created Yerbafile{RESET}");
+}

data/rust/src/commands/insert.rs

@@ -0,0 +1,106 @@
+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 insert config.yml "database.ssl" true
+    yerba insert config.yml "database.ssl" true --after "host"
+    yerba insert config.yml "database.ssl" true --before "port"
+    yerba insert config.yml "tags" "yaml"
+    yerba insert config.yml "tags" "yaml" --at 0
+    yerba insert config.yml "tags" "yaml" --after "ruby"
+    yerba insert speakers.yml "" "name: Bob" --after ".name == Alice"
+    yerba insert videos.yml "[0].speakers" "Diana" --before ".name == Charlie"
+    yerba insert videos.yml "" --from "new_talk.yml" --after ".id == first-talk"
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Insert a new key into a map or item into a sequence",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  selector: String,
+  value: Option<String>,
+  #[arg(long, help = "Read value from a file (use - for stdin)")]
+  from: Option<String>,
+  #[arg(long, help = "Insert before this value or condition (e.g. \".name == Alice\")")]
+  before: Option<String>,
+  #[arg(long, help = "Insert after this value or condition (e.g. \".name == Alice\")")]
+  after: Option<String>,
+  #[arg(long)]
+  at: Option<usize>,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    let resolved_value = if let Some(from_path) = self.from {
+      if from_path == "-" {
+        use std::io::Read;
+        let mut buffer = String::new();
+
+        std::io::stdin().read_to_string(&mut buffer).unwrap_or_else(|error| {
+          use super::color::*;
+          eprintln!("{RED}Error:{RESET} reading stdin: {}", error);
+
+          std::process::exit(1);
+        });
+
+        buffer.trim().to_string()
+      } else {
+        std::fs::read_to_string(&from_path)
+          .unwrap_or_else(|error| {
+            use super::color::*;
+            eprintln!("{RED}Error:{RESET} reading {}: {}", from_path, error);
+            std::process::exit(1);
+          })
+          .trim()
+          .to_string()
+      }
+    } else if let Some(val) = self.value {
+      val
+    } else {
+      use super::color::*;
+      eprintln!("{RED}Error:{RESET} either a value argument or --from is required");
+
+      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)
+      }
+    } else if let Some(target) = self.after {
+      if target.starts_with('.') {
+        yerba::InsertPosition::AfterCondition(target)
+      } else {
+        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)
+    };
+
+    let mut document = parse_file(&self.file);
+    run_op(|| document.insert_into(&self.selector, &resolved_value, position));
+    output(&self.file, &document, self.dry_run);
+  }
+}

data/rust/src/commands/mate.rs

@@ -0,0 +1,55 @@
+use super::color::*;
+
+pub fn run() {
+  let g = GREEN;
+  let b = BOLD;
+  let d = DIM;
+  let i = "\x1b[3m"; // italic
+  let y = YELLOW;
+  let r = RESET;
+  let hr = format!("    {d}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}{r}");
+
+  println!();
+  println!("    {b}{g}\u{1f9c9} YERBA MATE{r}");
+  println!();
+  println!("    {d}From the Guarani people of South America to the world.{r}");
+  println!("    {d}Brewed from the leaves of{r} {i}Ilex paraguariensis{r}{d}, shared{r}");
+  println!("    {d}in a hollowed calabaza, sipped through a metal bombilla.{r}");
+  println!("    {d}One cup, many rounds.{r}");
+  println!();
+  println!("{hr}");
+  println!();
+  println!("    {b}{g}yerba{r} {d}/\u{02c8}\u{0292}\u{025b}\u{027e}.ba/{r} {y}noun{r}");
+  println!("    The dried leaves of {i}Ilex paraguariensis{r}, used to brew");
+  println!("    mate. From Guarani {i}ka'a{r}, meaning \"herb\".");
+  println!();
+  println!("    {b}{g}mate{r} {d}/\u{02c8}ma.te/{r} {y}noun{r}");
+  println!("    A traditional South American caffeine-rich infusion.");
+  println!("    Also the hollowed calabaza (gourd) from which it is drunk.");
+  println!();
+  println!("    {b}{g}bombilla{r} {d}/bom\u{02c8}bi.\u{0292}a/{r} {y}noun{r}");
+  println!("    A metal straw with a filtered tip at the bottom, used");
+  println!("    to sip mate without swallowing the leaves.");
+  println!();
+  println!("    {b}{g}cebador{r} {d}/se.ba\u{02c8}\u{00f0}o\u{027e}/{r} {y}noun{r}");
+  println!("    The person who prepares and serves mate to the group.");
+  println!("    A role of care, not hierarchy.");
+  println!();
+  println!("    {b}{g}ronda{r} {d}/\u{02c8}ron.da/{r} {y}noun{r}");
+  println!("    The circle of people sharing mate. The cup passes");
+  println!("    from hand to hand until it returns to the cebador.");
+  println!();
+  println!("    {b}{g}cebar{r} {d}/se\u{02c8}ba\u{027e}/{r} {y}verb{r}");
+  println!("    To pour hot water over the yerba and serve a round.");
+  println!("    The act of preparing each individual serving.");
+  println!();
+  println!("    {b}{g}aprontar{r} {d}/ap\u{027e}on\u{02c8}ta\u{027e}/{r} {y}verb{r}");
+  println!("    To set up mate before the first pour: arranging the");
+  println!("    yerba, heating the water, positioning the bombilla.");
+  println!();
+  println!("    {b}{g}ensillar{r} {d}/ensi\u{02c8}\u{0292}a\u{027e}/{r} {y}verb{r}");
+  println!("    To replace spent yerba with fresh leaves mid-session,");
+  println!("    extending the life of the mate.");
+  println!();
+  println!("{hr}");
+}