t-rust-less-lib 0.1.11

Password manager library
Documentation 
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

use super::SelectionProvider;
use std::sync::{Arc, RwLock};
use std::time::SystemTime;
use zeroize::Zeroize;

struct LastContext {
  content: String,
  timestamp: SystemTime,
  initial: bool,
}

impl Drop for LastContext {
  fn drop(&mut self) {
    self.content.zeroize();
  }
}

/// Debounce selections.
///
/// Some clients, like a browser that shall not be named (it's from a company start with G),
/// sent up to 4 selection requests to process a single Crtl-V. There seems to be no other way
/// but to debounce these requests by time. I.e. we consider all requests within 200ms to be part
/// of the same paste-action.
///
pub struct SelectionDebounce {
  underlying: Arc<RwLock<dyn SelectionProvider>>,
  last_content: Option<LastContext>,
  startup_timestamp: SystemTime,
}

impl SelectionDebounce {
  pub fn new(underlying: Arc<RwLock<dyn SelectionProvider>>) -> Self {
    SelectionDebounce {
      underlying,
      last_content: None,
      startup_timestamp: SystemTime::now(),
    }
  }
}

impl SelectionProvider for SelectionDebounce {
  fn current_selection_name(&self) -> Option<String> {
    self.underlying.read().ok()?.current_selection_name()
  }

  fn get_selection(&mut self) -> Option<String> {
    let now = SystemTime::now();
    if let Some(last_content) = self.last_content.take() {
      if last_content.initial {
        self.last_content.replace(LastContext {
          content: last_content.content.clone(),
          timestamp: now,
          initial: false,
        });
        return Some(last_content.content.clone());
      }
      if let Ok(elapsed) = now.duration_since(last_content.timestamp) {
        if elapsed.as_millis() < 200 {
          let content = last_content.content.clone();
          self.last_content.replace(last_content);
          return Some(content);
        }
      }
    }

    match self.underlying.write().ok()?.get_selection() {
      Some(content) => {
        let initial = matches!(now.duration_since(self.startup_timestamp), Ok(elapsed) if elapsed.as_millis() < 200);
        self.last_content = Some(LastContext {
          content: content.clone(),
          timestamp: now,
          initial,
        });
        Some(content)
      }
      _ => {
        self.last_content = None;
        None
      }
    }
  }
}