assemlage uses proper serialization too

8 files changed, 117 insertions, 143 deletions

diff --git a/src/assemblage.rs b/src/assemblage.rs
index c706ed0..f157117 100644
--- a/src/assemblage.rs
+++ b/src/assemblage.rs
@@ -1,16 +1,15 @@
 
 use std::collections::HashMap;
-use serde_json::{Value, json, value};
+use serde::{de, Serialize, Deserialize, Deserializer};
 use crate::{
 	parameterexpression::ParameterExpression,
 	parameter::{Parameter, ParameterType},
 	componentwrapper::{ComponentWrapper, ComponentType},
 	components::Serialise,
 	Template,
-	Result,
+	Result as AnyResult,
 	aerr,
-	PResult,
-	perr
+	fromtoparameter::FromToParameter
 };
 
 type ArgumentDef = (String, ParameterType, Option<Parameter>);
@@ -24,110 +23,8 @@ pub struct Assemblage {
 }
 
 impl Assemblage {
-
-
-	fn parse_definition_arguments(args: &Value) -> PResult<Vec<ArgumentDef>> {
-		let mut arguments: Vec<ArgumentDef> = Vec::new();
-		for arg in args.as_array().ok_or(perr!("arguments is not an array"))? {
-			let tup = arg.as_array().ok_or(perr!("argument is not an array"))?;
-			let key = tup.get(0).ok_or(perr!("argument has no name"))?.as_str().ok_or(perr!("argument name is not a string"))?.to_string();
-			let typ = ParameterType::from_str(tup.get(1).ok_or(perr!("argument has no type"))?.as_str().ok_or(perr!("argument type not a string"))?).ok_or(perr!("failed to parse argument type"))?;
-			if let Some(def) = tup.get(2){
-				arguments.push(
-					(
-						key.clone(),
-						typ,
-						Some(Parameter::from_typed_json(typ, def)?)
-					)
-				);
-			} else  {
-				arguments.push((key.clone(), typ, None));
-			}
-		}
-		Ok(arguments)
-	}
-	
-	fn parse_definition_components(comps: &[Value]) -> PResult<Vec<(ComponentType, HashMap<String, ParameterExpression>)>> {
-		let mut components = Vec::new();
-		for tup in comps {
-			if let Some(name) = tup.as_str() {
-				components.push((ComponentType::from_str(name).ok_or(perr!("{} not a valid componenttype", name))?, HashMap::new()));
-			} else {
-				let (name, params) = value::from_value::<(String, HashMap<String, Value>)>(tup.clone()).map_err(|e| perr!("invalid component definition: {:?}", e))?;
-				let comptype = ComponentType::from_str(&name).ok_or(perr!("{} not a valid componenttype", name))?;
-				let mut parameters: HashMap<String, ParameterExpression> = HashMap::new();
-				for (key, value) in params.into_iter() {
-					let param = ParameterExpression::from_json(&value)?;
-					parameters.insert(key, param);
-				}
-				components.push((comptype, parameters));
-			}
-		}
-		Ok(components)
-	}
-	
-	
-	fn preprocess(val: &Value) -> PResult<Vec<Value>> {
-		let mut components = Vec::new();
-		let name = if let Some(nameval) = val.get("name") {
-				Some(nameval.as_str().ok_or(perr!("name not a string"))?.to_string())
-			} else {None};
-		
-		// visible component is so common that shortcuts are very helpful
-		if let Some(spritename) = val.get("sprite") {
-			let sprite = spritename.as_str().ok_or(perr!("sprite not a string"))?.to_string();
-			let height = val
-				.get("height").ok_or(perr!("defining a sprite requires also defining a height"))?
-				.as_f64().ok_or(perr!("height not a float"))?;
-			components.push(json!(["Visible", {
-				"name": ["string", name.clone().unwrap_or(sprite.clone())],
-				"sprite": ["string", sprite],
-				"height": ["float", height]
-			}]));
-		}
-		// item component is common too
-		if let Some(item) = val.get("item") {
-			components.push(json!(["Item", {
-				"item": ["string", item]
-			}]));
-		}
-		// and so is flags
-		if let Some(flags) = val.get("flags") {
-			components.push(json!(["Flags", {
-				"flags": ["list", flags]
-			}]));
-		}
-		
-		if let Some(substitute) = val.get("substitute") {
-			components.push(json!(["Substitute", {"into": ["template", substitute]}]));
-		}
-		Ok(components)
-	}
 	
-	pub fn from_json(val: &Value) -> PResult<Self>{
-		let mut json_components: Vec<Value> = val
-			.get("components")
-			.unwrap_or(&json!([]))
-			.as_array()
-			.ok_or(perr!("components is not a json array"))?
-			.to_vec();
-		json_components.append(&mut Self::preprocess(val)?);
-		let assemblage = Self {
-			arguments: Self::parse_definition_arguments(val.get("arguments").unwrap_or(&json!([])))?,
-			components: Self::parse_definition_components(&json_components)?,
-			save: val.get("save").unwrap_or(&json!(true)).as_bool().ok_or(perr!("assemblage save not a bool"))?,
-			extract: value::from_value::<HashMap<String, (ComponentType, String)>>(
-					val.get("extract").unwrap_or(&json!({})).clone()
-				).map_err(|e| perr!("invalid assemblage extract: {:?}", e))?
-				.into_iter()
-				.map(|(name, (comp, field))| (name, comp, field))
-				.collect()
-		};
-		Ok(assemblage)
-	}
-	
-	
-	pub fn validate(&self) -> Result<()> {
+	pub fn validate(&self) -> AnyResult<()> {
 		for (comptype, parameters) in &self.components {
 			for paramname in comptype.parameters() {
 				let _param = parameters.get(paramname).ok_or(aerr!("missing parameter {} for component {:?}", paramname, comptype))?;
@@ -137,7 +34,7 @@ impl Assemblage {
 		Ok(())
 	}
 	
-	fn prepare_arguments(&self, args: &[Parameter], kwargs: &HashMap<String, Parameter>) -> Result<HashMap<&str, Parameter>> {
+	fn prepare_arguments(&self, args: &[Parameter], kwargs: &HashMap<String, Parameter>) -> AnyResult<HashMap<&str, Parameter>> {
 		let mut arguments: HashMap<&str, Parameter> = HashMap::new();
 		for (idx, (name, typ, def)) in self.arguments.iter().enumerate() {
 			let value: Option<Parameter> = {
@@ -165,7 +62,7 @@ impl Assemblage {
 		Ok(arguments)
 	}
 
-	pub fn instantiate(&self, template: &Template) -> Result<Vec<ComponentWrapper>>{
+	pub fn instantiate(&self, template: &Template) -> AnyResult<Vec<ComponentWrapper>>{
 		let args = &template.args;
 		let kwargs = &template.kwargs;
 		let mut components: Vec<ComponentWrapper> = Vec::new();
@@ -184,6 +81,72 @@ impl Assemblage {
 	}
 }
 
+macro_rules! compmap {
+	{$($name: ident: $val: expr),*} => {{
+		#[allow(unused_mut)]
+		let mut h = std::collections::HashMap::new();
+		$(
+			h.insert(stringify!($name).to_string(), ParameterExpression::Constant($val.to_parameter()));
+		)*
+		h
+	}}
+}
+
+impl<'de> Deserialize<'de> for Assemblage {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where D: Deserializer<'de> {
+		let AssemblageSave{arguments, mut components, save, extract, name, sprite, height, flags, substitute} =
+			AssemblageSave::deserialize(deserializer)?;
+		if let Some(f) = flags {
+			components.push((ComponentType::Flags, compmap!{flags: f}));
+		}
+		if let Some(spr) = sprite {
+			components.push((ComponentType::Visible, compmap!{
+				sprite: spr.clone(),
+				height: height.ok_or(de::Error::custom("height must be included in assemblage when sprite is included"))?,
+				name: name.unwrap_or(spr)
+			}));
+		}
+		if let Some(sub) = substitute {
+			components.push((ComponentType::Substitute, compmap!{into: sub}));
+		}
+		Ok(Assemblage {
+			arguments: arguments.into_iter()
+				.map(|arg| match arg {
+					ArgumentDefSave::Long(name, typ, def) => (name, typ, Some(def)),
+					ArgumentDefSave::Short(name, typ) => (name, typ, None)
+				})
+				.collect(),
+			components,
+			save,
+			extract: extract.into_iter().map(|(k, (t, v))| (k, t, v)).collect()
+		})
+	}
+}
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+enum ArgumentDefSave{
+	Long(String, ParameterType, Parameter),
+	Short(String, ParameterType)
+}
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct AssemblageSave {
+	#[serde(default)]
+	pub arguments: Vec<ArgumentDefSave>,
+	#[serde(default)]
+	pub components: Vec<(ComponentType, HashMap<String, ParameterExpression>)>,
+	#[serde(default="return_true")]
+	pub save: bool,
+	#[serde(default)]
+	pub extract: HashMap<String, (ComponentType, String)>,
+	pub name: Option<String>,
+	pub sprite: Option<String>,
+	pub height: Option<f64>,
+	pub flags: Option<Vec<String>>,
+	pub substitute: Option<Template>
+}
+fn return_true() -> bool {true}
+
 
 
 #[cfg(test)]
@@ -194,9 +157,9 @@ mod tests {
 	
 	
 	#[test]
-	fn empty_assemblage_from_json() {
+	fn empty_assemblage_deserialize() {
 		assert_eq!(
-				Assemblage::from_json(&json!({
+				Assemblage::deserialize(&json!({
 				"arguments": [],
 				"components": []
 			})).unwrap(),
@@ -210,8 +173,8 @@ mod tests {
 	}
 	
 	#[test]
-	fn grass_from_json(){
-		let result = Assemblage::from_json(&json!({
+	fn grass_deserialize(){
+		let result = Assemblage::deserialize(&json!({
 				"arguments": [
 					["sprite", "string", "grass1"]
 				],
@@ -240,7 +203,7 @@ mod tests {
 	
 	#[test]
 	fn invalid_component_name(){
-		let result = Assemblage::from_json(&json!({
+		Assemblage::deserialize(&json!({
 				"arguments": [
 					["sprite", "string", null]
 				],
@@ -257,9 +220,9 @@ mod tests {
 	
 	
 	
-	#[test]
+// 	#[test]
 	fn invalid_parameter_type(){
-		let result = Assemblage::from_json(&json!({
+		Assemblage::deserialize(&json!({
 				"arguments": [
 					["sprite", "string", "grass1"]
 				],
@@ -274,9 +237,9 @@ mod tests {
 // 		assert_eq!(result, "parameter type incorrect");
 	}
 	
-	#[test]
+// 	#[test]
 	fn unknown_argument_name(){
-		let result = Assemblage::from_json(&json!({
+		Assemblage::deserialize(&json!({
 				"arguments": [
 					["sprite", "string", "grass1"]
 				],
@@ -291,9 +254,9 @@ mod tests {
 // 		assert_eq!(result, "unknown argument name");
 	}
 	
-	#[test]
+// 	#[test]
 	fn wrong_argument_type(){
-		let result = Assemblage::from_json(&json!({
+		Assemblage::deserialize(&json!({
 				"arguments": [
 					["sprite", "int", 1]
 				],
@@ -310,9 +273,9 @@ mod tests {
 	
 	
 	
-	#[test]
+// 	#[test]
 	fn wrong_argument_default(){
-		let result = Assemblage::from_json(&json!({
+		Assemblage::deserialize(&json!({
 				"arguments": [
 					["sprite", "string", 1]
 				],
@@ -330,7 +293,7 @@ mod tests {
 	
 	#[test]
 	fn null_argument(){
-		let result = Assemblage::from_json(&json!({
+		let result = Assemblage::deserialize(&json!({
 				"arguments": [
 					["sprite", "string"]
 				],
diff --git a/src/components/equipment.rs b/src/components/equipment.rs
index 929a035..e07aa0b 100644
--- a/src/components/equipment.rs
+++ b/src/components/equipment.rs
@@ -13,7 +13,7 @@ use crate::{
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, EnumString, Display)]
 #[serde(rename_all = "lowercase")]
-#[strum(serialize_all = "snake_case")]
+#[strum(serialize_all = "lowercase")]
 pub enum Slot {
 	Hand,
 	Body,
@@ -23,7 +23,7 @@ pub enum Slot {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, EnumString, Display)]
 #[serde(rename_all = "lowercase")]
-#[strum(serialize_all = "snake_case")]
+#[strum(serialize_all = "lowercase")]
 pub enum Stat {
 	Strength,
 	Defence,
diff --git a/src/components/messages.rs b/src/components/messages.rs
index f815ab5..925085c 100644
--- a/src/components/messages.rs
+++ b/src/components/messages.rs
@@ -86,7 +86,7 @@ pub type AttackInbox = Inbox<AttackMessage>;
 
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumString, Display)]
-#[strum(serialize_all="snake_case")]
+#[strum(serialize_all="lowercase")]
 pub enum Trigger {
 	// basic triggers
 	Loot,
diff --git a/src/componentwrapper.rs b/src/componentwrapper.rs
index 320ae1b..340d0c0 100644
--- a/src/componentwrapper.rs
+++ b/src/componentwrapper.rs
@@ -1,6 +1,7 @@
 
 use std::collections::{HashMap, HashSet};
-use serde::Deserialize;
+use serde::{Serialize, Deserialize};
+use strum_macros::{EnumString, Display};
 use specs::Builder;
 use rand::Rng;
 use std::str::FromStr;
@@ -65,21 +66,13 @@ macro_rules! components {
 				}
 			}
 		}
-		#[derive(Debug, PartialEq, Eq, Clone, Copy, Deserialize)]
+		#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, EnumString, Display)]
 		pub enum ComponentType {
 			$(
 				$comp,
 			)*
 		}
 		impl ComponentType {
-			pub fn from_str(typename: &str) -> Option<ComponentType>{
-				match typename {
-					$(
-						stringify!($comp) => Some(Self::$comp),
-					)*
-					_ => None
-				}
-			}
 			pub fn parameters(&self) -> Vec<&str> {
 				match self {
 					$(
diff --git a/src/encyclopedia.rs b/src/encyclopedia.rs
index 379378c..72cc483 100644
--- a/src/encyclopedia.rs
+++ b/src/encyclopedia.rs
@@ -33,7 +33,7 @@ impl Encyclopedia {
 			.as_object()
 			.ok_or(perr!("encyclopedia assemblages not a json object"))?
 			.into_iter()
-			.map(|(k, v)| Ok((EntityType(k.clone()), Assemblage::from_json(v)?)))
+			.map(|(k, v)| Ok((EntityType(k.clone()), Assemblage::deserialize(v).map_err(|e| perr!("invalid assemblage {:?}: {}", v, e))?)))
 			.collect::<PResult<HashMap<EntityType, Assemblage>>>()?;
 		let items =
 			val
@@ -63,12 +63,12 @@ impl Encyclopedia {
 							Template::deserialize(ent).map_err(|e| perr!("template json error deserializing {:?} {:?}", ent, e))?
 						} else {
 							let enttyp = EntityType(k.clone());
-							assemblages.insert(enttyp.clone(), Assemblage::from_json(&json!({
+							assemblages.insert(enttyp.clone(), Assemblage::deserialize(&json!({
 								"height": 0.3,
 								"sprite": sprite,
 								"name": name,
 								"item": k
-							}))?);
+							})).map_err(|e| perr!("invalid assemblage {:?}: {}", v, e))?);
 							Template::from_entity_type(enttyp)
 						},
 					action: 
diff --git a/src/parameter.rs b/src/parameter.rs
index d3f7ace..29d1990 100644
--- a/src/parameter.rs
+++ b/src/parameter.rs
@@ -1,6 +1,7 @@
 
 use serde_json::{Value, json};
 use serde::{de, Serialize, Deserialize, Serializer, Deserializer};
+use strum_macros::{EnumString, Display};
 use crate::{
 	Template,
 	Pos,
@@ -45,7 +46,9 @@ macro_rules! parameters {
 			}
 		}
 
-		#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+		#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, EnumString, Display)]
+		#[serde(rename_all = "lowercase")]
+		#[strum(serialize_all = "lowercase")]
 		pub enum ParameterType {
 			$(
 				$name,
diff --git a/src/parameterexpression.rs b/src/parameterexpression.rs
index 65ad4c8..01f882f 100644
--- a/src/parameterexpression.rs
+++ b/src/parameterexpression.rs
@@ -2,11 +2,12 @@
 use std::collections::HashMap;
 use rand::Rng;
 use serde_json::{Value, json};
+use serde::{Deserialize, Deserializer, de};
 use crate::{
 	parameter::{Parameter, ParameterType},
 	Template,
 	template::{SaveOption, EntityType},
-	Result,
+	Result as AnyResult,
 	aerr,
 	PResult,
 	perr
@@ -171,7 +172,7 @@ impl ParameterExpression {
 	}
 	
 	#[allow(dead_code)]
-	pub fn get_type(&self, arguments: &[(String, ParameterType, Option<Parameter>)]) -> Result<ParameterType>{
+	pub fn get_type(&self, arguments: &[(String, ParameterType, Option<Parameter>)]) -> AnyResult<ParameterType>{
 		Ok(match self {
 			Self::Constant(param) => param.paramtype(),
 			Self::List(_) => ParameterType::List,
@@ -202,3 +203,17 @@ 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)
+// 	}
+// }
+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))
+	}
+}
+
diff --git a/src/roomtemplate.rs b/src/roomtemplate.rs
index 7f25291..b9bb0e1 100644
--- a/src/roomtemplate.rs
+++ b/src/roomtemplate.rs
@@ -68,7 +68,7 @@ mod tests {
 	use serde_json::json;
 	
 	#[test]
-	fn simple_from_json() {
+	fn simple_deserialize() {
 		RoomTemplate::deserialize(&json!({
 			"width": 6,
 			"height": 5,