Struct CacheKey 

pub struct CacheKey { /* private fields */ }

Unique identifier for cached AST summaries.

A cache key combines:

• Canonical path: Normalized file path with symlinks resolved
• Language ID: Plugin identifier (e.g., “rust”, “python”)
• Content hash: BLAKE3 digest of file contents

Equality and Hashing

Two cache keys are equal if all three components match. This ensures cache misses when:

• File content changes (different hash)
• File is moved (different canonical path)
• Language plugin changes (different language ID)

Canonicalization Fallback

If path canonicalization fails, the original path is used. This handles:

• Deleted files during cache cleanup
• Permission-denied scenarios
• Filesystems without canonicalization support

Fallback events are logged at DEBUG level via the log crate.

Implementations

impl CacheKey

pub fn new<P: AsRef<Path>>( path: P, language: impl Into<String>, content_hash: Blake3Hash, ) -> Self

Create a new cache key with path canonicalization.

Attempts to canonicalize the path. If canonicalization fails, falls back to the original path and logs a DEBUG message.

Arguments

• path: File path (can be relative or contain symlinks)
• language: Language identifier from the plugin
• content_hash: BLAKE3 hash of file contents

Examples

use sqry_core::cache::CacheKey;
use sqry_core::hash::Blake3Hash;
use std::path::PathBuf;

let hash_hex = "a".repeat(64);
let hash = Blake3Hash::from_hex(&hash_hex).unwrap();
let key = CacheKey::new(
    PathBuf::from("./src/main.rs"),
    "rust",
    hash,
);

pub fn from_raw_path<P: Into<PathBuf>>( path: P, language: impl Into<String>, content_hash: Blake3Hash, ) -> Self

Create a cache key without path canonicalization.

Uses the provided path as-is, skipping canonicalization. Useful for testing or when paths are already canonical.

Examples

use sqry_core::cache::CacheKey;
use sqry_core::hash::Blake3Hash;
use std::path::PathBuf;

let hash_hex = "a".repeat(64);
let hash = Blake3Hash::from_hex(&hash_hex).unwrap();
let key = CacheKey::from_raw_path(
    PathBuf::from("/absolute/path/file.rs"),
    "rust",
    hash,
);

pub fn path(&self) -> &Path

Get the canonical file path (or original if canonicalization failed).

pub fn language(&self) -> &str

Get the language identifier.

pub fn content_hash(&self) -> &Blake3Hash

Get the content hash.

pub fn is_canonical(&self) -> bool

Check if path canonicalization succeeded.

Returns false if the key is using the original path as a fallback.

pub fn storage_key(&self) -> String

Compute a storage key for file persistence.

Returns a string combining language, content hash, path hash, and filename, suitable for use as a directory/file path in the persistent cache.

Format: {language}/{content_hash}/{path_hash}/{filename}

The path hash prevents collisions when different files have identical content and filename (e.g., /proj1/main.rs and /proj2/main.rs).

Examples

use sqry_core::cache::CacheKey;
use sqry_core::hash::Blake3Hash;
use std::path::PathBuf;

let hash_hex = "a".repeat(64);
let hash = Blake3Hash::from_hex(&hash_hex).unwrap();
let key = CacheKey::from_raw_path(
    PathBuf::from("/path/to/file.rs"),
    "rust",
    hash,
);

let storage_key = key.storage_key();
assert!(storage_key.starts_with("rust/"));
assert!(storage_key.ends_with("file.rs"));

Trait Implementations

impl Clone for CacheKey

fn clone(&self) -> CacheKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheKey

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

Formats the value using the given formatter.

impl Display for CacheKey

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

Formats the value using the given formatter.

impl Hash for CacheKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CacheKey

fn eq(&self, other: &CacheKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CacheKey

impl StructuralPartialEq for CacheKey