refactor: change filter process logic

quake_core/src/entry/entry_define.rs

@@ -6,7 +6,7 @@ use serde_derive::{Deserialize, Serialize};
 
 use crate::entry::EntryDefines;
 use crate::helper::quake_time;
-use crate::meta::EntryDefineFields;
+use crate::meta::{EntryDefineFields, MetaField};
 
 /// Define a new entry:
 /// - `entry_type`: the entry_type for operation in system, should be in letter or `_` use in `dir`, `storage` such as
@@ -53,7 +53,8 @@ impl Default for EntryDefine {
 }
 
 impl EntryDefine {
-    pub fn to_type(&self) -> EntryDefineFields {
+    // todo: directly Deserialize to meta field
+    pub fn to_field_type(&self) -> IndexMap<String, MetaField> {
         let mut fields: IndexMap<String, String> = IndexMap::new();
         for map in &self.fields {
             for (key, value) in map {
@@ -160,8 +161,8 @@ mod tests {
         let todo = &custom_entry_from_yaml()[0];
         assert_eq!(3, todo.fields.len());
 
-        let custom_type = todo.to_type();
-        let option = custom_type.field("title").unwrap();
+        let custom_type = todo.to_field_type();
+        let option = custom_type.get("title").unwrap();
         assert_eq!(&MetaField::Title(String::from("Title")), option)
     }
 

quake_core/src/meta/meta_field.rs

@@ -9,14 +9,13 @@ pub enum MetaField {
     Body(String),
     Author(Author),
     Text(String),
-    Tagged(Vec<String>),
     Searchable(String),
     Theme(String),
     Epic(String),
     // String for map
     Date(String),
     /// custom filter types
-    Filterable(Vec<String>),
+    Filterable(String),
     /// priority
     Priority(String),
     /// todo: define for Attachment
@@ -38,7 +37,6 @@ impl Display for MetaField {
         match self {
             MetaField::Text(text) => write!(f, "{}", text),
             MetaField::Title(title) => write!(f, "{}", title),
-            MetaField::Tagged(tag) => write!(f, "{}", tag.join("#")),
             MetaField::Author(author) => write!(f, "{:?}", author),
             MetaField::Searchable(str) => write!(f, "{}", str),
             MetaField::Filterable(conds) => write!(f, "{:?}", conds),

quake_core/src/meta/mod.rs

@@ -1,15 +1,24 @@
 use indexmap::IndexMap;
 
-pub mod meta_field;
-
 pub use meta_field::MetaField;
 
+pub mod meta_field;
+
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct Author {
     name: String,
     email: String,
 }
 
+impl Author {
+    pub fn new(str: String) -> Author {
+        Author {
+            name: str.to_string(),
+            email: "".to_string(),
+        }
+    }
+}
+
 impl Default for Author {
     fn default() -> Self {
         Author {
@@ -20,38 +29,27 @@ impl Default for Author {
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct EntryDefineFields {
-    pub fields: IndexMap<String, MetaField>,
-}
+pub struct EntryDefineFields {}
 
 impl EntryDefineFields {
-    pub fn from(map: IndexMap<String, String>) -> EntryDefineFields {
+    pub fn from(map: IndexMap<String, String>) -> IndexMap<String, MetaField> {
         let mut fields = IndexMap::new();
         for (key, value) in map {
             fields.insert(key, Self::parse_field_type(value));
         }
 
-        EntryDefineFields { fields }
-    }
-
-    pub fn field(&self, text: &str) -> Option<&MetaField> {
-        self.fields.get(text)
+        fields
     }
 
     fn parse_field_type(value: String) -> MetaField {
-        let field = match value.as_str() {
-            "Text" => MetaField::Text(value),
-            "Title" => MetaField::Title(value),
-            "Flow" => MetaField::Flow(value),
-            "Tagged" => {
-                let tags = vec![];
-                MetaField::Tagged(tags)
-            }
-            "Author" => {
-                let author = Author::default();
-                MetaField::Author(author)
-            }
-            "Date" => MetaField::Date(value),
+        let field = match value.to_lowercase().as_str() {
+            "text" => MetaField::Text(value),
+            "title" => MetaField::Title(value),
+            "flow" => MetaField::Flow(value),
+            "string" => MetaField::Text(value),
+            "searchable" => MetaField::Searchable("string".to_string()),
+            "filterable" => MetaField::Filterable("string".to_string()),
+            "date" => MetaField::Date(value),
             _ => MetaField::Unknown(value),
         };
         field
@@ -60,17 +58,18 @@ impl EntryDefineFields {
 
 #[cfg(test)]
 mod tests {
-    use crate::meta::{EntryDefineFields, MetaField};
     use indexmap::IndexMap;
 
+    use crate::meta::{EntryDefineFields, MetaField};
+
     #[test]
     fn custom_type() {
         let mut map = IndexMap::new();
         map.insert("title".to_string(), "Title".to_string());
 
-        let custom_type = EntryDefineFields::from(map);
+        let fields = EntryDefineFields::from(map);
 
-        let option = custom_type.fields.get("title").unwrap();
+        let option = fields.get("title").unwrap();
         assert_eq!(&MetaField::Title(String::from("Title")), option)
     }
 }

quake_core/src/parser/parser.rs

@@ -86,7 +86,7 @@ fn midway(decl: Pair<Rule>) -> Midway {
             Rule::parameter => {
                 midway.end = value(pair);
             }
-            Rule::from | Rule::to | Rule::s_quote | Rule::e_quote => {}
+            Rule::from | Rule::to | Rule::left_bracket | Rule::right_bracket => {}
             _ => {
                 println!("{}", pair);
             }
@@ -112,7 +112,7 @@ fn endway(decl: Pair<Rule>) -> Endway {
                     }
                 }
             }
-            Rule::from | Rule::to | Rule::s_quote | Rule::e_quote => {}
+            Rule::from | Rule::to | Rule::left_bracket | Rule::right_bracket => {}
             _ => {
                 println!("{}", pair);
             }
@@ -157,8 +157,8 @@ fn parameters(decl: Pair<Rule>) -> Vec<Parameter> {
 
                 params.push(param)
             }
-            Rule::s_quote => {}
-            Rule::e_quote => {}
+            Rule::left_bracket => {}
+            Rule::right_bracket => {}
             _ => {
                 println!("{}", pair);
             }

quake_core/src/parser/quake.pest

@@ -12,15 +12,19 @@ transflow_decl = {
 }
 
 transflow_expr = {
-    midway | endway
+    (midway | endway) ~ ("." ~ left_bracket ~ filter_expr ~ right_bracket)?
 }
 
 midway = {
-    from ~ parameters ~ "." ~ to ~ s_quote ~ parameter ~ e_quote
+    from ~ parameters ~ "." ~ to ~ left_bracket ~ parameter ~ right_bracket
 }
 
 endway = {
-    from ~ parameters ~ "." ~ to ~ s_quote ~ component_decl ~ e_quote
+    from ~ parameters ~ "." ~ to ~ left_bracket ~ component_decl ~ right_bracket
+}
+
+filter_expr = {
+    single_quoted_string
 }
 
 component_decl = {
@@ -35,14 +39,14 @@ from = { "from" }
 to = { "to" }
 
 parameters = {
-    s_quote ~ parameter ~ ("," ~ parameter)* ~ e_quote
+    left_bracket ~ parameter ~ ("," ~ parameter)* ~ right_bracket
 }
 
-s_quote = {
+left_bracket = {
     "(" | "（"
 }
 
-e_quote = {
+right_bracket = {
     ")" | "）"
 }