added to_float

Author: togglebyte

CHANGES.md

@@ -1,6 +1,8 @@
 * 0.2.6
     * `Either` now works by doing truthiness checks on state
     * `Backend::full_screen()` convenience function
+    * `to_float` template function
+    * `PathBuf`s can now be used as templates
 * 0.2.5
     * BUGFIX: component reuse in if / else
     * `with` statement

anathema-templates/src/components.rs

@@ -29,13 +29,33 @@ pub trait ToSourceKind {
     }
 }
 
-impl<T: AsRef<str>> ToSourceKind for T {
+impl ToSourceKind for String {
     fn to_path(self) -> SourceKind {
-        SourceKind::Path(self.as_ref().into())
+        SourceKind::Path(self.into())
     }
 
     fn to_template(self) -> SourceKind {
-        SourceKind::Str(self.as_ref().into())
+        SourceKind::Str(self)
+    }
+}
+
+impl ToSourceKind for &str {
+    fn to_path(self) -> SourceKind {
+        SourceKind::Path(self.into())
+    }
+
+    fn to_template(self) -> SourceKind {
+        SourceKind::Str(self.into())
+    }
+}
+
+impl ToSourceKind for PathBuf {
+    fn to_path(self) -> SourceKind {
+        SourceKind::Path(self)
+    }
+
+    fn to_template(self) -> SourceKind {
+        panic!("PathBuf can not be a template, only a path to one")
     }
 }
 

anathema-value-resolver/src/functions/mod.rs

@@ -59,6 +59,7 @@ impl FunctionTable {
         inner.insert("to_lower".into(), Function::from(string::to_lower));
         inner.insert("to_str".into(), Function::from(string::to_str));
         inner.insert("to_int".into(), Function::from(number::to_int));
+        inner.insert("to_float".into(), Function::from(number::to_float));
         inner.insert("round".into(), Function::from(number::round));
         inner.insert("contains".into(), Function::from(list::contains));
         Self { inner }

anathema-value-resolver/src/functions/number.rs

@@ -30,6 +30,29 @@ pub(super) fn to_int<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
     }
 }
 
+pub(super) fn to_float<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
+    if args.len() != 1 {
+        return ValueKind::Null;
+    }
+
+    match &args[0] {
+        ValueKind::Int(i) => ValueKind::Float(*i as f64),
+        ValueKind::Float(f) => ValueKind::Float(*f),
+        ValueKind::Bool(b) if !b => ValueKind::Float(0.0),
+        ValueKind::Bool(_) => ValueKind::Float(1.0),
+        ValueKind::Char(c) => match c.to_digit(10) {
+            Some(i) => ValueKind::Float(i as f64),
+            None => ValueKind::Null,
+        },
+        ValueKind::Hex(hex) => ValueKind::Float(hex.as_u32() as f64),
+        ValueKind::Str(s) => match s.parse() {
+            Ok(i) => ValueKind::Float(i),
+            Err(_) => ValueKind::Null,
+        },
+        _ => ValueKind::Null,
+    }
+}
+
 pub(super) fn round<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
     if args.is_empty() || args.len() > 2 {
         return ValueKind::Null;