Struct Hook 

pub struct Hook {

    pub id: String,
    pub name: Option<String>,
    pub entry: String,
    pub language: String,
    pub files: Option<String>,
    pub exclude: Option<String>,
    pub types: Vec<String>,
    pub exclude_types: Vec<String>,
    pub additional_dependencies: Vec<String>,
    pub args: Vec<String>,
    pub always_run: bool,
    pub fail_fast: bool,
    pub pass_filenames: bool,
    pub stages: Vec<Stage>,
    pub verbose: bool,
    pub minimum_pre_commit_version: Option<String>,
    pub depends_on: Vec<String>,
    pub concurrent: bool,
}

Enhanced Hook structure with runtime capabilities

Fields

id: String

Unique identifier for the hook

name: Option<String>

Human-readable name (optional)

entry: String

Command to execute

language: String

Programming language environment

files: Option<String>

File patterns to include (raw string for serialization)

exclude: Option<String>

File patterns to exclude (raw string for serialization)

types: Vec<String>

File types to include

exclude_types: Vec<String>

File types to exclude

additional_dependencies: Vec<String>

Additional dependencies to install

args: Vec<String>

Additional arguments to pass to the hook

always_run: bool

Whether to always run this hook, even if no files match

fail_fast: bool

Whether to fail fast on first error

pass_filenames: bool

Whether to pass filenames to the hook

stages: Vec<Stage>

Stages where this hook should run

verbose: bool

Whether to show verbose output

minimum_pre_commit_version: Option<String>

Minimum version required

depends_on: Vec<String>

Hook IDs that this hook depends on (must run before this hook)

concurrent: bool

Whether this hook can run concurrently with others (default: true)

Implementations

impl Hook

pub fn new( id: impl Into<String>, entry: impl Into<String>, language: impl Into<String>, ) -> Self

Create a new hook with required fields

pub fn with_name(self, name: impl Into<String>) -> Self

Builder pattern methods

pub fn with_files(self, files: impl Into<String>) -> Self

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

pub fn with_types(self, types: Vec<String>) -> Self

pub fn with_args(self, args: Vec<String>) -> Self

pub fn with_stages(self, stages: Vec<Stage>) -> Self

pub fn always_run(self, always_run: bool) -> Self

pub fn fail_fast(self, fail_fast: bool) -> Self

pub fn pass_filenames(self, pass_filenames: bool) -> Self

pub fn with_verbose(self, verbose: bool) -> Self

pub fn with_exclude_types(self, exclude_types: Vec<String>) -> Self

pub fn with_additional_dependencies( self, additional_dependencies: Vec<String>, ) -> Self

pub fn with_depends_on(self, depends_on: Vec<String>) -> Self

pub fn with_concurrent(self, concurrent: bool) -> Self

pub fn validate(&self) -> Result<()>

Validate the hook configuration

pub fn file_filter(&self) -> Result<FileFilter>

Get a file filter for this hook

pub fn runs_for_stage(&self, stage: &Stage) -> bool

Check if this hook should run for the given stage

pub fn command(&self) -> Vec<String>

Get the full command to execute For optimal performance, consider using command_cow() for zero-copy operations

pub fn command_cow(&self) -> Vec<Cow<'_, str>>

Get the full command to execute using zero-copy operations with Cow This method eliminates unnecessary string clones by borrowing string slices when possible

pub fn command_arena<'arena>( &self, arena: &'arena Bump, ) -> &'arena [&'arena str]

Get the full command to execute using arena allocation for better performance This method avoids string clones by allocating command strings in the provided arena

pub fn from_config(config_hook: &Hook, _repo_url: &str) -> Result<Self>

Create a Hook from configuration

Trait Implementations

impl Clone for Hook

fn clone(&self) -> Hook

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hook

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hook

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Hook

fn eq(&self, other: &Hook) -> 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 Serialize for Hook

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Hook