yerba 0.4.2-x86_64-linux-gnu → 0.5.0-x86_64-linux-gnu

data/rust/src/document/unique.rs

@@ -0,0 +1,86 @@
+use yaml_parser::ast::BlockSeq;
+
+use rowan::ast::AstNode;
+
+use crate::document::{extract_scalar_text, navigate_from_node, Document};
+use crate::error::YerbaError;
+
+#[derive(Debug, Clone)]
+pub struct DuplicateInfo {
+  pub value: String,
+  pub line: usize,
+}
+
+impl Document {
+  pub fn unique(&mut self, dot_path: &str, by: &str, remove: bool) -> Result<Vec<DuplicateInfo>, YerbaError> {
+    self.unique_with_options(dot_path, by, remove, false)
+  }
+
+  pub fn unique_with_options(&mut self, dot_path: &str, by: &str, remove: bool, allow_blank_duplicates: bool) -> Result<Vec<DuplicateInfo>, YerbaError> {
+    let current_node = self.navigate(dot_path)?;
+    let source = self.root.text().to_string();
+
+    let sequence = match current_node.descendants().find_map(BlockSeq::cast) {
+      Some(sequence) => sequence,
+      None => return Ok(Vec::new()),
+    };
+
+    let entries: Vec<_> = sequence.entries().collect();
+
+    if entries.len() <= 1 {
+      return Ok(Vec::new());
+    }
+
+    let by_is_scalar = by == ".";
+
+    let labels: Vec<(Option<String>, usize)> = entries
+      .iter()
+      .map(|entry| {
+        let offset: usize = entry.syntax().text_range().start().into();
+        let line = source[..offset].matches('\n').count() + 1;
+
+        let value = if by_is_scalar {
+          Some(entry.flow().and_then(|flow| extract_scalar_text(flow.syntax())).unwrap_or_default())
+        } else {
+          let field = by.strip_prefix('.').unwrap_or(by);
+          let nodes = navigate_from_node(entry.syntax(), field);
+
+          nodes.first().and_then(extract_scalar_text)
+        };
+
+        (value, line)
+      })
+      .collect();
+
+    let mut seen = std::collections::HashSet::new();
+    let mut duplicate_indices: Vec<usize> = Vec::new();
+    let mut duplicates: Vec<DuplicateInfo> = Vec::new();
+
+    for (index, (label, line)) in labels.iter().enumerate() {
+      let label = match label {
+        None => continue,
+        Some(value) => value,
+      };
+
+      if allow_blank_duplicates && label.is_empty() {
+        continue;
+      }
+
+      if !seen.insert(label.clone()) {
+        duplicate_indices.push(index);
+        duplicates.push(DuplicateInfo {
+          value: label.clone(),
+          line: *line,
+        });
+      }
+    }
+
+    if remove && !duplicate_indices.is_empty() {
+      for &index in duplicate_indices.iter().rev() {
+        self.remove_at(dot_path, index)?;
+      }
+    }
+
+    Ok(duplicates)
+  }
+}

data/rust/src/error.rs

@@ -7,6 +7,8 @@ pub enum YerbaError {
   NotASequence(String),
   IndexOutOfBounds(usize, usize),
   UnknownKeys(Vec<String>),
+  DuplicateValues(Vec<crate::DuplicateInfo>),
+  SchemaValidation(Vec<crate::schema::ValidationError>),
   DuplicateKey {
     key: String,
     first_line: usize,
@@ -48,10 +50,26 @@ impl std::fmt::Display for YerbaError {
         )
       }
 
+      YerbaError::DuplicateValues(duplicates) => {
+        let noun = if duplicates.len() == 1 { "duplicate" } else { "duplicates" };
+        let details: Vec<String> = duplicates
+          .iter()
+          .map(|duplicate| format!("\"{}\" (line {})", duplicate.value, duplicate.line))
+          .collect();
+
+        write!(f, "found {} {}: {}", duplicates.len(), noun, details.join(", "))
+      }
+
       YerbaError::IndexOutOfBounds(index, length) => {
         write!(f, "index {} out of bounds (length {})", index, length)
       }
 
+      YerbaError::SchemaValidation(errors) => {
+        let details: Vec<String> = errors.iter().map(|error| error.to_string()).collect();
+
+        write!(f, "schema validation failed:\n{}", details.join("\n"))
+      }
+
       YerbaError::UnknownKeys(keys) => {
         let suggestion = keys.iter().map(|key| format!("\"{}\"", key)).collect::<Vec<_>>().join(", ");
 
@@ -71,3 +89,63 @@ impl From<std::io::Error> for YerbaError {
     YerbaError::IoError(err)
   }
 }
+
+pub struct GitHubAnnotation {
+  pub level: &'static str,
+  pub file: String,
+  pub line: Option<usize>,
+  pub message: String,
+}
+
+impl std::fmt::Display for GitHubAnnotation {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self.line {
+      Some(line) => write!(f, "::{}file={},line={}::{}", self.level, self.file, line, self.message),
+      None => write!(f, "::{}file={}::{}", self.level, self.file, self.message),
+    }
+  }
+}
+
+pub trait GitHubAnnotations {
+  fn github_annotations(&self, file: &str) -> Vec<GitHubAnnotation>;
+}
+
+impl GitHubAnnotations for YerbaError {
+  fn github_annotations(&self, file: &str) -> Vec<GitHubAnnotation> {
+    match self {
+      YerbaError::DuplicateValues(duplicates) => duplicates
+        .iter()
+        .map(|duplicate| GitHubAnnotation {
+          level: "error ",
+          file: file.to_string(),
+          line: Some(duplicate.line),
+          message: format!("duplicate: \"{}\"", duplicate.value),
+        })
+        .collect(),
+
+      YerbaError::SchemaValidation(errors) => errors
+        .iter()
+        .map(|error| GitHubAnnotation {
+          level: "error ",
+          file: file.to_string(),
+          line: error.line,
+          message: error.to_string(),
+        })
+        .collect(),
+
+      YerbaError::DuplicateKey { key, duplicate_line, .. } => vec![GitHubAnnotation {
+        level: "error ",
+        file: file.to_string(),
+        line: Some(*duplicate_line),
+        message: format!("duplicate key: \"{}\"", key),
+      }],
+
+      _ => vec![GitHubAnnotation {
+        level: "error ",
+        file: file.to_string(),
+        line: None,
+        message: self.to_string(),
+      }],
+    }
+  }
+}

data/rust/src/ffi.rs

@@ -298,13 +298,22 @@ pub unsafe extern "C" fn yerba_document_get_value(document: *const Document, pat
 
 /// Caller must free with yerba_string_free.
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_get_values(document: *const Document, path: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn yerba_document_selectors(document: *const Document) -> *mut c_char {
+  let document = &*document;
+
+  let selectors = document.selectors();
+  let json_string = serde_json::to_string(&selectors).unwrap_or_else(|_| "[]".to_string());
+
+  CString::new(json_string).unwrap_or_default().into_raw()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_resolve_selectors(document: *const Document, path: *const c_char) -> *mut c_char {
   let document = &*document;
   let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
 
-  let values = document.get_values(selector_string);
-  let json_values: Vec<serde_json::Value> = values.iter().map(crate::json::yaml_to_json).collect();
-  let json_string = serde_json::to_string(&json_values).unwrap_or_else(|_| "[]".to_string());
+  let selectors = document.resolve_selectors(selector_string);
+  let json_string = serde_json::to_string(&selectors).unwrap_or_else(|_| "[]".to_string());
 
   CString::new(json_string).unwrap_or_default().into_raw()
 }
@@ -357,6 +366,13 @@ pub unsafe extern "C" fn yerba_document_exists(document: *const Document, path:
   document.exists(selector_string)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_valid_selector(document: *const Document, path: *const c_char) -> bool {
+  let document = &*document;
+  let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
+  document.is_valid_selector(selector_string)
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_find(document: *const Document, path: *const c_char, condition: *const c_char, select: *const c_char) -> *mut c_char {
   let document = &*document;
@@ -404,13 +420,19 @@ pub unsafe extern "C" fn yerba_document_insert(
   document: *mut Document,
   path: *const c_char,
   value: *const c_char,
+  value_type: YerbaValueType,
   before: *const c_char,
   after: *const c_char,
   at: i64,
 ) -> YerbaResult {
   let document = &mut *document;
   let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
-  let value_string = CStr::from_ptr(value).to_str().unwrap_or("");
+  let raw_value = CStr::from_ptr(value).to_str().unwrap_or("");
+
+  let value_string = match value_type {
+    YerbaValueType::String => crate::syntax::quote_if_needed(raw_value),
+    _ => raw_value.to_string(),
+  };
 
   let position = if at >= 0 {
     InsertPosition::At(at as usize)
@@ -424,7 +446,7 @@ pub unsafe extern "C" fn yerba_document_insert(
     InsertPosition::Last
   };
 
-  match document.insert_into(selector_string, value_string, position) {
+  match document.insert_into(selector_string, &value_string, position) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }
@@ -626,6 +648,44 @@ pub unsafe extern "C" fn yerba_document_blank_lines(document: *mut Document, pat
   }
 }
 
+/// Caller must free with yerba_string_free.
+#[no_mangle]
+pub unsafe extern "C" fn yerba_document_validate_schema(document: *const Document, schema_json: *const c_char, selector: *const c_char) -> *mut c_char {
+  let document = &*document;
+  let schema_string = CStr::from_ptr(schema_json).to_str().unwrap_or("");
+  let selector_string = if selector.is_null() { None } else { CStr::from_ptr(selector).to_str().ok() };
+
+  let schema: serde_json::Value = match serde_json::from_str(schema_string) {
+    Ok(schema) => schema,
+    Err(e) => {
+      let error = serde_json::json!([{"message": format!("invalid schema: {}", e), "path": "", "line": null}]);
+      return CString::new(error.to_string()).unwrap_or_default().into_raw();
+    }
+  };
+
+  let errors = document.validate_schema(&schema, false, selector_string);
+
+  if errors.is_empty() {
+    return ptr::null_mut();
+  }
+
+  let json_errors: Vec<serde_json::Value> = errors
+    .iter()
+    .map(|error| {
+      serde_json::json!({
+        "message": error.message,
+        "path": error.path,
+        "line": error.line,
+        "item_label": error.item_label,
+      })
+    })
+    .collect();
+
+  CString::new(serde_json::to_string(&json_errors).unwrap_or_else(|_| "[]".to_string()))
+    .unwrap_or_default()
+    .into_raw()
+}
+
 /// Caller must free with yerba_string_free.
 #[no_mangle]
 pub unsafe extern "C" fn yerba_yerbafile_find(directory: *const c_char) -> *mut c_char {
@@ -716,11 +776,31 @@ pub unsafe extern "C" fn yerba_get_result_free(result: YerbaGetResult) {
 pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *const c_char) -> YerbaTypedList {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
   let selector_string = CStr::from_ptr(path).to_str().unwrap_or("");
-  let scalars = crate::glob_get(pattern, selector_string);
+  let nodes = crate::glob_get(pattern, selector_string);
 
-  let results: Vec<serde_json::Value> = scalars
+  let results: Vec<serde_json::Value> = nodes
     .iter()
-    .map(|scalar| serde_json::json!({"text": scalar.text, "type": detect_yaml_type(scalar) as u8}))
+    .map(|node| {
+      let mut value = serde_json::json!({
+        "node_type": node.node_type,
+        "selector": node.selector,
+        "line": node.line,
+      });
+
+      if let Some(file_path) = &node.file_path {
+        value["file_path"] = serde_json::json!(file_path);
+      }
+
+      if let Some(text) = &node.text {
+        value["text"] = serde_json::json!(text);
+      }
+
+      if let Some(vt) = node.value_type {
+        value["type"] = serde_json::json!(vt as u8);
+      }
+
+      value
+    })
     .collect();
 
   let length = results.len();

data/rust/src/lib.rs

@@ -1,15 +1,16 @@
 pub mod didyoumean;
 mod document;
-mod error;
+pub mod error;
 pub mod ffi;
 pub mod json;
 mod quote_style;
+pub mod schema;
 pub mod selector;
 mod syntax;
 mod yaml_writer;
 pub mod yerbafile;
 
-pub use document::{collect_selectors, Document, InsertPosition, Location, NodeInfo, NodeType, SortField};
+pub use document::{collect_selectors, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType, SortField};
 pub use error::YerbaError;
 pub use quote_style::{KeyStyle, QuoteStyle};
 pub use selector::Selector;
@@ -29,11 +30,9 @@ pub fn parse_file(path: impl AsRef<std::path::Path>) -> Result<Document, YerbaEr
   Document::parse_file(path)
 }
 
-pub fn glob_get(pattern: &str, selector: &str) -> Vec<ScalarValue> {
+pub fn glob_get(pattern: &str, selector: &str) -> Vec<document::LocatedNode> {
   use rayon::prelude::*;
 
-  let parsed_selector = Selector::parse(selector);
-
   let files = match glob::glob(pattern) {
     Ok(paths) => paths.filter_map(|p| p.ok()).collect::<Vec<_>>(),
     Err(_) => return vec![],
@@ -45,11 +44,7 @@ pub fn glob_get(pattern: &str, selector: &str) -> Vec<ScalarValue> {
       let mut results = Vec::new();
 
       if let Ok(document) = Document::parse_file(file) {
-        if parsed_selector.has_wildcard() {
-          results.extend(document.get_all_typed(selector));
-        } else if let Some(scalar) = document.get_typed(selector) {
-          results.push(scalar);
-        }
+        results.extend(document.get_all_located(selector));
       }
 
       results

data/rust/src/main.rs

@@ -48,7 +48,9 @@ static HELP: LazyLock<String> = LazyLock::new(|| {
       yerba sort-keys config.yml "database" "id,host,port,name"
       yerba quote-style "data/**/*.yml" --values double
       yerba sort videos.yml "[]" --by ".id" --order "talk-3,talk-1,talk-2"
+      yerba schema "data/**/*.yml" --schema schema.json
       yerba selectors videos.yml
+      yerba location videos.yml "[0].title"
   "#})
 });
 

data/rust/src/schema.rs

@@ -0,0 +1,93 @@
+use std::fs;
+use std::path::Path;
+
+use crate::error::YerbaError;
+
+#[derive(Debug)]
+pub struct ValidationError {
+  pub path: String,
+  pub message: String,
+  pub item_label: Option<String>,
+  pub line: Option<usize>,
+}
+
+impl std::fmt::Display for ValidationError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    let location = match self.line {
+      Some(line) => format!(" (line {})", line),
+      None => String::new(),
+    };
+
+    match &self.item_label {
+      Some(label) => write!(f, "{} at {} ({}){}", self.message, self.path, label, location),
+      None => write!(f, "{} at {}{}", self.message, self.path, location),
+    }
+  }
+}
+
+pub fn validate_value(value: &serde_json::Value, schema: &serde_json::Value) -> Vec<ValidationError> {
+  let compiled = match jsonschema::draft7::new(schema) {
+    Ok(compiled) => compiled,
+    Err(error) => {
+      return vec![ValidationError {
+        path: String::new(),
+        message: format!("invalid schema: {}", error),
+        item_label: None,
+        line: None,
+      }];
+    }
+  };
+
+  compiled
+    .iter_errors(value)
+    .map(|error| ValidationError {
+      path: error.instance_path.to_string(),
+      message: error.to_string(),
+      item_label: None,
+      line: None,
+    })
+    .collect()
+}
+
+pub fn validate_array(items: &[serde_json::Value], schema: &serde_json::Value) -> Vec<ValidationError> {
+  let compiled = match jsonschema::draft7::new(schema) {
+    Ok(compiled) => compiled,
+    Err(error) => {
+      return vec![ValidationError {
+        path: String::new(),
+        message: format!("invalid schema: {}", error),
+        item_label: None,
+        line: None,
+      }];
+    }
+  };
+
+  let mut errors = Vec::new();
+
+  for (index, item) in items.iter().enumerate() {
+    let item_label = item
+      .get("name")
+      .or_else(|| item.get("title"))
+      .or_else(|| item.get("id"))
+      .and_then(|value| value.as_str())
+      .map(|string| string.to_string())
+      .unwrap_or_else(|| format!("index {}", index));
+
+    for error in compiled.iter_errors(item) {
+      errors.push(ValidationError {
+        path: format!("/{}{}", index, error.instance_path),
+        message: error.to_string(),
+        item_label: Some(item_label.clone()),
+        line: None,
+      });
+    }
+  }
+
+  errors
+}
+
+pub fn load_schema(path: impl AsRef<Path>) -> Result<serde_json::Value, YerbaError> {
+  let content = fs::read_to_string(path.as_ref())?;
+
+  serde_json::from_str(&content).map_err(|error| YerbaError::ParseError(format!("invalid JSON schema: {}", error)))
+}

data/rust/src/syntax.rs

@@ -8,6 +8,9 @@ use yaml_parser::{SyntaxKind, SyntaxNode, SyntaxToken};
 pub struct ScalarValue {
   pub text: String,
   pub kind: SyntaxKind,
+  pub file_path: Option<String>,
+  pub selector: Option<String>,
+  pub line: Option<usize>,
 }
 
 #[repr(C)]
@@ -29,25 +32,44 @@ pub fn detect_yaml_type(scalar: &ScalarValue) -> YerbaValueType {
 }
 
 pub fn extract_scalar(node: &SyntaxNode) -> Option<ScalarValue> {
-  let token = find_scalar_token(node)?;
+  if let Some(token) = find_scalar_token(node) {
+    let text = match token.kind() {
+      SyntaxKind::PLAIN_SCALAR => token.text().to_string(),
 
-  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::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])
+      }
 
-    SyntaxKind::SINGLE_QUOTED_SCALAR => {
-      let raw = token.text();
-      unescape_single_quoted(&raw[1..raw.len() - 1])
-    }
+      _ => return None,
+    };
 
-    _ => return None,
-  };
+    return Some(ScalarValue {
+      text,
+      kind: token.kind(),
+      file_path: None,
+      selector: None,
+      line: None,
+    });
+  }
 
-  Some(ScalarValue { text, kind: token.kind() })
+  let block_token = node
+    .descendants_with_tokens()
+    .filter_map(|element| element.into_token())
+    .find(|token| token.kind() == SyntaxKind::BLOCK_SCALAR_TEXT)?;
+
+  Some(ScalarValue {
+    text: dedent_block_scalar(block_token.text()),
+    kind: SyntaxKind::BLOCK_SCALAR_TEXT,
+    file_path: None,
+    selector: None,
+    line: None,
+  })
 }
 
 pub fn is_map_key(token: &SyntaxToken) -> bool {
@@ -89,28 +111,61 @@ pub fn format_scalar_value(value: &str, kind: SyntaxKind) -> String {
   }
 }
 
-pub fn extract_scalar_text(node: &SyntaxNode) -> Option<String> {
-  let token = find_scalar_token(node)?;
+pub fn quote_if_needed(value: &str) -> String {
+  if is_yaml_non_string(value) {
+    format_scalar_value(value, SyntaxKind::DOUBLE_QUOTED_SCALAR)
+  } else {
+    value.to_string()
+  }
+}
 
-  match token.kind() {
-    SyntaxKind::PLAIN_SCALAR => Some(token.text().to_string()),
+pub fn extract_scalar_text(node: &SyntaxNode) -> Option<String> {
+  if let Some(token) = find_scalar_token(node) {
+    return match token.kind() {
+      SyntaxKind::PLAIN_SCALAR => Some(token.text().to_string()),
 
-    SyntaxKind::DOUBLE_QUOTED_SCALAR => {
-      let text = token.text();
-      let inner = &text[1..text.len() - 1];
+      SyntaxKind::DOUBLE_QUOTED_SCALAR => {
+        let text = token.text();
+        let inner = &text[1..text.len() - 1];
 
-      Some(unescape_double_quoted(inner))
-    }
+        Some(unescape_double_quoted(inner))
+      }
 
-    SyntaxKind::SINGLE_QUOTED_SCALAR => {
-      let text = token.text();
-      let inner = &text[1..text.len() - 1];
+      SyntaxKind::SINGLE_QUOTED_SCALAR => {
+        let text = token.text();
+        let inner = &text[1..text.len() - 1];
 
-      Some(unescape_single_quoted(inner))
-    }
+        Some(unescape_single_quoted(inner))
+      }
 
-    _ => None,
+      _ => None,
+    };
   }
+
+  let block_scalar_text = node
+    .descendants_with_tokens()
+    .filter_map(|element| element.into_token())
+    .find(|token| token.kind() == SyntaxKind::BLOCK_SCALAR_TEXT)?;
+
+  Some(dedent_block_scalar(block_scalar_text.text()))
+}
+
+pub fn dedent_block_scalar(text: &str) -> String {
+  let lines: Vec<&str> = text.lines().collect();
+  let min_indent = lines
+    .iter()
+    .filter(|line| !line.trim().is_empty())
+    .map(|line| line.len() - line.trim_start().len())
+    .min()
+    .unwrap_or(0);
+
+  let dedented: String = lines
+    .iter()
+    .map(|line| if line.len() >= min_indent { &line[min_indent..] } else { line.trim() })
+    .collect::<Vec<_>>()
+    .join("\n");
+
+  dedented.trim().to_string()
 }
 
 pub fn unescape_double_quoted(text: &str) -> String {
@@ -260,8 +315,13 @@ pub fn detect_yaml_type_from_plain(value: &str) -> YerbaValueType {
     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") {
+  // Hex (0x...) — only valid hex digits after prefix
+  if (value.starts_with("0x") || value.starts_with("0X")) && value.len() > 2 && value[2..].chars().all(|c| c.is_ascii_hexdigit()) {
+    return YerbaValueType::Integer;
+  }
+
+  // Octal (0o...) — only valid octal digits after prefix
+  if (value.starts_with("0o") || value.starts_with("0O")) && value.len() > 2 && value[2..].chars().all(|c| matches!(c, '0'..='7')) {
     return YerbaValueType::Integer;
   }