Migrated controls to boltdb

cmd/controls.go

@@ -2,15 +2,16 @@ package cmd
 
 import (
 	"fmt"
+	"github.com/HakShak/sanemame/db"
+	"github.com/HakShak/sanemame/mamexml"
+	"github.com/boltdb/bolt"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	"log"
 	"os"
 	"text/tabwriter"
-
-	"github.com/spf13/cobra"
 )
 
-import "github.com/HakShak/sanemame/mamexml"
-
 // controlsCmd represents the controls command
 var controlsCmd = &cobra.Command{
 	Use:   "controls",
@@ -42,33 +43,22 @@ Cobra is a CLI library for Go that empowers applications.
 This application is a tool to generate the needed files
 to quickly create a Cobra application.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		controls, err := mamexml.LoadControlsXml("controls.xml")
+		dbPath := viper.GetString(DatabaseLocation)
+		boltDb, err := bolt.Open(dbPath, 0600, nil)
 		if err != nil {
 			log.Fatal(err)
 		}
+		defer boltDb.Close()
 
-		controlList := make(map[string]map[string]bool)
-
-		for _, game := range controls {
-			for _, player := range game.PlayerControls {
-				for _, control := range player.Controls {
-					if _, ok := controlList[control.Constant.Name]; !ok {
-						controlList[control.Constant.Name] = make(map[string]bool)
-					}
-					controlList[control.Constant.Name][control.Name] = true
-				}
-			}
-		}
+		controls := db.GetControlNames(boltDb)
 
 		tw := new(tabwriter.Writer)
 		tw.Init(os.Stdout, 0, 0, 2, ' ', 0)
-		fmt.Fprintln(tw, "Keyword\tDescription")
-		fmt.Fprintln(tw, "-------\t-----------")
+		fmt.Fprintln(tw, "Keyword\tNames")
+		fmt.Fprintln(tw, "-------\t-----")
 
-		for keyword, descriptions := range controlList {
-			for description, _ := range descriptions {
-				fmt.Fprintf(tw, "%s\t%v\n", keyword, description)
-			}
+		for control, desc := range controls {
+			fmt.Fprintf(tw, "%s\t%s\n", control, desc)
 		}
 
 		fmt.Fprintln(tw)

cmd/initdb.go

@@ -28,6 +28,7 @@ to quickly create a Cobra application.`,
 		defer boltDb.Close()
 
 		db.UpdateCategories(boltDb, "Catver.ini")
+		db.UpdateControls(boltDb, "controls.xml")
 	},
 }
 

db/categories.go

@@ -50,20 +50,5 @@ func UpdateCategories(db *bolt.DB, fileName string) {
 }
 
 func GetCategories(db *bolt.DB) []string {
-	var result []string
-	err := db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(CategoryMachines))
-
-		bucket.ForEach(func(k, v []byte) error {
-			result = append(result, string(k))
-			return nil
-		})
-
-		return nil
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	return result
+	return GetAllKeys(db, CategoryMachines)
 }

db/controls.go

@@ -0,0 +1,92 @@
+package db
+
+import (
+	"encoding/json"
+	"github.com/HakShak/sanemame/mamexml"
+	"github.com/boltdb/bolt"
+	"log"
+)
+
+const ControlMachines = "control-machines"
+const ControlNames = "control-names"
+
+func checkList(list []string, key string) bool {
+	for _, check := range list {
+		if check == key {
+			return true
+		}
+	}
+	return false
+}
+
+func UpdateControls(db *bolt.DB, fileName string) {
+	controls, err := mamexml.LoadControlsXml(fileName)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	controlNames := make(map[string][]string)
+	controlMachines := make(map[string][]string)
+
+	for machine, controls := range controls {
+		for _, control := range mamexml.GetControlsNames(controls) {
+			if !checkList(controlNames[control.Name], control.Description) {
+				controlNames[control.Name] = append(controlNames[control.Name], control.Description)
+			}
+
+			controlMachines[control.Name] = append(controlMachines[control.Name], machine)
+		}
+	}
+
+	err = db.Update(func(tx *bolt.Tx) error {
+		bucket, err := tx.CreateBucketIfNotExists([]byte(ControlNames))
+		if err != nil {
+			return err
+		}
+
+		for controlKey, nameList := range controlNames {
+			nameListBytes, err := json.Marshal(nameList)
+			if err != nil {
+				return err
+			}
+			err = bucket.Put([]byte(controlKey), nameListBytes)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.Update(func(tx *bolt.Tx) error {
+		bucket, err := tx.CreateBucketIfNotExists([]byte(ControlMachines))
+		if err != nil {
+			return err
+		}
+
+		for controlKey, machineList := range controlMachines {
+			machineListBytes, err := json.Marshal(machineList)
+			if err != nil {
+				return err
+			}
+			err = bucket.Put([]byte(controlKey), machineListBytes)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func GetControls(db *bolt.DB) []string {
+	return GetAllKeys(db, ControlNames)
+}
+
+func GetControlNames(db *bolt.DB) map[string]string {
+	return GetAll(db, ControlNames)
+}

db/db.go

@@ -0,0 +1,44 @@
+package db
+
+import (
+	"github.com/boltdb/bolt"
+	"log"
+)
+
+func GetAllKeys(db *bolt.DB, bucket string) []string {
+	var result []string
+	err := db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucket))
+
+		bucket.ForEach(func(k, v []byte) error {
+			result = append(result, string(k))
+			return nil
+		})
+
+		return nil
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return result
+}
+
+func GetAll(db *bolt.DB, bucket string) map[string]string {
+	result := make(map[string]string)
+	err := db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucket))
+
+		bucket.ForEach(func(k, v []byte) error {
+			result[string(k)] = string(v)
+			return nil
+		})
+
+		return nil
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return result
+}

mamexml/controls.go

@@ -10,6 +10,11 @@ import (
 
 import "gopkg.in/cheggaaa/pb.v1"
 
+type ControlsName struct {
+	Name        string
+	Description string
+}
+
 type ControlsConstant struct {
 	Name string `xml:"name,attr"`
 }
@@ -35,6 +40,16 @@ type ControlsGame struct {
 	PlayerControls []ControlsPlayer `xml:"player"`
 }
 
+func GetControlsNames(controlGame ControlsGame) []ControlsName {
+	var result []ControlsName
+	for _, playerControl := range controlGame.PlayerControls {
+		for _, control := range playerControl.Controls {
+			result = append(result, ControlsName{control.Constant.Name, control.Name})
+		}
+	}
+	return result
+}
+
 func LoadControlsXml(filename string) (map[string]ControlsGame, error) {
 	log.Printf("Loading %s", filename)
 	file, err := os.Open(filename)