Struct Ruleset

pub struct Ruleset { /* private fields */ }

An ordered set of Rules sorted by priority.

Examples

use csv_sanity::{
    Ruleset,
    Rule,
    TransformedRecord,
};
use csv_sanity::transformers::*;
let ruleset = {
    let mut r = Ruleset::new();
    r.add_rule(Rule::for_fields(&["First Name", "Last Name"], Transformers::Capitalize(
        CapitalizeTransformer::new()
    )));
    r.add_rule(Rule::for_fields(&["Email"], Transformers::Email(
        EmailTransformer::new()
    )));
    r
};
let headers = vec!["Id", "First Name", "Last Name", "Email"].iter().map(|s| s.to_string()).collect();
let record = vec!["1", " JOHN", "SNOW  ", "\t   JSNOW@EXAMPLE.COM "].iter().map(|s| s.to_string()).collect();
let transformed_record = ruleset.apply_rules(&headers, &record, 1);
assert_eq!(TransformedRecord {
    field_values: vec!["1", "John", "Snow", "jsnow@example.com"].iter().map(|s| Some(s.to_string())).collect(),
    errors: Vec::new(),
}, transformed_record);

Implementations

impl Ruleset

pub fn new() -> Ruleset

Construct a new Ruleset with a default NoneTransformer and TrimTransformer global rules.

The default trim and none rules should be appropriate for most CSV files. For CSV files where these default rules are not desired use the Ruleset::without_default_rules method.

pub fn without_default_rules() -> Ruleset

Construct a new Ruleset without any of the default rules.

pub fn add_rule(&mut self, rule: Rule)

Add a Rule to the this ruleset.

pub fn validate_rules( &self, headers: &Vec<String>, ) -> Result<(), Vec<ValidationError>>

Validate this ruleset against a CSV file by comparing it’s Rules against the headers.

pub fn apply_rules( &self, headers: &Vec<String>, fields: &Vec<String>, record_n: usize, ) -> TransformedRecord

Apply this Ruleset to a record from a CSV file.

Trait Implementations

impl Clone for Ruleset

fn clone(&self) -> Ruleset

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ruleset

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ruleset

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Ruleset

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

where __S: Serializer,

Serialize this value into the given Serde serializer.