woocraft 0.4.5

GPUI components lib for Woocraft design system.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::rc::Rc;

use anyhow::Result;
use gpui::{App, Context, Hsla, MouseMoveEvent, Task, Window};
use ropey::Rope;

use crate::widgets::editor::{InputState, RopeExt, popovers::ContextMenu};

mod code_actions;
mod completions;
mod definitions;
mod document_colors;
mod hover;

pub use code_actions::*;
pub use completions::*;
pub use definitions::*;
pub use document_colors::*;
pub use hover::*;

/// LSP ServerCapabilities
///
/// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#serverCapabilities
pub struct Lsp {
  /// The completion provider.
  pub completion_provider: Option<Rc<dyn CompletionProvider>>,
  /// The code action providers.
  pub code_action_providers: Vec<Rc<dyn CodeActionProvider>>,
  /// The hover provider.
  pub hover_provider: Option<Rc<dyn HoverProvider>>,
  /// The definition provider.
  pub definition_provider: Option<Rc<dyn DefinitionProvider>>,
  /// The document color provider.
  pub document_color_provider: Option<Rc<dyn DocumentColorProvider>>,

  document_colors: Vec<(lsp_types::Range, Hsla)>,
  _hover_task: Task<Result<()>>,
  _document_color_task: Task<()>,
}

impl Default for Lsp {
  fn default() -> Self {
    Self {
      completion_provider: None,
      code_action_providers: vec![],
      hover_provider: None,
      definition_provider: None,
      document_color_provider: None,
      document_colors: vec![],
      _hover_task: Task::ready(Ok(())),
      _document_color_task: Task::ready(()),
    }
  }
}

impl Lsp {
  /// Update the LSP when the text changes.
  pub(crate) fn update(&mut self, text: &Rope, window: &mut Window, cx: &mut Context<InputState>) {
    self.update_document_colors(text, window, cx);
  }

  /// Reset all LSP states.
  pub(crate) fn reset(&mut self) {
    self.document_colors.clear();
    self._hover_task = Task::ready(Ok(()));
    self._document_color_task = Task::ready(());
  }
}

impl InputState {
  pub(crate) fn hide_context_menu(&mut self, cx: &mut Context<Self>) {
    self.context_menu = None;
    self._context_menu_task = Task::ready(Ok(()));
    cx.notify();
  }

  pub(crate) fn is_context_menu_open(&self, cx: &App) -> bool {
    let Some(menu) = self.context_menu.as_ref() else {
      return false;
    };

    menu.is_open(cx)
  }

  /// Handles an action for the completion menu, if it exists.
  ///
  /// Return true if the action was handled, otherwise false.
  pub fn handle_action_for_context_menu(
    &mut self, action: Box<dyn gpui::Action>, window: &mut Window, cx: &mut Context<Self>,
  ) -> bool {
    let Some(menu) = self.context_menu.as_ref() else {
      return false;
    };

    let mut handled = false;

    match menu {
      ContextMenu::Completion(menu) => {
        menu.update(cx, |menu, cx| {
          handled = menu.handle_action(action, window, cx)
        });
      }
      ContextMenu::CodeAction(menu) => {
        menu.update(cx, |menu, cx| {
          handled = menu.handle_action(action, window, cx)
        });
      }
    };

    handled
  }

  /// Apply a list of [`lsp_types::TextEdit`] to mutate the text.
  pub fn apply_lsp_edits(
    &mut self, text_edits: &Vec<lsp_types::TextEdit>, window: &mut Window, cx: &mut Context<Self>,
  ) {
    for edit in text_edits {
      let start = self.text.position_to_offset(&edit.range.start);
      let end = self.text.position_to_offset(&edit.range.end);

      let range_utf16 = self.range_to_utf16(&(start..end));
      self.replace_text_in_range_silent(Some(range_utf16), &edit.new_text, window, cx);
    }
  }

  pub(super) fn handle_mouse_move(
    &mut self, offset: usize, event: &MouseMoveEvent, window: &mut Window,
    cx: &mut Context<InputState>,
  ) {
    let mut needs_notify = false;

    if event.modifiers.secondary() {
      needs_notify |= self.clear_hover_popover_if_needed();
      needs_notify |= self.handle_hover_definition(offset, window, cx);
    } else {
      needs_notify |= self.clear_hover_definition_if_needed();
      needs_notify |= self.handle_hover_popover(offset, window, cx);
    }

    if needs_notify {
      cx.notify();
    }
  }
}