app args and configuration handle revised

3 files changed, 82 insertions, 54 deletions

diff --git a/main.go b/main.go
index 788d72c..0a8b5b3 100644
--- a/main.go
+++ b/main.go
@@ -1,35 +1,31 @@
 package main
 
 import (
-	"os"
-
 	"github.com/isacikgoz/gitbatch/pkg/app"
 	log "github.com/sirupsen/logrus"
 	"gopkg.in/alecthomas/kingpin.v2"
 )
 
 var (
-	// take this as default directory if user does not start app with -d flag
-	currentDir, err = os.Getwd()
-	dirs            = kingpin.Flag("directory", "Directory to roam for git repositories").Default(currentDir).Short('d').Strings()
-	ignoreConfig    = kingpin.Flag("ignore-config", "Ignore config file").Short('i').Bool()
-	recurseDepth    = kingpin.Flag("recursive-depth", "Find directories recursively").Default("1").Short('r').Int()
-	logLevel        = kingpin.Flag("log-level", "Logging level; trace,debug,info,warn,error").Default("error").Short('l').String()
-	quick           = kingpin.Flag("quick", "runs without gui and fetches/pull remote upstream. modes are fetch or pull").Short('q').String()
+	dirs         = kingpin.Flag("directory", "Directory(s) to roam for git repositories.").Short('d').Strings()
+	mode         = kingpin.Flag("mode", "Application start mode, more sensible with quick run.").Short('m').String()
+	recurseDepth = kingpin.Flag("recursive-depth", "Find directories recursively.").Default("0").Short('r').Int()
+	logLevel     = kingpin.Flag("log-level", "Logging level; trace,debug,info,warn,error").Default("error").Short('l').String()
+	quick        = kingpin.Flag("quick", "runs without gui and fetches/pull remote upstream.").Short('q').Bool()
 )
 
 func main() {
-	kingpin.Version("gitbatch version 0.1.0 (alpha)")
+	kingpin.Version("gitbatch version 0.1.1 (alpha)")
 	// parse the command line flag and options
 	kingpin.Parse()
 
 	// set the app
-	app, err := app.Setup(app.SetupConfig{
-		Directories:  *dirs,
-		LogLevel:     *logLevel,
-		IgnoreConfig: *ignoreConfig,
-		Depth:        *recurseDepth,
-		QuickMode:    *quick,
+	app, err := app.Setup(&app.SetupConfig{
+		Directories: *dirs,
+		LogLevel:    *logLevel,
+		Depth:       *recurseDepth,
+		QuickMode:   *quick,
+		Mode:        *mode,
 	})
 	if err != nil {
 		log.Fatal(err)
diff --git a/pkg/app/app.go b/pkg/app/app.go
index 9bceee2..9c9e9a7 100644
--- a/pkg/app/app.go
+++ b/pkg/app/app.go
@@ -1,6 +1,8 @@
 package app
 
 import (
+	"os"
+
 	"github.com/isacikgoz/gitbatch/pkg/gui"
 	log "github.com/sirupsen/logrus"
 )
@@ -9,51 +11,48 @@ import (
 // it has only the gui.Gui pointer for interface entity.
 type App struct {
 	Gui    *gui.Gui
-	Config *Config
+	Config *SetupConfig
 }
 
 // SetupConfig is an assembler data to initiate a setup
 type SetupConfig struct {
-	Directories  []string
-	LogLevel     string
-	IgnoreConfig bool
-	Depth        int
-	QuickMode    string
+	Directories []string
+	LogLevel    string
+	Depth       int
+	QuickMode   bool
+	Mode        string
 }
 
 // Setup will handle pre-required operations. It is designed to be a wrapper for
 // main method right now.
-func Setup(setupConfig SetupConfig) (*App, error) {
+func Setup(setupConfig *SetupConfig) (*App, error) {
 	// initiate the app and give it initial values
 	app := &App{}
-	setLogLevel(setupConfig.LogLevel)
-	var err error
-	app.Config, err = LoadConfiguration()
-	if err != nil {
-		// the error types and handling is not considered yer
-		log.Error(err)
-		return app, err
+	if len(setupConfig.Directories) <= 0 {
+		d, _ := os.Getwd()
+		setupConfig.Directories = []string{d}
 	}
-	var directories []string
 
-	if len(app.Config.Directories) <= 0 || setupConfig.IgnoreConfig {
-		directories = generateDirectories(setupConfig.Directories, setupConfig.Depth)
-	} else {
-		directories = generateDirectories(app.Config.Directories, setupConfig.Depth)
+	appConfig, err := overrideDefaults(setupConfig)
+	if err != nil {
+		return nil, err
 	}
 
-	if len(setupConfig.QuickMode) > 0 {
-		x := setupConfig.QuickMode == "fetch"
-		y := setupConfig.QuickMode == "pull"
+	setLogLevel(appConfig.LogLevel)
+	directories := generateDirectories(appConfig.Directories, appConfig.Depth)
+
+	if appConfig.QuickMode {
+		x := appConfig.Mode == "fetch"
+		y := appConfig.Mode == "pull"
 		if x == y {
-			log.Fatal("Unrecognized quick mode: " + setupConfig.QuickMode)
+			log.Fatal("Unrecognized quick mode: " + appConfig.Mode)
 		}
-		quick(directories, setupConfig.Depth, setupConfig.QuickMode)
+		quick(directories, appConfig.Depth, appConfig.Mode)
 		log.Fatal("Finished")
 	}
 
 	// create a gui.Gui struct and set it as App's gui
-	app.Gui, err = gui.NewGui(app.Config.Mode, directories)
+	app.Gui, err = gui.NewGui(appConfig.Mode, directories)
 	if err != nil {
 		// the error types and handling is not considered yer
 		log.Error(err)
@@ -90,3 +89,23 @@ func setLogLevel(logLevel string) {
 		"level": logLevel,
 	}).Trace("logging level has been set")
 }
+
+func overrideDefaults(setupConfig *SetupConfig) (appConfig *SetupConfig, err error) {
+	appConfig, err = LoadConfiguration()
+	if len(setupConfig.Directories) > 0 {
+		appConfig.Directories = setupConfig.Directories
+	}
+	if len(setupConfig.LogLevel) > 0 {
+		appConfig.LogLevel = setupConfig.LogLevel
+	}
+	if setupConfig.Depth > 0 {
+		appConfig.Depth = setupConfig.Depth
+	}
+	if setupConfig.QuickMode {
+		appConfig.QuickMode = setupConfig.QuickMode
+	}
+	if len(setupConfig.Mode) > 0 {
+		appConfig.Mode = setupConfig.Mode
+	}
+	return appConfig, err
+}
diff --git a/pkg/app/config.go b/pkg/app/config.go
index b613532..57c2e6e 100644
--- a/pkg/app/config.go
+++ b/pkg/app/config.go
@@ -9,12 +9,6 @@ import (
 	"github.com/spf13/viper"
 )
 
-// Config type is the configuration entity of the application
-type Config struct {
-	Mode        string
-	Directories []string
-}
-
 // config file stuff
 var (
 	configFileName = "config"
@@ -28,14 +22,20 @@ var (
 
 // configuration items
 var (
-	modeKey         = "mode"
-	modeKeyDefault  = "fetch"
-	pathsKey        = "paths"
-	pathsKeyDefault = []string{"."}
+	modeKey             = "mode"
+	modeKeyDefault      = "fetch"
+	pathsKey            = "paths"
+	pathsKeyDefault     = []string{"."}
+	logLevelKey         = "loglevel"
+	logLevelKeyDefault  = "error"
+	qucikKey            = "quick"
+	qucikKeyDefault     = false
+	recursionKey        = "recursion"
+	recursionKeyDefault = 1
 )
 
 // LoadConfiguration returns a Config struct is filled
-func LoadConfiguration() (*Config, error) {
+func LoadConfiguration() (*SetupConfig, error) {
 	if err := initializeConfigurationManager(); err != nil {
 		return nil, err
 	}
@@ -45,15 +45,28 @@ func LoadConfiguration() (*Config, error) {
 	if err := readConfiguration(); err != nil {
 		return nil, err
 	}
-	config := &Config{
+	var directories []string
+	if len(viper.GetStringSlice(pathsKey)) <= 0 {
+		d, _ := os.Getwd()
+		directories = []string{d}
+	} else {
+		directories = viper.GetStringSlice(pathsKey)
+	}
+	config := &SetupConfig{
+		Directories: directories,
+		LogLevel:    viper.GetString(logLevelKey),
+		Depth:       viper.GetInt(recursionKey),
+		QuickMode:   viper.GetBool(qucikKey),
 		Mode:        viper.GetString(modeKey),
-		Directories: viper.GetStringSlice(pathsKey),
 	}
 	return config, nil
 }
 
 // set default configuration parameters
 func setDefaults() error {
+	viper.SetDefault(logLevelKey, logLevelKeyDefault)
+	viper.SetDefault(qucikKey, qucikKeyDefault)
+	viper.SetDefault(recursionKey, recursionKeyDefault)
 	viper.SetDefault(modeKey, modeKeyDefault)
 	// viper.SetDefault(pathsKey, pathsKeyDefault)
 	return nil