feat: add initial extension support

Cargo.toml

@@ -27,7 +27,7 @@ include = [
 [features]
 default = []
 extensions = ["dep:serde_yaml"]
-parse = ["dep:hex", "dep:thiserror", "semver"]
+parse = ["dep:hex", "dep:thiserror", "dep:serde_yaml", "semver"]
 protoc = ["dep:protobuf-src"]
 semver = ["dep:semver"]
 serde = ["dep:pbjson", "dep:pbjson-build", "dep:pbjson-types"]
@@ -38,6 +38,8 @@ pbjson = { version = "0.8.0", optional = true }
 pbjson-types = { version = "0.8.0", optional = true }
 prost = "0.14.1"
 prost-types = "0.14.1"
+# Required by generated text schemas: the typify-generated code emits
+# ::regress::Regex for `pattern` validations.
 regress = "0.10.4"
 semver = { version = "1.0.27", optional = true }
 serde = { version = "1.0.228", features = ["derive"] }

src/extensions.rs

@@ -6,6 +6,7 @@
 //! included in the packaged crate, ignored by git, and automatically kept
 //! in-sync.
 
+#[cfg(feature = "extensions")]
 include!(concat!(env!("OUT_DIR"), "/extensions.in"));
 
 #[cfg(test)]

src/parse/context.rs

@@ -4,9 +4,9 @@
 
 use thiserror::Error;
 
-use crate::parse::{
-    Anchor, Parse, proto::extensions::SimpleExtensionUrn, text::simple_extensions::SimpleExtensions,
-};
+use crate::parse::proto::extensions::SimpleExtensionUrn;
+use crate::parse::text::simple_extensions::ExtensionFile;
+use crate::parse::{Anchor, Parse};
 
 /// A parse context.
 ///
@@ -22,22 +22,24 @@ pub trait Context {
     {
         item.parse(self)
     }
+}
 
+pub trait ProtoContext: Context {
     /// Add a [SimpleExtensionUrn] to this context. Must return an error for duplicate
-    /// anchors or when the urn is not supported.
+    /// anchors or when the URI is not supported.
     ///
     /// This function must eagerly resolve and parse the simple extension, returning an
     /// error if either fails.
     fn add_simple_extension_urn(
         &mut self,
         simple_extension_urn: &SimpleExtensionUrn,
-    ) -> Result<&SimpleExtensions, ContextError>;
+    ) -> Result<&ExtensionFile, ContextError>;
 
     /// Returns the simple extensions for the given simple extension anchor.
     fn simple_extensions(
         &self,
         anchor: &Anchor<SimpleExtensionUrn>,
-    ) -> Result<&SimpleExtensions, ContextError>;
+    ) -> Result<&ExtensionFile, ContextError>;
 }
 
 /// Parse context errors.
@@ -57,57 +59,49 @@ pub enum ContextError {
 }
 
 #[cfg(test)]
-pub(crate) mod tests {
+pub(crate) mod fixtures {
     use std::collections::{HashMap, hash_map::Entry};
 
     use crate::parse::{
         Anchor, context::ContextError, proto::extensions::SimpleExtensionUrn,
-        text::simple_extensions::SimpleExtensions,
+        text::simple_extensions::ExtensionFile,
     };
 
     /// A test context.
     ///
     /// This currently mocks support for simple extensions (does not resolve or
     /// parse).
+    #[derive(Default)]
     pub struct Context {
-        empty_simple_extensions: SimpleExtensions,
-        simple_extensions: HashMap<Anchor<SimpleExtensionUrn>, SimpleExtensionUrn>,
+        simple_extensions: HashMap<Anchor<SimpleExtensionUrn>, ExtensionFile>,
     }
 
-    impl Default for Context {
-        fn default() -> Self {
-            Self {
-                empty_simple_extensions: SimpleExtensions {},
-                simple_extensions: Default::default(),
-            }
-        }
-    }
+    impl super::Context for Context {}
 
-    impl super::Context for Context {
+    impl super::ProtoContext for Context {
         fn add_simple_extension_urn(
             &mut self,
             simple_extension_urn: &crate::parse::proto::extensions::SimpleExtensionUrn,
-        ) -> Result<&SimpleExtensions, ContextError> {
+        ) -> Result<&ExtensionFile, ContextError> {
             match self.simple_extensions.entry(simple_extension_urn.anchor()) {
                 Entry::Occupied(_) => Err(ContextError::DuplicateSimpleExtension(
                     simple_extension_urn.anchor(),
                 )),
                 Entry::Vacant(entry) => {
-                    // TODO: fetch
-                    entry.insert(simple_extension_urn.clone());
-                    // For now just return an empty extension
-                    Ok(&self.empty_simple_extensions)
+                    let f = ExtensionFile::empty(simple_extension_urn.urn().clone());
+                    let ext_ref = entry.insert(f);
+
+                    Ok(ext_ref)
                 }
             }
         }
 
         fn simple_extensions(
             &self,
             anchor: &Anchor<SimpleExtensionUrn>,
-        ) -> Result<&SimpleExtensions, ContextError> {
+        ) -> Result<&ExtensionFile, ContextError> {
             self.simple_extensions
-                .contains_key(anchor)
-                .then_some(&self.empty_simple_extensions)
+                .get(anchor)
                 .ok_or(ContextError::UndefinedSimpleExtension(*anchor))
         }
     }

src/parse/proto/extensions/simple_extension_urn.rs

@@ -7,7 +7,7 @@ use std::str::FromStr;
 use thiserror::Error;
 
 use crate::{
-    parse::{Anchor, Context, Parse, context::ContextError},
+    parse::{Anchor, Parse, context::ContextError, context::ProtoContext},
     proto,
     urn::{InvalidUrn, Urn},
 };
@@ -50,7 +50,7 @@ pub enum SimpleExtensionUrnError {
     Context(#[from] ContextError),
 }
 
-impl<C: Context> Parse<C> for proto::extensions::SimpleExtensionUrn {
+impl<C: ProtoContext> Parse<C> for proto::extensions::SimpleExtensionUrn {
     type Parsed = SimpleExtensionUrn;
     type Error = SimpleExtensionUrnError;
 
@@ -90,7 +90,7 @@ impl From<SimpleExtensionUrn> for proto::extensions::SimpleExtensionUrn {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parse::{Context as _, context::tests::Context};
+    use crate::parse::{Context as _, context::fixtures::Context};
 
     #[test]
     fn parse() -> Result<(), SimpleExtensionUrnError> {

src/parse/proto/plan_version.rs

@@ -3,7 +3,7 @@
 //! Parsing of [proto::PlanVersion].
 
 use crate::{
-    parse::{Parse, context::Context, proto::Version},
+    parse::{Parse, context::ProtoContext, proto::Version},
     proto,
 };
 use thiserror::Error;
@@ -38,7 +38,7 @@ pub enum PlanVersionError {
     Version(#[from] VersionError),
 }
 
-impl<C: Context> Parse<C> for proto::PlanVersion {
+impl<C: ProtoContext> Parse<C> for proto::PlanVersion {
     type Parsed = PlanVersion;
     type Error = PlanVersionError;
 
@@ -71,7 +71,7 @@ impl From<PlanVersion> for proto::PlanVersion {
 mod tests {
     use super::*;
     use crate::{
-        parse::{context::tests::Context, proto::VersionError},
+        parse::{context::fixtures::Context, proto::VersionError},
         version,
     };
 

src/parse/proto/version.rs

@@ -3,7 +3,7 @@
 //! Parsing of [proto::Version].
 
 use crate::{
-    parse::{Parse, context::Context},
+    parse::{Parse, context::ProtoContext},
     proto, version,
 };
 use hex::FromHex;
@@ -75,7 +75,7 @@ pub enum VersionError {
     Substrait(semver::Version, semver::VersionReq),
 }
 
-impl<C: Context> Parse<C> for proto::Version {
+impl<C: ProtoContext> Parse<C> for proto::Version {
     type Parsed = Version;
     type Error = VersionError;
 
@@ -142,7 +142,7 @@ impl From<Version> for proto::Version {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parse::context::tests::Context;
+    use crate::parse::context::fixtures::Context;
 
     #[test]
     fn version() -> Result<(), VersionError> {

src/parse/text/mod.rs

@@ -1,5 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
-//! Parsing of [text](crate::text) types.
+//! Utilities for working with Substrait *text* objects.
+//!
+//! The generated [`crate::text`] module exposes the raw YAML-derived structs
+//! (e.g. [`crate::text::simple_extensions::SimpleExtensions`]).  This module
+//! provides parsing helpers that validate those raw values and offer
+//! higher-level wrappers for validation, lookups, and combining into protobuf
+//! objects.
 
 pub mod simple_extensions;