ZacharyZhang-NY/ELY-Browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add page notes panel

Browse Source
This commit is contained in:
ZacharyZhang-NY
2026-05-08 06:53:31 -04:00
parent bae3c7789f
commit 7e68857eb8
15 changed files with 844 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ely_app/src/shell/internal_pages.rs
+2
View File
@@ -6,6 +6,7 @@ mod download_settings;
mod downloads;
mod general;
mod history;
mod notes;
mod plugin_catalog;
mod plugin_details;
mod plugins;
@@ -42,6 +43,7 @@ impl ElyShell {
) -> AnyElement {
match tab.url().as_str() {
"ely://bookmarks" => self.render_bookmarks_page(snapshot, cx),
"ely://notes" => self.render_notes_page(snapshot, cx),
"ely://reading-list" => self.render_reading_list_page(snapshot, cx),
"ely://downloads" => self.render_downloads_page(snapshot, cx),
"ely://history" => self.render_history_page(snapshot, cx),
crates/ely_app/src/shell/internal_pages/notes.rs
+293
View File
@@ -0,0 +1,293 @@
use std::time::{Duration, SystemTime};
use ely_browser_core::BrowserSnapshot;
use ely_design_system::colors;
use ely_domain::NoteEntry;
use gpui::prelude::FluentBuilder;
use gpui::{
AnyElement, Context, InteractiveElement, IntoElement, ParentElement, SharedString,
StatefulInteractiveElement, Styled, div, px, rgb,
};
use gpui_component::{
IconName, Sizable, StyledExt,
button::{Button, ButtonVariants},
scroll::ScrollableElement,
};
use super::{ElyShell, render_canvas_surface};
impl ElyShell {
pub(super) fn render_notes_page(
&mut self,
snapshot: &BrowserSnapshot,
cx: &mut Context<Self>,
) -> AnyElement {
render_canvas_surface(
div()
.size_full()
.p_8()
.flex()
.flex_col()
.gap_5()
.child(render_notes_header(snapshot))
.child(self.render_note_entries(snapshot, cx)),
)
}
fn render_note_entries(
&mut self,
snapshot: &BrowserSnapshot,
cx: &mut Context<Self>,
) -> AnyElement {
if snapshot.notes.is_empty() {
return div()
.flex_1()
.border_t_1()
.border_color(rgb(colors::HAIRLINE))
.pt_5()
.text_sm()
.text_color(rgb(colors::MUTED))
.child("Notes are empty for this Profile.")
.into_any_element();
}
div()
.flex_1()
.min_h_0()
.flex()
.flex_col()
.overflow_y_scrollbar()
.border_t_1()
.border_color(rgb(colors::HAIRLINE))
.children(
snapshot
.notes
.iter()
.rev()
.enumerate()
.map(|(index, note)| self.render_note_row(index, snapshot, note, cx)),
)
.into_any_element()
}
fn render_note_row(
&mut self,
index: usize,
snapshot: &BrowserSnapshot,
note: &NoteEntry,
cx: &mut Context<Self>,
) -> AnyElement {
let url = note.source_url().clone();
let open_url = note.source_url().clone();
let space_name = note_space_name(snapshot, note);
div()
.id(SharedString::from(format!("note-{}", note.id().as_str())))
.py_3()
.border_b_1()
.border_color(rgb(colors::HAIRLINE))
.flex()
.items_center()
.justify_between()
.gap_4()
.child(
div()
.id(SharedString::from(format!("note-open-{}", note.id().as_str())))
.min_w_0()
.flex_1()
.flex()
.items_center()
.gap_3()
.cursor_pointer()
.hover(|style| style.bg(rgb(colors::CANVAS_SOFT)))
.active(|style| style.opacity(0.82))
.on_click(cx.listener(move |shell, _, window, cx| {
shell.open_url(url.clone(), window, cx);
}))
.child(div().text_color(rgb(colors::MUTED_SOFT)).child(IconName::File))
.child(
div()
.min_w_0()
.flex()
.flex_col()
.gap_1()
.child(
div()
.text_sm()
.font_semibold()
.truncate()
.text_color(rgb(colors::INK))
.child(note.title().to_string()),
)
.child(
div()
.text_xs()
.truncate()
.text_color(rgb(colors::MUTED))
.child(note.display_url()),
)
.child(
div()
.text_xs()
.truncate()
.text_color(rgb(colors::MUTED_SOFT))
.child(markdown_preview(note.body())),
),
),
)
.child(
div()
.max_w(px(260.0))
.flex()
.items_center()
.justify_end()
.gap_2()
.text_xs()
.font_semibold()
.text_color(rgb(colors::MUTED))
.when_some(space_name, |this, space_name| {
this.child(div().max_w(px(110.0)).truncate().child(space_name))
})
.child(note.target_label())
.child(updated_at_label(note.updated_at())),
)
.child(
Button::new(("open-note-source", index))
.ghost()
.xsmall()
.label("Open")
.tooltip("Open Note Source")
.on_click(cx.listener(move |shell, _, window, cx| {
shell.open_url(open_url.clone(), window, cx);
})),
)
.into_any_element()
}
}
fn render_notes_header(snapshot: &BrowserSnapshot) -> AnyElement {
div()
.flex()
.items_end()
.justify_between()
.child(
div()
.flex()
.flex_col()
.gap_2()
.child(div().text_size(px(26.0)).text_color(rgb(colors::INK)).child("Notes"))
.child(
div()
.text_sm()
.text_color(rgb(colors::MUTED))
.child(format!("Profile: {}", snapshot.active_profile_name)),
),
)
.child(
div()
.text_xs()
.text_color(rgb(colors::MUTED))
.child(notes_count_label(snapshot.notes.len())),
)
.into_any_element()
}
fn note_space_name(snapshot: &BrowserSnapshot, note: &NoteEntry) -> Option<String> {
snapshot
.spaces
.iter()
.find(|space| space.id() == note.space_id())
.map(|space| space.name().to_string())
}
fn notes_count_label(count: usize) -> String {
match count {
1 => "1 note".to_string(),
count => format!("{count} notes"),
}
}
fn markdown_preview(body: &str) -> String {
let preview = body
.lines()
.find_map(|line| {
let trimmed = line.trim();
(!trimmed.is_empty()).then_some(trimmed)
})
.unwrap_or(body.trim());
truncate_chars(preview, 120)
}
fn truncate_chars(value: &str, limit: usize) -> String {
let mut chars = value.chars();
let truncated: String = chars.by_ref().take(limit).collect();
if chars.next().is_some() { format!("{truncated}...") } else { truncated }
}
fn updated_at_label(updated_at: SystemTime) -> String {
updated_at_label_for(updated_at, SystemTime::now())
}
fn updated_at_label_for(updated_at: SystemTime, now: SystemTime) -> String {
let age = now.duration_since(updated_at).unwrap_or(Duration::ZERO);
if age < Duration::from_secs(60) {
return "Updated just now".to_string();
}
if age < Duration::from_secs(3_600) {
return format!("Updated {} mins ago", age.as_secs() / 60);
}
if age < Duration::from_secs(86_400) {
return format!("Updated {} hrs ago", age.as_secs() / 3_600);
}
if age < Duration::from_secs(604_800) {
return format!("Updated {} days ago", age.as_secs() / 86_400);
}
"Updated earlier".to_string()
}
#[cfg(test)]
mod tests {
use std::time::{Duration, SystemTime};
use super::{markdown_preview, updated_at_label_for};
#[test]
fn markdown_preview_uses_first_non_empty_line() {
assert_eq!(markdown_preview("\n # Heading\n- detail"), "# Heading");
}
#[test]
fn markdown_preview_truncates_long_lines() {
let preview = markdown_preview(&"a".repeat(130));
assert_eq!(preview.len(), 123);
assert!(preview.ends_with("..."));
}
#[test]
fn updated_at_label_formats_recent_entries() {
let now = SystemTime::UNIX_EPOCH + Duration::from_secs(10_000);
assert_eq!(updated_at_label_for(now - Duration::from_secs(20), now), "Updated just now");
}
#[test]
fn updated_at_label_formats_minutes_hours_days_and_older_entries() {
let now = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
assert_eq!(updated_at_label_for(now - Duration::from_secs(120), now), "Updated 2 mins ago");
assert_eq!(
updated_at_label_for(now - Duration::from_secs(10_800), now),
"Updated 3 hrs ago"
);
assert_eq!(
updated_at_label_for(now - Duration::from_secs(345_600), now),
"Updated 4 days ago"
);
assert_eq!(
updated_at_label_for(now - Duration::from_secs(691_200), now),
"Updated earlier"
);
}
}
crates/ely_app/src/shell/internal_pages/sync.rs
+1
View File
@@ -216,6 +216,7 @@ fn sync_object_kind_label(kind: SyncObjectKind) -> &'static str {
SyncObjectKind::Spaces => "Spaces",
SyncObjectKind::Tabs => "Tabs",
SyncObjectKind::Bookmarks => "Bookmarks",
SyncObjectKind::Notes => "Notes",
SyncObjectKind::ReadingList => "Reading List",
SyncObjectKind::Profiles => "Profiles",
SyncObjectKind::SitePermissions => "Site permissions",
crates/ely_browser_core/src/navigation.rs
+13
View File
@@ -17,6 +17,7 @@ fn internal_page_title(url: &str) -> Option<&'static str> {
match url {
"ely://new-tab" => Some("New Tab"),
"ely://bookmarks" => Some("Bookmarks"),
"ely://notes" => Some("Notes"),
"ely://reading-list" => Some("Reading List"),
"ely://downloads" => Some("Downloads"),
"ely://history" => Some("History"),
@@ -91,6 +92,14 @@ pub(crate) fn reading_progress_percent(
ReadingProgressPercent::new(percent).map(Some).map_err(CoreError::from)
}
pub(crate) fn note_body(command: &str) -> Option<&str> {
command_argument(command, &["note ", "add-note ", "add note "])
}
pub(crate) fn tab_note_body(command: &str) -> Option<&str> {
command_argument(command, &["tab-note ", "tab note ", "note-tab ", "note tab "])
}
pub(crate) fn new_profile_name(command: &str) -> Option<&str> {
command_argument(command, &["new-profile ", "new profile "])
}
@@ -134,6 +143,10 @@ pub(crate) fn reading_list_url() -> Result<UrlText, CoreError> {
internal_page_url("ely://reading-list")
}
pub(crate) fn notes_url() -> Result<UrlText, CoreError> {
internal_page_url("ely://notes")
}
pub(crate) fn history_url() -> Result<UrlText, CoreError> {
internal_page_url("ely://history")
}
crates/ely_browser_core/src/state.rs
+8 -2
View File
@@ -3,8 +3,9 @@ use std::{collections::BTreeMap, time::SystemTime};
use ely_domain::{
ArchivePolicy, ArchivedTab, BookmarkEntry, BrowserTab, DomainError, DownloadEntry,
DownloadPolicy, FavoriteLimit, HistoryEntry, HistoryRecordingPolicy, NewTabDestination,
Profile, ProfileId, ProfileKind, ReadingListEntry, SearchEngine, SitePermissionAuditEvent,
SitePermissionEntry, Space, SpaceId, SplitLayout, SyncStatus, TabId, UrlText,
NoteEntry, Profile, ProfileId, ProfileKind, ReadingListEntry, SearchEngine,
SitePermissionAuditEvent, SitePermissionEntry, Space, SpaceId, SplitLayout, SyncStatus, TabId,
UrlText,
};
use crate::{CoreError, navigation::tab_title};
@@ -14,6 +15,7 @@ mod bookmarks;
mod commands;
mod downloads;
mod history;
mod notes;
mod plugins;
mod profiles;
mod reading_list;
@@ -51,6 +53,7 @@ pub struct BrowserSnapshot {
pub pinned_tabs: Vec<BrowserTab>,
pub archived_tabs: Vec<ArchivedTab>,
pub bookmarks: Vec<BookmarkEntry>,
pub notes: Vec<NoteEntry>,
pub reading_list: Vec<ReadingListEntry>,
pub site_permissions: Vec<SitePermissionEntry>,
pub site_permission_audit_events: Vec<SitePermissionAuditEvent>,
@@ -83,6 +86,7 @@ pub struct BrowserCore {
tabs: Vec<BrowserTab>,
archived_tabs: Vec<ArchivedTab>,
bookmarks: Vec<BookmarkEntry>,
notes: Vec<NoteEntry>,
reading_list: Vec<ReadingListEntry>,
site_permissions: Vec<SitePermissionEntry>,
site_permission_audit_events: Vec<SitePermissionAuditEvent>,
@@ -151,6 +155,7 @@ impl BrowserCore {
tabs: vec![tab],
archived_tabs: Vec::new(),
bookmarks: Vec::new(),
notes: Vec::new(),
reading_list: Vec::new(),
site_permissions: Vec::new(),
site_permission_audit_events: Vec::new(),
@@ -342,6 +347,7 @@ impl BrowserCore {
pinned_tabs: self.pinned_tabs(),
archived_tabs: self.archived_tabs.clone(),
bookmarks: self.visible_bookmarks(),
notes: self.visible_notes(),
reading_list: self.visible_reading_list(),
site_permissions: self.visible_site_permissions(),
site_permission_audit_events: self.visible_site_permission_audit_events(),
crates/ely_browser_core/src/state/commands.rs
+22 -4
View File
@@ -6,10 +6,10 @@ use crate::{
CoreError,
navigation::{
about_url, archive_idle_days, archive_url, bookmarks_url, downloads_url, history_url,
move_tab_space_name, new_private_profile_name, new_profile_name, new_space_name,
plugin_detail_url, plugins_url, reading_list_url, reading_progress_percent, search_url,
settings_page_url, settings_url, shortcut_settings_url, space_icon, switch_profile_name,
sync_status_url, task_manager_url,
move_tab_space_name, new_private_profile_name, new_profile_name, new_space_name, note_body,
notes_url, plugin_detail_url, plugins_url, reading_list_url, reading_progress_percent,
search_url, settings_page_url, settings_url, shortcut_settings_url, space_icon,
switch_profile_name, sync_status_url, tab_note_body, task_manager_url,
},
};
@@ -61,6 +61,12 @@ impl BrowserCore {
self.command_query.clear();
}
}
CommandIntent::ScopedSearch { scope: CommandScope::Notes, query } => {
if let Some(url) = self.find_note_match(query) {
self.open_tab(url);
self.command_query.clear();
}
}
CommandIntent::ScopedSearch { scope: CommandScope::ReadingList, query } => {
if let Some(url) = self.find_reading_list_match(query) {
self.open_tab(url);
@@ -127,6 +133,14 @@ impl BrowserCore {
self.set_active_tab_reading_progress(percent)?;
return Ok(true);
}
if let Some(body) = tab_note_body(command) {
self.save_active_tab_note(body)?;
return Ok(true);
}
if let Some(body) = note_body(command) {
self.save_active_url_note(body)?;
return Ok(true);
}
match command.to_ascii_lowercase().as_str() {
"new-tab" => {
@@ -150,6 +164,10 @@ impl BrowserCore {
self.open_tab(reading_list_url()?);
Ok(true)
}
"notes" | "open-notes" | "open notes" => {
self.open_tab(notes_url()?);
Ok(true)
}
"history" | "open-history" | "open history" => {
self.open_tab(history_url()?);
Ok(true)
crates/ely_browser_core/src/state/notes.rs
+114
View File
@@ -0,0 +1,114 @@
use std::time::SystemTime;
use ely_domain::{NoteEntry, NoteId, NoteTarget, UrlText};
use crate::CoreError;
use super::BrowserCore;
impl BrowserCore {
pub fn save_active_url_note(&mut self, body: impl Into<String>) -> Result<NoteId, CoreError> {
let active_tab = self.active_tab()?.clone();
let now = SystemTime::now();
let target = NoteTarget::Url(active_tab.url().clone());
if let Some(index) = self.note_index_for_target(active_tab.profile_id(), &target) {
self.notes[index].update(
active_tab.title(),
active_tab.url().clone(),
body.into(),
now,
)?;
return Ok(self.notes[index].id().clone());
}
let entry = NoteEntry::new(
active_tab.profile_id().clone(),
active_tab.space_id().clone(),
target,
active_tab.title(),
active_tab.url().clone(),
body,
now,
)?;
let entry_id = entry.id().clone();
self.notes.push(entry);
Ok(entry_id)
}
pub fn save_active_tab_note(&mut self, body: impl Into<String>) -> Result<NoteId, CoreError> {
let active_tab = self.active_tab()?.clone();
let now = SystemTime::now();
let target = NoteTarget::Tab(active_tab.id().clone());
if let Some(index) = self.note_index_for_target(active_tab.profile_id(), &target) {
self.notes[index].update(
active_tab.title(),
active_tab.url().clone(),
body.into(),
now,
)?;
return Ok(self.notes[index].id().clone());
}
let entry = NoteEntry::new(
active_tab.profile_id().clone(),
active_tab.space_id().clone(),
target,
active_tab.title(),
active_tab.url().clone(),
body,
now,
)?;
let entry_id = entry.id().clone();
self.notes.push(entry);
Ok(entry_id)
}
pub(super) fn find_note_match(&self, query: &str) -> Option<UrlText> {
let normalized_query = query.trim().to_lowercase();
if normalized_query.is_empty() {
return None;
}
self.notes
.iter()
.rev()
.filter(|entry| entry.profile_id() == &self.active_profile_id)
.find(|entry| note_entry_matches_query(entry, &normalized_query))
.map(|entry| entry.source_url().clone())
}
pub(super) fn visible_notes(&self) -> Vec<NoteEntry> {
self.notes
.iter()
.filter(|entry| entry.profile_id() == &self.active_profile_id)
.cloned()
.collect()
}
fn note_index_for_target(
&self,
profile_id: &ely_domain::ProfileId,
target: &NoteTarget,
) -> Option<usize> {
self.notes.iter().position(|entry| {
entry.profile_id() == profile_id && note_targets_match(entry.target(), target)
})
}
}
fn note_targets_match(left: &NoteTarget, right: &NoteTarget) -> bool {
match (left, right) {
(NoteTarget::Url(left_url), NoteTarget::Url(right_url)) => left_url == right_url,
(NoteTarget::Tab(left_tab), NoteTarget::Tab(right_tab)) => left_tab == right_tab,
_ => false,
}
}
fn note_entry_matches_query(entry: &NoteEntry, normalized_query: &str) -> bool {
entry.title().to_lowercase().contains(normalized_query)
|| entry.source_url().as_str().to_lowercase().contains(normalized_query)
|| entry.display_url().to_lowercase().contains(normalized_query)
|| entry.body().to_lowercase().contains(normalized_query)
}
crates/ely_browser_core/src/state/sync.rs
+9
View File
@@ -7,6 +7,7 @@ pub(super) struct SyncObjectPolicies {
spaces: SyncObjectPolicy,
tabs: SyncObjectPolicy,
bookmarks: SyncObjectPolicy,
notes: SyncObjectPolicy,
reading_list: SyncObjectPolicy,
profiles: SyncObjectPolicy,
site_permissions: SyncObjectPolicy,
@@ -20,6 +21,7 @@ impl Default for SyncObjectPolicies {
spaces: SyncObjectPolicy::Enabled,
tabs: SyncObjectPolicy::Enabled,
bookmarks: SyncObjectPolicy::Enabled,
notes: SyncObjectPolicy::Enabled,
reading_list: SyncObjectPolicy::Enabled,
profiles: SyncObjectPolicy::Enabled,
site_permissions: SyncObjectPolicy::Enabled,
@@ -35,6 +37,7 @@ impl SyncObjectPolicies {
SyncObjectKind::Spaces => self.spaces,
SyncObjectKind::Tabs => self.tabs,
SyncObjectKind::Bookmarks => self.bookmarks,
SyncObjectKind::Notes => self.notes,
SyncObjectKind::ReadingList => self.reading_list,
SyncObjectKind::Profiles => self.profiles,
SyncObjectKind::SitePermissions => self.site_permissions,
@@ -48,6 +51,7 @@ impl SyncObjectPolicies {
SyncObjectKind::Spaces => self.spaces = policy,
SyncObjectKind::Tabs => self.tabs = policy,
SyncObjectKind::Bookmarks => self.bookmarks = policy,
SyncObjectKind::Notes => self.notes = policy,
SyncObjectKind::ReadingList => self.reading_list = policy,
SyncObjectKind::Profiles => self.profiles = policy,
SyncObjectKind::SitePermissions => self.site_permissions = policy,
@@ -84,6 +88,11 @@ impl BrowserCore {
self.bookmarks.len(),
SyncObjectState::LocalOnly,
),
self.sync_object_status(
SyncObjectKind::Notes,
self.notes.len(),
SyncObjectState::LocalOnly,
),
self.sync_object_status(
SyncObjectKind::ReadingList,
self.reading_list.len(),
crates/ely_browser_core/tests/notes.rs
+145
View File
@@ -0,0 +1,145 @@
use std::error::Error;
use ely_browser_core::{BrowserCore, InitialBrowserConfig};
use ely_domain::{CommandIntent, CommandScope, NoteTarget, ProfileKind, UrlText};
#[test]
fn url_note_records_active_page_context() -> Result<(), Box<dyn Error>> {
let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
let tab_id = core.open_tab(UrlText::parse("https://example.com/notes-url")?);
let active_profile_id = core.active_tab()?.profile_id().clone();
let active_space_id = core.active_tab()?.space_id().clone();
let note_id = core.save_active_url_note("# Research\n- fact")?;
let snapshot = core.snapshot()?;
let [note] = snapshot.notes.as_slice() else {
return Err(format!("expected 1 note, got {}", snapshot.notes.len()).into());
};
assert_eq!(snapshot.active_tab_id, tab_id);
assert_eq!(note.id(), &note_id);
assert_eq!(note.profile_id(), &active_profile_id);
assert_eq!(note.space_id(), &active_space_id);
assert_eq!(note.target(), &NoteTarget::Url(UrlText::parse("https://example.com/notes-url")?));
assert_eq!(note.title(), "example.com");
assert_eq!(note.body(), "# Research\n- fact");
Ok(())
}
#[test]
fn tab_note_records_tab_target() -> Result<(), Box<dyn Error>> {
let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
let tab_id = core.open_tab(UrlText::parse("https://example.com/tab-note")?);
core.save_active_tab_note("- tab detail")?;
let snapshot = core.snapshot()?;
let [note] = snapshot.notes.as_slice() else {
return Err(format!("expected 1 note, got {}", snapshot.notes.len()).into());
};
assert_eq!(note.target(), &NoteTarget::Tab(tab_id));
assert_eq!(note.target_label(), "Tab note");
assert_eq!(note.source_url().as_str(), "https://example.com/tab-note");
Ok(())
}
#[test]
fn url_note_command_updates_existing_note() -> Result<(), Box<dyn Error>> {
let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
core.open_tab(UrlText::parse("https://example.com/research")?);
core.set_command_query(">note first");
core.submit_command()?;
core.set_command_query(">note second");
let intent = core.submit_command()?;
let snapshot = core.snapshot()?;
assert_eq!(intent, Some(CommandIntent::Command("note second".to_string())));
assert_eq!(snapshot.command_query, "");
assert_eq!(snapshot.notes.len(), 1);
assert_eq!(snapshot.notes[0].body(), "second");
Ok(())
}
#[test]
fn tab_note_command_records_tab_target() -> Result<(), Box<dyn Error>> {
let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
let tab_id = core.open_tab(UrlText::parse("https://example.com/pinned-detail")?);
core.set_command_query(">tab-note - pinned detail");
let intent = core.submit_command()?;
let snapshot = core.snapshot()?;
assert_eq!(intent, Some(CommandIntent::Command("tab-note - pinned detail".to_string())));
assert_eq!(snapshot.command_query, "");
assert_eq!(snapshot.notes.len(), 1);
assert_eq!(snapshot.notes[0].target(), &NoteTarget::Tab(tab_id));
assert_eq!(snapshot.notes[0].body(), "- pinned detail");
Ok(())
}
#[test]
fn notes_scoped_search_opens_matching_note_url() -> Result<(), Box<dyn Error>> {
let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
core.open_tab(UrlText::parse("https://example.com/matching-note")?);
core.save_active_url_note("# Citation\nunique cue")?;
core.open_tab(UrlText::parse("https://example.com/other")?);
core.set_command_query("@notes unique cue");
let intent = core.submit_command()?;
let snapshot = core.snapshot()?;
assert_eq!(
intent,
Some(CommandIntent::ScopedSearch {
scope: CommandScope::Notes,
query: "unique cue".to_string()
})
);
assert_eq!(core.active_tab()?.url().as_str(), "https://example.com/matching-note");
assert_eq!(snapshot.command_query, "");
Ok(())
}
#[test]
fn notes_stay_with_active_profile() -> Result<(), Box<dyn Error>> {
let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
let default_profile_id = core.active_tab()?.profile_id().clone();
let personal_profile_id = core.create_profile("Personal", 0xf54e00, ProfileKind::Standard)?;
core.open_tab(UrlText::parse("https://example.com/personal-note")?);
core.save_active_url_note("private cue")?;
core.select_profile(&default_profile_id)?;
core.set_command_query("@notes private cue");
let intent = core.submit_command()?;
let snapshot = core.snapshot()?;
assert_eq!(
intent,
Some(CommandIntent::ScopedSearch {
scope: CommandScope::Notes,
query: "private cue".to_string()
})
);
assert_eq!(core.active_tab()?.profile_id(), &default_profile_id);
assert_ne!(core.active_tab()?.profile_id(), &personal_profile_id);
assert!(snapshot.notes.is_empty());
assert_eq!(snapshot.command_query, "@notes private cue");
Ok(())
}
#[test]
fn open_notes_command_opens_notes_page() -> Result<(), Box<dyn Error>> {
let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
core.set_command_query(">open-notes");
let intent = core.submit_command()?;
let active_tab = core.active_tab()?;
assert_eq!(intent, Some(CommandIntent::Command("open-notes".to_string())));
assert_eq!(active_tab.title(), "Notes");
assert_eq!(active_tab.url().as_str(), "ely://notes");
assert_eq!(core.snapshot()?.command_query, "");
Ok(())
}
crates/ely_browser_core/tests/sync.rs
+2
View File
@@ -12,6 +12,7 @@ fn default_sync_status_reflects_local_browser_state() -> Result<(), Box<dyn Erro
core.create_space("Research", "R", 0xf54e00)?;
core.open_tab(UrlText::parse("https://example.com/research")?);
core.bookmark_active_tab()?;
core.save_active_url_note("sync note")?;
core.save_active_tab_to_reading_list()?;
let snapshot = core.snapshot()?;
@@ -26,6 +27,7 @@ fn default_sync_status_reflects_local_browser_state() -> Result<(), Box<dyn Erro
SyncObjectStatus::new(SyncObjectKind::Spaces, 2, SyncObjectState::LocalOnly),
SyncObjectStatus::new(SyncObjectKind::Tabs, 3, SyncObjectState::LocalOnly),
SyncObjectStatus::new(SyncObjectKind::Bookmarks, 1, SyncObjectState::LocalOnly),
SyncObjectStatus::new(SyncObjectKind::Notes, 1, SyncObjectState::LocalOnly),
SyncObjectStatus::new(SyncObjectKind::ReadingList, 1, SyncObjectState::LocalOnly),
SyncObjectStatus::new(SyncObjectKind::Profiles, 1, SyncObjectState::LocalOnly),
SyncObjectStatus::new(SyncObjectKind::SitePermissions, 0, SyncObjectState::LocalOnly),
crates/ely_domain/src/command.rs
+2
View File
@@ -6,6 +6,7 @@ pub enum CommandScope {
Spaces,
Tabs,
Bookmarks,
Notes,
ReadingList,
History,
Settings,
@@ -50,6 +51,7 @@ fn parse_scope(value: &str) -> Option<(CommandScope, &str)> {
"@spaces" => CommandScope::Spaces,
"@tabs" => CommandScope::Tabs,
"@bookmarks" => CommandScope::Bookmarks,
"@notes" => CommandScope::Notes,
"@reading-list" | "@reading" => CommandScope::ReadingList,
"@history" => CommandScope::History,
"@settings" => CommandScope::Settings,
crates/ely_domain/src/identifiers.rs
+1
View File
@@ -41,3 +41,4 @@ entity_id!(WebViewId, "webview");
entity_id!(DownloadId, "download");
entity_id!(BookmarkId, "bookmark");
entity_id!(ReadingListId, "reading");
entity_id!(NoteId, "note");
crates/ely_domain/src/lib.rs
+3 -1
View File
@@ -7,6 +7,7 @@ mod favorite;
mod history;
mod identifiers;
mod new_tab;
mod note;
mod plugin;
mod privacy;
mod profile;
@@ -30,9 +31,10 @@ pub use error::DomainError;
pub use favorite::FavoriteLimit;
pub use history::HistoryEntry;
pub use identifiers::{
BookmarkId, DownloadId, ProfileId, ReadingListId, SpaceId, SplitId, TabId, WebViewId,
BookmarkId, DownloadId, NoteId, ProfileId, ReadingListId, SpaceId, SplitId, TabId, WebViewId,
};
pub use new_tab::NewTabDestination;
pub use note::{NoteEntry, NoteTarget};
pub use plugin::{
PluginContributionPoint, PluginId, PluginManifest, PluginPermission, PluginPermissionRisk,
PluginSignature, PluginSignatureAlgorithm,
crates/ely_domain/src/note.rs
+228
View File
@@ -0,0 +1,228 @@
use std::time::SystemTime;
use crate::{DomainError, NoteId, ProfileId, SpaceId, TabId, UrlText};
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum NoteTarget {
Url(UrlText),
Tab(TabId),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct NoteEntry {
id: NoteId,
profile_id: ProfileId,
space_id: SpaceId,
target: NoteTarget,
title: String,
source_url: UrlText,
body: String,
created_at: SystemTime,
updated_at: SystemTime,
}
impl NoteEntry {
pub fn new(
profile_id: ProfileId,
space_id: SpaceId,
target: NoteTarget,
title: impl Into<String>,
source_url: UrlText,
body: impl Into<String>,
now: SystemTime,
) -> Result<Self, DomainError> {
let title = non_empty_text("note title", title.into())?;
let body = normalize_body(body.into())?;
Ok(Self {
id: NoteId::new(),
profile_id,
space_id,
target,
title,
source_url,
body,
created_at: now,
updated_at: now,
})
}
#[must_use]
pub fn id(&self) -> &NoteId {
&self.id
}
#[must_use]
pub fn profile_id(&self) -> &ProfileId {
&self.profile_id
}
#[must_use]
pub fn space_id(&self) -> &SpaceId {
&self.space_id
}
#[must_use]
pub fn target(&self) -> &NoteTarget {
&self.target
}
#[must_use]
pub fn target_label(&self) -> &'static str {
match &self.target {
NoteTarget::Url(_) => "URL note",
NoteTarget::Tab(_) => "Tab note",
}
}
#[must_use]
pub fn title(&self) -> &str {
&self.title
}
#[must_use]
pub fn source_url(&self) -> &UrlText {
&self.source_url
}
#[must_use]
pub fn display_url(&self) -> String {
self.source_url.display_url()
}
#[must_use]
pub fn body(&self) -> &str {
&self.body
}
#[must_use]
pub fn created_at(&self) -> SystemTime {
self.created_at
}
#[must_use]
pub fn updated_at(&self) -> SystemTime {
self.updated_at
}
pub fn update(
&mut self,
title: impl Into<String>,
source_url: UrlText,
body: impl Into<String>,
updated_at: SystemTime,
) -> Result<(), DomainError> {
self.title = non_empty_text("note title", title.into())?;
self.source_url = source_url;
self.body = normalize_body(body.into())?;
self.updated_at = updated_at;
Ok(())
}
}
fn normalize_body(value: String) -> Result<String, DomainError> {
let normalized = value.replace("\r\n", "\n").replace('\r', "\n");
non_empty_text("note body", normalized)
}
fn non_empty_text(field: &'static str, value: String) -> Result<String, DomainError> {
let trimmed = value.trim();
if trimmed.is_empty() {
return Err(DomainError::EmptyField { field });
}
Ok(trimmed.to_string())
}
#[cfg(test)]
mod tests {
use std::time::{Duration, SystemTime};
use super::{NoteEntry, NoteTarget};
use crate::{DomainError, ProfileId, SpaceId, TabId, UrlText};
#[test]
fn creates_url_note_with_markdown_body() -> Result<(), DomainError> {
let now = SystemTime::UNIX_EPOCH + Duration::from_secs(10);
let source_url = UrlText::parse("https://example.com/article")?;
let note = NoteEntry::new(
ProfileId::new(),
SpaceId::new(),
NoteTarget::Url(source_url.clone()),
"Example",
source_url,
" # Heading\r\n- item ",
now,
)?;
assert_eq!(note.title(), "Example");
assert_eq!(note.body(), "# Heading\n- item");
assert_eq!(note.target_label(), "URL note");
assert_eq!(note.created_at(), now);
assert_eq!(note.updated_at(), now);
Ok(())
}
#[test]
fn creates_tab_note_target() -> Result<(), DomainError> {
let tab_id = TabId::new();
let note = NoteEntry::new(
ProfileId::new(),
SpaceId::new(),
NoteTarget::Tab(tab_id.clone()),
"Example",
UrlText::parse("https://example.com/tab")?,
"- detail",
SystemTime::UNIX_EPOCH,
)?;
assert_eq!(note.target(), &NoteTarget::Tab(tab_id));
assert_eq!(note.target_label(), "Tab note");
Ok(())
}
#[test]
fn rejects_empty_body() -> Result<(), DomainError> {
let source_url = UrlText::parse("https://example.com")?;
let result = NoteEntry::new(
ProfileId::new(),
SpaceId::new(),
NoteTarget::Url(source_url.clone()),
"Example",
source_url,
" ",
SystemTime::UNIX_EPOCH,
);
assert_eq!(result, Err(DomainError::EmptyField { field: "note body" }));
Ok(())
}
#[test]
fn updates_body_and_timestamp() -> Result<(), DomainError> {
let created_at = SystemTime::UNIX_EPOCH + Duration::from_secs(10);
let updated_at = created_at + Duration::from_secs(30);
let mut note = NoteEntry::new(
ProfileId::new(),
SpaceId::new(),
NoteTarget::Url(UrlText::parse("https://example.com/old")?),
"Old",
UrlText::parse("https://example.com/old")?,
"first",
created_at,
)?;
note.update(
"New",
UrlText::parse("https://example.com/new")?,
" second\rline ",
updated_at,
)?;
assert_eq!(note.title(), "New");
assert_eq!(note.source_url().as_str(), "https://example.com/new");
assert_eq!(note.body(), "second\nline");
assert_eq!(note.created_at(), created_at);
assert_eq!(note.updated_at(), updated_at);
Ok(())
}
}
crates/ely_domain/src/sync.rs
+1
View File
@@ -8,6 +8,7 @@ pub enum SyncObjectKind {
Spaces,
Tabs,
Bookmarks,
Notes,
ReadingList,
Profiles,
SitePermissions,