Fix replace feature

boilingcore/boilingcore.go

@@ -198,8 +198,7 @@ func (s *State) initTemplates() error {
 			return err
 		}
 
-		testMain := s.Config.DriverName + "_main.tpl"
-		s.TestMainTemplate, err = loadTemplate(nil, testMain, filepath.Join(basePath, templatesTestMainDirectory, testMain))
+		s.TestMainTemplate, err = loadTemplate(filepath.Join(basePath, templatesTestMainDirectory), s.Config.DriverName+"_main.tpl")
 		if err != nil {
 			return err
 		}
@@ -218,18 +217,21 @@ func (s *State) processReplacements() error {
 
 		toReplace, replaceWith := splits[0], splits[1]
 
+		toReplaceSplit := strings.Split(toReplace, string(filepath.Separator))
+		fileName := toReplaceSplit[len(toReplaceSplit)-1]
+
 		var err error
 		switch filepath.Dir(toReplace) {
 		case templatesDirectory:
-			_, err = loadTemplate(s.Templates.Template, toReplace, replaceWith)
+			err = replaceTemplate(s.Templates.Template, fileName, replaceWith)
 		case templatesSingletonDirectory:
-			_, err = loadTemplate(s.SingletonTemplates.Template, toReplace, replaceWith)
+			err = replaceTemplate(s.SingletonTemplates.Template, fileName, replaceWith)
 		case templatesTestDirectory:
-			_, err = loadTemplate(s.TestTemplates.Template, toReplace, replaceWith)
+			err = replaceTemplate(s.TestTemplates.Template, fileName, replaceWith)
 		case templatesSingletonTestDirectory:
-			_, err = loadTemplate(s.SingletonTestTemplates.Template, toReplace, replaceWith)
+			err = replaceTemplate(s.SingletonTestTemplates.Template, fileName, replaceWith)
 		case templatesTestMainDirectory:
-			s.TestMainTemplate, err = loadTemplate(nil, toReplace, replaceWith)
+			err = replaceTemplate(s.TestMainTemplate, fileName, replaceWith)
 		default:
 			return errors.Errorf("replace file's directory not part of any known folder: %s", toReplace)
 		}

boilingcore/templates.go

@@ -111,24 +111,35 @@ func loadTemplates(dir string) (*templateList, error) {
 	return &templateList{Template: tpl}, err
 }
 
-// loadTemplate loads a single template, uses tpl as a base template if provided
-// and creates a new base template if not.
-func loadTemplate(tpl *template.Template, name, filename string) (*template.Template, error) {
+// loadTemplate loads a single template file
+func loadTemplate(dir string, filename string) (*template.Template, error) {
+	pattern := filepath.Join(dir, filename)
+	tpl, err := template.New("").Funcs(templateFunctions).ParseFiles(pattern)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return tpl.Lookup(filename), err
+}
+
+// replaceTemplate finds the template matching with name and replaces its
+// contents with the contents of the template located at filename
+func replaceTemplate(tpl *template.Template, name, filename string) error {
+	if tpl == nil {
+		return fmt.Errorf("template for %s is nil", name)
+	}
+
 	b, err := ioutil.ReadFile(filename)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed reading template file: %s", filename)
+		return errors.Wrapf(err, "failed reading template file: %s", filename)
 	}
 
-	if tpl == nil {
-		tpl = template.New(name)
-	} else {
-		tpl = tpl.New(name)
-	}
-	if tpl, err = tpl.Funcs(templateFunctions).Parse(string(b)); err != nil {
-		return nil, errors.Wrapf(err, "failed to parse template file: %s", filename)
+	if tpl, err = tpl.New(name).Funcs(templateFunctions).Parse(string(b)); err != nil {
+		return errors.Wrapf(err, "failed to parse template file: %s", filename)
 	}
 
-	return tpl, nil
+	return nil
 }
 
 // set is to stop duplication from named enums, allowing a template loop