Add line filters for file endpoint (#412)

* Add line filters for file endpoint

* Fix clippy

Author: rsdy

server/bleep/src/indexes/file.rs

@@ -8,7 +8,7 @@ use std::{
     },
 };
 
-use anyhow::{Context, Result};
+use anyhow::Result;
 use async_trait::async_trait;
 use scc::hash_map::Entry;
 use tantivy::{
@@ -266,7 +266,7 @@ impl Indexable for File {
 }
 
 impl Indexer<File> {
-    pub async fn file_body(&self, file_disk_path: &str) -> Result<String> {
+    pub async fn file_body(&self, file_disk_path: &str) -> Result<ContentDocument> {
         // Mostly taken from `by_path`, below.
         //
         // TODO: This can be unified with `by_path` below, but we first need to decide on a unified
@@ -280,26 +280,7 @@ impl Indexer<File> {
             IndexRecordOption::Basic,
         );
 
-        let collector = TopDocs::with_limit(1);
-        let search_results = searcher
-            .search(&query, &collector)
-            .context("failed to search index")?;
-
-        match search_results.as_slice() {
-            [] => Err(anyhow::Error::msg("no path found")),
-            [(_, doc_addr)] => Ok(searcher
-                .doc(*doc_addr)
-                .context("failed to get document by address")?
-                .get_first(self.source.content)
-                .context("content field was missing")?
-                .as_text()
-                .context("content field did not contain text")?
-                .to_owned()),
-            _ => {
-                warn!("TopDocs is not limited to 1 and index contains duplicates");
-                Err(anyhow::Error::msg("multiple paths returned"))
-            }
-        }
+        self.top_hit(Box::new(query), searcher).await
     }
 
     pub async fn by_path(
@@ -311,7 +292,6 @@ impl Indexer<File> {
         let searcher = reader.searcher();
 
         let file_index = searcher.index();
-        let file_source = &self.source;
 
         // query the `relative_path` field of the `File` index, using tantivy's query language
         //
@@ -326,6 +306,16 @@ impl Indexer<File> {
             ))
             .expect("failed to parse tantivy query");
 
+        self.top_hit(query, searcher).await
+    }
+
+    async fn top_hit(
+        &self,
+        query: Box<dyn tantivy::query::Query>,
+        searcher: tantivy::Searcher,
+    ) -> Result<ContentDocument> {
+        let file_source = &self.source;
+
         let collector = TopDocs::with_limit(1);
         let search_results = searcher
             .search(&query, &collector)

server/bleep/src/webserver/file.rs

@@ -2,41 +2,148 @@ use std::sync::Arc;
 
 use axum::{
     extract::{Path, Query},
-    response::IntoResponse,
-    Extension,
+    Extension, Json,
 };
 
 use super::prelude::*;
 
-#[derive(Debug, serde::Deserialize)]
-pub struct Params {
-    pub rev: Option<String>,
+#[derive(Debug, serde::Deserialize, Default)]
+pub(super) struct Params {
+    /// 1-indexed line number at which to start the snippet
+    pub line_start: Option<isize>,
+
+    /// 1-indexed line number at which to end the snippet
+    pub line_end: Option<usize>,
 }
 
 #[derive(serde::Serialize)]
-pub struct FileResponse {
+pub(super) struct FileResponse {
     contents: String,
 }
 
 impl super::ApiResponse for FileResponse {}
 
-pub async fn handle(
+pub(super) async fn handle<'a>(
     Path(path): Path<String>,
     Query(params): Query<Params>,
     Extension(indexes): Extension<Arc<Indexes>>,
-) -> impl IntoResponse {
+) -> Result<Json<super::Response<'a>>, Error> {
     // Strip leading slash, always present.
     let file_disk_path = &path[1..];
 
-    if params.rev.is_some() {
-        return Err(Error::internal("the `rev` parameter is not yet supported"));
-    }
-
-    let contents = indexes
+    let doc = indexes
         .file
         .file_body(file_disk_path)
         .await
         .map_err(Error::internal)?;
 
-    Ok(json(FileResponse { contents }))
+    Ok(json(FileResponse {
+        contents: split_by_lines(&doc.content, &doc.line_end_indices, &params)?.to_string(),
+    }))
+}
+
+fn split_by_lines<'a>(text: &'a str, indices: &[u32], params: &Params) -> Result<&'a str, Error> {
+    let char_start = match params.line_start {
+        Some(line_start) if line_start == 1 => 0,
+        Some(line_start) if line_start > 1 => {
+            (indices
+                .get(line_start as usize - 2)
+                .ok_or_else(|| Error::user("invalid line number"))?
+                + 1) as usize
+        }
+        Some(_) => return Err(Error::user("line numbers are 1-indexed!")),
+        _ => 0,
+    };
+
+    let line_end = params.line_end.unwrap_or(indices.len()) - 1;
+    let char_end = *indices
+        .get(line_end)
+        .ok_or_else(|| Error::user("invalid line number"))? as usize;
+
+    Ok(&text[char_start..=char_end])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn no_params() {
+        let text = r#"aaaaaa
+bbbbbb
+cccccc
+"#;
+
+        let indices = text
+            .match_indices('\n')
+            .map(|(i, _)| i as u32)
+            .collect::<Vec<_>>();
+
+        println!("{indices:?}");
+
+        assert_eq!(
+            split_by_lines(
+                text,
+                &indices,
+                &Params {
+                    line_start: None,
+                    line_end: None
+                }
+            )
+            .unwrap_or_else(|_| panic!("bad")),
+            text
+        );
+
+        assert_eq!(
+            split_by_lines(
+                text,
+                &indices,
+                &Params {
+                    line_start: Some(1),
+                    line_end: None
+                }
+            )
+            .unwrap_or_else(|_| panic!("bad")),
+            text
+        );
+
+        assert_eq!(
+            split_by_lines(
+                text,
+                &indices,
+                &Params {
+                    line_start: Some(2),
+                    line_end: None
+                }
+            )
+            .unwrap_or_else(|_| panic!("bad")),
+            &text[7..]
+        );
+
+        assert_eq!(
+            split_by_lines(
+                text,
+                &indices,
+                &Params {
+                    line_start: Some(3),
+                    line_end: Some(3),
+                }
+            )
+            .unwrap_or_else(|_| panic!("bad")),
+            &text[14..]
+        );
+
+        assert_eq!(
+            split_by_lines(
+                text,
+                &indices,
+                &Params {
+                    line_start: Some(2),
+                    line_end: Some(3),
+                }
+            )
+            .unwrap_or_else(|_| panic!("bad")),
+            &text[7..]
+        );
+    }
 }