summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/assemblage.rs63
-rw-r--r--src/errors.rs20
-rw-r--r--src/fromtoparameter.rs11
-rw-r--r--src/item.rs11
-rw-r--r--src/main.rs2
-rw-r--r--src/parameter.rs114
-rw-r--r--src/parameterexpression.rs179
-rw-r--r--src/template.rs15
8 files changed, 143 insertions, 272 deletions
diff --git a/src/assemblage.rs b/src/assemblage.rs
index e4554eb..9911c77 100644
--- a/src/assemblage.rs
+++ b/src/assemblage.rs
@@ -181,9 +181,9 @@ mod tests {
],
"components": [
["Visible", {
- "sprite": ["arg", "sprite"],
- "height": ["float", 0.1],
- "name": ["string", "grass"]
+ "sprite": {"$arg": "sprite"},
+ "height": 0.1,
+ "name": "grass"
}]
]
})).unwrap();
@@ -210,9 +210,9 @@ mod tests {
],
"components": [
["visible", { // no capital so invalid
- "sprite": ["A", "sprite"],
- "height": ["float", 0.1],
- "name": ["string", "grass"]
+ "sprite": {"$arg": "sprite"},
+ "height": 0.1,
+ "name": "grass"
}]
]
})).unwrap_err();
@@ -229,48 +229,15 @@ mod tests {
],
"components": [
["Visible", {
- "sprite": ["A", "sprite"],
- "height": ["string", "0.1"],
- "name": ["string", "grass"]
+ "sprite": {"$arg": "sprite"},
+ "height": "0.1",
+ "name": "grass"
}]
]
})).unwrap_err();
// assert_eq!(result, "parameter type incorrect");
}
-// #[test]
- fn unknown_argument_name(){
- Assemblage::deserialize(&json!({
- "arguments": [
- ["sprite", "string", "grass1"]
- ],
- "components": [
- ["Visible", {
- "sprite": ["A", "sprits"],
- "height": ["float", 0.1],
- "name": ["string", "grass"]
- }]
- ]
- })).unwrap_err();
-// assert_eq!(result, "unknown argument name");
- }
-
-// #[test]
- fn wrong_argument_type(){
- Assemblage::deserialize(&json!({
- "arguments": [
- ["sprite", "int", 1]
- ],
- "components": [
- ["Visible", {
- "sprite": ["A", "sprite"],
- "height": ["float", 0.1],
- "name": ["string", "grass"]
- }]
- ]
- })).unwrap_err();
-// assert_eq!(result, "parameter type incorrect");
- }
@@ -282,9 +249,9 @@ mod tests {
],
"components": [
["Visible", {
- "sprite": ["A", "sprite"],
- "height": ["float", 0.1],
- "name": ["string", "grass"]
+ "sprite": {"$arg": "sprite"},
+ "height": 0.1,
+ "name": "grass"
}]
]
})).unwrap_err();
@@ -300,9 +267,9 @@ mod tests {
],
"components": [
["Visible", {
- "sprite": ["arg", "sprite"],
- "height": ["float", 0.1],
- "name": ["arg", "sprite"]
+ "sprite": {"$arg": "sprite"},
+ "height": 0.1,
+ "name": {"$arg": "sprite"}
}]
]
})).unwrap();
diff --git a/src/errors.rs b/src/errors.rs
index 294159c..c58f2ff 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -25,23 +25,3 @@ macro_rules! aerr {
}
-
-#[derive(Debug)]
-pub struct ParseError {
- pub text: String
-}
-impl Error for ParseError {
- fn source(&self) -> Option<&(dyn Error + 'static)> {
- None
- }
-}
-impl Display for ParseError {
- fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
- write!(f, "Error: {}", self.text)
- }
-}
-#[macro_export]
-macro_rules! perr {
- ($($description:tt)*) => {crate::errors::ParseError{text: format!($($description)*)}}
-}
-pub type PResult<T> = std::result::Result<T, ParseError>;
diff --git a/src/fromtoparameter.rs b/src/fromtoparameter.rs
index 8d169d0..13483d7 100644
--- a/src/fromtoparameter.rs
+++ b/src/fromtoparameter.rs
@@ -76,7 +76,6 @@ tofrom!(i64: Int);
tofrom!(f64: Float);
tofrom!(bool:Bool);
tofrom!(String: String);
-tofrom!(Pos: Pos);
tofrom!(Template: Template);
tofrom!(PlayerId(String));
@@ -177,3 +176,13 @@ where
Parameter::List(vec![self.0.to_parameter(), self.1.to_parameter(), self.2.to_parameter()])
}
}
+
+impl FromToParameter for Pos {
+ fn from_parameter(p: Parameter) -> Option<Self>{
+ let (x, y) = <(i64, i64)>::from_parameter(p)?;
+ Some(Self{x, y})
+ }
+ fn to_parameter(self) -> Parameter {
+ (self.x, self.y).to_parameter()
+ }
+}
diff --git a/src/item.rs b/src/item.rs
index 37ee4f2..c8337f9 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -1,7 +1,6 @@
use std::collections::HashSet;
-use std::str::FromStr;
use serde;
use serde::{Deserialize, Serialize};
use crate::{
@@ -9,8 +8,7 @@ use crate::{
components::{
Flag,
equipment::Equippable
- },
- errors::{ParseError}
+ }
};
@@ -18,13 +16,6 @@ use crate::{
#[derive(Debug, Default, PartialEq, Eq, Clone, Hash, Serialize, Deserialize)]
pub struct ItemId(pub String);
-impl FromStr for ItemId {
- type Err = ParseError;
- fn from_str(s: &str) -> Result<Self, Self::Err> {
- Ok(Self(s.to_string()))
- }
-}
-
#[derive(Debug, Clone)]
pub struct Item {
pub ent: Template,
diff --git a/src/main.rs b/src/main.rs
index 6cd0f24..2176801 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -45,7 +45,7 @@ use self::{
playerid::PlayerId,
roomid::RoomId,
item::ItemId,
- errors::{Result, PResult},
+ errors::{Result},
sprite::Sprite,
template::Template,
encyclopedia::Encyclopedia,
diff --git a/src/parameter.rs b/src/parameter.rs
index 29d1990..be846a1 100644
--- a/src/parameter.rs
+++ b/src/parameter.rs
@@ -1,35 +1,22 @@
-use serde_json::{Value, json};
-use serde::{de, Serialize, Deserialize, Serializer, Deserializer};
+use serde::{Serialize, Deserialize};
use strum_macros::{EnumString, Display};
use crate::{
Template,
- Pos,
- PResult,
- perr
};
macro_rules! parameters {
- ($($name: ident ($typ: ty) $stringname: ident, $v: ident ($fromjson: expr) ($tojson: expr));*;) => {
- #[derive(Debug, PartialEq, Clone)]
+ {$($name: ident $typ: ty);*;} => {
+ #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+ #[serde(untagged)]
pub enum Parameter {
$(
$name($typ),
)*
}
impl Parameter {
- pub fn from_typed_json(typ: ParameterType, val: &Value) -> PResult<Parameter>{
- match typ {
- $(
- ParameterType::$name => Ok(Self::$name({
- let $v = val;
- $fromjson
- })),
- )*
- }
- }
pub fn paramtype(&self) -> ParameterType {
match self {
$(
@@ -37,13 +24,6 @@ macro_rules! parameters {
)*
}
}
- pub fn to_json(&self) -> Value {
- match self {
- $(
- Self::$name($v) => $tojson,
- )*
- }
- }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, EnumString, Display)]
@@ -54,36 +34,17 @@ macro_rules! parameters {
$name,
)*
}
- impl ParameterType {
- pub fn from_str(typename: &str) -> Option<Self>{
- match typename {
- $(
- stringify!($stringname) => Some(Self::$name),
- )*
- _ => None
- }
- }
- }
}
}
-parameters!(
- String (String) string, v (v.as_str().ok_or(perr!("{:?} not a string", v))?.to_string()) (json!(v));
- Int (i64) int, v (v.as_i64().ok_or(perr!("{:?} not an int", v))?) (json!(v));
- Pos (Pos) pos, v (Pos::deserialize(v).map_err(|e| perr!("{:?} not a pos {}", v, e))?) (json!(v));
- Float (f64) float, v (v.as_f64().ok_or(perr!("{:?} not an float", v))?) (json!(v));
- Template (Template) template, v (Template::deserialize(v).map_err(|e| perr!("template json error {:?}", e))?) (json!(["template", v]));
- Bool (bool) bool, v (v.as_bool().ok_or(perr!("{:?} not a bool", v))?) (json!(v));
- List (Vec<Parameter>) list, v
- ({
- v
- .as_array().ok_or(perr!("{:?} not an array", v))?
- .iter()
- .map(|item| Parameter::guess_from_json(item))
- .collect::<PResult<Vec<Parameter>>>()?
- })
- (json!(["list", v.iter().map(Parameter::to_json).collect::<Vec<Value>>()]));
-);
+parameters!{
+ String String;
+ Int i64;
+ Float f64;
+ Template Template;
+ Bool bool;
+ List Vec<Parameter>;
+}
impl Parameter {
@@ -92,58 +53,21 @@ impl Parameter {
Self::String(string.to_string())
}
- pub fn guess_from_json(val: &Value) -> PResult<Parameter> {
- if let Some(arr) = val.as_array() {
- if arr.len() == 2 && arr[0].is_string() {
- let typestr = arr[0].as_str().unwrap();
- let typ = ParameterType::from_str(typestr).ok_or(perr!("invalid parameter type {}", typestr))?;
- return Self::from_typed_json(typ, &arr[1]);
- }
- }
- let typ =
- if val.is_string() {
- ParameterType::String
- } else if val.is_u64() || val.is_i64() {
- ParameterType::Int
- } else if val.is_f64() {
- ParameterType::Float
- } else if val.is_boolean(){
- ParameterType::Bool
- } else if val.is_object(){
- ParameterType::Template
- } else {
- return Err(perr!("can't guess the type of parameter {:?}", val));
- };
- Self::from_typed_json(typ, val)
- }
}
-impl Serialize for Parameter {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer {
- self.to_json().serialize(serializer)
- }
-}
-impl<'de> Deserialize<'de> for Parameter {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where D: Deserializer<'de> {
- Self::guess_from_json(&Value::deserialize(deserializer)?).map_err(|e| de::Error::custom(e.text))
- }
-}
-
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
macro_rules! gfj { // guess from json
- ($($j:tt)*) => {Parameter::guess_from_json(&json!($($j)*)).unwrap()}
+ ($($j:tt)*) => {Parameter::deserialize(&json!($($j)*)).unwrap()}
}
#[test]
fn can_guess_json() {
- Parameter::guess_from_json(&json!(3)).unwrap();
+ Parameter::deserialize(&json!(3)).unwrap();
}
#[test]
@@ -162,19 +86,19 @@ mod tests {
assert_eq!(gfj!(-0.0), Parameter::Float(0.0));
assert_eq!(gfj!(true), Parameter::Bool(true));
- assert_eq!(gfj!(["int", 3]), Parameter::Int(3));
+ assert_eq!(gfj!(["int", 3]), Parameter::List(vec![Parameter::string("int"), Parameter::Int(3)]));
+ assert_eq!(gfj!([2, 5]), Parameter::List(vec![Parameter::Int(2), Parameter::Int(5)]));
}
#[test]
fn guess_json_none() {
- assert!(Parameter::guess_from_json(&json!([2, 5])).is_err());
- assert!(Parameter::guess_from_json(&json!({"hello": "world"})).is_err());
+ assert!(Parameter::deserialize(&json!({"hello": "world"})).is_err());
}
#[test]
fn parse_list() {
assert_eq!(
- gfj!(["list", [5, 3, 1, 2]]),
+ gfj!([5, 3, 1, 2]),
Parameter::List(vec![
Parameter::Int(5),
Parameter::Int(3),
@@ -183,7 +107,7 @@ mod tests {
])
);
assert_eq!(
- gfj!(["list", [5, 3.0, "Hello", true]]),
+ gfj!([5, 3.0, "Hello", true]),
Parameter::List(vec![
Parameter::Int(5),
Parameter::Float(3.0),
diff --git a/src/parameterexpression.rs b/src/parameterexpression.rs
index b92613a..2db52ef 100644
--- a/src/parameterexpression.rs
+++ b/src/parameterexpression.rs
@@ -1,16 +1,13 @@
use std::collections::HashMap;
use rand::Rng;
-use serde_json::{Value, json};
-use serde::{Deserialize, Deserializer, de};
+use serde::{Deserialize, Deserializer};
use crate::{
parameter::{Parameter, ParameterType},
Template,
template::{EntityType},
Result as AnyResult,
aerr,
- PResult,
- perr
};
const MAX_NESTING: usize = 5;
@@ -21,7 +18,7 @@ pub enum ParameterExpression {
Constant(Parameter),
List(Vec<ParameterExpression>),
#[allow(dead_code)] // rustc bug does not know that this variant is used: https://github.com/rust-lang/rust/issues/68408
- Template{name: EntityType, kwargs: HashMap<String, ParameterExpression>, save: Option<bool>},
+ Template{name: EntityType, kwargs: HashMap<String, ParameterExpression>, save: Option<bool>, clan: Option<String>},
Argument(String),
Random(Vec<ParameterExpression>),
Concat(Vec<ParameterExpression>),
@@ -47,7 +44,7 @@ impl ParameterExpression {
Self::List(values) => {
Some(Parameter::List(values.iter().map(|v| v.evaluate_(arguments, template, nesting+1)).collect::<Option<Vec<Parameter>>>()?))
}
- Self::Template{name, kwargs, save} => {
+ Self::Template{name, kwargs, save, clan} => {
Some(Parameter::Template(Template{
name: name.clone(),
save: *save,
@@ -57,7 +54,7 @@ impl ParameterExpression {
|(k, v)|
Some((k.clone(), v.evaluate_(arguments, template, nesting+1)?)))
.collect::<Option<HashMap<String, Parameter>>>()?,
- clan: None
+ clan: clan.clone()
}))
}
Self::Argument(argname) => {
@@ -95,88 +92,12 @@ impl ParameterExpression {
}
}
- pub fn from_json(value: &Value) -> PResult<Self> {
- if !value.is_array() {
- return Ok(Self::Constant(Parameter::guess_from_json(value)?));
- }
- let paramvalue = value.get(1).ok_or(perr!("index 1 not in component parameter"))?;
- let typename = value.get(0).ok_or(perr!("index 0 not in component parameter"))?.as_str().ok_or(perr!("compparam type not a string"))?;
- match typename {
- "string" | "int" | "float" | "bool" | "pos" => {
- let paramtype = ParameterType::from_str(typename).expect(&format!("unknown parameter type {:?}", typename));
- Ok(Self::Constant(Parameter::from_typed_json(paramtype, paramvalue)?))
- }
- "list" => {
- let values = paramvalue.as_array().ok_or(perr!("random argument not an array"))?;
- let mut entries = Vec::new();
- for entry in values {
- entries.push(Self::from_json(entry)?)
- }
- Ok(Self::List(entries))
- }
- "template" => {
- match paramvalue {
- Value::String(s) => Ok(Self::Template{
- name: EntityType(s.clone()),
- kwargs: HashMap::new(),
- save: None
- }),
- Value::Object(o) => {
- let name = EntityType(o.get("type").ok_or(perr!("template doesn't have 'type'"))?.as_str().ok_or(perr!("template type not a string"))?.to_string());
- let mut kwargs = HashMap::new();
- for (key, arg) in o.get("kwargs").unwrap_or(&json!({})).as_object().ok_or(perr!("template kwargs not a json object"))? {
- kwargs.insert(key.to_string(), Self::from_json(arg)?);
- }
- let save = match o.get("save") {
- Some(Value::Bool(b)) if *b => Some(true),
- Some(Value::Bool(_b)) => Some(false),
- None => None,
- _ => {return Err(perr!("save not a bool"))}
- };
- Ok(Self::Template{name, kwargs, save})
- }
- _ => return Err(perr!("invalid template {:?}", paramvalue))
- }
- }
- "A" | "arg" => {
- let argname = paramvalue.as_str().ok_or(perr!("argument parameter not a string"))?.to_string();
- Ok(Self::Argument(argname))
- }
- "random" => {
- let optionvalues = paramvalue.as_array().ok_or(perr!("random argument not an array"))?;
- let mut options = Vec::new();
- for option in optionvalues {
- options.push(Self::from_json(option)?)
- }
- Ok(Self::Random(options))
- }
- "concat" => {
- let values = paramvalue.as_array().ok_or(perr!("concat argument not an array"))?;
- let mut options = Vec::new();
- for option in values {
- options.push(Self::from_json(option)?)
- }
- Ok(Self::Concat(options))
- }
- "if" => {
- Ok(Self::If(
- Box::new(Self::from_json(paramvalue.get(0).ok_or(perr!("if does not have condition"))?)?),
- Box::new(Self::from_json(paramvalue.get(1).ok_or(perr!("if does not have then value"))?)?),
- Box::new(Self::from_json(paramvalue.get(2).ok_or(perr!("if does not have else value"))?)?)
- ))
- }
- "self" => Ok(Self::TemplateSelf),
- "name" => Ok(Self::TemplateName),
- _ => Err(perr!("unknown compparam type '{}'", typename))
- }
- }
-
#[allow(dead_code)]
pub fn get_type(&self, arguments: &[(String, ParameterType, Option<Parameter>)]) -> AnyResult<ParameterType>{
Ok(match self {
Self::Constant(param) => param.paramtype(),
Self::List(_) => ParameterType::List,
- Self::Template{name: _, kwargs: _, save: _} => ParameterType::Template,
+ Self::Template{name: _, kwargs: _, save: _, clan: _} => ParameterType::Template,
Self::Argument(argname) => arguments.iter().find(|(n, _t, _d)| n == argname).ok_or(aerr!("unknown argument name {} in {:?}", argname, arguments))?.1,
Self::Random(options) => {
let typ: ParameterType = options.get(0).ok_or(aerr!("random has no options"))?.get_type(arguments)?;
@@ -204,16 +125,57 @@ impl ParameterExpression {
}
}
-// impl Serialize for ParameterExpression {
-// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-// where S: Serializer {
-// self.to_json().serialize(serializer)
-// }
-// }
+
+#[derive(Debug, PartialEq, Clone, Deserialize)]
+enum DynamicParameterExpressionSave {
+ #[serde(rename = "$arg")]
+ Argument(String),
+ #[serde(rename = "$random")]
+ Random(Vec<ParameterExpression>),
+ #[serde(rename = "$concat")]
+ Concat(Vec<ParameterExpression>),
+ #[serde(rename = "$if")]
+ If(Box<ParameterExpression>, Box<ParameterExpression>, Box<ParameterExpression>),
+ #[serde(rename = "$self")]
+ TemplateSelf,
+ #[serde(rename = "$name")]
+ TemplateName
+}
+#[derive(Debug, PartialEq, Clone, Deserialize)]
+#[serde(untagged)]
+enum ParameterExpressionSave {
+ List(Vec<ParameterExpression>),
+ Template {
+ #[serde(rename = "$template")]
+ name: EntityType,
+ #[serde(rename="__save__", default, skip_serializing_if = "Option::is_none")]
+ save: Option<bool>,
+ #[serde(rename="__clan__", default, skip_serializing_if = "Option::is_none")]
+ clan: Option<String>,
+ #[serde(flatten)]
+ kwargs: HashMap<String, ParameterExpression>
+ },
+ Dynamic(DynamicParameterExpressionSave),
+ Constant(Parameter),
+}
+use ParameterExpressionSave as PES;
+use DynamicParameterExpressionSave as DPES;
+
impl<'de> Deserialize<'de> for ParameterExpression {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de> {
- Self::from_json(&Value::deserialize(deserializer)?).map_err(|e| de::Error::custom(e.text))
+ let save = ParameterExpressionSave::deserialize(deserializer)?;
+ Ok(match save {
+ PES::List(params) => Self::List(params),
+ PES::Template{name, save, clan, kwargs} => Self::Template{name, save, kwargs, clan},
+ PES::Dynamic(DPES::Argument(name)) => Self::Argument(name),
+ PES::Dynamic(DPES::Random(items)) => Self::Random(items),
+ PES::Dynamic(DPES::Concat(items)) => Self::Concat(items),
+ PES::Dynamic(DPES::If(condition, ifpart, elsepart)) => Self::If(condition, ifpart, elsepart),
+ PES::Dynamic(DPES::TemplateSelf) => Self::TemplateSelf,
+ PES::Dynamic(DPES::TemplateName) => Self::TemplateName,
+ PES::Constant(param) => Self::Constant(param)
+ })
}
}
@@ -222,6 +184,7 @@ mod tests {
use super::*;
use super::ParameterExpression as PE;
use crate::hashmap;
+ use serde_json::json;
#[test]
fn test_desrialize(){
@@ -230,22 +193,48 @@ mod tests {
PE::Constant(Parameter::String("hello".to_string()))
);
assert_eq!(
- PE::deserialize(json!(["arg", "hello"])).unwrap(),
+ PE::deserialize(json!({"$arg": "hello"})).unwrap(),
PE::Argument("hello".to_string())
);
assert_eq!(
- PE::deserialize(json!(["list", ["hello", 3]])).unwrap(),
+ PE::deserialize(json!(["hello", 3])).unwrap(),
PE::List(vec![
PE::Constant(Parameter::String("hello".to_string())),
PE::Constant(Parameter::Int(3))
])
);
+ }
+ #[test]
+ fn test_templates(){
assert_eq!(
- PE::deserialize(json!(["template", {"type": "radish", "kwargs": {"health": 10}}])).unwrap(),
+ PE::deserialize(json!({"$template": "radish", "health": 10})).unwrap(),
PE::Template{
name: EntityType("radish".to_string()),
kwargs: hashmap!{"health".to_string() => PE::Constant(Parameter::Int(10))},
- save: None
+ save: None,
+ clan: None
+ }
+ );
+ assert_eq!(
+ PE::deserialize(json!({":template": "radish", "health": 10})).unwrap(),
+ PE::Constant(Parameter::Template(Template{
+ name: EntityType("radish".to_string()),
+ kwargs: hashmap!{"health".to_string() => Parameter::Int(10)},
+ save: None,
+ clan: None
+ }))
+ );
+ assert_eq!(
+ PE::deserialize(json!({"$template": "radish", "health": {"$if": [{"$arg": "is_eldritch"}, 20, 3]}})).unwrap(),
+ PE::Template{
+ name: EntityType("radish".to_string()),
+ kwargs: hashmap!{"health".to_string() => PE::If(
+ Box::new(PE::Argument("is_eldritch".to_string())),
+ Box::new(PE::Constant(Parameter::Int(20))),
+ Box::new(PE::Constant(Parameter::Int(3)))
+ )},
+ save: None,
+ clan: None
}
);
}
diff --git a/src/template.rs b/src/template.rs
index 1ef6fc1..6eb27e1 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -23,6 +23,16 @@ enum TemplateSave {
save: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
clan: Option<String>
+ },
+ New{
+ #[serde(rename = ":template")]
+ name: EntityType,
+ #[serde(rename="__save__", default, skip_serializing_if = "Option::is_none")]
+ save: Option<bool>,
+ #[serde(rename="__clan__", default, skip_serializing_if = "Option::is_none")]
+ clan: Option<String>,
+ #[serde(default, flatten, skip_serializing_if = "HashMap::is_empty")]
+ kwargs: HashMap<String, Parameter>
}
}
@@ -40,7 +50,8 @@ impl From<TemplateSave> for Template {
fn from(ts: TemplateSave) -> Self {
match ts {
TemplateSave::Name(name) => Self{name, kwargs: HashMap::new(), save: None, clan: None},
- TemplateSave::Full{name, kwargs, save, clan} => Self{name, kwargs, save, clan}
+ TemplateSave::Full{name, kwargs, save, clan} => Self{name, kwargs, save, clan},
+ TemplateSave::New{name, kwargs, save, clan} => Self{name, kwargs, save, clan}
}
}
}
@@ -49,7 +60,7 @@ impl Into<TemplateSave> for Template {
if self.kwargs.is_empty() && self.save == None && self.clan == None {
return TemplateSave::Name(self.name);
}
- TemplateSave::Full {
+ TemplateSave::New {
name: self.name,
kwargs: self.kwargs,
save: self.save,
generated by cgit (git 2.34.1) at 2026-05-31 22:42:49 +0000