59b5bf3 · helix · git.iko.soy

1−use anyhow::{anyhow, Context, Error};

1+use anyhow::{anyhow, bail, Context, Error};

2use serde::de::{self, Deserialize, Deserializer};

3use serde::Serialize;

4use std::cell::Cell;

11

12use helix_core::{

13 encoding,

14− history::History,

14+ history::{History, UndoKind},

15 indent::{auto_detect_indent_style, IndentStyle},

16 line_ending::auto_detect_line_ending,

17 syntax::{self, LanguageConfiguration},

54 "normal" => Ok(Mode::Normal),

55 "select" => Ok(Mode::Select),

56 "insert" => Ok(Mode::Insert),

57− _ => Err(anyhow!("Invalid mode '{}'", s)),

57+ _ => bail!("Invalid mode '{}'", s),

58 }

59 }

60}

396 /// The same as [`format`], but only returns formatting changes if auto-formatting

397 /// is configured.

398 pub fn auto_format(&self) -> Option<impl Future<Output = LspFormatting> + 'static> {

399− if self.language_config().map(|c| c.auto_format) == Some(true) {

399+ if self.language_config()?.auto_format {

400 self.format()

401 } else {

402 None

406 /// If supported, returns the changes that should be applied to this document in order

407 /// to format it nicely.

408 pub fn format(&self) -> Option<impl Future<Output = LspFormatting> + 'static> {

409− if let Some(language_server) = self.language_server() {

409+ let language_server = self.language_server()?;

410− let text = self.text.clone();

410+ let text = self.text.clone();

411− let offset_encoding = language_server.offset_encoding();

411+ let offset_encoding = language_server.offset_encoding();

412− let request = language_server.text_document_formatting(

412+ let request = language_server.text_document_formatting(

413− self.identifier(),

413+ self.identifier(),

414− lsp::FormattingOptions::default(),

414+ lsp::FormattingOptions::default(),

415− None,

415+ None,

416− )?;

416+ )?;

417−

417+

418− let fut = async move {

418+ let fut = async move {

419− let edits = request.await.unwrap_or_else(|e| {

419+ let edits = request.await.unwrap_or_else(|e| {

420− log::warn!("LSP formatting failed: {}", e);

420+ log::warn!("LSP formatting failed: {}", e);

421− Default::default()

421+ Default::default()

422− });

422+ });

423− LspFormatting {

423+ LspFormatting {

424− doc: text,

424+ doc: text,

425− edits,

425+ edits,

426− offset_encoding,

426+ offset_encoding,

427− }

427+ }

428− };

428+ };

429− Some(fut)

429+ Some(fut)

430− } else {

431− None

432− }

433 }

430 }

434

431

435 pub fn save(&mut self) -> impl Future<Output = Result<(), anyhow::Error>> {

432 pub fn save(&mut self) -> impl Future<Output = Result<(), anyhow::Error>> {

473 if let Some(parent) = path.parent() {

470 if let Some(parent) = path.parent() {

474 // TODO: display a prompt asking the user if the directories should be created

471 // TODO: display a prompt asking the user if the directories should be created

475 if !parent.exists() {

472 if !parent.exists() {

476− return Err(Error::msg(

477− "can't save file, parent directory does not exist",

473+ bail!("can't save file, parent directory does not exist");

478− ));

479 }

474 }

480 }

475 }

481

476

522 /// line ending.

517 /// line ending.

523 pub fn detect_indent_and_line_ending(&mut self) {

518 pub fn detect_indent_and_line_ending(&mut self) {

524 self.indent_style = auto_detect_indent_style(&self.text).unwrap_or_else(|| {

519 self.indent_style = auto_detect_indent_style(&self.text).unwrap_or_else(|| {

525− self.language

520+ self.language_config()

526− .as_ref()

527 .and_then(|config| config.indent.as_ref())

521 .and_then(|config| config.indent.as_ref())

528 .map_or(DEFAULT_INDENT, |config| IndentStyle::from_str(&config.unit))

522 .map_or(DEFAULT_INDENT, |config| IndentStyle::from_str(&config.unit))

529 });

523 });

537

531

538 // If there is no path or the path no longer exists.

532 // If there is no path or the path no longer exists.

539 if path.is_none() {

533 if path.is_none() {

540− return Err(anyhow!("can't find file to reload from"));

534+ bail!("can't find file to reload from");

541 }

535 }

542

536

543 let mut file = std::fs::File::open(path.unwrap())?;

537 let mut file = std::fs::File::open(path.unwrap())?;

558

552

559 /// Sets the [`Document`]'s encoding with the encoding correspondent to `label`.

553 /// Sets the [`Document`]'s encoding with the encoding correspondent to `label`.

560 pub fn set_encoding(&mut self, label: &str) -> Result<(), Error> {

554 pub fn set_encoding(&mut self, label: &str) -> Result<(), Error> {

561− match encoding::Encoding::for_label(label.as_bytes()) {

555+ self.encoding = encoding::Encoding::for_label(label.as_bytes())

562− Some(encoding) => self.encoding = encoding,

563− None => return Err(anyhow::anyhow!("unknown encoding")),

556+ .ok_or_else(|| anyhow!("unknown encoding"))?;

564− }

565 Ok(())

557 Ok(())

566 }

558 }

567

559

646 );

638 );

647 }

639 }

648

640

649− // set modified since accessed

650 self.modified_since_accessed = true;

641 self.modified_since_accessed = true;

651 }

642 }

652

643

689

680

690 if let Some(notify) = notify {

681 if let Some(notify) = notify {

691 tokio::spawn(notify);

682 tokio::spawn(notify);

692− } //.expect("failed to emit textDocument/didChange");

683+ }

693 }

684 }

694 }

685 }

695 success

686 success

717 success

708 success

718 }

709 }

719

710

720− /// Undo the last modification to the [`Document`]. Returns whether the undo was successful.

721− pub fn undo(&mut self, view_id: ViewId) -> bool {

711+ fn undo_redo_impl(&mut self, view_id: ViewId, undo: bool) -> bool {

722 let mut history = self.history.take();

712 let mut history = self.history.take();

713+ let txn = if undo { history.undo() } else { history.redo() };

723− let success = if let Some(transaction) = history.undo() {

714+ let success = if let Some(txn) = txn {

724− self.apply_impl(transaction, view_id)

715+ self.apply_impl(txn, view_id)

725 } else {

716 } else {

726 false

717 false

727 };

718 };

734 success

725 success

735 }

726 }

736

727

728+ /// Undo the last modification to the [`Document`]. Returns whether the undo was successful.

729+ pub fn undo(&mut self, view_id: ViewId) -> bool {

730+ self.undo_redo_impl(view_id, true)

731+ }

732+

737 /// Redo the last modification to the [`Document`]. Returns whether the redo was sucessful.

733 /// Redo the last modification to the [`Document`]. Returns whether the redo was sucessful.

738 pub fn redo(&mut self, view_id: ViewId) -> bool {

734 pub fn redo(&mut self, view_id: ViewId) -> bool {

739− let mut history = self.history.take();

735+ self.undo_redo_impl(view_id, false)

740− let success = if let Some(transaction) = history.redo() {

741− self.apply_impl(transaction, view_id)

742− } else {

743− false

744− };

745− self.history.set(history);

746−

747− if success {

748− // reset changeset to fix len

749− self.changes = ChangeSet::new(self.text());

750− }

751− success

752 }

736 }

753

737

754 pub fn savepoint(&mut self) {

738 pub fn savepoint(&mut self) {

761 }

745 }

762 }

746 }

763

747

764− /// Undo modifications to the [`Document`] according to `uk`.

765− pub fn earlier(&mut self, view_id: ViewId, uk: helix_core::history::UndoKind) -> bool {

748+ fn earlier_later_impl(&mut self, view_id: ViewId, uk: UndoKind, earlier: bool) -> bool {

749+ let txns = if earlier {

766− let txns = self.history.get_mut().earlier(uk);

750+ self.history.get_mut().earlier(uk)

751+ } else {

752+ self.history.get_mut().later(uk)

753+ };

767 let mut success = false;

754 let mut success = false;

768 for txn in txns {

755 for txn in txns {

769 if self.apply_impl(&txn, view_id) {

756 if self.apply_impl(&txn, view_id) {

777 success

764 success

778 }

765 }

779

766

767+ /// Undo modifications to the [`Document`] according to `uk`.

768+ pub fn earlier(&mut self, view_id: ViewId, uk: UndoKind) -> bool {

769+ self.earlier_later_impl(view_id, uk, true)

770+ }

771+

780 /// Redo modifications to the [`Document`] according to `uk`.

772 /// Redo modifications to the [`Document`] according to `uk`.

781− pub fn later(&mut self, view_id: ViewId, uk: helix_core::history::UndoKind) -> bool {

773+ pub fn later(&mut self, view_id: ViewId, uk: UndoKind) -> bool {

782− let txns = self.history.get_mut().later(uk);

774+ self.earlier_later_impl(view_id, uk, false)

783− let mut success = false;

784− for txn in txns {

785− if self.apply_impl(&txn, view_id) {

786− success = true;

787− }

788− }

789− if success {

790− // reset changeset to fix len

791− self.changes = ChangeSet::new(self.text());

792− }

793− success

794 }

775 }

795

776

796 /// Commit pending changes to history

777 /// Commit pending changes to history

850 /// `language-server` configuration, or the document language if no

831 /// `language-server` configuration, or the document language if no

851 /// `language-id` has been specified.

832 /// `language-id` has been specified.

852 pub fn language_id(&self) -> Option<&str> {

833 pub fn language_id(&self) -> Option<&str> {

853− self.language

834+ self.language_config()

854− .as_ref()

855 .and_then(|config| config.language_server.as_ref())

835 .and_then(|config| config.language_server.as_ref())

856− .and_then(|lsp_config| lsp_config.language_id.as_ref())

836+ .and_then(|lsp_config| lsp_config.language_id.as_deref())

857− .map_or_else(

858− || {

859− self.language()

837+ .or_else(|| Some(self.language()?.rsplit_once('.')?.1))

860− .and_then(|s| s.rsplit_once('.'))

861− .map(|(_, language_id)| language_id)

862− },

863− |language_id| Some(language_id.as_str()),

864− )

865 }

838 }

866

839

867 /// Corresponding [`LanguageConfiguration`].

840 /// Corresponding [`LanguageConfiguration`].

874 self.version

847 self.version

875 }

848 }

876

849

850+ /// Language server if it has been initialized.

877 pub fn language_server(&self) -> Option<&helix_lsp::Client> {

851 pub fn language_server(&self) -> Option<&helix_lsp::Client> {

878− let server = self.language_server.as_deref();

852+ let server = self.language_server.as_deref()?;

879− let initialized = server

880− .map(|server| server.is_initialized())

853+ server.is_initialized().then(|| server)

881− .unwrap_or(false);

882−

883− // only resolve language_server if it's initialized

884− if initialized {

885− server

886− } else {

887− None

888− }

889 }

854 }

890

855

891 #[inline]

856 #[inline]

896

861

897 /// Tab size in columns.

862 /// Tab size in columns.

898 pub fn tab_width(&self) -> usize {

863 pub fn tab_width(&self) -> usize {

899− self.language

864+ self.language_config()

900− .as_ref()

901 .and_then(|config| config.indent.as_ref())

865 .and_then(|config| config.indent.as_ref())

902 .map_or(4, |config| config.tab_width) // fallback to 4 columns

866 .map_or(4, |config| config.tab_width) // fallback to 4 columns

903 }

867 }

922

886

923 /// File path as a URL.

887 /// File path as a URL.

924 pub fn url(&self) -> Option<Url> {

888 pub fn url(&self) -> Option<Url> {

925− self.path().map(|path| Url::from_file_path(path).unwrap())

889+ Url::from_file_path(self.path()?).ok()

926 }

890 }

927

891

928 #[inline]

892 #[inline]

945 .map(helix_core::path::get_relative_path)

909 .map(helix_core::path::get_relative_path)

946 }

910 }

947

911

948− // pub fn slice<R>(&self, range: R) -> RopeSlice where R: RangeBounds {

949− // self.state.doc.slice

950− // }

951−

952 // transact(Fn) ?

912 // transact(Fn) ?

953

913

954 // -- LSP methods

914 // -- LSP methods

969

929

970 pub fn set_diagnostics(&mut self, diagnostics: Vec<Diagnostic>) {

930 pub fn set_diagnostics(&mut self, diagnostics: Vec<Diagnostic>) {

971 self.diagnostics = diagnostics;

931 self.diagnostics = diagnostics;

972− // sort by range

973 self.diagnostics

932 self.diagnostics

974 .sort_unstable_by_key(|diagnostic| diagnostic.range);

933 .sort_unstable_by_key(|diagnostic| diagnostic.range);

975 }

934 }