fix(deps): update rust crate serde to v1.0.215

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fzf-make"
-version = "0.37.0"
+version = "0.38.0"
 edition = "2021"
 authors = ["kyu08"]
 description = "A command line tool that executes make target using fuzzy finder with preview window."

src/err/any_to_string.rs

@@ -0,0 +1,10 @@
+// ref: https://qiita.com/kgtkr/items/a17827c4bb704f39c854
+pub fn any_to_string(any: &dyn std::any::Any) -> String {
+    if let Some(s) = any.downcast_ref::<String>() {
+        s.clone()
+    } else if let Some(s) = any.downcast_ref::<&str>() {
+        s.to_string()
+    } else {
+        "Any".to_string()
+    }
+}

src/err/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod any_to_string;

src/file/mod.rs

@@ -1,2 +1,3 @@
 pub(crate) mod path_to_content;
 pub(crate) mod toml;
+mod toml_old;

src/file/path_to_content.rs

@@ -1,5 +1,4 @@
 use anyhow::{anyhow, Result};
-
 use std::{fs::read_to_string, path::PathBuf};
 
 pub fn path_to_content(path: PathBuf) -> Result<String> {

src/file/toml.rs

@@ -1,4 +1,4 @@
-use super::path_to_content;
+use super::{path_to_content, toml_old};
 use crate::model::{
     histories::{self},
     runner_type,
@@ -23,18 +23,27 @@ impl Histories {
         match history_file_path() {
             Some((history_file_dir, history_file_name)) => {
                 match path_to_content::path_to_content(history_file_dir.join(history_file_name)) {
-                    // TODO: Show error message on message pane if parsing history file failed. https://github.com/kyu08/fzf-make/issues/152
-                    Ok(c) => match parse_history(c.to_string()) {
-                        Ok(h) => h,
-                        Err(_) => Histories { histories: vec![] },
-                    },
-                    Err(_) => Histories { histories: vec![] },
+                    Ok(c) => Histories::parse_history_in_considering_history_file_format_version(c),
+                    Err(_) => Histories::default(),
                 }
             }
-            None => Histories { histories: vec![] },
+            None => Histories::default(),
         }
     }
 
+    fn parse_history_in_considering_history_file_format_version(content: String) -> Histories {
+        // NOTE: The history file format has changed after https://github.com/kyu08/fzf-make/pull/324.
+        // So at first we try to parse it as the new format, and then try to parse it as the old format.
+        match parse_history(content.to_string()) {
+            Ok(h) => h,
+            Err(_) => toml_old::parse_history(content.to_string()).unwrap_or_default(),
+        }
+    }
+
+    pub fn new(histories: Vec<History>) -> Self {
+        Self { histories }
+    }
+
     fn from(histories: histories::Histories) -> Self {
         let mut result: Vec<History> = vec![];
         for h in histories.histories {
@@ -53,7 +62,7 @@ impl Histories {
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
-struct History {
+pub struct History {
     path: PathBuf,
     commands: Vec<HistoryCommand>,
 }
@@ -82,17 +91,25 @@ impl History {
             commands,
         }
     }
+
+    pub fn new(path: PathBuf, commands: Vec<HistoryCommand>) -> Self {
+        Self { path, commands }
+    }
 }
 
 /// toml representation of histories::HistoryCommand.
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "kebab-case")]
-struct HistoryCommand {
+pub struct HistoryCommand {
     runner_type: runner_type::RunnerType,
     name: String,
 }
 
 impl HistoryCommand {
+    pub fn new(runner_type: runner_type::RunnerType, name: String) -> Self {
+        Self { runner_type, name }
+    }
+
     fn from(command: histories::HistoryCommand) -> Self {
         Self {
             runner_type: command.runner_type,
@@ -260,4 +277,143 @@ name = "echo1"
             }
         }
     }
+
+    #[test]
+    fn parse_history_in_considering_history_file_format_version_test() {
+        struct Case {
+            title: &'static str,
+            content: String,
+            expect: Histories,
+        }
+        let cases = vec![
+            Case {
+                title: "Success(new format)",
+                content: r#"
+[[histories]]
+path = "/Users/user/code/fzf-make"
+
+[[histories.commands]]
+runner-type = "make"
+name = "test"
+
+[[histories.commands]]
+runner-type = "make"
+name = "check"
+
+[[histories.commands]]
+runner-type = "make"
+name = "spell-check"
+
+[[histories]]
+path = "/Users/user/code/golang/go-playground"
+
+[[histories.commands]]
+runner-type = "make"
+name = "run"
+
+[[histories.commands]]
+runner-type = "make"
+name = "echo1"
+                "#
+                .to_string(),
+                expect: Histories {
+                    histories: vec![
+                        History {
+                            path: PathBuf::from("/Users/user/code/fzf-make"),
+                            commands: vec![
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "test".to_string(),
+                                },
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "check".to_string(),
+                                },
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "spell-check".to_string(),
+                                },
+                            ],
+                        },
+                        History {
+                            path: PathBuf::from("/Users/user/code/golang/go-playground"),
+                            commands: vec![
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "run".to_string(),
+                                },
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "echo1".to_string(),
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+            Case {
+                title: "Success(old format)",
+                content: r#"
+[[history]]
+path = "/Users/user/code/fzf-make/Makefile"
+executed-targets = ["test", "check", "spell-check"]
+
+[[history]]
+path = "/Users/user/code/golang/go-playground/Makefile"
+executed-targets = ["run", "echo1"]
+                "#
+                .to_string(),
+                expect: Histories {
+                    histories: vec![
+                        History {
+                            path: PathBuf::from("/Users/user/code/fzf-make"),
+                            commands: vec![
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "test".to_string(),
+                                },
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "check".to_string(),
+                                },
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "spell-check".to_string(),
+                                },
+                            ],
+                        },
+                        History {
+                            path: PathBuf::from("/Users/user/code/golang/go-playground"),
+                            commands: vec![
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "run".to_string(),
+                                },
+                                HistoryCommand {
+                                    runner_type: runner_type::RunnerType::Make,
+                                    name: "echo1".to_string(),
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+            Case {
+                title: "Error",
+                content: r#"
+                "#
+                .to_string(),
+                expect: Histories::default(),
+            },
+        ];
+
+        for case in cases {
+            assert_eq!(
+                case.expect,
+                Histories::parse_history_in_considering_history_file_format_version(case.content),
+                "\nFailed: 🚨{:?}🚨\n",
+                case.title,
+            )
+        }
+    }
 }