Struct FileTypeProfile 

pub struct FileTypeProfile {
    pub processor: String,
    pub extensions: Vec<String>,
    pub include: Vec<String>,
    pub exclude: Vec<String>,
    pub fields: Vec<FieldRule>,
    pub options: HashMap<String, String>,
}

Specifies which processor to use and what fields to sanitize.

File matching

A file is processed by this profile when all of the following hold:

1. Its name ends with one of the extensions (required — an empty list matches nothing).
2. If include is non-empty, the filename matches at least one of those glob patterns.
3. The filename does not match any exclude glob pattern.

Glob patterns use * (any chars within a path component) and ** (any chars including path separators).

Example (YAML)

- processor: json
  extensions: [".json"]
  # Only apply to files whose names start with "config"
  include: ["config*.json"]
  # Never apply to log files
  exclude: ["*.log.json", "logs/**"]
  fields:
    - pattern: "*.password"
      category: "custom:password"

Fields

processor: String

Name of the processor to use (e.g. "key_value", "json").

extensions: Vec<String>

File extensions this profile applies to (e.g. [".rb", ".conf"]).

include: Vec<String>

If non-empty, the filename must match at least one of these glob patterns in addition to the extension check.

exclude: Vec<String>

Filenames matching any of these glob patterns are excluded from structured processing even if they match the extension (and include).

fields: Vec<FieldRule>

Field rules: which keys/paths to sanitize.

options: HashMap<String, String>

Free-form options passed to the processor (e.g. delimiter, comment chars).

Implementations

impl FileTypeProfile

pub fn new(processor: impl Into<String>, fields: Vec<FieldRule>) -> Self

Create a minimal profile for a given processor.

pub fn with_extension(self, ext: impl Into<String>) -> Self

Add an extension to this profile.

pub fn with_option( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add a free-form option.

pub fn matches_filename(&self, filename: &str) -> bool

Check whether a filename should be processed by this profile.

Returns true when all three conditions hold:

1. The filename ends with one of extensions (an empty list → false).
2. If include is non-empty, the filename matches at least one glob.
3. The filename does not match any exclude glob.

Invalid glob patterns in include/exclude are silently skipped.

Examples

use sanitize_engine::processor::profile::FieldRule;
use sanitize_engine::processor::profile::FileTypeProfile;

let profile = FileTypeProfile::new("json", vec![])
    .with_extension(".json");

assert!(profile.matches_filename("config.json"));
assert!(profile.matches_filename("logs/app.json"));
assert!(!profile.matches_filename("config.yml"));

// Exclude log-formatted JSON files.
let profile = FileTypeProfile::new("json", vec![])
    .with_extension(".json")
    .with_exclude("*.log.json")
    .with_exclude("logs/**");

assert!(profile.matches_filename("config.json"));
assert!(!profile.matches_filename("app.log.json"));
assert!(!profile.matches_filename("logs/events.json"));

// Include only config files.
let profile = FileTypeProfile::new("json", vec![])
    .with_extension(".json")
    .with_include("config*.json");

assert!(profile.matches_filename("config.json"));
assert!(profile.matches_filename("config-prod.json"));
assert!(!profile.matches_filename("events.json"));

pub fn with_include(self, pat: impl Into<String>) -> Self

Add a glob pattern to the include list.

pub fn with_exclude(self, pat: impl Into<String>) -> Self

Add a glob pattern to the exclude list.

Trait Implementations

impl Clone for FileTypeProfile

fn clone(&self) -> FileTypeProfile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FileTypeProfile

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FileTypeProfile

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FileTypeProfile

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.