use jsonx_lib::Value;
use crate::{
json::{req_object, req_str, req_u32, to_value, write_u64},
response::ResponseError,
};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Position {
pub line: u32,
pub character: u32,
}
impl Position {
#[inline]
#[must_use]
pub const fn new(line: u32, character: u32) -> Self {
Self { line, character }
}
#[must_use]
pub fn to_json(&self) -> Value<'static> {
let mut out = String::new();
self.write(&mut out);
to_value(&out)
}
pub fn from_json(value: &Value<'_>) -> Result<Self, ResponseError> {
if !matches!(value, Value::Object(_)) {
return Err(ResponseError::invalid_params(format!(
"invalid params: a position must be an object, not {}",
value.kind()
)));
}
Ok(Self {
line: req_u32(value, "line")?,
character: req_u32(value, "character")?,
})
}
pub(crate) fn write(&self, out: &mut String) {
out.push_str("{\"line\":");
write_u64(out, u64::from(self.line));
out.push_str(",\"character\":");
write_u64(out, u64::from(self.character));
out.push('}');
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Range {
pub start: Position,
pub end: Position,
}
impl Range {
#[inline]
#[must_use]
pub const fn new(start: Position, end: Position) -> Self {
Self { start, end }
}
#[must_use]
pub fn to_json(&self) -> Value<'static> {
let mut out = String::new();
self.write(&mut out);
to_value(&out)
}
pub fn from_json(value: &Value<'_>) -> Result<Self, ResponseError> {
if !matches!(value, Value::Object(_)) {
return Err(ResponseError::invalid_params(format!(
"invalid params: a range must be an object, not {}",
value.kind()
)));
}
Ok(Self {
start: Position::from_json(req_object(value, "start")?)?,
end: Position::from_json(req_object(value, "end")?)?,
})
}
pub(crate) fn write(&self, out: &mut String) {
out.push_str("{\"start\":");
self.start.write(out);
out.push_str(",\"end\":");
self.end.write(out);
out.push('}');
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Encoding {
Utf8,
#[default]
Utf16,
}
impl Encoding {
#[inline]
pub(crate) const fn as_str(self) -> &'static str {
match self {
Encoding::Utf8 => "utf-8",
Encoding::Utf16 => "utf-16",
}
}
pub(crate) fn negotiate<'a>(offered: impl IntoIterator<Item = &'a str>) -> Self {
if offered.into_iter().any(|name| name == "utf-8") {
Encoding::Utf8
} else {
Encoding::Utf16
}
}
}
pub(crate) fn document_position(params: &Value<'_>) -> Result<(String, Position), ResponseError> {
let uri = req_str(req_object(params, "textDocument")?, "uri")?.to_owned();
let position = Position::from_json(req_object(params, "position")?)?;
Ok((uri, position))
}
pub(crate) fn document_uri(params: &Value<'_>) -> Result<String, ResponseError> {
Ok(req_str(req_object(params, "textDocument")?, "uri")?.to_owned())
}
#[cfg(test)]
mod tests {
use jsonx_lib::json;
use super::*;
#[test]
fn test_encoding_negotiate_prefers_utf8() {
assert_eq!(Encoding::negotiate(["utf-16", "utf-8"]), Encoding::Utf8);
assert_eq!(Encoding::negotiate(["utf-32", "utf-16"]), Encoding::Utf16);
assert_eq!(Encoding::negotiate([]), Encoding::Utf16);
}
#[test]
fn test_encoding_as_str_matches_protocol_names() {
assert_eq!(Encoding::Utf8.as_str(), "utf-8");
assert_eq!(Encoding::Utf16.as_str(), "utf-16");
}
#[test]
fn test_position_orders_by_line_then_column() {
assert!(Position::new(0, 9) < Position::new(1, 0));
assert!(Position::new(1, 1) < Position::new(1, 2));
}
#[test]
fn test_position_and_range_round_trip_through_json() {
let range = Range::new(Position::new(0, u32::MAX), Position::new(u32::MAX, 0));
assert_eq!(Range::from_json(&range.to_json()).ok(), Some(range));
}
#[test]
fn test_position_from_json_rejects_wrong_shapes() {
for bad in [
json!(null),
json!([1, 2]),
json!({ "line": 1 }),
json!({ "line": 1, "character": "2" }),
json!({ "line": 1.5, "character": 2 }),
json!({ "line": 4294967296_u64, "character": 2 }),
] {
let err = Position::from_json(&bad).err();
assert_eq!(
err.map(|e| e.code()),
Some(ResponseError::INVALID_PARAMS),
"{bad}"
);
}
assert!(Range::from_json(&json!({ "start": {} })).is_err());
assert!(Range::from_json(&json!(5)).is_err());
}
#[test]
fn test_document_position_reads_the_request_shape() {
let params = json!({ "textDocument": { "uri": "file:///a" }, "position": { "line": 1, "character": 2 } });
assert_eq!(
document_position(¶ms).ok(),
Some(("file:///a".to_owned(), Position::new(1, 2)))
);
assert!(document_position(&json!({ "position": {} })).is_err());
assert_eq!(document_uri(¶ms).ok().as_deref(), Some("file:///a"));
}
}