model: refactor Variable initialization

Use specific functions for building resolved and unresolved variables.

Author: davvid

src/cmds/init.rs

@@ -92,7 +92,7 @@ pub fn main(options: &cli::MainOptions, init_options: &mut InitOptions) -> Resul
     };
 
     let mut config = model::Configuration::new();
-    config.root = model::Variable::new(init_options.root.clone(), None);
+    config.root = model::Variable::from_expr(init_options.root.clone());
     config.root_path.clone_from(&dirname);
     config.path = Some(config_path.clone());
 

src/config/reader.rs

@@ -125,15 +125,15 @@ fn parse_recursive(
     // Provide GARDEN_ROOT.
     config.variables.insert(
         string!(constants::GARDEN_ROOT),
-        model::Variable::new(config.root.get_expr().to_string(), None),
+        model::Variable::from_expr(config.root.get_expr().to_string()),
     );
 
     if let Some(config_path_raw) = config.dirname.as_ref() {
         // Calculate an absolute path for GARDEN_CONFIG_DIR.
         if let Ok(config_path) = path::canonicalize(config_path_raw) {
             config.variables.insert(
                 string!(constants::GARDEN_CONFIG_DIR),
-                model::Variable::new(config_path.to_string_lossy().to_string(), None),
+                model::Variable::from_expr(config_path.to_string_lossy().to_string()),
             );
         }
     }
@@ -377,7 +377,7 @@ fn get_indexset_str(yaml: &Yaml, values: &mut StringSet) -> bool {
 /// Construct a model::Variable from a ran YAML object.
 fn variable_from_yaml(yaml: &Yaml) -> Option<model::Variable> {
     match yaml {
-        Yaml::String(yaml_str) => Some(model::Variable::new(yaml_str.to_string(), None)),
+        Yaml::String(yaml_str) => Some(model::Variable::from_expr(yaml_str.to_string())),
         Yaml::Array(yaml_array) => {
             // If we see an array we loop over so that the first value wins.
             for array_value in yaml_array.iter().rev() {
@@ -390,16 +390,13 @@ fn variable_from_yaml(yaml: &Yaml) -> Option<model::Variable> {
             // Integers are already resolved.
             let int_value = yaml_int.to_string();
 
-            Some(model::Variable::new(int_value.to_string(), Some(int_value)))
+            Some(model::Variable::from_resolved_expr(int_value))
         }
         Yaml::Boolean(yaml_bool) => {
             // Booleans are already resolved.
             let bool_value = syntax::bool_to_string(*yaml_bool);
 
-            Some(model::Variable::new(
-                bool_value.to_string(),
-                Some(bool_value),
-            ))
+            Some(model::Variable::from_resolved_expr(bool_value))
         }
         _ => {
             // dump_node(yaml, 1, "");
@@ -567,7 +564,7 @@ fn get_template(
             template
                 .tree
                 .remotes
-                .insert(string!(constants::ORIGIN), model::Variable::new(url, None));
+                .insert(string!(constants::ORIGIN), model::Variable::from_expr(url));
             return template;
         }
         // If a `<url>` is configured then populate the "origin" remote.
@@ -576,7 +573,7 @@ fn get_template(
             template
                 .tree
                 .remotes
-                .insert(string!(constants::ORIGIN), model::Variable::new(url, None));
+                .insert(string!(constants::ORIGIN), model::Variable::from_expr(url));
         }
     }
 
@@ -675,7 +672,7 @@ fn get_tree_from_url(name: &Yaml, url: &str) -> model::Tree {
     }
     tree.remotes.insert(
         string!(constants::ORIGIN),
-        model::Variable::new(url.to_string(), None),
+        model::Variable::from_expr(url.to_string()),
     );
 
     tree
@@ -709,7 +706,7 @@ fn get_tree_fields(value: &Yaml, tree: &mut model::Tree) {
         if get_str(&value[constants::URL], &mut url) {
             tree.remotes.insert(
                 tree.default_remote.to_string(),
-                model::Variable::new(url, None),
+                model::Variable::from_expr(url),
             );
         }
     }
@@ -806,7 +803,7 @@ fn get_str_variables_map(yaml: &Yaml, remotes: &mut model::VariableMap) {
         if let (Some(name_str), Some(value_str)) = (name.as_str(), value.as_str()) {
             remotes.insert(
                 name_str.to_string(),
-                model::Variable::new(value_str.to_string(), None),
+                model::Variable::from_expr(value_str.to_string()),
             );
         }
     }

src/model.rs

@@ -69,10 +69,20 @@ impl Clone for Variable {
 }
 
 impl Variable {
-    pub(crate) fn new(expr: String, value: Option<String>) -> Self {
+    /// Create an un-evaluated variable from an expression string.
+    pub(crate) fn from_expr(expr: String) -> Self {
         Variable {
             expr,
-            value: UnsafeCell::new(value),
+            value: UnsafeCell::new(None),
+            evaluating: Cell::new(false),
+        }
+    }
+
+    /// Create a resolved variable from a string that is both the expression and value.
+    pub(crate) fn from_resolved_expr(expr: String) -> Self {
+        Variable {
+            expr: expr.clone(),
+            value: UnsafeCell::new(Some(expr)),
             evaluating: Cell::new(false),
         }
     }
@@ -278,13 +288,13 @@ impl Tree {
     pub(crate) fn add_builtin_variables(&mut self) {
         self.variables.insert(
             string!(constants::TREE_NAME),
-            Variable::new(self.get_name().clone(), None),
+            Variable::from_expr(self.get_name().clone()),
         );
 
         // Register the ${TREE_PATH} variable.
         self.variables.insert(
             string!(constants::TREE_PATH),
-            Variable::new(self.get_path().get_expr().clone(), None),
+            Variable::from_expr(self.get_path().get_expr().clone()),
         );
     }
 
@@ -783,7 +793,7 @@ impl Configuration {
                 }
                 _ => {
                     self.override_variables
-                        .insert(name, Variable::new(expr, None));
+                        .insert(name, Variable::from_expr(expr));
                 }
             }
         }
@@ -795,7 +805,7 @@ impl Configuration {
         let quiet_string = if self.quiet || quiet { "--quiet" } else { "" }.to_string();
         self.variables.insert(
             string!(constants::GARDEN_CMD_QUIET),
-            Variable::new(quiet_string.clone(), Some(quiet_string)),
+            Variable::from_resolved_expr(quiet_string),
         );
         let verbose = self.verbose + verbose;
         let verbose_string = if verbose > 0 {
@@ -805,7 +815,7 @@ impl Configuration {
         };
         self.variables.insert(
             string!(constants::GARDEN_CMD_VERBOSE),
-            Variable::new(verbose_string.clone(), Some(verbose_string)),
+            Variable::from_resolved_expr(verbose_string),
         );
     }