feat(cli): implement config and rules (#19)

* feat(cli): impl config file reading

Signed-off-by: KeisukeYamashita <[email protected]>

* feat(cli): configure correct license

Signed-off-by: KeisukeYamashita <[email protected]>

* feat(cli): pin rust version

Signed-off-by: KeisukeYamashita <[email protected]>

* feat(cli): impl json and yaml config file

Signed-off-by: KeisukeYamashita <[email protected]>

* feat(cli): impl config

Signed-off-by: KeisukeYamashita <[email protected]>

---------

Signed-off-by: KeisukeYamashita <[email protected]>

Author: KeisukeYamashita

Cargo.lock

@@ -1,22 +1,25 @@
 [package]
 name = "commitlint-rs"
 description = "CLI tool to lint commits by Conventional Commits"
+authors = ["KeisukeYamashita <[email protected]>"]
 keywords = ["conventional-commits", "lint"]
 categories = ["command-line-utilities"]
 version = "0.0.3"
 readme = "README.md"
 repository = "https://github.com/KeisukeYamashita/commitlint-rs"
-license-file = "LICENSE"
+license-file = "Apache-2.0 or MIT"
 edition = "2021"
 exclude = ["/web"]
+rust-version = "1.71"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 clap = { version = "4.3.4", features = ["derive", "env", "string"] }
 futures = "0.3.28"
 regex = "1.8.4"
-serde = "1.0.164"
+serde = { version = "1.0.164", features = ["derive"] }
+serde_json = "1.0.96"
 serde_yaml = "0.9.21"
 tokio = { version = "1.28.2", features = ["full"] }
 

Cargo.toml

@@ -0,0 +1,20 @@
+Copyright (c) 2023- KeisukeYamashita
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE LICENSE-APACHE

@@ -0,0 +1,3 @@
+rules:
+  body-empty:
+    hoge: hoho

LICENSE-MIT

@@ -17,8 +17,8 @@ use crate::message::Message;
 #[command(author, about = "CLI to lint with conventional commits", long_about = None, version)]
 pub struct Args {
     /// Path to the config file
-    #[arg(short = 'g', long, default_value = ".")]
-    pub config: PathBuf,
+    #[arg(short = 'g', long)]
+    pub config: Option<PathBuf>,
 
     /// Directory to execute in
     #[arg(short = 'd', long, default_value = ".")]

examples/.commitlint.yaml

@@ -1,4 +1,10 @@
-use std::{fmt::Error, path::PathBuf};
+use serde::Deserialize;
+use std::{fs, path::PathBuf};
+
+use crate::rule::{Rules};
+
+/// Default Root config file path to search for.
+const DEFAULT_CONFIG_ROOT: &str = ".";
 
 /// Default commitlintrc configuration files
 /// If the user didn't specify a configuration file with -g or --config argument,
@@ -11,23 +17,27 @@ const DEFAULT_CONFIG_FILE: [&str; 4] = [
 ];
 
 /// Config represents the configuration of commitlint.
-#[derive(Debug)]
-pub struct Config {}
-
-/// Default configuration if no configuration file is found.
-pub fn default_config() -> Config {
-    Config {}
+#[derive(Clone, Debug, Default, Deserialize)]
+pub struct Config {
+    /// Rules represents the rules of commitlint.
+    pub rules: Rules,
 }
 
 /// Load configuration from the specified path.
-pub async fn load(path: PathBuf) -> Result<Config, Error> {
-    let config_file = find_config_file(path);
+pub async fn load(path: Option<PathBuf>) -> Result<Config, String> {
+    let config_file = match &path {
+        Some(p) => Some(p.clone()),
+        None => find_config_file(PathBuf::from(DEFAULT_CONFIG_ROOT)),
+    };
 
-    if config_file.is_none() {
-        return Ok(default_config());
+    match (config_file, path) {
+        // If the file was specified and found, load it.
+        (Some(p), _) => load_config_file(p).await,
+        // If the file was not specified and not found, return default config.
+        (None, None) => Ok(Config::default()),
+        // If the was explicitly specified but not found, return an error.
+        (None, Some(p)) => Err(format!("Configuration file not found in {}", p.display())),
     }
-
-    Ok(Config {})
 }
 
 /// Find configuration file in the specified path.
@@ -43,3 +53,65 @@ pub fn find_config_file(path: PathBuf) -> Option<PathBuf> {
 
     None
 }
+
+/// Load config file from the specified path.
+pub async fn load_config_file(path: PathBuf) -> Result<Config, String> {
+    if !path.exists() {
+        return Err(format!(
+            "Configuration file not found in {}",
+            path.display()
+        ));
+    }
+
+    match path.extension() {
+        Some(ext) => match ext.to_str() {
+            Some("json") => load_json_config_file(path).await,
+            Some("yaml") | Some("yml") => load_yaml_config_file(path).await,
+            _ => load_unknown_config_file(path).await,
+        },
+        None => Err(format!(
+            "Unsupported configuration file format: {}",
+            path.display()
+        )),
+    }
+}
+
+/// Load JSON config file from the specified path.
+async fn load_json_config_file(path: PathBuf) -> Result<Config, String> {
+    let text = fs::read_to_string(path).unwrap();
+
+    match serde_json::from_str::<Config>(&text) {
+        Ok(config) => Ok(config),
+        Err(err) => Err(format!("Failed to parse configuration file: {}", err)),
+    }
+}
+
+/// Load YAML config file from the specified path.
+async fn load_yaml_config_file(path: PathBuf) -> Result<Config, String> {
+    let text = fs::read_to_string(path).unwrap();
+
+    match serde_yaml::from_str::<Config>(&text) {
+        Ok(config) => Ok(config),
+        Err(err) => Err(format!("Failed to parse configuration file: {}", err)),
+    }
+}
+
+/// Try to load configuration file from the specified path.
+/// First try to load it as JSON, then as YAML.
+/// If both fail, return an error.
+async fn load_unknown_config_file(path: PathBuf) -> Result<Config, String> {
+    let text = fs::read_to_string(path.clone()).unwrap();
+
+    if let Ok(config) = serde_json::from_str::<Config>(&text) {
+        return Ok(config);
+    }
+
+    if let Ok(config) = serde_yaml::from_str::<Config>(&text) {
+        return Ok(config);
+    }
+
+    Err(format!(
+        "Failed to parse configuration file: {}",
+        path.display()
+    ))
+}

src/args.rs

@@ -75,7 +75,7 @@ pub fn parse_commit_message(
 
     for line in lines {
         if in_footer {
-            let parts: Vec<&str> = line.splitn(2, ":").collect();
+            let parts: Vec<&str> = line.splitn(2, ':').collect();
             if parts.len() == 2 {
                 let key = parts[0].trim().to_string();
                 let value = parts[1].trim().to_string();
@@ -86,7 +86,9 @@ pub fn parse_commit_message(
             in_footer = true;
         } else {
             body.get_or_insert_with(String::new).push_str(line);
-            body.as_mut().map(|b| b.push('\n'));
+            if let Some(b) = body.as_mut() {
+                b.push('\n')
+            }
         }
     }
 
@@ -117,7 +119,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn text_parse_subject_with_scope() {
+    fn test_parse_subject_with_scope() {
         let input = "feat(cli): add dummy option";
         assert_eq!(
             parse_subject(input),
@@ -130,7 +132,7 @@ mod tests {
     }
 
     #[test]
-    fn text_parse_subject_with_emphasized_type_with_scope() {
+    fn test_parse_subject_with_emphasized_type_with_scope() {
         let input = "feat(cli)!: add dummy option";
         assert_eq!(
             parse_subject(input),
@@ -143,7 +145,7 @@ mod tests {
     }
 
     #[test]
-    fn text_parse_subject_without_scope() {
+    fn test_parse_subject_without_scope() {
         let input = "feat: add dummy option";
         assert_eq!(
             parse_subject(input),
@@ -152,7 +154,7 @@ mod tests {
     }
 
     #[test]
-    fn text_parse_subject_with_emphasized_type_without_scope() {
+    fn test_parse_subject_with_emphasized_type_without_scope() {
         let input = "feat!: add dummy option";
         assert_eq!(
             parse_subject(input),

src/config.rs

@@ -3,9 +3,11 @@ mod config;
 mod git;
 mod message;
 mod result;
+mod rule;
 
 use args::Args;
 use clap::Parser;
+use message::validate;
 
 use std::process::exit;
 
@@ -14,7 +16,7 @@ async fn main() {
     let args = Args::parse();
 
     let config = match config::load(args.config.clone()).await {
-        Ok(config) => config,
+        Ok(c) => c,
         Err(err) => {
             eprintln!("Failed to load config: {}", err);
             exit(1)
@@ -35,7 +37,11 @@ async fn main() {
 
     let threads = messages
         .into_iter()
-        .map(|message| tokio::spawn(async move { message.lint().await }))
+        .map(|message| {
+            let config = config.clone();
+
+            tokio::spawn(async move { validate(&message, &config).await })
+        })
         .collect::<Vec<_>>();
 
     let results = futures::future::join_all(threads).await;
@@ -46,13 +52,11 @@ async fn main() {
             eprintln!("{}", err);
         }
 
-        if let Ok(r) = result {
-            if let Ok(h) = r {
-                if let Some(violations) = &h.violations {
-                    for violation in violations {
-                        eprintln!("{}", violation);
-                        invalid = true;
-                    }
+        if let Ok(Ok(h)) = result {
+            if !h.violations.is_empty() {
+                for violation in &h.violations {
+                    eprintln!("{}", violation.message);
+                    invalid = true;
                 }
             }
         }

src/git.rs

@@ -1,4 +1,5 @@
 use crate::{
+    config::Config,
     git::{parse_commit_message, parse_subject},
     result::Result as LintResult,
 };
@@ -17,9 +18,15 @@ use std::{collections::HashMap, fmt::Error};
 ///
 #[derive(Clone, Debug)]
 pub struct Message {
+    /// Body part of the commit message.
+    pub body: Option<String>,
+
     /// Description part of the commit message.
     pub description: Option<String>,
 
+    /// Footers part of the commit message.
+    pub footers: Option<HashMap<String, String>>,
+
     /// Raw commit message (or any input from stdin) including the body and footers.
     pub raw: String,
 
@@ -28,12 +35,6 @@ pub struct Message {
 
     /// Scope part of the commit message.
     pub scope: Option<String>,
-
-    /// Body part of the commit message.
-    pub body: Option<String>,
-
-    /// Footers part of the commit message.
-    pub footers: Option<HashMap<String, String>>,
 }
 
 /// Message represents a commit message.
@@ -60,12 +61,11 @@ impl Message {
             },
         }
     }
+}
 
-    /// Lint the raw commit message.
-    pub async fn lint(&self) -> Result<LintResult, Error> {
-        // TODO: Implement linting.
-        Ok(LintResult {
-            violations: Some(vec!["Hello".to_string()]),
-        })
-    }
+/// validate the raw commit message.
+pub async fn validate(msg: &Message, config: &Config) -> Result<LintResult, Error> {
+    let violations = config.rules.validate(msg);
+
+    Ok(LintResult { violations })
 }