Shorten var names to comply with line len reqs

diff --git a/src/config/config_type.rs b/src/config/config_type.rs
index 4c2e4c3d5bb6d5901624e188554feb939bed72c2..0dcd377bffd3f0ee37babe3a14993b0807cd3d38 100644 (file)
--- a/src/config/config_type.rs
+++ b/src/config/config_type.rs
@@ -393,34 +393,34 @@ fn set_heuristics(&mut self) {
 
             fn set_license_template(&mut self) {
                 if self.was_set().license_template_path() {
-                    let license_template_path = self.license_template_path();
-                    let mut license_template_file = match File::open(&license_template_path) {
+                    let lt_path = self.license_template_path();
+                    let mut lt_file = match File::open(&lt_path) {
                         Ok(file) => file,
                         Err(e) => {
                             eprintln!("Warning: unable to open license template file {:?}: {}",
-                                      license_template_path, e);
+                                      lt_path, e);
                             return;
                         }
                     };
-                    let mut license_template_str = String::new();
-                    if let Err(e) = license_template_file.read_to_string(&mut license_template_str) {
+                    let mut lt_str = String::new();
+                    if let Err(e) = lt_file.read_to_string(&mut lt_str) {
                         eprintln!("Warning: unable to read from license template file {:?}: {}",
-                                  license_template_path, e);
+                                  lt_path, e);
                         return;
                     };
-                    let license_template_parsed = match TemplateParser::parse(&license_template_str) {
+                    let lt_parsed = match TemplateParser::parse(&lt_str) {
                         Ok(string) => string,
                         Err(e) => {
                             eprintln!("Warning: unable to parse license template file {:?}: {}",
-                                      license_template_path, e);
+                                      lt_path, e);
                             return;
                         }
                     };
-                    self.license_template = match Regex::new(&license_template_parsed) {
+                    self.license_template = match Regex::new(&lt_parsed) {
                         Ok(re) => Some(re),
                         Err(e) => {
                             eprintln!("Warning: regex syntax error in placeholder, unable to compile \
-                                       license template from file {:?}: {}", license_template_path, e);
+                                       license template from file {:?}: {}", lt_path, e);
                             return;
                         }
                     }