262 lines
10 KiB
Rust
262 lines
10 KiB
Rust
use std::path::PathBuf;
|
|
|
|
use dock::DockArea;
|
|
use gpui::prelude::*;
|
|
use gpui::{App, Entity, PathPromptOptions, WeakEntity, Window, div, px};
|
|
use gpui_base::input::TextareaState;
|
|
use gpui_component::button::{Button, ButtonVariants};
|
|
use gpui_component::dialog::{DialogDescription, DialogFooter, DialogHeader, DialogTitle};
|
|
use gpui_component::form::{field, v_form};
|
|
use gpui_component::input::{Input, InputState, Textarea};
|
|
use gpui_component::{Disableable, IconName, WindowExt, h_flex};
|
|
use settings::SettingsStore;
|
|
use signed_core::Announcement;
|
|
use signed_state::{Backend, CheckoutsStore};
|
|
|
|
use super::super::open_repo_panel;
|
|
use super::grasp_servers::{GraspServersState, grasp_servers_field, load_user_grasp_servers};
|
|
use crate::views::dialog_state::{DialogProgress, error_row};
|
|
|
|
/// Shared state for the Create Repository dialog, so async results can be rendered.
|
|
pub type CreateRepoState = DialogProgress;
|
|
|
|
/// Open the Create Repository dialog.
|
|
pub fn open(dock_area: WeakEntity<DockArea>, window: &mut Window, cx: &mut App) {
|
|
let settings = SettingsStore::global(cx);
|
|
let default_folder = settings
|
|
.read(cx)
|
|
.settings()
|
|
.create_repository
|
|
.default_folder
|
|
.clone()
|
|
.unwrap_or_else(paths::desktop_dir);
|
|
|
|
let name_input = cx.new(|cx| InputState::new(window, cx).placeholder("Repository name"));
|
|
let desc_input = cx.new(|cx| {
|
|
TextareaState::new(window, cx)
|
|
.auto_grow(3, 5)
|
|
.placeholder("Short description")
|
|
});
|
|
let folder_input = cx.new(|cx| {
|
|
InputState::new(window, cx).default_value(default_folder.to_string_lossy().to_string())
|
|
});
|
|
let relay_input = cx.new(|cx| {
|
|
InputState::new(window, cx).placeholder("wss://relay.example.com or relay.example.com")
|
|
});
|
|
let state = cx.new(|_| CreateRepoState::default());
|
|
let grasp_settings = settings.read(cx).settings().grasp_servers.clone();
|
|
let grasp_state = cx.new(|_| GraspServersState::new_default(&grasp_settings));
|
|
|
|
load_user_grasp_servers(grasp_state.clone(), window, cx);
|
|
|
|
window.open_dialog(cx, move |dialog, _window, _cx| {
|
|
const DESC: &str = "Publish a new repository to your grasp servers.";
|
|
const FOLDER_NOTE: &str = "Where the repository's working copy is created.";
|
|
|
|
let name_input = name_input.clone();
|
|
let desc_input = desc_input.clone();
|
|
let folder_input = folder_input.clone();
|
|
let relay_input = relay_input.clone();
|
|
let state = state.clone();
|
|
let grasp_state = grasp_state.clone();
|
|
let dock_area = dock_area.clone();
|
|
|
|
dialog
|
|
.width(px(520.))
|
|
.margin_top(px(50.))
|
|
.content(move |content, _window, cx| {
|
|
let busy = state.read(cx).busy;
|
|
let error = state.read(cx).error.clone();
|
|
|
|
content
|
|
.child(
|
|
DialogHeader::new()
|
|
.child(DialogTitle::new().child("Create repository"))
|
|
.child(DialogDescription::new().child(DESC)),
|
|
)
|
|
.child(
|
|
v_form()
|
|
.child(
|
|
field()
|
|
.label("Repository name")
|
|
.description("Max 100 characters")
|
|
.required(true)
|
|
.child(Input::new(&name_input)),
|
|
)
|
|
.child(
|
|
field()
|
|
.label("Description")
|
|
.child(Textarea::new(&desc_input)),
|
|
)
|
|
.child(
|
|
field().label("Folder").description(FOLDER_NOTE).child(
|
|
h_flex()
|
|
.gap_1()
|
|
.items_center()
|
|
.child(
|
|
div()
|
|
.flex_1()
|
|
.child(Input::new(&folder_input).disabled(true)),
|
|
)
|
|
.child(
|
|
Button::new("choose-folder")
|
|
.icon(IconName::FolderOpen)
|
|
.ghost()
|
|
.tooltip("Choose folder")
|
|
.on_click({
|
|
let folder_input = folder_input.clone();
|
|
move |_ev, window, cx| {
|
|
choose_folder(&folder_input, window, cx);
|
|
}
|
|
}),
|
|
),
|
|
),
|
|
)
|
|
.child(grasp_servers_field(&grasp_state, &relay_input, cx)),
|
|
)
|
|
.children(error_row(&error, cx))
|
|
.child(
|
|
DialogFooter::new().justify_end().child(
|
|
Button::new("create")
|
|
.primary()
|
|
.label("Create repository")
|
|
.icon(IconName::ArrowRight)
|
|
.tooltip("Create repository")
|
|
.loading(busy)
|
|
.disabled(busy)
|
|
.on_click({
|
|
let name_input = name_input.clone();
|
|
let desc_input = desc_input.clone();
|
|
let folder_input = folder_input.clone();
|
|
let state = state.clone();
|
|
let grasp_state = grasp_state.clone();
|
|
let dock_area = dock_area.clone();
|
|
|
|
move |_ev, window, cx| {
|
|
create_repository(
|
|
name_input.clone(),
|
|
desc_input.clone(),
|
|
folder_input.clone(),
|
|
state.clone(),
|
|
grasp_state.clone(),
|
|
dock_area.clone(),
|
|
window,
|
|
cx,
|
|
);
|
|
}
|
|
}),
|
|
),
|
|
)
|
|
})
|
|
});
|
|
}
|
|
|
|
/// Pick the repository's storage folder with the platform's native folder picker.
|
|
fn choose_folder(folder_input: &Entity<InputState>, window: &mut Window, cx: &mut App) {
|
|
let handle = window.window_handle();
|
|
let folder_input = folder_input.clone();
|
|
let store = SettingsStore::global(cx);
|
|
|
|
let prompt = cx.prompt_for_paths(PathPromptOptions {
|
|
files: false,
|
|
directories: true,
|
|
multiple: false,
|
|
prompt: Some("Choose folder".into()),
|
|
});
|
|
|
|
cx.spawn(async move |cx| {
|
|
if let Ok(Ok(Some(mut paths))) = prompt.await
|
|
&& let Some(path) = paths.pop()
|
|
{
|
|
let path = path.to_string_lossy().to_string();
|
|
cx.update_window(handle, |_, window, cx| {
|
|
store.update(cx, |store, cx| {
|
|
store.edit(
|
|
|settings| {
|
|
settings.create_repository.default_folder = Some(path.clone().into())
|
|
},
|
|
cx,
|
|
);
|
|
});
|
|
folder_input.update(cx, |input, cx| input.set_value(path, window, cx));
|
|
})
|
|
.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
/// Run the create-repository flow.
|
|
///
|
|
/// Opens the new working copy and the repository panel on success.
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn create_repository(
|
|
name_input: Entity<InputState>,
|
|
desc_input: Entity<TextareaState>,
|
|
folder_input: Entity<InputState>,
|
|
state: Entity<CreateRepoState>,
|
|
grasp_state: Entity<GraspServersState>,
|
|
dock_area: WeakEntity<DockArea>,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) {
|
|
let name = name_input.read(cx).value().trim().to_owned();
|
|
let description = desc_input.read(cx).value().trim().to_owned();
|
|
let folder = PathBuf::from(folder_input.read(cx).value().trim());
|
|
let servers = grasp_state.read(cx).grasp_servers.clone();
|
|
|
|
if name.is_empty() {
|
|
state.update(cx, |state, _| state.fail("Repository name is required"));
|
|
return;
|
|
}
|
|
if servers.is_empty() {
|
|
state.update(cx, |state, _| state.fail("Add at least one grasp server"));
|
|
return;
|
|
}
|
|
|
|
state.update(cx, |state, _| state.begin());
|
|
|
|
let backend = Backend::global(cx);
|
|
let task = backend.update(cx, |backend, cx| {
|
|
backend.create_repository(&name, &description, folder, servers, cx)
|
|
});
|
|
|
|
let handle = window.window_handle();
|
|
let state = state.clone();
|
|
let dock_area = dock_area.clone();
|
|
|
|
cx.spawn(async move |cx| match task.await {
|
|
Ok((announcement, local_path)) => {
|
|
cx.update_window(handle, |_, window, cx| {
|
|
window.close_dialog(cx);
|
|
// Record the new working copy as a checkout of this repository.
|
|
// The New PR panel then pre-fills it.
|
|
let checkouts = CheckoutsStore::global(cx);
|
|
checkouts.update(cx, |store, cx| {
|
|
store.record(local_path.clone(), announcement.addr(), cx);
|
|
});
|
|
cx.open_with_system(&local_path);
|
|
open_repo(dock_area, announcement, window, cx);
|
|
})
|
|
.ok();
|
|
}
|
|
Err(e) => {
|
|
cx.update_window(handle, |_, _window, cx| {
|
|
state.update(cx, |state, _| state.fail(e.to_string()));
|
|
})
|
|
.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
/// Open the newly created repository in the dock's center.
|
|
fn open_repo(
|
|
dock_area: WeakEntity<DockArea>,
|
|
announcement: Announcement,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) {
|
|
open_repo_panel(&dock_area, &announcement, window, cx);
|
|
}
|