yerba 0.1.1 → 0.2.0

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
+}

data/rust/src/syntax.rs

@@ -4,6 +4,55 @@ use rowan::{TextRange, TextSize};
 use yaml_parser::ast::{BlockMap, BlockMapEntry};
 use yaml_parser::{SyntaxKind, SyntaxNode, SyntaxToken};
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct ScalarValue {
+  pub text: String,
+  pub kind: SyntaxKind,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum YerbaValueType {
+  Null = 0,
+  Boolean = 1,
+  Integer = 2,
+  Float = 3,
+  String = 4,
+}
+
+pub fn detect_yaml_type(scalar: &ScalarValue) -> YerbaValueType {
+  if scalar.kind != SyntaxKind::PLAIN_SCALAR {
+    return YerbaValueType::String;
+  }
+
+  detect_yaml_type_from_plain(&scalar.text)
+}
+
+pub fn extract_scalar(node: &SyntaxNode) -> Option<ScalarValue> {
+  let token = find_scalar_token(node)?;
+
+  let text = match token.kind() {
+    SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
+
+    SyntaxKind::DOUBLE_QUOTED_SCALAR => {
+      let raw = token.text();
+      unescape_double_quoted(&raw[1..raw.len() - 1])
+    }
+
+    SyntaxKind::SINGLE_QUOTED_SCALAR => {
+      let raw = token.text();
+      unescape_single_quoted(&raw[1..raw.len() - 1])
+    }
+
+    _ => return None,
+  };
+
+  Some(ScalarValue {
+    text,
+    kind: token.kind(),
+  })
+}
+
 pub fn is_map_key(token: &SyntaxToken) -> bool {
   token
     .parent_ancestors()
@@ -141,46 +190,73 @@ pub fn removal_range(node: &SyntaxNode) -> TextRange {
 }
 
 pub fn is_yaml_non_string(value: &str) -> bool {
-  // Null (YAML 1.1 + 1.2)
-  if matches!(value, "null" | "Null" | "NULL" | "~" | "") {
-    return true;
-  }
-
-  // Boolean (YAML 1.2)
-  if matches!(value, "true" | "True" | "TRUE" | "false" | "False" | "FALSE") {
-    return true;
-  }
+  detect_yaml_type_from_plain(value) != YerbaValueType::String
+}
 
-  // Boolean (YAML 1.1 extras)
-  if matches!(
+pub fn is_yaml_truthy(value: &str) -> bool {
+  matches!(
     value,
-    "yes" | "Yes" | "YES" | "no" | "No" | "NO" | "on" | "On" | "ON" | "off" | "Off" | "OFF" | "y" | "Y" | "n" | "N"
-  ) {
-    return true;
+    "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON" | "y" | "Y"
+  )
+}
+
+pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {
+  // Null (YAML 1.1 + 1.2)
+  if matches!(value, "null" | "Null" | "NULL" | "~" | "") {
+    return YerbaValueType::Null;
   }
 
-  // Special floats (YAML 1.1 + 1.2)
+  // Boolean (YAML 1.2 + 1.1)
   if matches!(
     value,
-    ".inf" | ".Inf" | ".INF" | "-.inf" | "-.Inf" | "-.INF" | "+.inf" | "+.Inf" | "+.INF" | ".nan" | ".NaN" | ".NAN"
+    "true"
+      | "True"
+      | "TRUE"
+      | "false"
+      | "False"
+      | "FALSE"
+      | "yes"
+      | "Yes"
+      | "YES"
+      | "no"
+      | "No"
+      | "NO"
+      | "on"
+      | "On"
+      | "ON"
+      | "off"
+      | "Off"
+      | "OFF"
+      | "y"
+      | "Y"
+      | "n"
+      | "N"
   ) {
-    return true;
+    return YerbaValueType::Boolean;
   }
 
   // Integer
   if value.parse::<i64>().is_ok() {
-    return true;
+    return YerbaValueType::Integer;
   }
 
   // Octal (0o...) and hex (0x...)
   if value.starts_with("0x") || value.starts_with("0X") || value.starts_with("0o") || value.starts_with("0O") {
-    return true;
+    return YerbaValueType::Integer;
+  }
+
+  // Special floats (YAML 1.1 + 1.2)
+  if matches!(
+    value,
+    ".inf" | ".Inf" | ".INF" | "-.inf" | "-.Inf" | "-.INF" | "+.inf" | "+.Inf" | "+.INF" | ".nan" | ".NaN" | ".NAN"
+  ) {
+    return YerbaValueType::Float;
   }
 
   // Float
   if value.parse::<f64>().is_ok() {
-    return true;
+    return YerbaValueType::Float;
   }
 
-  false
+  YerbaValueType::String
 }

data/rust/src/yaml_writer.rs

@@ -0,0 +1,89 @@
+use serde_json::Value;
+
+use crate::QuoteStyle;
+
+pub fn json_to_yaml_text(value: &Value, quote_style: &QuoteStyle, indent: usize) -> String {
+  match value {
+    Value::Object(map) => {
+      let prefix = " ".repeat(indent);
+
+      map
+        .iter()
+        .map(|(k, v)| match v {
+          Value::Array(arr) => {
+            let items: Vec<String> = arr
+              .iter()
+              .map(|item| match item {
+                Value::Object(_) => {
+                  let inner = json_to_yaml_text(item, quote_style, indent + 4);
+                  format!("{}  - {}", prefix, inner.trim_start())
+                }
+
+                _ => format!("{}  - {}", prefix, format_yaml_scalar(item, quote_style)),
+              })
+              .collect();
+
+            format!("{}{}:\n{}", prefix, k, items.join("\n"))
+          }
+
+          Value::Object(_) => {
+            let inner = json_to_yaml_text(v, quote_style, indent + 2);
+            format!("{}{}:\n{}", prefix, k, inner)
+          }
+
+          _ => format!("{}{}: {}", prefix, k, format_yaml_scalar(v, quote_style)),
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+    }
+
+    _ => {
+      let prefix = " ".repeat(indent);
+
+      format!("{}{}", prefix, format_yaml_scalar(value, quote_style))
+    }
+  }
+}
+
+fn format_yaml_scalar(value: &Value, quote_style: &QuoteStyle) -> String {
+  match value {
+    Value::Null => "null".to_string(),
+    Value::Bool(boolean) => boolean.to_string(),
+    Value::Number(number) => number.to_string(),
+    Value::String(string) => match quote_style {
+      QuoteStyle::Double => {
+        let escaped = string.replace('\\', "\\\\").replace('"', "\\\"");
+
+        format!("\"{}\"", escaped)
+      }
+
+      QuoteStyle::Single => {
+        let escaped = string.replace('\'', "''");
+
+        format!("'{}'", escaped)
+      }
+
+      QuoteStyle::Plain => {
+        if crate::syntax::is_yaml_non_string(string) {
+          format!("\"{}\"", string.replace('"', "\\\""))
+        } else {
+          string.clone()
+        }
+      }
+
+      _ => {
+        let escaped = string.replace('\\', "\\\\").replace('"', "\\\"");
+
+        format!("\"{}\"", escaped)
+      }
+    },
+
+    Value::Array(array) => {
+      let items: Vec<String> = array.iter().map(|item| format_yaml_scalar(item, quote_style)).collect();
+
+      format!("[{}]", items.join(", "))
+    }
+
+    Value::Object(_) => format!("{:?}", value),
+  }
+}