Struct MetadataNormalizer 

pub struct MetadataNormalizer { /* private fields */ }

Metadata normalizer for query convenience

Converts user-friendly short forms (e.g., async) to canonical keys (e.g., is_async) used by plugins. Enables easier queries while maintaining consistency with metadata::keys.

Implementations

impl MetadataNormalizer

pub fn new() -> Self

Create a new metadata normalizer with default mappings

Examples

use sqry_core::normalizer::MetadataNormalizer;

let normalizer = MetadataNormalizer::new();

pub fn normalize(&self, raw: HashMap<String, String>) -> HashMap<String, String>

Normalize metadata by mapping legacy keys to canonical forms

Behavior

• Legacy keys are converted to canonical keys
• Unknown keys are preserved as-is (no data loss)
• If both legacy and canonical keys exist, canonical wins
• Empty metadata returns empty hashmap

Examples

use sqry_core::normalizer::MetadataNormalizer;
use std::collections::HashMap;

let mut raw = HashMap::new();
raw.insert("async".to_string(), "true".to_string());       // Short form
raw.insert("custom".to_string(), "value".to_string());     // Unknown

let normalizer = MetadataNormalizer::new();
let normalized = normalizer.normalize(raw);

assert_eq!(normalized.get("is_async"), Some(&"true".to_string())); // Canonical
assert_eq!(normalized.get("custom"), Some(&"value".to_string()));   // Preserved
assert_eq!(normalized.get("async"), None); // Short form removed

pub fn is_legacy_key(&self, key: &str) -> bool

Check if a key is a legacy key that will be normalized

Examples

use sqry_core::normalizer::MetadataNormalizer;

let normalizer = MetadataNormalizer::new();
assert!(normalizer.is_legacy_key("async"));           // Short form
assert!(!normalizer.is_legacy_key("is_async"));       // Canonical
assert!(!normalizer.is_legacy_key("custom_key"));     // Unknown

pub fn get_canonical(&self, key: &str) -> Option<&'static str>

Get the canonical form of a key (if it’s a legacy key)

Returns None if the key is not a legacy key.

Examples

use sqry_core::normalizer::MetadataNormalizer;

let normalizer = MetadataNormalizer::new();
assert_eq!(normalizer.get_canonical("async"), Some("is_async"));    // Short → canonical
assert_eq!(normalizer.get_canonical("is_async"), None);            // Already canonical
assert_eq!(normalizer.get_canonical("custom"), None);              // Unknown

pub fn legacy_keys(&self) -> impl Iterator<Item = &&'static str>

Get all legacy keys supported by this normalizer

Useful for documentation and validation.

Examples

use sqry_core::normalizer::MetadataNormalizer;

let normalizer = MetadataNormalizer::new();
let legacy_keys: Vec<&&str> = normalizer.legacy_keys().collect();
assert!(legacy_keys.contains(&&"async"));       // Short forms
assert!(legacy_keys.contains(&&"static"));

pub fn canonical_keys(&self) -> impl Iterator<Item = &&'static str>

Get all canonical keys (targets of normalization)

Examples

use sqry_core::normalizer::MetadataNormalizer;

let normalizer = MetadataNormalizer::new();
let canonical_keys: Vec<&&str> = normalizer.canonical_keys().collect();
assert!(canonical_keys.contains(&&"is_async"));    // Canonical forms
assert!(canonical_keys.contains(&&"is_static"));

pub fn mappings( &self, ) -> impl Iterator<Item = (&'static str, &'static str)> + '_

Get all short form → canonical mappings

Returns an iterator over (short_form, canonical) pairs.

Examples

use sqry_core::normalizer::MetadataNormalizer;

let normalizer = MetadataNormalizer::new();
for (short_form, canonical) in normalizer.mappings() {
    println!("{} → {}", short_form, canonical);
}

Trait Implementations

impl Clone for MetadataNormalizer

fn clone(&self) -> MetadataNormalizer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MetadataNormalizer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MetadataNormalizer

fn default() -> Self

Returns the “default value” for a type.