factors: Rename SpinFactors->RuntimeFactors

And shorten some generic params.

Signed-off-by: Lann Martin <lann.martin@fermyon.com>

Author: lann

crates/factor-outbound-networking/src/lib.rs

@@ -9,22 +9,22 @@ use spin_factor_wasi::WasiFactor;
 use spin_factors::{
     anyhow::{self, Context},
     ConfigureAppContext, Factor, FactorInstancePreparer, InstancePreparers, PrepareContext,
-    RuntimeConfig, SpinFactors,
+    RuntimeConfig, RuntimeFactors,
 };
 use spin_outbound_networking::{AllowedHostsConfig, ALLOWED_HOSTS_KEY};
 
 pub struct OutboundNetworkingFactor;
 
 impl Factor for OutboundNetworkingFactor {
-    type AppConfig = AppConfig;
+    type AppState = AppState;
     type InstancePreparer = InstancePreparer;
     type InstanceState = ();
 
-    fn configure_app<Factors: SpinFactors>(
+    fn configure_app<Factors: RuntimeFactors>(
         &self,
         ctx: ConfigureAppContext<Factors>,
         _runtime_config: &mut impl RuntimeConfig,
-    ) -> anyhow::Result<Self::AppConfig> {
+    ) -> anyhow::Result<Self::AppState> {
         // Extract allowed_outbound_hosts for all components
         let component_allowed_hosts = ctx
             .app()
@@ -40,14 +40,14 @@ impl Factor for OutboundNetworkingFactor {
                 ))
             })
             .collect::<anyhow::Result<_>>()?;
-        Ok(AppConfig {
+        Ok(AppState {
             component_allowed_hosts,
         })
     }
 }
 
 #[derive(Default)]
-pub struct AppConfig {
+pub struct AppState {
     component_allowed_hosts: HashMap<String, Arc<[String]>>,
 }
 
@@ -58,7 +58,7 @@ pub struct InstancePreparer {
 }
 
 impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
-    fn new<Factors: SpinFactors>(
+    fn new<Factors: RuntimeFactors>(
         ctx: PrepareContext<OutboundNetworkingFactor>,
         mut preparers: InstancePreparers<Factors>,
     ) -> anyhow::Result<Self> {

crates/factor-variables/src/lib.rs

@@ -3,18 +3,18 @@ use std::sync::Arc;
 use spin_expressions::ProviderResolver;
 use spin_factors::{
     anyhow, ConfigureAppContext, Factor, FactorInstancePreparer, InitContext, InstancePreparers,
-    PrepareContext, RuntimeConfig, SpinFactors,
+    PrepareContext, RuntimeConfig, RuntimeFactors,
 };
 use spin_world::{async_trait, v1::config as v1_config, v2::variables};
 
 pub struct VariablesFactor;
 
 impl Factor for VariablesFactor {
-    type AppConfig = AppConfig;
+    type AppState = AppState;
     type InstancePreparer = InstancePreparer;
     type InstanceState = InstanceState;
 
-    fn init<Factors: SpinFactors>(
+    fn init<Factors: RuntimeFactors>(
         &mut self,
         mut ctx: InitContext<Factors, Self>,
     ) -> anyhow::Result<()> {
@@ -23,11 +23,11 @@ impl Factor for VariablesFactor {
         Ok(())
     }
 
-    fn configure_app<Factors: SpinFactors>(
+    fn configure_app<Factors: RuntimeFactors>(
         &self,
         ctx: ConfigureAppContext<Factors>,
         _runtime_config: &mut impl RuntimeConfig,
-    ) -> anyhow::Result<Self::AppConfig> {
+    ) -> anyhow::Result<Self::AppState> {
         let app = ctx.app();
         let mut resolver =
             ProviderResolver::new(app.variables().map(|(key, val)| (key.clone(), val.clone())))?;
@@ -38,14 +38,14 @@ impl Factor for VariablesFactor {
             )?;
         }
         // TODO: add providers from runtime config
-        Ok(AppConfig {
+        Ok(AppState {
             resolver: Arc::new(resolver),
         })
     }
 }
 
 #[derive(Default)]
-pub struct AppConfig {
+pub struct AppState {
     resolver: Arc<ProviderResolver>,
 }
 
@@ -60,7 +60,7 @@ impl InstancePreparer {
 }
 
 impl FactorInstancePreparer<VariablesFactor> for InstancePreparer {
-    fn new<Factors: SpinFactors>(
+    fn new<Factors: RuntimeFactors>(
         ctx: PrepareContext<VariablesFactor>,
         _preparers: InstancePreparers<Factors>,
     ) -> anyhow::Result<Self> {

crates/factor-wasi/src/lib.rs

@@ -4,7 +4,7 @@ use std::{future::Future, net::SocketAddr, path::Path};
 
 use spin_factors::{
     anyhow, AppComponent, Factor, FactorInstancePreparer, InitContext, InstancePreparers,
-    PrepareContext, SpinFactors,
+    PrepareContext, RuntimeFactors,
 };
 use wasmtime_wasi::{ResourceTable, WasiCtx, WasiCtxBuilder, WasiView};
 
@@ -21,11 +21,11 @@ impl WasiFactor {
 }
 
 impl Factor for WasiFactor {
-    type AppConfig = ();
+    type AppState = ();
     type InstancePreparer = InstancePreparer;
     type InstanceState = InstanceState;
 
-    fn init<Factors: SpinFactors>(
+    fn init<Factors: RuntimeFactors>(
         &mut self,
         mut ctx: InitContext<Factors, Self>,
     ) -> anyhow::Result<()> {
@@ -124,7 +124,7 @@ pub struct InstancePreparer {
 
 impl FactorInstancePreparer<WasiFactor> for InstancePreparer {
     // NOTE: Replaces WASI parts of AppComponent::apply_store_config
-    fn new<Factors: SpinFactors>(
+    fn new<Factors: RuntimeFactors>(
         ctx: PrepareContext<WasiFactor>,
         _preparers: InstancePreparers<Factors>,
     ) -> anyhow::Result<Self> {

crates/factor-wasi/src/preview1.rs

@@ -1,17 +1,17 @@
 use spin_factors::{
     anyhow, Factor, FactorInstancePreparer, InitContext, InstancePreparers, PrepareContext,
-    SpinFactors,
+    RuntimeFactors,
 };
 use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
 pub struct WasiPreview1Factor;
 
 impl Factor for WasiPreview1Factor {
-    type AppConfig = ();
+    type AppState = ();
     type InstancePreparer = InstancePreparer;
     type InstanceState = WasiP1Ctx;
 
-    fn init<Factors: SpinFactors>(
+    fn init<Factors: RuntimeFactors>(
         &mut self,
         mut ctx: InitContext<Factors, Self>,
     ) -> anyhow::Result<()> {
@@ -24,7 +24,7 @@ pub struct InstancePreparer {
 }
 
 impl FactorInstancePreparer<WasiPreview1Factor> for InstancePreparer {
-    fn new<Factors: SpinFactors>(
+    fn new<Factors: RuntimeFactors>(
         _ctx: PrepareContext<WasiPreview1Factor>,
         _preparers: InstancePreparers<Factors>,
     ) -> anyhow::Result<Self> {

crates/factors-derive/src/lib.rs

@@ -2,7 +2,7 @@ use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::{parse_macro_input, Data, DeriveInput, Error};
 
-#[proc_macro_derive(SpinFactors)]
+#[proc_macro_derive(RuntimeFactors)]
 pub fn derive_factors(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let expanded = expand_factors(&input).unwrap_or_else(|err| err.into_compile_error());
@@ -20,7 +20,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
     let name = &input.ident;
     let vis = &input.vis;
 
-    let app_configs_name = format_ident!("{name}AppConfigs");
+    let app_configs_name = format_ident!("{name}AppState");
     let preparers_name = format_ident!("{name}InstancePreparers");
     let state_name = format_ident!("{name}InstanceState");
 
@@ -133,8 +133,8 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
 
         }
 
-        impl #factors_path::SpinFactors for #name {
-            type AppConfigs = #app_configs_name;
+        impl #factors_path::RuntimeFactors for #name {
+            type AppState = #app_configs_name;
             type InstancePreparers = #preparers_name;
             type InstanceState = #state_name;
 
@@ -159,7 +159,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
 
             }
 
-            fn app_config<T: #Factor>(app_configs: &Self::AppConfigs) -> Option<&T::AppConfig> {
+            fn app_config<T: #Factor>(app_configs: &Self::AppState) -> Option<&T::AppState> {
                 let type_id = #TypeId::of::<T>();
                 #(
                     if type_id == #TypeId::of::<#factor_types>() {
@@ -172,7 +172,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
 
         #vis struct #app_configs_name {
             #(
-                pub #factor_names: Option<<#factor_types as #Factor>::AppConfig>,
+                pub #factor_names: Option<<#factor_types as #Factor>::AppState>,
             )*
         }
 

crates/factors/src/factor.rs

@@ -2,13 +2,13 @@ use std::any::Any;
 
 use anyhow::Context;
 
-use crate::{App, FactorInstancePreparer, Linker, ModuleLinker, RuntimeConfig, SpinFactors};
+use crate::{App, FactorInstancePreparer, Linker, ModuleLinker, RuntimeConfig, RuntimeFactors};
 
 pub trait Factor: Any + Sized {
-    /// Per-app configuration for this factor.
+    /// Per-app state for this factor.
     ///
     /// See [`Factor::configure_app`].
-    type AppConfig: Default;
+    type AppState: Default;
 
     /// The [`FactorInstancePreparer`] for this factor.
     type InstancePreparer: FactorInstancePreparer<Self>;
@@ -20,10 +20,7 @@ pub trait Factor: Any + Sized {
 
     /// Initializes this Factor for a runtime. This will be called at most once,
     /// before any call to [`FactorInstancePreparer::new`]
-    fn init<Factors: SpinFactors>(
-        &mut self,
-        mut ctx: InitContext<Factors, Self>,
-    ) -> anyhow::Result<()> {
+    fn init<T: RuntimeFactors>(&mut self, mut ctx: InitContext<T, Self>) -> anyhow::Result<()> {
         // TODO: Should `ctx` always be immut? Rename this param/type?
         _ = &mut ctx;
         Ok(())
@@ -33,33 +30,33 @@ pub trait Factor: Any + Sized {
     /// [`App`]. A runtime may - but is not required to - reuse the returned
     /// config across multiple instances. Note that this may be called without
     /// any call to `init` in cases where only validation is needed.
-    fn configure_app<Factors: SpinFactors>(
+    fn configure_app<T: RuntimeFactors>(
         &self,
-        ctx: ConfigureAppContext<Factors>,
+        ctx: ConfigureAppContext<T>,
         _runtime_config: &mut impl RuntimeConfig,
-    ) -> anyhow::Result<Self::AppConfig> {
+    ) -> anyhow::Result<Self::AppState> {
         _ = ctx;
         Ok(Default::default())
     }
 }
 
-pub(crate) type GetDataFn<Factors, Fact> =
-    fn(&mut <Factors as SpinFactors>::InstanceState) -> &mut <Fact as Factor>::InstanceState;
+pub(crate) type GetDataFn<Facts, Fact> =
+    fn(&mut <Facts as RuntimeFactors>::InstanceState) -> &mut <Fact as Factor>::InstanceState;
 
 /// An InitContext is passed to [`Factor::init`], giving access to the global
 /// common [`wasmtime::component::Linker`].
-pub struct InitContext<'a, Factors: SpinFactors, T: Factor> {
-    pub(crate) linker: Option<&'a mut Linker<Factors>>,
-    pub(crate) module_linker: Option<&'a mut ModuleLinker<Factors>>,
-    pub(crate) get_data: GetDataFn<Factors, T>,
+pub struct InitContext<'a, T: RuntimeFactors, F: Factor> {
+    pub(crate) linker: Option<&'a mut Linker<T>>,
+    pub(crate) module_linker: Option<&'a mut ModuleLinker<T>>,
+    pub(crate) get_data: GetDataFn<T, F>,
 }
 
-impl<'a, Factors: SpinFactors, T: Factor> InitContext<'a, Factors, T> {
+impl<'a, T: RuntimeFactors, F: Factor> InitContext<'a, T, F> {
     #[doc(hidden)]
     pub fn new(
-        linker: Option<&'a mut Linker<Factors>>,
-        module_linker: Option<&'a mut ModuleLinker<Factors>>,
-        get_data: GetDataFn<Factors, T>,
+        linker: Option<&'a mut Linker<T>>,
+        module_linker: Option<&'a mut ModuleLinker<T>>,
+        get_data: GetDataFn<T, F>,
     ) -> Self {
         Self {
             linker,
@@ -68,23 +65,23 @@ impl<'a, Factors: SpinFactors, T: Factor> InitContext<'a, Factors, T> {
         }
     }
 
-    pub fn linker(&mut self) -> Option<&mut Linker<Factors>> {
+    pub fn linker(&mut self) -> Option<&mut Linker<T>> {
         self.linker.as_deref_mut()
     }
 
-    pub fn module_linker(&mut self) -> Option<&mut ModuleLinker<Factors>> {
+    pub fn module_linker(&mut self) -> Option<&mut ModuleLinker<T>> {
         self.module_linker.as_deref_mut()
     }
 
-    pub fn get_data_fn(&self) -> GetDataFn<Factors, T> {
+    pub fn get_data_fn(&self) -> GetDataFn<T, F> {
         self.get_data
     }
 
     pub fn link_bindings(
         &mut self,
         add_to_linker: impl Fn(
-            &mut Linker<Factors>,
-            fn(&mut Factors::InstanceState) -> &mut T::InstanceState,
+            &mut Linker<T>,
+            fn(&mut T::InstanceState) -> &mut F::InstanceState,
         ) -> anyhow::Result<()>,
     ) -> anyhow::Result<()>
 where {
@@ -98,8 +95,8 @@ where {
     pub fn link_module_bindings(
         &mut self,
         add_to_linker: impl Fn(
-            &mut ModuleLinker<Factors>,
-            fn(&mut Factors::InstanceState) -> &mut T::InstanceState,
+            &mut ModuleLinker<T>,
+            fn(&mut T::InstanceState) -> &mut F::InstanceState,
         ) -> anyhow::Result<()>,
     ) -> anyhow::Result<()>
 where {
@@ -111,42 +108,42 @@ where {
     }
 }
 
-pub struct ConfigureAppContext<'a, Factors: SpinFactors> {
+pub struct ConfigureAppContext<'a, T: RuntimeFactors> {
     pub(crate) app: &'a App,
-    pub(crate) app_configs: &'a Factors::AppConfigs,
+    pub(crate) app_configs: &'a T::AppState,
 }
 
-impl<'a, Factors: SpinFactors> ConfigureAppContext<'a, Factors> {
+impl<'a, T: RuntimeFactors> ConfigureAppContext<'a, T> {
     #[doc(hidden)]
-    pub fn new(app: &'a App, app_configs: &'a Factors::AppConfigs) -> Self {
+    pub fn new(app: &'a App, app_configs: &'a T::AppState) -> Self {
         Self { app, app_configs }
     }
 
     pub fn app(&self) -> &App {
         self.app
     }
 
-    pub fn app_config<T: Factor>(&self) -> crate::Result<&T::AppConfig> {
-        Factors::app_config::<T>(self.app_configs).context("no such factor")
+    pub fn app_config<F: Factor>(&self) -> crate::Result<&F::AppState> {
+        T::app_config::<F>(self.app_configs).context("no such factor")
     }
 }
 
-pub struct ConfiguredApp<Factors: SpinFactors> {
+pub struct ConfiguredApp<T: RuntimeFactors> {
     app: App,
-    app_configs: Factors::AppConfigs,
+    app_configs: T::AppState,
 }
 
-impl<Factors: SpinFactors> ConfiguredApp<Factors> {
+impl<T: RuntimeFactors> ConfiguredApp<T> {
     #[doc(hidden)]
-    pub fn new(app: App, app_configs: Factors::AppConfigs) -> Self {
+    pub fn new(app: App, app_configs: T::AppState) -> Self {
         Self { app, app_configs }
     }
 
     pub fn app(&self) -> &App {
         &self.app
     }
 
-    pub fn app_config<T: Factor>(&self) -> crate::Result<&T::AppConfig> {
-        Factors::app_config::<T>(&self.app_configs).context("no such factor")
+    pub fn app_config<F: Factor>(&self) -> crate::Result<&F::AppState> {
+        T::app_config::<F>(&self.app_configs).context("no such factor")
     }
 }