refactor

src/wildcardsubdomain.rs

@@ -1,29 +1,93 @@
 use serde_json::{from_str, Value};
 
+struct ThreeTuple {
+    title: String,
+    message: String,
+    emoji: String,
+}
+
+impl ThreeTuple {
+    fn new(title: String, message: String, emoji: String) -> ThreeTuple {
+        ThreeTuple {
+            title,
+            message,
+            emoji,
+        }
+    }
+
+    fn get_str_from_json(json: &Value, key: &str) -> Option<String> {
+        json.get(key)
+            .and_then(|value| value.as_str().map(|s| s.to_string()))
+    }
+
+    fn get_from_json(json: &Value, default: ThreeTuple, key: &str) -> ThreeTuple {
+        match json.get(key) {
+            Some(value) => ThreeTuple::new(
+                Self::get_str_from_json(value, "title").unwrap_or(default.title),
+                Self::get_str_from_json(value, "message").unwrap_or(default.message),
+                Self::get_str_from_json(value, "emoji").unwrap_or(default.emoji),
+            ),
+            _ => default,
+        }
+    }
+
+    fn get_default_from_json(
+        json: &Value,
+        title: String,
+        message_suffix: String,
+        emoji: String,
+    ) -> ThreeTuple {
+        Self::get_from_json(
+            json,
+            ThreeTuple::new(title.clone(), format!("{}{}", title, message_suffix), emoji),
+            "default",
+        )
+    }
+}
+
+impl Clone for ThreeTuple {
+    fn clone(&self) -> Self {
+        ThreeTuple {
+            title: self.title.clone(),
+            message: self.message.clone(),
+            emoji: self.emoji.clone(),
+        }
+    }
+}
+
 pub struct Hostdata {
-    pub subdomain: String,
-    pub domain: String,
-    pub host: String,
+    domain: String,
+    host: String,
     pub decoded_subdomain: String,
+    three_tuple: ThreeTuple,
 }
 
 impl Hostdata {
     pub fn new(host: String, domain: String) -> Hostdata {
-        if host.contains(&format!(".{}", domain)) {
-            let subdomain = host.replace(&format!(".{}", domain), "");
-            Hostdata {
-                subdomain: subdomain.clone(),
-                domain,
-                host,
-                decoded_subdomain: Self::decode(subdomain),
-            }
+        let pattern = format!(".{}", domain);
+        let subdomain = if host.contains(&pattern) {
+            host.replace(&pattern, "")
         } else {
-            Hostdata {
-                subdomain: "".to_string(),
-                domain,
-                host,
-                decoded_subdomain: "".to_string(),
-            }
+            "".to_string()
+        };
+        let decoded_subdomain = Self::decode(subdomain.clone());
+
+        let json_str = include_str!("../static/3tuples.json");
+        let json: Value = from_str(json_str).unwrap_or_default();
+        let default_three_tuple = ThreeTuple::get_default_from_json(
+            &json,
+            subdomain,
+            "おわりが売ってる".to_string(),
+            "✅".to_string(),
+        );
+        let three_tuple =
+            ThreeTuple::get_from_json(&json, default_three_tuple.clone(), &decoded_subdomain);
+
+        Hostdata {
+            domain,
+            host,
+            decoded_subdomain,
+            three_tuple,
         }
     }
 
@@ -39,75 +103,11 @@ impl Hostdata {
         let html = include_str!("../static/index.html.tmpl");
         html.replace(
             "{{ .Title }}",
-            &format!("{}{}", self.get_title(), title_suffix),
+            &format!("{}{}", self.three_tuple.title, title_suffix),
         )
-        .replace("{{ .Message }}", &self.get_message())
+        .replace("{{ .Message }}", &self.three_tuple.message)
         .replace("{{ .Host }}", &self.host)
-        .replace("{{ .Emoji }}", &self.get_emoji())
+        .replace("{{ .Emoji }}", &self.three_tuple.emoji)
         .replace("{{ .Domain }}", &self.domain)
     }
-
-    fn get_title(&self) -> String {
-        self.get_3tuple().0
-    }
-
-    fn get_message(&self) -> String {
-        self.get_3tuple().1
-    }
-
-    fn get_emoji(&self) -> String {
-        self.get_3tuple().2
-    }
-
-    fn get_3tuple(&self) -> (String, String, String) {
-        let json_str = include_str!("../static/3tuples.json");
-        let json: Value = from_str(json_str).unwrap_or_default();
-
-        let default_3tuple = match json.get("default") {
-            Some(value) => {
-                let message = value
-                    .get("message")
-                    .unwrap_or(&Value::Null)
-                    .as_str()
-                    .unwrap_or_default();
-                let emoji = value
-                    .get("emoji")
-                    .unwrap_or(&Value::Null)
-                    .as_str()
-                    .unwrap_or_default();
-                (
-                    self.decoded_subdomain.clone(),
-                    format!("{}{}", self.decoded_subdomain, message),
-                    emoji.to_string(),
-                )
-            }
-            _ => (
-                self.decoded_subdomain.clone(),
-                format!("{}おわりが売ってる", self.decoded_subdomain),
-                "✅".to_string(),
-            ),
-        };
-
-        match json.get(&self.decoded_subdomain) {
-            Some(value) => {
-                let title = value
-                    .get("title")
-                    .unwrap_or(&Value::Null)
-                    .as_str()
-                    .unwrap_or(default_3tuple.0.as_str());
-                let message = value
-                    .get("message")
-                    .unwrap_or(&Value::Null)
-                    .as_str()
-                    .unwrap_or(default_3tuple.1.as_str());
-                let emoji = value
-                    .get("emoji")
-                    .unwrap_or(&Value::Null)
-                    .as_str()
-                    .unwrap_or(default_3tuple.2.as_str());
-                (title.to_string(), message.to_string(), emoji.to_string())
-            }
-            _ => default_3tuple,
-        }
-    }
 }