yerba 0.2.0-x86_64-linux-gnu

data/rust/src/json.rs

@@ -0,0 +1,128 @@
+use crate::selector::{Selector, SelectorSegment};
+
+pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
+  match value {
+    serde_yaml::Value::Null => serde_json::Value::Null,
+    serde_yaml::Value::Bool(boolean) => serde_json::Value::Bool(*boolean),
+
+    serde_yaml::Value::Number(number) => {
+      if let Some(integer) = number.as_i64() {
+        serde_json::Value::Number(integer.into())
+      } else if let Some(float) = number.as_f64() {
+        serde_json::json!(float)
+      } else {
+        serde_json::Value::String(number.to_string())
+      }
+    }
+
+    serde_yaml::Value::String(string) => serde_json::Value::String(string.clone()),
+
+    serde_yaml::Value::Sequence(sequence) => serde_json::Value::Array(sequence.iter().map(yaml_to_json).collect()),
+
+    serde_yaml::Value::Mapping(mapping) => {
+      let mut map = serde_json::Map::new();
+
+      for (key, yaml_value) in mapping {
+        let json_key = match key {
+          serde_yaml::Value::String(string) => string.clone(),
+          _ => format!("{:?}", key),
+        };
+
+        map.insert(json_key, yaml_to_json(yaml_value));
+      }
+
+      serde_json::Value::Object(map)
+    }
+
+    serde_yaml::Value::Tagged(tagged) => yaml_to_json(&tagged.value),
+  }
+}
+
+pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_json::Value {
+  let parsed = Selector::parse(field);
+  let segments = parsed.segments();
+
+  if segments.len() == 1 {
+    if let SelectorSegment::Key(key) = &segments[0] {
+      if let serde_yaml::Value::Mapping(map) = value {
+        for (map_key, yaml_value) in map {
+          if let serde_yaml::Value::String(key_string) = map_key {
+            if key_string == key {
+              return yaml_to_json(yaml_value);
+            }
+          }
+        }
+      }
+
+      return serde_json::Value::Null;
+    }
+  }
+
+  let mut current_values = vec![value.clone()];
+
+  for segment in segments {
+    let mut next_values = Vec::new();
+
+    for current in &current_values {
+      match segment {
+        SelectorSegment::AllItems => {
+          if let serde_yaml::Value::Sequence(sequence) = current {
+            next_values.extend(sequence.iter().cloned());
+          }
+        }
+
+        SelectorSegment::Index(index) => {
+          if let serde_yaml::Value::Sequence(sequence) = current {
+            if let Some(item) = sequence.get(*index) {
+              next_values.push(item.clone());
+            }
+          }
+        }
+
+        SelectorSegment::Key(key) => {
+          if let serde_yaml::Value::Mapping(map) = current {
+            for (map_key, yaml_value) in map {
+              if let serde_yaml::Value::String(key_string) = map_key {
+                if key_string == key {
+                  next_values.push(yaml_value.clone());
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    current_values = next_values;
+  }
+
+  let used_all_items = parsed.segments().iter().any(|s| matches!(s, SelectorSegment::AllItems));
+
+  if current_values.is_empty() {
+    if used_all_items {
+      serde_json::Value::Array(Vec::new())
+    } else {
+      serde_json::Value::Null
+    }
+  } else if current_values.len() == 1 && !used_all_items {
+    yaml_to_json(&current_values[0])
+  } else {
+    serde_json::Value::Array(current_values.iter().map(yaml_to_json).collect())
+  }
+}
+
+pub fn select_field_key(field: &str) -> String {
+  let parsed = Selector::parse(field);
+
+  parsed
+    .segments()
+    .iter()
+    .find_map(|segment| {
+      if let SelectorSegment::Key(key) = segment {
+        Some(key.clone())
+      } else {
+        None
+      }
+    })
+    .unwrap_or_else(|| field.to_string())
+}

data/rust/src/lib.rs

@@ -0,0 +1,29 @@
+mod document;
+mod error;
+pub mod ffi;
+pub mod json;
+mod quote_style;
+pub mod selector;
+mod syntax;
+mod yaml_writer;
+pub mod yerbafile;
+
+pub use document::{Document, InsertPosition, SortField};
+pub use error::YerbaError;
+pub use quote_style::QuoteStyle;
+pub use selector::Selector;
+pub use syntax::{detect_yaml_type, ScalarValue, YerbaValueType};
+pub use yaml_writer::json_to_yaml_text;
+pub use yerbafile::Yerbafile;
+
+pub fn version() -> &'static str {
+  env!("CARGO_PKG_VERSION")
+}
+
+pub fn parse(source: &str) -> Result<Document, YerbaError> {
+  Document::parse(source)
+}
+
+pub fn parse_file(path: impl AsRef<std::path::Path>) -> Result<Document, YerbaError> {
+  Document::parse_file(path)
+}

data/rust/src/main.rs

@@ -0,0 +1,72 @@
+mod commands;
+
+use std::sync::LazyLock;
+
+use clap::builder::styling::{AnsiColor, Effects, Styles};
+use clap::Parser;
+use indoc::indoc;
+
+const STYLES: Styles = Styles::styled()
+  .header(AnsiColor::Green.on_default().effects(Effects::BOLD))
+  .usage(AnsiColor::Green.on_default().effects(Effects::BOLD))
+  .literal(AnsiColor::Cyan.on_default())
+  .placeholder(AnsiColor::Yellow.on_default())
+  .valid(AnsiColor::Green.on_default());
+
+static HELP: LazyLock<String> = LazyLock::new(|| {
+  commands::colorize_help(indoc! {r#"
+    Selectors:
+      key                  A single key          "database.host"
+      key.nested           Nested key path       "database.settings.pool"
+      []                   All items in array    "[].title"
+      [N]                  Item at index         "[0].title"
+      [].key[].nested      Nested array access   "[].speakers[].name"
+
+    Conditions:
+      .key == value        Equality              ".kind == keynote"
+      .key != value        Inequality            ".status != draft"
+      .key contains val    Substring or member   ".title contains Ruby"
+      .key not_contains    Negated contains      ".title not_contains test"
+
+    Yerbafile:
+      yerba init           Create a new Yerbafile in the current directory
+      yerba check          Check if all files match the rules (exits 1 if not)
+      yerba apply          Apply all rules and write changes
+
+    Examples:
+      yerba get config.yml "database.host"
+      yerba get videos.yml "[0].title"
+      yerba get videos.yml "[]" --select ".title,.speakers"
+      yerba get "data/**/videos.yml" "[]" --condition ".kind == keynote" --select ".id,.title"
+      yerba set config.yml "database.host" "0.0.0.0"
+      yerba insert config.yml "tags" "yaml" --after "ruby"
+      yerba insert speakers.yml "" --from "speaker.yml" --after ".name == Alice"
+      yerba delete config.yml "database.pool"
+      yerba move videos.yml "" ".id == talk-2" --after ".id == talk-1"
+      yerba sort-keys config.yml "database" "id,host,port,name"
+      yerba quote-style "data/**/*.yml" --values double
+  "#})
+});
+
+#[derive(Parser)]
+#[command(
+  name = "yerba",
+  version = yerba::version(),
+  disable_version_flag = true,
+  styles = STYLES,
+  about = "Yerba 🧉 YAML Editing and Refactoring with Better Accuracy",
+  arg_required_else_help = true,
+  override_usage = "\x1b[1myerba\x1b[0m <command> <file> <selector> [options]",
+  disable_help_subcommand = true,
+  after_help = HELP.as_str()
+)]
+#[allow(clippy::upper_case_acronyms)]
+struct CLI {
+  #[command(subcommand)]
+  command: commands::Command,
+}
+
+fn main() {
+  let cli = CLI::parse();
+  cli.command.run();
+}

data/rust/src/quote_style.rs

@@ -0,0 +1,42 @@
+use clap::ValueEnum;
+use yaml_parser::SyntaxKind;
+
+#[derive(Debug, Clone, PartialEq, ValueEnum)]
+pub enum QuoteStyle {
+  Plain,
+  #[value(alias = "single-quoted")]
+  Single,
+  #[value(alias = "double-quoted")]
+  Double,
+  #[value(alias = "block-literal")]
+  Literal,
+  #[value(alias = "block-folded")]
+  Folded,
+}
+
+impl std::str::FromStr for QuoteStyle {
+  type Err = String;
+
+  fn from_str(string: &str) -> Result<Self, Self::Err> {
+    match string {
+      "plain" => Ok(QuoteStyle::Plain),
+      "single" | "single-quoted" => Ok(QuoteStyle::Single),
+      "double" | "double-quoted" => Ok(QuoteStyle::Double),
+      "literal" | "block-literal" => Ok(QuoteStyle::Literal),
+      "folded" | "block-folded" => Ok(QuoteStyle::Folded),
+      _ => Err(format!("unknown quote style: '{}'", string)),
+    }
+  }
+}
+
+impl QuoteStyle {
+  pub(crate) fn to_syntax_kind(&self) -> SyntaxKind {
+    match self {
+      QuoteStyle::Plain => SyntaxKind::PLAIN_SCALAR,
+      QuoteStyle::Single => SyntaxKind::SINGLE_QUOTED_SCALAR,
+      QuoteStyle::Double => SyntaxKind::DOUBLE_QUOTED_SCALAR,
+      QuoteStyle::Literal => SyntaxKind::BLOCK_SCALAR_TEXT,
+      QuoteStyle::Folded => SyntaxKind::BLOCK_SCALAR_TEXT,
+    }
+  }
+}

data/rust/src/selector.rs

@@ -0,0 +1,241 @@
+/// A parsed selector used across selectors, conditions, and select fields.
+///
+/// Selectors starting with `.` are relative to the current item context.
+/// All other selectors are absolute from the document root.
+///
+/// Examples:
+///   ".title"              → Relative([Key("title")])
+///   ".speakers[].name"    → Relative([Key("speakers"), AllItems, Key("name")])
+///   "database.host"       → Absolute([Key("database"), Key("host")])
+///   "[].title"            → Absolute([AllItems, Key("title")])
+///   "[0].speakers[]"      → Absolute([Index(0), Key("speakers"), AllItems])
+///   "[]"                  → Absolute([AllItems])
+///
+#[derive(Debug, Clone, PartialEq)]
+pub enum Selector {
+  Relative(Vec<SelectorSegment>),
+  Absolute(Vec<SelectorSegment>),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum SelectorSegment {
+  Key(String),
+  AllItems,
+  Index(usize),
+}
+
+impl Selector {
+  pub fn parse(input: &str) -> Self {
+    let input = input.trim();
+
+    if input.is_empty() {
+      return Selector::Absolute(Vec::new());
+    }
+
+    if let Some(rest) = input.strip_prefix('.') {
+      Selector::Relative(parse_segments(rest))
+    } else {
+      Selector::Absolute(parse_segments(input))
+    }
+  }
+
+  pub fn is_relative(&self) -> bool {
+    matches!(self, Selector::Relative(_))
+  }
+
+  pub fn is_absolute(&self) -> bool {
+    matches!(self, Selector::Absolute(_))
+  }
+
+  pub fn segments(&self) -> &[SelectorSegment] {
+    match self {
+      Selector::Relative(segments) | Selector::Absolute(segments) => segments,
+    }
+  }
+
+  pub fn is_empty(&self) -> bool {
+    self.segments().is_empty()
+  }
+
+  pub fn ends_with_bracket(&self) -> bool {
+    matches!(
+      self.segments().last(),
+      Some(SelectorSegment::AllItems | SelectorSegment::Index(_))
+    )
+  }
+
+  pub fn has_brackets(&self) -> bool {
+    self
+      .segments()
+      .iter()
+      .any(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)))
+  }
+
+  pub fn has_wildcard(&self) -> bool {
+    self.segments().iter().any(|s| matches!(s, SelectorSegment::AllItems))
+  }
+
+  /// Split into the container selector (up to and including the last []) and the remaining field selector.
+  /// Used to separate "where to search" from "what to extract".
+  ///
+  /// "[].speakers[].name" → ("[].speakers[]", ".name")
+  /// "[].title"           → ("[]", ".title")
+  /// "[]"                 → ("[]", "")
+  /// "database.host"      → ("", "database.host")
+  pub fn split_at_last_bracket(&self) -> (Selector, Selector) {
+    let segments = self.segments();
+
+    let last_bracket = segments
+      .iter()
+      .rposition(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)));
+
+    match last_bracket {
+      Some(pos) => {
+        let container = segments[..=pos].to_vec();
+        let field = segments[pos + 1..].to_vec();
+
+        (Selector::Absolute(container), Selector::Relative(field))
+      }
+      None => (Selector::Absolute(Vec::new()), Selector::Absolute(segments.to_vec())),
+    }
+  }
+
+  /// Split at the first [] bracket — used for condition evaluation.
+  /// The condition is evaluated on items at the first container level.
+  ///
+  /// "[].speakers[]"     → ("[],", ".speakers[]")
+  /// "[].title"          → ("[]", ".title")
+  /// "[]"                → ("[]", "")
+  pub fn split_at_first_bracket(&self) -> (Selector, Selector) {
+    let segments = self.segments();
+
+    let first_bracket = segments
+      .iter()
+      .position(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)));
+
+    match first_bracket {
+      Some(position) => {
+        let container = segments[..=position].to_vec();
+        let rest = segments[position + 1..].to_vec();
+
+        (Selector::Absolute(container), Selector::Relative(rest))
+      }
+
+      None => (Selector::Absolute(Vec::new()), Selector::Absolute(segments.to_vec())),
+    }
+  }
+
+  /// Resolve a relative selector against a base absolute selector.
+  ///
+  /// ".title" + "[]"          → "[].title"
+  /// ".name"  + "[].speakers[]" → "[].speakers[].name"
+  /// If self is absolute, returns self unchanged.
+  pub fn resolve_relative(&self, base: &Selector) -> Selector {
+    if self.is_absolute() {
+      return self.clone();
+    }
+
+    let mut segments = base.segments().to_vec();
+    segments.extend_from_slice(self.segments());
+
+    Selector::Absolute(segments)
+  }
+
+  pub fn to_selector_string(&self) -> String {
+    let segments = self.segments();
+
+    if segments.is_empty() {
+      return String::new();
+    }
+
+    let mut result = String::new();
+
+    for (index, segment) in segments.iter().enumerate() {
+      match segment {
+        SelectorSegment::Key(key) => {
+          if index > 0 && !matches!(segments.get(index - 1), Some(SelectorSegment::Key(_))) {
+            if !result.ends_with('.') {
+              result.push('.');
+            }
+          } else if index > 0 {
+            result.push('.');
+          }
+
+          result.push_str(key);
+        }
+
+        SelectorSegment::AllItems => {
+          result.push_str("[]");
+        }
+
+        SelectorSegment::Index(i) => {
+          result.push_str(&format!("[{}]", i));
+        }
+      }
+    }
+
+    result
+  }
+}
+
+fn parse_segments(input: &str) -> Vec<SelectorSegment> {
+  let mut segments = Vec::new();
+  let mut rest = input;
+
+  while !rest.is_empty() {
+    if rest.starts_with('[') {
+      if let Some(close) = rest.find(']') {
+        let inner = &rest[1..close];
+
+        if inner.is_empty() {
+          segments.push(SelectorSegment::AllItems);
+        } else if let Ok(index) = inner.parse::<usize>() {
+          segments.push(SelectorSegment::Index(index));
+        }
+
+        rest = &rest[close + 1..];
+
+        if rest.starts_with('.') {
+          rest = &rest[1..];
+        }
+      } else {
+        break;
+      }
+    } else {
+      let dot_index = rest.find('.');
+      let bracket_index = rest.find('[');
+
+      let split_at = match (dot_index, bracket_index) {
+        (Some(dot), Some(bracket)) => Some(dot.min(bracket)),
+        (Some(dot), None) => Some(dot),
+        (None, Some(bracket)) => Some(bracket),
+        (None, None) => None,
+      };
+
+      match split_at {
+        Some(index) => {
+          let key = &rest[..index];
+
+          if !key.is_empty() {
+            segments.push(SelectorSegment::Key(key.to_string()));
+          }
+
+          rest = &rest[index..];
+
+          if rest.starts_with('.') {
+            rest = &rest[1..];
+          }
+        }
+        None => {
+          if !rest.is_empty() {
+            segments.push(SelectorSegment::Key(rest.to_string()));
+          }
+
+          break;
+        }
+      }
+    }
+  }
+
+  segments
+}