automatic cargo CI changes

.github/dependabot.yaml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    # Check for updates every Monday
+    schedule:
+      interval: "weekly"

.github/workflows/cargo.yaml

@@ -1,10 +1,16 @@
-name: cargo devel CI
+name: Rust CI
 on:
+  pull_request:
+    branches:
+      - '**'
   push:
     branches:
       - '**'
       # - '!master'
 
+env:
+  CARGO_TERM_COLOR: always
+
 jobs:
   CI:
     runs-on: ubuntu-latest
@@ -38,10 +44,10 @@ jobs:
       - name: cargo fmt
         run: cargo fmt --all
       - name: cargo test
-        run: cargo test --all-features --all-targets --workspace && cargo test --all-features --workspace --doc
+        run: cargo test --all-features --all-targets --workspace
       - name: commit back to repository
         uses: stefanzweifel/git-auto-commit-action@v5
         with:
           # Optional. Commit message for the created commit.
           # Defaults to "Apply automatic changes"
-          commit_message: automatic cargo CI changes
+          commit_message: "ci: automatic Rust CI changes"

.github/workflows/release.yaml

@@ -0,0 +1,54 @@
+name: Release-plz
+
+permissions:
+  pull-requests: write
+  contents: write
+
+on:
+  push:
+    branches:
+      - master
+      - main
+
+jobs:
+
+  # Release unpublished packages.
+  release-plz-release:
+    name: Release-plz release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: MarcoIeni/release-plz-action@v0.5
+        with:
+          command: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
+  # Create a PR with the new versions and changelog, preparing the next release.
+  release-plz-pr:
+    name: Release-plz PR
+    runs-on: ubuntu-latest
+    concurrency:
+      group: release-plz-${{ github.ref }}
+      cancel-in-progress: false
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: MarcoIeni/release-plz-action@v0.5
+        with:
+          command: release-pr
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

scripts/publish.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-set -e
-cargo check --all-features
-echo ">>>>>>>> PUBLISHING RELEASE FOR REPO"
-bash scripts/release.sh
-echo ">>>>>>>> PUBLISHING TO CRATES.IO NEXT"
-sleep 2
-cargo publish
-echo ">>>>>>>> PUBLISHING TO CSCHERR.DE NEXT"
-sleep 2
-cargo publish --registry cscherr

scripts/release.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-TOKEN=$(cat ~/.git-credentials | grep 'git.cscherr.de' | grep -P '(?:)[^:]*(?=@)' -o)
-NEW_VERSION=$(cat Cargo.toml | rg '^\s*version\s*=\s*"([^"]*)"\s*$' -or '$1')
-GIT_COMMIT_SHA=$(git rev-parse HEAD)
-REPO=${PWD##*/} # name of cwd
-BODY="
-$(git log $(git describe --tags --abbrev=0)..HEAD --pretty="- %s" --oneline --decorate)
-"
-USER=PlexSheep
-git tag "v$NEW_VERSION" || echo "could not tag"
-curl -X 'POST' \
-	'https://git.cscherr.de/api/v1/repos/PlexSheep/'$REPO'/releases' \
-	-H 'accept: application/json' \
-	-H "Authorization: token $TOKEN" \
-	-H 'Content-Type: application/json' \
-	-d '{
-  "body": "'"$BODY"'",
-  "draft": false,
-  "name": "v'$NEW_VERSION'",
-  "prerelease": true,
-  "tag_name": "v'$NEW_VERSION'",
-  "target_commitish": "'$GIT_COMMIT_SHA'"
-}' | python -m json.tool
-git push || echo "could not push"

src/game/mod.rs

@@ -349,7 +349,7 @@ impl<'wl, WL: WordList> GameBuilder<'wl, WL> {
     }
 }
 
-impl<'wl, WL: WordList> Display for Game<'wl, WL> {
+impl<WL: WordList> Display for Game<'_, WL> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // TODO: make this actually useful
         // TODO: make this actually fancy

src/game/summary.rs

@@ -6,7 +6,7 @@ pub struct Summary<'wl, WL: WordList> {
     data: Vec<&'wl Game<'wl, WL>>,
 }
 
-impl<'wl, WL: WordList> Default for Summary<'wl, WL> {
+impl<WL: WordList> Default for Summary<'_, WL> {
     fn default() -> Self {
         Self::new()
     }

src/solve/naive/mod.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use libpt::log::{debug, error, info, trace};
 
 use crate::error::{SolverError, WResult};
-use crate::game::evaluation::{Evaluation};
+use crate::game::evaluation::Evaluation;
 use crate::wlist::word::{Word, WordData};
 use crate::wlist::WordList;
 

tests/solver.rs

@@ -1,10 +1,7 @@
 use test_log::test; // set the log level with an envvar: `RUST_LOG=trace cargo test`
 
-use wordle_analyzer::game::evaluation::Evaluation;
-use wordle_analyzer::game::Game;
 use wordle_analyzer::solve::{AnyBuiltinSolver, NaiveSolver, Solver, StupidSolver};
 use wordle_analyzer::wlist::builtin::BuiltinWList;
-use wordle_analyzer::wlist::word::{Word, WordData};
 use wordle_analyzer::wlist::WordList;
 
 fn wordlist() -> impl WordList {
@@ -19,121 +16,3 @@ fn test_build_builtin_solvers() {
     let _naive_solver =
         AnyBuiltinSolver::Naive(NaiveSolver::build(&wl).expect("could not build naive solver"));
 }
-
-#[test]
-fn test_naive_play_predetermined_game() -> anyhow::Result<()> {
-    let wl = wordlist();
-    let sl =
-        AnyBuiltinSolver::Naive(NaiveSolver::build(&wl).expect("could not build naive solver"));
-    let mut game = Game::build(5, false, 6, &wl, false)?;
-    game.set_solution(Some(("nines".into(), 0.002))); // The accuracy is made up but shouldn't
-                                                      // matter
-    sl.make_a_move(&mut game)?;
-    assert_eq!(
-        game.responses().last().unwrap().guess(),
-        &Word::from("which")
-    );
-    sl.make_a_move(&mut game)?;
-    assert_eq!(
-        game.responses().last().unwrap().guess(),
-        &Word::from("their")
-    );
-    sl.make_a_move(&mut game)?;
-    assert_eq!(
-        game.responses().last().unwrap().guess(),
-        &Word::from("being")
-    );
-    sl.make_a_move(&mut game)?;
-    assert_eq!(
-        game.responses().last().unwrap().guess(),
-        &Word::from("since")
-    );
-    sl.make_a_move(&mut game)?;
-    assert_eq!(
-        game.responses().last().unwrap().guess(),
-        &Word::from("lines")
-    );
-    sl.make_a_move(&mut game)?;
-    assert_eq!(
-        game.responses().last().unwrap().guess(),
-        &Word::from("mines")
-    );
-    sl.make_a_move(&mut game)?;
-    assert_eq!(
-        game.responses().last().unwrap().guess(),
-        &Word::from("wines")
-    );
-
-    // naive is at the moment too bad to solve "nines"
-    assert!(game.finished());
-    assert!(!game.won());
-
-    Ok(())
-}
-
-#[test]
-fn test_naive_play_predetermined_game_manually() -> anyhow::Result<()> {
-    let wl = wordlist();
-    let sl =
-        AnyBuiltinSolver::Naive(NaiveSolver::build(&wl).expect("could not build naive solver"));
-    // we don't insert the solution yet,
-    // pretend that a user inputs guesses manually
-    let mut game = Game::build(5, false, 6, &wl, false)?;
-    let _actual_solution: Option<WordData> = Some(("nines".into(), 0.002));
-    let mut next_guess: Word;
-
-    next_guess = sl.guess_for(&game)?;
-    assert_eq!(next_guess, Word::from("which"));
-    game.guess(
-        &next_guess.clone(),
-        Some(Evaluation::build(&next_guess, "xxfxx")?),
-    )?;
-
-    next_guess = sl.guess_for(&game)?;
-    assert_eq!(next_guess, Word::from("their"));
-    game.guess(
-        &next_guess.clone(),
-        Some(Evaluation::build(&next_guess, "xxffx")?),
-    )?;
-
-    next_guess = sl.guess_for(&game)?;
-    assert_eq!(next_guess, Word::from("being"));
-    game.guess(
-        &next_guess.clone(),
-        Some(Evaluation::build(&next_guess, "xfffx")?),
-    )?;
-
-    next_guess = sl.guess_for(&game)?;
-    assert_eq!(next_guess, Word::from("since"));
-    game.guess(
-        &next_guess.clone(),
-        Some(Evaluation::build(&next_guess, "fcfxf")?),
-    )?;
-
-    next_guess = sl.guess_for(&game)?;
-    assert_eq!(next_guess, Word::from("lines"));
-    game.guess(
-        &next_guess.clone(),
-        Some(Evaluation::build(&next_guess, "xcccc")?),
-    )?;
-
-    next_guess = sl.guess_for(&game)?;
-    assert_eq!(next_guess, Word::from("mines"));
-    game.guess(
-        &next_guess.clone(),
-        Some(Evaluation::build(&next_guess, "xcccc")?),
-    )?;
-
-    next_guess = sl.guess_for(&game)?;
-    assert_eq!(next_guess, Word::from("wines"));
-    game.guess(
-        &next_guess.clone(),
-        Some(Evaluation::build(&next_guess, "xcccc")?),
-    )?;
-
-    // naive is at the moment too bad to solve "nines"
-    assert!(game.finished());
-    assert!(!game.won());
-
-    Ok(())
-}