317 lines
11 KiB
Rust
317 lines
11 KiB
Rust
//! Secret-aware presentation state for one storage-owned entry document.
|
|
|
|
use std::{cell::Cell, fmt};
|
|
|
|
use ironstorage::{
|
|
document::{DocumentError, EntryDocument, EntryField},
|
|
repository::SecretBytes,
|
|
};
|
|
|
|
/// Focus and scrolling state for an authenticated document.
|
|
///
|
|
/// The document remains the source of field order, labels, kinds, sensitivity,
|
|
/// and values. This type only tracks transient presentation choices.
|
|
pub struct EntryViewer {
|
|
document: EntryDocument,
|
|
focused: usize,
|
|
scroll: Cell<usize>,
|
|
}
|
|
|
|
impl EntryViewer {
|
|
pub fn new(document: EntryDocument) -> Self {
|
|
Self {
|
|
document,
|
|
focused: 0,
|
|
scroll: Cell::new(0),
|
|
}
|
|
}
|
|
|
|
pub fn document(&self) -> &EntryDocument {
|
|
&self.document
|
|
}
|
|
|
|
pub fn into_document(self) -> EntryDocument {
|
|
self.document
|
|
}
|
|
|
|
pub fn focused_index(&self) -> Option<usize> {
|
|
(!self.document.fields().is_empty()).then_some(self.focused)
|
|
}
|
|
|
|
pub fn focused_field(&self) -> Option<&EntryField> {
|
|
self.document.display_fields().get(self.focused).copied()
|
|
}
|
|
|
|
pub fn focus_next(&mut self) {
|
|
if !self.document.fields().is_empty() {
|
|
self.focused = (self.focused + 1) % self.document.fields().len();
|
|
}
|
|
}
|
|
|
|
pub fn focus_previous(&mut self) {
|
|
if !self.document.fields().is_empty() {
|
|
self.focused = self
|
|
.focused
|
|
.checked_sub(1)
|
|
.unwrap_or(self.document.fields().len() - 1);
|
|
}
|
|
}
|
|
|
|
pub fn copy_focused(&self) -> Result<SecretBytes, DocumentError> {
|
|
let field = self.focused_field().ok_or(DocumentError::InvalidIndex {
|
|
index: self.focused,
|
|
})?;
|
|
self.document.copy_field_value(field.id())
|
|
}
|
|
|
|
pub fn scroll(&self) -> usize {
|
|
self.scroll.get()
|
|
}
|
|
|
|
/// Keep the focused rendered row range inside the supplied viewport while
|
|
/// retaining the current offset whenever it is already visible.
|
|
pub fn ensure_focus_visible(
|
|
&self,
|
|
focused_start: usize,
|
|
focused_height: usize,
|
|
total_rows: usize,
|
|
viewport_rows: usize,
|
|
) -> usize {
|
|
if self.document.fields().is_empty() || total_rows == 0 {
|
|
self.scroll.set(0);
|
|
return 0;
|
|
}
|
|
if viewport_rows == 0 {
|
|
let scroll = self.scroll.get().min(total_rows.saturating_sub(1));
|
|
self.scroll.set(scroll);
|
|
return scroll;
|
|
}
|
|
let maximum = total_rows.saturating_sub(viewport_rows);
|
|
let mut scroll = self.scroll.get().min(maximum);
|
|
let focused_height = focused_height.max(1);
|
|
let focused_end = focused_start.saturating_add(focused_height);
|
|
let viewport_end = scroll.saturating_add(viewport_rows);
|
|
if focused_height > viewport_rows {
|
|
if focused_end <= scroll {
|
|
scroll = focused_end.saturating_sub(1);
|
|
} else if focused_start >= viewport_end {
|
|
scroll = focused_start;
|
|
}
|
|
} else if focused_start < scroll {
|
|
scroll = focused_start;
|
|
} else {
|
|
if focused_end > viewport_end {
|
|
scroll = focused_end.saturating_sub(viewport_rows);
|
|
}
|
|
}
|
|
scroll = scroll.min(maximum);
|
|
self.scroll.set(scroll);
|
|
scroll
|
|
}
|
|
|
|
pub fn scroll_down(&mut self, rows: usize) {
|
|
self.scroll.set(self.scroll.get().saturating_add(rows));
|
|
}
|
|
|
|
pub fn scroll_up(&mut self, rows: usize) {
|
|
self.scroll.set(self.scroll.get().saturating_sub(rows));
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for EntryViewer {
|
|
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
formatter
|
|
.debug_struct("EntryViewer")
|
|
.field("document", &self.document)
|
|
.field("focused", &self.focused)
|
|
.field("scroll", &self.scroll.get())
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) mod test_support {
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use ironstorage::{
|
|
command::GrepRequest,
|
|
crypto::{KeyInfo, KeyStore, SecretProvider, SecretProviderError},
|
|
document::{EntryDocument, EntryDocumentService},
|
|
read::{GrepResults, VaultReader},
|
|
repository::{EntryPath, Repository, SecretBytes},
|
|
};
|
|
use tempfile::TempDir;
|
|
|
|
struct FixtureSecrets;
|
|
|
|
impl SecretProvider for FixtureSecrets {
|
|
fn secret_for(&mut self, key: &KeyInfo) -> Result<SecretBytes, SecretProviderError> {
|
|
let passphrase = match key.fingerprint().as_str() {
|
|
"7E5C5241B25F6FFAAD717EBFA132DCB2DC23AE30" => b"fixture-alice-passphrase".to_vec(),
|
|
"B37027B56FC406BD3F6A622B2AC03492B992D06F" => b"fixture-bob-passphrase".to_vec(),
|
|
_ => return Err(SecretProviderError::Unavailable),
|
|
};
|
|
Ok(SecretBytes::new(passphrase))
|
|
}
|
|
}
|
|
|
|
pub(crate) fn fixture_document(entry: &str) -> EntryDocument {
|
|
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../../crates/storage/tests/fixtures/compatibility");
|
|
fixture_document_from(&root.join("stores/basic"), entry)
|
|
}
|
|
|
|
pub(crate) fn fixture_grep() -> GrepResults {
|
|
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../../crates/storage/tests/fixtures/compatibility");
|
|
let repository = Repository::open(root.join("stores/basic")).expect("fixture repository");
|
|
let keys = KeyStore::load(root.join("keys")).expect("fixture keys");
|
|
VaultReader::new(&repository, &keys)
|
|
.grep(
|
|
&GrepRequest {
|
|
pattern: "alice".to_owned(),
|
|
ignore_case: false,
|
|
invert_match: false,
|
|
line_number: true,
|
|
fixed_strings: true,
|
|
},
|
|
&mut FixtureSecrets,
|
|
)
|
|
.expect("fixture grep")
|
|
}
|
|
|
|
pub(crate) fn fixture_document_from(store: &Path, entry: &str) -> EntryDocument {
|
|
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../../crates/storage/tests/fixtures/compatibility");
|
|
let repository = Repository::open(store).expect("fixture repository");
|
|
let keys = KeyStore::load(root.join("keys")).expect("fixture keys");
|
|
EntryDocumentService::new(&repository, &keys)
|
|
.open(entry, &mut FixtureSecrets)
|
|
.expect("fixture document")
|
|
}
|
|
|
|
pub(crate) fn fixture_document_from_plaintext(
|
|
entry: &str,
|
|
plaintext: &[u8],
|
|
) -> (TempDir, EntryDocument) {
|
|
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../../crates/storage/tests/fixtures/compatibility");
|
|
let store = tempfile::tempdir().expect("temporary fixture store");
|
|
let repository = Repository::open(store.path()).expect("fixture repository");
|
|
let keys = KeyStore::load(root.join("keys")).expect("fixture keys");
|
|
let recipients = keys
|
|
.resolve_recipients(b"7E5C5241B25F6FFAAD717EBFA132DCB2DC23AE30\n")
|
|
.expect("fixture recipient");
|
|
let ciphertext = keys
|
|
.encrypt(SecretBytes::new(plaintext.to_vec()), &recipients)
|
|
.expect("fixture encryption");
|
|
let path = EntryPath::parse(entry).expect("fixture entry path");
|
|
repository
|
|
.write_entry(&path, &ciphertext)
|
|
.expect("fixture entry write");
|
|
let document = EntryDocumentService::new(&repository, &keys)
|
|
.open(entry, &mut FixtureSecrets)
|
|
.expect("fixture document");
|
|
(store, document)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{test_support::fixture_document, *};
|
|
|
|
#[test]
|
|
fn focus_wraps_without_changing_the_authenticated_document() {
|
|
let mut viewer = EntryViewer::new(fixture_document("email/personal"));
|
|
viewer.focus_next();
|
|
assert_eq!(viewer.focused_index(), Some(1));
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.focused_index(), Some(0));
|
|
}
|
|
|
|
#[test]
|
|
fn copy_uses_only_the_focused_structured_value() {
|
|
let viewer = EntryViewer::new(fixture_document("email/personal"));
|
|
let copied = viewer.copy_focused().expect("copy value");
|
|
assert_eq!(copied.expose(), b"alice@example.test");
|
|
assert!(!format!("{viewer:?}").contains("correct horse fixture"));
|
|
}
|
|
|
|
#[test]
|
|
fn scrolling_saturates() {
|
|
let mut viewer = EntryViewer::new(fixture_document("unicode/咖啡"));
|
|
viewer.focus_next();
|
|
viewer.scroll_down(usize::MAX);
|
|
let end = viewer.scroll();
|
|
viewer.scroll_down(1);
|
|
assert_eq!(viewer.scroll(), end);
|
|
viewer.scroll_up(usize::MAX);
|
|
assert_eq!(viewer.scroll(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn focus_only_scrolls_when_it_crosses_a_viewport_edge() {
|
|
let mut viewer = EntryViewer::new(fixture_document("email/personal"));
|
|
assert_eq!(viewer.document().fields().len(), 3);
|
|
|
|
assert_eq!(viewer.ensure_focus_visible(0, 1, 3, 3), 0);
|
|
viewer.focus_next();
|
|
assert_eq!(viewer.ensure_focus_visible(1, 1, 3, 3), 0);
|
|
viewer.focus_next();
|
|
assert_eq!(viewer.ensure_focus_visible(2, 1, 3, 3), 0);
|
|
viewer.focus_next();
|
|
assert_eq!(viewer.ensure_focus_visible(0, 1, 3, 3), 0);
|
|
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.focused_index(), Some(2));
|
|
assert_eq!(viewer.ensure_focus_visible(2, 1, 3, 2), 1);
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.focused_index(), Some(1));
|
|
assert_eq!(viewer.ensure_focus_visible(1, 1, 3, 2), 1);
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.focused_index(), Some(0));
|
|
assert_eq!(viewer.ensure_focus_visible(0, 1, 3, 2), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn viewport_resize_clamps_then_minimally_reveals_the_focus() {
|
|
let mut viewer = EntryViewer::new(fixture_document("email/personal"));
|
|
viewer.focus_next();
|
|
viewer.focus_next();
|
|
assert_eq!(viewer.ensure_focus_visible(2, 1, 3, 1), 2);
|
|
assert_eq!(viewer.ensure_focus_visible(2, 1, 3, 2), 1);
|
|
assert_eq!(viewer.ensure_focus_visible(2, 1, 3, 3), 0);
|
|
assert_eq!(viewer.ensure_focus_visible(2, 1, 3, 1), 2);
|
|
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.ensure_focus_visible(1, 1, 3, 1), 1);
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.ensure_focus_visible(0, 1, 3, 1), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn wrapped_fields_use_rendered_row_ranges_for_minimal_scrolling() {
|
|
let mut viewer = EntryViewer::new(fixture_document("email/personal"));
|
|
viewer.focus_next();
|
|
viewer.focus_next();
|
|
|
|
assert_eq!(viewer.ensure_focus_visible(4, 2, 6, 4), 2);
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.ensure_focus_visible(2, 2, 6, 4), 2);
|
|
viewer.focus_previous();
|
|
assert_eq!(viewer.ensure_focus_visible(0, 2, 6, 4), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn a_field_taller_than_the_viewport_allows_needed_manual_scrolling() {
|
|
let mut viewer = EntryViewer::new(fixture_document("email/personal"));
|
|
viewer.focus_next();
|
|
|
|
assert_eq!(viewer.ensure_focus_visible(1, 5, 7, 3), 0);
|
|
viewer.scroll_down(2);
|
|
assert_eq!(viewer.ensure_focus_visible(1, 5, 7, 3), 2);
|
|
viewer.scroll_down(usize::MAX);
|
|
assert_eq!(viewer.ensure_focus_visible(1, 5, 7, 3), 4);
|
|
}
|
|
}
|