Merge pull request #45 from devrc-hub/feature/raw_variable_modifier

Feature/raw variable modifier

Author: Lispython

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "devrc"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Alex <hey.turbo.driver@gmail.com>"]
 description = "devrc is an easy to use task runner tool on steroids for developers"
 edition = "2018"

Cargo.toml

@@ -1,7 +1,7 @@
 
 variables:
   message: "Hello, $USER!"
-  message_1 +template: "Hello, $USER"
+  message_1 +raw: "Hello, $USER"
 
 environment:
   var_1: "env_var_1"

Devrcfile

@@ -1,11 +1,12 @@
 variables:
   first_name: "Alex"
   second_name: "Alice"
+  raw_var +raw: "Raw variable {{ task_variable_global }}"
 
 environment:
   ENV_NAME: "{{ second_name }}"
 
-task_name:
+first_task:
   desc: "Task description"
   variables:
     task_variable: "Task variable value"
@@ -23,3 +24,11 @@ second_task:
     var: "simple var"
   exec: |
     echo "Second task:  {{ task_variable_global }} "
+
+
+third_task:
+  desc: "Third task description"
+  variables:
+    local_var: "{{ raw_var }}"
+  exec: |
+    echo "Third task:  {{ raw_var }} "

examples/simple_demo.yml

@@ -50,7 +50,13 @@ impl Scope {
                 variables::ValueKind::None => return Err(DevrcError::EmptyVariable),
                 variables::ValueKind::String(inner) => {
                     let key = VariableKey::try_from(original_key.clone())?;
-                    let value = VariableValue::new(original_key, inner).with_render_value(self)?;
+
+                    let value: VariableValue = if key.raw {
+                        VariableValue::new(original_key, inner).as_raw()?
+                    } else {
+                        VariableValue::new(original_key, inner).with_render_value(self)?
+                    };
+
                     self.variables.insert(key.clone(), value.clone());
 
                     if key.set_global && self.parent.is_some() {

src/scope.rs

@@ -60,6 +60,7 @@ pub struct VariableKey {
     pub original: String,
     pub name: String,
     pub set_global: bool,
+    pub raw: bool,
 }
 
 // impl From<String> for VariableKey {
@@ -85,30 +86,40 @@ impl VariableKey {
 #[derive(Debug, Default, PartialEq, Eq, Hash, Clone)]
 pub struct VariableValue {
     pub name: String,
-    pub raw: String,
+    pub original: String,
     pub rendered: Option<String>,
+    pub raw: bool,
 }
 
 impl VariableValue {
     pub fn new(name: &str, raw: &str) -> Self {
         Self {
             name: name.to_owned(),
-            raw: raw.to_owned(),
+            original: raw.to_owned(),
             rendered: None,
+            raw: false,
         }
     }
 
     pub fn get_rendered_value(&self) -> String {
+        if self.raw {
+            return self.original.clone();
+        }
         self.rendered.clone().unwrap_or_default()
     }
 
     pub fn render_value(&mut self, name: &str, scope: &Scope) -> DevrcResult<()> {
-        self.rendered = Some(render_string(name, &self.raw, scope)?);
+        self.rendered = Some(render_string(name, &self.original, scope)?);
         Ok(())
     }
 
     pub fn with_render_value(mut self, scope: &Scope) -> DevrcResult<Self> {
-        self.rendered = Some(render_string(&self.name, &self.raw, scope)?);
+        self.rendered = Some(render_string(&self.name, &self.original, scope)?);
+        Ok(self)
+    }
+
+    pub fn as_raw(mut self) -> DevrcResult<Self> {
+        self.raw = true;
         Ok(self)
     }
 }

src/variables.rs

@@ -4,21 +4,25 @@ use crate::{
 };
 
 const GLOBAL_MODIFIER: &str = "+global";
+const RAW_MODIFIER: &str = "+raw";
 
 pub fn parse_key(value: &str) -> DevrcResult<VariableKey> {
-    let mut parts = value.splitn(2, |c| c == ' ' || c == '\t');
+    let mut parts = value.split(|c| c == ' ' || c == '\t');
 
     let name = parts.next().ok_or(DevrcError::InvalidVariableName)?;
 
     let mut key = VariableKey {
         original: value.to_string(),
         name: name.to_string(),
         set_global: false,
+        raw: false,
     };
 
-    if let Some(value) = parts.next() {
-        if value == GLOBAL_MODIFIER {
+    for part in parts {
+        if part == GLOBAL_MODIFIER {
             key.set_global = true;
+        } else if part == RAW_MODIFIER {
+            key.raw = true;
         } else {
             return Err(DevrcError::InvalidVariableModifier);
         }
@@ -34,12 +38,13 @@ mod tests {
 
     #[test]
     fn test_parse_variables_key_with_global() {
-        let result = parse_key("name +global").unwrap();
+        let result = parse_key("name +global +raw").unwrap();
 
         let control = VariableKey {
-            original: "name +global".to_string(),
+            original: "name +global +raw".to_string(),
             name: "name".to_string(),
             set_global: true,
+            raw: true,
         };
         assert_eq!(result, control);
     }
@@ -52,13 +57,14 @@ mod tests {
             original: "name".to_string(),
             name: "name".to_string(),
             set_global: false,
+            raw: false,
         };
         assert_eq!(result, control);
     }
 
     #[test]
     fn test_invalid_key() {
-        let result = parse_key("name +invalid");
+        let result = parse_key("name +invalid +global +raw");
 
         match result {
             Err(DevrcError::InvalidVariableModifier) => {}