GitHub Actions用workflowを作成

.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+      - name: Check
+        run: cargo check
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+      - name: Run tests
+        run: cargo test --verbose
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+      - name: Lint with clippy
+        run: cargo clippy --all-targets --all-features
+
+  fmt:
+    name: Rustfmt
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+      - name: Check formatting
+        run: cargo fmt --all --check

src/main.rs

@@ -30,12 +30,13 @@ fn main() {
 }
 
 fn run_command(args: Cli) -> Result<(), anyhow::Error> {
-    Ok(match args.command {
+    match args.command {
         Command::Init(args) => {
             settings::gen_setting_file(&args)?;
         }
         Command::Run(args) => {
             runner::run(args)?;
         }
-    })
+    };
+    Ok(())
 }

src/runner/io.rs

@@ -78,7 +78,7 @@ pub(super) fn save_summary_log(
     stats: &multi::TestStats,
     comment: &str,
 ) -> Result<()> {
-    let mut writer = match OpenOptions::new().write(true).append(true).open(&path) {
+    let mut writer = match OpenOptions::new().append(true).open(&path) {
         Ok(file) => BufWriter::new(file),
         Err(_) => {
             create_parent_dir(&path)?;
@@ -120,7 +120,7 @@ fn save_summary_log_inner(
         .to_formatted_string(&Locale::en);
 
     let score_log10 = stats.score_sum_log10;
-    let average_score_log10 = stats.score_sum_log10 as f64 / stats.results.len() as f64;
+    let average_score_log10 = stats.score_sum_log10 / stats.results.len() as f64;
 
     writeln!(
         writer,

src/runner/multi.rs

@@ -143,10 +143,9 @@ mod test {
     use crate::runner::single::{Objective, TestStep};
     use printer::MockPrinter;
     use regex::Regex;
-    use std::{cell::LazyCell, num::NonZero};
+    use std::num::NonZero;
 
-    const SCORE_REGEX: LazyCell<Regex> =
-        LazyCell::new(|| Regex::new(r"^\s*Score\s*=\s*(?P<score>\d+)\s*$").unwrap());
+    thread_local!(static SCORE_REGEX: Regex = Regex::new(r"^\s*Score\s*=\s*(?P<score>\d+)\s*$").unwrap());
 
     #[test]
     fn test_multi_case_runner() {
@@ -159,7 +158,7 @@ mod test {
             None,
             true,
         )];
-        let single_runner = SingleCaseRunner::new(steps, SCORE_REGEX.clone());
+        let single_runner = SingleCaseRunner::new(steps, SCORE_REGEX.with(|r| r.clone()));
         let test_cases = vec![
             TestCase::new(0, NonZero::new(100), Objective::Max),
             TestCase::new(1, NonZero::new(200), Objective::Max),

src/runner/multi/printer.rs

@@ -61,8 +61,8 @@ impl Printer for ConsolePrinter {
         match result.score() {
             Ok(_) => writeln!(writer, "{}", record)?,
             Err(e) => {
-                writeln!(writer, "{}", record.yellow().to_string())?;
-                writeln!(writer, "{}", e.to_string().yellow().to_string())?;
+                writeln!(writer, "{}", record.yellow())?;
+                writeln!(writer, "{}", e.to_string().yellow())?;
             }
         };
 
@@ -221,6 +221,7 @@ mod test {
 
     #[test]
     fn test_console_printer() {
+        colored::control::set_override(true);
         let mut printer = ConsolePrinter::new(3);
 
         let test_results = gen_test_results();

src/runner/single.rs

@@ -267,22 +267,21 @@ impl SingleCaseRunner {
     fn write_output(path: impl AsRef<OsStr>, contents: &[u8]) -> Result<()> {
         let path = Path::new(&path);
         Self::create_parent_dir_all(path)?;
-        std::fs::write(&path, contents)?;
+        std::fs::write(path, contents)?;
 
         Ok(())
     }
 
     fn extract_score(&self, outputs: &[Vec<u8>]) -> Option<f64> {
         outputs
             .iter()
-            .map(|s| {
+            .filter_map(|s| {
                 let s = String::from_utf8_lossy(s);
                 self.score_pattern
                     .captures_iter(&s)
-                    .filter_map(|m| m.name("score").map(|s| s.as_str().parse().ok()).flatten())
+                    .filter_map(|m| m.name("score").and_then(|s| s.as_str().parse().ok()))
                     .last()
             })
-            .flatten()
             .last()
     }
 
@@ -295,11 +294,9 @@ impl SingleCaseRunner {
 #[cfg(test)]
 mod test {
     use super::*;
-    use std::cell::LazyCell;
 
     const TEST_CASE: TestCase = TestCase::new(42, None, Objective::Max);
-    const SCORE_REGEX: LazyCell<Regex> =
-        LazyCell::new(|| Regex::new(r"^\s*Score\s*=\s*(?P<score>\d+)\s*$").unwrap());
+    thread_local!(static SCORE_REGEX: Regex = Regex::new(r"^\s*Score\s*=\s*(?P<score>\d+)\s*$").unwrap());
 
     #[test]
     fn test_calc_relative_score() {
@@ -345,15 +342,15 @@ mod test {
     #[test]
     fn run_test_ok() {
         let steps = vec![gen_teststep("echo", Some("Score = 1234"))];
-        let runner = SingleCaseRunner::new(steps, SCORE_REGEX.clone());
+        let runner = SingleCaseRunner::new(steps, get_regex());
         let result = runner.run(TEST_CASE);
         assert_eq!(result.score(), &Ok(NonZeroU64::new(1234).unwrap()));
     }
 
     #[test]
     fn run_test_score_zero() {
         let steps = vec![gen_teststep("echo", Some("Score = 0"))];
-        let runner = SingleCaseRunner::new(steps, SCORE_REGEX.clone());
+        let runner = SingleCaseRunner::new(steps, get_regex());
         let result = runner.run(TEST_CASE);
 
         // 0点以下はWrong Answerとして扱う
@@ -363,15 +360,15 @@ mod test {
     #[test]
     fn run_test_fail() {
         let steps = vec![gen_teststep("false", None)];
-        let runner = SingleCaseRunner::new(steps, SCORE_REGEX.clone());
+        let runner = SingleCaseRunner::new(steps, get_regex());
         let result = runner.run(TEST_CASE);
         assert!(result.score.is_err());
     }
 
     #[test]
     fn run_test_invalid_output() {
         let steps = vec![gen_teststep("echo", Some("invalid_output"))];
-        let runner = SingleCaseRunner::new(steps, SCORE_REGEX.clone());
+        let runner = SingleCaseRunner::new(steps, get_regex());
         let result = runner.run(TEST_CASE);
         assert!(result.score.is_err());
     }
@@ -380,4 +377,8 @@ mod test {
         let args = arg.iter().map(|s| s.to_string()).collect();
         TestStep::new(program.to_string(), args, None, None, None, None, true)
     }
+
+    fn get_regex() -> Regex {
+        SCORE_REGEX.with(|r| r.clone())
+    }
 }

src/settings.rs

@@ -209,7 +209,7 @@ fn gen_run_steps(lang: Box<dyn Language>, is_interactive: bool) -> Vec<TestStep>
 
 fn gen_gitignore(dir: impl AsRef<OsStr>) -> Result<()> {
     let dir = Path::new(&dir);
-    std::fs::create_dir_all(&dir)?;
+    std::fs::create_dir_all(dir)?;
 
     let path = dir.join(".gitignore");
 
@@ -288,9 +288,9 @@ impl Language for Cpp {
 
     fn test_command(&self, is_interactive: bool) -> (String, Vec<String>) {
         if is_interactive {
-            return ("../a.out".to_string(), vec![]);
+            ("../a.out".to_string(), vec![])
         } else {
-            return ("./a.out".to_string(), vec![]);
+            ("./a.out".to_string(), vec![])
         }
     }
 }
@@ -319,19 +319,19 @@ impl Language for Go {
             "go".to_string(),
             vec![
                 "build".to_string(),
-            "-o".to_string(), 
-            "a.out".to_string(),
-            "main.go".to_string(),
+                "-o".to_string(),
+                "a.out".to_string(),
+                "main.go".to_string(),
             ],
             None,
         )]
     }
 
     fn test_command(&self, is_interactive: bool) -> (String, Vec<String>) {
         if is_interactive {
-            return ("../a.out".to_string(), vec![]);
+            ("../a.out".to_string(), vec![])
         } else {
-            return ("./a.out".to_string(), vec![]);
+            ("./a.out".to_string(), vec![])
         }
     }
-}
+}