Merge pull request #109 from yuma140902/clippy-lint

chore: clippy

src/main.rs

@@ -2,7 +2,7 @@ use clap::Parser;
 use tempura::cli::{Cli, Commands};
 use tracing::debug;
 
-fn verbose_to_level(verbose: u8) -> tracing::Level {
+const fn verbose_to_level(verbose: u8) -> tracing::Level {
     if verbose == 0 {
         #[cfg(debug_assertions)]
         return tracing::Level::DEBUG;

src/pipeline/job.rs

@@ -50,6 +50,7 @@ impl<'a> Job<'a> {
         let mut output_file = fs::OpenOptions::new()
             .write(true)
             .create(true)
+            .truncate(true)
             .append(false)
             .open(&self.output_path)
             .with_context(|| {
@@ -66,15 +67,15 @@ impl<'a> Job<'a> {
         Ok(())
     }
 
-    pub fn pipeline(&self) -> &Pipeline {
+    pub const fn pipeline(&self) -> &Pipeline {
         self.pipeline
     }
 
-    pub fn input_path(&self) -> &PathBuf {
+    pub const fn input_path(&self) -> &PathBuf {
         &self.input_path
     }
 
-    pub fn output_path(&self) -> &PathBuf {
+    pub const fn output_path(&self) -> &PathBuf {
         &self.output_path
     }
 }

src/string_matcher.rs

@@ -22,14 +22,10 @@ pub enum StringMatcher {
 impl StringMatcher {
     pub fn is_match(&self, string: &str) -> bool {
         match self {
-            StringMatcher::Regex { regex } => regex.is_match(string),
-            StringMatcher::Not { matcher } => !matcher.is_match(string),
-            StringMatcher::All { matchers } => {
-                matchers.iter().all(|matcher| matcher.is_match(string))
-            }
-            StringMatcher::Any { matchers } => {
-                matchers.iter().any(|matcher| matcher.is_match(string))
-            }
+            Self::Regex { regex } => regex.is_match(string),
+            Self::Not { matcher } => !matcher.is_match(string),
+            Self::All { matchers } => matchers.iter().all(|matcher| matcher.is_match(string)),
+            Self::Any { matchers } => matchers.iter().any(|matcher| matcher.is_match(string)),
         }
     }
 }

src/transformer/template_renderer.rs

@@ -18,7 +18,7 @@ pub struct TemplateRenderer {
     pub current_directory: Option<CurrentDirectory>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(tag = "type")]
 pub enum CurrentDirectory {
     EntryDirectory,
@@ -53,8 +53,8 @@ impl Transformer for TemplateRenderer {
             )
         }
 
-        let current_directory: Option<String> = if let Some(CurrentDirectory::EntryDirectory) =
-            &self.current_directory
+        let current_directory: Option<String> = if self.current_directory
+            == Some(CurrentDirectory::EntryDirectory)
         {
             match store.get("___entry_directory") {
                 Some(Value::JSON(serde_json::Value::String(entry_dir))) => Some(entry_dir.into()),

src/value.rs

@@ -1,27 +1,26 @@
 use handlebars::Template;
 
+#[derive(Debug, Clone)]
 /// [`Value`] is data read from a file by the [`Loader`](crate::loader::Loader).
 /// Conceptually, it is the same as JSON.
 /// It is hierarchical and has types such as object, string, and numeric.
-
-#[derive(Debug, Clone)]
 pub enum Value {
     Bytes(Vec<u8>),
     Template(Template),
     JSON(serde_json::Value),
 }
 
 impl Value {
-    pub fn get_type_name(&self) -> &'static str {
+    pub const fn get_type_name(&self) -> &'static str {
         match self {
-            Value::Bytes(_) => "bytes",
-            Value::JSON(json) => get_json_type_name(json),
-            Value::Template(_) => "template",
+            Self::Bytes(_) => "bytes",
+            Self::JSON(json) => get_json_type_name(json),
+            Self::Template(_) => "template",
         }
     }
 }
 
-fn get_json_type_name(json: &serde_json::Value) -> &'static str {
+const fn get_json_type_name(json: &serde_json::Value) -> &'static str {
     match json {
         serde_json::Value::Null => "null",
         serde_json::Value::Bool(_) => "bool",