Add initial integration of liquid template language

Signed-off-by: Ryan Bottriell <[email protected]>

Author: rydrman

Cargo.lock

@@ -12,6 +12,7 @@ members = [
     "crates/spk-exec",
     "crates/spk-launcher",
     "crates/spk-schema",
+    "crates/spk-schema/crates/*",
     "crates/spk-solve",
     "crates/spk-solve/crates/*",
     "crates/spk-storage",

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+authors = ["Ryan Bottriell <[email protected]>"]
+edition = "2021"
+name = "spk-cmd-make-recipe"
+version = "0.36.0"
+
+[dependencies]
+anyhow = "1.0"
+async-trait = "0.1"
+clap = { version = "3.2", features = ["derive", "env"] }
+spk-cli-common = { path = '../common' }
+spk-schema = { path = '../../spk-schema' }
+spk-schema-liquid = { path = '../../spk-schema/crates/liquid' }
+tracing = "0.1.35"

crates/spk-cli/cmd-make-recipe/Cargo.toml

@@ -0,0 +1,74 @@
+// Copyright (c) Sony Pictures Imageworks, et al.
+// SPDX-License-Identifier: Apache-2.0
+// https://github.com/imageworks/spk
+
+use std::sync::Arc;
+
+use anyhow::{Context, Result};
+use clap::Args;
+use spk_cli_common::{flags, CommandArgs, Run};
+use spk_schema::foundation::format::FormatOptionMap;
+use spk_schema::foundation::spec_ops::Named;
+use spk_schema::{SpecTemplate, Template, TemplateExt};
+
+/// Render a package spec template into a recipe
+///
+/// This is done automatically when building packages, but can
+/// be a useful debugging tool when writing package spec files.
+#[derive(Args)]
+#[clap(visible_aliases = &["mkrecipe", "mkr"])]
+pub struct MakeRecipe {
+    #[clap(flatten)]
+    pub options: flags::Options,
+
+    #[clap(short, long, global = true, parse(from_occurrences))]
+    pub verbose: u32,
+
+    /// The package spec file to render
+    #[clap(name = "SPEC_FILE")]
+    pub package: Option<String>,
+}
+
+impl CommandArgs for MakeRecipe {
+    // The important positional arg for a make-recipe is the package
+    fn get_positional_args(&self) -> Vec<String> {
+        match self.package.clone() {
+            Some(p) => vec![p],
+            None => vec![],
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Run for MakeRecipe {
+    async fn run(&mut self) -> Result<i32> {
+        let options = self.options.get_options()?;
+
+        let template = match flags::find_package_template(&self.package)? {
+            flags::FindPackageTemplateResult::NotFound(name) => {
+                Arc::new(SpecTemplate::from_file(name.as_ref())?)
+            }
+            res => {
+                let (_, template) = res.must_be_found();
+                template
+            }
+        };
+
+        tracing::info!("rendering template for {}", template.name());
+        tracing::info!("using options {}", options.format_option_map());
+        let rendered = spk_schema_liquid::render_template(template.source(), &options)
+            .context("Failed to render template")?;
+        print!("{rendered}");
+
+        match template.render(&options) {
+            Err(err) => {
+                tracing::error!("This template did not render into a valid spec {err}");
+                Ok(1)
+            }
+            Ok(_) => {
+                tracing::info!("Successfully rendered a valid spec");
+                Ok(0)
+            }
+        }
+    }
+}

crates/spk-cli/cmd-make-recipe/src/cmd_make_recipe.rs

@@ -0,0 +1,7 @@
+// Copyright (c) Sony Pictures Imageworks, et al.
+// SPDX-License-Identifier: Apache-2.0
+// https://github.com/imageworks/spk
+
+#![deny(unsafe_op_in_unsafe_fn)]
+
+pub mod cmd_make_recipe;

crates/spk-cli/cmd-make-recipe/src/lib.rs

@@ -25,6 +25,7 @@ spfs = { version = '0.34.6', path = "../spfs" }
 spk-schema-foundation = { path = "./crates/foundation" }
 spk-schema-ident = { path = "./crates/ident" }
 spk-schema-validators = { path = "./crates/validators" }
+spk-schema-liquid = { path = "./crates/liquid" }
 sys-info = "0.9.0"
 tempfile = "3.3"
 thiserror = "1.0"

crates/spk-schema/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+authors = ["Ryan Bottriell <[email protected]>"]
+edition = "2021"
+name = "spk-schema-liquid"
+version = "0.36.0"
+
+[features]
+migration-to-components = ["spk-schema-foundation/migration-to-components"]
+
+[dependencies]
+liquid = "0.26.0"
+liquid-core = "0.26.0"
+serde = "1.0"
+serde_json = "1.0"
+spk-schema-foundation = { path = "../foundation" }
+tracing = "0.1.35"
+
+[dev-dependencies]
+rstest = "0.15.0"

crates/spk-schema/crates/liquid/Cargo.toml

@@ -0,0 +1,73 @@
+// Copyright (c) Sony Pictures Imageworks, et al.
+// SPDX-License-Identifier: Apache-2.0
+// https://github.com/imageworks/spk
+
+use std::str::FromStr;
+
+use liquid::model::Scalar;
+use liquid::ValueView;
+use liquid_core::{
+    Display_filter,
+    Expression,
+    Filter,
+    FilterParameters,
+    FilterReflection,
+    FromFilterParameters,
+    ParseFilter,
+    Result,
+    Runtime,
+    Value,
+};
+use spk_schema_foundation::version::Version;
+use spk_schema_foundation::version_range::{Ranged, VersionFilter};
+
+#[cfg(test)]
+#[path = "./filter_compare_version_test.rs"]
+mod filter_compare_version_test;
+
+#[derive(Debug, FilterParameters)]
+struct CompareVersionArgs {
+    #[parameter(description = "The comparison operation to perform", arg_type = "str")]
+    operator: Expression,
+    #[parameter(
+        description = "The version to compare with, if not part of the operator string",
+        arg_type = "str"
+    )]
+    rhs: Option<Expression>,
+}
+
+#[derive(Clone, ParseFilter, FilterReflection)]
+#[filter(
+    name = "compare_version",
+    description = "Compares one version to another using spk ordering semantics",
+    parameters(CompareVersionArgs),
+    parsed(CompareVersionFilter)
+)]
+pub struct CompareVersion;
+
+#[derive(Debug, FromFilterParameters, Display_filter)]
+#[name = "compare_version"]
+struct CompareVersionFilter {
+    #[parameters]
+    args: CompareVersionArgs,
+}
+
+impl Filter for CompareVersionFilter {
+    fn evaluate(&self, input: &dyn ValueView, runtime: &dyn Runtime) -> Result<Value> {
+        let args = self.args.evaluate(runtime)?;
+        let input = input.as_scalar().ok_or_else(|| {
+            liquid::Error::with_msg("Expected a scalar value for filter 'compare_version'")
+        })?;
+        let lhs = Version::from_str(input.into_string().as_str())
+            .map_err(|err| liquid::Error::with_msg(err.to_string()))?;
+        let range_str = match &args.rhs {
+            None => args.operator.to_kstr().to_string(),
+            Some(rhs) => format!("{}{}", args.operator, rhs),
+        };
+        let range = VersionFilter::from_str(range_str.as_str())
+            .map_err(|err| liquid::Error::with_msg(err.to_string()))?;
+
+        let result = range.is_applicable(&lhs).is_ok();
+        Ok(Value::Scalar(Scalar::new(result).to_owned()))
+    }
+}

crates/spk-schema/crates/liquid/src/filter_compare_version.rs

@@ -0,0 +1,35 @@
+// Copyright (c) Sony Pictures Imageworks, et al.
+// SPDX-License-Identifier: Apache-2.0
+// https://github.com/imageworks/spk
+
+use rstest::rstest;
+use serde_json::json;
+
+#[rstest]
+fn test_template_rendering_version_range() {
+    // the compare_version helper should be useful in if blocks
+    // in order to render section based on version ranges
+
+    let options = json!({});
+    static TPL: &str = r#"
+{% default version = "1.2.3" %}
+{% assign use_new_download = version | compare_version: ">=1.0" %}
+pkg: package/{{ version }}
+sources:
+{%- if use_new_download %}
+  - git: https://downloads.testing/package/v{{ version }}
+{%- else %}
+  - git: https://olddownloads.testing/package/v{{ version }}
+{%- endif %}
+"#;
+    static EXPECTED: &str = r#"
+
+
+pkg: package/1.2.3
+sources:
+  - git: https://downloads.testing/package/v1.2.3
+"#;
+    let rendered =
+        crate::render_template(TPL, &options).expect("template should not fail to render");
+    assert_eq!(rendered, EXPECTED);
+}

crates/spk-schema/crates/liquid/src/filter_compare_version_test.rs

@@ -0,0 +1,82 @@
+// Copyright (c) Sony Pictures Imageworks, et al.
+// SPDX-License-Identifier: Apache-2.0
+// https://github.com/imageworks/spk
+
+use std::ops::Deref;
+use std::str::FromStr;
+
+use liquid::ValueView;
+use liquid_core::runtime::StackFrame;
+use liquid_core::{
+    Display_filter,
+    Expression,
+    Filter,
+    FilterParameters,
+    FilterReflection,
+    FromFilterParameters,
+    ParseFilter,
+    Result,
+    Runtime,
+    Value,
+};
+use spk_schema_foundation::version::Version;
+
+#[cfg(test)]
+#[path = "./filter_parse_version_test.rs"]
+mod filter_parse_version_test;
+
+#[derive(Debug, FilterParameters)]
+struct ParseVersionArgs {
+    #[parameter(description = "An optional sub-component to access", arg_type = "str")]
+    path: Option<Expression>,
+}
+
+#[derive(Clone, ParseFilter, FilterReflection)]
+#[filter(
+    name = "parse_version",
+    description = "Parses an spk version, outputting one or all components",
+    parameters(ParseVersionArgs),
+    parsed(ParseVersionFilter)
+)]
+pub struct ParseVersion;
+
+#[derive(Debug, FromFilterParameters, Display_filter)]
+#[name = "parse_version"]
+struct ParseVersionFilter {
+    #[parameters]
+    args: ParseVersionArgs,
+}
+
+impl Filter for ParseVersionFilter {
+    fn evaluate(&self, input: &dyn ValueView, runtime: &dyn Runtime) -> Result<Value> {
+        let input = input.as_scalar().ok_or_else(|| {
+            liquid::Error::with_msg("Expected a scalar value for filter 'parse_version'")
+        })?;
+        let version = Version::from_str(input.into_string().as_str())
+            .map_err(|err| liquid::Error::with_msg(err.to_string()))?;
+
+        let data = liquid::object!({
+            "major": version.major(),
+            "minor": version.minor(),
+            "patch": version.patch(),
+            "base": version.base(),
+            "parts": version.parts.parts,
+            "plus_epsilon": version.parts.plus_epsilon,
+            "pre": version.pre.deref(),
+            "post": version.post.deref(),
+        });
+
+        if let Some(path) = &self.args.path {
+            if matches!(path, Expression::Literal(..)) {
+                return Err(liquid::Error::with_msg(
+                    "parse_version expected a path to evaluate, but found a literal value",
+                ));
+            }
+            let rt = StackFrame::new(runtime, data);
+            let value = path.evaluate(&rt)?;
+            Ok(value.into_owned())
+        } else {
+            Ok(data.into())
+        }
+    }
+}