Small commit to add hybrid search and autoembedding

milli/src/prompt/context.rs

@@ -0,0 +1,97 @@
+use liquid::model::{
+    ArrayView, DisplayCow, KStringCow, ObjectRender, ObjectSource, State, Value as LiquidValue,
+};
+use liquid::{ObjectView, ValueView};
+
+use super::document::Document;
+use super::fields::Fields;
+use crate::FieldsIdsMap;
+
+#[derive(Debug, Clone)]
+pub struct Context<'a> {
+    document: &'a Document<'a>,
+    fields: Fields<'a>,
+}
+
+impl<'a> Context<'a> {
+    pub fn new(document: &'a Document<'a>, field_id_map: &'a FieldsIdsMap) -> Self {
+        Self { document, fields: Fields::new(document, field_id_map) }
+    }
+}
+
+impl<'a> ObjectView for Context<'a> {
+    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> ValueView for Context<'a> {
+    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)
+    }
+}

milli/src/prompt/document.rs

@@ -0,0 +1,131 @@
+use std::cell::OnceCell;
+use std::collections::BTreeMap;
+
+use liquid::model::{
+    DisplayCow, KString, KStringCow, ObjectRender, ObjectSource, State, Value as LiquidValue,
+};
+use liquid::{ObjectView, ValueView};
+
+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: obkv::KvReaderU16<'a>,
+        side: DelAdd,
+        inverted_field_map: &'a FieldsIdsMap,
+    ) -> Self {
+        let mut out_data = BTreeMap::new();
+        for (fid, raw) in data {
+            let obkv = KvReaderDelAdd::new(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 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().collect())
+    }
+
+    fn as_object(&self) -> Option<&dyn ObjectView> {
+        Some(self)
+    }
+}

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))
+    }
+}

milli/src/prompt/fields.rs

@@ -0,0 +1,172 @@
+use liquid::model::{
+    ArrayView, DisplayCow, KStringCow, ObjectRender, ObjectSource, State, Value as LiquidValue,
+};
+use liquid::{ObjectView, ValueView};
+
+use super::document::Document;
+use crate::FieldsIdsMap;
+#[derive(Debug, Clone)]
+pub struct Fields<'a>(Vec<FieldValue<'a>>);
+
+impl<'a> Fields<'a> {
+    pub fn new(document: &'a Document<'a>, field_id_map: &'a FieldsIdsMap) -> Self {
+        Self(
+            std::iter::repeat(document)
+                .zip(field_id_map.iter())
+                .map(|(document, (_fid, name))| FieldValue { document, name })
+                .collect(),
+        )
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct FieldValue<'a> {
+    name: &'a str,
+    document: &'a Document<'a>,
+}
+
+impl<'a> ValueView for FieldValue<'a> {
+    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> FieldValue<'a> {
+    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_empty(&self) -> bool {
+        self.size() == 0
+    }
+}
+
+impl<'a> ObjectView for FieldValue<'a> {
+    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(|&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())),
+        )
+    }
+
+    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> {
+        match index {
+            "name" => Some(self.name()),
+            "value" => Some(self.value()),
+            _ => None,
+        }
+    }
+}
+
+impl<'a> ArrayView for Fields<'a> {
+    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> ValueView for Fields<'a> {
+    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)
+    }
+}

milli/src/prompt/mod.rs

@@ -0,0 +1,144 @@
+mod context;
+mod document;
+pub(crate) mod error;
+mod fields;
+mod template_checker;
+
+use std::convert::TryFrom;
+
+use error::{NewPromptError, RenderPromptError};
+
+use self::context::Context;
+use self::document::Document;
+use crate::update::del_add::DelAdd;
+use crate::FieldsIdsMap;
+
+pub struct Prompt {
+    template: liquid::Template,
+    template_text: String,
+    strategy: PromptFallbackStrategy,
+    fallback: String,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct PromptData {
+    pub template: String,
+    pub strategy: PromptFallbackStrategy,
+    pub fallback: String,
+}
+
+impl From<Prompt> for PromptData {
+    fn from(value: Prompt) -> Self {
+        Self { template: value.template_text, strategy: value.strategy, fallback: value.fallback }
+    }
+}
+
+impl TryFrom<PromptData> for Prompt {
+    type Error = NewPromptError;
+
+    fn try_from(value: PromptData) -> Result<Self, Self::Error> {
+        Prompt::new(value.template, Some(value.strategy), Some(value.fallback))
+    }
+}
+
+impl Clone for Prompt {
+    fn clone(&self) -> Self {
+        let template_text = self.template_text.clone();
+        Self {
+            template: new_template(&template_text).unwrap(),
+            template_text,
+            strategy: self.strategy,
+            fallback: self.fallback.clone(),
+        }
+    }
+}
+
+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 %} \
+    {{ field.name }}: {{ field.value }}\n\
+    {% endfor %}"
+}
+
+fn default_fallback() -> &'static str {
+    "<MISSING>"
+}
+
+impl Default for Prompt {
+    fn default() -> Self {
+        Self {
+            template: default_template(),
+            template_text: default_template_text().into(),
+            strategy: Default::default(),
+            fallback: default_fallback().into(),
+        }
+    }
+}
+
+impl Default for PromptData {
+    fn default() -> Self {
+        Self {
+            template: default_template_text().into(),
+            strategy: Default::default(),
+            fallback: default_fallback().into(),
+        }
+    }
+}
+
+impl Prompt {
+    pub fn new(
+        template: String,
+        strategy: Option<PromptFallbackStrategy>,
+        fallback: Option<String>,
+    ) -> Result<Self, NewPromptError> {
+        let this = Self {
+            template: liquid::ParserBuilder::with_stdlib()
+                .build()
+                .unwrap()
+                .parse(&template)
+                .map_err(NewPromptError::cannot_parse_template)?,
+            template_text: template,
+            strategy: strategy.unwrap_or_default(),
+            fallback: fallback.unwrap_or_default(),
+        };
+
+        // render template with special object that's OK with `doc.*` and `fields.*`
+        /// FIXME: doesn't work for nested objects e.g. `doc.a.b`
+        this.template
+            .render(&template_checker::TemplateChecker)
+            .map_err(NewPromptError::invalid_fields_in_template)?;
+
+        Ok(this)
+    }
+
+    pub fn render(
+        &self,
+        document: obkv::KvReaderU16<'_>,
+        side: DelAdd,
+        field_id_map: &FieldsIdsMap,
+    ) -> Result<String, RenderPromptError> {
+        let document = Document::new(document, side, field_id_map);
+        let context = Context::new(&document, field_id_map);
+
+        self.template.render(&context).map_err(RenderPromptError::missing_context)
+    }
+}
+
+#[derive(
+    Debug, Default, Clone, PartialEq, Eq, Copy, serde::Serialize, serde::Deserialize, deserr::Deserr,
+)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[deserr(rename_all = camelCase, deny_unknown_fields)]
+pub enum PromptFallbackStrategy {
+    Fallback,
+    Skip,
+    #[default]
+    Error,
+}

milli/src/prompt/template_checker.rs

@@ -0,0 +1,282 @@
+use liquid::model::{
+    ArrayView, DisplayCow, KStringCow, ObjectRender, ObjectSource, State, Value as LiquidValue,
+};
+use liquid::{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(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 {
+        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 {
+        DUMMY_VALUE.query_state(state)
+    }
+
+    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 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 {
+        DUMMY_VALUE.query_state(state)
+    }
+
+    fn to_kstr(&self) -> KStringCow<'_> {
+        DUMMY_VALUE.to_kstr()
+    }
+
+    fn to_value(&self) -> LiquidValue {
+        LiquidValue::Nil
+    }
+
+    fn as_array(&self) -> Option<&dyn ArrayView> {
+        Some(self)
+    }
+}
+
+impl ArrayView for DummyFields {
+    fn as_value(&self) -> &dyn ValueView {
+        self
+    }
+
+    fn size(&self) -> i64 {
+        i64::MAX
+    }
+
+    fn values<'k>(&'k self) -> Box<dyn Iterator<Item = &'k dyn ValueView> + 'k> {
+        Box::new(std::iter::empty())
+    }
+
+    fn contains_key(&self, _index: i64) -> bool {
+        true
+    }
+
+    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> {
+        Some(DUMMY_VALUE.as_view())
+    }
+}
+
+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 {
+        DUMMY_VALUE.query_state(state)
+    }
+
+    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)
+    }
+}