chore: MSRV is 1.88, but we can use nightly rustfmt + clippy

Author: nik-rev

.clippy.toml

@@ -2,3 +2,4 @@ allow-expect-in-tests = true
 allow-unwrap-in-tests = true
 allow-dbg-in-tests = true
 allow-print-in-tests = true
+allow-indexing-slicing-in-tests = true

.rustfmt.toml

@@ -1 +1,30 @@
+# injects `rustfmt` formatter into code blocks in doc comments
+format_code_in_doc_comments = true
+# when blocky items are the last argument to a function, they can overflow
+overflow_delimited_expr = true
+# `Foo { x: x }` => `Foo { x }`
 use_field_init_shorthand = true
+# `let (a, _, _) = ...` => `let (a, ..) => ...`
+condense_wildcard_suffixes = true
+# breaks up long string literals over several lines
+format_strings = true
+# This is the most merge-conflict-friendly option to organize imports
+# each `use` imports a single item
+imports_granularity = "Item"
+# converts `/* */` to `//`
+normalize_comments = true
+# converts `#[doc]` to `///`
+normalize_doc_attributes = true
+# use `0xdeadbeef` and not `0xDEADBEEF`
+hex_literal_case = "Lower"
+# Force multiline closure and match arm bodies to be wrapped in a block
+# 
+# This makes it MUCH easier to then add more statements in the closure/match arm
+force_multiline_blocks = true
+# Comments longer than 80 characters are wrapped to the next line
+wrap_comments = true
+# always format struct, and enum variant with named fields
+# into multiple lines - makes refactoring easier
+struct_variant_width = 0
+# like above, but with literals
+struct_lit_width = 0

Cargo.lock

@@ -7,6 +7,15 @@ homepage = "https://github.com/nik-rev/countryfetch"
 description = "A Command-line tool similar to Neofetch for obtaining information about your country"
 license = "MIT OR Apache-2.0"
 
+# Our MSRV. We use nightly toolchain for better dev experience, but
+# this software must build with at least this version.
+# 
+# More info in the comment in `rust-toolchain.toml`
+rust-version = "1.88"
+
+[lints]
+workspace = true
+
 [workspace]
 members = [".", "generate_country_data"]
 default-members = ["."]
@@ -56,18 +65,6 @@ inherits = "release"
 codegen-units = 1
 lto = true
 
-# ============================
-# 
-#            Lints
-#
-# - strict set of lints for a
-#   more consistent codebase
-#
-# - delegate as much as possible
-#   to automated tooling 
-# 
-# ============================
-
 [workspace.lints.rust]
 # do not import if its already in scope
 # e.g. `use std::option::Option::None`
@@ -80,20 +77,36 @@ unused_qualifications = "warn"
 unused_macro_rules = "warn"
 # lints against e.g. undefined meta variables
 meta_variable_misuse = "warn"
-# all types must `#[derive(Copy)]`
-missing_copy_implementations = "warn"
-# all types must `#[derive(Debug)]`
-missing_debug_implementations = "warn"
 
 [workspace.lints.clippy]
 pedantic = { priority = -1, level = "warn" }
 
+# --- allowed lints
+# 
+# `$a * $b + $c` is slower and less precise than `$a.mul_add($b, $c)`
+# but it is more readable, the gain in speed / precision
+# will be negligible in most situations
+suboptimal_flops = "allow"
+# arbitrary limit imposes unnecessary
+# restriction and can make code harder to follow
+too_many_lines = "allow"
+# if we need it const, make it const.
+# no need to make everything that can be const, const
+missing_const_for_fn = "allow"
+# Too verbose.
+missing_errors_doc = "allow"
+# ---
+
+# We use nightly Rust toolchain but want to guarantee that we
+# can build with a stable Rust compiler.
+#
+# See `rust-toolchain.toml` for more info.
+incompatible_msrv = "deny"
+
 # --- more consistent ways of writing code
 # 
 # `if $a { Some($b) } else { None }` => `$a.then(|| $b)`
 if_then_some_else_none = "warn"
-# `use Trait` => `use Trait as _`
-unused_trait_names = "warn"
 # `foo.rs` => `foo/mod.rs`
 self_named_module_files = "warn"
 # omit `test_` prefix in tests: `fn test_foo` => `fn foo`
@@ -135,6 +148,8 @@ multiple_unsafe_ops_per_block = "warn"
 
 # --- explain more things
 # 
+# `#[allow]` => `#[expect]`
+allow_attributes = "warn"
 # `#[allow]` => `#[allow, reason = "why"]`
 allow_attributes_without_reason = "warn"
 # `unsafe` blocks need a `SAFETY:` comment
@@ -159,34 +174,17 @@ dbg_macro = "warn"
 todo = "warn"
 use_debug = "warn"
 unimplemented = "warn"
-# explicitly `#[allow]` functions to print to stdout
+# must explicitly `#[allow]` functions to print to stdout
 print_stdout = "warn" 
-# explicitly `#[allow]` functions to print to stderr
+# must explicitly `#[allow]` functions to print to stderr
 print_stderr = "warn"
 # ---
 
 # --- prevent bugs
-# new variants added by libraries become errors
-# instead of being silently ignored
-wildcard_enum_match_arm = "warn"
 # if function and trait provide method of same name, it is confusing
 same_name_method = "warn"
 # `create_dir(...)` => `create_dir_all(...)`
 # usually, failing when dir already exists is
 # not what we want
 create_dir = "warn"
 # ---
-
-# --- allowed lints
-# 
-# `$a * $b + $c` is slower and less precise than `$a.mul_add($b, $c)`
-# but it is more readable, the gain in speed / precision
-# will be negligible in most situations
-suboptimal_flops = "allow"
-# arbitrary limit imposes unnecessary
-# restriction and can make code harder to follow
-too_many_lines = "allow"
-# if we need it const, make it const.
-# no need to make everything that can be const, const
-missing_const_for_fn = "allow"
-# ---

Cargo.toml

@@ -32,7 +32,7 @@ reqwest = { version = "0.12", default-features = false, features = [
 futures = "0.3"
 
 # NOTE: This must be the same version as what is required by `rascii_art`
-image = "0.25.6"
+image = "0.24.6"
 
 rayon = "1.11"
 

generate_country_data/Cargo.toml

@@ -1,11 +1,13 @@
 //! Generate the entire Country enum and all methods associated with it
 use core::fmt;
 
-use rayon::iter::{IntoParallelRefIterator as _, ParallelIterator as _};
+use rayon::iter::IntoParallelRefIterator as _;
+use rayon::iter::ParallelIterator as _;
 use strum::IntoEnumIterator as _;
 
 use crate::Country;
-use crate::country_parts::{self, CountryData};
+use crate::country_parts::CountryData;
+use crate::country_parts::{self};
 
 #[derive(strum::EnumIter, strum::Display)]
 #[strum(serialize_all = "snake_case")]
@@ -309,10 +311,8 @@ pub async fn generate_code(countries: &[Country]) -> (String, String) {
     let mut country_enum = Codegen {
         prefix: String::from(
             "// @generated
-#![allow(clippy::all)]
+#![allow(warnings)]
 #![cfg_attr(rustfmt, rustfmt_skip)]
-#![allow(clippy::should_implement_trait)]
-#![allow(clippy::needless_arbitrary_self_type)]
 
 pub mod extras;
 pub use extras::*;

generate_country_data/src/codegen.rs

@@ -1,2 +1,20 @@
-toolchain.channel = "1.88"
-toolchain.components = ["rust-analyzer", "cargo", "rustfmt", "clippy", "rustc"]
+# We use nightly Rust toolchain but set `rust-version` in `Cargo.toml` to
+# a stable release.
+#
+# This allows us to use the latest versions of clippy, rustfmt and rust-analyzer.
+#
+# We can't use `#[feature(..)]` of course, and the `clippy::incompatible_msrv` lint ensures we
+# don't use any Rust features that were stabilized in a later version than `rust-version` set
+# in the `Cargo.toml`.
+#
+# We can use `#[feature(..)]` in tests which is nice - since tests aren't compiled with the main
+# crate so MSRV does not apply to them
+toolchain.channel = "nightly-2025-08-24"
+toolchain.components = [
+  "rust-analyzer",
+  "cargo",
+  "rustfmt",
+  "clippy",
+  "rustc",
+  "rust-src"
+]

rust-toolchain.toml

@@ -1,16 +1,23 @@
-use std::fs::{self, File};
+//! Cache
+
+use std::fs;
+use std::fs::File;
 use std::io::Read as _;
 use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::SystemTime;
+use std::time::UNIX_EPOCH;
 
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+use serde::Serialize;
 
 /// Cache allows us to make less network request at the cost of inacurracy if
 /// the user moves to another country within the `Cache::REFRESH_AFTER_SEC`
 /// period
 #[derive(Serialize, Deserialize)]
 pub struct Cache {
+    /// When was the last time we modified the cache
     modified_time: u64,
+    /// Country code stored
     pub country_code: String,
 }
 
@@ -19,17 +26,20 @@ impl Cache {
     /// it will make another networkr request to the country API to get the
     /// user's current country
     const REFRESH_AFTER_SEC: u64 = 30 * 60;
+    /// The file that we use for cache
     const CACHE_FILE: &str = "countryfetch.json";
 
+    /// If it is outdated
     fn is_outdated(&self) -> bool {
         (SystemTime::now()
             .duration_since(UNIX_EPOCH)
-            .unwrap()
+            .unwrap_or_default()
             .as_secs()
             .saturating_sub(self.modified_time))
             < Self::REFRESH_AFTER_SEC
     }
 
+    /// Returns the file of the cache
     fn cache_file() -> Option<PathBuf> {
         directories::BaseDirs::new().map(|b| b.cache_dir().join(Self::CACHE_FILE))
     }
@@ -47,16 +57,9 @@ impl Cache {
     }
 
     /// Read the cache file if we can find it
-    ///
-    /// # Panics
-    ///
-    /// If the system clock is set to earlier than [`std::time::UNIX_EPOCH`]
     pub fn write(country_code: String) -> Result<(), Box<dyn core::error::Error>> {
         let serialized = serde_json::ser::to_vec(&Self {
-            modified_time: SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_secs(),
+            modified_time: SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs(),
             country_code,
         })?;
 

src/cache.rs

@@ -1,11 +1,17 @@
+//! The command-line interface
+
 use core::error;
 
-use anstyle::{AnsiColor, Effects};
-use clap::{Parser, ValueEnum as _};
+use anstyle::AnsiColor;
+use anstyle::Effects;
+use clap::Parser;
+use clap::ValueEnum as _;
 
+use crate::Country;
+use crate::Location;
 use crate::cache::Cache;
 use crate::country_format::format_country;
-use crate::{Country, Location, generated_country_data};
+use crate::generated_country_data;
 
 /// Styles for the CLI
 const STYLES: clap::builder::Styles = clap::builder::Styles::styled()
@@ -17,13 +23,16 @@ const STYLES: clap::builder::Styles = clap::builder::Styles::styled()
     .valid(AnsiColor::BrightCyan.on_default().effects(Effects::BOLD))
     .invalid(AnsiColor::BrightYellow.on_default().effects(Effects::BOLD));
 
+/// Countryfetch's arguments
 #[derive(Parser, Debug)]
 #[command(version, author = "Nik Revenco", about, long_about = None, styles = STYLES)]
 #[expect(
     clippy::struct_excessive_bools,
     reason = "Clap is expected to have many command line arguments"
 )]
 pub struct Args {
+    /// A list of countries to generate output for. If it's empty, detect the
+    /// country
     #[clap(hide_possible_values = true, ignore_case = true)]
     pub country: Option<Vec<generated_country_data::Country>>,
     /// Print information about all countries
@@ -86,6 +95,7 @@ impl Args {
     /// # Panics
     ///
     /// - Stored invalid 2 letter country code in the cache file
+    #[expect(clippy::print_stdout, reason = "this is where we print the country")]
     pub async fn print(self) -> Result<(), Box<dyn error::Error>> {
         if self.list_countries {
             println!(

src/cli.rs

@@ -1,3 +1,8 @@
+#![allow(
+    clippy::missing_docs_in_private_items,
+    missing_docs,
+    reason = "this just models the JSON API"
+)]
 use std::collections::HashMap;
 
 use serde::Deserialize;
@@ -6,7 +11,9 @@ use serde::Deserialize;
 #[derive(Default, Debug, Clone, PartialEq, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Country {
+    /// Name of the country
     #[serde(rename = "name")]
+    #[expect(clippy::struct_field_names, reason = "this is cleaner")]
     country_name: Name,
     #[serde(default)]
     #[serde(rename = "tld")]
@@ -102,12 +109,15 @@ impl Country {
             .await
     }
 
+    #[must_use]
     pub fn country_name(&self) -> &str {
         &self.country_name.common
     }
+    #[must_use]
     pub fn driving_side(&self) -> &str {
         &self.car.side
     }
+    #[must_use]
     pub fn dialing_code(&self) -> String {
         let codes = self
             .dialing_code