Struct ApplyOptions 

pub struct ApplyOptions {
    pub dry_run: bool,
    pub fuzz_factor: f32,
}

Options for configuring how a patch is applied.

This struct controls the behavior of patch application functions like apply_patch_to_file() and apply_patch_to_content(). It allows you to enable dry-run mode, configure the fuzzy matching threshold, and more.

While you can construct it directly, it’s often more convenient to use one of the associated functions like ApplyOptions::new(), ApplyOptions::dry_run(), or the fluent with_dry_run() and with_fuzz_factor() methods.

Example

use mpatch::ApplyOptions;

// Direct construction for full control.
let custom_options = ApplyOptions {
    dry_run: true,
    fuzz_factor: 0.9,
};

// Using a convenience constructor for common cases.
let dry_run_options = ApplyOptions::dry_run();
assert_eq!(dry_run_options.dry_run, true);

// Using fluent methods for a chainable style.
let fluent_options = ApplyOptions::new()
    .with_dry_run(true)
    .with_fuzz_factor(0.5);
assert_eq!(fluent_options.fuzz_factor, 0.5);

Fields

dry_run: bool

If true, no files will be modified. Instead, a diff of the proposed changes will be generated and returned in PatchResult.

This is the primary way to preview the outcome of a patch operation without making any changes to the filesystem. When dry_run is enabled, functions like apply_patch_to_file() will populate the diff field of the returned PatchResult.

Example

// Create options for a dry run.
let options = ApplyOptions {
    dry_run: true,
    fuzz_factor: 0.7,
};

assert!(options.dry_run);

fuzz_factor: f32

The similarity threshold for fuzzy matching (0.0 to 1.0). Higher is stricter. 0.0 disables fuzzy matching.

Implementations

impl ApplyOptions

pub fn new() -> Self

Creates a new ApplyOptions instance with default values.

This is an alias for ApplyOptions::default().

Example

let options = ApplyOptions::new();
assert_eq!(options.dry_run, false);
assert_eq!(options.fuzz_factor, 0.7);

pub fn dry_run() -> Self

Creates a new ApplyOptions instance configured for a dry run.

All other options are set to their default values.

Example

let options = ApplyOptions::dry_run();
assert_eq!(options.dry_run, true);
assert_eq!(options.fuzz_factor, 0.7);

pub fn exact() -> Self

Creates a new ApplyOptions instance configured for an exact match (fuzz factor 0.0).

All other options are set to their default values.

Example

let options = ApplyOptions::exact();

assert_eq!(options.dry_run, false);
assert_eq!(options.fuzz_factor, 0.0);

pub fn with_dry_run(self, dry_run: bool) -> Self

Returns a new ApplyOptions instance with the dry_run flag set.

This is a fluent method that allows for chaining.

Example

let options = ApplyOptions::new().with_dry_run(true);
assert_eq!(options.dry_run, true);

let options2 = options.with_dry_run(false);
assert_eq!(options2.dry_run, false);

pub fn with_fuzz_factor(self, fuzz_factor: f32) -> Self

Returns a new ApplyOptions instance with the fuzz_factor set.

This is a fluent method that allows for chaining.

Example

let options = ApplyOptions::new().with_fuzz_factor(0.9);
assert_eq!(options.fuzz_factor, 0.9);

let options2 = options.with_fuzz_factor(0.5);
assert_eq!(options2.fuzz_factor, 0.5);

pub fn builder() -> ApplyOptionsBuilder

Creates a new builder for ApplyOptions.

This provides a classic builder pattern for constructing an ApplyOptions struct, which can be useful when the configuration is built conditionally or comes from multiple sources.

Example

let options = ApplyOptions::builder()
    .dry_run(true)
    .fuzz_factor(0.8)
    .build();

assert_eq!(options.dry_run, true);
assert_eq!(options.fuzz_factor, 0.8);

Trait Implementations

impl Clone for ApplyOptions

fn clone(&self) -> ApplyOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ApplyOptions

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

Formats the value using the given formatter.

impl Default for ApplyOptions

fn default() -> Self

Creates a new ApplyOptions instance with default values.

This is the standard way to get a default configuration, which has dry_run set to false and fuzz_factor set to 0.7.

Example

let options: ApplyOptions = Default::default();

assert_eq!(options.dry_run, false);
assert_eq!(options.fuzz_factor, 0.7);

impl PartialEq for ApplyOptions

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

impl StructuralPartialEq for ApplyOptions