{
+ let state = window.use_state(cx, |_, _| WindowDragState { should_move: false });
+
+ this.window_control_area(WindowControlArea::Drag)
+ .on_mouse_down_out(window.listener_for(&state, |state, _, _, _| {
+ state.should_move = false;
+ }))
+ .on_mouse_down(
+ MouseButton::Left,
+ window.listener_for(&state, |state, _, _, _| {
+ state.should_move = true;
+ }),
+ )
+ .on_mouse_up(
+ MouseButton::Left,
+ window.listener_for(&state, |state, _, _, _| {
+ state.should_move = false;
+ }),
+ )
+ .on_mouse_move(window.listener_for(&state, |state, _, window, _| {
+ if state.should_move {
+ state.should_move = false;
+ window.start_window_move();
+ }
+ }))
+ .on_click(|event, window, _| {
+ if event.click_count() == 2 {
+ if cfg!(target_os = "macos") {
+ window.titlebar_double_click();
+ } else {
+ window.zoom_window();
+ }
+ }
+ })
+}
diff --git a/crates/dock/src/tab_panel.rs b/crates/dock/src/tab_panel.rs
new file mode 100644
index 0000000..8d0bf79
--- /dev/null
+++ b/crates/dock/src/tab_panel.rs
@@ -0,0 +1,902 @@
+//! The Signed appearance for a tab group.
+//!
+//! `gpui_base::dock::TabGroup` owns the behavior — membership, the displayed
+//! tab, drag hit-testing, the zoom flag — and draws none of it. Everything
+//! visible is here, ported from the vendored dock: the pill tab bar that
+//! doubles as the window title bar (with window controls, title-bar
+//! dragging, and previous/next tab buttons), the toolbar, the ellipsis menu,
+//! the dock collapse affordance, the drop placeholder, and the styled drag
+//! preview.
+
+use std::cell::Cell;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::Duration;
+
+use gpui::prelude::FluentBuilder as _;
+use gpui::{
+ Anchor, Animation, AnimationExt as _, AnyElement, AnyView, App, AppContext as _, Bounds,
+ Context, Div, Empty, InteractiveElement as _, IntoElement, ParentElement as _, Pixels, Point,
+ Render, ScrollHandle, SharedString, Stateful, StatefulInteractiveElement as _, StyleRefinement,
+ Styled as _, Window, div, px, size,
+};
+use gpui_base::dock::{
+ AnyDrag, DockPlacement, DragPanel, DropIndicator, NodeId, PaneNode, PaneRef,
+ PanelView as BasePanelView, TabGroupContext, TabGroupRenderer,
+};
+use gpui_base::{ElementExt, InteractiveElementExt, Tab, Tabs};
+use gpui_component::animation::{Lerp as _, ease_out_cubic};
+use gpui_component::button::{Button, ButtonVariants as _};
+use gpui_component::menu::DropdownMenu as _;
+use gpui_component::{
+ ActiveTheme as _, Disableable as _, IconName, Selectable as _, Sizable as _, h_flex, v_flex,
+};
+
+use crate::dock_area::SkinShared;
+use crate::{
+ ClosePanel, PanelControl, PanelHandle, TAB_BAR_HEIGHT, ToggleZoom, t, title_bar_drag_handlers,
+ window_controls,
+};
+
+/// The size the styled drag preview occupies, reported to base so a drop
+/// placeholder knows where to fly in from.
+const DRAG_PREVIEW_SIZE: gpui::Size
= size(px(96.), px(30.));
+
+/// A panel's title, or its registered name when it reached base without this
+/// crate's handle and so carries no presentation. See [`PanelHandle::of`].
+pub(crate) fn panel_title(
+ panel: &Arc,
+ window: &mut Window,
+ cx: &mut App,
+) -> AnyElement {
+ match PanelHandle::of(panel) {
+ Some(handle) => handle.title(window, cx),
+ None => SharedString::from(panel.panel_name(cx)).into_any_element(),
+ }
+}
+
+/// The preview that follows the cursor while a panel is dragged.
+///
+/// `gpui_base::dock::DragPanel` is the payload and draws nothing; this is the
+/// appearance half, reintroduced here.
+struct DragPanelPreview {
+ panel: Arc,
+}
+
+impl Render for DragPanelPreview {
+ fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement {
+ div()
+ .id("drag-panel")
+ .cursor_grab()
+ .py_1()
+ .px_3()
+ .w_24()
+ .overflow_hidden()
+ .whitespace_nowrap()
+ .border_1()
+ .border_color(cx.theme().border)
+ .rounded(cx.theme().radius)
+ .text_color(cx.theme().tab_foreground)
+ .bg(cx.theme().tokens.tab_active)
+ .opacity(0.75)
+ .child(panel_title(&self.panel, window, cx))
+ }
+}
+
+/// Where the zoom affordance goes for the group's displayed panel, or `None`
+/// when there is none to offer.
+///
+/// Two questions, and both have to be asked. [`Panel::zoom_control`] says
+/// *where* the control appears; [`gpui_base::dock::Panel::zoomable`] says
+/// whether zooming happens at all, and base refuses a zoom that fails it.
+fn zoom_control(group: &TabGroupContext, cx: &App) -> Option {
+ let panel = group.active_panel()?;
+ panel
+ .zoomable(cx)
+ .then(|| PanelHandle::of(panel).and_then(|handle| handle.zoom_control(cx)))
+ .flatten()
+}
+
+/// The left-most, top-most tab group in a container — where a left dock's
+/// collapse affordance goes. Mirrors the old `StackPanel::left_top_tab_panel`.
+fn left_top_group(node: &PaneNode) -> Option {
+ match node.kind() {
+ PaneRef::Tabs { .. } => Some(node.id()),
+ PaneRef::Split { children, .. } => children.first().and_then(left_top_group),
+ PaneRef::Tiles { .. } => None,
+ }
+}
+
+/// The right-most, top-most tab group. A vertical split stacks its children,
+/// so its *first* child is the top one; a horizontal split's last child is
+/// the right-most. Mirrors the old `StackPanel::right_top_tab_panel`.
+fn right_top_group(node: &PaneNode) -> Option {
+ match node.kind() {
+ PaneRef::Tabs { .. } => Some(node.id()),
+ PaneRef::Split { axis, children, .. } => match axis {
+ gpui::Axis::Vertical => children.first(),
+ gpui::Axis::Horizontal => children.last(),
+ }
+ .and_then(right_top_group),
+ PaneRef::Tiles { .. } => None,
+ }
+}
+
+/// One tab group's appearance.
+///
+/// Built per group — `DockAreaRenderer::tab_group_renderer` is called once
+/// per container — so the tab bar's scroll position and the measured
+/// title-bar geometry belong to the group they describe.
+pub(crate) struct SignedTabGroupSkin {
+ shared: Rc,
+ scroll_handle: ScrollHandle,
+ /// The displayed tab the last frame drew, so a change scrolls the new tab
+ /// into view.
+ last_active_ix: Cell>,
+ /// Bounds of the title bar row (the wrapper around the tab bar), in
+ /// window coordinates. Measured via `on_prepaint` to position the
+ /// title-bar drag overlay.
+ title_bar_bounds: Rc>>>,
+ /// Bounds of the tab bar's trailing empty space (right after the last
+ /// tab), which marks where the draggable region starts.
+ title_bar_strip_bounds: Rc>>>,
+ /// Bounds of the tab bar's suffix (toolbar) area, which marks where the
+ /// draggable region ends.
+ title_bar_suffix_bounds: Rc>>>,
+}
+
+impl SignedTabGroupSkin {
+ pub(crate) fn new(shared: Rc) -> Self {
+ Self {
+ shared,
+ scroll_handle: ScrollHandle::default(),
+ last_active_ix: Cell::new(None),
+ title_bar_bounds: Rc::new(Cell::new(None)),
+ title_bar_strip_bounds: Rc::new(Cell::new(None)),
+ title_bar_suffix_bounds: Rc::new(Cell::new(None)),
+ }
+ }
+
+ /// A group that is the left dock's whole content with a single panel
+ /// draws no chrome at all — the vendored dock rendered such a panel bare,
+ /// and the sidebar is one.
+ fn is_plain_sidebar_group(&self, group: &TabGroupContext, cx: &mut App) -> bool {
+ let Some(area) = self.shared.area().upgrade() else {
+ return false;
+ };
+ let area = area.read(cx);
+ let Some(left) = area
+ .layout(DockPlacement::Left)
+ .map(|tree| tree.root().id())
+ else {
+ return false;
+ };
+ left == group.node() && group.panels().len() == 1
+ }
+
+ /// The bottom or right dock whose root tab group this group is, if any.
+ ///
+ /// Base bars a dock's only group from being dragged or closed, so the
+ /// dock cannot be emptied. A bottom/right panel is supposed to be
+ /// closable and movable, though — the vendored dock allowed exactly that
+ /// — so the skin recognizes the group and routes around the bar.
+ fn is_dock_root_group(&self, group: &TabGroupContext, cx: &App) -> Option {
+ let area = self.shared.area().upgrade()?;
+ let area = area.read(cx);
+ [DockPlacement::Bottom, DockPlacement::Right]
+ .into_iter()
+ .find(|placement| {
+ area.layout(*placement)
+ .is_some_and(|tree| tree.root().id() == group.node())
+ })
+ }
+
+ /// The drag payload for the tab at `ix`, or `None` when this group must
+ /// not be rearranged. A locked group is never draggable; a group that is
+ /// a bottom/right dock's only content still is, because the center is
+ /// always there to land in.
+ fn tab_drag(&self, group: &TabGroupContext, ix: usize, cx: &App) -> Option {
+ if group.is_locked() {
+ return None;
+ }
+ if !group.is_draggable() && self.is_dock_root_group(group, cx).is_none() {
+ return None;
+ }
+ group.drag_panel(ix, cx)
+ }
+
+ /// Whether a dock's collapse affordance belongs in *this* group's tab
+ /// bar, and which way it points. `None` means this group draws none.
+ fn dock_toggle_button(
+ &self,
+ placement: DockPlacement,
+ group: &TabGroupContext,
+ cx: &mut App,
+ ) -> Option {
+ if group.is_zoomed() || !self.shared.is_toggle_button_visible() {
+ return None;
+ }
+
+ let area = self.shared.area().upgrade()?;
+ let area = area.read(cx);
+ // A dock that does not exist is not collapsible, so this covers the
+ // old `left_dock.is_some()` test too.
+ if !area.is_dock_collapsible(placement) {
+ return None;
+ }
+
+ let designated = match placement {
+ DockPlacement::Left => area
+ .layout(DockPlacement::Center)
+ .and_then(|tree| left_top_group(tree.root())),
+ DockPlacement::Right => area
+ .layout(DockPlacement::Center)
+ .and_then(|tree| right_top_group(tree.root())),
+ DockPlacement::Bottom => area
+ .layout(DockPlacement::Bottom)
+ .and_then(|tree| left_top_group(tree.root())),
+ DockPlacement::Center => None,
+ };
+ if designated != Some(group.node()) {
+ return None;
+ }
+
+ let is_open = area.is_dock_open(placement);
+ let icon = match (placement, is_open) {
+ (DockPlacement::Left, true) => IconName::PanelLeft,
+ (DockPlacement::Left, false) => IconName::PanelLeftOpen,
+ (DockPlacement::Right, true) => IconName::PanelRight,
+ (DockPlacement::Right, false) => IconName::PanelRightOpen,
+ (DockPlacement::Bottom, true) => IconName::PanelBottom,
+ (DockPlacement::Bottom, false) => IconName::PanelBottomOpen,
+ (DockPlacement::Center, _) => return None,
+ };
+
+ let area = self.shared.area().clone();
+ Some(
+ Button::new(SharedString::from(format!("toggle-dock:{placement:?}")))
+ .icon(icon)
+ .small()
+ .ghost()
+ .tab_stop(false)
+ .tooltip(match is_open {
+ true => t("Dock.Collapse"),
+ false => t("Dock.Expand"),
+ })
+ .on_click(move |_, window, cx| {
+ _ = area.update(cx, |area, cx| area.toggle_dock(placement, window, cx));
+ }),
+ )
+ }
+
+ /// The previous/next tab buttons shown in the tab bar's leading prefix.
+ ///
+ /// Unlike the dock toggle button they always render, but are disabled at
+ /// the ends of the tab strip (or while the panel is collapsed).
+ fn render_prev_next_tab_buttons(
+ &self,
+ group: &TabGroupContext,
+ _cx: &mut App,
+ ) -> impl IntoElement {
+ let collapsed = group.is_collapsed();
+ let active_ix = group.active_ix();
+ let panels_len = group.panels().len();
+ let prev_enabled = !collapsed && active_ix > 0;
+ let next_enabled = !collapsed && active_ix + 1 < panels_len;
+
+ h_flex()
+ .gap_1()
+ .child(
+ Button::new("tab:prev")
+ .icon(IconName::ArrowLeft)
+ .small()
+ .ghost()
+ .tab_stop(false)
+ .tooltip("Previous tab")
+ .disabled(!prev_enabled)
+ .on_click({
+ let group = group.clone();
+ move |_, window, cx| group.select_tab(active_ix - 1, window, cx)
+ }),
+ )
+ .child(
+ Button::new("tab:next")
+ .icon(IconName::ArrowRight)
+ .small()
+ .ghost()
+ .tab_stop(false)
+ .tooltip("Next tab")
+ .disabled(!next_enabled)
+ .on_click({
+ let group = group.clone();
+ move |_, window, cx| group.select_tab(active_ix + 1, window, cx)
+ }),
+ )
+ }
+
+ /// The trailing controls: the panel's own buttons, the zoom affordance,
+ /// and the ellipsis menu.
+ fn render_toolbar(
+ &self,
+ group: &TabGroupContext,
+ window: &mut Window,
+ cx: &mut App,
+ ) -> impl IntoElement {
+ if group.is_collapsed() {
+ return div();
+ }
+
+ let zoomed = group.is_zoomed();
+ let handle = group.active_panel().and_then(PanelHandle::of);
+ let control = zoom_control(group, cx);
+ let toolbar_zoom = control.is_some_and(|control| control.toolbar_visible());
+ let menu_zoom = control.is_some_and(|control| control.menu_visible());
+ // A bottom/right dock's only panel cannot be closed through the
+ // group (base keeps a dock's last group), but the skin handles that
+ // close by removing the whole dock, so the item is offered.
+ let closable = group.is_closable()
+ || (self.is_dock_root_group(group, cx).is_some()
+ && group.active_panel().is_some_and(|panel| panel.closable(cx)));
+ let buttons = handle.and_then(|handle| handle.toolbar_buttons(window, cx));
+ let panel = handle.map(|handle| handle.panel());
+
+ h_flex()
+ .gap_1()
+ .occlude()
+ .when_some(buttons, |this, buttons| {
+ this.children(
+ buttons
+ .into_iter()
+ .map(|button| button.small().ghost().tab_stop(false)),
+ )
+ })
+ .map(|this| {
+ let value = if zoomed {
+ Some(("zoom-out", IconName::Minimize, t("Dock.Zoom Out")))
+ } else if toolbar_zoom {
+ Some(("zoom-in", IconName::Maximize, t("Dock.Zoom In")))
+ } else {
+ None
+ };
+
+ if let Some((id, icon, tooltip)) = value {
+ this.child(
+ Button::new(id)
+ .icon(icon)
+ .small()
+ .ghost()
+ .tab_stop(false)
+ .tooltip_with_action(tooltip, &ToggleZoom, None)
+ .selected(zoomed)
+ .on_click({
+ let group = group.clone();
+ move |_, window, cx| group.toggle_zoom(window, cx)
+ }),
+ )
+ } else {
+ this
+ }
+ })
+ .child(
+ Button::new("menu")
+ .icon(IconName::Ellipsis)
+ .small()
+ .ghost()
+ .tab_stop(false)
+ .dropdown_menu(move |menu, window, cx| {
+ menu.when_some(panel.clone(), |menu, panel| {
+ panel.dropdown_menu(menu, window, cx)
+ })
+ .separator()
+ .menu_with_disabled(
+ if zoomed {
+ t("Dock.Zoom Out")
+ } else {
+ t("Dock.Zoom In")
+ },
+ Box::new(ToggleZoom),
+ !menu_zoom,
+ )
+ .when(closable, |menu| {
+ menu.separator().menu(t("Dock.Close"), Box::new(ClosePanel))
+ })
+ })
+ .anchor(Anchor::TopRight),
+ )
+ }
+
+ /// One tab of the pill strip.
+ ///
+ /// While collapsed, tabs lose the active style and all interactions, and
+ /// the strip becomes the way a closed bottom dock is opened again.
+ #[allow(clippy::too_many_arguments)]
+ fn render_tab(
+ &self,
+ group: &TabGroupContext,
+ ix: usize,
+ panel: Arc,
+ active: bool,
+ is_bottom_dock: bool,
+ window: &mut Window,
+ cx: &mut App,
+ ) -> Tab {
+ let collapsed = group.is_collapsed();
+ let droppable = group.is_droppable();
+ let drag = self.tab_drag(group, ix, cx);
+ let handle = PanelHandle::of(&panel);
+
+ Tab::new(ix)
+ .h_6()
+ .px_3()
+ .text_sm()
+ .whitespace_nowrap()
+ .flex()
+ .items_center()
+ .justify_center()
+ .gap_1()
+ .flex_shrink_0()
+ .overflow_hidden()
+ .rounded(cx.theme().radius)
+ .text_color(cx.theme().foreground)
+ .map(|this| match handle.and_then(|handle| handle.tab_name(cx)) {
+ Some(tab_name) => this.child(tab_name),
+ None => this.child(panel_title(&panel, window, cx)),
+ })
+ // Pill presentation: the selected tab is the filled pill, the
+ // rest are transparent until hovered.
+ .styles(|styles| {
+ styles.selected(|style| {
+ style
+ .text_color(cx.theme().tab_active_foreground)
+ .bg(cx.theme().tab_active)
+ })
+ })
+ .hover(|this| {
+ if active {
+ this
+ } else {
+ this.text_color(cx.theme().secondary_foreground)
+ .bg(cx.theme().secondary_hover)
+ }
+ })
+ .selected(active)
+ .on_click({
+ let group = group.clone();
+ let area = self.shared.area().clone();
+ move |_, window, cx| {
+ group.select_tab(ix, window, cx);
+
+ // Clicking the strip of a collapsed bottom dock is how it
+ // is opened again.
+ if is_bottom_dock && collapsed {
+ _ = area.update(cx, |area, cx| {
+ area.toggle_dock(DockPlacement::Bottom, window, cx);
+ });
+ }
+ }
+ })
+ .when(!collapsed, |this| {
+ this.when_some(drag, |this, drag| {
+ this.on_drag(drag, {
+ let panel = panel.clone();
+ move |drag, offset, _, cx| {
+ cx.stop_propagation();
+ drag.set_drag_offset(offset);
+ drag.set_preview_size(DRAG_PREVIEW_SIZE);
+ cx.new(|_| DragPanelPreview {
+ panel: panel.clone(),
+ })
+ }
+ })
+ })
+ .when(droppable, |this| {
+ this.drag_over::(|this, _, _, cx| {
+ this.rounded_l_none()
+ .border_l_2()
+ .border_r_0()
+ .border_color(cx.theme().drag_border)
+ })
+ .on_drop({
+ let group = group.clone();
+ move |drag: &DragPanel, window, cx| {
+ group.drop_panel(drag.clone(), Some(ix), true, window, cx);
+ }
+ })
+ .drag_over::(|this, _, _, cx| {
+ this.rounded_l_none()
+ .border_l_2()
+ .border_r_0()
+ .border_color(cx.theme().drag_border)
+ })
+ .on_drop({
+ let group = group.clone();
+ move |item: &AnyDrag, window, cx| {
+ group.drop_item(item.clone(), None, window, cx);
+ }
+ })
+ })
+ })
+ }
+
+ /// The strip after the last tab: a drop target for panels and host-owned
+ /// drag items. Its left edge (right after the last tab) marks the start
+ /// of the title-bar drag overlay.
+ fn render_empty_space(
+ &self,
+ group: &TabGroupContext,
+ tabs_count: usize,
+ _cx: &mut App,
+ ) -> AnyElement {
+ let strip_bounds = self.title_bar_strip_bounds.clone();
+ let shared = self.shared.clone();
+ let droppable = group.is_droppable();
+
+ let mut empty = div()
+ .id("tab-bar-empty-space")
+ .h_full()
+ .flex_grow_1()
+ .min_w_16()
+ .on_prepaint(move |bounds, _, cx| {
+ if strip_bounds.get() != Some(bounds) {
+ strip_bounds.set(Some(bounds));
+ _ = shared.area().update(cx, |_, cx| cx.notify());
+ }
+ });
+
+ if droppable {
+ empty = empty
+ .drag_over::(|this, _, _, cx| this.bg(cx.theme().tokens.drop_target))
+ .on_drop({
+ let group = group.clone();
+ let node = group.node();
+ move |drag: &DragPanel, window, cx| {
+ // A panel dropped past its own last tab lands in the
+ // final slot; one from elsewhere is appended in the
+ // background.
+ let ix = (drag.source() == node).then(|| tabs_count - 1);
+ group.drop_panel(drag.clone(), ix, false, window, cx);
+ }
+ })
+ .drag_over::(|this, _, _, cx| this.bg(cx.theme().tokens.drop_target))
+ .on_drop({
+ let group = group.clone();
+ move |item: &AnyDrag, window, cx| {
+ group.drop_item(item.clone(), None, window, cx);
+ }
+ });
+ }
+
+ empty.into_any_element()
+ }
+}
+
+impl TabGroupRenderer for SignedTabGroupSkin {
+ fn frame(&self, group: &TabGroupContext, _: &mut Window, cx: &mut App) -> Stateful {
+ let control = zoom_control(group, cx);
+ // An emptied group — its last panel was dragged away — draws nothing,
+ // so an emptied dock does not leave a bare tab bar behind.
+ if group.panels().is_empty() {
+ return div().id("tab-panel");
+ }
+ // Closing the only panel of a bottom/right dock would leave an empty
+ // dock, which base refuses through the group. The skin removes the
+ // whole dock instead — the vendored dock's close took its split
+ // group away just the same.
+ let dock_to_remove = (group.panels().len() <= 1)
+ .then(|| self.is_dock_root_group(group, cx))
+ .flatten();
+ let shared = self.shared.clone();
+
+ // `v_flex`, not `div`: gpui's default display is Block, and in block
+ // layout a child's `flex_grow` is ignored — the content region below
+ // the tab bar would resolve to zero height.
+ v_flex()
+ .id("tab-panel")
+ .size_full()
+ .overflow_hidden()
+ .bg(cx.theme().tokens.background)
+ // A collapsed group is a strip of tabs with no content, and the
+ // actions act on content.
+ .when(!group.is_collapsed(), |this| {
+ this.on_action({
+ let group = group.clone();
+ move |_: &ToggleZoom, window, cx| {
+ // The affordance decides the control, so a panel that
+ // offers none is not zoomed *in* by the keybinding
+ // either. Zooming out is never refused: a panel that
+ // stopped offering the control while zoomed would
+ // otherwise strand the user with no way back.
+ if !group.is_zoomed() && control.is_none() {
+ return;
+ }
+ group.toggle_zoom(window, cx);
+ }
+ })
+ .on_action({
+ let group = group.clone();
+ let shared = shared.clone();
+ move |_: &ClosePanel, window, cx| {
+ let Some(panel) = group.active_panel() else {
+ return;
+ };
+ if !panel.closable(cx) {
+ return;
+ }
+ let panel = panel.panel_id(cx);
+ match dock_to_remove {
+ Some(placement) => {
+ _ = shared.area().update(cx, |area, cx| {
+ area.remove_dock(placement, window, cx);
+ });
+ }
+ None => group.close(panel, window, cx),
+ }
+ }
+ })
+ })
+ }
+
+ fn content_frame(&self, group: &TabGroupContext, _: &mut Window, _: &mut App) -> Stateful
{
+ v_flex()
+ .id("active-panel")
+ // A collapsed group draws its tab strip and nothing else, so the
+ // content region must not claim any space.
+ .when(!group.is_collapsed(), |this| this.flex_1())
+ }
+
+ fn render_tab_bar(
+ &self,
+ group: &TabGroupContext,
+ window: &mut Window,
+ cx: &mut App,
+ ) -> AnyElement {
+ // An emptied group draws no tab bar; the app prunes the emptied
+ // bottom/right dock a moment later.
+ if group.panels().is_empty() {
+ return Empty.into_any_element();
+ }
+
+ // The sidebar group draws no chrome at all, like the vendored dock's
+ // bare `DockItem::Panel`.
+ if self.is_plain_sidebar_group(group, cx) {
+ return Empty.into_any_element();
+ }
+
+ let collapsed = group.is_collapsed();
+ let active_ix = group.active_ix();
+ let tabs_count = group.panels().len();
+
+ let left_dock_button = self.dock_toggle_button(DockPlacement::Left, group, cx);
+ let bottom_dock_button = self.dock_toggle_button(DockPlacement::Bottom, group, cx);
+ let right_dock_button = self.dock_toggle_button(DockPlacement::Right, group, cx);
+ let is_bottom_dock = bottom_dock_button.is_some();
+
+ // macOS: the traffic lights overlay the window's top-left corner. Only
+ // the group whose tab bar actually sits under them must reserve the
+ // space: the left dock (sidebar) normally clears them, and when it is
+ // closed or absent it is the center's left-most, top-most tab group
+ // that is in the corner. A bottom or right dock is never there, and
+ // neither is the right panel of a center split.
+ let needs_traffic_light_padding = cfg!(target_os = "macos")
+ && self.shared.area().upgrade().is_some_and(|area| {
+ let area = area.read(cx);
+ !area.is_dock_open(DockPlacement::Left)
+ && area
+ .layout(DockPlacement::Center)
+ .and_then(|tree| left_top_group(tree.root()))
+ == Some(group.node())
+ });
+
+ // Bring a newly displayed tab into view. The group owns selection
+ // now, so the skin notices the change rather than being told about it.
+ let displayed = group.active_panel().map(|panel| panel.panel_id(cx));
+ let visible: Vec
= group
+ .panels()
+ .iter()
+ .enumerate()
+ .filter(|(_, panel)| panel.visible(cx))
+ .map(|(ix, _)| ix)
+ .collect();
+ if self.last_active_ix.replace(Some(active_ix)) != Some(active_ix)
+ && let Some(visible_ix) = visible.iter().position(|ix| *ix == active_ix)
+ {
+ self.scroll_handle.scroll_to_item(visible_ix);
+ }
+
+ // The tab strip lays out its scrollable content at content width, so
+ // the area after the last tab only spans `min_w_16` — the rest of the
+ // tab bar has no element at all. Cover that dead zone with a
+ // measured overlay so the whole non-interactive area can drag the
+ // window. Its span is [last tab's right edge, suffix's left edge].
+ let drag_overlay = match (
+ self.title_bar_bounds.get(),
+ self.title_bar_strip_bounds.get(),
+ self.title_bar_suffix_bounds.get(),
+ ) {
+ (Some(title), Some(strip), Some(suffix)) => {
+ let left = strip.left() - title.left();
+ let right = title.right() - suffix.left();
+ (left + right < title.size.width).then(|| {
+ title_bar_drag_handlers(
+ div()
+ .id(("title-bar-drag", group.node().as_u64()))
+ .absolute()
+ .top_0()
+ .bottom_0()
+ .left(left)
+ .right(right),
+ window,
+ cx,
+ )
+ })
+ }
+ _ => None,
+ };
+
+ let tabs: Vec<_> = group
+ .panels()
+ .iter()
+ .enumerate()
+ .filter_map(|(ix, panel)| {
+ let mut active = displayed == Some(panel.panel_id(cx));
+ if !panel.visible(cx) {
+ return None;
+ }
+ // A collapsed group shows no tab as active: the strip is a
+ // way back in, not a selection.
+ if collapsed {
+ active = false;
+ }
+ Some(self.render_tab(group, ix, panel.clone(), active, is_bottom_dock, window, cx))
+ })
+ .collect();
+
+ let empty_space = self.render_empty_space(group, tabs_count, cx);
+ let title_bar_bounds = self.title_bar_bounds.clone();
+ let title_bar_suffix_bounds = self.title_bar_suffix_bounds.clone();
+ let shared = self.shared.clone();
+ let suffix_shared = self.shared.clone();
+
+ div()
+ .flex()
+ .flex_row()
+ .child(
+ div()
+ .relative()
+ .flex_1()
+ .min_w_0()
+ .on_prepaint(move |bounds, _, cx| {
+ if title_bar_bounds.get() != Some(bounds) {
+ title_bar_bounds.set(Some(bounds));
+ _ = shared.area().update(cx, |_, cx| cx.notify());
+ }
+ })
+ .child(
+ Tabs::new("tab-bar")
+ .px(px(-1.))
+ .h(TAB_BAR_HEIGHT)
+ .flex()
+ .items_center()
+ .text_color(cx.theme().tab_foreground)
+ .child(
+ h_flex()
+ .items_center()
+ .top_0()
+ // Right -1 for avoid border overlap with the first tab
+ .right(-px(1.))
+ .h_full()
+ .gap_2()
+ .px_2()
+ .when(needs_traffic_light_padding, |this| this.pl(px(80.)))
+ .children(left_dock_button)
+ .children(bottom_dock_button)
+ .child(self.render_prev_next_tab_buttons(group, cx)),
+ )
+ .child(
+ h_flex().id("tabs").flex_1().overflow_x_hidden().child(
+ h_flex()
+ .id("tabs-inner")
+ .relative()
+ .gap(px(4.))
+ .overflow_x_scroll()
+ .lock_scroll_axis()
+ .track_scroll(&self.scroll_handle)
+ .children(tabs)
+ .when(!collapsed, |this| this.child(empty_space)),
+ ),
+ )
+ .when(!collapsed, |this| {
+ this.child(
+ h_flex()
+ .items_center()
+ .top_0()
+ .right_0()
+ .h_full()
+ .px_2()
+ .gap_1()
+ .on_prepaint(move |bounds, _, cx| {
+ if title_bar_suffix_bounds.get() != Some(bounds) {
+ title_bar_suffix_bounds.set(Some(bounds));
+ _ = suffix_shared
+ .area()
+ .update(cx, |_, cx| cx.notify());
+ }
+ })
+ .children(
+ group
+ .active_panel()
+ .and_then(PanelHandle::of)
+ .and_then(|handle| handle.title_suffix(window, cx)),
+ )
+ .child(self.render_toolbar(group, window, cx))
+ .children(right_dock_button),
+ )
+ }),
+ )
+ .when_some(drag_overlay, |this, overlay| this.child(overlay)),
+ )
+ .child(window_controls::window_controls(window, cx))
+ .into_any_element()
+ }
+
+ fn render_active_panel(
+ &self,
+ panel: AnyView,
+ group: &TabGroupContext,
+ _: &mut Window,
+ _: &mut App,
+ ) -> AnyElement {
+ if group.is_collapsed() {
+ return Empty.into_any_element();
+ }
+
+ div()
+ .id("tab-content")
+ .overflow_y_scroll()
+ .overflow_x_hidden()
+ .flex_1()
+ .child(panel.cached(StyleRefinement::default().absolute().size_full()))
+ .into_any_element()
+ }
+
+ fn render_drop_indicator(
+ &self,
+ indicator: DropIndicator,
+ _: &mut Window,
+ cx: &mut App,
+ ) -> Option {
+ let (from, to) = (indicator.from(), indicator.to());
+ // The placeholder animates from wherever it was to where the drop
+ // would land, so its own element is positioned at the destination and
+ // the animation only has to walk the difference back to zero.
+ let offset = from.origin() - to.origin();
+
+ Some(
+ div()
+ .absolute()
+ .left(to.origin().x)
+ .top(to.origin().y)
+ .w(to.size().width)
+ .h(to.size().height)
+ .child(
+ div()
+ .absolute()
+ .bg(cx.theme().tokens.drop_target)
+ .with_animation(
+ gpui::ElementId::NamedInteger(
+ "drop-placeholder".into(),
+ indicator.epoch(),
+ ),
+ Animation::new(Duration::from_millis(150)).with_easing(ease_out_cubic),
+ move |this, delta| {
+ let origin = offset.lerp(&Point::default(), delta);
+ let width = from.size().width.lerp(&to.size().width, delta);
+ let height = from.size().height.lerp(&to.size().height, delta);
+ this.left(origin.x).top(origin.y).w(width).h(height)
+ },
+ ),
+ )
+ .into_any_element(),
+ )
+ }
+}
diff --git a/crates/dock/src/tiles.rs b/crates/dock/src/tiles.rs
new file mode 100644
index 0000000..a8aaacd
--- /dev/null
+++ b/crates/dock/src/tiles.rs
@@ -0,0 +1,416 @@
+//! The Signed appearance for a tiles canvas.
+//!
+//! `gpui_base::dock::TilesState` owns the geometry — snapping, the resize
+//! arithmetic, the undo stack, the zoom flag — and draws none of it. The tile
+//! frame, its title bar and its resize affordances are here, ported from
+//! gpui-component's `TilesSkin` (the vendored dock had no tiles canvas, so
+//! there is no local look to preserve).
+
+use std::rc::Rc;
+
+use gpui::prelude::FluentBuilder as _;
+use gpui::{
+ AnyElement, App, AppContext as _, Context, Div, DragMoveEvent, Empty, InteractiveElement as _,
+ IntoElement, MouseButton, MouseDownEvent, ParentElement as _, Pixels, Render, ScrollHandle,
+ Size, Stateful, StatefulInteractiveElement as _, Styled as _, Window, div, px,
+};
+use gpui_base::dock::{
+ DRAG_BAR_HEIGHT, HANDLE_SIZE, NodeId, ResizeSide, TileContext, TilesRenderer,
+};
+use gpui_component::button::{Button, ButtonVariants as _};
+use gpui_component::menu::{DropdownMenu as _, PopupMenuItem};
+use gpui_component::scroll::Scrollbar;
+use gpui_component::{
+ ActiveTheme as _, Icon, IconName, Selectable as _, Sizable as _, h_flex, v_flex,
+};
+
+use crate::dock_area::SkinShared;
+use crate::tab_panel::panel_title;
+use crate::{PanelHandle, t};
+
+/// How far a resize handle sticks out past the tile's edge.
+const HANDLE_OFFSET: Pixels = px(-4.);
+
+/// The payload a tile drag carries, so one canvas ignores another's drags.
+#[derive(Clone)]
+struct DragMoving(NodeId);
+
+impl Render for DragMoving {
+ fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
+ Empty
+ }
+}
+
+/// The payload a tile resize carries, for the same reason.
+#[derive(Clone)]
+struct DragResizing(NodeId);
+
+impl Render for DragResizing {
+ fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
+ Empty
+ }
+}
+
+/// One tiles canvas's appearance.
+///
+/// Built per canvas — `DockAreaRenderer::tiles_renderer` is called once per
+/// container — so the scroll position belongs to the canvas it scrolls.
+pub(crate) struct SignedTilesSkin {
+ shared: Rc,
+ scroll_handle: ScrollHandle,
+}
+
+impl SignedTilesSkin {
+ pub(crate) fn new(shared: Rc) -> Self {
+ Self {
+ shared,
+ scroll_handle: ScrollHandle::default(),
+ }
+ }
+
+ /// One edge or corner handle.
+ fn resize_handle(
+ &self,
+ tile: &TileContext,
+ id: &'static str,
+ side: ResizeSide,
+ build: impl FnOnce(Stateful) -> Stateful
,
+ ) -> Stateful
{
+ let node = tile.node();
+
+ build(div().id(id).absolute())
+ .on_mouse_down(MouseButton::Left, {
+ let tile = tile.clone();
+ move |event: &MouseDownEvent, window, cx| {
+ tile.begin_resize(side, event.position, window, cx);
+ cx.stop_propagation();
+ }
+ })
+ .on_drag(DragResizing(node), |drag, _, _, cx| {
+ cx.stop_propagation();
+ cx.new(|_| drag.clone())
+ })
+ .on_drag_move({
+ let tile = tile.clone();
+ move |event: &DragMoveEvent
, window, cx| {
+ if event.drag(cx).0 != node {
+ return;
+ }
+ tile.resize_to(event.event.position, window, cx);
+ }
+ })
+ }
+
+ /// The trailing controls of a tile's title bar.
+ ///
+ /// A tile has no tab bar to hang a toolbar off, so this is where its zoom,
+ /// close and ellipsis menu live. The entries use click handlers rather
+ /// than the [`ToggleZoom`](crate::ToggleZoom) and
+ /// [`ClosePanel`](crate::ClosePanel) actions: those are dispatched to a
+ /// focused tab group, and a tile is not one.
+ fn render_tile_controls(
+ &self,
+ tile: &TileContext,
+ window: &mut Window,
+ cx: &mut App,
+ ) -> impl IntoElement {
+ let handle = PanelHandle::of(tile.panel());
+ let control = handle.and_then(|handle| handle.zoom_control(cx));
+ let zoomed = tile.is_zoomed();
+ let toolbar_zoom =
+ tile.is_zoomable() && control.is_some_and(|control| control.toolbar_visible());
+ let menu_zoom = tile.is_zoomable() && control.is_some_and(|control| control.menu_visible());
+ let closable = tile.is_closable();
+ let buttons = handle.and_then(|handle| handle.toolbar_buttons(window, cx));
+ let panel = handle.map(|handle| handle.panel());
+
+ h_flex()
+ .gap_1()
+ .flex_shrink_0()
+ .occlude()
+ .when_some(buttons, |this, buttons| {
+ this.children(
+ buttons
+ .into_iter()
+ .map(|button| button.xsmall().ghost().tab_stop(false)),
+ )
+ })
+ .when_some(
+ match (zoomed, toolbar_zoom) {
+ (true, _) => Some(("zoom-out", IconName::Minimize, t("Dock.Zoom Out"))),
+ (false, true) => Some(("zoom-in", IconName::Maximize, t("Dock.Zoom In"))),
+ (false, false) => None,
+ },
+ |this, (id, icon, tooltip)| {
+ this.child(
+ Button::new(id)
+ .icon(icon)
+ .xsmall()
+ .ghost()
+ .tab_stop(false)
+ .tooltip(tooltip)
+ .selected(zoomed)
+ .on_click({
+ let tile = tile.clone();
+ move |_, window, cx| tile.toggle_zoom(window, cx)
+ }),
+ )
+ },
+ )
+ .child(
+ Button::new("menu")
+ .icon(IconName::Ellipsis)
+ .xsmall()
+ .ghost()
+ .tab_stop(false)
+ .dropdown_menu({
+ let tile = tile.clone();
+ move |menu, window, cx| {
+ menu.when_some(panel.clone(), |menu, panel| {
+ panel.dropdown_menu(menu, window, cx)
+ })
+ .separator()
+ .item(
+ PopupMenuItem::new(match zoomed {
+ true => t("Dock.Zoom Out"),
+ false => t("Dock.Zoom In"),
+ })
+ .disabled(!menu_zoom && !zoomed)
+ .on_click({
+ let tile = tile.clone();
+ move |_, window, cx| tile.toggle_zoom(window, cx)
+ }),
+ )
+ .when(closable, |menu| {
+ menu.separator()
+ .item(PopupMenuItem::new(t("Dock.Close")).on_click({
+ let tile = tile.clone();
+ move |_, window, cx| tile.close(window, cx)
+ }))
+ })
+ }
+ })
+ .anchor(gpui::Anchor::TopRight),
+ )
+ }
+}
+
+impl TilesRenderer for SignedTilesSkin {
+ fn frame(&self, _: &mut Window, cx: &mut App) -> Stateful {
+ div()
+ .id("tiles")
+ .relative()
+ .size_full()
+ .bg(cx.theme().tokens.tiles)
+ .track_scroll(&self.scroll_handle)
+ .overflow_scroll()
+ }
+
+ fn tile_frame(&self, tile: &TileContext, _: &mut Window, cx: &mut App) -> Stateful
{
+ v_flex()
+ .id(("tile", tile.panel_id().as_u64()))
+ .occlude()
+ .overflow_hidden()
+ .bg(cx.theme().tokens.background)
+ .border_1()
+ .border_color(cx.theme().border)
+ .rounded(cx.theme().tile_radius)
+ // Room for the title bar, which is positioned over the padding so
+ // the panel below it is never covered. Base draws the panel view
+ // as a plain child, so this is the only way to keep the two from
+ // overlapping.
+ .pt(DRAG_BAR_HEIGHT)
+ // Base installs the stored bounds on an ordinary tile and nothing
+ // at all on a zoomed one — how a zoomed tile fills the dock is
+ // this skin's decision.
+ .when(tile.is_zoomed(), |this| this.size_full())
+ .on_mouse_down(MouseButton::Left, {
+ let tile = tile.clone();
+ move |_, window, cx| tile.bring_to_front(window, cx)
+ })
+ // A gesture can end with the pointer anywhere, so both halves are
+ // needed; each is a no-op unless this tile is the one moving.
+ .on_mouse_up(MouseButton::Left, {
+ let tile = tile.clone();
+ move |_, window, cx| {
+ tile.end_move(window, cx);
+ tile.end_resize(window, cx);
+ }
+ })
+ .on_mouse_up_out(MouseButton::Left, {
+ let tile = tile.clone();
+ move |_, window, cx| {
+ tile.end_move(window, cx);
+ tile.end_resize(window, cx);
+ }
+ })
+ }
+
+ fn render_drag_bar(&self, tile: &TileContext, window: &mut Window, cx: &mut App) -> AnyElement {
+ let node = tile.node();
+ let handle = PanelHandle::of(tile.panel());
+ let title_style = handle.and_then(|handle| handle.title_style(cx));
+
+ h_flex()
+ .id("drag-bar")
+ .absolute()
+ .top_0()
+ .left_0()
+ .w_full()
+ .h(DRAG_BAR_HEIGHT)
+ .items_center()
+ .gap_1()
+ .pl_3()
+ .pr_2()
+ .when_some(title_style, |this, style| {
+ this.bg(style.background).text_color(style.foreground)
+ })
+ .child(
+ div()
+ .flex_1()
+ .min_w_16()
+ .overflow_hidden()
+ .text_ellipsis()
+ .whitespace_nowrap()
+ .child(panel_title(tile.panel(), window, cx)),
+ )
+ .children(handle.and_then(|handle| handle.title_suffix(window, cx)))
+ .child(self.render_tile_controls(tile, window, cx))
+ // A zoomed tile is not at its stored bounds, so there is nothing
+ // for a move to mean; base refuses the gesture too.
+ .when(!tile.is_zoomed(), |this| {
+ this.cursor_grab()
+ .on_mouse_down(MouseButton::Left, {
+ let tile = tile.clone();
+ move |event: &MouseDownEvent, window, cx| {
+ tile.begin_move(event.position, window, cx);
+ }
+ })
+ .on_drag(DragMoving(node), |drag, _, _, cx| {
+ cx.stop_propagation();
+ cx.new(|_| drag.clone())
+ })
+ .on_drag_move({
+ let tile = tile.clone();
+ move |event: &DragMoveEvent
, window, cx| {
+ if event.drag(cx).0 != node {
+ return;
+ }
+ tile.move_to(event.event.position, window, cx);
+ }
+ })
+ })
+ .into_any_element()
+ }
+
+ fn render_resize_handles(
+ &self,
+ tile: &TileContext,
+ _: &mut Window,
+ cx: &mut App,
+ ) -> AnyElement {
+ let bounds = tile.bounds();
+
+ // A passive full-tile box so each handle is positioned against the
+ // tile rather than against whatever the flow put it next to. It
+ // registers no interaction of its own, so it does not shadow the panel
+ // underneath.
+ div()
+ .absolute()
+ .top_0()
+ .left_0()
+ .size_full()
+ .child(
+ self.resize_handle(tile, "left-resize-handle", ResizeSide::Left, |this| {
+ this.cursor_ew_resize()
+ .top_0()
+ .left(HANDLE_OFFSET)
+ .w(HANDLE_SIZE)
+ .h(bounds.size.height)
+ }),
+ )
+ .child(
+ self.resize_handle(tile, "right-resize-handle", ResizeSide::Right, |this| {
+ this.cursor_ew_resize()
+ .top_0()
+ .right(HANDLE_OFFSET)
+ .w(HANDLE_SIZE)
+ .h(bounds.size.height)
+ }),
+ )
+ .child(
+ self.resize_handle(tile, "top-resize-handle", ResizeSide::Top, |this| {
+ this.cursor_ns_resize()
+ .left_0()
+ .top(HANDLE_OFFSET)
+ .w(bounds.size.width)
+ .h(HANDLE_SIZE)
+ }),
+ )
+ .child(
+ self.resize_handle(tile, "bottom-resize-handle", ResizeSide::Bottom, |this| {
+ this.cursor_ns_resize()
+ .left_0()
+ .bottom(HANDLE_OFFSET)
+ .w(bounds.size.width)
+ .h(HANDLE_SIZE)
+ }),
+ )
+ .child(
+ Icon::new(IconName::ResizeCorner)
+ .size_3()
+ .absolute()
+ .right(px(1.))
+ .bottom(px(1.))
+ .text_color(cx.theme().muted_foreground.opacity(0.5)),
+ )
+ .child(self.resize_handle(
+ tile,
+ "corner-resize-handle",
+ ResizeSide::BottomRight,
+ |this| {
+ this.cursor_nwse_resize()
+ .right(HANDLE_OFFSET)
+ .bottom(HANDLE_OFFSET)
+ .size_3()
+ },
+ ))
+ .into_any_element()
+ }
+
+ /// The panel of a tile gets `size_full` here; base draws the panel as a
+ /// plain child, so without it a panel that does not size itself has no
+ /// size.
+ fn panel_frame(&self, tile: &TileContext, _: &mut Window, _: &mut App) -> Stateful {
+ h_flex()
+ .id(("tile-panel", tile.panel_id().as_u64()))
+ .overflow_hidden()
+ .size_full()
+ }
+
+ /// The canvas scrollbar.
+ ///
+ /// It has to be an overlay rather than one of the frame's own children:
+ /// the frame is the scroll container and base appends the tiles after
+ /// whatever the frame carries, so a scrollbar placed there would paint and
+ /// hit-test underneath every tile.
+ fn render_overlay(
+ &self,
+ content: Size
,
+ _: &mut Window,
+ _: &mut App,
+ ) -> Option {
+ Some(
+ Scrollbar::new(&self.scroll_handle)
+ .scroll_size(content)
+ .when_some(self.shared.tiles_scrollbar_mode(), |this, mode| {
+ this.mode(mode)
+ })
+ .into_any_element(),
+ )
+ }
+
+ fn grid_size(&self, cx: &App) -> Pixels {
+ cx.theme().tile_grid_size
+ }
+}
diff --git a/crates/dock/src/window_controls.rs b/crates/dock/src/window_controls.rs
new file mode 100644
index 0000000..4a695be
--- /dev/null
+++ b/crates/dock/src/window_controls.rs
@@ -0,0 +1,170 @@
+use gpui::prelude::FluentBuilder as _;
+use gpui::{
+ App, Hsla, InteractiveElement, IntoElement, MouseButton, ParentElement, RenderOnce,
+ StatefulInteractiveElement, Styled, Window, div, px,
+};
+use gpui_component::{ActiveTheme, Icon, IconName, Sizable as _, h_flex};
+
+use crate::TAB_BAR_HEIGHT;
+
+/// The standard width of a window control button.
+const CONTROL_WIDTH: f32 = 34.;
+
+#[derive(IntoElement, Clone)]
+enum ControlIcon {
+ Minimize,
+ Restore,
+ Maximize,
+ Close,
+}
+
+impl ControlIcon {
+ fn minimize() -> Self {
+ Self::Minimize
+ }
+
+ fn restore() -> Self {
+ Self::Restore
+ }
+
+ fn maximize() -> Self {
+ Self::Maximize
+ }
+
+ fn close() -> Self {
+ Self::Close
+ }
+
+ fn id(&self) -> &'static str {
+ match self {
+ Self::Minimize => "minimize",
+ Self::Restore => "restore",
+ Self::Maximize => "maximize",
+ Self::Close => "close",
+ }
+ }
+
+ fn icon(&self) -> IconName {
+ match self {
+ Self::Minimize => IconName::WindowMinimize,
+ Self::Restore => IconName::WindowRestore,
+ Self::Maximize => IconName::WindowMaximize,
+ Self::Close => IconName::WindowClose,
+ }
+ }
+
+ fn window_control_area(&self) -> gpui::WindowControlArea {
+ match self {
+ Self::Minimize => gpui::WindowControlArea::Min,
+ Self::Restore | Self::Maximize => gpui::WindowControlArea::Max,
+ Self::Close => gpui::WindowControlArea::Close,
+ }
+ }
+
+ fn is_close(&self) -> bool {
+ matches!(self, Self::Close)
+ }
+
+ #[inline]
+ fn hover_fg(&self, cx: &App) -> Hsla {
+ if self.is_close() {
+ cx.theme().danger_foreground
+ } else {
+ cx.theme().secondary_foreground
+ }
+ }
+
+ #[inline]
+ fn hover_bg(&self, cx: &App) -> Hsla {
+ if self.is_close() {
+ cx.theme().danger
+ } else {
+ cx.theme().secondary_hover
+ }
+ }
+
+ #[inline]
+ fn active_bg(&self, cx: &mut App) -> Hsla {
+ if self.is_close() {
+ cx.theme().danger_active
+ } else {
+ cx.theme().secondary_active
+ }
+ }
+}
+
+impl RenderOnce for ControlIcon {
+ fn render(self, _: &mut Window, cx: &mut App) -> impl IntoElement {
+ let is_linux = cfg!(target_os = "linux");
+ let is_windows = cfg!(target_os = "windows");
+ let hover_fg = self.hover_fg(cx);
+ let hover_bg = self.hover_bg(cx);
+ let active_bg = self.active_bg(cx);
+ let icon = self.clone();
+
+ div()
+ .id(self.id())
+ .flex()
+ .w(px(CONTROL_WIDTH))
+ .h_full()
+ .flex_shrink_0()
+ .justify_center()
+ .content_center()
+ .items_center()
+ .text_color(cx.theme().foreground)
+ .hover(|style| style.bg(hover_bg).text_color(hover_fg))
+ .active(|style| style.bg(active_bg).text_color(hover_fg))
+ .when(is_windows, |this| {
+ this.window_control_area(self.window_control_area())
+ })
+ .when(is_linux, |this| {
+ this.on_mouse_down(MouseButton::Left, move |_, window, cx| {
+ window.prevent_default();
+ cx.stop_propagation();
+ })
+ .on_click(move |_, window, cx| {
+ cx.stop_propagation();
+ match icon {
+ Self::Minimize => window.minimize_window(),
+ Self::Restore | Self::Maximize => window.zoom_window(),
+ Self::Close => window.remove_window(),
+ }
+ })
+ })
+ .child(Icon::new(self.icon()).small())
+ }
+}
+
+pub(crate) fn window_controls(window: &mut Window, cx: &mut App) -> impl IntoElement {
+ if cfg!(target_os = "macos") || cfg!(target_family = "wasm") {
+ return div().id("window-controls");
+ }
+
+ let supported = window.window_controls();
+
+ h_flex()
+ .id("window-controls")
+ .items_center()
+ .flex_shrink_0()
+ .h_full()
+ // Like native windows apps, the controls span the title bar but never
+ // grow past the tab bar height.
+ .when(cfg!(target_os = "windows"), |this| {
+ this.max_h(TAB_BAR_HEIGHT)
+ })
+ .border_l_1()
+ .border_b_1()
+ .border_color(cx.theme().border)
+ .bg(cx.theme().tokens.tab_bar)
+ .when(supported.minimize, |this| {
+ this.child(ControlIcon::minimize())
+ })
+ .when(supported.maximize, |this| {
+ this.child(if window.is_maximized() {
+ ControlIcon::restore()
+ } else {
+ ControlIcon::maximize()
+ })
+ })
+ .child(ControlIcon::close())
+}
diff --git a/crates/dock/tests/render_smoke.rs b/crates/dock/tests/render_smoke.rs
new file mode 100644
index 0000000..02eed70
--- /dev/null
+++ b/crates/dock/tests/render_smoke.rs
@@ -0,0 +1,99 @@
+//! Render-path smoke tests: the skin reads the dock area while rendering, and
+//! GPUI panics if an entity is read while it is leased (being updated). These
+//! pin that the first frame — docks, groups, tab bars — renders without
+//! tripping the lease check.
+
+use dock::{BasePanel, Panel, SignedDockSkin, panel_handle};
+use gpui::{
+ App, AppContext, Context, Empty, EventEmitter, FocusHandle, Focusable, IntoElement, Render,
+ TestAppContext, Window,
+};
+use gpui_base::dock::{DockArea, DockLayout, DockPlacement, PanelEvent};
+
+struct Probe {
+ focus_handle: FocusHandle,
+}
+
+impl Probe {
+ fn new(cx: &mut Context) -> Self {
+ Self {
+ focus_handle: cx.focus_handle(),
+ }
+ }
+}
+
+impl BasePanel for Probe {
+ fn panel_name(&self) -> &'static str {
+ "Probe"
+ }
+}
+
+impl Panel for Probe {
+ fn title(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
+ "Probe"
+ }
+}
+
+impl EventEmitter for Probe {}
+
+impl Focusable for Probe {
+ fn focus_handle(&self, _: &App) -> FocusHandle {
+ self.focus_handle.clone()
+ }
+}
+
+impl Render for Probe {
+ fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
+ Empty
+ }
+}
+
+#[gpui::test]
+fn the_first_frame_renders_the_area_and_its_docks(cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ gpui_component::init(cx);
+ });
+ let (area, cx) = cx.add_window_view(|window, cx| {
+ let skin = SignedDockSkin::new(cx);
+ DockArea::new("test", None, window, cx).with_renderer(skin)
+ });
+
+ let bottom = cx.update(|_, cx| cx.new(Probe::new));
+ cx.update(|window, cx| {
+ let left = cx.new(Probe::new);
+ let center = cx.new(Probe::new);
+
+ area.update(cx, |area, cx| {
+ area.set_dock(
+ DockPlacement::Left,
+ DockLayout::tabs().panel_view(panel_handle(left), cx),
+ window,
+ cx,
+ );
+ area.set_center(
+ DockLayout::tabs().panel_view(panel_handle(center), cx),
+ window,
+ cx,
+ );
+ area.set_dock(
+ DockPlacement::Bottom,
+ DockLayout::tabs().panel_view(panel_handle(bottom.clone()), cx),
+ window,
+ cx,
+ );
+ });
+ });
+
+ // The first frame walks every render hook — the dock frame, each group's
+ // tab bar, the toolbar — all of which read the dock area.
+ cx.update(|window, cx| window.draw(cx).clear(cx));
+
+ // Emptying a dock leaves an empty group behind; its render must also be
+ // safe (and draw nothing).
+ cx.update(|window, cx| {
+ area.update(cx, |area, cx| {
+ area.remove_panel(bottom, window, cx);
+ });
+ });
+ cx.update(|window, cx| window.draw(cx).clear(cx));
+}
diff --git a/crates/paths/Cargo.toml b/crates/paths/Cargo.toml
new file mode 100644
index 0000000..da558cc
--- /dev/null
+++ b/crates/paths/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "paths"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+dirs = "6"
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
new file mode 100644
index 0000000..9d51d04
--- /dev/null
+++ b/crates/paths/src/lib.rs
@@ -0,0 +1,166 @@
+//! Paths to locations used by Signed.
+//!
+//! Follows the same pattern as Zed's `paths` crate: platform-correct base
+//! directories, resolved once and cached, with an optional custom data dir
+//! override for portable/dev installs.
+
+use std::path::PathBuf;
+use std::sync::OnceLock;
+
+/// The application name, used to derive platform-specific data, config and
+/// cache directory paths.
+pub const APP_NAME: &str = "Signed";
+
+/// Lowercased form of [`APP_NAME`], for use in XDG-style paths on
+/// Linux/FreeBSD and the macOS `~/.config` fallback.
+pub const APP_NAME_LOWERCASE: &str = "signed";
+
+/// A custom data directory override, set only by [`set_custom_data_dir`].
+static CUSTOM_DATA_DIR: OnceLock = OnceLock::new();
+
+/// The resolved data directory.
+/// On macOS, this is `~/Library/Application Support/Signed`.
+/// On Linux/FreeBSD, this is `$XDG_DATA_HOME/signed`.
+/// On Windows, this is `%LOCALAPPDATA%\Signed`.
+static CURRENT_DATA_DIR: OnceLock = OnceLock::new();
+
+/// The resolved config directory.
+/// On macOS, this is `~/.config/signed`.
+/// On Linux/FreeBSD, this is `$XDG_CONFIG_HOME/signed`.
+/// On Windows, this is `%APPDATA%\Signed`.
+static CONFIG_DIR: OnceLock = OnceLock::new();
+
+/// Returns the current user's home directory.
+pub fn home_dir() -> PathBuf {
+ dirs::home_dir().expect("failed to determine home directory")
+}
+
+/// Sets a custom directory for all user data, overriding the default data
+/// directory. Must be called before any other path operation. The directory
+/// is created if it doesn't exist and canonicalized to an absolute path.
+///
+/// # Panics
+///
+/// Panics if called after [`data_dir`] or [`config_dir`] was initialized, or
+/// if the directory cannot be created/canonicalized.
+pub fn set_custom_data_dir(dir: &str) -> &'static PathBuf {
+ if CURRENT_DATA_DIR.get().is_some() || CONFIG_DIR.get().is_some() {
+ panic!("set_custom_data_dir called after data_dir or config_dir was initialized");
+ }
+
+ CUSTOM_DATA_DIR.get_or_init(|| {
+ let path = PathBuf::from(dir);
+ std::fs::create_dir_all(&path).expect("failed to create custom data directory");
+ path.canonicalize()
+ .expect("failed to canonicalize custom data directory")
+ })
+}
+
+/// Returns the path to the configuration directory.
+pub fn config_dir() -> &'static PathBuf {
+ CONFIG_DIR.get_or_init(|| {
+ if let Some(custom_dir) = CUSTOM_DATA_DIR.get() {
+ custom_dir.join("config")
+ } else if cfg!(target_os = "windows") {
+ dirs::config_dir()
+ .expect("failed to determine RoamingAppData directory")
+ .join(APP_NAME)
+ } else if cfg!(any(target_os = "linux", target_os = "freebsd")) {
+ if let Ok(flatpak_xdg_config) = std::env::var("FLATPAK_XDG_CONFIG_HOME") {
+ flatpak_xdg_config.into()
+ } else {
+ dirs::config_dir().expect("failed to determine XDG_CONFIG_HOME directory")
+ }
+ .join(APP_NAME_LOWERCASE)
+ } else {
+ home_dir().join(".config").join(APP_NAME_LOWERCASE)
+ }
+ })
+}
+
+/// Returns the path to the data directory.
+pub fn data_dir() -> &'static PathBuf {
+ CURRENT_DATA_DIR.get_or_init(|| {
+ if let Some(custom_dir) = CUSTOM_DATA_DIR.get() {
+ custom_dir.clone()
+ } else if cfg!(target_os = "macos") {
+ home_dir()
+ .join("Library/Application Support")
+ .join(APP_NAME)
+ } else if cfg!(any(target_os = "linux", target_os = "freebsd")) {
+ if let Ok(flatpak_xdg_data) = std::env::var("FLATPAK_XDG_DATA_HOME") {
+ flatpak_xdg_data.into()
+ } else {
+ dirs::data_local_dir().expect("failed to determine XDG_DATA_HOME directory")
+ }
+ .join(APP_NAME_LOWERCASE)
+ } else if cfg!(target_os = "windows") {
+ dirs::data_local_dir()
+ .expect("failed to determine LocalAppData directory")
+ .join(APP_NAME)
+ } else {
+ config_dir().clone()
+ }
+ })
+}
+
+/// Returns the path to the cache directory.
+pub fn cache_dir() -> &'static PathBuf {
+ static CACHE_DIR: OnceLock = OnceLock::new();
+ CACHE_DIR.get_or_init(|| {
+ if cfg!(target_os = "macos") {
+ dirs::cache_dir()
+ .expect("failed to determine caches directory")
+ .join(APP_NAME)
+ } else if cfg!(target_os = "windows") {
+ dirs::cache_dir()
+ .expect("failed to determine LocalAppData directory")
+ .join(APP_NAME)
+ } else if cfg!(any(target_os = "linux", target_os = "freebsd")) {
+ if let Ok(flatpak_xdg_cache) = std::env::var("FLATPAK_XDG_CACHE_HOME") {
+ flatpak_xdg_cache.into()
+ } else {
+ dirs::cache_dir().expect("failed to determine XDG_CACHE_HOME directory")
+ }
+ .join(APP_NAME_LOWERCASE)
+ } else {
+ home_dir().join(".cache").join(APP_NAME_LOWERCASE)
+ }
+ })
+}
+
+/// Returns the path to the logs directory.
+pub fn logs_dir() -> &'static PathBuf {
+ static LOGS_DIR: OnceLock = OnceLock::new();
+ LOGS_DIR.get_or_init(|| {
+ if cfg!(target_os = "macos") {
+ home_dir().join("Library/Logs").join(APP_NAME)
+ } else {
+ data_dir().join("logs")
+ }
+ })
+}
+
+/// Returns the path to the nostr database directory (LMDB).
+pub fn nostr_dir() -> &'static PathBuf {
+ static NOSTR_DIR: OnceLock = OnceLock::new();
+ NOSTR_DIR.get_or_init(|| data_dir().join("nostr"))
+}
+
+/// Returns the path to the local git clone cache (grasp mirrors).
+pub fn repos_dir() -> &'static PathBuf {
+ static REPOS_DIR: OnceLock = OnceLock::new();
+ REPOS_DIR.get_or_init(|| data_dir().join("repos"))
+}
+
+/// Returns the path to the `settings.json` file.
+pub fn settings_file() -> &'static PathBuf {
+ static SETTINGS_FILE: OnceLock = OnceLock::new();
+ SETTINGS_FILE.get_or_init(|| config_dir().join("settings.json"))
+}
+
+/// Returns the path to the `keymap.json` file.
+pub fn keymap_file() -> &'static PathBuf {
+ static KEYMAP_FILE: OnceLock = OnceLock::new();
+ KEYMAP_FILE.get_or_init(|| config_dir().join("keymap.json"))
+}
diff --git a/crates/signed_core/Cargo.toml b/crates/signed_core/Cargo.toml
index 5b1e5ca..bd77e36 100644
--- a/crates/signed_core/Cargo.toml
+++ b/crates/signed_core/Cargo.toml
@@ -5,4 +5,5 @@ edition.workspace = true
publish.workspace = true
[dependencies]
+gpui.workspace = true
nostr.workspace = true
diff --git a/crates/signed_core/src/addr.rs b/crates/signed_core/src/addr.rs
index 79df08b..0a7bc51 100644
--- a/crates/signed_core/src/addr.rs
+++ b/crates/signed_core/src/addr.rs
@@ -1,44 +1,13 @@
-use std::fmt;
-use std::str::FromStr;
-
use nostr::prelude::*;
/// Address of a NIP-34 repository announcement: `30617::`.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RepoAddr {
- pub owner: PublicKey,
- pub id: String,
-}
-
-impl RepoAddr {
- pub fn new(owner: PublicKey, id: impl Into) -> Self {
- Self {
- owner,
- id: id.into(),
- }
- }
-
- /// The NIP-33 coordinate for the announcement event (`a` tag value).
- pub fn coordinate(&self) -> Coordinate {
- Coordinate::new(Kind::GitRepoAnnouncement, self.owner).identifier(self.id.clone())
- }
-}
-
-impl fmt::Display for RepoAddr {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "{}", self.coordinate())
- }
-}
-
-impl FromStr for RepoAddr {
- type Err = nostr::error::Error;
-
- /// Parse from `::`, `naddr1...` bech32 or `nostr:naddr1...` URI.
- fn from_str(s: &str) -> Result {
- let coordinate = Coordinate::parse(s)?;
- Ok(Self {
- owner: coordinate.public_key,
- id: coordinate.identifier,
- })
- }
+///
+/// The Rust Nostr SDK's [`Coordinate`] already provides parsing, formatting
+/// and hashing for this; the alias keeps the repository-specific vocabulary
+/// while reusing the SDK type.
+pub type RepoAddr = Coordinate;
+
+/// Build the address of a NIP-34 repository announcement.
+pub fn repo_addr(owner: PublicKey, id: impl Into) -> RepoAddr {
+ Coordinate::new(Kind::GitRepoAnnouncement, owner).identifier(id)
}
diff --git a/crates/signed_core/src/annotations.rs b/crates/signed_core/src/annotations.rs
new file mode 100644
index 0000000..1541b22
--- /dev/null
+++ b/crates/signed_core/src/annotations.rs
@@ -0,0 +1,306 @@
+use nostr::prelude::*;
+
+/// ngit / GitWorkshop cover-note extension (kind 1624): a markdown note
+/// attached to an issue, patch or PR by its author or a repository
+/// maintainer. Not part of the NIP-34 draft; read support for interop.
+pub const COVER_NOTE_KIND: Kind = Kind::Custom(1624);
+
+/// Whether a kind-1985 label event is a valid annotation of `root`: it
+/// references the root via a lowercase `e` tag and was authored by the root
+/// author or a maintainer.
+fn label_targets_root(event: &Event, root: &Event, maintainers: &[PublicKey]) -> bool {
+ if event.kind != Kind::Label {
+ return false;
+ }
+ if event.pubkey != root.pubkey && !maintainers.contains(&event.pubkey) {
+ return false;
+ }
+ let root_id = root.id.to_hex();
+ event
+ .tags
+ .iter()
+ .any(|tag| tag.kind() == "e" && tag.content().is_some_and(|content| content == root_id))
+}
+
+/// Whether a kind-1985 label event declares the `#t` namespace and carries at
+/// least one `["l", "", "#t"]` label.
+fn has_hashtag_labels(event: &Event) -> bool {
+ event.tags.iter().any(|tag| tag.as_slice() == ["L", "#t"])
+ && event.tags.iter().any(|tag| {
+ let slice = tag.as_slice();
+ slice.len() >= 3 && slice[0] == "l" && slice[2] == "#t" && !slice[1].is_empty()
+ })
+}
+
+/// The effective hashtag labels of `root`: the `t` tags on the event itself
+/// (self-reported by its author) plus all labels attached via authorized
+/// NIP-32 kind-1985 events in the `#t` namespace. Labels are additive — all
+/// valid label events contribute (no latest-wins semantics).
+pub fn labels(root: &Event, label_events: &[Event], maintainers: &[PublicKey]) -> Vec {
+ let mut labels: Vec = root
+ .tags
+ .hashtags()
+ .map(|hashtag| hashtag.to_string())
+ .collect();
+
+ for event in label_events {
+ if !label_targets_root(event, root, maintainers) || !has_hashtag_labels(event) {
+ continue;
+ }
+ for tag in event.tags.iter() {
+ let slice = tag.as_slice();
+ if slice.len() >= 3 && slice[0] == "l" && slice[2] == "#t" && !slice[1].is_empty() {
+ let label = &slice[1];
+ if !labels.contains(label) {
+ labels.push(label.clone());
+ }
+ }
+ }
+ }
+
+ labels
+}
+
+/// The effective subject/title override of `root`, from authorized kind-1985
+/// label events in the `#subject` namespace. Only the latest event wins
+/// (tiebreak: lexicographically larger event id, per NIP-01 replaceable
+/// semantics). Returns `None` when no valid override exists.
+pub fn subject_override(
+ root: &Event,
+ label_events: &[Event],
+ maintainers: &[PublicKey],
+) -> Option {
+ label_events
+ .iter()
+ .filter(|event| label_targets_root(event, root, maintainers))
+ .filter(|event| {
+ event
+ .tags
+ .iter()
+ .any(|tag| tag.as_slice() == ["L", "#subject"])
+ && event.tags.iter().any(|tag| {
+ let slice = tag.as_slice();
+ slice.len() >= 3
+ && slice[0] == "l"
+ && slice[2] == "#subject"
+ && !slice[1].is_empty()
+ })
+ })
+ .max_by(|a, b| {
+ a.created_at
+ .cmp(&b.created_at)
+ .then_with(|| a.id.to_string().cmp(&b.id.to_string()))
+ })
+ .and_then(|event| {
+ event.tags.iter().find_map(|tag| {
+ let slice = tag.as_slice();
+ (slice.len() >= 3
+ && slice[0] == "l"
+ && slice[2] == "#subject"
+ && !slice[1].is_empty())
+ .then(|| slice[1].clone())
+ })
+ })
+}
+
+/// The effective hashtag labels and subject override of `root` in one pass
+/// (mirrors ngit's `get_labels_and_subject`).
+pub fn labels_and_subject(
+ root: &Event,
+ label_events: &[Event],
+ maintainers: &[PublicKey],
+) -> (Vec, Option) {
+ (
+ labels(root, label_events, maintainers),
+ subject_override(root, label_events, maintainers),
+ )
+}
+
+/// The effective cover note of `root`: the latest authorized kind-1624 event
+/// (tiebreak: lexicographically larger event id, per NIP-01 replaceable
+/// semantics). Returns `None` when no valid cover note exists.
+pub fn cover_note<'a>(
+ root: &Event,
+ cover_notes: &'a [Event],
+ maintainers: &[PublicKey],
+) -> Option<&'a Event> {
+ let root_id = root.id.to_hex();
+
+ cover_notes
+ .iter()
+ .filter(|event| {
+ event.kind == COVER_NOTE_KIND
+ && (event.pubkey == root.pubkey || maintainers.contains(&event.pubkey))
+ && event.tags.iter().any(|tag| {
+ tag.kind() == "e" && tag.content().is_some_and(|content| content == root_id)
+ })
+ })
+ .max_by(|a, b| {
+ a.created_at
+ .cmp(&b.created_at)
+ .then_with(|| a.id.to_string().cmp(&b.id.to_string()))
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn keys_from_hex(hex: &str) -> Keys {
+ Keys::new(SecretKey::from_hex(hex).expect("valid secret key"))
+ }
+
+ fn signed(author: &Keys, kind: Kind, tags: Vec, created_at: u64) -> Event {
+ EventBuilder::new(kind, "")
+ .tags(tags)
+ .custom_created_at(Timestamp::from(created_at))
+ .finalize(author)
+ .expect("signed event")
+ }
+
+ fn root_event() -> Event {
+ signed(
+ &keys_from_hex("0000000000000000000000000000000000000000000000000000000000000001"),
+ Kind::GitIssue,
+ vec![Tag::hashtag("bug")],
+ 100,
+ )
+ }
+
+ fn e_tag(event: &Event) -> Tag {
+ Tag::parse(["e", &event.id.to_hex()]).expect("valid e tag")
+ }
+
+ #[test]
+ fn labels_take_inline_hashtags_and_external_label_events() {
+ let root = root_event();
+ let maintainer =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
+ let labels_event = signed(
+ &maintainer,
+ Kind::Label,
+ vec![
+ e_tag(&root),
+ Tag::parse(["L", "#t"]).expect("valid L tag"),
+ Tag::parse(["l", "help-wanted", "#t"]).expect("valid l tag"),
+ ],
+ 200,
+ );
+
+ let labels = labels(&root, &[labels_event], &[maintainer.public_key()]);
+
+ assert_eq!(labels, vec!["bug", "help-wanted"]);
+ }
+
+ #[test]
+ fn labels_ignore_unauthorized_and_misnamed_events() {
+ let root = root_event();
+ let maintainer =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
+ let stranger =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000003");
+
+ // A stranger's label event is not authorized.
+ let stranger_labels = signed(
+ &stranger,
+ Kind::Label,
+ vec![
+ e_tag(&root),
+ Tag::parse(["L", "#t"]).expect("valid L tag"),
+ Tag::parse(["l", "nope", "#t"]).expect("valid l tag"),
+ ],
+ 200,
+ );
+ // A valid author referencing a different event.
+ let other_labels = signed(
+ &maintainer,
+ Kind::Label,
+ vec![
+ Tag::parse([
+ "e",
+ "2222222222222222222222222222222222222222222222222222222222222222",
+ ])
+ .expect("valid e tag"),
+ Tag::parse(["L", "#t"]).expect("valid L tag"),
+ Tag::parse(["l", "nope", "#t"]).expect("valid l tag"),
+ ],
+ 200,
+ );
+ // A valid author without the namespace declaration.
+ let missing_namespace = signed(
+ &maintainer,
+ Kind::Label,
+ vec![
+ e_tag(&root),
+ Tag::parse(["l", "nope", "#t"]).expect("valid l tag"),
+ ],
+ 200,
+ );
+
+ assert_eq!(
+ labels(
+ &root,
+ &[stranger_labels, other_labels, missing_namespace],
+ &[maintainer.public_key()]
+ ),
+ vec!["bug"]
+ );
+ }
+
+ #[test]
+ fn subject_override_latest_authorized_event_wins() {
+ let root = root_event();
+ let maintainer =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
+ let older = signed(
+ &maintainer,
+ Kind::Label,
+ vec![
+ e_tag(&root),
+ Tag::parse(["L", "#subject"]).expect("valid L tag"),
+ Tag::parse(["l", "Old title", "#subject"]).expect("valid l tag"),
+ ],
+ 200,
+ );
+ let newer = signed(
+ &maintainer,
+ Kind::Label,
+ vec![
+ e_tag(&root),
+ Tag::parse(["L", "#subject"]).expect("valid L tag"),
+ Tag::parse(["l", "New title", "#subject"]).expect("valid l tag"),
+ ],
+ 300,
+ );
+
+ assert_eq!(
+ subject_override(&root, &[newer, older], &[maintainer.public_key()]),
+ Some("New title".to_owned())
+ );
+ }
+
+ #[test]
+ fn cover_note_latest_authorized_event_wins() {
+ let root = root_event();
+ let maintainer =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
+ let stranger =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000003");
+ let older = signed(&maintainer, COVER_NOTE_KIND, vec![e_tag(&root)], 200);
+ let newer = signed(&maintainer, COVER_NOTE_KIND, vec![e_tag(&root)], 300);
+ let unauthorized = signed(&stranger, COVER_NOTE_KIND, vec![e_tag(&root)], 400);
+
+ let newer_id = newer.id;
+ let events = [older, unauthorized, newer];
+ let maintainers = [maintainer.public_key()];
+ let note = cover_note(&root, &events, &maintainers);
+ assert_eq!(note.map(|event| event.id), Some(newer_id));
+ }
+
+ #[test]
+ fn cover_note_none_without_valid_events() {
+ let root = root_event();
+
+ assert_eq!(cover_note(&root, &[], &[]), None);
+ }
+}
diff --git a/crates/signed_core/src/clone_url.rs b/crates/signed_core/src/clone_url.rs
index 19772cc..ca5cc94 100644
--- a/crates/signed_core/src/clone_url.rs
+++ b/crates/signed_core/src/clone_url.rs
@@ -28,10 +28,7 @@ pub fn parse_clone_url(url: &str) -> Option {
if first.starts_with("naddr1") {
let coordinate = Nip19Coordinate::from_bech32(first).ok()?;
- return Some(CloneTarget::Addr(RepoAddr::new(
- coordinate.coordinate.public_key,
- coordinate.coordinate.identifier,
- )));
+ return Some(CloneTarget::Addr(coordinate.coordinate));
}
let (relay_hint, identifier) = match third {
diff --git a/crates/signed_core/src/comments.rs b/crates/signed_core/src/comments.rs
new file mode 100644
index 0000000..1715cf6
--- /dev/null
+++ b/crates/signed_core/src/comments.rs
@@ -0,0 +1,161 @@
+use std::collections::{HashMap, HashSet};
+
+use nostr::prelude::*;
+
+/// A NIP-22 comment thread: a top-level comment on the root event and its
+/// nested replies (oldest first at every level).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CommentThread {
+ /// The thread's top-level comment.
+ pub comment: Event,
+ /// Replies to [`Self::comment`], nested recursively.
+ pub replies: Vec,
+}
+
+/// The direct parent of a comment (NIP-22 lowercase `e` tag), or `None` for
+/// comments without one.
+fn comment_parent(event: &Event) -> Option {
+ event
+ .tags
+ .iter()
+ .find(|tag| tag.kind() == "e")
+ .and_then(Tag::content)
+ .and_then(|id| EventId::parse(id).ok())
+}
+
+/// Group the comments on a root event (issue / patch / PR) into NIP-22
+/// threads. A comment whose parent is the root itself starts a thread; other
+/// comments nest under their parent comment. Threads and replies are ordered
+/// oldest-first. Replies whose parent comment is missing (e.g. not fetched)
+/// are placed as top-level threads so they are not dropped.
+pub fn comment_threads(root: &Event, comments: &[Event]) -> Vec {
+ // Index comments by their parent id. Comments without a parent tag are
+ // treated as replying to the root event itself.
+ let mut children: HashMap> = HashMap::new();
+ for comment in comments {
+ let parent = comment_parent(comment).unwrap_or(root.id);
+ children.entry(parent).or_default().push(comment);
+ }
+ for list in children.values_mut() {
+ list.sort_by_key(|event| event.created_at);
+ }
+
+ let mut visited: HashSet = HashSet::new();
+
+ fn build(
+ id: EventId,
+ children: &HashMap>,
+ visited: &mut HashSet,
+ ) -> Vec {
+ let Some(list) = children.get(&id) else {
+ return Vec::new();
+ };
+ let mut threads = Vec::new();
+ for event in list {
+ // Guards against malformed reply cycles.
+ if visited.insert(event.id) {
+ threads.push(CommentThread {
+ comment: (*event).clone(),
+ replies: build(event.id, children, visited),
+ });
+ }
+ }
+ threads
+ }
+
+ let mut threads = build(root.id, &children, &mut visited);
+
+ // Orphan replies: their parent comment is unknown, so they never appear
+ // in the tree rooted at the root event; surface them as top-level threads.
+ let mut orphans: Vec<&Event> = comments
+ .iter()
+ .filter(|event| !visited.contains(&event.id))
+ .collect();
+ orphans.sort_by_key(|event| event.created_at);
+ for comment in orphans {
+ if visited.insert(comment.id) {
+ threads.push(CommentThread {
+ comment: comment.clone(),
+ replies: build(comment.id, &children, &mut visited),
+ });
+ }
+ }
+
+ threads
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn comment(keys: &Keys, parent: Option<&Event>, content: &str, created_at: u64) -> Event {
+ let tags = parent
+ .map(|parent| vec![Tag::parse(["e", &parent.id.to_hex()]).expect("valid e tag")])
+ .unwrap_or_default();
+ EventBuilder::new(Kind::Comment, content)
+ .tags(tags)
+ .custom_created_at(Timestamp::from(created_at))
+ .finalize(keys)
+ .expect("signed event")
+ }
+
+ fn flatten(threads: &[CommentThread]) -> Vec {
+ let mut out = Vec::new();
+ for thread in threads {
+ out.push(thread.comment.content.clone());
+ out.extend(flatten(&thread.replies));
+ }
+ out
+ }
+
+ #[test]
+ fn nests_replies_under_their_parents() {
+ let keys = Keys::generate();
+ let root = EventBuilder::new(Kind::GitIssue, "issue")
+ .finalize(&keys)
+ .expect("signed event");
+
+ let a = comment(&keys, Some(&root), "a", 100);
+ let a1 = comment(&keys, Some(&a), "a1", 200);
+ let a2 = comment(&keys, Some(&a), "a2", 300);
+ let b = comment(&keys, Some(&root), "b", 150);
+
+ let threads = comment_threads(&root, &[a2, b, a, a1]);
+
+ assert_eq!(flatten(&threads), vec!["a", "a1", "a2", "b"]);
+ }
+
+ #[test]
+ fn comments_without_a_parent_tag_attach_to_the_root() {
+ let keys = Keys::generate();
+ let root = EventBuilder::new(Kind::GitIssue, "issue")
+ .finalize(&keys)
+ .expect("signed event");
+
+ // Old-style comments carried no `e` tag at all.
+ let orphan = comment(&keys, None, "no parent", 100);
+
+ let threads = comment_threads(&root, &[orphan]);
+
+ assert_eq!(flatten(&threads), vec!["no parent"]);
+ }
+
+ #[test]
+ fn orphan_replies_are_surfaced_as_top_level_threads() {
+ let keys = Keys::generate();
+ let root = EventBuilder::new(Kind::GitIssue, "issue")
+ .finalize(&keys)
+ .expect("signed event");
+ let a = comment(&keys, Some(&root), "a", 100);
+
+ // `missing` is not in the comment set; its reply should still show up.
+ let missing = EventBuilder::new(Kind::Comment, "missing")
+ .finalize(&keys)
+ .expect("signed event");
+ let reply_to_missing = comment(&keys, Some(&missing), "reply to missing", 200);
+
+ let threads = comment_threads(&root, &[a, reply_to_missing]);
+
+ assert_eq!(flatten(&threads), vec!["a", "reply to missing"]);
+ }
+}
diff --git a/crates/signed_core/src/deletions.rs b/crates/signed_core/src/deletions.rs
new file mode 100644
index 0000000..131c1b0
--- /dev/null
+++ b/crates/signed_core/src/deletions.rs
@@ -0,0 +1,79 @@
+use std::collections::HashSet;
+
+use nostr::prelude::*;
+
+/// NIP-09 deletion requests and NIP-62 vanish requests, used to hide
+/// deleted events before they reach the UI.
+///
+/// Built from the kind-5 / kind-62 events stored in the local database;
+/// pass any event through [`Deletions::is_deleted`] before displaying it.
+pub struct Deletions {
+ /// `(deleted event id, expected author)` from `e` tags of kind-5 events.
+ ids: HashSet<(EventId, PublicKey)>,
+ /// `(coordinate, expected author, cutoff)` from `a` tags of kind-5 events.
+ /// All versions of the addressable event up to `cutoff` are deleted.
+ coords: Vec<(Coordinate, PublicKey, Timestamp)>,
+ /// `(author, cutoff)` from kind-62 vanish requests.
+ vanished: Vec<(PublicKey, Timestamp)>,
+}
+
+impl Deletions {
+ /// Build the deletion index from raw kind-5 and kind-62 events.
+ pub fn from_events(events: impl IntoIterator- ) -> Self {
+ let mut ids = HashSet::new();
+ let mut coords = Vec::new();
+ let mut vanished = Vec::new();
+
+ for event in events {
+ if event.kind == Kind::EventDeletion {
+ ids.extend(event.tags.event_ids().map(|id| (id, event.pubkey)));
+ coords.extend(
+ event
+ .tags
+ .coordinates()
+ .map(|c| (c, event.pubkey, event.created_at)),
+ );
+ } else if event.kind == Kind::RequestToVanish {
+ // Client-side we can't verify which relay the request targeted,
+ // so any vanish request is honored for the author's events.
+ vanished.push((event.pubkey, event.created_at));
+ }
+ }
+
+ Self {
+ ids,
+ coords,
+ vanished,
+ }
+ }
+
+ /// Whether the event is covered by a valid deletion or vanish request.
+ ///
+ /// A request is only valid when its author matches the deleted event's
+ /// author (NIP-09); addressable events are deleted up to the request's
+ /// `created_at`.
+ pub fn is_deleted(&self, event: &Event) -> bool {
+ if self
+ .vanished
+ .iter()
+ .any(|(pk, cutoff)| *pk == event.pubkey && event.created_at <= *cutoff)
+ {
+ return true;
+ }
+
+ if self.ids.contains(&(event.id, event.pubkey)) {
+ return true;
+ }
+
+ if event.kind.is_addressable()
+ && let Some(identifier) = event.tags.identifier()
+ {
+ let coordinate = Coordinate::new(event.kind, event.pubkey).identifier(identifier);
+ return self.coords.iter().any(|(c, pk, cutoff)| {
+ *c == coordinate && *pk == event.pubkey && event.created_at <= *cutoff
+ });
+ }
+
+ false
+ }
+}
diff --git a/crates/signed_core/src/filters.rs b/crates/signed_core/src/filters.rs
index f275343..d11d929 100644
--- a/crates/signed_core/src/filters.rs
+++ b/crates/signed_core/src/filters.rs
@@ -1,14 +1,14 @@
-use nostr::filter::{Alphabet, SingleLetterTag};
use nostr::prelude::*;
use crate::RepoAddr;
/// Kinds that make up the activity of a repository.
-pub const ACTIVITY_KINDS: [Kind; 8] = [
+pub const ACTIVITY_KINDS: [Kind; 9] = [
Kind::GitPatch,
Kind::GitPullRequest,
Kind::GitPullRequestUpdate,
Kind::GitIssue,
+ Kind::Comment,
Kind::GitStatusOpen,
Kind::GitStatusApplied,
Kind::GitStatusClosed,
@@ -19,26 +19,25 @@ pub const ACTIVITY_KINDS: [Kind; 8] = [
pub fn announcement(addr: &RepoAddr) -> Filter {
Filter::new()
.kind(Kind::GitRepoAnnouncement)
- .author(addr.owner)
- .identifier(addr.id.clone())
+ .author(addr.public_key)
+ .identifier(addr.identifier.clone())
}
/// Latest state event (refs / HEAD) for a repository.
pub fn state(addr: &RepoAddr) -> Filter {
Filter::new()
.kind(Kind::RepoState)
- .author(addr.owner)
- .identifier(addr.id.clone())
+ .author(addr.public_key)
+ .identifier(addr.identifier.clone())
}
-/// All NIP-34 activity addressed to a repository (`#a` tag).
+/// All NIP-34 activity addressed to a repository (`#a` tag): issues, PRs,
+/// patches, statuses and comments (kind 1111).
///
/// Note: the `a` tag on status events is optional per NIP-34, so statuses
/// published without it won't be matched here.
pub fn activity(addr: &RepoAddr) -> Filter {
- Filter::new()
- .kinds(ACTIVITY_KINDS)
- .custom_tag(SingleLetterTag::lowercase(Alphabet::A), addr.to_string())
+ Filter::new().kinds(ACTIVITY_KINDS).coordinate(addr)
}
/// Status events (`1630..=1633`) referencing a specific root event (`#e` tag).
@@ -53,6 +52,15 @@ pub fn statuses_for(root: EventId) -> Filter {
.event(root)
}
+/// Cover notes (kind 1624) and NIP-32 label events (kind 1985) referencing a
+/// specific root event (`#e` tag), fetched per root like comments and
+/// statuses because they carry no repository `a` tag.
+pub fn annotations_for(root: EventId) -> Filter {
+ Filter::new()
+ .kinds([crate::COVER_NOTE_KIND, Kind::Label])
+ .event(root)
+}
+
/// A user's grasp list (kind `10317`).
pub fn grasp_list(public_key: PublicKey) -> Filter {
Filter::new()
@@ -60,6 +68,32 @@ pub fn grasp_list(public_key: PublicKey) -> Filter {
.author(public_key)
}
+/// NIP-22 comments (kind `1111`) referencing any of the given root events
+/// (issues, patches, PRs).
+///
+/// Comments are not addressed to the repository — they carry no `a` tag with
+/// the repo coordinate — so they must be fetched by their root reference
+/// instead. NIP-22 defines the uppercase `E` tag as the root of the thread
+/// (used by ngit) while some clients (including Signed itself) reference the
+/// root with a lowercase `e` tag, so both are matched.
+///
+/// Returns two filters because `#E` and `#e` conditions would be ANDed if
+/// combined into one.
+pub fn comments_for(roots: impl IntoIterator
- ) -> Vec
{
+ let roots: Vec = roots.into_iter().map(|id| id.to_hex()).collect();
+ if roots.is_empty() {
+ return Vec::new();
+ }
+ vec![
+ Filter::new()
+ .kind(Kind::Comment)
+ .custom_tags(SingleLetterTag::UPPERCASE_E, roots.clone()),
+ Filter::new()
+ .kind(Kind::Comment)
+ .custom_tags(SingleLetterTag::LOWERCASE_E, roots),
+ ]
+}
+
/// All repositories announced by an author.
pub fn announcements_by(public_key: PublicKey) -> Filter {
Filter::new()
@@ -68,8 +102,30 @@ pub fn announcements_by(public_key: PublicKey) -> Filter {
}
/// All repository announcements (for global discovery).
-pub fn all_announcements(limit: usize) -> Filter {
- Filter::new()
- .kind(Kind::GitRepoAnnouncement)
- .limit(limit)
+///
+/// Unbounded: intended for negentropy sync, which reconciles sets
+/// efficiently regardless of size. Local database queries with this
+/// filter are served by LMDB, so they stay fast as the database grows.
+pub fn all_announcements() -> Filter {
+ Filter::new().kind(Kind::GitRepoAnnouncement)
+}
+
+/// All deletion-related events (NIP-09 kind `5`, NIP-62 kind `62`).
+///
+/// Unbounded, like [`all_announcements`]: deletion requests must be known
+/// before any other event can be shown.
+pub fn deletions() -> Filter {
+ Filter::new().kinds([Kind::EventDeletion, Kind::RequestToVanish])
+}
+
+/// Deletion events relevant to a single repository: requests authored by
+/// the repository owner and requests addressed to the repository
+/// coordinate (`#a` tag).
+pub fn deletions_for_repo(addr: &RepoAddr) -> Vec {
+ vec![
+ Filter::new()
+ .kinds([Kind::EventDeletion, Kind::RequestToVanish])
+ .author(addr.public_key),
+ Filter::new().kind(Kind::EventDeletion).coordinate(addr),
+ ]
}
diff --git a/crates/signed_core/src/lib.rs b/crates/signed_core/src/lib.rs
index f4958fd..a19d715 100644
--- a/crates/signed_core/src/lib.rs
+++ b/crates/signed_core/src/lib.rs
@@ -1,10 +1,18 @@
pub mod addr;
+pub mod annotations;
pub mod clone_url;
+pub mod comments;
+pub mod deletions;
pub mod filters;
pub mod model;
+pub mod state;
pub mod status;
-pub use addr::RepoAddr;
+pub use addr::{RepoAddr, repo_addr};
+pub use annotations::{COVER_NOTE_KIND, cover_note, labels_and_subject, subject_override};
pub use clone_url::{CloneTarget, parse_clone_url};
-pub use model::Announcement;
+pub use comments::{CommentThread, comment_threads};
+pub use deletions::Deletions;
+pub use model::{Announcement, activity_subject, pull_request_patch};
+pub use state::{build_state, parse_state};
pub use status::{RepoStatus, references_root, resolve_status};
diff --git a/crates/signed_core/src/model.rs b/crates/signed_core/src/model.rs
index 199f09a..a4a9f83 100644
--- a/crates/signed_core/src/model.rs
+++ b/crates/signed_core/src/model.rs
@@ -1,26 +1,173 @@
+use gpui::SharedString;
use nostr::prelude::*;
/// Parsed NIP-34 repository announcement (plain data, ready for the UI).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Announcement {
+ /// Repository ID (`d` tag).
+ pub id: String,
/// Author of the announcement event.
pub owner: PublicKey,
/// When the announcement was published (for latest-wins resolution).
pub created_at: Timestamp,
- /// Repository ID (`d` tag).
- pub id: String,
- pub name: Option,
- pub description: Option,
+ pub name: Option,
+ pub description: Option,
/// Webpage URLs for browsing.
- pub web: Vec,
+ pub web: Vec,
/// URLs for `git clone`.
- pub clone: Vec,
+ pub clone: Vec,
/// Relays the repository monitors for patches and issues.
- pub relays: Vec,
+ pub relays: Vec,
/// Earliest unique commit ID (`r` tag with `euc` marker).
pub euc: Option,
/// Other recognized maintainers.
pub maintainers: Vec,
+ /// Value of a `u` tag, if any: this repository is a subordinate fork of
+ /// the referenced upstream (NIP-34).
+ pub upstream: Option,
+ /// Hashtags labelling the repository (`t` tags).
+ pub hashtags: Vec,
+}
+
+/// Subject of a NIP-34 issue or pull request event: the `subject` tag,
+/// falling back to the first non-empty line of the content.
+pub fn activity_subject(event: &Event) -> SharedString {
+ let subject = event
+ .tags
+ .iter()
+ .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+ Ok(Nip34Tag::Subject(subject)) => Some(subject),
+ _ => None,
+ });
+
+ subject
+ .map(SharedString::from)
+ .or_else(|| {
+ event
+ .content
+ .lines()
+ .map(str::trim)
+ .find(|line| !line.is_empty())
+ .map(SharedString::from)
+ })
+ .unwrap_or(SharedString::from("Untitled"))
+}
+
+/// The patch set of a pull request: the root patch event (kind `1617`) the
+/// PR references via its `e` tag, plus every patch of the set chained to it
+/// with NIP-10 `e` reply tags, in series order (oldest first). When the PR
+/// has no `e` tag, falls back to the patch producing the PR's tip commit
+/// (its `commit`/`r` tag, per NIP-34) and walks the reply chain backward to
+/// the root.
+///
+/// Returns an empty list when no patch event can be linked to the PR.
+pub fn pull_request_patches<'a>(
+ pr: &Event,
+ patches: impl IntoIterator- ,
+) -> Vec<&'a Event> {
+ let patches: Vec<&'a Event> = patches.into_iter().collect();
+
+ // The PR references its root patch via an `e` tag; follow the NIP-10
+ // reply chain forward from there (each patch of the set replies to the
+ // previous one). Among several replies (a revision), the newest wins.
+ if let Some(root_id) = pr.tags.event_ids().next()
+ && let Some(root) = patches.iter().find(|patch| patch.id == root_id)
+ {
+ return forward_series(root, &patches);
+ }
+
+ // No `e` tag: the last patch of the set carries the PR's tip commit in
+ // its `commit`/`r` tag; walk the reply chain backward to the root.
+ let Some(tip) = current_commit_of(pr) else {
+ return Vec::new();
+ };
+ let Some(last) = patches
+ .iter()
+ .filter(|patch| patch_produces_commit(patch, &tip))
+ .max_by_key(|patch| patch.created_at)
+ .copied()
+ else {
+ return Vec::new();
+ };
+
+ let mut series = vec![last];
+ loop {
+ let Some(prev_id) = series.last().unwrap().tags.event_ids().next() else {
+ break;
+ };
+ let Some(prev) = patches
+ .iter()
+ .find(|patch| patch.id == prev_id && !series.contains(patch))
+ .copied()
+ else {
+ break;
+ };
+ series.push(prev);
+ }
+ series.reverse();
+ series
+}
+
+/// The patch content of a pull request: the contents of every patch event of
+/// its patch set (see [`pull_request_patches`]) joined in series order,
+/// falling back to the PR's own content for older PRs that carried the
+/// patch inline.
+pub fn pull_request_patch<'a>(pr: &Event, patches: impl IntoIterator
- ) -> String {
+ let patches: Vec<&'a Event> = patches.into_iter().collect();
+ let series = pull_request_patches(pr, patches.iter().copied());
+ if series.is_empty() {
+ return pr.content.clone();
+ }
+ series
+ .iter()
+ .map(|patch| patch.content.as_str())
+ .collect::
>()
+ .join("\n")
+}
+
+/// The chain of patches replying to `root` (NIP-10 `e` tags), oldest first.
+fn forward_series<'a>(root: &'a Event, patches: &[&'a Event]) -> Vec<&'a Event> {
+ let mut series = vec![root];
+ loop {
+ let next = patches
+ .iter()
+ .filter(|patch| !series.contains(patch))
+ .filter(|patch| {
+ patch
+ .tags
+ .event_ids()
+ .any(|id| id == series.last().unwrap().id)
+ })
+ .max_by_key(|patch| patch.created_at);
+ let Some(next) = next else {
+ break;
+ };
+ series.push(next);
+ }
+ series
+}
+
+/// The `c` tag of an event (tip of the proposed branch), as hex.
+fn current_commit_of(event: &Event) -> Option {
+ event
+ .tags
+ .iter()
+ .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+ Ok(Nip34Tag::CurrentCommit(commit)) => Some(commit.to_string()),
+ _ => None,
+ })
+}
+
+/// Whether `patch` produces `commit` (its `commit` or `r` tag), so clients
+/// can find existing patches for a specific commit.
+fn patch_produces_commit(patch: &Event, commit: &str) -> bool {
+ patch
+ .tags
+ .iter()
+ .any(|tag| match Nip34Tag::parse(tag.as_slice()) {
+ Ok(Nip34Tag::Commit(c) | Nip34Tag::Reference(c)) => c.to_string() == commit,
+ _ => false,
+ })
}
impl Announcement {
@@ -30,45 +177,43 @@ impl Announcement {
return None;
}
- let mut id: Option = None;
- let mut name: Option = None;
- let mut description: Option = None;
- let mut web: Vec = Vec::new();
- let mut clone: Vec = Vec::new();
- let mut relays: Vec = Vec::new();
+ let id = event.tags.identifier()?;
+
+ let mut hashtags: Vec = Vec::new();
+ hashtags.extend(event.tags.hashtags().map(|t| t.to_string()));
+
+ let mut name: Option = None;
+ let mut description: Option = None;
+ let mut web: Vec = Vec::new();
+ let mut clone: Vec = Vec::new();
+ let mut relays: Vec = Vec::new();
let mut euc: Option = None;
let mut maintainers: Vec = Vec::new();
+ let mut upstream: Option = None;
for tag in event.tags.iter() {
- let values: &[String] = tag.as_slice();
- match tag.kind() {
- "d" => id = tag.content().map(str::to_owned),
- "name" => name = tag.content().map(str::to_owned),
- "description" => description = tag.content().map(str::to_owned),
- "web" => web.extend(values.iter().skip(1).cloned()),
- "clone" => clone.extend(values.iter().skip(1).cloned()),
- "relays" => relays.extend(values.iter().skip(1).cloned()),
- "r" => {
- if values.get(2).map(String::as_str) == Some("euc") {
- euc = tag.content().map(str::to_owned);
- }
- }
- "maintainers" => {
- maintainers.extend(
- values
- .iter()
- .skip(1)
- .filter_map(|v| PublicKey::from_hex(v).ok()),
- );
- }
+ match Nip34Tag::parse(tag.as_slice()) {
+ Ok(Nip34Tag::Name(value)) => name = Some(value.into()),
+ Ok(Nip34Tag::Description(value)) => description = Some(value.into()),
+ Ok(Nip34Tag::Web(urls)) => web.extend(urls),
+ Ok(Nip34Tag::Clone(urls)) => clone.extend(urls),
+ Ok(Nip34Tag::Relays(urls)) => relays.extend(urls),
+ Ok(Nip34Tag::EarliestUniqueCommitId(commit)) => euc = Some(commit.to_string()),
+ Ok(Nip34Tag::Maintainers(keys)) => maintainers.extend(keys),
_ => {}
}
+
+ // The `u` tag is not modelled by the SDK's `Nip34Tag`; parse it
+ // manually (first value wins).
+ if upstream.is_none() && tag.kind() == "u" {
+ upstream = tag.content().map(str::to_owned);
+ }
}
Some(Self {
owner: event.pubkey,
created_at: event.created_at,
- id: id?,
+ id,
name,
description,
web,
@@ -76,11 +221,329 @@ impl Announcement {
relays,
euc,
maintainers,
+ upstream,
+ hashtags,
})
}
/// The repository address of this announcement.
pub fn addr(&self) -> crate::RepoAddr {
- crate::RepoAddr::new(self.owner, self.id.clone())
+ crate::repo_addr(self.owner, self.id.clone())
+ }
+
+ /// The description of the repository, or a default if none is provided.
+ pub fn description(&self) -> SharedString {
+ self.description
+ .clone()
+ .unwrap_or(SharedString::from("No description"))
+ }
+
+ /// The effective maintainers of this repository: the announced
+ /// `maintainers` plus the announcement author, who asserts themselves as
+ /// a maintainer of the primary project unless a `u` tag marks this
+ /// repository as a subordinate fork (NIP-34).
+ pub fn effective_maintainers(&self) -> Vec {
+ let mut maintainers = self.maintainers.clone();
+ if self.upstream.is_none() && !maintainers.contains(&self.owner) {
+ maintainers.push(self.owner);
+ }
+ maintainers
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const MAINTAINER_HEX: &str = "68d81165918100b7da43fc28f7d1fc12554466e1115886b9e7bb326f65ec4272";
+
+ fn keys() -> Keys {
+ Keys::new(
+ SecretKey::from_hex("0000000000000000000000000000000000000000000000000000000000000001")
+ .expect("valid secret key"),
+ )
+ }
+
+ /// Build a signed kind `30617` event from raw tag values.
+ fn announcement_event(tags: &[&[&str]]) -> Event {
+ let tags: Vec = tags
+ .iter()
+ .map(|t| Tag::parse(t.to_vec()).expect("valid tag"))
+ .collect();
+
+ EventBuilder::new(Kind::GitRepoAnnouncement, "")
+ .tags(tags)
+ .finalize(&keys())
+ .expect("signed event")
+ }
+
+ #[test]
+ fn parses_full_announcement() {
+ let event = announcement_event(&[
+ &["d", "my-repo"],
+ &["name", "My Repo"],
+ &["description", "A test repository"],
+ &["web", "https://example.com/repo"],
+ &["clone", "https://example.com/repo.git"],
+ &["relays", "wss://relay.example.com"],
+ &["r", "aa231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+ &["maintainers", MAINTAINER_HEX],
+ &["t", "rust"],
+ &["t", "nostr"],
+ ]);
+
+ let announcement = Announcement::from_event(&event).expect("parses");
+
+ assert_eq!(announcement.owner, keys().public_key());
+ assert_eq!(announcement.id, "my-repo");
+ assert_eq!(announcement.name.as_deref(), Some("My Repo"));
+ assert_eq!(
+ announcement.description.as_deref(),
+ Some("A test repository")
+ );
+ assert_eq!(
+ announcement.web,
+ vec![Url::parse("https://example.com/repo").unwrap()]
+ );
+ assert_eq!(
+ announcement.clone,
+ vec![Url::parse("https://example.com/repo.git").unwrap()]
+ );
+ assert_eq!(
+ announcement.relays,
+ vec![RelayUrl::parse("wss://relay.example.com").unwrap()]
+ );
+ assert_eq!(
+ announcement.euc.as_deref(),
+ Some("aa231c4c6a5777dc89b42207b499891a344add5c")
+ );
+ assert_eq!(
+ announcement.maintainers,
+ vec![PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey")]
+ );
+ assert_eq!(announcement.hashtags, vec!["rust", "nostr"]);
+ }
+
+ #[test]
+ fn requires_d_tag() {
+ let event = announcement_event(&[&["name", "No id"]]);
+
+ assert!(Announcement::from_event(&event).is_none());
+ }
+
+ #[test]
+ fn ignores_other_kinds() {
+ let event = EventBuilder::new(Kind::GitIssue, "")
+ .finalize(&keys())
+ .expect("signed event");
+
+ assert!(Announcement::from_event(&event).is_none());
+ }
+
+ #[test]
+ fn drops_malformed_values() {
+ let event = announcement_event(&[
+ &["d", "my-repo"],
+ &["clone", "not a url"],
+ &["relays", "wss://good.example.com"],
+ &["maintainers", "not-a-pubkey"],
+ ]);
+
+ let announcement = Announcement::from_event(&event).expect("parses");
+
+ // An invalid URL keeps the whole clone tag from being parsed.
+ assert!(announcement.clone.is_empty());
+ assert_eq!(
+ announcement.relays,
+ vec![RelayUrl::parse("wss://good.example.com").unwrap()]
+ );
+ assert!(announcement.maintainers.is_empty());
+ }
+
+ #[test]
+ fn ignores_unknown_tags() {
+ let event = announcement_event(&[&["d", "my-repo"], &["t", "label"], &["subject", "n/a"]]);
+
+ let announcement = Announcement::from_event(&event).expect("parses");
+
+ assert_eq!(announcement.id, "my-repo");
+ assert!(announcement.name.is_none());
+ assert!(announcement.web.is_empty());
+ }
+
+ #[test]
+ fn parses_upstream_tag() {
+ let event = announcement_event(&[
+ &["d", "my-fork"],
+ &["u", "30617:abc:upstream|https://example.com/upstream.git"],
+ ]);
+
+ let announcement = Announcement::from_event(&event).expect("parses");
+
+ assert_eq!(
+ announcement.upstream.as_deref(),
+ Some("30617:abc:upstream|https://example.com/upstream.git")
+ );
+ }
+
+ #[test]
+ fn effective_maintainers_include_owner_for_primary_repos() {
+ let event = announcement_event(&[&["d", "my-repo"], &["maintainers", MAINTAINER_HEX]]);
+
+ let announcement = Announcement::from_event(&event).expect("parses");
+ let maintainers = announcement.effective_maintainers();
+
+ // The owner asserts themselves as a maintainer of the primary
+ // project (NIP-34), alongside the announced co-maintainers.
+ assert_eq!(maintainers.len(), 2);
+ assert!(maintainers.contains(&announcement.owner));
+ assert!(maintainers.contains(&PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey")));
+ }
+
+ #[test]
+ fn effective_maintainers_exclude_owner_for_subordinate_forks() {
+ let event = announcement_event(&[
+ &["d", "my-fork"],
+ &["u", "30617:abc:upstream|https://example.com/upstream.git"],
+ &["maintainers", MAINTAINER_HEX],
+ ]);
+
+ let announcement = Announcement::from_event(&event).expect("parses");
+ let maintainers = announcement.effective_maintainers();
+
+ // A `u` tag marks the repository as a subordinate fork: the author
+ // is not a maintainer of the primary project (NIP-34).
+ assert!(!maintainers.contains(&announcement.owner));
+ assert_eq!(
+ maintainers,
+ vec![PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey")]
+ );
+ }
+
+ /// Build a signed PR event with the given tags and content.
+ fn pr_event(content: &str, tags: Vec) -> Event {
+ EventBuilder::new(Kind::GitPullRequest, content)
+ .tags(tags)
+ .finalize(&keys())
+ .expect("signed event")
+ }
+
+ #[test]
+ fn pull_request_patch_prefers_linked_patch_event() {
+ let patch = EventBuilder::new(Kind::GitPatch, "patch-content")
+ .finalize(&keys())
+ .expect("signed event");
+ let pr = pr_event("description", vec![Tag::event(patch.id)]);
+
+ assert_eq!(pull_request_patch(&pr, [&patch]), "patch-content");
+ }
+
+ #[test]
+ fn pull_request_patch_falls_back_to_inline_content() {
+ // Older PRs carried the patch in the content; no linked patch event.
+ let pr = pr_event("patch-inline", vec![]);
+
+ assert_eq!(pull_request_patch(&pr, [] as [&Event; 0]), "patch-inline");
+ }
+
+ #[test]
+ fn pull_request_patch_ignores_unrelated_patch_events() {
+ let patch = EventBuilder::new(Kind::GitPatch, "patch-content")
+ .finalize(&keys())
+ .expect("signed event");
+ let pr = pr_event("description", vec![]);
+
+ assert_eq!(pull_request_patch(&pr, [&patch]), "description");
+ }
+
+ /// Build a signed patch event with a controlled `created_at`.
+ fn patch_event(content: &str, tags: Vec, created_at: u64) -> Event {
+ EventBuilder::new(Kind::GitPatch, content)
+ .tags(tags)
+ .custom_created_at(Timestamp::from(created_at))
+ .finalize(&keys())
+ .expect("signed event")
+ }
+
+ #[test]
+ fn pull_request_patch_joins_the_whole_patch_set() {
+ // NIP-34: a PR references the root patch; later patches of the set
+ // reply to the previous one (NIP-10 `e` tags).
+ let root = patch_event("patch-one", vec![], 100);
+ let second = patch_event("patch-two", vec![Tag::event(root.id)], 200);
+ let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+ assert_eq!(
+ pull_request_patch(&pr, [&root, &second]),
+ "patch-one\npatch-two"
+ );
+ assert_eq!(
+ pull_request_patches(&pr, [&root, &second]),
+ vec![&root, &second]
+ );
+ }
+
+ #[test]
+ fn pull_request_patches_walks_the_reply_chain_in_order() {
+ let root = patch_event("patch-one", vec![], 100);
+ let second = patch_event("patch-two", vec![Tag::event(root.id)], 200);
+ let third = patch_event("patch-three", vec![Tag::event(second.id)], 300);
+ let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+ let series = pull_request_patches(&pr, [&third, &root, &second]);
+ assert_eq!(
+ series
+ .iter()
+ .map(|p| p.content.as_str())
+ .collect::>(),
+ vec!["patch-one", "patch-two", "patch-three"]
+ );
+ }
+
+ #[test]
+ fn pull_request_patches_ignores_unrelated_replies() {
+ let root = patch_event("patch-one", vec![], 100);
+ let other = patch_event("other-patch", vec![Tag::event(root.id)], 250);
+ // A patch replying to a different root is not part of the set.
+ let stranger = patch_event("stranger", vec![], 150);
+ let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+ let series = pull_request_patches(&pr, [&root, &other, &stranger]);
+ assert_eq!(
+ series
+ .iter()
+ .map(|p| p.content.as_str())
+ .collect::>(),
+ vec!["patch-one", "other-patch"]
+ );
+ }
+
+ #[test]
+ fn pull_request_patches_finds_the_set_via_the_tip_commit() {
+ // PRs without an `e` tag: the last patch of the set carries the tip
+ // commit in its `r` tag; walk the reply chain backward to the root.
+ let root = patch_event("patch-one", vec![], 100);
+ let tip = "1111111111111111111111111111111111111111";
+ let last = patch_event(
+ "patch-two",
+ vec![
+ Tag::event(root.id),
+ Tag::parse(["r", tip]).expect("valid tag"),
+ ],
+ 200,
+ );
+ let pr = pr_event(
+ "description",
+ vec![Tag::parse(["c", tip]).expect("valid tag")],
+ );
+
+ let series = pull_request_patches(&pr, [&root, &last]);
+ assert_eq!(
+ series
+ .iter()
+ .map(|p| p.content.as_str())
+ .collect::>(),
+ vec!["patch-one", "patch-two"]
+ );
}
}
diff --git a/crates/signed_core/src/state.rs b/crates/signed_core/src/state.rs
new file mode 100644
index 0000000..6032748
--- /dev/null
+++ b/crates/signed_core/src/state.rs
@@ -0,0 +1,146 @@
+use nostr::prelude::*;
+
+/// Build a kind `30618` repository state event from refs and HEAD.
+///
+/// `refs` are `(refname, commit-id)` pairs (e.g. `refs/heads/main`); `head`
+/// is the short branch name HEAD points to, published as
+/// `ref: refs/heads/`. The `d` tag matches the repository id.
+pub fn build_state(id: &str, refs: &[(String, String)], head: Option<&str>) -> EventBuilder {
+ let mut tags: Vec = vec![Tag::identifier(id.to_owned())];
+ for (name, commit) in refs {
+ tags.push(Tag::parse([name.as_str(), commit.as_str()]).expect("valid ref tag"));
+ }
+ if let Some(head) = head {
+ tags.push(
+ Tag::parse(["HEAD", &format!("ref: refs/heads/{head}")]).expect("valid HEAD tag"),
+ );
+ }
+ EventBuilder::new(Kind::RepoState, "").tags(tags)
+}
+
+/// Parse a kind `30618` repository state event into refs and HEAD.
+///
+/// `refs` are `(refname, commit-id)` pairs; `head` is the branch pointed to
+/// by the `HEAD` tag, if any.
+pub fn parse_state(event: &Event) -> (Vec<(String, String)>, Option) {
+ let mut refs = Vec::new();
+ let mut head = None;
+
+ for tag in event.tags.iter() {
+ match Nip34Tag::parse(tag.as_slice()) {
+ Ok(Nip34Tag::Head(branch)) => head = Some(branch),
+ Ok(Nip34Tag::RefHead { branch, commit }) => {
+ refs.push((format!("refs/heads/{branch}"), commit.to_string()));
+ }
+ Ok(Nip34Tag::RefTag { name, commit }) => {
+ refs.push((format!("refs/tags/{name}"), commit.to_string()));
+ }
+ _ => {}
+ }
+ }
+
+ (refs, head)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const COMMIT_A: &str = "aa231c4c6a5777dc89b42207b499891a344add5c";
+ const COMMIT_B: &str = "59429cfc6cb35b0a1ddace73b5a5c5ed57b8f5ca";
+
+ fn keys() -> Keys {
+ Keys::new(
+ SecretKey::from_hex("0000000000000000000000000000000000000000000000000000000000000001")
+ .expect("valid secret key"),
+ )
+ }
+
+ /// Build a signed kind `30618` event from raw tag values.
+ fn state_event(tags: &[&[&str]]) -> Event {
+ let tags: Vec = tags
+ .iter()
+ .map(|t| Tag::parse(t.to_vec()).expect("valid tag"))
+ .collect();
+
+ EventBuilder::new(Kind::RepoState, "")
+ .tags(tags)
+ .finalize(&keys())
+ .expect("signed event")
+ }
+
+ #[test]
+ fn parses_heads_and_tags() {
+ let event = state_event(&[
+ &["HEAD", "ref: refs/heads/main"],
+ &["refs/heads/main", COMMIT_A],
+ &["refs/heads/dev", COMMIT_B],
+ &["refs/tags/v1.0", COMMIT_A],
+ ]);
+
+ let (refs, head) = parse_state(&event);
+
+ assert_eq!(head.as_deref(), Some("main"));
+ assert_eq!(
+ refs,
+ vec![
+ ("refs/heads/main".to_owned(), COMMIT_A.to_owned()),
+ ("refs/heads/dev".to_owned(), COMMIT_B.to_owned()),
+ ("refs/tags/v1.0".to_owned(), COMMIT_A.to_owned()),
+ ]
+ );
+ }
+
+ #[test]
+ fn head_without_prefix_is_ignored() {
+ let event = state_event(&[&["HEAD", "main"]]);
+
+ let (refs, head) = parse_state(&event);
+
+ assert!(refs.is_empty());
+ assert!(head.is_none());
+ }
+
+ #[test]
+ fn ignores_non_state_tags() {
+ let event = state_event(&[&["d", "my-repo"], &["name", "ignored"]]);
+
+ let (refs, head) = parse_state(&event);
+
+ assert!(refs.is_empty());
+ assert!(head.is_none());
+ }
+
+ #[test]
+ fn build_state_round_trips_through_parse() {
+ let refs = [
+ ("refs/heads/main".to_owned(), COMMIT_A.to_owned()),
+ ("refs/heads/dev".to_owned(), COMMIT_B.to_owned()),
+ ("refs/tags/v1.0".to_owned(), COMMIT_A.to_owned()),
+ ];
+
+ let event = build_state("my-repo", &refs, Some("main"))
+ .finalize(&keys())
+ .expect("signed event");
+
+ assert_eq!(event.kind, Kind::RepoState);
+ assert_eq!(event.tags.identifier().as_deref(), Some("my-repo"));
+
+ let (parsed_refs, head) = parse_state(&event);
+ assert_eq!(parsed_refs, refs);
+ assert_eq!(head.as_deref(), Some("main"));
+ }
+
+ #[test]
+ fn build_state_omits_head_when_detached() {
+ let refs = [("refs/heads/main".to_owned(), COMMIT_A.to_owned())];
+
+ let event = build_state("my-repo", &refs, None)
+ .finalize(&keys())
+ .expect("signed event");
+
+ let (parsed_refs, head) = parse_state(&event);
+ assert_eq!(parsed_refs, refs);
+ assert!(head.is_none());
+ }
+}
diff --git a/crates/signed_core/src/status.rs b/crates/signed_core/src/status.rs
index 5c159e3..01b3d3f 100644
--- a/crates/signed_core/src/status.rs
+++ b/crates/signed_core/src/status.rs
@@ -30,13 +30,15 @@ impl RepoStatus {
}
}
-/// Check whether a status event references the given root event via an `e` tag.
+/// Check whether an event references the given root event via an `e` or `E`
+/// tag. NIP-10 / NIP-34 use the lowercase `e` tag; NIP-22 comments (kind
+/// `1111`) use the uppercase `E` tag for the root of the thread.
pub fn references_root(event: &Event, root: &EventId) -> bool {
- let root_hex: String = root.to_hex();
+ let root = root.to_hex();
event
.tags
.iter()
- .any(|t| t.kind() == "e" && t.content() == Some(root_hex.as_str()))
+ .any(|tag| matches!(tag.kind(), "e" | "E") && tag.content() == Some(root.as_str()))
}
/// Resolve the status of a root event per NIP-34:
@@ -58,3 +60,154 @@ where
.and_then(|e| RepoStatus::from_kind(e.kind))
.unwrap_or(RepoStatus::Open)
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const ROOT_ID_HEX: &str = "1111111111111111111111111111111111111111111111111111111111111111";
+ const OTHER_ID_HEX: &str = "2222222222222222222222222222222222222222222222222222222222222222";
+
+ fn keys_from_hex(hex: &str) -> Keys {
+ Keys::new(SecretKey::from_hex(hex).expect("valid secret key"))
+ }
+
+ fn root_event_id() -> EventId {
+ EventId::from_hex(ROOT_ID_HEX).expect("valid event id")
+ }
+
+ /// Build a signed status event with a controlled `created_at`.
+ fn status_event(author: &Keys, kind: Kind, root: EventId, created_at: u64) -> Event {
+ EventBuilder::new(kind, "")
+ .tags([Tag::event(root)])
+ .custom_created_at(Timestamp::from(created_at))
+ .finalize(author)
+ .expect("signed event")
+ }
+
+ #[test]
+ fn references_root_matches_e_tag() {
+ let root = root_event_id();
+ let event = EventBuilder::new(Kind::GitStatusOpen, "")
+ .tags([Tag::event(root)])
+ .finalize(&keys_from_hex(
+ "0000000000000000000000000000000000000000000000000000000000000001",
+ ))
+ .expect("signed event");
+
+ assert!(references_root(&event, &root));
+ assert!(!references_root(
+ &event,
+ &EventId::from_hex(OTHER_ID_HEX).expect("valid id")
+ ));
+ }
+
+ #[test]
+ fn references_root_matches_uppercase_e_tag() {
+ let root = root_event_id();
+ let event = EventBuilder::new(Kind::Comment, "")
+ .tags([Tag::parse(["E", ROOT_ID_HEX]).expect("valid E tag")])
+ .finalize(&keys_from_hex(
+ "0000000000000000000000000000000000000000000000000000000000000001",
+ ))
+ .expect("signed event");
+
+ assert!(references_root(&event, &root));
+ assert!(!references_root(
+ &event,
+ &EventId::from_hex(OTHER_ID_HEX).expect("valid id")
+ ));
+ }
+
+ #[test]
+ fn references_root_false_without_e_tags() {
+ let event = EventBuilder::new(Kind::GitStatusOpen, "")
+ .finalize(&keys_from_hex(
+ "0000000000000000000000000000000000000000000000000000000000000001",
+ ))
+ .expect("signed event");
+
+ assert!(!references_root(&event, &root_event_id()));
+ }
+
+ #[test]
+ fn defaults_to_open_without_status_events() {
+ let owner =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000001");
+ let maintainer =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
+
+ let statuses: Vec = Vec::new();
+
+ assert_eq!(
+ resolve_status(
+ statuses.iter(),
+ &owner.public_key(),
+ &[maintainer.public_key()]
+ ),
+ RepoStatus::Open
+ );
+ }
+
+ #[test]
+ fn latest_status_wins() {
+ let owner =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000001");
+ let maintainer =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
+ let root = root_event_id();
+
+ let statuses = [
+ status_event(&maintainer, Kind::GitStatusClosed, root, 100),
+ status_event(&owner, Kind::GitStatusOpen, root, 200),
+ ];
+
+ assert_eq!(
+ resolve_status(
+ statuses.iter(),
+ &owner.public_key(),
+ &[maintainer.public_key()]
+ ),
+ RepoStatus::Open
+ );
+ }
+
+ #[test]
+ fn ignores_statuses_from_others() {
+ let owner =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000001");
+ let maintainer =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
+ let stranger =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000003");
+ let root = root_event_id();
+
+ let statuses = [
+ status_event(&stranger, Kind::GitStatusClosed, root, 300),
+ status_event(&maintainer, Kind::GitStatusDraft, root, 100),
+ ];
+
+ assert_eq!(
+ resolve_status(
+ statuses.iter(),
+ &owner.public_key(),
+ &[maintainer.public_key()]
+ ),
+ RepoStatus::Draft
+ );
+ }
+
+ #[test]
+ fn ignores_non_status_kinds() {
+ let owner =
+ keys_from_hex("0000000000000000000000000000000000000000000000000000000000000001");
+ let root = root_event_id();
+
+ let statuses = [status_event(&owner, Kind::GitIssue, root, 100)];
+
+ assert_eq!(
+ resolve_status(statuses.iter(), &owner.public_key(), &[]),
+ RepoStatus::Open
+ );
+ }
+}
diff --git a/crates/signed_git/Cargo.toml b/crates/signed_git/Cargo.toml
index bdfb0c0..3a17301 100644
--- a/crates/signed_git/Cargo.toml
+++ b/crates/signed_git/Cargo.toml
@@ -8,5 +8,8 @@ publish.workspace = true
signed_core = { path = "../signed_core" }
nostr.workspace = true
-gix.workspace = true
+gix = { workspace = true, features = ["revision", "blob-diff"] }
anyhow.workspace = true
+
+[dev-dependencies]
+tempfile = "3"
diff --git a/crates/signed_git/src/lib.rs b/crates/signed_git/src/lib.rs
index 0d5bb29..713dbf1 100644
--- a/crates/signed_git/src/lib.rs
+++ b/crates/signed_git/src/lib.rs
@@ -2,11 +2,13 @@
//!
//! All functions may block; call them inside `cx.background_spawn`.
+use std::collections::HashSet;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use anyhow::{Context, Result, bail};
+use gix::diff::blob::unified_diff::{ConsumeHunk, DiffLineKind as GixLineKind, HunkHeader};
use gix::interrupt::IS_INTERRUPTED;
use gix::progress::Discard;
use signed_core::RepoAddr;
@@ -25,8 +27,8 @@ impl GitCache {
/// Local path of the clone for a repository.
pub fn repo_path(&self, addr: &RepoAddr) -> PathBuf {
self.root
- .join(addr.owner.to_hex())
- .join(sanitize_path_component(&addr.id))
+ .join(addr.public_key.to_hex())
+ .join(sanitize_path_component(&addr.identifier))
}
/// Open an existing clone.
@@ -59,7 +61,12 @@ impl GitCache {
for url in clone_urls {
match clone(url, &path) {
- Ok(repo) => return Ok(repo),
+ Ok(repo) => {
+ // The initial clone uses the default refspecs; also
+ // fetch the `refs/nostr/*` PR refs.
+ fetch_all(&repo).ok();
+ return Ok(repo);
+ }
Err(e) => last_err = Some(e),
}
}
@@ -71,11 +78,23 @@ impl GitCache {
}
}
-/// Fetch all configured refspecs from `origin`.
+/// Fetch all configured refspecs from `origin`, plus the `refs/nostr/*`
+/// namespace where GRASP mirrors serve pull request branches (one ref per
+/// PR event id, as used by ngit).
pub fn fetch_all(repo: &gix::Repository) -> Result<()> {
+ let options = gix::remote::ref_map::Options {
+ extra_refspecs: vec![
+ gix::refspec::parse(
+ gix::bstr::BStr::new("+refs/nostr/*:refs/nostr/*"),
+ gix::refspec::parse::Operation::Fetch,
+ )?
+ .to_owned(),
+ ],
+ ..Default::default()
+ };
repo.find_remote("origin")?
.connect(gix::remote::Direction::Fetch)?
- .prepare_fetch(Discard, Default::default())?
+ .prepare_fetch(Discard, options)?
.receive(Discard, &IS_INTERRUPTED)?;
Ok(())
}
@@ -116,8 +135,14 @@ fn clone(url: &str, path: &Path) -> Result {
Ok(repo)
}
+/// Map an untrusted repository id to a safe single path component.
+///
+/// Replaces everything outside `[A-Za-z0-9._-]` with `_`, and rejects the
+/// special components `.` and `..` so the id can't escape the cache root
+/// when joined onto the owner directory.
fn sanitize_path_component(id: &str) -> String {
- id.chars()
+ let sanitized: String = id
+ .chars()
.map(|c| {
if c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.') {
c
@@ -125,5 +150,2258 @@ fn sanitize_path_component(id: &str) -> String {
'_'
}
})
- .collect()
+ .collect();
+
+ if sanitized == "." || sanitized == ".." {
+ return "_".to_owned();
+ }
+
+ sanitized
+}
+
+/// In-memory object cache for history walks (see [`open_with_cache`]).
+/// Without one, every walk re-decodes the same commit objects from the
+/// object database.
+const OBJECT_CACHE_BYTES: usize = 64 * 1024 * 1024;
+
+/// Metadata of a commit, as shown in the repository browser's file header.
+#[derive(Debug, Clone)]
+pub struct FileCommit {
+ /// Shortened commit id (7+ hex chars, disambiguated if needed).
+ pub id: String,
+ /// First line of the commit message.
+ pub summary: String,
+ /// Rest of the commit message after the title; `None` when there is no
+ /// body (single-line commit messages).
+ pub description: Option,
+ /// Author name.
+ pub author: String,
+ /// Author time, seconds since the Unix epoch.
+ pub time: i64,
+}
+
+/// Relative paths of all entries in the worktree (files and directories),
+/// directories first, then alphabetically within each group. The `.git`
+/// directory is skipped.
+pub fn worktree_entries(repo: &gix::Repository) -> Result> {
+ let workdir = repo.workdir().context("repository has no worktree")?;
+
+ let mut entries: Vec<(PathBuf, bool)> = Vec::new();
+ collect_entries(workdir, workdir, &mut entries)?;
+
+ entries.sort_by(|(a, a_is_dir), (b, b_is_dir)| {
+ b_is_dir
+ .cmp(a_is_dir)
+ .then_with(|| a.as_os_str().cmp(b.as_os_str()))
+ });
+ Ok(entries.into_iter().map(|(path, _)| path).collect())
+}
+
+/// Read a file from the worktree. Returns `Ok(None)` if the path is missing
+/// or not a regular file.
+pub fn worktree_read(repo: &gix::Repository, rel: &Path) -> Result>> {
+ let workdir = repo.workdir().context("repository has no worktree")?;
+ let path = workdir.join(rel);
+
+ match std::fs::read(&path) {
+ Ok(bytes) => Ok(Some(bytes)),
+ Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
+ Err(e) if e.kind() == std::io::ErrorKind::IsADirectory => Ok(None),
+ Err(e) => Err(e).with_context(|| format!("failed to read {}", path.display())),
+ }
+}
+
+/// Find the README file in the repository root (returned as a path relative
+/// to the worktree). Case-insensitive; prefers `README.md`, then `.markdown`,
+/// `.mdown`, `.mkdn`, then any other file whose name starts with `readme`.
+pub fn find_readme(repo: &gix::Repository) -> Result> {
+ let Some(workdir) = repo.workdir() else {
+ return Ok(None);
+ };
+
+ let mut candidates: Vec = Vec::new();
+ for entry in std::fs::read_dir(workdir)? {
+ let entry = entry?;
+ let name = entry.file_name();
+ let Some(name) = name.to_str() else { continue };
+ if name.to_ascii_lowercase().starts_with("readme") {
+ candidates.push(entry.path());
+ }
+ }
+
+ candidates.sort_by_key(|path| {
+ let ext = path
+ .extension()
+ .map(|e| e.to_string_lossy().to_ascii_lowercase());
+ match ext.as_deref() {
+ Some("md") => 0,
+ Some("markdown") => 1,
+ Some("mdown") => 2,
+ Some("mkdn") => 3,
+ Some(_) => 5,
+ None => 4,
+ }
+ });
+
+ Ok(candidates
+ .into_iter()
+ .next()
+ .and_then(|path| path.strip_prefix(workdir).ok().map(Path::to_path_buf)))
+}
+
+/// Open the repository at `workdir` with an in-memory object cache sized for
+/// history walks.
+fn open_with_cache(workdir: &Path) -> Result {
+ let mut repo = gix::open(workdir)?;
+ repo.object_cache_size_if_unset(OBJECT_CACHE_BYTES);
+ Ok(repo)
+}
+
+/// A [`FileCommit`] from a walk commit: author, message title and shortened
+/// id. `include_description` controls whether the message body is copied;
+/// history lists never display it, so skipping it saves a string allocation
+/// per listed commit (the diff panel fetches the full commit on demand).
+fn file_commit(commit: &gix::Commit<'_>, include_description: bool) -> Result {
+ let author = commit.author()?;
+ let message = commit.message()?;
+ Ok(FileCommit {
+ id: commit.id().shorten_or_id().to_string(),
+ summary: String::from_utf8_lossy(message.title).trim().to_string(),
+ description: if include_description {
+ message
+ .body
+ .map(|body| String::from_utf8_lossy(body).trim().to_string())
+ .filter(|body| !body.is_empty())
+ } else {
+ None
+ },
+ author: String::from_utf8_lossy(author.name).trim().to_string(),
+ time: author.time()?.seconds,
+ })
+}
+
+/// Find the most recent commit that changed `rel` (a path relative to the
+/// worktree), like `git log -1 -- ` does for non-merge commits.
+///
+/// Walks history from `HEAD` newest-first and returns the first commit whose
+/// tree entry for `rel` differs from its first parent's; a merge that only
+/// changed the file through its second parent is therefore not reported.
+/// Returns `Ok(None)` if no commit touched the file (e.g. untracked files).
+pub fn last_commit(repo: &gix::Repository, rel: &Path) -> Result> {
+ let rel = rel.to_path_buf();
+ Ok(last_commits(repo, std::slice::from_ref(&rel))?
+ .into_iter()
+ .next()
+ .map(|(_, commit)| commit))
+}
+
+/// Newest commit touching each of `rels` (relative to the worktree), like
+/// `git log -1 -- ` per path, found in a single history walk: every
+/// commit is decoded once and shared across all paths. Paths without any
+/// commit (e.g. untracked files) are absent from the result.
+pub fn worktree_last_commits(
+ workdir: &Path,
+ rels: &[PathBuf],
+) -> Result> {
+ last_commits(&open_with_cache(workdir)?, rels)
+}
+
+/// The walk behind [`last_commit`] and [`worktree_last_commits`], stopping as
+/// soon as every pending path has its commit.
+fn last_commits(repo: &gix::Repository, rels: &[PathBuf]) -> Result> {
+ use gix::traverse::commit::simple::CommitTimeOrder;
+
+ let Some(head) = repo.head_id().ok() else {
+ return Ok(Vec::new());
+ };
+
+ // De-duplicate while preserving order.
+ let mut pending: Vec = Vec::with_capacity(rels.len());
+ let mut seen: HashSet<&Path> = HashSet::with_capacity(rels.len());
+ for rel in rels {
+ if seen.insert(rel.as_path()) {
+ pending.push(rel.clone());
+ }
+ }
+
+ let walk = repo
+ .rev_walk([head])
+ .sorting(gix::revision::walk::Sorting::ByCommitTime(
+ CommitTimeOrder::NewestFirst,
+ ));
+
+ let mut found = Vec::new();
+ for info in walk.all()? {
+ if pending.is_empty() {
+ break;
+ }
+ let info = info?;
+ let commit = info.object()?;
+ let tree = commit.tree()?;
+ let parent_tree = match info.parent_ids().next() {
+ Some(parent) => Some(parent.object()?.into_commit().tree()?),
+ None => None,
+ };
+
+ // Compare each still-unresolved path against this commit and its
+ // first parent; resolved paths leave the pending set.
+ let mut ix = 0;
+ while ix < pending.len() {
+ let rel = &pending[ix];
+ let blob = tree.lookup_entry_by_path(rel)?;
+ let parent_blob = match &parent_tree {
+ Some(tree) => tree.lookup_entry_by_path(rel)?,
+ None => None,
+ };
+
+ if blob.map(|entry| entry.id().detach()) != parent_blob.map(|entry| entry.id().detach())
+ {
+ found.push((rel.clone(), file_commit(&commit, true)?));
+ pending.swap_remove(ix);
+ } else {
+ ix += 1;
+ }
+ }
+ }
+
+ Ok(found)
+}
+
+/// Cap on [`CommitList::commits`]: the virtual list renders a window at a
+/// time and the tab badge shows the real count, so a huge history is never
+/// fully materialized in memory.
+pub const MAX_LISTED_COMMITS: usize = 20_000;
+
+/// Commits reachable from `HEAD`, newest first, possibly capped: `commits`
+/// holds at most [`MAX_LISTED_COMMITS`] entries and `total` is the real
+/// count (for the tab badge).
+pub struct CommitList {
+ /// Number of commits reachable from HEAD.
+ pub total: usize,
+ /// Newest commits, capped at [`MAX_LISTED_COMMITS`].
+ pub commits: Vec,
+}
+
+/// All commits reachable from `HEAD`, newest first, with author and summary.
+/// Returns an empty list for a repository without any commits yet.
+pub fn all_commits(repo: &gix::Repository) -> Result {
+ use gix::traverse::commit::simple::CommitTimeOrder;
+
+ let Some(head) = repo.head_id().ok() else {
+ return Ok(CommitList {
+ total: 0,
+ commits: Vec::new(),
+ });
+ };
+ let walk = repo
+ .rev_walk([head])
+ .sorting(gix::revision::walk::Sorting::ByCommitTime(
+ CommitTimeOrder::NewestFirst,
+ ));
+
+ let mut commits = Vec::new();
+ let mut total = 0;
+ for info in walk.all()? {
+ let info = info?;
+ total += 1;
+ if commits.len() < MAX_LISTED_COMMITS {
+ commits.push(file_commit(&info.object()?, false)?);
+ }
+ }
+ Ok(CommitList { total, commits })
+}
+
+/// Like [`all_commits`], but opens the repository located at `workdir`
+/// (for non-bare clones the clone root is the worktree) first.
+pub fn worktree_all_commits(workdir: &Path) -> Result {
+ all_commits(&open_with_cache(workdir)?)
+}
+
+/// The kind of a [`DiffLine`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DiffLineKind {
+ /// An unchanged context line, present on both sides.
+ Context,
+ /// A line added by the commit.
+ Addition,
+ /// A line removed by the commit.
+ Deletion,
+}
+
+/// One line of a file diff.
+#[derive(Debug, Clone)]
+pub struct DiffLine {
+ pub kind: DiffLineKind,
+ /// 1-based line number in the old version, if the line exists there.
+ pub old: Option,
+ /// 1-based line number in the new version, if the line exists there.
+ pub new: Option,
+ /// Line content without the trailing newline.
+ pub text: String,
+}
+
+/// A hunk of a file diff, like `@@ -a,b +c,d @@`, with the lines between the
+/// two headers (context around the change, then removals and additions).
+#[derive(Debug, Clone)]
+pub struct DiffHunk {
+ /// 1-based start line in the old version.
+ pub old_start: u32,
+ /// Number of old lines covered by the hunk.
+ pub old_lines: u32,
+ /// 1-based start line in the new version.
+ pub new_start: u32,
+ /// Number of new lines covered by the hunk.
+ pub new_lines: u32,
+ pub lines: Vec,
+}
+
+/// How a file changed in a commit.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DiffStatus {
+ Added,
+ Modified,
+ Deleted,
+ Renamed,
+ Copied,
+}
+
+/// The diff of one file in a commit.
+#[derive(Debug, Clone)]
+pub struct FileDiff {
+ /// Path of the file relative to the repo root (the destination path for
+ /// renames and copies).
+ pub path: String,
+ /// Previous path, for renames and copies.
+ pub old_path: Option,
+ pub status: DiffStatus,
+ /// Number of added lines; 0 for binary files.
+ pub insertions: usize,
+ /// Number of removed lines; 0 for binary files.
+ pub deletions: usize,
+ /// True if either version is binary (then `hunks` is empty).
+ pub binary: bool,
+ pub hunks: Vec,
+}
+
+/// The changes of one commit: every file it added, modified, deleted or
+/// renamed, with line-level hunks for text files.
+#[derive(Debug, Clone)]
+pub struct CommitDiff {
+ pub files: Vec,
+}
+
+/// The changes of the commit `id` (short or full) in the repository at
+/// `workdir`, compared against its first parent (the empty tree for the root
+/// commit), like `git show`. Directory entries and submodules are skipped;
+/// their contents are reported as individual file changes. Files are sorted
+/// by path.
+pub fn worktree_commit_diff(workdir: &Path, id: &str) -> Result {
+ commit_diff(&open_with_cache(workdir)?, id)
+}
+
+fn commit_diff(repo: &gix::Repository, id: &str) -> Result {
+ let commit_id = repo.rev_parse_single(id.as_bytes())?;
+ let commit = commit_id.object()?.into_commit();
+ let new_tree = commit.tree()?;
+ let old_tree = match commit.parent_ids().next() {
+ Some(parent) => Some(parent.object()?.into_commit().tree()?),
+ None => None,
+ };
+ tree_diff(repo, old_tree.as_ref(), &new_tree)
+}
+
+/// The changes between two commits (`base`..`tip`), like `git diff base tip`.
+/// Same file handling as [`worktree_commit_diff`] (directories and
+/// submodules are skipped, files are sorted by path).
+pub fn worktree_commit_range_diff(workdir: &Path, base: &str, tip: &str) -> Result {
+ let repo = open_with_cache(workdir)?;
+ let base_tree = repo
+ .rev_parse_single(base.as_bytes())?
+ .object()?
+ .into_commit()
+ .tree()?;
+ let tip_tree = repo
+ .rev_parse_single(tip.as_bytes())?
+ .object()?
+ .into_commit()
+ .tree()?;
+ tree_diff(&repo, Some(&base_tree), &tip_tree)
+}
+
+/// Commits in the range `base`..`tip`, newest first, like `git log base..tip`.
+pub fn worktree_commit_range_commits(
+ workdir: &Path,
+ base: &str,
+ tip: &str,
+) -> Result> {
+ use gix::traverse::commit::simple::CommitTimeOrder;
+
+ let repo = open_with_cache(workdir)?;
+ let base_id = repo.rev_parse_single(base.as_bytes())?;
+ let tip_id = repo.rev_parse_single(tip.as_bytes())?;
+ let walk = repo
+ .rev_walk([tip_id])
+ .sorting(gix::revision::walk::Sorting::ByCommitTime(
+ CommitTimeOrder::NewestFirst,
+ ))
+ .with_hidden([base_id]);
+
+ let mut commits = Vec::new();
+ for info in walk.all()? {
+ let info = info?;
+ commits.push(file_commit(&info.object()?, false)?);
+ }
+ Ok(commits)
+}
+
+/// The changes between two trees, used by both [`commit_diff`] and
+/// [`worktree_commit_range_diff`].
+fn tree_diff(
+ repo: &gix::Repository,
+ old_tree: Option<&gix::Tree<'_>>,
+ new_tree: &gix::Tree<'_>,
+) -> Result {
+ use gix::diff::blob::platform::prepare_diff::Operation;
+ use gix::object::tree::diff::Change;
+ use gix::objs::tree::EntryKind;
+
+ let changes = repo.diff_tree_to_tree(old_tree, Some(new_tree), None)?;
+ let mut cache = repo.diff_resource_cache_for_tree_diff()?;
+
+ let mut files = Vec::new();
+ for change in changes {
+ let attached = Change::from_change_ref(change.to_ref(), repo, repo);
+
+ // The tree diff also reports directory entries; only their contents
+ // are listed, so skip trees and submodule gitlinks.
+ let (path, old_path, status) = match attached {
+ Change::Addition {
+ location,
+ entry_mode,
+ ..
+ } if !matches!(entry_mode.kind(), EntryKind::Tree | EntryKind::Commit) => {
+ (location.to_owned(), None, DiffStatus::Added)
+ }
+ Change::Deletion {
+ location,
+ entry_mode,
+ ..
+ } if !matches!(entry_mode.kind(), EntryKind::Tree | EntryKind::Commit) => {
+ (location.to_owned(), None, DiffStatus::Deleted)
+ }
+ Change::Modification {
+ location,
+ previous_entry_mode,
+ entry_mode,
+ ..
+ } if !matches!(entry_mode.kind(), EntryKind::Tree | EntryKind::Commit)
+ && !matches!(
+ previous_entry_mode.kind(),
+ EntryKind::Tree | EntryKind::Commit
+ ) =>
+ {
+ (location.to_owned(), None, DiffStatus::Modified)
+ }
+ Change::Rewrite {
+ location,
+ source_location,
+ source_entry_mode,
+ entry_mode,
+ copy,
+ ..
+ } if !matches!(entry_mode.kind(), EntryKind::Tree | EntryKind::Commit)
+ && !matches!(
+ source_entry_mode.kind(),
+ EntryKind::Tree | EntryKind::Commit
+ ) =>
+ {
+ let status = if copy {
+ DiffStatus::Copied
+ } else {
+ DiffStatus::Renamed
+ };
+ (
+ location.to_owned(),
+ Some(source_location.to_owned()),
+ status,
+ )
+ }
+ _ => continue,
+ };
+
+ // Always diff with the built-in algorithm: external diff drivers
+ // would shell out, which is out of scope for a read-only viewer.
+ let platform = attached.diff(&mut cache)?;
+ platform
+ .resource_cache
+ .options
+ .skip_internal_diff_if_external_is_configured = true;
+ let outcome = platform.resource_cache.prepare_diff()?;
+
+ let (binary, hunks, insertions, deletions) = match outcome.operation {
+ Operation::InternalDiff { algorithm } => {
+ let input = outcome.interned_input();
+ let diff = gix::diff::blob::diff_with_slider_heuristics(algorithm, &input);
+
+ let mut hunks = Vec::new();
+ let mut insertions = 0usize;
+ let mut deletions = 0usize;
+ let collector = HunkCollector {
+ hunks: &mut hunks,
+ insertions: &mut insertions,
+ deletions: &mut deletions,
+ };
+ gix::diff::blob::UnifiedDiff::new(&diff, &input, collector, Default::default())
+ .consume()?;
+ (false, hunks, insertions, deletions)
+ }
+ Operation::SourceOrDestinationIsBinary => (true, Vec::new(), 0, 0),
+ Operation::ExternalCommand { .. } => unreachable!("external diff drivers are disabled"),
+ };
+
+ files.push(FileDiff {
+ path: String::from_utf8_lossy(&path).into_owned(),
+ old_path: old_path.map(|p| String::from_utf8_lossy(&p).into_owned()),
+ status,
+ insertions,
+ deletions,
+ binary,
+ hunks,
+ });
+ }
+
+ files.sort_by(|a, b| a.path.cmp(&b.path));
+ Ok(CommitDiff { files })
+}
+
+/// Parse a `git format-patch` output (a single patch or a patch series)
+/// into the same [`CommitDiff`] structure used for commit diffs.
+///
+/// The mbox envelope (From/Subject/… headers, commit body and diffstat)
+/// is skipped; every `diff --git` section becomes one [`FileDiff`]. Paths
+/// are taken from the section headers, with git's C-style quoting undone.
+/// Sections without hunks (pure renames, mode changes, binary files) are
+/// reported without lines.
+pub fn patch_diffs(patch: &str) -> Result {
+ let lines: Vec<&str> = patch.lines().collect();
+ let mut files = Vec::new();
+ let mut i = 0;
+
+ while i < lines.len() {
+ let Some(header) = lines[i].strip_prefix("diff --git ") else {
+ i += 1;
+ continue;
+ };
+ let (file, next) = parse_diff_section(header, &lines, i + 1)?;
+ files.push(file);
+ i = next;
+ }
+
+ Ok(CommitDiff { files })
+}
+
+/// Commits of a `git format-patch` output (a single patch or a patch
+/// series), parsed from the mbox envelope headers of each patch: commit id,
+/// author, summary and author time. Entries appear in patch order (oldest
+/// first, as produced by `git format-patch`).
+pub fn patch_commits(patch: &str) -> Vec {
+ let lines: Vec<&str> = patch.lines().collect();
+ let mut commits = Vec::new();
+ let mut i = 0;
+
+ while i < lines.len() {
+ // A patch starts with its `From ` envelope line.
+ let Some(rest) = lines[i].strip_prefix("From ") else {
+ i += 1;
+ continue;
+ };
+ let Some(id) = rest.split_whitespace().next() else {
+ i += 1;
+ continue;
+ };
+ if id.len() != 40 {
+ i += 1;
+ continue;
+ }
+
+ let mut author = String::new();
+ let mut summary = String::new();
+ let mut time = 0i64;
+
+ // Envelope headers of this patch, up to the blank line separating
+ // them from the commit message.
+ i += 1;
+ while i < lines.len() && !lines[i].is_empty() {
+ let header = lines[i];
+ if let Some(value) = header.strip_prefix("From: ") {
+ author = name_from_address(value);
+ } else if let Some(value) = header.strip_prefix("Subject: ") {
+ summary = strip_patch_prefix(value);
+ } else if let Some(value) = header.strip_prefix("Date: ") {
+ time = gix::date::parse(value.trim(), None)
+ .map(|t| t.seconds)
+ .unwrap_or(0);
+ }
+ i += 1;
+ }
+
+ commits.push(FileCommit {
+ id: id.to_string(),
+ summary,
+ description: None,
+ author,
+ time,
+ });
+ }
+
+ commits
+}
+
+/// The name part of a `From: Name ` header value.
+fn name_from_address(from: &str) -> String {
+ match from.trim().find('<') {
+ Some(ix) => from[..ix].trim().to_string(),
+ None => from.trim().to_string(),
+ }
+}
+
+/// Strip the `[PATCH]`, `[PATCH 1/2]`, `[RFC PATCH]` … prefix from a patch
+/// `Subject:` header.
+fn strip_patch_prefix(subject: &str) -> String {
+ let trimmed = subject.trim();
+ let Some(rest) = trimmed.strip_prefix('[') else {
+ return trimmed.to_string();
+ };
+ let Some(end) = rest.find(']') else {
+ return trimmed.to_string();
+ };
+ if rest[..end].to_ascii_lowercase().contains("patch") {
+ rest[end + 1..].trim().to_string()
+ } else {
+ trimmed.to_string()
+ }
+}
+
+/// Parse one file's diff section: everything after its `diff --git` header
+/// up to the next section (or the end of the patch). Returns the section
+/// and the index of the first unconsumed line.
+fn parse_diff_section(header: &str, lines: &[&str], start: usize) -> Result<(FileDiff, usize)> {
+ let (header_old, header_new) = header_paths(header)?;
+ // The `---`/`+++` lines name the two sides unambiguously (the header
+ // can't distinguish spaces); fall back to the header for sections
+ // without them (pure renames, mode changes).
+ let mut old_path = header_old;
+ let mut new_path = header_new;
+
+ let mut status = DiffStatus::Modified;
+ let mut binary = false;
+ let mut hunks = Vec::new();
+ let mut insertions = 0usize;
+ let mut deletions = 0usize;
+ let mut i = start;
+
+ while i < lines.len() {
+ let line = lines[i];
+
+ // The next file's section starts at this line.
+ if line.starts_with("diff --git ") {
+ break;
+ }
+ i += 1;
+
+ if line.starts_with("@@ -") {
+ let (hunk, next) = parse_hunk(lines, i - 1)?;
+ i = next;
+ insertions += hunk
+ .lines
+ .iter()
+ .filter(|line| line.kind == DiffLineKind::Addition)
+ .count();
+ deletions += hunk
+ .lines
+ .iter()
+ .filter(|line| line.kind == DiffLineKind::Deletion)
+ .count();
+ hunks.push(hunk);
+ } else if let Some(rest) = line.strip_prefix("--- ") {
+ if rest == "/dev/null" {
+ status = DiffStatus::Added;
+ } else {
+ old_path = diff_line_path(rest, "a/")?;
+ }
+ } else if let Some(rest) = line.strip_prefix("+++ ") {
+ if rest == "/dev/null" {
+ status = DiffStatus::Deleted;
+ } else {
+ new_path = diff_line_path(rest, "b/")?;
+ }
+ } else if line.starts_with("new file mode ") {
+ status = DiffStatus::Added;
+ } else if line.starts_with("deleted file mode ") {
+ status = DiffStatus::Deleted;
+ } else if line.starts_with("copy from ") {
+ status = DiffStatus::Copied;
+ } else if line.starts_with("rename from ") {
+ status = DiffStatus::Renamed;
+ } else if line.starts_with("Binary files ") || line.starts_with("GIT binary patch") {
+ binary = true;
+ // A literal binary patch may follow; skip it without consuming
+ // the next section's header.
+ while i < lines.len() && !lines[i].starts_with("diff --git ") {
+ i += 1;
+ }
+ break;
+ }
+ // Everything else (index/mode/similarity lines) is ignored.
+ }
+
+ Ok((
+ FileDiff {
+ path: new_path,
+ old_path: matches!(status, DiffStatus::Renamed | DiffStatus::Copied)
+ .then_some(old_path),
+ status,
+ insertions,
+ deletions,
+ binary,
+ hunks,
+ },
+ i,
+ ))
+}
+
+/// Parse one hunk: the `@@ -a,b +c,d @@` header plus every body line up to
+/// the next hunk header, the next `diff --git` section or the end of the
+/// patch. Returns the hunk and the index of the first unconsumed line.
+fn parse_hunk(lines: &[&str], start: usize) -> Result<(DiffHunk, usize)> {
+ let (old_start, old_lines, new_start, new_lines) = hunk_header(lines[start])?;
+
+ let mut diff_lines = Vec::new();
+ let mut old = old_start;
+ let mut new = new_start;
+ let mut i = start + 1;
+
+ while i < lines.len() {
+ let line = lines[i];
+ let Some(kind) = line_prefix_kind(line) else {
+ break;
+ };
+ i += 1;
+
+ // Context lines advance both counters, deletions only the old one
+ // and additions only the new one, so every line ends up with its
+ // real line number in both versions.
+ let (old_no, new_no) = match kind {
+ DiffLineKind::Context => {
+ let numbers = (Some(old), Some(new));
+ old += 1;
+ new += 1;
+ numbers
+ }
+ DiffLineKind::Addition => {
+ let number = Some(new);
+ new += 1;
+ (None, number)
+ }
+ DiffLineKind::Deletion => {
+ let number = Some(old);
+ old += 1;
+ (number, None)
+ }
+ };
+ diff_lines.push(DiffLine {
+ kind,
+ old: old_no,
+ new: new_no,
+ text: line[1..].to_owned(),
+ });
+ }
+
+ Ok((
+ DiffHunk {
+ old_start,
+ old_lines,
+ new_start,
+ new_lines,
+ lines: diff_lines,
+ },
+ i,
+ ))
+}
+
+/// The kind of a hunk body line, from its first character; lines that don't
+/// belong to the hunk (headers, `\ No newline…`, the next section) yield
+/// `None`.
+fn line_prefix_kind(line: &str) -> Option {
+ match line.as_bytes().first()? {
+ b' ' => Some(DiffLineKind::Context),
+ b'+' => Some(DiffLineKind::Addition),
+ b'-' => Some(DiffLineKind::Deletion),
+ _ => None,
+ }
+}
+
+/// Parse a unified-diff hunk header `@@ -a,b +c,d @@`; omitted line counts
+/// default to 1.
+fn hunk_header(header: &str) -> Result<(u32, u32, u32, u32)> {
+ let rest = header
+ .strip_prefix("@@ ")
+ .context("malformed hunk header")?;
+ let (old_spec, rest) = rest.split_once(' ').context("malformed hunk header")?;
+ let new_spec = rest.split_once(' ').map(|(new, _)| new).unwrap_or(rest);
+
+ fn parse(spec: &str) -> Result<(u32, u32)> {
+ let spec = spec.strip_prefix(['-', '+']).unwrap_or(spec);
+ let (start, count) = match spec.split_once(',') {
+ Some((start, count)) => (start, count.parse::()?),
+ None => (spec, 1),
+ };
+ Ok((start.parse::()?, count))
+ }
+
+ let (old_start, old_lines) = parse(old_spec)?;
+ let (new_start, new_lines) = parse(new_spec)?;
+ Ok((old_start, old_lines, new_start, new_lines))
+}
+
+/// The old and new paths of a `diff --git a/X b/Y` header, with git's
+/// C-style quoting undone.
+///
+/// Git only quotes paths containing characters that need escaping (non-ASCII
+/// bytes, `"`, `\`); plain spaces are left unquoted, so the two sides of an
+/// unquoted header are split at the last ` b/`.
+fn header_paths(header: &str) -> Result<(String, String)> {
+ if header.starts_with('"') {
+ // Quoted paths include the `a/` / `b/` prefix inside the quotes.
+ let (old, rest) = take_quoted(header).context("unterminated quoted path")?;
+ let rest = rest.trim_start();
+ let new = if rest.starts_with('"') {
+ take_quoted(rest).context("unterminated quoted path")?.0
+ } else {
+ rest.split_whitespace().next().unwrap_or(rest)
+ };
+ let old = old
+ .strip_prefix("a/")
+ .context("old path without `a/` prefix")?;
+ let new = new
+ .strip_prefix("b/")
+ .context("new path without `b/` prefix")?;
+ Ok((unquote_path(old)?, unquote_path(new)?))
+ } else {
+ let (old, rest) = header
+ .rsplit_once(" b/")
+ .context("malformed diff --git header")?;
+ let old = old
+ .strip_prefix("a/")
+ .context("old path without `a/` prefix")?;
+ Ok((old.to_owned(), rest.to_owned()))
+ }
+}
+
+/// The path of a `--- a/X` / `+++ b/Y` line: the prefix stripped, git's
+/// trailing padding tab (for paths containing spaces) removed and C-style
+/// quoting undone. These lines name the two sides unambiguously, unlike the
+/// `diff --git` header.
+fn diff_line_path(line: &str, prefix: &str) -> Result {
+ let line = line.trim_end_matches('\t');
+ if line.starts_with('"') {
+ let (path, _) = take_quoted(line).context("unterminated quoted path")?;
+ let path = path
+ .strip_prefix(prefix)
+ .context("diff line path without `a/` or `b/` prefix")?;
+ unquote_path(path)
+ } else {
+ Ok(line
+ .strip_prefix(prefix)
+ .context("diff line path without `a/` or `b/` prefix")?
+ .to_owned())
+ }
+}
+
+/// The content of a git C-style quoted path (opening `"`, escaped content,
+/// closing `"`) and the rest of the input; `None` if unterminated.
+///
+/// Iterates by character so the returned slices always land on UTF-8
+/// boundaries, even for non-ASCII paths.
+fn take_quoted(input: &str) -> Option<(&str, &str)> {
+ let mut end = 1; // byte after the opening quote
+ let mut rest = &input[1..];
+ while let Some(ch) = rest.chars().next() {
+ let len = ch.len_utf8();
+ match ch {
+ '\\' => {
+ // Consume the escaped character too (it may be multi-byte).
+ let escaped = rest[len..].chars().next()?;
+ let consumed = len + escaped.len_utf8();
+ end += consumed;
+ rest = &rest[consumed..];
+ }
+ '"' => return Some((&input[1..end], &input[end + len..])),
+ _ => {
+ end += len;
+ rest = &rest[len..];
+ }
+ }
+ }
+ None
+}
+
+/// Undo git's C-style path quoting (`\NNN` octal escapes, `\"`, `\\`).
+fn unquote_path(path: &str) -> Result {
+ if !path.contains('\\') {
+ return Ok(path.to_owned());
+ }
+
+ let mut out = Vec::with_capacity(path.len());
+ let mut bytes = path.as_bytes();
+ while let Some((&b, rest)) = bytes.split_first() {
+ bytes = rest;
+ if b == b'\\' {
+ match bytes.split_first() {
+ Some((&b'"', rest)) | Some((&b'\\', rest)) => {
+ out.push(b);
+ bytes = rest;
+ }
+ Some((&b'n', rest)) => {
+ out.push(b'\n');
+ bytes = rest;
+ }
+ Some((&b't', rest)) => {
+ out.push(b'\t');
+ bytes = rest;
+ }
+ Some((&d1, rest)) if (b'0'..=b'7').contains(&d1) => {
+ let Some((&d2, rest)) = rest.split_first() else {
+ bail!("malformed octal escape in quoted path");
+ };
+ let Some((&d3, rest)) = rest.split_first() else {
+ bail!("malformed octal escape in quoted path");
+ };
+ if !(b'0'..=b'7').contains(&d2) || !(b'0'..=b'7').contains(&d3) {
+ bail!("malformed octal escape in quoted path");
+ }
+ let code =
+ (d1 - b'0') as u16 * 64 + (d2 - b'0') as u16 * 8 + (d3 - b'0') as u16;
+ if code > u8::MAX as u16 {
+ bail!("octal escape out of range in quoted path");
+ }
+ out.push(code as u8);
+ bytes = rest;
+ }
+ _ => bail!("malformed escape in quoted path"),
+ }
+ } else {
+ out.push(b);
+ }
+ }
+
+ String::from_utf8(out).context("invalid UTF-8 in quoted path")
+}
+
+/// Collects the hunks of one blob diff while tracking per-line numbers.
+///
+/// The unified-diff headers give the 1-based start line of the hunk in each
+/// file; context lines advance both counters, removals only the old one and
+/// additions only the new one, so each line ends up with its real line
+/// numbers in both versions.
+struct HunkCollector<'a> {
+ hunks: &'a mut Vec,
+ insertions: &'a mut usize,
+ deletions: &'a mut usize,
+}
+
+impl ConsumeHunk for HunkCollector<'_> {
+ type Out = ();
+
+ fn consume_hunk(
+ &mut self,
+ header: HunkHeader,
+ lines: &[(GixLineKind, &[u8])],
+ ) -> std::io::Result<()> {
+ let mut old_ln = header.before_hunk_start;
+ let mut new_ln = header.after_hunk_start;
+ let mut out = Vec::with_capacity(lines.len());
+
+ for (kind, content) in lines {
+ let text = String::from_utf8_lossy(content).into_owned();
+ let line = match kind {
+ GixLineKind::Context => {
+ let line = DiffLine {
+ kind: DiffLineKind::Context,
+ old: Some(old_ln),
+ new: Some(new_ln),
+ text,
+ };
+ old_ln += 1;
+ new_ln += 1;
+ line
+ }
+ GixLineKind::Remove => {
+ *self.deletions += 1;
+ let line = DiffLine {
+ kind: DiffLineKind::Deletion,
+ old: Some(old_ln),
+ new: None,
+ text,
+ };
+ old_ln += 1;
+ line
+ }
+ GixLineKind::Add => {
+ *self.insertions += 1;
+ let line = DiffLine {
+ kind: DiffLineKind::Addition,
+ old: None,
+ new: Some(new_ln),
+ text,
+ };
+ new_ln += 1;
+ line
+ }
+ };
+ out.push(line);
+ }
+
+ self.hunks.push(DiffHunk {
+ old_start: header.before_hunk_start,
+ old_lines: header.before_hunk_len,
+ new_start: header.after_hunk_start,
+ new_lines: header.after_hunk_len,
+ lines: out,
+ });
+ Ok(())
+ }
+
+ fn finish(self) {}
+}
+
+/// The commit HEAD points to, like `git log -1`. Returns `Ok(None)` for a
+/// repository without commits yet (unborn HEAD).
+pub fn head_commit(repo: &gix::Repository) -> Result> {
+ let Some(head) = repo.head_id().ok() else {
+ return Ok(None);
+ };
+ let commit = head.object()?.into_commit();
+ Ok(Some(file_commit(&commit, true)?))
+}
+
+/// Full metadata of the commit `id` (short or full) in the repository at
+/// `workdir`, like [`head_commit`] for an arbitrary commit. Returns
+/// `Ok(None)` when the id cannot be resolved.
+///
+/// The commit list ([`all_commits`]) omits message bodies to keep the walk
+/// cheap; the diff panel uses this to fetch the full commit on demand.
+pub fn worktree_commit(workdir: &Path, id: &str) -> Result> {
+ let repo = open_with_cache(workdir)?;
+ match repo.rev_parse_single(id.as_bytes()) {
+ Ok(commit_id) => {
+ let commit = commit_id.object()?.into_commit();
+ Ok(Some(file_commit(&commit, true)?))
+ }
+ Err(_) => Ok(None),
+ }
+}
+
+/// Short names of local branches (`refs/heads/*`) of `repo`, sorted
+/// alphabetically.
+pub fn repo_branches(repo: &gix::Repository) -> Result> {
+ let mut names = Vec::new();
+ for reference in repo.references()?.local_branches()? {
+ let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
+ names.push(String::from_utf8_lossy(reference.name().shorten()).into_owned());
+ }
+ names.sort();
+ Ok(names)
+}
+
+/// Short names of tags (`refs/tags/*`) of `repo`, sorted alphabetically.
+pub fn repo_tags(repo: &gix::Repository) -> Result> {
+ let mut names = Vec::new();
+ for reference in repo.references()?.tags()? {
+ let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
+ names.push(String::from_utf8_lossy(reference.name().shorten()).into_owned());
+ }
+ names.sort();
+ Ok(names)
+}
+
+/// Short names of local branches (`refs/heads/*`), sorted alphabetically.
+pub fn worktree_branches(workdir: &Path) -> Result> {
+ repo_branches(&open_with_cache(workdir)?)
+}
+
+/// Short names of tags (`refs/tags/*`), sorted alphabetically.
+pub fn worktree_tags(workdir: &Path) -> Result> {
+ repo_tags(&open_with_cache(workdir)?)
+}
+
+/// Short name of the branch HEAD points to, or `None` when detached (e.g.
+/// after checking out a tag or a commit directly).
+pub fn current_branch(repo: &gix::Repository) -> Result> {
+ let head = repo.head()?;
+ let Some(name) = head.referent_name() else {
+ return Ok(None);
+ };
+ Ok(Some(String::from_utf8_lossy(name.shorten()).into_owned()))
+}
+
+/// Branch, tag and HEAD refs of a repository, ready for a NIP-34 kind-30618
+/// repository state announcement.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RepoRefState {
+ /// `(full refname, commit id)` pairs for heads and tags, sorted.
+ pub refs: Vec<(String, String)>,
+ /// Short branch name HEAD points to, or `None` when detached.
+ pub head: Option,
+}
+
+/// Collect the refs of `repo`: local branches and tags as
+/// `(refname, commit-id)` pairs, plus the branch HEAD points to.
+pub fn repo_ref_state(repo: &gix::Repository) -> Result {
+ let mut refs = Vec::new();
+
+ for reference in repo.references()?.local_branches()? {
+ let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
+ refs.push((
+ String::from_utf8_lossy(reference.name().as_bstr()).into_owned(),
+ reference.id().to_string(),
+ ));
+ }
+ for reference in repo.references()?.tags()? {
+ let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
+ refs.push((
+ String::from_utf8_lossy(reference.name().as_bstr()).into_owned(),
+ reference.id().to_string(),
+ ));
+ }
+ refs.sort();
+
+ let head = match repo.head() {
+ Ok(head) => head
+ .referent_name()
+ .filter(|name| name.as_bstr().starts_with(b"refs/heads/"))
+ .map(|name| String::from_utf8_lossy(name.shorten()).into_owned()),
+ Err(_) => None,
+ };
+
+ Ok(RepoRefState { refs, head })
+}
+
+/// [`repo_ref_state`] for the repository at `workdir`.
+pub fn worktree_ref_state(workdir: &Path) -> Result {
+ repo_ref_state(&open_with_cache(workdir)?)
+}
+
+/// Everything the browser needs to refresh after a branch or tag switch.
+pub struct WorktreeSnapshot {
+ /// Relative paths of all worktree entries, directories first.
+ pub entries: Vec,
+ /// README path relative to the worktree, if any.
+ pub readme_path: Option,
+ /// Contents of the README, if any.
+ pub readme: Option>,
+ /// Branch HEAD points to (`None` when detached, e.g. on a tag).
+ pub current_branch: Option,
+ /// Commit HEAD points to, if any (see [`head_commit`]).
+ pub head_commit: Option,
+}
+
+/// Snapshot the worktree after a branch/tag switch: entries, README, the
+/// branch HEAD points to and its commit, opening the repository once.
+pub fn worktree_snapshot(workdir: &Path) -> Result {
+ let repo = open_with_cache(workdir)?;
+ let readme_path = find_readme(&repo)?;
+ let readme = match &readme_path {
+ Some(path) => worktree_read(&repo, path)?,
+ None => None,
+ };
+ Ok(WorktreeSnapshot {
+ entries: worktree_entries(&repo)?,
+ readme_path,
+ readme,
+ current_branch: current_branch(&repo)?,
+ head_commit: head_commit(&repo)?,
+ })
+}
+
+/// Switch the checked-out ref and update the worktree to match, like
+/// `git checkout --force`. Local modifications are discarded since these
+/// clones are read-only browser copies.
+fn checkout(workdir: &Path, args: &[&str]) -> Result<()> {
+ let output = Command::new("git")
+ .arg("checkout")
+ .arg("--force")
+ .args(args)
+ .current_dir(workdir)
+ .output()
+ .context("failed to spawn `git checkout`")?;
+ if !output.status.success() {
+ bail!(
+ "git checkout {} failed: {}",
+ args.join(" "),
+ String::from_utf8_lossy(&output.stderr)
+ );
+ }
+ Ok(())
+}
+
+/// Check out the local branch `name`; HEAD stays attached to it.
+pub fn worktree_checkout_branch(workdir: &Path, name: &str) -> Result<()> {
+ // The short name (not `refs/heads/`) keeps HEAD attached; the
+ // full ref name would be treated as a commit-ish and detach it.
+ checkout(workdir, &[name])
+}
+
+/// Check out the tag `name`; HEAD becomes detached at the tagged commit,
+/// which [`current_branch`] reports as `None`.
+pub fn worktree_checkout_tag(workdir: &Path, name: &str) -> Result<()> {
+ // `--detach` pins the full tag ref so HEAD always ends up detached.
+ checkout(workdir, &["--detach", &format!("refs/tags/{name}")])
+}
+
+fn collect_entries(root: &Path, dir: &Path, out: &mut Vec<(PathBuf, bool)>) -> Result<()> {
+ for entry in std::fs::read_dir(dir)? {
+ let entry = entry?;
+ if entry.file_name() == ".git" {
+ continue;
+ }
+
+ let is_dir = entry.file_type()?.is_dir();
+ let path = entry.path();
+ let rel = path.strip_prefix(root)?.to_path_buf();
+ out.push((rel, is_dir));
+
+ if is_dir {
+ collect_entries(root, &path, out)?;
+ }
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use std::collections::HashMap;
+
+ use nostr::prelude::*;
+ use signed_core::repo_addr;
+
+ use super::*;
+
+ #[test]
+ fn keeps_plain_ids() {
+ assert_eq!(sanitize_path_component("my-repo"), "my-repo");
+ assert_eq!(sanitize_path_component("repo.v2"), "repo.v2");
+ assert_eq!(sanitize_path_component("a_b-c"), "a_b-c");
+ }
+
+ #[test]
+ fn replaces_unsafe_characters() {
+ assert_eq!(sanitize_path_component("a/b\\c:d"), "a_b_c_d");
+ assert_eq!(sanitize_path_component(""), "");
+ }
+
+ #[test]
+ fn blocks_parent_components() {
+ assert_eq!(sanitize_path_component(".."), "_");
+ assert_eq!(sanitize_path_component("."), "_");
+ // Separators are neutralized before the check, so these stay safe.
+ assert_eq!(sanitize_path_component("../.."), ".._..");
+ assert_eq!(sanitize_path_component("a/../b"), "a_.._b");
+ }
+
+ #[test]
+ fn repo_path_stays_inside_root() {
+ let cache = GitCache::new("/cache".into());
+ let owner = Keys::generate().public_key();
+
+ let path = cache.repo_path(&repo_addr(owner, ".."));
+ assert!(path.starts_with("/cache"));
+ assert_eq!(
+ path.file_name().map(|n| n.to_string_lossy().into_owned()),
+ Some("_".into())
+ );
+ }
+
+ #[test]
+ fn repo_ref_state_lists_branches_tags_and_head() {
+ let (_dir, repo) = fixture(&[("a.txt", b"hello")]);
+ commit_all(&repo, "initial");
+ let workdir = repo.workdir().expect("workdir").to_path_buf();
+
+ let state = repo_ref_state(&repo).expect("refs");
+
+ let branch = current_branch(&repo).expect("branch").expect("on a branch");
+ assert_eq!(state.head.as_deref(), Some(branch.as_str()));
+ assert_eq!(state.refs.len(), 1);
+ assert_eq!(state.refs[0].0, format!("refs/heads/{branch}"));
+ assert_eq!(state.refs[0].1.len(), 40);
+
+ // Additional branches and tags are listed alongside.
+ git_run(&workdir, &["branch", "feature"]);
+ git_run(&workdir, &["tag", "v1.0"]);
+
+ let state = repo_ref_state(&repo).expect("refs");
+ let mut expected: Vec = vec![
+ format!("refs/heads/{branch}"),
+ "refs/heads/feature".to_owned(),
+ "refs/tags/v1.0".to_owned(),
+ ];
+ expected.sort();
+ assert_eq!(
+ state
+ .refs
+ .iter()
+ .map(|(name, _)| name.clone())
+ .collect::>(),
+ expected
+ );
+
+ // A detached HEAD yields no head branch.
+ git_run(&workdir, &["checkout", "--detach"]);
+ let state = repo_ref_state(&repo).expect("refs");
+ assert!(state.head.is_none());
+ assert_eq!(state.refs.len(), 3);
+ }
+
+ /// Build a throwaway non-bare repository with the given files (rel → bytes).
+ fn fixture(files: &[(&str, &[u8])]) -> (tempfile::TempDir, gix::Repository) {
+ let dir = tempfile::tempdir().expect("tempdir");
+ let repo = gix::init(&dir).expect("init");
+
+ for (rel, bytes) in files {
+ let path = dir.path().join(rel);
+ std::fs::create_dir_all(path.parent().expect("parent")).expect("mkdir");
+ std::fs::write(&path, bytes).expect("write");
+ }
+
+ (dir, repo)
+ }
+
+ #[test]
+ fn worktree_entries_lists_all_files_and_dirs() {
+ let (_dir, repo) = fixture(&[
+ ("README.md", b"# Hi"),
+ ("src/main.rs", b"fn main() {}"),
+ ("src/lib.rs", b""),
+ ("docs/guide.md", b"guide"),
+ ]);
+
+ let entries = worktree_entries(&repo).expect("entries");
+ let entries: Vec = entries
+ .iter()
+ .map(|p| p.to_string_lossy().into_owned())
+ .collect();
+
+ assert_eq!(
+ entries,
+ vec![
+ "docs",
+ "src",
+ "README.md",
+ "docs/guide.md",
+ "src/lib.rs",
+ "src/main.rs"
+ ]
+ );
+ }
+
+ #[test]
+ fn worktree_read_returns_bytes_or_none() {
+ let (_dir, repo) = fixture(&[("a.txt", b"hello"), ("sub/b.bin", b"\x00\x01")]);
+
+ assert_eq!(
+ worktree_read(&repo, Path::new("a.txt")).expect("read"),
+ Some(b"hello".to_vec())
+ );
+ assert_eq!(
+ worktree_read(&repo, Path::new("sub/b.bin")).expect("read"),
+ Some(vec![0x00, 0x01])
+ );
+ assert_eq!(
+ worktree_read(&repo, Path::new("missing.txt")).expect("read"),
+ None
+ );
+ }
+
+ /// Stage everything and create a commit with the git CLI (like
+ /// [`apply_patch`], the crate already shells out to the CLI).
+ fn commit_all(repo: &gix::Repository, message: &str) {
+ git_run(repo.workdir().expect("workdir"), &["add", "-A"]);
+ git_run(repo.workdir().expect("workdir"), &["commit", "-m", message]);
+ }
+
+ /// Run a git command in `dir`, asserting success.
+ fn git_run(dir: &Path, args: &[&str]) {
+ let status = Command::new("git")
+ .current_dir(dir)
+ .env("GIT_AUTHOR_NAME", "Test Author")
+ .env("GIT_AUTHOR_EMAIL", "test@example.com")
+ .env("GIT_COMMITTER_NAME", "Test Author")
+ .env("GIT_COMMITTER_EMAIL", "test@example.com")
+ .env("GIT_EDITOR", "true")
+ .args(args)
+ .status()
+ .expect("spawn git");
+ assert!(status.success(), "git {args:?} failed");
+ }
+
+ #[test]
+ fn last_commit_returns_most_recent_change() {
+ let (dir, repo) = fixture(&[("a.txt", b"one")]);
+ commit_all(&repo, "initial");
+
+ std::fs::write(dir.path().join("a.txt"), b"two").expect("write");
+ commit_all(&repo, "change a");
+
+ // A commit touching another file must not be reported for a.txt.
+ std::fs::write(dir.path().join("b.txt"), b"other").expect("write");
+ commit_all(&repo, "add b");
+
+ let commit = last_commit(&repo, Path::new("a.txt"))
+ .expect("lookup")
+ .expect("found");
+ assert_eq!(commit.summary, "change a");
+ assert_eq!(commit.author, "Test Author");
+ assert!(!commit.id.is_empty());
+ assert!(commit.time > 0);
+ }
+
+ #[test]
+ fn all_commits_lists_every_commit() {
+ let (dir, repo) = fixture(&[("a.txt", b"one")]);
+ commit_all(&repo, "initial");
+
+ std::fs::write(dir.path().join("a.txt"), b"two").expect("write");
+ commit_all(&repo, "second");
+ std::fs::write(dir.path().join("b.txt"), b"b").expect("write");
+ commit_all(&repo, "third");
+
+ let list = all_commits(&repo).expect("commits");
+ assert_eq!(list.total, 3);
+ let mut summaries: Vec<&str> = list.commits.iter().map(|c| c.summary.as_str()).collect();
+ summaries.sort();
+ assert_eq!(summaries, vec!["initial", "second", "third"]);
+ assert!(
+ list.commits
+ .iter()
+ .all(|c| c.author == "Test Author" && !c.id.is_empty() && c.time > 0)
+ );
+ }
+
+ #[test]
+ fn all_commits_returns_empty_without_head() {
+ let (_dir, repo) = fixture(&[("a.txt", b"one")]);
+
+ let list = all_commits(&repo).expect("commits");
+ assert!(list.commits.is_empty());
+ assert_eq!(list.total, 0);
+ }
+
+ #[test]
+ fn last_commit_returns_none_for_untracked_files() {
+ let (dir, repo) = fixture(&[("a.txt", b"one")]);
+ commit_all(&repo, "initial");
+ std::fs::write(dir.path().join("untracked.txt"), b"x").expect("write");
+
+ let commit = last_commit(&repo, Path::new("untracked.txt")).expect("lookup");
+ assert!(commit.is_none());
+ }
+
+ #[test]
+ fn last_commit_reports_merge_commits() {
+ let (dir, repo) = fixture(&[("a.txt", b"base")]);
+ commit_all(&repo, "initial");
+
+ let run = |args: &[&str]| {
+ let status = Command::new("git")
+ .current_dir(dir.path())
+ .env("GIT_AUTHOR_NAME", "Test Author")
+ .env("GIT_AUTHOR_EMAIL", "test@example.com")
+ .env("GIT_COMMITTER_NAME", "Test Author")
+ .env("GIT_COMMITTER_EMAIL", "test@example.com")
+ .env("GIT_EDITOR", "true")
+ .args(args)
+ .status()
+ .expect("spawn git");
+ assert!(status.success(), "git {args:?} failed");
+ };
+ run(&["checkout", "-b", "feature"]);
+ std::fs::write(dir.path().join("a.txt"), b"feature").expect("write");
+ commit_all(&repo, "feature change");
+ run(&["checkout", "-"]);
+ // --no-ff forces a merge commit; it is the latest commit changing a.txt.
+ run(&["merge", "--no-ff", "--no-edit", "feature"]);
+
+ let commit = last_commit(&repo, Path::new("a.txt"))
+ .expect("lookup")
+ .expect("found");
+ assert_eq!(
+ commit.id,
+ repo.head_id().expect("head").shorten_or_id().to_string()
+ );
+ assert!(commit.summary.starts_with("Merge branch"));
+ }
+
+ #[test]
+ fn last_commits_batches_multiple_paths() {
+ let (dir, repo) = fixture(&[("a.txt", b"one"), ("b.txt", b"b")]);
+ commit_all(&repo, "initial");
+
+ std::fs::write(dir.path().join("a.txt"), b"two").expect("write");
+ commit_all(&repo, "change a");
+ std::fs::write(dir.path().join("b.txt"), b"bb").expect("write");
+ commit_all(&repo, "change b");
+
+ let found = worktree_last_commits(
+ dir.path(),
+ &[
+ PathBuf::from("a.txt"),
+ PathBuf::from("b.txt"),
+ // Untracked paths are simply absent from the result.
+ PathBuf::from("missing.txt"),
+ ],
+ )
+ .expect("commits");
+ let by_path: HashMap<&Path, &FileCommit> = found
+ .iter()
+ .map(|(path, commit)| (path.as_path(), commit))
+ .collect();
+ assert_eq!(by_path.len(), 2);
+ assert_eq!(by_path[Path::new("a.txt")].summary, "change a");
+ assert_eq!(by_path[Path::new("b.txt")].summary, "change b");
+ }
+
+ #[test]
+ fn find_readme_prefers_markdown() {
+ let (_dir, repo) = fixture(&[("readme.txt", b"txt"), ("README.md", b"md")]);
+
+ let readme = find_readme(&repo).expect("find");
+ assert_eq!(
+ readme.map(|p| p.to_string_lossy().into_owned()),
+ Some("README.md".into())
+ );
+ }
+
+ #[test]
+ fn find_readme_falls_back_to_any_readme() {
+ let (_dir, repo) = fixture(&[("README.rst", b"rst")]);
+
+ let readme = find_readme(&repo).expect("find");
+ assert_eq!(
+ readme.map(|p| p.to_string_lossy().into_owned()),
+ Some("README.rst".into())
+ );
+ }
+
+ #[test]
+ fn find_readme_returns_none_without_one() {
+ let (_dir, repo) = fixture(&[("main.rs", b"")]);
+ assert!(find_readme(&repo).expect("find").is_none());
+ }
+
+ #[test]
+ fn head_commit_reports_head() {
+ let (_dir, repo) = fixture(&[("a.txt", b"one")]);
+
+ // Unborn HEAD: no commit yet.
+ assert!(head_commit(&repo).expect("head").is_none());
+
+ commit_all(&repo, "initial");
+ let head = head_commit(&repo).expect("head").expect("commit");
+ assert_eq!(
+ head.id,
+ repo.head_id().expect("head id").shorten_or_id().to_string()
+ );
+ assert_eq!(head.summary, "initial");
+ assert_eq!(head.author, "Test Author");
+ }
+
+ #[test]
+ fn worktree_branches_and_tags_list_short_names() {
+ let (dir, repo) = fixture(&[("a.txt", b"one")]);
+ commit_all(&repo, "initial");
+ let dir = dir.path();
+
+ git_run(dir, &["checkout", "-b", "feature"]);
+ git_run(dir, &["tag", "v0.9"]);
+ git_run(dir, &["tag", "v1.0"]);
+
+ // The initial branch name depends on git configuration; only the
+ // branch we created is fixed.
+ let branches = worktree_branches(dir).expect("branches");
+ assert_eq!(branches.len(), 2);
+ assert!(branches.contains(&"feature".to_string()));
+ assert!(branches.windows(2).all(|pair| pair[0] <= pair[1]), "sorted");
+
+ assert_eq!(
+ worktree_tags(dir).expect("tags"),
+ vec!["v0.9".to_string(), "v1.0".to_string()]
+ );
+ }
+
+ #[test]
+ fn current_branch_tracks_checkout() {
+ let (dir, repo) = fixture(&[("a.txt", b"one")]);
+ commit_all(&repo, "initial");
+ let dir = dir.path();
+
+ let default = worktree_branches(dir)
+ .expect("branches")
+ .into_iter()
+ .next()
+ .expect("default branch");
+ assert_eq!(
+ current_branch(&repo).expect("branch").as_deref(),
+ Some(default.as_str())
+ );
+
+ git_run(dir, &["checkout", "-b", "feature"]);
+ assert_eq!(
+ current_branch(&repo).expect("branch").as_deref(),
+ Some("feature")
+ );
+
+ // Tags detach HEAD.
+ git_run(dir, &["tag", "v1.0"]);
+ worktree_checkout_tag(dir, "v1.0").expect("checkout tag");
+ assert_eq!(current_branch(&repo).expect("branch"), None);
+
+ // Branches re-attach HEAD.
+ worktree_checkout_branch(dir, &default).expect("checkout branch");
+ assert_eq!(
+ current_branch(&repo).expect("branch").as_deref(),
+ Some(default.as_str())
+ );
+ }
+
+ #[test]
+ fn worktree_snapshot_reflects_checked_out_ref() {
+ let (dir, repo) = fixture(&[("README.md", b"# main"), ("a.txt", b"one")]);
+ commit_all(&repo, "initial");
+ let dir = dir.path();
+
+ git_run(dir, &["checkout", "-b", "feature"]);
+ std::fs::write(dir.join("README.md"), b"# feature").expect("write");
+ std::fs::write(dir.join("b.txt"), b"b").expect("write");
+ commit_all(&repo, "feature work");
+
+ let snapshot = worktree_snapshot(dir).expect("snapshot");
+ assert_eq!(snapshot.current_branch.as_deref(), Some("feature"));
+ assert_eq!(
+ snapshot.head_commit.as_ref().expect("head commit").summary,
+ "feature work"
+ );
+ assert_eq!(
+ String::from_utf8(snapshot.readme.expect("readme")).expect("utf8"),
+ "# feature"
+ );
+ let entries: Vec = snapshot
+ .entries
+ .iter()
+ .map(|p| p.to_string_lossy().into_owned())
+ .collect();
+ assert!(entries.contains(&"b.txt".to_string()));
+
+ let default = worktree_branches(dir)
+ .expect("branches")
+ .into_iter()
+ .find(|name| name != "feature")
+ .expect("default branch");
+ worktree_checkout_branch(dir, &default).expect("checkout");
+
+ let snapshot = worktree_snapshot(dir).expect("snapshot");
+ assert_eq!(snapshot.current_branch.as_deref(), Some(default.as_str()));
+ assert_eq!(
+ snapshot.head_commit.as_ref().expect("head commit").summary,
+ "initial"
+ );
+ assert_eq!(
+ String::from_utf8(snapshot.readme.expect("readme")).expect("utf8"),
+ "# main"
+ );
+ assert!(
+ !snapshot
+ .entries
+ .iter()
+ .any(|p| p.to_string_lossy() == "b.txt")
+ );
+ }
+
+ #[test]
+ fn commit_diff_lists_added_modified_and_deleted_files() {
+ let (dir, repo) = fixture(&[("keep.txt", b"keep"), ("mod.txt", b"one\ntwo\nthree\n")]);
+ commit_all(&repo, "initial");
+
+ std::fs::write(dir.path().join("mod.txt"), b"one\ntwo!\nthree\n").expect("write");
+ std::fs::write(dir.path().join("new.txt"), b"hello\n").expect("write");
+ std::fs::remove_file(dir.path().join("keep.txt")).expect("remove");
+ commit_all(&repo, "changes");
+
+ let head = repo.head_id().expect("head").shorten_or_id().to_string();
+ let diff = worktree_commit_diff(dir.path(), &head).expect("diff");
+
+ let by_path: HashMap<&str, &FileDiff> = diff
+ .files
+ .iter()
+ .map(|file| (file.path.as_str(), file))
+ .collect();
+ assert_eq!(by_path.len(), 3);
+
+ let added = by_path["new.txt"];
+ assert_eq!(added.status, DiffStatus::Added);
+ assert_eq!(added.insertions, 1);
+ assert_eq!(added.deletions, 0);
+ assert_eq!(added.hunks.len(), 1);
+ assert_eq!(added.hunks[0].lines.len(), 1);
+ assert_eq!(added.hunks[0].lines[0].kind, DiffLineKind::Addition);
+ assert_eq!(added.hunks[0].lines[0].old, None);
+ assert_eq!(added.hunks[0].lines[0].new, Some(1));
+ assert_eq!(added.hunks[0].lines[0].text, "hello");
+
+ let modified = by_path["mod.txt"];
+ assert_eq!(modified.status, DiffStatus::Modified);
+ assert_eq!(modified.insertions, 1);
+ assert_eq!(modified.deletions, 1);
+ assert!(!modified.binary);
+ let lines = &modified.hunks[0].lines;
+ // One hunk with context around the single-line change: the removed
+ // line is old 2, the added line is new 2.
+ assert!(lines.iter().any(|line| {
+ line.kind == DiffLineKind::Deletion
+ && line.old == Some(2)
+ && line.new.is_none()
+ && line.text == "two"
+ }));
+ assert!(lines.iter().any(|line| {
+ line.kind == DiffLineKind::Addition
+ && line.old.is_none()
+ && line.new == Some(2)
+ && line.text == "two!"
+ }));
+ assert!(lines.iter().any(|line| {
+ line.kind == DiffLineKind::Context && line.old == Some(1) && line.new == Some(1)
+ }));
+
+ let deleted = by_path["keep.txt"];
+ assert_eq!(deleted.status, DiffStatus::Deleted);
+ assert_eq!(deleted.deletions, 1);
+ assert_eq!(deleted.hunks[0].lines[0].kind, DiffLineKind::Deletion);
+ assert_eq!(deleted.hunks[0].lines[0].old, Some(1));
+ assert_eq!(deleted.hunks[0].lines[0].new, None);
+ }
+
+ #[test]
+ fn commit_range_diff_lists_changes_between_two_commits() {
+ let (dir, repo) = fixture(&[("a.txt", b"a\n"), ("b.txt", b"b\n")]);
+ commit_all(&repo, "first");
+ let base = repo.head_id().expect("head").to_string();
+
+ std::fs::write(dir.path().join("a.txt"), b"changed\n").expect("write");
+ std::fs::write(dir.path().join("c.txt"), b"new\n").expect("write");
+ commit_all(&repo, "second");
+ let tip = repo.head_id().expect("head").to_string();
+
+ let diff = worktree_commit_range_diff(dir.path(), &base, &tip).expect("diff");
+
+ let by_path: HashMap<&str, &FileDiff> = diff
+ .files
+ .iter()
+ .map(|file| (file.path.as_str(), file))
+ .collect();
+ assert_eq!(by_path.len(), 2);
+ assert_eq!(by_path["a.txt"].status, DiffStatus::Modified);
+ assert_eq!(by_path["a.txt"].insertions, 1);
+ assert_eq!(by_path["a.txt"].deletions, 1);
+ assert_eq!(by_path["c.txt"].status, DiffStatus::Added);
+ // b.txt is unchanged between the two commits.
+ assert!(diff.files.iter().all(|file| file.path != "b.txt"));
+ }
+
+ #[test]
+ fn commit_range_commits_lists_only_new_commits_newest_first() {
+ let (dir, repo) = fixture(&[("a.txt", b"one\n")]);
+ commit_all(&repo, "one");
+ let base = repo.head_id().expect("head").to_string();
+
+ std::fs::write(dir.path().join("a.txt"), b"two\n").expect("write");
+ commit_all(&repo, "two");
+ std::fs::write(dir.path().join("a.txt"), b"three\n").expect("write");
+ commit_all(&repo, "three");
+ let tip = repo.head_id().expect("head").to_string();
+
+ let commits = worktree_commit_range_commits(dir.path(), &base, &tip).expect("commits");
+
+ assert_eq!(commits.len(), 2);
+ assert_eq!(commits[0].summary, "three");
+ assert_eq!(commits[1].summary, "two");
+ }
+
+ #[test]
+ fn commit_diff_reports_binary_files_without_hunks() {
+ let (_dir, repo) = fixture(&[("blob.bin", b"\x00\x01\x02")]);
+ commit_all(&repo, "initial");
+
+ std::fs::write(_dir.path().join("blob.bin"), b"\x00\x03").expect("write");
+ commit_all(&repo, "binary change");
+
+ let head = repo.head_id().expect("head").shorten_or_id().to_string();
+ let diff = worktree_commit_diff(_dir.path(), &head).expect("diff");
+ let file = diff
+ .files
+ .iter()
+ .find(|f| f.path == "blob.bin")
+ .expect("file");
+ assert!(file.binary);
+ assert!(file.hunks.is_empty());
+ assert_eq!(file.insertions, 0);
+ assert_eq!(file.deletions, 0);
+ }
+
+ #[test]
+ fn commit_diff_resolves_short_ids_and_root_commit() {
+ let (dir, repo) = fixture(&[("a.txt", b"one\n")]);
+ commit_all(&repo, "initial");
+
+ // The root commit diffs against the empty tree: everything is added.
+ let head = repo.head_id().expect("head").shorten_or_id().to_string();
+ let diff = worktree_commit_diff(dir.path(), &head).expect("diff");
+ assert_eq!(diff.files.len(), 1);
+ assert_eq!(diff.files[0].path, "a.txt");
+ assert_eq!(diff.files[0].status, DiffStatus::Added);
+ assert_eq!(diff.files[0].insertions, 1);
+ }
+
+ #[test]
+ fn file_commit_includes_message_body() {
+ let (_dir, repo) = fixture(&[("a.txt", b"one")]);
+ commit_all(&repo, "title");
+
+ // A single-line message has no body.
+ let head = head_commit(&repo).expect("head").expect("commit");
+ assert_eq!(head.summary, "title");
+ assert_eq!(head.description, None);
+
+ // A message with a body exposes it, trimmed.
+ let dir = _dir.path();
+ let status = Command::new("git")
+ .current_dir(dir)
+ .env("GIT_AUTHOR_NAME", "Test Author")
+ .env("GIT_AUTHOR_EMAIL", "test@example.com")
+ .env("GIT_COMMITTER_NAME", "Test Author")
+ .env("GIT_COMMITTER_EMAIL", "test@example.com")
+ .env("GIT_EDITOR", "true")
+ .args([
+ "commit",
+ "--allow-empty",
+ "-m",
+ "title two",
+ "-m",
+ "line one\n\nline two",
+ ])
+ .status()
+ .expect("spawn git");
+ assert!(status.success(), "git commit failed");
+
+ let head = head_commit(&repo).expect("head").expect("commit");
+ assert_eq!(head.summary, "title two");
+ assert_eq!(head.description.as_deref(), Some("line one\n\nline two"));
+ }
+
+ #[test]
+ fn commit_diff_reports_renames() {
+ let (_dir, repo) = fixture(&[("old.txt", b"same content\n")]);
+ commit_all(&repo, "initial");
+
+ std::fs::rename(_dir.path().join("old.txt"), _dir.path().join("new.txt")).expect("rename");
+ commit_all(&repo, "rename");
+
+ let head = repo.head_id().expect("head").shorten_or_id().to_string();
+ let diff = worktree_commit_diff(_dir.path(), &head).expect("diff");
+ let file = diff
+ .files
+ .iter()
+ .find(|f| f.path == "new.txt")
+ .expect("file");
+ assert_eq!(file.status, DiffStatus::Renamed);
+ assert_eq!(file.old_path.as_deref(), Some("old.txt"));
+ // A pure rename has no content change; the file is still listed.
+ assert!(file.hunks.is_empty());
+ assert_eq!(file.insertions, 0);
+ assert_eq!(file.deletions, 0);
+ }
+
+ #[test]
+ fn parses_format_patch_output() {
+ let patch = r#"From 1f6c0c5f3f1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a Mon Sep 17 00:00:00 2001
+From: A
+Subject: [PATCH] fix
+
+fix the thing
+
+---
+ src/lib.rs | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/lib.rs b/src/lib.rs
+index 1234567..89abcde 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -1,3 +1,3 @@
+ fn main() {
+- println!("old");
++ println!("new");
+ }
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ assert_eq!(diff.files.len(), 1);
+ let file = &diff.files[0];
+ assert_eq!(file.path, "src/lib.rs");
+ assert_eq!(file.old_path, None);
+ assert_eq!(file.status, DiffStatus::Modified);
+ assert_eq!(file.insertions, 1);
+ assert_eq!(file.deletions, 1);
+
+ let hunk = &file.hunks[0];
+ assert_eq!(hunk.old_start, 1);
+ assert_eq!(hunk.old_lines, 3);
+ assert_eq!(hunk.new_start, 1);
+ assert_eq!(hunk.new_lines, 3);
+ assert_eq!(hunk.lines.len(), 4);
+ assert_eq!(hunk.lines[0].kind, DiffLineKind::Context);
+ assert_eq!(hunk.lines[0].old, Some(1));
+ assert_eq!(hunk.lines[0].new, Some(1));
+ assert_eq!(hunk.lines[1].kind, DiffLineKind::Deletion);
+ assert_eq!(hunk.lines[1].old, Some(2));
+ assert_eq!(hunk.lines[1].new, None);
+ assert_eq!(hunk.lines[2].kind, DiffLineKind::Addition);
+ assert_eq!(hunk.lines[2].old, None);
+ assert_eq!(hunk.lines[2].new, Some(2));
+ assert_eq!(hunk.lines[3].kind, DiffLineKind::Context);
+ assert_eq!(hunk.lines[3].old, Some(3));
+ assert_eq!(hunk.lines[3].new, Some(3));
+ }
+
+ #[test]
+ fn parses_new_file_as_added() {
+ let patch = r#"diff --git a/README.md b/README.md
+new file mode 100644
+index 0000000..1234567
+--- /dev/null
++++ b/README.md
+@@ -0,0 +1 @@
++# hello
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ let file = &diff.files[0];
+ assert_eq!(file.path, "README.md");
+ assert_eq!(file.status, DiffStatus::Added);
+ assert_eq!(file.old_path, None);
+ assert_eq!(file.insertions, 1);
+ assert_eq!(file.deletions, 0);
+ assert_eq!(file.hunks[0].old_start, 0);
+ assert_eq!(file.hunks[0].old_lines, 0);
+ assert_eq!(file.hunks[0].new_start, 1);
+ }
+
+ #[test]
+ fn parses_renames_with_old_path() {
+ let patch = r#"diff --git a/old.rs b/new.rs
+similarity index 85%
+rename from old.rs
+rename to new.rs
+index 123..456 100644
+--- a/old.rs
++++ b/new.rs
+@@ -1 +1 @@
+-fn main() {}
++fn main() { println!("hi"); }
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ let file = &diff.files[0];
+ assert_eq!(file.path, "new.rs");
+ assert_eq!(file.old_path.as_deref(), Some("old.rs"));
+ assert_eq!(file.status, DiffStatus::Renamed);
+ assert_eq!(file.insertions, 1);
+ assert_eq!(file.deletions, 1);
+ }
+
+ #[test]
+ fn parses_patch_series_and_skips_envelope() {
+ let patch = r#"From aaaa Mon Sep 17 00:00:00 2001
+From: A
+Subject: [PATCH 1/2] one
+
+---
+ a.txt | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/a.txt b/a.txt
+index 1..2 100644
+--- a/a.txt
++++ b/a.txt
+@@ -1 +1,2 @@
+ a
++b
+
+From bbbb Mon Sep 17 00:00:00 2001
+From: A
+Subject: [PATCH 2/2] two
+
+diff --git a/b.txt b/b.txt
+index 3..4 100644
+--- a/b.txt
++++ b/b.txt
+@@ -1 +1 @@
+-x
++y
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ assert_eq!(diff.files.len(), 2);
+ assert_eq!(diff.files[0].path, "a.txt");
+ assert_eq!(diff.files[0].insertions, 1);
+ assert_eq!(diff.files[1].path, "b.txt");
+ assert_eq!(diff.files[1].deletions, 1);
+ }
+
+ #[test]
+ fn patch_commits_lists_every_patch_in_order() {
+ let patch = r#"From 1111111111111111111111111111111111111111 Mon Sep 17 00:00:00 2001
+From: Alice
+Date: Tue, 1 Aug 2023 10:00:00 +0200
+Subject: [PATCH 1/2] first
+
+body one
+---
+ a.txt | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/a.txt b/a.txt
+@@ -1 +1,2 @@
+ a
++b
+
+From 2222222222222222222222222222222222222222 Mon Sep 17 00:00:00 2001
+From: Bob
+Date: Wed, 2 Aug 2023 11:30:00 +0000
+Subject: [PATCH 2/2] second
+
+body two
+---
+ b.txt | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/b.txt b/b.txt
+@@ -1 +1,2 @@
+ x
++y
+"#;
+
+ let commits = patch_commits(patch);
+ assert_eq!(commits.len(), 2);
+
+ assert_eq!(commits[0].id, "1111111111111111111111111111111111111111");
+ assert_eq!(commits[0].summary, "first");
+ assert_eq!(commits[0].author, "Alice");
+ assert_eq!(commits[0].time, 1690876800);
+
+ assert_eq!(commits[1].id, "2222222222222222222222222222222222222222");
+ assert_eq!(commits[1].summary, "second");
+ assert_eq!(commits[1].author, "Bob");
+ assert_eq!(commits[1].time, 1690975800);
+ }
+
+ #[test]
+ fn patch_commits_strips_patch_subject_prefixes() {
+ let patch = r#"From 1111111111111111111111111111111111111111 Mon Sep 17 00:00:00 2001
+From: A
+Subject: [RFC PATCH v3 4/7] the real title
+
+---
+"#;
+
+ let commits = patch_commits(patch);
+ assert_eq!(commits.len(), 1);
+ assert_eq!(commits[0].summary, "the real title");
+ }
+
+ #[test]
+ fn patch_commits_handles_missing_headers() {
+ // A hand-written patch without author/date headers still lists a
+ // commit; time stays 0 and the author falls back to the raw value.
+ let patch = r#"From 1111111111111111111111111111111111111111 Mon Sep 17 00:00:00 2001
+Subject: [PATCH] plain
+
+---
+"#;
+
+ let commits = patch_commits(patch);
+ assert_eq!(commits.len(), 1);
+ assert_eq!(commits[0].summary, "plain");
+ assert_eq!(commits[0].author, "");
+ assert_eq!(commits[0].time, 0);
+ }
+
+ #[test]
+ fn patch_commits_ignores_non_patch_lines() {
+ assert!(patch_commits("").is_empty());
+ assert!(patch_commits("just some text\nFrom 123\n").is_empty());
+ // A diff-only body (no mbox envelope) has no commits.
+ let patch = "diff --git a/x b/x\n--- a/x\n+++ b/x\n";
+ assert!(patch_commits(patch).is_empty());
+ }
+
+ #[test]
+ fn marks_binary_sections() {
+ let patch = r#"diff --git a/img.png b/img.png
+index 123..456 100644
+Binary files a/img.png and b/img.png differ
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ assert!(diff.files[0].binary);
+ assert!(diff.files[0].hunks.is_empty());
+ }
+
+ #[test]
+ fn unquotes_quoted_paths() {
+ let patch = r#"diff --git "a/weird file.rs" "b/weird file.rs"
+index 123..456 100644
+--- "a/weird file.rs"
++++ "b/weird file.rs"
+@@ -1 +1 @@
+-x
++y
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ assert_eq!(diff.files[0].path, "weird file.rs");
+ assert_eq!(diff.files[0].status, DiffStatus::Modified);
+ }
+
+ #[test]
+ fn unquotes_non_ascii_quoted_paths() {
+ let patch = r#"diff --git "a/说明.md" "b/说明.md"
+index 123..456 100644
+--- "a/说明.md"
++++ "b/说明.md"
+@@ -1 +1 @@
+-x
++y
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ assert_eq!(diff.files[0].path, "说明.md");
+ assert_eq!(diff.files[0].status, DiffStatus::Modified);
+ }
+
+ #[test]
+ fn unquotes_octal_escaped_paths() {
+ let patch = r#"diff --git "a/\345\270\226.md" "b/\345\270\226.md"
+index 123..456 100644
+--- "a/\345\270\226.md"
++++ "b/\345\270\226.md"
+@@ -1 +1 @@
+-x
++y
+"#;
+ let diff = patch_diffs(patch).expect("parse");
+
+ assert_eq!(diff.files[0].path, "帖.md");
+ assert_eq!(diff.files[0].status, DiffStatus::Modified);
+ }
+
+ #[test]
+ fn empty_or_unparseable_patch_yields_no_files() {
+ assert_eq!(patch_diffs("").expect("parse").files.len(), 0);
+ assert_eq!(patch_diffs("just some text").expect("parse").files.len(), 0);
+ assert_eq!(
+ patch_diffs("---\nnot a patch\n")
+ .expect("parse")
+ .files
+ .len(),
+ 0
+ );
+ }
+
+ #[test]
+ fn parses_real_format_patch_output() {
+ // Build a commit touching a mix of file kinds, then feed genuine
+ // `git format-patch` output through the parser: quoted paths (space
+ // in the name), octal-escaped paths (UTF-8 name), a rename-free
+ // modification, an addition and a binary deletion.
+ let (dir, repo) = fixture(&[
+ ("src/main.rs", b"fn main() {\n println!(\"one\");\n}\n"),
+ ("my file.txt", b"hello\n"),
+ ("\u{8bf4}\u{660e}.md", "# \u{8bf4}\u{660e}\n".as_bytes()),
+ ("img.png", b"\x89PNG\r\n\x1a\n\x00binary"),
+ ]);
+ commit_all(&repo, "initial");
+
+ std::fs::write(
+ dir.path().join("src/main.rs"),
+ b"fn main() {\n println!(\"two\");\n println!(\"three\");\n}\n",
+ )
+ .expect("write");
+ std::fs::write(dir.path().join("my file.txt"), b"hello world\n").expect("write");
+ std::fs::write(
+ dir.path().join("\u{8bf4}\u{660e}.md"),
+ "# \u{8bf4}\u{660e}\nupdated\n",
+ )
+ .expect("write");
+ std::fs::remove_file(dir.path().join("img.png")).expect("remove");
+ std::fs::write(dir.path().join("new file.md"), b"# new\n").expect("write");
+ commit_all(&repo, "changes");
+
+ let output = Command::new("git")
+ .current_dir(dir.path())
+ .env("GIT_AUTHOR_NAME", "Test Author")
+ .env("GIT_AUTHOR_EMAIL", "test@example.com")
+ .env("GIT_COMMITTER_NAME", "Test Author")
+ .env("GIT_COMMITTER_EMAIL", "test@example.com")
+ .args(["format-patch", "-1", "--stdout"])
+ .output()
+ .expect("spawn git format-patch");
+ assert!(output.status.success(), "git format-patch failed");
+ let patch = String::from_utf8(output.stdout).expect("patch is utf-8");
+
+ let diff = patch_diffs(&patch).expect("parse real format-patch output");
+
+ let by_path = |path: &str| {
+ diff.files
+ .iter()
+ .find(|file| file.path == path)
+ .unwrap_or_else(|| panic!("missing file {path:?}"))
+ };
+
+ // Space in the name: git quotes the path in the header.
+ let file = by_path("my file.txt");
+ assert_eq!(file.status, DiffStatus::Modified);
+ assert_eq!(file.insertions, 1);
+
+ // UTF-8 name: git emits the path as octal escapes.
+ let file = by_path("\u{8bf4}\u{660e}.md");
+ assert_eq!(file.status, DiffStatus::Modified);
+ assert_eq!(file.insertions, 1);
+
+ let file = by_path("src/main.rs");
+ assert_eq!(file.status, DiffStatus::Modified);
+ assert_eq!(file.insertions, 2);
+ assert_eq!(file.deletions, 1);
+ assert!(!file.hunks.is_empty());
+
+ let file = by_path("new file.md");
+ assert_eq!(file.status, DiffStatus::Added);
+ assert_eq!(file.insertions, 1);
+
+ // Binary deletion: git emits no ---/+++ lines, only the mode and
+ // the "Binary files" marker.
+ let file = by_path("img.png");
+ assert_eq!(file.status, DiffStatus::Deleted);
+ assert!(file.binary);
+ assert!(file.hunks.is_empty());
+ }
}
diff --git a/crates/signed_nostr/src/backend.rs b/crates/signed_nostr/src/backend.rs
index 1a11220..ff86625 100644
--- a/crates/signed_nostr/src/backend.rs
+++ b/crates/signed_nostr/src/backend.rs
@@ -1,6 +1,8 @@
+#[cfg(not(target_arch = "wasm32"))]
+use std::path::Path;
use std::time::Duration;
-use anyhow::{Context, Result, anyhow};
+use anyhow::{Context, Result};
use nostr_gossip_memory::prelude::*;
#[cfg(not(target_arch = "wasm32"))]
use nostr_lmdb::prelude::*;
@@ -10,117 +12,45 @@ use nostr_sdk::prelude::*;
use crate::signer::UniversalSigner;
-/// Owns the nostr client: relay pool, LMDB database and signer.
+/// Open (or create) the LMDB database at `db_path` and build a client
+/// configured for Signed, together with a fresh signer.
///
-/// The SDK manages its own internal tokio runtime; every method here is a
-/// plain async fn that can be driven by GPUI's executors.
-#[derive(Clone)]
-pub struct NostrBackend {
- client: Client,
- signer: UniversalSigner,
+/// The SDK manages its own internal tokio runtime; the returned client can be
+/// driven by GPUI's executors.
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn new_backend(db_path: impl AsRef) -> Result<(Client, UniversalSigner)> {
+ let signer = UniversalSigner::new(Keys::generate());
+ let database = NostrLmdb::open(db_path)
+ .await
+ .context("failed to open nostr database")?;
+ Ok(with_database(signer, database))
}
-impl NostrBackend {
- /// Open (or create) the LMDB database at `db_path` and build the client.
- #[cfg(not(target_arch = "wasm32"))]
- pub async fn new(db_path: impl AsRef) -> Result {
- let signer = UniversalSigner::new(Keys::generate());
- let database = NostrLmdb::open(db_path)
- .await
- .context("failed to open nostr database")?;
- Ok(Self::with_database(signer, database))
- }
-
- /// In-memory database on wasm (no LMDB available).
- #[cfg(target_arch = "wasm32")]
- pub fn new() -> Result {
- let signer = UniversalSigner::new(Keys::generate());
- Ok(Self::with_database(signer, MemoryDatabase::unbounded()))
- }
-
- fn with_database(signer: UniversalSigner, database: D) -> Self
- where
- D: IntoNostrDatabase,
- {
- let authenticator = SignerAuthenticator::new(signer.clone());
-
- let client = ClientBuilder::default()
- .database(database)
- .authenticator(authenticator)
- .gossip(NostrGossipMemory::unbounded())
- .gossip_config(GossipConfig::default().no_background_refresh())
- .connect_timeout(Duration::from_secs(10))
- .verify_subscriptions(true)
- .ban_relay_on_mismatch(true)
- .sleep_when_idle(SleepWhenIdle::Enabled {
- timeout: Duration::from_secs(600),
- })
- .build();
-
- Self { client, signer }
- }
-
- pub fn client(&self) -> Client {
- self.client.clone()
- }
-
- pub fn signer(&self) -> UniversalSigner {
- self.signer.clone()
- }
-
- pub async fn add_relay(&self, url: &str) -> Result<()> {
- self.client.add_relay(url).await?;
- Ok(())
- }
-
- /// Add a relay used only for discovery (e.g. NIP-65 indexer relays).
- /// No subscriptions or writes are routed through it.
- pub async fn add_discovery_relay(&self, url: &str) -> Result<()> {
- self.client
- .add_relay(url)
- .capabilities(RelayCapabilities::DISCOVERY)
- .await?;
- Ok(())
- }
-
- pub async fn connect(&self) {
- self.client.connect().await;
- }
-
- /// Start a persistent subscription. Received events are stored in the
- /// database automatically by the relay pool.
- pub async fn subscribe(&self, filter: Filter) -> Result {
- let output = self.client.subscribe(filter).await?;
- Ok(output.value)
- }
-
- /// Query the local database (the single source of truth for the UI).
- pub async fn query(&self, filter: Filter) -> Result> {
- let events = self.client.database().query(filter).await?;
- Ok(events.into_iter().collect())
- }
-
- /// Sign with the current signer, broadcast, and save locally so the
- /// event is immediately visible to [`NostrBackend::query`].
- pub async fn send(&self, builder: EventBuilder) -> Result {
- let event = builder.finalize_async(&self.signer).await?;
-
- let output = self.client.send_event(&event).await?;
-
- // Keep our own events in the local database; the notification pump
- // only fires for events received from relays.
- self.client.database().save_event(&event).await?;
-
- if output.success.is_empty() && !output.failed.is_empty() {
- let reasons = output
- .failed
- .values()
- .cloned()
- .collect::>()
- .join(", ");
- return Err(anyhow!("event not accepted by any relay: {reasons}"));
- }
-
- Ok(event)
- }
+/// In-memory database on wasm (no LMDB available).
+#[cfg(target_arch = "wasm32")]
+pub fn new_backend() -> Result<(Client, UniversalSigner)> {
+ let signer = UniversalSigner::new(Keys::generate());
+ Ok(with_database(signer, MemoryDatabase::unbounded()))
+}
+
+fn with_database(signer: UniversalSigner, database: D) -> (Client, UniversalSigner)
+where
+ D: IntoNostrDatabase,
+{
+ let authenticator = SignerAuthenticator::new(signer.clone());
+
+ let client = ClientBuilder::default()
+ .database(database)
+ .authenticator(authenticator)
+ .gossip(NostrGossipMemory::unbounded())
+ .gossip_config(GossipConfig::default().no_background_refresh())
+ .connect_timeout(Duration::from_secs(10))
+ .verify_subscriptions(true)
+ .ban_relay_on_mismatch(true)
+ .sleep_when_idle(SleepWhenIdle::Enabled {
+ timeout: Duration::from_secs(600),
+ })
+ .build();
+
+ (client, signer)
}
diff --git a/crates/signed_nostr/src/lib.rs b/crates/signed_nostr/src/lib.rs
index 1328bf4..3c99075 100644
--- a/crates/signed_nostr/src/lib.rs
+++ b/crates/signed_nostr/src/lib.rs
@@ -2,6 +2,6 @@ mod backend;
mod signer;
mod update;
-pub use backend::NostrBackend;
+pub use backend::new_backend;
pub use signer::{SignedAuthUrlHandler, UniversalSigner};
pub use update::Update;
diff --git a/crates/signed_nostr/src/signer.rs b/crates/signed_nostr/src/signer.rs
index 9f676d2..9f8e592 100644
--- a/crates/signed_nostr/src/signer.rs
+++ b/crates/signed_nostr/src/signer.rs
@@ -194,7 +194,7 @@ impl AuthUrlHandler for SignedAuthUrlHandler {
auth_url: Url,
) -> Pin> + Send + '_>> {
Box::pin(async move {
- webbrowser::open(auth_url.as_str()).unwrap();
+ webbrowser::open(auth_url.as_str()).map_err(nostr_connect::error::Error::other)?;
Ok(())
})
}
diff --git a/crates/signed_nostr/src/update.rs b/crates/signed_nostr/src/update.rs
index 1f2222f..1b3f1de 100644
--- a/crates/signed_nostr/src/update.rs
+++ b/crates/signed_nostr/src/update.rs
@@ -7,7 +7,7 @@ use nostr_sdk::prelude::*;
pub struct Update {
pub kind: Kind,
/// First `a` tag value of the event, if any (e.g. the repository coordinate).
- pub coordinate: Option,
+ pub coordinate: Option,
pub author: PublicKey,
pub event_id: EventId,
}
@@ -15,12 +15,7 @@ pub struct Update {
impl Update {
/// Build an update from a received event.
pub fn from_event(event: &Event) -> Self {
- let coordinate = event
- .tags
- .iter()
- .find(|t| t.kind() == "a")
- .and_then(|t| t.content())
- .map(str::to_owned);
+ let coordinate = event.tags.coordinates().nth(0);
Self {
kind: event.kind,
diff --git a/crates/signed_state/Cargo.toml b/crates/signed_state/Cargo.toml
index cea9b9a..0bd56f0 100644
--- a/crates/signed_state/Cargo.toml
+++ b/crates/signed_state/Cargo.toml
@@ -6,12 +6,16 @@ publish.workspace = true
[dependencies]
signed_core = { path = "../signed_core" }
+signed_git = { path = "../signed_git" }
signed_nostr = { path = "../signed_nostr" }
+utils = { path = "../utils" }
nostr.workspace = true
nostr-sdk.workspace = true
nostr-connect.workspace = true
+bitcoin_hashes = "1"
+
gpui.workspace = true
flume.workspace = true
anyhow.workspace = true
diff --git a/crates/signed_state/src/backend.rs b/crates/signed_state/src/backend.rs
index 668063a..88c556d 100644
--- a/crates/signed_state/src/backend.rs
+++ b/crates/signed_state/src/backend.rs
@@ -1,16 +1,18 @@
+use std::collections::HashMap;
use std::time::Duration;
use anyhow::{Error, anyhow};
use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Task};
+use nostr::event::IntoEventBuilder;
use nostr_connect::prelude::*;
+use nostr_sdk::client::SyncSummary;
use nostr_sdk::prelude::*;
use signed_core::filters;
-use signed_nostr::{NostrBackend, SignedAuthUrlHandler, UniversalSigner, Update};
+use signed_nostr::{SignedAuthUrlHandler, UniversalSigner, Update};
-/// Keyring entry holding the user credential (`nsec1...` or `bunker://...`).
-pub const USER_KEYRING: &str = "su.reya.signed#user";
-/// Keyring entry holding the locally generated key for NIP-46 sessions.
-pub const MASTER_KEYRING: &str = "su.reya.signed#master";
+/// Keyring entry holding the user credential (`nsec1...` or `bunker://...`
+/// with an embedded `?master=` NIP-46 session key).
+pub const USER_KEYRING: &str = "Signed Safe Storage";
/// Timeout for NIP-46 signer responses.
pub const NOSTR_CONNECT_TIMEOUT: u64 = 60;
@@ -33,12 +35,27 @@ pub const INDEXER_RELAYS: [&str; 3] = [
pub enum BackendEvent {
/// User has no signer configured.
SignerRequired,
+ /// The stored identity is NIP-49 encrypted (`ncryptsec1...`); a
+ /// passphrase is required to decrypt it before the session can resume.
+ PassphraseRequired,
/// The signer has changed (login/logout/account switch).
SignerChanged,
/// Relay bootstrap finished.
Connected,
/// A new event was received from a relay and stored in the database.
NostrUpdate(Update),
+ /// A negentropy sync completed; the database was updated directly,
+ /// so stores should re-query (no [`BackendEvent::NostrUpdate`] is fired
+ /// for synced events).
+ Synced,
+ /// A negentropy sync is in flight. Stores may re-query to render
+ /// incrementally; UI can show `current`/`total` progress.
+ SyncProgress {
+ /// Total events to process.
+ total: u64,
+ /// Events processed so far.
+ current: u64,
+ },
/// An event built locally was signed, broadcast and stored.
Published(Box),
/// An error occurred.
@@ -58,8 +75,14 @@ impl BackendEvent {
/// notification pump. Stores subscribe to [`BackendEvent`] and re-query the
/// local database when relevant updates arrive.
pub struct Backend {
- inner: NostrBackend,
+ client: Client,
+ signer: UniversalSigner,
current_user: Option,
+ connected: bool,
+ sync_progress: Option<(u64, u64)>,
+ /// Whether the stored credential is NIP-49 encrypted and a passphrase
+ /// is still needed to resume the session.
+ passphrase_required: bool,
tasks: Vec>>,
}
@@ -79,11 +102,11 @@ impl Backend {
cx.set_global(GlobalBackend(entity));
}
- pub(crate) fn new(inner: NostrBackend, cx: &mut Context) -> Self {
- let client = inner.client();
+ pub(crate) fn new(client: Client, signer: UniversalSigner, cx: &mut Context) -> Self {
+ let pump_client = client.clone();
let pump = cx.spawn(async move |this, cx| {
- let mut notifications = client.notifications();
+ let mut notifications = pump_client.notifications();
while let Some(notification) = notifications.next().await {
let ClientNotification::Event { event, .. } = notification else {
@@ -104,8 +127,12 @@ impl Backend {
});
let mut this = Self {
- inner,
+ client,
+ signer,
current_user: None,
+ connected: false,
+ sync_progress: None,
+ passphrase_required: false,
tasks: vec![pump],
};
@@ -116,23 +143,30 @@ impl Backend {
/// Bootstrap the client: connect to the default relays (indexers as
/// discovery-only) and restore the saved session, if any.
fn bootstrap(&mut self, cx: &mut Context) {
- let backend = self.inner.clone();
+ let client = self.client.clone();
let task = cx.background_spawn(async move {
for url in BOOTSTRAP_RELAYS {
- backend.add_relay(url).await?;
+ client.add_relay(url).await?;
}
for url in INDEXER_RELAYS {
- backend.add_discovery_relay(url).await?;
+ client
+ .add_relay(url)
+ .capabilities(RelayCapabilities::DISCOVERY)
+ .await?;
}
- backend.connect().await;
+ client.connect().await;
Ok::<(), Error>(())
});
self.tasks.push(cx.spawn(async move |this, cx| {
match task.await {
Ok(()) => {
- this.update(cx, |_this, cx| cx.emit(BackendEvent::Connected))?;
+ this.update(cx, |this, cx| {
+ this.connected = true;
+ cx.emit(BackendEvent::Connected);
+ cx.notify();
+ })?;
}
Err(e) => {
this.update(cx, |_this, cx| cx.emit(BackendEvent::error(e.to_string())))?;
@@ -145,7 +179,9 @@ impl Backend {
}
/// Restore the saved session from the keyring. Emits
- /// [`BackendEvent::SignerRequired`] if no credential is stored.
+ /// [`BackendEvent::SignerRequired`] if no credential is stored, or
+ /// [`BackendEvent::PassphraseRequired`] if the stored identity is
+ /// NIP-49 encrypted.
pub fn restore_session(&mut self, cx: &mut Context) {
if cfg!(target_arch = "wasm32") {
cx.emit(BackendEvent::SignerRequired);
@@ -153,7 +189,6 @@ impl Backend {
}
let user = cx.read_credentials(USER_KEYRING);
- let master = self.master_key(cx);
self.tasks.push(cx.spawn(async move |this, cx| {
let content = match user.await {
@@ -169,15 +204,24 @@ impl Backend {
let keys = Keys::new(SecretKey::parse(&content)?);
this.update(cx, |this, cx| this.set_signer(keys, cx))?;
} else if content.starts_with("bunker://") {
- let uri = NostrConnectUri::parse(&content)?;
+ let (base, keys) = extract_master_key(&content);
+ let uri = NostrConnectUri::parse(base)?;
let mut signer = NostrConnect::new(
uri,
- master.await,
+ keys,
Duration::from_secs(NOSTR_CONNECT_TIMEOUT),
None,
)?;
signer.auth_url_handler(SignedAuthUrlHandler);
this.update(cx, |this, cx| this.set_signer(signer, cx))?;
+ } else if content.starts_with("ncryptsec1") {
+ // Encrypted identity: a passphrase is required to
+ // decrypt it before the session can resume.
+ log::warn!("stored identity is ncryptsec-encrypted; waiting for passphrase");
+ this.update(cx, |this, cx| {
+ this.passphrase_required = true;
+ cx.emit(BackendEvent::PassphraseRequired);
+ })?;
} else {
this.update(cx, |_, cx| cx.emit(BackendEvent::SignerRequired))?;
}
@@ -197,6 +241,166 @@ impl Backend {
}));
}
+ /// Decrypt the NIP-49 encrypted credential stored in the keyring with
+ /// the given passphrase and resume the session.
+ ///
+ /// The scrypt decryption runs off the UI thread. The returned task
+ /// yields the public key on success, or the failure reason (e.g. wrong
+ /// passphrase), so callers can render inline errors.
+ pub fn restore_with_passphrase(
+ &mut self,
+ password: &str,
+ cx: &mut Context,
+ ) -> Task> {
+ let password = password.to_owned();
+ let user = cx.read_credentials(USER_KEYRING);
+
+ cx.spawn(async move |this, cx| {
+ let content = user
+ .await?
+ .map(|(_username, secret)| String::from_utf8(secret))
+ .transpose()?
+ .ok_or_else(|| anyhow!("no stored credential; nothing to unlock"))?;
+
+ if !content.starts_with("ncryptsec1") {
+ return Err(anyhow!("stored credential is not passphrase-encrypted"));
+ }
+
+ let decrypt_task = cx.background_spawn(async move {
+ let encrypted = EncryptedSecretKey::from_bech32(&content)?;
+ let secret = encrypted.decrypt(&password)?;
+ Ok::<_, Error>(Keys::new(secret))
+ });
+
+ let keys = decrypt_task.await?;
+ let public_key = keys.public_key();
+
+ this.update(cx, |this, cx| this.set_signer(keys, cx))?;
+
+ Ok(public_key)
+ })
+ }
+
+ /// Create a new identity: generate keys, encrypt the secret key with the
+ /// passphrase (NIP-49) and persist it in the keyring, then publish the
+ /// user's NIP-65 relay list, metadata and grasp list.
+ ///
+ /// The heavy encryption runs off the UI thread. The returned task yields
+ /// the new public key on success, or the failure reason, so callers can
+ /// render progress and inline errors.
+ pub fn create_identity(
+ &mut self,
+ name: &str,
+ password: &str,
+ cx: &mut Context,
+ ) -> Task> {
+ let name = name.trim().to_owned();
+ let password = password.to_owned();
+
+ if name.is_empty() || name.len() > 255 {
+ return Task::ready(Err(anyhow!("Name must be 1-255 characters")));
+ }
+ if password.is_empty() {
+ return Task::ready(Err(anyhow!("Passphrase must not be empty")));
+ }
+
+ cx.spawn(async move |this, cx| {
+ let job = cx.background_spawn(async move {
+ let keys = Keys::generate();
+ let encrypted =
+ EncryptedSecretKey::new(keys.secret_key(), &password, 16, KeySecurity::Medium)?;
+ let ncryptsec = encrypted.to_bech32()?;
+ Ok::<_, Error>((keys, ncryptsec))
+ });
+
+ let (keys, ncryptsec) = job.await?;
+ let public_key = keys.public_key();
+
+ // Persist the encrypted credential.
+ let write = cx.update(|cx| {
+ cx.write_credentials(USER_KEYRING, &public_key.to_hex(), ncryptsec.as_bytes())
+ });
+ write.await?;
+
+ this.update(cx, |this, cx| {
+ // Become the new identity, so the publishes below are
+ // signed with the new keys.
+ this.signer.swap_inner(keys);
+ this.current_user = Some(public_key);
+ this.bootstrap_user(public_key, cx);
+ cx.emit(BackendEvent::SignerChanged);
+ cx.notify();
+
+ let relays: Vec<(RelayUrl, Option)> = [
+ (
+ RelayUrl::parse("wss://relay.primal.net").unwrap(),
+ Some(RelayMetadata::Read),
+ ),
+ (
+ RelayUrl::parse("wss://relay.ditto.pub").unwrap(),
+ Some(RelayMetadata::Read),
+ ),
+ (
+ RelayUrl::parse("wss://relay.nostr.net").unwrap(),
+ Some(RelayMetadata::Write),
+ ),
+ (
+ RelayUrl::parse("wss://nos.lol").unwrap(),
+ Some(RelayMetadata::Write),
+ ),
+ ]
+ .to_vec();
+
+ this.send_fire_and_forget(RelayList::new(relays).into_event_builder(), cx);
+
+ let metadata = Metadata::new()
+ .name(&name)
+ .display_name(&name)
+ .into_event_builder();
+
+ this.send_fire_and_forget(metadata, cx);
+
+ let grasp_servers: Vec = ["wss://gitnostr.com", "wss://relay.ngit.dev"]
+ .into_iter()
+ .map(|url| RelayUrl::parse(url).expect("valid relay URL"))
+ .collect();
+
+ this.send_fire_and_forget(
+ GitUserGraspList { grasp_servers }.into_event_builder(),
+ cx,
+ );
+ })?;
+
+ Ok(public_key)
+ })
+ }
+
+ /// Login with an `nsec1...` key or a `bunker://...` URI, dispatching on
+ /// the credential's prefix.
+ pub fn login(&mut self, credential: &str, cx: &mut Context) {
+ let credential = credential.trim();
+
+ if credential.starts_with("nsec1") {
+ self.login_with_nsec(credential, cx);
+ } else if credential.starts_with("bunker://") {
+ self.login_with_bunker(credential, cx);
+ } else {
+ cx.emit(BackendEvent::error(
+ "Unsupported credential, expected nsec1... or bunker://...",
+ ));
+ }
+ }
+
+ /// Create a fresh identity and login with it. The generated key is
+ /// persisted in the keyring like any other `nsec` credential.
+ pub fn login_with_new_identity(&mut self, cx: &mut Context) {
+ let nsec = Keys::generate()
+ .secret_key()
+ .to_bech32()
+ .expect("infallible");
+ self.login_with_nsec(&nsec, cx);
+ }
+
/// Login with an `nsec1...` secret key. The credential is verified by
/// the signer flow and persisted in the keyring.
pub fn login_with_nsec(&mut self, nsec: &str, cx: &mut Context