aoc_leaderbot_lib 3.0.0

Support library for aoc_leaderbot, an Advent of Code leaderboard-watching bot
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! Memory-based bot config implementation

use std::any::type_name;

use aoc_leaderboard::aoc::LeaderboardCredentials;
use chrono::{Datelike, Local};
use derive_builder::{Builder, UninitializedFieldError};
use serde::{Deserialize, Serialize};

use crate::leaderbot::Config;

/// Bot config storing values in memory.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Builder)]
#[builder(
    derive(Debug, PartialEq, Eq, Hash),
    build_fn(name = "build_internal", error = "UninitializedFieldError", private)
)]
pub struct MemoryConfig {
    /// Year for which to monitor the leaderboard.
    ///
    /// If not provided, the current year will be used.
    #[builder(default = "Local::now().year()")]
    pub year: i32,

    /// Leaderboard ID.
    ///
    /// See [`Config::leaderboard_id`] for info on this value.
    pub leaderboard_id: u64,

    /// AoC leaderboard credentials.
    ///
    /// See [`Config::credentials`] for info on this value.
    #[builder(setter(into))]
    pub credentials: LeaderboardCredentials,
}

impl MemoryConfig {
    /// Creates a builder to initialize a new instance.
    pub fn builder() -> MemoryConfigBuilder {
        MemoryConfigBuilder::default()
    }

    /// Creates a new instance with values for all fields.
    pub fn new(year: i32, leaderboard_id: u64, credentials: LeaderboardCredentials) -> Self {
        Self { year, leaderboard_id, credentials }
    }
}

impl MemoryConfigBuilder {
    /// Sets the config's [`credentials`] to the given [view key].
    ///
    /// [`credentials`]: MemoryConfig::credentials
    /// [view key]: LeaderboardCredentials::ViewKey
    pub fn view_key<S>(&mut self, view_key: S) -> &mut Self
    where
        S: Into<String>,
    {
        self.credentials = Some(LeaderboardCredentials::ViewKey(view_key.into()));
        self
    }

    /// Sets the config's [`credentials`] to the given [session cookie].
    ///
    /// [`credentials`]: MemoryConfig::credentials
    /// [session cookie]: LeaderboardCredentials::SessionCookie
    pub fn session_cookie<S>(&mut self, session_cookie: S) -> &mut Self
    where
        S: Into<String>,
    {
        self.credentials = Some(LeaderboardCredentials::SessionCookie(session_cookie.into()));
        self
    }

    /// Builds a new [`MemoryConfig`].
    ///
    /// # Errors
    ///
    /// - [`Error::MissingField`]: if a required field was not specified
    ///
    /// [`Error::MissingField`]: crate::error::Error::MissingField
    pub fn build(&self) -> crate::Result<MemoryConfig> {
        match self.build_internal() {
            Ok(config) => Ok(config),
            Err(field_err) => Err(crate::Error::MissingField {
                target: type_name::<MemoryConfig>(),
                field: field_err.field_name(),
            }),
        }
    }
}

impl Config for MemoryConfig {
    #[cfg_attr(not(coverage), tracing::instrument(skip(self), level = "trace", ret))]
    fn year(&self) -> i32 {
        self.year
    }

    #[cfg_attr(not(coverage), tracing::instrument(skip(self), level = "trace", ret))]
    fn leaderboard_id(&self) -> u64 {
        self.leaderboard_id
    }

    #[cfg_attr(not(coverage), tracing::instrument(skip(self), level = "trace", ret))]
    fn credentials(&self) -> LeaderboardCredentials {
        self.credentials.clone()
    }
}