Add global extractors

parsing/match.go

@@ -1,13 +1,11 @@
 package parsing
 
-import (
-	"fmt"
-	"regexp"
-)
+import "regexp"
 
+// Match tries regular expressions from the given map on the file; it returns
+// the key of the first match
 func Match(file []byte, dict map[string]*regexp.Regexp) string {
 	for key, reg := range dict {
-		fmt.Printf("test %s", key)
 		if reg.Match(file) {
 			return key
 		}

parsing/parser.go

@@ -2,7 +2,6 @@ package parsing
 
 import (
 	"encoding/csv"
-	"fmt"
 	"io/ioutil"
 	"log"
 	"os"
@@ -11,6 +10,8 @@ import (
 	"github.com/spf13/viper"
 )
 
+// ParseAll parses all viper given parameters for all instances and saves them
+// to a CSV file
 func ParseAll(solvers []settings.Solver, instances []settings.Instance) {
 	params := viper.GetStringSlice("parameters")
 	if len(params) > 0 {
@@ -52,22 +53,24 @@ func persistantHeaders() []string {
 	return headers
 }
 
+// ParseParameter returns the parsed result of an Extraction for a given
+// instance if found.
 func ParseParameter(solver *settings.Solver, instance *settings.Instance,
 	parameter string) string {
-	fmt.Println(solver.Matchers)
-	var res string
 	if f, err := ioutil.ReadFile(instance.OutPath(solver.Name)); err != nil {
 		log.Printf("Unable to open file %s", instance.OutPath(solver.Name))
 	} else {
-		switch {
-		case (solver.Extractors[parameter] != nil):
-			res = Extract(f, solver.Extractors[parameter])
-		case (solver.LastExtractors[parameter] != nil):
-			res = ExtractLast(f, solver.LastExtractors[parameter])
-		case (solver.Matchers[parameter] != nil):
-			fmt.Println("do you see me?")
-			res = Match(f, solver.Matchers[parameter])
+		clusters := []*settings.ExtractionCluster{solver.Extractors, settings.GlobalExtractors()}
+		for _, c := range clusters {
+			switch {
+			case (c.Extractors[parameter] != nil):
+				return Extract(f, c.Extractors[parameter])
+			case (c.LastExtractors[parameter] != nil):
+				return ExtractLast(f, c.LastExtractors[parameter])
+			case (c.Matchers[parameter] != nil):
+				return Match(f, c.Matchers[parameter])
+			}
 		}
 	}
-	return res
+	return ""
 }

settings/extraction.go

@@ -0,0 +1,62 @@
+package settings
+
+import (
+	"fmt"
+	"log"
+	"regexp"
+
+	"github.com/spf13/viper"
+)
+
+type ExtractionCluster struct {
+	Extractors     map[string]*regexp.Regexp
+	LastExtractors map[string]*regexp.Regexp
+	Matchers       map[string]map[string]*regexp.Regexp
+}
+
+func ExtractorsFromViper(viperSpace string) *ExtractionCluster {
+	var cluster ExtractionCluster
+	if viperSpace != "" {
+		viperSpace += "."
+	}
+
+	cluster.Extractors = make(map[string]*regexp.Regexp)
+	for i, str := range viper.GetStringMapString(viperSpace + "extractors") {
+		reg, err := regexp.Compile(str)
+		if err != nil {
+			log.Panicf("Error compiling extractor `%s:%s`: %s",
+				viperSpace, i, err)
+		} else {
+			cluster.Extractors[i] = reg
+		}
+	}
+
+	cluster.LastExtractors = make(map[string]*regexp.Regexp)
+	for i, str := range viper.GetStringMapString(viperSpace + "last_extractors") {
+		reg, err := regexp.Compile(str)
+		if err != nil {
+			log.Panicf("Error compiling extractor `%s:%s`: %s",
+				viperSpace, i, err)
+		} else {
+			cluster.LastExtractors[i] = reg
+		}
+	}
+
+	cluster.Matchers = make(map[string]map[string]*regexp.Regexp)
+	for i := range viper.GetStringMap(viperSpace + "matchers") {
+		matcher := make(map[string]*regexp.Regexp)
+		for j, str := range viper.GetStringMapString(viperSpace + "matchers." + i) {
+			reg, err := regexp.Compile(str)
+			if err != nil {
+				log.Panicf("Error compiling match case `%s:%s:`: %s",
+					viperSpace, i, err)
+			} else {
+				matcher[j] = reg
+			}
+		}
+		fmt.Println(matcher)
+		cluster.Matchers[i] = matcher
+	}
+
+	return &cluster
+}

settings/general.go

@@ -0,0 +1,11 @@
+package settings
+
+var extractors *ExtractionCluster
+
+// GlobalExtractors returns the extractors defined on a global level
+func GlobalExtractors() *ExtractionCluster {
+	if extractors == nil {
+		extractors = ExtractorsFromViper("")
+	}
+	return extractors
+}

settings/solver.go

@@ -1,12 +1,6 @@
 package settings
 
-import (
-	"fmt"
-	"log"
-	"regexp"
-
-	"github.com/spf13/viper"
-)
+import "github.com/spf13/viper"
 
 // Solver contains all information regarding a FlatZinc solver and its output
 type Solver struct {
@@ -15,9 +9,7 @@ type Solver struct {
 	Globals string // Globals directory
 	Flags   string // FZN solver flags
 
-	Extractors     map[string]*regexp.Regexp
-	LastExtractors map[string]*regexp.Regexp
-	Matchers       map[string]map[string]*regexp.Regexp
+	Extractors *ExtractionCluster
 }
 
 // SolversFromViper extracts all solver information from Viper
@@ -38,43 +30,7 @@ func SolversFromViper() []Solver {
 			solver.Binary = solver.Name
 		}
 
-		solver.Extractors = make(map[string]*regexp.Regexp)
-		for i, str := range viper.GetStringMapString("solvers." + key + ".extractors") {
-			reg, err := regexp.Compile(str)
-			if err != nil {
-				log.Panicf("Error compiling extractor `%s:%s`: %s",
-					key, i, err)
-			} else {
-				solver.Extractors[i] = reg
-			}
-		}
-
-		solver.LastExtractors = make(map[string]*regexp.Regexp)
-		for i, str := range viper.GetStringMapString("solvers." + key + ".last_extractors") {
-			reg, err := regexp.Compile(str)
-			if err != nil {
-				log.Panicf("Error compiling extractor `%s:%s`: %s",
-					key, i, err)
-			} else {
-				solver.LastExtractors[i] = reg
-			}
-		}
-
-		solver.Matchers = make(map[string]map[string]*regexp.Regexp)
-		for i := range viper.GetStringMap("solvers." + key + ".matchers") {
-			matcher := make(map[string]*regexp.Regexp)
-			for j, str := range viper.GetStringMapString("solvers." + key + ".matchers." + i) {
-				reg, err := regexp.Compile(str)
-				if err != nil {
-					log.Panicf("Error compiling match case `%s:%s:`: %s",
-						key, i, err)
-				} else {
-					matcher[j] = reg
-				}
-			}
-			fmt.Println(matcher)
-			solver.Matchers[i] = matcher
-		}
+		solver.Extractors = ExtractorsFromViper("solvers." + key)
 
 		solvers = append(solvers, solver)
 	}