yerba 0.4.2 → 0.5.1

data/rust/src/document/schema.rs

@@ -0,0 +1,73 @@
+use super::*;
+
+impl Document {
+  pub fn validate_schema(&self, schema: &serde_json::Value, items: bool, selector: Option<&str>) -> Vec<crate::schema::ValidationError> {
+    let path = selector.unwrap_or("");
+    let has_wildcard = crate::selector::Selector::parse(path).has_wildcard();
+
+    let value = match self.get_value(path) {
+      Some(value) => crate::json::yaml_to_json(&value),
+      None => return vec![],
+    };
+
+    let validate_items = items || has_wildcard;
+
+    let mut errors = if validate_items {
+      match value.as_array() {
+        Some(array) => crate::schema::validate_array(array, schema),
+        None if value.is_null() => vec![crate::schema::ValidationError {
+          path: String::new(),
+          message: "expected an array but document is empty or not a sequence".to_string(),
+          item_label: None,
+          line: None,
+        }],
+        None => crate::schema::validate_array(std::slice::from_ref(&value), schema),
+      }
+    } else {
+      if value.is_null() {
+        return vec![];
+      }
+
+      crate::schema::validate_value(&value, schema)
+    };
+
+    let source = self.to_string();
+
+    for error in &mut errors {
+      if !error.path.is_empty() {
+        let selector = json_pointer_to_selector(&error.path);
+
+        if let Ok(node) = self.navigate(&selector) {
+          let offset: usize = node.text_range().start().into();
+          let line = source[..offset].chars().filter(|c| *c == '\n').count() + 1;
+
+          error.line = Some(line);
+        }
+      }
+    }
+
+    errors
+  }
+}
+
+fn json_pointer_to_selector(pointer: &str) -> String {
+  pointer
+    .strip_prefix('/')
+    .unwrap_or(pointer)
+    .split('/')
+    .map(|segment| {
+      if let Ok(index) = segment.parse::<usize>() {
+        format!("[{}]", index)
+      } else {
+        segment.to_string()
+      }
+    })
+    .fold(String::new(), |mut path, segment| {
+      if !path.is_empty() && !segment.starts_with('[') {
+        path.push('.');
+      }
+
+      path.push_str(&segment);
+      path
+    })
+}

data/rust/src/document/set.rs

@@ -26,7 +26,7 @@ impl Document {
   }
 
   pub fn set_all(&mut self, dot_path: &str, value: &str) -> Result<(), YerbaError> {
-    let nodes = self.navigate_all(dot_path);
+    let nodes = self.navigate_all_compact(dot_path);
 
     if nodes.is_empty() {
       return Err(YerbaError::SelectorNotFound(dot_path.to_string()));

data/rust/src/document/sort.rs

@@ -113,12 +113,15 @@ impl Document {
       return self.validate_each_sort_keys(sequence_path, key_order);
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = match self.navigate(dot_path) {
+      Ok(node) => node,
+      Err(_) => return Ok(()),
+    };
 
-    let map = current_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = match current_node.descendants().find_map(BlockMap::cast) {
+      Some(map) => map,
+      None => return Ok(()),
+    };
 
     let unknown_keys: Vec<String> = map
       .entries()
@@ -138,12 +141,15 @@ impl Document {
       return self.sort_each_keys(sequence_path, key_order);
     }
 
-    let current_node = self.navigate(dot_path)?;
+    let current_node = match self.navigate(dot_path) {
+      Ok(node) => node,
+      Err(_) => return Ok(()),
+    };
 
-    let map = current_node
-      .descendants()
-      .find_map(BlockMap::cast)
-      .ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
+    let map = match current_node.descendants().find_map(BlockMap::cast) {
+      Some(map) => map,
+      None => return Ok(()),
+    };
 
     let entries: Vec<_> = map.entries().collect();
 
@@ -202,7 +208,7 @@ impl Document {
         Err(_) => return Ok(()),
       }
     } else {
-      let found = self.navigate_all(dot_path);
+      let found = self.navigate_all_compact(dot_path);
       if found.is_empty() {
         return Ok(());
       }
@@ -307,7 +313,7 @@ impl Document {
         Err(_) => return Ok(()),
       }
     } else {
-      let found = self.navigate_all(dot_path);
+      let found = self.navigate_all_compact(dot_path);
       if found.is_empty() {
         return Ok(());
       }
@@ -438,7 +444,7 @@ impl Document {
       (dot_path, "")
     };
 
-    let parent_nodes = self.navigate_all(parent_path);
+    let parent_nodes = self.navigate_all_compact(parent_path);
     let source = self.root.text().to_string();
     let mut edits: Vec<(TextRange, String)> = Vec::new();
 
@@ -571,10 +577,10 @@ impl Document {
     };
 
     let labels: Vec<String> = match self.get_value(&items_selector) {
-      Some(serde_yaml::Value::Sequence(sequence)) => sequence
+      Some(yaml_serde::Value::Sequence(sequence)) => sequence
         .iter()
         .map(|value| match value {
-          serde_yaml::Value::String(string) => string.clone(),
+          yaml_serde::Value::String(string) => string.clone(),
           _ => String::new(),
         })
         .collect(),

data/rust/src/document/style.rs

@@ -3,7 +3,7 @@ use super::*;
 impl Document {
   pub fn enforce_blank_lines(&mut self, dot_path: &str, blank_lines: usize) -> Result<(), YerbaError> {
     let nodes = if dot_path.contains('[') {
-      self.navigate_all(dot_path)
+      self.navigate_all_compact(dot_path)
     } else {
       vec![self.navigate(dot_path)?]
     };
@@ -105,7 +105,7 @@ impl Document {
     let source = self.root.text().to_string();
 
     let scope_ranges: Vec<TextRange> = match dot_path {
-      Some(path) if !path.is_empty() => self.navigate_all(path).iter().map(|node| node.text_range()).collect(),
+      Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
     };
 
@@ -219,7 +219,7 @@ impl Document {
     let source = self.root.text().to_string();
 
     let scope_ranges: Vec<TextRange> = match dot_path {
-      Some(path) if !path.is_empty() => self.navigate_all(path).iter().map(|node| node.text_range()).collect(),
+      Some(path) if !path.is_empty() => self.navigate_all_compact(path).iter().map(|node| node.text_range()).collect(),
       _ => vec![self.root.text_range()],
     };
 

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/json.rs

@@ -1,11 +1,11 @@
 use crate::selector::{Selector, SelectorSegment};
 
-pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
+pub fn yaml_to_json(value: &yaml_serde::Value) -> serde_json::Value {
   match value {
-    serde_yaml::Value::Null => serde_json::Value::Null,
-    serde_yaml::Value::Bool(boolean) => serde_json::Value::Bool(*boolean),
+    yaml_serde::Value::Null => serde_json::Value::Null,
+    yaml_serde::Value::Bool(boolean) => serde_json::Value::Bool(*boolean),
 
-    serde_yaml::Value::Number(number) => {
+    yaml_serde::Value::Number(number) => {
       if let Some(integer) = number.as_i64() {
         serde_json::Value::Number(integer.into())
       } else if let Some(float) = number.as_f64() {
@@ -15,16 +15,16 @@ pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
       }
     }
 
-    serde_yaml::Value::String(string) => serde_json::Value::String(string.clone()),
+    yaml_serde::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()),
+    yaml_serde::Value::Sequence(sequence) => serde_json::Value::Array(sequence.iter().map(yaml_to_json).collect()),
 
-    serde_yaml::Value::Mapping(mapping) => {
+    yaml_serde::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(),
+          yaml_serde::Value::String(string) => string.clone(),
           _ => format!("{:?}", key),
         };
 
@@ -34,19 +34,19 @@ pub fn yaml_to_json(value: &serde_yaml::Value) -> serde_json::Value {
       serde_json::Value::Object(map)
     }
 
-    serde_yaml::Value::Tagged(tagged) => yaml_to_json(&tagged.value),
+    yaml_serde::Value::Tagged(tagged) => yaml_to_json(&tagged.value),
   }
 }
 
-pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_json::Value {
+pub fn resolve_select_field(value: &yaml_serde::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 {
+      if let yaml_serde::Value::Mapping(map) = value {
         for (map_key, yaml_value) in map {
-          if let serde_yaml::Value::String(key_string) = map_key {
+          if let yaml_serde::Value::String(key_string) = map_key {
             if key_string == key {
               return yaml_to_json(yaml_value);
             }
@@ -66,13 +66,13 @@ pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_jso
     for current in &current_values {
       match segment {
         SelectorSegment::AllItems => {
-          if let serde_yaml::Value::Sequence(sequence) = current {
+          if let yaml_serde::Value::Sequence(sequence) = current {
             next_values.extend(sequence.iter().cloned());
           }
         }
 
         SelectorSegment::Index(index) => {
-          if let serde_yaml::Value::Sequence(sequence) = current {
+          if let yaml_serde::Value::Sequence(sequence) = current {
             if let Some(item) = sequence.get(*index) {
               next_values.push(item.clone());
             }
@@ -80,9 +80,9 @@ pub fn resolve_select_field(value: &serde_yaml::Value, field: &str) -> serde_jso
         }
 
         SelectorSegment::Key(key) => {
-          if let serde_yaml::Value::Mapping(map) = current {
+          if let yaml_serde::Value::Mapping(map) = current {
             for (map_key, yaml_value) in map {
-              if let serde_yaml::Value::String(key_string) = map_key {
+              if let yaml_serde::Value::String(key_string) = map_key {
                 if key_string == key {
                   next_values.push(yaml_value.clone());
                 }

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
@@ -93,10 +88,10 @@ pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select:
               }
             }
             None => {
-              if let serde_yaml::Value::Mapping(map) = value {
+              if let yaml_serde::Value::Mapping(map) = value {
                 for (key, yaml_value) in map {
                   let json_key = match key {
-                    serde_yaml::Value::String(string) => string.clone(),
+                    yaml_serde::Value::String(string) => string.clone(),
                     _ => format!("{:?}", key),
                   };
 

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"
   "#})
 });