Struct Registry 

pub struct Registry { /* private fields */ }

A loaded, validated collection of site definitions.

Engines (shared signature templates referenced by Site::engine) are resolved into sites at load time — by the time you call Registry::sites every entry already has its inherited signals / request_headers / regex_check materialised. The original Engine objects are kept on the registry for re-export and inspection via Registry::engines.

Implementations

impl Registry

pub fn default_embedded() -> Result<Self>

Load the default site list embedded into the crate at build time.

pub fn default_embedded_with_wmn() -> Result<Self>

Load the default site list plus the WhatsMyName-derived supplementary set. WhatsMyName data is licensed CC BY-SA 4.0 (see LICENSE-CC-BY-SA-4.0 at the repo root); enabling this path means downstream redistribution of the merged scan data must respect the ShareAlike obligation. Sites contributed by the WhatsMyName tranche carry the source:wmn tag for provenance.

Engines from the WMN tranche merge with the MIT tranche; case-insensitive site-name collisions resolve in favour of the MIT-tranche entry (the hand-curated Sherlock/Maigret-derived signature wins; the WMN duplicate is dropped). Returns an error only if either tranche fails its own validation — engine references are checked across the merged set.

pub fn from_json_str(json: &str) -> Result<Self>

Parse and validate a registry from a JSON string. Engine references on each site are resolved before validation; a site that names an engine which doesn’t exist in the engines block fails loading with Error::InvalidSite.

pub fn engines(&self) -> &BTreeMap<String, Engine>

Inheritable engine templates, keyed by name. Useful for introspection and for serialising the registry back out; detection paths read the resolved fields off the sites directly and don’t need to consult this map.

pub fn load_from_path(path: impl AsRef<Path>) -> Result<Self>

Read a registry from a JSON file.

pub fn sites(&self) -> &[Site]

Borrow all sites in load order.

pub fn len(&self) -> usize

Number of sites.

pub fn is_empty(&self) -> bool

True if the registry has no sites (always false for a valid load, since we’d already have rejected it).

pub fn filter( &self, include: &[String], exclude: &[String], tags: &[String], exclude_tags: &[String], include_nsfw: bool, ) -> Vec<Site>

Apply include/exclude name filters and a tag filter.

• If include is non-empty, only sites whose name contains at least one include term (case-insensitive substring) are kept.
• Sites whose name contains any exclude term are dropped.
• If tags is non-empty, only sites carrying at least one of the requested tags are kept (case-insensitive). A site with no tags is therefore dropped by a tag filter — asking for --tag social means “only social-tagged sites”.
• Sites carrying any tag in exclude_tags are dropped (e.g. --exclude-tag bot-protected for a fast clean run).
• NSFW sites are auto-excluded (the nsfw tag) unless include_nsfw is true or tags explicitly asks for nsfw. This matches Sherlock’s --nsfw opt-in pattern and prevents the default adler <username> from surfacing adult-site URLs the user didn’t ask for.
• Sites are returned by value (cloned) so the result is independent of the registry’s lifetime — convenient for handing to the executor.

pub fn tag_counts(&self) -> Vec<(String, usize)>

Distinct tags across all sites, sorted, with the count of sites carrying each. Powers --list-tags.

Trait Implementations

impl Clone for Registry

fn clone(&self) -> Registry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Registry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Registry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.