slumber-python 5.1.0__tar.gz → 5.1.1__tar.gz

{slumber_python-5.1.0 → slumber_python-5.1.1}/Cargo.lock

@@ -809,7 +809,7 @@ dependencies = [
 
 [[package]]
 name = "doc_utils"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "anyhow",
  "clap",
@@ -3280,7 +3280,7 @@ checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "slumber"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "anyhow",
  "console-subscriber",
@@ -3294,7 +3294,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_cli"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -3329,7 +3329,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_config"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "derive_more",
  "dirs",
@@ -3354,7 +3354,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_core"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -3402,7 +3402,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_import"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "anyhow",
  "base64 0.22.1",
@@ -3434,7 +3434,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_macros"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3443,7 +3443,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_python"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "async-trait",
  "dialoguer",
@@ -3457,7 +3457,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_template"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "bytes",
  "derive_more",
@@ -3484,7 +3484,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_tui"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3525,7 +3525,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_util"
-version = "5.1.0"
+version = "5.1.1"
 dependencies = [
  "derive_more",
  "dirs",

{slumber_python-5.1.0 → slumber_python-5.1.1}/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://slumber.lucaspickering.me"
 keywords = ["rest", "http", "terminal", "tui"]
 license = "MIT"
 repository = "https://github.com/LucasPickering/slumber"
-version = "5.1.0"
+version = "5.1.1"
 # Keep in sync w/ rust-toolchain.toml
 rust-version = "1.90.0"
 
@@ -43,14 +43,14 @@ serde_json = {version = "1.0.120", default-features = false, features = ["preser
 serde_json_path = "0.7.1"
 serde_test = "1.0.176"
 serde_yaml = {version = "0.9.0", default-features = false}
-slumber_cli = {path = "./crates/cli", version = "5.1.0" }
-slumber_config = {path = "./crates/config", version = "5.1.0", default-features = false }
-slumber_core = {path = "./crates/core", version = "5.1.0" }
-slumber_import = {path = "./crates/import", version = "5.1.0" }
-slumber_macros = {path = "./crates/macros", version = "5.1.0" }
-slumber_template = {path = "./crates/template", version = "5.1.0" }
-slumber_tui = {path = "./crates/tui", version = "5.1.0" }
-slumber_util = {path = "./crates/util", version = "5.1.0" }
+slumber_cli = {path = "./crates/cli", version = "5.1.1" }
+slumber_config = {path = "./crates/config", version = "5.1.1", default-features = false }
+slumber_core = {path = "./crates/core", version = "5.1.1" }
+slumber_import = {path = "./crates/import", version = "5.1.1" }
+slumber_macros = {path = "./crates/macros", version = "5.1.1" }
+slumber_template = {path = "./crates/template", version = "5.1.1" }
+slumber_tui = {path = "./crates/tui", version = "5.1.1" }
+slumber_util = {path = "./crates/util", version = "5.1.1" }
 strum = {version = "0.27.0", default-features = false}
 syn = "2.0.101"
 terminput = "0.5.3"

{slumber_python-5.1.0 → slumber_python-5.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slumber-python
-Version: 5.1.0
+Version: 5.1.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{slumber_python-5.1.0 → slumber_python-5.1.1}/crates/core/src/collection/json.rs

@@ -1,17 +1,17 @@
 //! Utilities for working with templated JSON
 
-use crate::render::TemplateContext;
+use crate::{render::TemplateContext, util::value_to_json};
 use futures::future;
 use serde::{Serialize, Serializer, ser::SerializeMap};
 use slumber_template::{
-    RenderError, Template, TemplateParseError, TryFromValue,
+    RenderError, RenderedOutput, Template, TemplateParseError, Value,
+    ValueError,
 };
 use std::str::FromStr;
 use thiserror::Error;
 
 /// A JSON value like [serde_json::Value], but all strings are templates
-#[derive(Clone, Debug, Serialize)]
-#[cfg_attr(any(test, feature = "test"), derive(PartialEq))]
+#[derive(Clone, Debug, PartialEq, Serialize)]
 #[serde(untagged)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum JsonTemplate {
@@ -50,82 +50,64 @@ impl JsonTemplate {
         }
     }
 
-    /// Render all templates to strings and return a static JSON value
-    pub async fn render(
-        &self,
-        context: &TemplateContext,
-    ) -> Result<serde_json::Value, RenderError> {
-        let rendered = match self {
-            Self::Null => serde_json::Value::Null,
-            Self::Bool(b) => serde_json::Value::Bool(*b),
-            Self::Number(number) => serde_json::Value::Number(number.clone()),
-            Self::String(template) => {
-                // Render to a JSON value instead of just a string. If the
-                // template is a single chunk that returns a non-string value
-                // (e.g. a number or array), use that value directly. This
-                // enables non-string values
-                serde_json::Value::try_from_value(
-                    template
-                        .render(&context.streaming(false))
-                        .await
-                        .try_collect_value()
-                        .await?,
-                )
-                .map_err(|error| RenderError::Value(error.error))?
+    /// Render to previewable chunks
+    ///
+    /// The return value is *usually* a single chunk, but if the JSON value is
+    /// a multi-chunk template string, then its multi-chunk output will be the
+    /// output for this.
+    pub async fn render(&self, context: &TemplateContext) -> RenderedOutput {
+        match self {
+            JsonTemplate::Null => Value::Null.into(),
+            JsonTemplate::Bool(b) => Value::Boolean(*b).into(),
+            JsonTemplate::Number(n) => {
+                if let Some(i) = n.as_i64() {
+                    Value::Integer(i).into()
+                } else if let Some(f) = n.as_f64() {
+                    Value::Float(f).into()
+                } else {
+                    // Integer is out of i64 range. Template values really
+                    // should be a superset of JSON values, but right now that's
+                    // not the case.
+                    Err(RenderError::from(ValueError::other(
+                        "JSON integer out of range",
+                    )))
+                    .into()
+                }
             }
-            Self::Array(array) => {
-                let array = future::try_join_all(
-                    array.iter().map(|item| item.render(context)),
-                )
-                .await?;
-                serde_json::Value::Array(array)
+            JsonTemplate::String(template) => template.render(context).await,
+            JsonTemplate::Array(array) => {
+                // Render each value and collection into an Array
+                future::try_join_all(array.iter().map(|value| async {
+                    value.render(context).await.try_collect_value().await
+                }))
+                .await
+                .map(Value::from)
+                .into() // Wrap into RenderedOutput
             }
-            Self::Object(map) => {
-                let map = future::try_join_all(map.iter().map(
-                    |(key, value)| async {
-                        let key = key
-                            .render_string(&context.streaming(false))
-                            .await?;
-                        let value = value.render(context).await?;
-                        Ok::<_, RenderError>((key, value))
-                    },
-                ))
-                .await?;
-                serde_json::Value::Object(map.into_iter().collect())
+            JsonTemplate::Object(map) => {
+                // Render each key/value and collect into an Object
+                future::try_join_all(map.iter().map(|(key, value)| async {
+                    let key = key.render_string(context).await?;
+                    let value =
+                        value.render(context).await.try_collect_value().await?;
+                    Ok::<_, RenderError>((key, value))
+                }))
+                .await
+                .map(Value::from)
+                .into() // Wrap into RenderedOutput
             }
-        };
-        Ok(rendered)
+        }
     }
-}
 
-impl From<&JsonTemplate> for serde_json::Value {
-    /// Convert a [JsonTemplate] to a [serde_json::Value], stringifying
-    /// templates
-    fn from(template: &JsonTemplate) -> Self {
-        match template {
-            JsonTemplate::Null => serde_json::Value::Null,
-            JsonTemplate::Bool(b) => serde_json::Value::Bool(*b),
-            JsonTemplate::Number(number) => {
-                serde_json::Value::Number(number.clone())
-            }
-            JsonTemplate::String(template) => {
-                serde_json::Value::String(template.display().to_string())
-            }
-            JsonTemplate::Array(array) => serde_json::Value::Array(
-                array.iter().map(serde_json::Value::from).collect(),
-            ),
-            JsonTemplate::Object(object) => serde_json::Value::Object(
-                object
-                    .iter()
-                    .map(|(key, value)| {
-                        (
-                            key.display().to_string(),
-                            serde_json::Value::from(value),
-                        )
-                    })
-                    .collect(),
-            ),
-        }
+    /// Render all templates to strings and return a static JSON value
+    pub async fn render_json(
+        &self,
+        context: &TemplateContext,
+    ) -> Result<serde_json::Value, RenderError> {
+        // Collect render output as a single value. The renderer should always
+        // output a single chunk, so it gets unpacked back to one value.
+        let value = self.render(context).await.try_collect_value().await?;
+        Ok(value_to_json(value))
     }
 }
 
@@ -210,45 +192,61 @@ pub enum JsonTemplateError {
 mod tests {
     use super::*;
     use crate::{
-        collection::Profile, render::TemplateContext, test_util::by_id,
+        collection::Profile,
+        render::TemplateContext,
+        test_util::{by_id, invalid_utf8},
     };
     use indexmap::indexmap;
     use rstest::rstest;
     use serde_json::json;
     use slumber_util::{Factory, assert_result};
 
-    /// Test that object keys are rendered as templates
+    /// Render JSON templates to JSON values
     #[rstest]
-    #[case::template_key(
+    #[case::null(json!(null), Ok(json!(null)))]
+    #[case::bool(json!(true), Ok(json!(true)))]
+    #[case::integer(json!(3), Ok(json!(3)))]
+    #[case::float(json!(3.15), Ok(json!(3.15)))]
+    #[case::string(json!("{{ username }}"), Ok(json!("testuser")))]
+    #[case::array(
+        json!([1, 2, "{{ username }}"]),
+        Ok(json!([1, 2, "testuser"])),
+    )]
+    #[case::object(
         json!({"{{ user_id }}": {"name": "{{ username }}"}}),
         Ok(json!({"123": {"name": "testuser"}})),
     )]
-    #[case::invalid_key(
-        json!({"{{ user_id": {"name": "{{ username }}"}}),
-        Err("invalid expression"),
-    )]
+    // serde_json converts the byte string to a number array. Seems reasonable
+    // enough.
+    #[case::bytes(json!("{{ invalid_utf8 }}"), Ok(json!([0xc3, 0x28])))]
+    // Once we have non-string profile values we can test:
+    // - Invalid int/float values
+    // - Unpacking strings
     #[tokio::test]
-    async fn test_render_template_keys(
+    async fn test_render_json(
         #[case] input: serde_json::Value,
         #[case] expected: Result<serde_json::Value, &str>,
     ) {
         let profile = Profile {
             data: indexmap! {
                 "user_id".into() => "123".into(),
-                "username".into() => "testuser".into()
+                "username".into() => "testuser".into(),
+                "invalid_utf8".into() => invalid_utf8(),
             },
             ..Profile::factory(())
         };
         let context =
             TemplateContext::factory((by_id([profile]), indexmap! {}));
 
-        let result = match JsonTemplate::try_from(input) {
-            // If we're expecting an error, it should happen during the parse
-            // so don't check for errors during render. Saves having to
-            // consolidate the error types
-            Ok(json) => Ok(json.render(&context).await.unwrap()),
-            Err(error) => Err(error),
-        };
+        let template = JsonTemplate::try_from(input).expect("Invalid template");
+        let result = template.render_json(&context).await;
         assert_result(result, expected);
     }
+
+    /// Parsing a JSON value with a key that isn't a valid template is an error
+    #[test]
+    fn test_invalid_key_template() {
+        let json = json!({"{{ invalid_key": {"name": "{{ username }}"}});
+        assert_result(JsonTemplate::try_from(json), Err("invalid expression"));
+    }
 }

{slumber_python-5.1.0 → slumber_python-5.1.1}/crates/core/src/http.rs

@@ -568,7 +568,7 @@ impl Recipe {
     ) -> Result<Url, RequestBuildErrorKind> {
         let template = options.url.as_ref().unwrap_or(&self.url);
         let url = template
-            .render_string(&context.streaming(false))
+            .render_string(context)
             .await
             .map_err(RequestBuildErrorKind::UrlRender)?;
         url.parse::<Url>()
@@ -591,12 +591,12 @@ impl Recipe {
         );
 
         let iter = merged.into_iter().map(async |((param, _), template)| {
-            let value = template
-                .render_string(&context.streaming(false))
-                .await
-                .map_err(|error| RequestBuildErrorKind::QueryRender {
-                    parameter: param.to_owned(),
-                    error,
+            let value =
+                template.render_string(context).await.map_err(|error| {
+                    RequestBuildErrorKind::QueryRender {
+                        parameter: param.to_owned(),
+                        error,
+                    }
                 })?;
             Ok((param.to_owned(), value))
         });
@@ -637,7 +637,7 @@ impl Recipe {
         value_template: &Template,
     ) -> Result<(HeaderName, HeaderValue), RequestBuildErrorKind> {
         let mut value: Vec<u8> = value_template
-            .render_bytes(&context.streaming(false))
+            .render_bytes(context)
             .await
             .map_err(|error| RequestBuildErrorKind::HeaderRender {
                 header: header.to_owned(),
@@ -679,17 +679,16 @@ impl Recipe {
             .authentication
             .as_ref()
             .or(self.authentication.as_ref());
-        let context = context.streaming(false); // Auth templates never support streaming
         match authentication {
             Some(Authentication::Basic { username, password }) => {
                 let (username, password) =
                     try_join!(
                         username
-                            .render_string(&context)
+                            .render_string(context)
                             .map_err(RequestBuildErrorKind::AuthUsernameRender),
                         async {
                             OptionFuture::from(password.as_ref().map(
-                                |password| password.render_string(&context),
+                                |password| password.render_string(context),
                             ))
                             .await
                             .transpose()
@@ -701,7 +700,7 @@ impl Recipe {
 
             Some(Authentication::Bearer { token }) => {
                 let token = token
-                    .render_string(&context)
+                    .render_string(context)
                     .await
                     .map_err(RequestBuildErrorKind::AuthTokenRender)?;
                 Ok(Some(Authentication::Bearer { token }))
@@ -735,7 +734,7 @@ impl Recipe {
                 Some(BodyOverride::Raw(template)),
             ) => {
                 let rendered = template
-                    .render_bytes(&context.streaming(false))
+                    .render_bytes(context)
                     .await
                     .map_err(RequestBuildErrorKind::BodyRender)?;
                 Ok(Some(RenderedBody::Raw(rendered)))
@@ -748,7 +747,7 @@ impl Recipe {
                 Some(BodyOverride::Raw(template)),
             ) => {
                 // Stream body is rendered as a stream (!!)
-                let output = template.render(&context.streaming(true)).await;
+                let output = template.render(&context.stream()).await;
                 let source = output.stream_source().cloned();
                 let stream = output
                     .try_into_stream()
@@ -764,7 +763,7 @@ impl Recipe {
             | (Some(RecipeBody::Raw(_)), Some(BodyOverride::Json(json)))
             | (Some(RecipeBody::Stream(_)), Some(BodyOverride::Json(json)))
             | (Some(RecipeBody::Json(_)), Some(BodyOverride::Json(json))) => {
-                json.render(context)
+                json.render_json(context)
                     .await
                     .map(|value| Some(RenderedBody::Json(value)))
                     .map_err(RequestBuildErrorKind::BodyRender)
@@ -776,15 +775,12 @@ impl Recipe {
                 // handled above
                 let merged = apply_overrides(fields, &options.form_fields);
                 let iter = merged.into_iter().map(async |(field, template)| {
-                    let value = template
-                        .render_string(&context.streaming(false))
-                        .await
-                        .map_err(|error| {
-                            RequestBuildErrorKind::BodyFormFieldRender {
-                                field: field.clone(),
-                                error,
-                            }
-                        })?;
+                    let value = template.render_string(context).await.map_err(
+                        |error| RequestBuildErrorKind::BodyFormFieldRender {
+                            field: field.clone(),
+                            error,
+                        },
+                    )?;
                     Ok::<_, RequestBuildErrorKind>((field.clone(), value))
                 });
                 let rendered = try_join_all(iter).await?;
@@ -793,8 +789,7 @@ impl Recipe {
             (Some(RecipeBody::FormMultipart(fields)), None) => {
                 let merged = apply_overrides(fields, &options.form_fields);
                 let iter = merged.into_iter().map(async |(field, template)| {
-                    let output =
-                        template.render(&context.streaming(true)).await;
+                    let output = template.render(&context.stream()).await;
                     // If this is a single-chunk template, we might be able to
                     // load directly from the source, since we support file
                     // streams natively. In that case, the stream will be thrown

{slumber_python-5.1.0 → slumber_python-5.1.1}/crates/core/src/render/functions.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     collection::RecipeId,
-    render::{FunctionError, Prompt, SelectOption, SingleRenderContext},
+    render::{FunctionError, Prompt, SelectOption, TemplateContext},
 };
 use base64::{Engine, prelude::BASE64_STANDARD};
 use bytes::Bytes;
@@ -124,7 +124,7 @@ pub fn boolean(value: Value) -> bool {
 /// ```
 #[template]
 pub fn command(
-    #[context] context: &SingleRenderContext<'_>,
+    #[context] context: &TemplateContext,
     command: Vec<String>,
     #[kwarg] cwd: Option<String>,
     #[kwarg] stdin: Option<Bytes>,
@@ -304,10 +304,7 @@ pub fn env(variable: String, #[kwarg] default: String) -> String {
 ///     output: Contents of config.json file
 /// ```
 #[template]
-pub fn file(
-    #[context] context: &SingleRenderContext<'_>,
-    path: String,
-) -> LazyValue {
+pub fn file(#[context] context: &TemplateContext, path: String) -> LazyValue {
     let path = context.root_dir.join(expand_home(PathBuf::from(path)));
     let source = StreamSource::File { path: path.clone() };
     // Return the file as a stream. If streaming isn't available here, it will
@@ -870,7 +867,7 @@ pub fn lower(value: String) -> String {
 /// ```
 #[template]
 pub async fn prompt(
-    #[context] context: &SingleRenderContext<'_>,
+    #[context] context: &TemplateContext,
     #[kwarg] message: Option<String>,
     #[kwarg] default: Option<String>,
     #[kwarg] sensitive: bool,
@@ -979,7 +976,7 @@ pub fn replace(
 /// ```
 #[template]
 pub async fn response(
-    #[context] context: &SingleRenderContext<'_>,
+    #[context] context: &TemplateContext,
     recipe_id: RecipeId,
     #[kwarg] trigger: RequestTrigger,
 ) -> Result<Bytes, FunctionError> {
@@ -1015,7 +1012,7 @@ pub async fn response(
 /// ```
 #[template]
 pub async fn response_header(
-    #[context] context: &SingleRenderContext<'_>,
+    #[context] context: &TemplateContext,
     recipe_id: RecipeId,
     header: String,
     #[kwarg] trigger: RequestTrigger,
@@ -1055,7 +1052,7 @@ pub async fn response_header(
 /// ```
 #[template]
 pub async fn select(
-    #[context] context: &SingleRenderContext<'_>,
+    #[context] context: &TemplateContext,
     options: Vec<SelectOption>,
     #[kwarg] message: Option<String>,
 ) -> Result<Value, FunctionError> {
@@ -1107,7 +1104,7 @@ impl TryFromValue for SelectOption {
 /// ```
 #[template]
 pub fn sensitive(
-    #[context] context: &SingleRenderContext<'_>,
+    #[context] context: &TemplateContext,
     value: String,
 ) -> String {
     mask_sensitive(context, value)
@@ -1310,7 +1307,7 @@ pub fn upper(value: String) -> String {
     value.to_uppercase()
 }
 
-fn mask_sensitive(context: &SingleRenderContext<'_>, value: String) -> String {
+fn mask_sensitive(context: &TemplateContext, value: String) -> String {
     if context.show_sensitive {
         value
     } else {