redirectionio 3.1.0

Redirection IO Library to handle matching rule, redirect and filtering headers and body.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use std::{collections::HashMap, str::FromStr};

use serde::{Deserialize, Serialize};

use crate::marker::{Camelize, Dasherize, Lowercase, Replace, Slice, Transform, Underscorize, Uppercase};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Transformer {
    #[serde(rename = "type")]
    pub kind: Option<String>,
    pub options: Option<HashMap<String, String>>,
}

impl Transformer {
    pub fn to_transform(&self) -> Option<Box<dyn Transform>> {
        match self.kind.as_ref() {
            None => None,
            Some(kind) => match kind.as_str() {
                "camelize" => Some(Box::<Camelize>::default()),
                "dasherize" => Some(Box::<Dasherize>::default()),
                "lowercase" => Some(Box::<Lowercase>::default()),
                "replace" => match self.options.as_ref() {
                    None => None,
                    Some(options) => {
                        if !options.contains_key("something") || !options.contains_key("with") {
                            return None;
                        }

                        Some(Box::new(Replace::new(
                            options.get("something").unwrap().clone(),
                            options.get("with").unwrap().clone(),
                        )))
                    }
                },
                "slice" => match self.options.as_ref() {
                    None => None,
                    Some(options) => {
                        let from = options.get("from").map(|f| usize::from_str(f)).and_then(|r| r.ok()).unwrap_or(0);
                        let to = options.get("to").map(|f| usize::from_str(f)).and_then(|r| r.ok());

                        Some(Box::new(Slice::new(from, to)))
                    }
                },
                "underscorize" => Some(Box::<Underscorize>::default()),
                "uppercase" => Some(Box::<Uppercase>::default()),
                _ => None,
            },
        }
    }
}