Merge branch 'indexer-edition-2024' into indexer-edition-2024-doc-chunks

crates/milli/src/prompt/context.rs

@@ -0,0 +1,93 @@
+use liquid::model::{
+    ArrayView, DisplayCow, KStringCow, ObjectRender, ObjectSource, State, Value as LiquidValue,
+};
+use liquid::{ObjectView, ValueView};
+
+#[derive(Debug, Clone)]
+pub struct Context<'a, D: ObjectView, F: ArrayView> {
+    document: &'a D,
+    fields: &'a F,
+}
+
+impl<'a, D: ObjectView, F: ArrayView> Context<'a, D, F> {
+    pub fn new(document: &'a D, fields: &'a F) -> Self {
+        Self { document, fields }
+    }
+}
+
+impl<'a, D: ObjectView, F: ArrayView> ObjectView for Context<'a, D, F> {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        2
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        Box::new(["doc", "fields"].iter().map(|s| KStringCow::from_static(s)))
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(
+            std::iter::once(self.document.as_value())
+                .chain(std::iter::once(self.fields.as_value())),
+        )
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(self.keys().zip(self.values()))
+    }
+
+    fn contains_key(&self, index: &str) -> bool {
+        index == "doc" || index == "fields"
+    }
+
+    fn get<'s>(&'s self, index: &str) -> Option<&'s dyn ValueView> {
+        match index {
+            "doc" => Some(self.document.as_value()),
+            "fields" => Some(self.fields.as_value()),
+            _ => None,
+        }
+    }
+}
+
+impl<'a, D: ObjectView, F: ArrayView> ValueView for Context<'a, D, F> {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectRender::new(self)))
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectSource::new(self)))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => false,
+        }
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        let s = ObjectRender::new(self).to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Object(
+            self.iter().map(|(k, x)| (k.to_string().into(), x.to_value())).collect(),
+        )
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+}

crates/milli/src/prompt/document.rs

@@ -0,0 +1,647 @@
+use std::cell::OnceCell;
+use std::collections::BTreeMap;
+use std::fmt::{self, Debug};
+
+use bumpalo::Bump;
+use liquid::model::{
+    ArrayView, DisplayCow, KString, KStringCow, ObjectRender, ObjectSource, ScalarCow, State,
+    Value as LiquidValue,
+};
+use liquid::{ObjectView, ValueView};
+use raw_collections::{RawMap, RawVec};
+use serde_json::value::RawValue;
+
+use crate::update::del_add::{DelAdd, KvReaderDelAdd};
+use crate::FieldsIdsMap;
+
+#[derive(Debug, Clone)]
+pub struct Document<'a>(BTreeMap<&'a str, (&'a [u8], ParsedValue)>);
+
+#[derive(Debug, Clone)]
+struct ParsedValue(std::cell::OnceCell<LiquidValue>);
+
+impl ParsedValue {
+    fn empty() -> ParsedValue {
+        ParsedValue(OnceCell::new())
+    }
+
+    fn get(&self, raw: &[u8]) -> &LiquidValue {
+        self.0.get_or_init(|| {
+            let value: serde_json::Value = serde_json::from_slice(raw).unwrap();
+            liquid::model::to_value(&value).unwrap()
+        })
+    }
+}
+
+impl<'a> Document<'a> {
+    pub fn new(
+        data: &'a obkv::KvReaderU16,
+        side: DelAdd,
+        inverted_field_map: &'a FieldsIdsMap,
+    ) -> Self {
+        let mut out_data = BTreeMap::new();
+        for (fid, raw) in data {
+            let obkv = KvReaderDelAdd::from_slice(raw);
+            let Some(raw) = obkv.get(side) else {
+                continue;
+            };
+            let Some(name) = inverted_field_map.name(fid) else {
+                continue;
+            };
+            out_data.insert(name, (raw, ParsedValue::empty()));
+        }
+        Self(out_data)
+    }
+
+    fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn iter(&self) -> impl Iterator<Item = (KString, LiquidValue)> + '_ {
+        self.0.iter().map(|(&k, (raw, data))| (k.to_owned().into(), data.get(raw).to_owned()))
+    }
+}
+
+impl<'a> ObjectView for Document<'a> {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        self.len() as i64
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        let keys = BTreeMap::keys(&self.0).map(|&s| s.into());
+        Box::new(keys)
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(self.0.values().map(|(raw, v)| v.get(raw) as &dyn ValueView))
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(self.0.iter().map(|(&k, (raw, data))| (k.into(), data.get(raw) as &dyn ValueView)))
+    }
+
+    fn contains_key(&self, index: &str) -> bool {
+        self.0.contains_key(index)
+    }
+
+    fn get<'s>(&'s self, index: &str) -> Option<&'s dyn ValueView> {
+        self.0.get(index).map(|(raw, v)| v.get(raw) as &dyn ValueView)
+    }
+}
+
+impl<'a> ValueView for Document<'a> {
+    fn as_debug(&self) -> &dyn Debug {
+        self
+    }
+
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectRender::new(self)))
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectSource::new(self)))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => self.is_empty(),
+        }
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        let s = ObjectRender::new(self).to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Object(self.iter().collect())
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+
+    fn is_object(&self) -> bool {
+        true
+    }
+}
+
+/// Implementation for any type that implements the Document trait
+use crate::update::new::document::Document as DocumentTrait;
+
+#[derive(Debug)]
+pub struct ParseableDocument<'doc, D> {
+    document: D,
+    doc_alloc: &'doc Bump,
+}
+
+impl<'doc, D> ParseableDocument<'doc, D> {
+    pub fn new(document: D, doc_alloc: &'doc Bump) -> Self {
+        Self { document, doc_alloc }
+    }
+}
+
+impl<'doc, D: DocumentTrait<'doc> + Debug> ObjectView for ParseableDocument<'doc, D> {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        self.document.len() as i64
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        Box::new(self.document.iter_top_level_fields().map(|res| {
+            let (field, _) = res.unwrap();
+            KStringCow::from_ref(field)
+        }))
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(self.document.iter_top_level_fields().map(|res| {
+            let (_, value) = res.unwrap();
+            ParseableValue::new_bump(value, self.doc_alloc) as _
+        }))
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(self.document.iter_top_level_fields().map(|res| {
+            let (field, value) = res.unwrap();
+            (KStringCow::from_ref(field), ParseableValue::new_bump(value, self.doc_alloc) as _)
+        }))
+    }
+
+    fn contains_key(&self, index: &str) -> bool {
+        self.document.top_level_field(index).unwrap().is_some()
+    }
+
+    fn get<'s>(&'s self, index: &str) -> Option<&'s dyn ValueView> {
+        let s = self.document.top_level_field(index).unwrap()?;
+        Some(ParseableValue::new_bump(s, self.doc_alloc))
+    }
+}
+
+impl<'doc, D: DocumentTrait<'doc> + Debug> ValueView for ParseableDocument<'doc, D> {
+    fn as_debug(&self) -> &dyn fmt::Debug {
+        self
+    }
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectRender::new(self)))
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectSource::new(self)))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => false,
+        }
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        let s = ObjectRender::new(self).to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Object(
+            self.document
+                .iter_top_level_fields()
+                .map(|res| {
+                    let (k, v) = res.unwrap();
+                    (k.to_string().into(), ParseableValue::new(v, self.doc_alloc).to_value())
+                })
+                .collect(),
+        )
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+
+    fn is_object(&self) -> bool {
+        true
+    }
+}
+
+#[derive(Debug)]
+struct ParseableValue<'doc> {
+    value: raw_collections::Value<'doc>,
+}
+
+impl<'doc> ParseableValue<'doc> {
+    pub fn new(value: &'doc RawValue, doc_alloc: &'doc Bump) -> Self {
+        let value = raw_collections::Value::from_raw_value(value, doc_alloc).unwrap();
+        Self { value }
+    }
+
+    pub fn new_bump(value: &'doc RawValue, doc_alloc: &'doc Bump) -> &'doc Self {
+        doc_alloc.alloc(Self::new(value, doc_alloc))
+    }
+}
+
+// transparent newtype for implementing ValueView
+#[repr(transparent)]
+#[derive(Debug)]
+struct ParseableMap<'doc>(RawMap<'doc>);
+
+// transparent newtype for implementing ValueView
+#[repr(transparent)]
+#[derive(Debug)]
+struct ParseableArray<'doc>(RawVec<'doc>);
+
+impl<'doc> ParseableMap<'doc> {
+    pub fn as_parseable<'a>(map: &'a RawMap<'doc>) -> &'a ParseableMap<'doc> {
+        // SAFETY: repr(transparent)
+        unsafe { &*(map as *const RawMap as *const Self) }
+    }
+}
+
+impl<'doc> ParseableArray<'doc> {
+    pub fn as_parseable<'a>(array: &'a RawVec<'doc>) -> &'a ParseableArray<'doc> {
+        // SAFETY: repr(transparent)
+        unsafe { &*(array as *const RawVec as *const Self) }
+    }
+}
+
+impl<'doc> ArrayView for ParseableArray<'doc> {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        self.0.len() as _
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(self.0.iter().map(|v| ParseableValue::new_bump(v, self.0.bump()) as _))
+    }
+
+    fn contains_key(&self, index: i64) -> bool {
+        let index = convert_index(index, self.size());
+        index < self.size() && index >= 0
+    }
+
+    fn get(&self, index: i64) -> Option<&dyn ValueView> {
+        let index = convert_index(index, self.size());
+        if index <= 0 {
+            return None;
+        }
+        let v = self.0.get(index as usize)?;
+        Some(ParseableValue::new_bump(v, self.0.bump()))
+    }
+}
+
+impl<'doc> ValueView for ParseableArray<'doc> {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ArrayRender { s: &self.0 }))
+    }
+
+    fn source(&self) -> DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ArraySource { s: &self.0 }))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "array"
+    }
+
+    fn query_state(&self, state: State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => self.0.is_empty(),
+        }
+    }
+
+    fn to_kstr(&self) -> KStringCow<'_> {
+        let s = ArrayRender { s: &self.0 }.to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Array(self.values().map(|v| v.to_value()).collect())
+    }
+
+    fn is_array(&self) -> bool {
+        true
+    }
+
+    fn as_array(&self) -> Option<&dyn ArrayView> {
+        Some(self as _)
+    }
+}
+
+impl<'doc> ObjectView for ParseableMap<'doc> {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        self.0.len() as i64
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        Box::new(self.0.keys().map(Into::into))
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(self.0.values().map(|value| {
+            let doc_alloc = self.0.bump();
+            ParseableValue::new_bump(value, doc_alloc) as _
+        }))
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(self.0.iter().map(|(k, v)| {
+            let doc_alloc = self.0.bump();
+            (k.into(), ParseableValue::new_bump(v, doc_alloc) as _)
+        }))
+    }
+
+    fn contains_key(&self, index: &str) -> bool {
+        self.0.get(index).is_some()
+    }
+
+    fn get<'s>(&'s self, index: &str) -> Option<&'s dyn ValueView> {
+        let v = self.0.get(index)?;
+        let doc_alloc = self.0.bump();
+        let value = ParseableValue::new(v, doc_alloc);
+        Some(doc_alloc.alloc(value) as _)
+    }
+}
+
+impl<'doc> ValueView for ParseableMap<'doc> {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectRender::new(self)))
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectSource::new(self)))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => self.0.is_empty(),
+        }
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        let s = ObjectRender::new(self).to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Object(
+            self.0
+                .iter()
+                .map(|(k, v)| {
+                    (k.to_string().into(), ParseableValue::new(v, self.0.bump()).to_value())
+                })
+                .collect(),
+        )
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+
+    fn is_object(&self) -> bool {
+        true
+    }
+}
+
+impl<'doc> ValueView for ParseableValue<'doc> {
+    fn as_debug(&self) -> &dyn Debug {
+        self
+    }
+
+    fn render(&self) -> DisplayCow<'_> {
+        use raw_collections::value::Number;
+        use raw_collections::Value;
+        match &self.value {
+            Value::Null => LiquidValue::Nil.render(),
+            Value::Bool(v) => v.render(),
+            Value::Number(number) => match number {
+                Number::PosInt(x) => DisplayCow::Borrowed(x),
+                Number::NegInt(x) => x.render(),
+                Number::Finite(x) => x.render(),
+            },
+            Value::String(s) => s.render(),
+            Value::Array(raw_vec) => ParseableArray::as_parseable(raw_vec).render(),
+            Value::Object(raw_map) => ParseableMap::as_parseable(raw_map).render(),
+        }
+    }
+
+    fn source(&self) -> DisplayCow<'_> {
+        use raw_collections::value::Number;
+        use raw_collections::Value;
+        match &self.value {
+            Value::Null => LiquidValue::Nil.source(),
+            Value::Bool(v) => ValueView::source(v),
+            Value::Number(number) => match number {
+                Number::PosInt(x) => DisplayCow::Borrowed(x),
+                Number::NegInt(x) => x.source(),
+                Number::Finite(x) => x.source(),
+            },
+            Value::String(s) => s.source(),
+            Value::Array(raw_vec) => ParseableArray::as_parseable(raw_vec).source(),
+            Value::Object(raw_map) => ParseableMap::as_parseable(raw_map).source(),
+        }
+    }
+
+    fn type_name(&self) -> &'static str {
+        use raw_collections::value::Number;
+        use raw_collections::Value;
+        match &self.value {
+            Value::Null => LiquidValue::Nil.type_name(),
+            Value::Bool(v) => v.type_name(),
+            Value::Number(number) => match number {
+                Number::PosInt(_x) => "whole positive number",
+                Number::NegInt(x) => x.type_name(),
+                Number::Finite(x) => x.type_name(),
+            },
+            Value::String(s) => s.type_name(),
+            Value::Array(_raw_vec) => "array",
+            Value::Object(_raw_map) => "object",
+        }
+    }
+
+    fn query_state(&self, state: State) -> bool {
+        use raw_collections::Value;
+        match &self.value {
+            Value::Null => ValueView::query_state(&LiquidValue::Nil, state),
+            Value::Bool(v) => ValueView::query_state(v, state),
+            Value::Number(_number) => match state {
+                State::Truthy => true,
+                State::DefaultValue => false,
+                State::Empty => false,
+                State::Blank => false,
+            },
+            Value::String(s) => ValueView::query_state(s, state),
+            Value::Array(raw_vec) => ParseableArray::as_parseable(raw_vec).query_state(state),
+            Value::Object(raw_map) => ParseableMap::as_parseable(raw_map).query_state(state),
+        }
+    }
+
+    fn to_kstr(&self) -> KStringCow<'_> {
+        use raw_collections::Value;
+        match &self.value {
+            Value::Null => ValueView::to_kstr(&LiquidValue::Nil),
+            Value::Bool(v) => ValueView::to_kstr(v),
+            Value::Number(_number) => self.render().to_string().into(),
+            Value::String(s) => KStringCow::from_ref(s),
+            Value::Array(raw_vec) => ParseableArray::as_parseable(raw_vec).to_kstr(),
+            Value::Object(raw_map) => ParseableMap::as_parseable(raw_map).to_kstr(),
+        }
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        use raw_collections::Value;
+        match &self.value {
+            Value::Null => LiquidValue::Nil,
+            Value::Bool(v) => LiquidValue::Scalar(liquid::model::ScalarCow::new(*v)),
+            Value::Number(number) => match number {
+                raw_collections::value::Number::PosInt(number) => {
+                    let number: i64 = match (*number).try_into() {
+                        Ok(number) => number,
+                        Err(_) => {
+                            return LiquidValue::Scalar(ScalarCow::new(self.render().to_string()))
+                        }
+                    };
+                    LiquidValue::Scalar(ScalarCow::new(number))
+                }
+                raw_collections::value::Number::NegInt(number) => {
+                    LiquidValue::Scalar(ScalarCow::new(*number))
+                }
+                raw_collections::value::Number::Finite(number) => {
+                    LiquidValue::Scalar(ScalarCow::new(*number))
+                }
+            },
+            Value::String(s) => LiquidValue::Scalar(liquid::model::ScalarCow::new(s.to_string())),
+            Value::Array(raw_vec) => ParseableArray::as_parseable(raw_vec).to_value(),
+            Value::Object(raw_map) => ParseableMap::as_parseable(raw_map).to_value(),
+        }
+    }
+
+    fn as_scalar(&self) -> Option<liquid::model::ScalarCow<'_>> {
+        use raw_collections::value::Number;
+        use raw_collections::Value;
+        match &self.value {
+            Value::Bool(v) => Some(liquid::model::ScalarCow::new(*v)),
+            Value::Number(number) => match number {
+                Number::PosInt(number) => {
+                    let number: i64 = match (*number).try_into() {
+                        Ok(number) => number,
+                        Err(_) => return Some(ScalarCow::new(self.render().to_string())),
+                    };
+                    Some(ScalarCow::new(number))
+                }
+                Number::NegInt(number) => Some(ScalarCow::new(*number)),
+                Number::Finite(number) => Some(ScalarCow::new(*number)),
+            },
+            Value::String(s) => Some(ScalarCow::new(*s)),
+            _ => None,
+        }
+    }
+
+    fn is_scalar(&self) -> bool {
+        use raw_collections::Value;
+        matches!(&self.value, Value::Bool(_) | Value::Number(_) | Value::String(_))
+    }
+
+    fn as_array(&self) -> Option<&dyn liquid::model::ArrayView> {
+        if let raw_collections::Value::Array(array) = &self.value {
+            return Some(ParseableArray::as_parseable(array) as _);
+        }
+        None
+    }
+
+    fn is_array(&self) -> bool {
+        matches!(&self.value, raw_collections::Value::Array(_))
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        if let raw_collections::Value::Object(object) = &self.value {
+            return Some(ParseableMap::as_parseable(object) as _);
+        }
+        None
+    }
+
+    fn is_object(&self) -> bool {
+        matches!(&self.value, raw_collections::Value::Object(_))
+    }
+
+    fn is_nil(&self) -> bool {
+        matches!(&self.value, raw_collections::Value::Null)
+    }
+}
+
+struct ArraySource<'s, 'doc> {
+    s: &'s RawVec<'doc>,
+}
+
+impl<'s, 'doc> fmt::Display for ArraySource<'s, 'doc> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "[")?;
+        for item in self.s {
+            let v = ParseableValue::new(item, self.s.bump());
+            write!(f, "{}, ", v.render())?;
+        }
+        write!(f, "]")?;
+        Ok(())
+    }
+}
+
+struct ArrayRender<'s, 'doc> {
+    s: &'s RawVec<'doc>,
+}
+
+impl<'s, 'doc> fmt::Display for ArrayRender<'s, 'doc> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for item in self.s {
+            let v = ParseableValue::new(item, self.s.bump());
+
+            write!(f, "{}", v.render())?;
+        }
+        Ok(())
+    }
+}
+
+fn convert_index(index: i64, max_size: i64) -> i64 {
+    if 0 <= index {
+        index
+    } else {
+        max_size + index
+    }
+}

crates/milli/src/prompt/error.rs

@@ -0,0 +1,56 @@
+use crate::error::FaultSource;
+
+#[derive(Debug, thiserror::Error)]
+#[error("{fault}: {kind}")]
+pub struct NewPromptError {
+    pub kind: NewPromptErrorKind,
+    pub fault: FaultSource,
+}
+
+impl From<NewPromptError> for crate::Error {
+    fn from(value: NewPromptError) -> Self {
+        crate::Error::UserError(crate::UserError::InvalidPrompt(value))
+    }
+}
+
+impl NewPromptError {
+    pub(crate) fn cannot_parse_template(inner: liquid::Error) -> NewPromptError {
+        Self { kind: NewPromptErrorKind::CannotParseTemplate(inner), fault: FaultSource::User }
+    }
+
+    pub(crate) fn invalid_fields_in_template(inner: liquid::Error) -> NewPromptError {
+        Self { kind: NewPromptErrorKind::InvalidFieldsInTemplate(inner), fault: FaultSource::User }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum NewPromptErrorKind {
+    #[error("cannot parse template: {0}")]
+    CannotParseTemplate(liquid::Error),
+    #[error("template contains invalid fields: {0}. Only `doc.*`, `fields[i].name`, `fields[i].value` are supported")]
+    InvalidFieldsInTemplate(liquid::Error),
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("{fault}: {kind}")]
+pub struct RenderPromptError {
+    pub kind: RenderPromptErrorKind,
+    pub fault: FaultSource,
+}
+impl RenderPromptError {
+    pub(crate) fn missing_context(inner: liquid::Error) -> RenderPromptError {
+        Self { kind: RenderPromptErrorKind::MissingContext(inner), fault: FaultSource::User }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum RenderPromptErrorKind {
+    #[error("missing field in document: {0}")]
+    MissingContext(liquid::Error),
+}
+
+impl From<RenderPromptError> for crate::Error {
+    fn from(value: RenderPromptError) -> Self {
+        crate::Error::UserError(crate::UserError::MissingDocumentField(value))
+    }
+}

crates/milli/src/prompt/fields.rs

@@ -0,0 +1,318 @@
+use std::cell::RefCell;
+use std::fmt;
+
+use bumpalo::Bump;
+use liquid::model::{
+    ArrayView, DisplayCow, KStringCow, ObjectRender, ObjectSource, State, Value as LiquidValue,
+};
+use liquid::{ObjectView, ValueView};
+
+use super::{FieldMetadata, FieldsIdsMapWithMetadata};
+use crate::GlobalFieldsIdsMap;
+
+#[derive(Debug, Clone, Copy)]
+pub struct FieldValue<'a, D: ObjectView> {
+    name: &'a str,
+    document: &'a D,
+    metadata: FieldMetadata,
+}
+
+impl<'a, D: ObjectView> ValueView for FieldValue<'a, D> {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectRender::new(self)))
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectSource::new(self)))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => self.is_empty(),
+        }
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        let s = ObjectRender::new(self).to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Object(
+            self.iter().map(|(k, v)| (k.to_string().into(), v.to_value())).collect(),
+        )
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+}
+
+impl<'a, D: ObjectView> FieldValue<'a, D> {
+    pub fn name(&self) -> &&'a str {
+        &self.name
+    }
+
+    pub fn value(&self) -> &dyn ValueView {
+        self.document.get(self.name).unwrap_or(&LiquidValue::Nil)
+    }
+
+    pub fn is_searchable(&self) -> &bool {
+        &self.metadata.searchable
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.size() == 0
+    }
+}
+
+impl<'a, D: ObjectView> ObjectView for FieldValue<'a, D> {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        2
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        Box::new(["name", "value", "is_searchable"].iter().map(|&x| KStringCow::from_static(x)))
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(
+            std::iter::once(self.name() as &dyn ValueView)
+                .chain(std::iter::once(self.value()))
+                .chain(std::iter::once(self.is_searchable() as &dyn ValueView)),
+        )
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(self.keys().zip(self.values()))
+    }
+
+    fn contains_key(&self, index: &str) -> bool {
+        index == "name" || index == "value" || index == "is_searchable"
+    }
+
+    fn get<'s>(&'s self, index: &str) -> Option<&'s dyn ValueView> {
+        match index {
+            "name" => Some(self.name()),
+            "value" => Some(self.value()),
+            "is_searchable" => Some(self.is_searchable()),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct OwnedFields<'a, D: ObjectView>(Vec<FieldValue<'a, D>>);
+
+#[derive(Debug)]
+pub struct BorrowedFields<'a, 'map, D: ObjectView> {
+    document: &'a D,
+    field_id_map: &'a RefCell<GlobalFieldsIdsMap<'map>>,
+    doc_alloc: &'a Bump,
+}
+
+impl<'a, D: ObjectView> OwnedFields<'a, D> {
+    pub fn new(document: &'a D, field_id_map: &'a FieldsIdsMapWithMetadata<'a>) -> Self {
+        Self(
+            std::iter::repeat(document)
+                .zip(field_id_map.iter())
+                .map(|(document, (fid, name))| FieldValue {
+                    document,
+                    name,
+                    metadata: field_id_map.metadata(fid).unwrap_or_default(),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl<'a, 'map, D: ObjectView> BorrowedFields<'a, 'map, D> {
+    pub fn new(
+        document: &'a D,
+        field_id_map: &'a RefCell<GlobalFieldsIdsMap<'map>>,
+        doc_alloc: &'a Bump,
+    ) -> Self {
+        Self { document, field_id_map, doc_alloc }
+    }
+}
+
+impl<'a, D: ObjectView> ArrayView for OwnedFields<'a, D> {
+    fn as_value(&self) -> &dyn ValueView {
+        self.0.as_value()
+    }
+
+    fn size(&self) -> i64 {
+        self.0.len() as i64
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        self.0.values()
+    }
+
+    fn contains_key(&self, index: i64) -> bool {
+        self.0.contains_key(index)
+    }
+
+    fn get(&self, index: i64) -> Option<&dyn ValueView> {
+        ArrayView::get(&self.0, index)
+    }
+}
+
+impl<'a, 'map, D: ObjectView> ArrayView for BorrowedFields<'a, 'map, D> {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        self.document.size()
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(self.document.keys().map(|k| {
+            let mut field_id_map = self.field_id_map.borrow_mut();
+            let (_, metadata) = field_id_map.id_with_metadata_or_insert(&k).unwrap();
+            let fv = self.doc_alloc.alloc(FieldValue {
+                name: self.doc_alloc.alloc_str(&k),
+                document: self.document,
+                metadata: FieldMetadata { searchable: metadata.searchable },
+            });
+            fv as _
+        }))
+    }
+
+    fn contains_key(&self, index: i64) -> bool {
+        let index = if index >= 0 { index } else { self.size() + index };
+        index >= 0 && index < self.size()
+    }
+
+    fn get(&self, index: i64) -> Option<&dyn ValueView> {
+        let index = if index >= 0 { index } else { self.size() + index };
+        let index: usize = index.try_into().ok()?;
+        let key = self.document.keys().nth(index)?;
+        let mut field_id_map = self.field_id_map.borrow_mut();
+        let (_, metadata) = field_id_map.id_with_metadata_or_insert(&key)?;
+        let fv = self.doc_alloc.alloc(FieldValue {
+            name: self.doc_alloc.alloc_str(&key),
+            document: self.document,
+            metadata: FieldMetadata { searchable: metadata.searchable },
+        });
+        Some(fv as _)
+    }
+}
+
+impl<'a, 'map, D: ObjectView> ValueView for BorrowedFields<'a, 'map, D> {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ArrayRender { s: self }))
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ArraySource { s: self }))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "array"
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => self.document.size() == 0,
+        }
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        let s = ArrayRender { s: self }.to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Array(self.values().map(|v| v.to_value()).collect())
+    }
+
+    fn as_array(&self) -> Option<&dyn ArrayView> {
+        Some(self)
+    }
+
+    fn is_array(&self) -> bool {
+        true
+    }
+}
+
+impl<'a, D: ObjectView> ValueView for OwnedFields<'a, D> {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        self.0.render()
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        self.0.source()
+    }
+
+    fn type_name(&self) -> &'static str {
+        self.0.type_name()
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        self.0.query_state(state)
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        self.0.to_kstr()
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        self.0.to_value()
+    }
+
+    fn as_array(&self) -> Option<&dyn ArrayView> {
+        Some(self)
+    }
+}
+
+struct ArraySource<'a, 'map, D: ObjectView> {
+    s: &'a BorrowedFields<'a, 'map, D>,
+}
+
+impl<'a, 'map, D: ObjectView> fmt::Display for ArraySource<'a, 'map, D> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "[")?;
+        for item in self.s.values() {
+            write!(f, "{}, ", item.render())?;
+        }
+        write!(f, "]")?;
+        Ok(())
+    }
+}
+
+struct ArrayRender<'a, 'map, D: ObjectView> {
+    s: &'a BorrowedFields<'a, 'map, D>,
+}
+
+impl<'a, 'map, D: ObjectView> fmt::Display for ArrayRender<'a, 'map, D> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for item in self.s.values() {
+            write!(f, "{}", item.render())?;
+        }
+        Ok(())
+    }
+}

crates/milli/src/prompt/mod.rs

@@ -0,0 +1,310 @@
+mod context;
+mod document;
+pub(crate) mod error;
+mod fields;
+mod template_checker;
+
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::convert::TryFrom;
+use std::fmt::Debug;
+use std::num::NonZeroUsize;
+use std::ops::Deref;
+
+use bumpalo::Bump;
+use document::ParseableDocument;
+use error::{NewPromptError, RenderPromptError};
+use fields::{BorrowedFields, OwnedFields};
+
+use self::context::Context;
+use self::document::Document;
+use crate::update::del_add::DelAdd;
+use crate::{FieldId, FieldsIdsMap, GlobalFieldsIdsMap};
+
+pub struct Prompt {
+    template: liquid::Template,
+    template_text: String,
+    max_bytes: Option<NonZeroUsize>,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct PromptData {
+    pub template: String,
+    pub max_bytes: Option<NonZeroUsize>,
+}
+
+impl From<Prompt> for PromptData {
+    fn from(value: Prompt) -> Self {
+        Self { template: value.template_text, max_bytes: value.max_bytes }
+    }
+}
+
+impl TryFrom<PromptData> for Prompt {
+    type Error = NewPromptError;
+
+    fn try_from(value: PromptData) -> Result<Self, Self::Error> {
+        Prompt::new(value.template, value.max_bytes)
+    }
+}
+
+impl Clone for Prompt {
+    fn clone(&self) -> Self {
+        let template_text = self.template_text.clone();
+        Self {
+            template: new_template(&template_text).unwrap(),
+            template_text,
+            max_bytes: self.max_bytes,
+        }
+    }
+}
+
+fn new_template(text: &str) -> Result<liquid::Template, liquid::Error> {
+    liquid::ParserBuilder::with_stdlib().build().unwrap().parse(text)
+}
+
+fn default_template() -> liquid::Template {
+    new_template(default_template_text()).unwrap()
+}
+
+fn default_template_text() -> &'static str {
+    "{% for field in fields %}\
+    {% if field.is_searchable and field.value != nil %}\
+    {{ field.name }}: {{ field.value }}\n\
+    {% endif %}\
+    {% endfor %}"
+}
+
+pub fn default_max_bytes() -> NonZeroUsize {
+    NonZeroUsize::new(400).unwrap()
+}
+
+impl Default for Prompt {
+    fn default() -> Self {
+        Self {
+            template: default_template(),
+            template_text: default_template_text().into(),
+            max_bytes: Some(default_max_bytes()),
+        }
+    }
+}
+
+impl Default for PromptData {
+    fn default() -> Self {
+        Self { template: default_template_text().into(), max_bytes: Some(default_max_bytes()) }
+    }
+}
+
+impl Prompt {
+    pub fn new(template: String, max_bytes: Option<NonZeroUsize>) -> Result<Self, NewPromptError> {
+        let this = Self {
+            template: liquid::ParserBuilder::with_stdlib()
+                .build()
+                .unwrap()
+                .parse(&template)
+                .map_err(NewPromptError::cannot_parse_template)?,
+            template_text: template,
+            max_bytes,
+        };
+
+        // render template with special object that's OK with `doc.*` and `fields.*`
+        this.template
+            .render(&template_checker::TemplateChecker)
+            .map_err(NewPromptError::invalid_fields_in_template)?;
+
+        Ok(this)
+    }
+
+    pub fn render_document<
+        'a,       // lifetime of the borrow of the document
+        'doc: 'a, // lifetime of the allocator, will live for an entire chunk of documents
+    >(
+        &self,
+        document: impl crate::update::new::document::Document<'a> + Debug,
+        field_id_map: &RefCell<GlobalFieldsIdsMap>,
+        doc_alloc: &'doc Bump,
+    ) -> Result<&'doc str, RenderPromptError> {
+        let document = ParseableDocument::new(document, doc_alloc);
+        let fields = BorrowedFields::new(&document, field_id_map, doc_alloc);
+        let context = Context::new(&document, &fields);
+        let mut rendered = bumpalo::collections::Vec::with_capacity_in(
+            self.max_bytes.unwrap_or_else(default_max_bytes).get(),
+            doc_alloc,
+        );
+        self.template
+            .render_to(&mut rendered, &context)
+            .map_err(RenderPromptError::missing_context)?;
+        Ok(std::str::from_utf8(rendered.into_bump_slice())
+            .expect("render can only write UTF-8 because all inputs and processing preserve utf-8"))
+    }
+
+    pub fn render_kvdeladd(
+        &self,
+        document: &obkv::KvReaderU16,
+        side: DelAdd,
+        field_id_map: &FieldsIdsMapWithMetadata,
+    ) -> Result<String, RenderPromptError> {
+        let document = Document::new(document, side, field_id_map);
+        let fields = OwnedFields::new(&document, field_id_map);
+        let context = Context::new(&document, &fields);
+
+        let mut rendered =
+            self.template.render(&context).map_err(RenderPromptError::missing_context)?;
+        if let Some(max_bytes) = self.max_bytes {
+            truncate(&mut rendered, max_bytes.get());
+        }
+        Ok(rendered)
+    }
+}
+
+fn truncate(s: &mut String, max_bytes: usize) {
+    if max_bytes >= s.len() {
+        return;
+    }
+    for i in (0..=max_bytes).rev() {
+        if s.is_char_boundary(i) {
+            s.truncate(i);
+            break;
+        }
+    }
+}
+
+pub struct FieldsIdsMapWithMetadata<'a> {
+    fields_ids_map: &'a FieldsIdsMap,
+    metadata: BTreeMap<FieldId, FieldMetadata>,
+}
+
+impl<'a> FieldsIdsMapWithMetadata<'a> {
+    pub fn new(fields_ids_map: &'a FieldsIdsMap, searchable_fields_ids: &'_ [FieldId]) -> Self {
+        let mut metadata: BTreeMap<FieldId, FieldMetadata> =
+            fields_ids_map.ids().map(|id| (id, Default::default())).collect();
+        for searchable_field_id in searchable_fields_ids {
+            let Some(metadata) = metadata.get_mut(searchable_field_id) else { continue };
+            metadata.searchable = true;
+        }
+        Self { fields_ids_map, metadata }
+    }
+
+    pub fn metadata(&self, field_id: FieldId) -> Option<FieldMetadata> {
+        self.metadata.get(&field_id).copied()
+    }
+}
+
+impl<'a> Deref for FieldsIdsMapWithMetadata<'a> {
+    type Target = FieldsIdsMap;
+
+    fn deref(&self) -> &Self::Target {
+        self.fields_ids_map
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+pub struct FieldMetadata {
+    pub searchable: bool,
+}
+
+#[cfg(test)]
+mod test {
+    use super::Prompt;
+    use crate::error::FaultSource;
+    use crate::prompt::error::{NewPromptError, NewPromptErrorKind};
+    use crate::prompt::truncate;
+
+    #[test]
+    fn default_template() {
+        // does not panic
+        Prompt::default();
+    }
+
+    #[test]
+    fn empty_template() {
+        Prompt::new("".into(), None).unwrap();
+    }
+
+    #[test]
+    fn template_ok() {
+        Prompt::new("{{doc.title}}: {{doc.overview}}".into(), None).unwrap();
+    }
+
+    #[test]
+    fn template_syntax() {
+        assert!(matches!(
+            Prompt::new("{{doc.title: {{doc.overview}}".into(), None),
+            Err(NewPromptError {
+                kind: NewPromptErrorKind::CannotParseTemplate(_),
+                fault: FaultSource::User
+            })
+        ));
+    }
+
+    #[test]
+    fn template_missing_doc() {
+        assert!(matches!(
+            Prompt::new("{{title}}: {{overview}}".into(), None),
+            Err(NewPromptError {
+                kind: NewPromptErrorKind::InvalidFieldsInTemplate(_),
+                fault: FaultSource::User
+            })
+        ));
+    }
+
+    #[test]
+    fn template_nested_doc() {
+        Prompt::new("{{doc.actor.firstName}}: {{doc.actor.lastName}}".into(), None).unwrap();
+    }
+
+    #[test]
+    fn template_fields() {
+        Prompt::new("{% for field in fields %}{{field}}{% endfor %}".into(), None).unwrap();
+    }
+
+    #[test]
+    fn template_fields_ok() {
+        Prompt::new(
+            "{% for field in fields %}{{field.name}}: {{field.value}}{% endfor %}".into(),
+            None,
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn template_fields_invalid() {
+        assert!(matches!(
+            // intentionally garbled field
+            Prompt::new("{% for field in fields %}{{field.vaelu}} {% endfor %}".into(), None),
+            Err(NewPromptError {
+                kind: NewPromptErrorKind::InvalidFieldsInTemplate(_),
+                fault: FaultSource::User
+            })
+        ));
+    }
+
+    // todo: test truncation
+    #[test]
+    fn template_truncation() {
+        let mut s = "インテル ザー ビーグル".to_string();
+
+        truncate(&mut s, 42);
+        assert_eq!(s, "インテル ザー ビーグル");
+
+        assert_eq!(s.len(), 32);
+        truncate(&mut s, 32);
+        assert_eq!(s, "インテル ザー ビーグル");
+
+        truncate(&mut s, 31);
+        assert_eq!(s, "インテル ザー ビーグ");
+        truncate(&mut s, 30);
+        assert_eq!(s, "インテル ザー ビーグ");
+        truncate(&mut s, 28);
+        assert_eq!(s, "インテル ザー ビー");
+        truncate(&mut s, 26);
+        assert_eq!(s, "インテル ザー ビー");
+        truncate(&mut s, 25);
+        assert_eq!(s, "インテル ザー ビ");
+
+        assert_eq!("イ".len(), 3);
+        truncate(&mut s, 3);
+        assert_eq!(s, "イ");
+        truncate(&mut s, 2);
+        assert_eq!(s, "");
+    }
+}

crates/milli/src/prompt/template_checker.rs

@@ -0,0 +1,301 @@
+use liquid::model::{
+    ArrayView, DisplayCow, KStringCow, ObjectRender, ObjectSource, State, Value as LiquidValue,
+};
+use liquid::{Object, ObjectView, ValueView};
+
+#[derive(Debug)]
+pub struct TemplateChecker;
+
+#[derive(Debug)]
+pub struct DummyDoc;
+
+#[derive(Debug)]
+pub struct DummyFields;
+
+#[derive(Debug)]
+pub struct DummyField;
+
+const DUMMY_VALUE: &LiquidValue = &LiquidValue::Nil;
+
+impl ObjectView for DummyField {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        2
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        Box::new(["name", "value"].iter().map(|s| KStringCow::from_static(s)))
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(vec![DUMMY_VALUE.as_view(), DUMMY_VALUE.as_view()].into_iter())
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(self.keys().zip(self.values()))
+    }
+
+    fn contains_key(&self, index: &str) -> bool {
+        index == "name" || index == "value"
+    }
+
+    fn get<'s>(&'s self, index: &str) -> Option<&'s dyn ValueView> {
+        if self.contains_key(index) {
+            Some(DUMMY_VALUE.as_view())
+        } else {
+            None
+        }
+    }
+}
+
+impl ValueView for DummyField {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> DisplayCow<'_> {
+        DUMMY_VALUE.render()
+    }
+
+    fn source(&self) -> DisplayCow<'_> {
+        DUMMY_VALUE.source()
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue => false,
+            State::Empty => false,
+            State::Blank => false,
+        }
+    }
+
+    fn to_kstr(&self) -> KStringCow<'_> {
+        DUMMY_VALUE.to_kstr()
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        let mut this = Object::new();
+        this.insert("name".into(), LiquidValue::Nil);
+        this.insert("value".into(), LiquidValue::Nil);
+        LiquidValue::Object(this)
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+}
+
+impl ValueView for DummyFields {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> DisplayCow<'_> {
+        DUMMY_VALUE.render()
+    }
+
+    fn source(&self) -> DisplayCow<'_> {
+        DUMMY_VALUE.source()
+    }
+
+    fn type_name(&self) -> &'static str {
+        "array"
+    }
+
+    fn query_state(&self, state: State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue => false,
+            State::Empty => false,
+            State::Blank => false,
+        }
+    }
+
+    fn to_kstr(&self) -> KStringCow<'_> {
+        DUMMY_VALUE.to_kstr()
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Array(vec![DummyField.to_value()])
+    }
+
+    fn as_array(&self) -> Option<&dyn ArrayView> {
+        Some(self)
+    }
+}
+
+impl ArrayView for DummyFields {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        u16::MAX as i64
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(std::iter::once(DummyField.as_value()))
+    }
+
+    fn contains_key(&self, index: i64) -> bool {
+        index < self.size()
+    }
+
+    fn get(&self, _index: i64) -> Option<&dyn ValueView> {
+        Some(DummyField.as_value())
+    }
+}
+
+impl ObjectView for DummyDoc {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        1000
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        Box::new(std::iter::empty())
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(std::iter::empty())
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(std::iter::empty())
+    }
+
+    fn contains_key(&self, _index: &str) -> bool {
+        true
+    }
+
+    fn get<'s>(&'s self, _index: &str) -> Option<&'s dyn ValueView> {
+        // Recursively sends itself
+        Some(self)
+    }
+}
+
+impl ValueView for DummyDoc {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> DisplayCow<'_> {
+        DUMMY_VALUE.render()
+    }
+
+    fn source(&self) -> DisplayCow<'_> {
+        DUMMY_VALUE.source()
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue => false,
+            State::Empty => false,
+            State::Blank => false,
+        }
+    }
+
+    fn to_kstr(&self) -> KStringCow<'_> {
+        DUMMY_VALUE.to_kstr()
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Nil
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+}
+
+impl ObjectView for TemplateChecker {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        2
+    }
+
+    fn keys<'k>(&'k self) -> Box<dyn Iterator<Item = KStringCow<'k>> + 'k> {
+        Box::new(["doc", "fields"].iter().map(|s| KStringCow::from_static(s)))
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(
+            std::iter::once(DummyDoc.as_value()).chain(std::iter::once(DummyFields.as_value())),
+        )
+    }
+
+    fn iter<'k>(&'k self) -> Box<dyn Iterator<Item = (KStringCow<'k>, &'k dyn ValueView)> + 'k> {
+        Box::new(self.keys().zip(self.values()))
+    }
+
+    fn contains_key(&self, index: &str) -> bool {
+        index == "doc" || index == "fields"
+    }
+
+    fn get<'s>(&'s self, index: &str) -> Option<&'s dyn ValueView> {
+        match index {
+            "doc" => Some(DummyDoc.as_value()),
+            "fields" => Some(DummyFields.as_value()),
+            _ => None,
+        }
+    }
+}
+
+impl ValueView for TemplateChecker {
+    fn as_debug(&self) -> &dyn std::fmt::Debug {
+        self
+    }
+
+    fn render(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectRender::new(self)))
+    }
+
+    fn source(&self) -> liquid::model::DisplayCow<'_> {
+        DisplayCow::Owned(Box::new(ObjectSource::new(self)))
+    }
+
+    fn type_name(&self) -> &'static str {
+        "object"
+    }
+
+    fn query_state(&self, state: liquid::model::State) -> bool {
+        match state {
+            State::Truthy => true,
+            State::DefaultValue | State::Empty | State::Blank => false,
+        }
+    }
+
+    fn to_kstr(&self) -> liquid::model::KStringCow<'_> {
+        let s = ObjectRender::new(self).to_string();
+        KStringCow::from_string(s)
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Object(
+            self.iter().map(|(k, x)| (k.to_string().into(), x.to_value())).collect(),
+        )
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+}