andrey/helix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

minor: Remove some outdated comments

Browse Source
This commit is contained in:
Blaž Hrastnik 2022-03-03 17:18:26 +09:00
parent 737282d0e9
commit 0062af6a19
No known key found for this signature in database
GPG Key ID: 1238B9C4AD889640
5 changed files with 6 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
helix-term/src/application.rs
View File

@ -42,16 +42,11 @@ pub struct Application {
compositor: Compositor,
editor: Editor,
// TODO should be separate to take only part of the config
// TODO: share an ArcSwap with Editor?
config: Config,
// Currently never read from. Remove the `allow(dead_code)` when
// that changes.
#[allow(dead_code)]
theme_loader: Arc<theme::Loader>,
// Currently never read from. Remove the `allow(dead_code)` when
// that changes.
#[allow(dead_code)]
syn_loader: Arc<syntax::Loader>,
@ -719,15 +714,6 @@ pub async fn handle_language_server_message(
Some(call) => call,
None => {
error!("Method not found {}", method);
// language_server.reply(
// call.id,
// // TODO: make a Into trait that can cast to Err(jsonrpc::Error)
// Err(helix_lsp::jsonrpc::Error {
// code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound,
// message: "Method not found".to_string(),
// data: None,
// }),
// );
return;
}
};

49
helix-term/src/commands.rs
View File

@ -1492,7 +1492,7 @@ fn search_impl(
let selection = doc.selection(view.id);
// Get the right side of the primary block cursor for forward search, or the
//grapheme before the start of the selection for reverse search.
// grapheme before the start of the selection for reverse search.
let start = match direction {
Direction::Forward => text.char_to_byte(graphemes::next_grapheme_boundary(
text,
@ -1504,10 +1504,10 @@ fn search_impl(
)),
};
//A regex::Match returns byte-positions in the str. In the case where we
//do a reverse search and wraparound to the end, we don't need to search
//the text before the current cursor position for matches, but by slicing
//it out, we need to add it back to the position of the selection.
// A regex::Match returns byte-positions in the str. In the case where we
// do a reverse search and wraparound to the end, we don't need to search
// the text before the current cursor position for matches, but by slicing
// it out, we need to add it back to the position of the selection.
let mut offset = 0;
// use find_at to find the next match after the cursor, loop around the end
@ -4352,9 +4352,6 @@ pub fn delete_word_forward(cx: &mut Context) {
// Undo / Redo
// TODO: each command could simply return a Option<transaction>, then the higher level handles
// storing it?
fn undo(cx: &mut Context) {
let count = cx.count();
let (view, doc) = current!(cx.editor);
@ -4930,42 +4927,6 @@ fn remove_primary_selection(cx: &mut Context) {
pub fn completion(cx: &mut Context) {
use helix_lsp::{lsp, util::pos_to_lsp_pos};
// trigger on trigger char, or if user calls it
// (or on word char typing??)
// after it's triggered, if response marked is_incomplete, update on every subsequent keypress
//
// lsp calls are done via a callback: it sends a request and doesn't block.
// when we get the response similarly to notification, trigger a call to the completion popup
//
// language_server.completion(params, |cx: &mut Context, _meta, response| {
// // called at response time
// // compositor, lookup completion layer
// // downcast dyn Component to Completion component
// // emit response to completion (completion.complete/handle(response))
// })
//
// typing after prompt opens: usually start offset is tracked and everything between
// start_offset..cursor is replaced. For our purposes we could keep the start state (doc,
// selection) and revert to them before applying. This needs to properly reset changes/history
// though...
//
// company-mode does this by matching the prefix of the completion and removing it.
// ignore isIncomplete for now
// keep state while typing
// the behavior should be, filter the menu based on input
// if items returns empty at any point, remove the popup
// if backspace past initial offset point, remove the popup
//
// debounce requests!
//
// need an idle timeout thing.
// https://github.com/company-mode/company-mode/blob/master/company.el#L620-L622
//
// "The idle delay in seconds until completion starts automatically.
// The prefix still has to satisfy `company-minimum-prefix-length' before that
// happens. The value of nil means no idle completion."
let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {

12
helix-term/src/ui/completion.rs
View File

@ -280,18 +280,6 @@ pub fn is_empty(&self) -> bool {
}
}
// need to:
// - trigger on the right trigger char
// - detect previous open instance and recycle
// - update after input, but AFTER the document has changed
// - if no more matches, need to auto close
//
// missing bits:
// - a more robust hook system: emit to a channel, process in main loop
// - a way to find specific layers in compositor
// - components register for hooks, then unregister when terminated
// ... since completion is a special case, maybe just build it into doc/render?
impl Component for Completion {
fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
// let the Editor handle Esc instead

14
helix-term/src/ui/editor.rs
View File

@ -522,7 +522,6 @@ pub fn render_diagnostics(
let info = theme.get("info");
let hint = theme.get("hint");
// Vec::with_capacity(diagnostics.len()); // rough estimate
let mut lines = Vec::new();
for diagnostic in diagnostics {
let text = Text::styled(
@ -637,19 +636,6 @@ pub fn render_statusline(
base_style,
));
// let indent_info = match doc.indent_style {
// IndentStyle::Tabs => "tabs",
// IndentStyle::Spaces(1) => "spaces:1",
// IndentStyle::Spaces(2) => "spaces:2",
// IndentStyle::Spaces(3) => "spaces:3",
// IndentStyle::Spaces(4) => "spaces:4",
// IndentStyle::Spaces(5) => "spaces:5",
// IndentStyle::Spaces(6) => "spaces:6",
// IndentStyle::Spaces(7) => "spaces:7",
// IndentStyle::Spaces(8) => "spaces:8",
// _ => "indent:ERROR",
// };
// Position
let pos = coords_at_pos(
doc.text().slice(..),

23
helix-view/src/tree.rs
View File

@ -45,8 +45,6 @@ pub fn view(view: View) -> Self {
}
}
// TODO: screen coord to container + container coordinate helpers
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Layout {
Horizontal,
@ -515,27 +513,6 @@ pub fn focus_next(&mut self) {
// For now that's okay though, since it's unlikely you'll be able to open a large enough
// number of splits to notice.
// current = focus
// let found = loop do {
// node = focus.parent;
// let found = node.next_sibling_of(current)
// if some {
// break found;
// }
// // else
// if node == root {
// return first child of root;
// };
// current = parent;
// }
// }
//
// use found next sibling
// loop do {
// if found = view -> focus = found, return
// if found = container -> found = first child
// }
let mut views = self
.traverse()
.skip_while(|&(id, _view)| id != self.focus)