owl-ms-language-server 0.7.0

An incremental analysis assistant for writing ontologies with the OWL Manchester Syntax
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

use log::error;
use parking_lot::RwLock;
use std::{borrow::Cow, io, path::PathBuf, time::Duration};
use thiserror::Error;
use tower_lsp::lsp_types::Url;

use crate::pos::Position;

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Error, Debug)]
pub enum Error {
    #[error("The provided document can not be found {0}")]
    DocumentNotFound(Url),
    #[error("The provided document type is not supported extention: {0}")]
    DocumentNotSupported(String),
    #[error("The provided document was empty: {0}")]
    DocumentEmpty(Url),
    #[error("The provided file path is not a URL {0}")]
    InvalidFilePath(PathBuf),
    #[error("The workspace of the document was not found {0}")]
    WorkspaceNotFound(Url),
    #[error("The lock could not be aquired for {0} sec")]
    LockTimeout(u64),
    #[error("The provided URL is not valid for this LSP {0}")]
    InvalidUrl(Url),
    #[error("The position is not inside the bounds {0}")]
    PositionOutOfBounds(Position),
    #[error("The tower lsp position is not inside the bounds {0:?}")]
    PositionOutOfBoundsTowerLsp(tower_lsp::lsp_types::Position),
    #[error("The LSP Feature is not supported at the moment: {0}")]
    LspFeatureNotSupported(&'static str),
    // From other error types
    #[error("Ureq Error: {0}")]
    Ureq(#[from] ureq::Error),
    #[error("Horned Owl Error: {0}")]
    HornedOwl(#[from] horned_owl::error::HornedError),
    #[error("IO Error: {0}")]
    Io(#[from] io::Error),
    #[error("Tokio Join Error: {0}")]
    TokioJoin(#[from] tokio::task::JoinError),
    #[error("Rope Error: {0}")]
    Rope(#[from] ropey::Error),
    #[error("Sophia Error: {0}")]
    Sophia(String), // I could not crate a streaming error type, because one of the generics is not importable, because of a foreign crate
}

impl From<Error> for tower_lsp::jsonrpc::Error {
    fn from(value: Error) -> Self {
        match value {
            Error::DocumentNotFound(url) => {
                Self::invalid_params(format!("The provided document can not be found {url}"))
            }
            _ => Self {
                code: 0.into(),
                message: Cow::from(format!("{value}")),
                data: None,
            },
        }
    }
}

pub trait ResultExt<T> {
    /// Consumes and logs the result if it contains error
    fn log_if_error(self);
    /// Inspects the Result and logs an Error if needed
    fn inspect_log(self) -> Self;
}

impl<T> ResultExt<T> for Result<T> {
    fn log_if_error(self) {
        let _ = self.inspect_log();
    }

    fn inspect_log(self) -> Self {
        self.inspect_err(|e| error!("{e}"))
    }
}

pub trait ResultIterator<T> {
    /// Filters out Errors and logs them
    fn filter_and_log(self) -> impl Iterator<Item = T>;
}

impl<T, I: Iterator<Item = Result<T>>> ResultIterator<T> for I {
    fn filter_and_log(self) -> impl Iterator<Item = T> {
        self.filter_map(|r| r.inspect_log().ok())
    }
}

pub trait RwLockExt<T> {
    fn read_timeout(
        &'_ self,
    ) -> Result<parking_lot::lock_api::RwLockReadGuard<'_, parking_lot::RawRwLock, T>>;
}

impl<T> RwLockExt<T> for RwLock<T> {
    fn read_timeout(
        &'_ self,
    ) -> Result<parking_lot::lock_api::RwLockReadGuard<'_, parking_lot::RawRwLock, T>> {
        self.try_read_recursive_for(Duration::from_secs(5))
            .ok_or(Error::LockTimeout(5))
    }
}