redirectionio 2.5.2

Redirection IO Library to handle matching rule, redirect and filtering headers and body.
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
51
52
53
54
55
56

use crate::router::{Camelize, Dasherize, Lowercase, Replace, Slice, Transform, Underscorize, Uppercase};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::str::FromStr;

#[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::new(Camelize::default())),
                "dasherize" => Some(Box::new(Dasherize::default())),
                "lowercase" => Some(Box::new(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) => {
                        if !options.contains_key("from") || !options.contains_key("to") {
                            return None;
                        }

                        let from = usize::from_str(options.get("from").unwrap()).unwrap_or(0);
                        let to = match usize::from_str(options.get("to").unwrap()) {
                            Err(_) => None,
                            Ok(value) => Some(value),
                        };

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