cmd/micro/settings.go

   1 package main
   2
   3 import (
   4         "encoding/json"
   5         "errors"
   6         "io/ioutil"
   7         "os"
   8         "reflect"
   9         "strconv"
  10 )
  11
  12 // The options that the user can set
  13 var settings map[string]interface{}
  14
  15 // InitSettings initializes the options map and sets all options to their default values
  16 func InitSettings() {
  17         defaults := DefaultSettings()
  18         var parsed map[string]interface{}
  19
  20         filename := configDir + "/settings.json"
  21         if _, e := os.Stat(filename); e == nil {
  22                 input, err := ioutil.ReadFile(filename)
  23                 if err != nil {
  24                         TermMessage("Error reading settings.json file: " + err.Error())
  25                         return
  26                 }
  27
  28                 err = json.Unmarshal(input, &parsed)
  29                 if err != nil {
  30                         TermMessage("Error reading settings.json:", err.Error())
  31                 }
  32         }
  33
  34         settings = make(map[string]interface{})
  35         for k, v := range defaults {
  36                 settings[k] = v
  37         }
  38         for k, v := range parsed {
  39                 settings[k] = v
  40         }
  41
  42         err := WriteSettings(filename)
  43         if err != nil {
  44                 TermMessage("Error writing settings.json file: " + err.Error())
  45         }
  46 }
  47
  48 // WriteSettings writes the settings to the specified filename as JSON
  49 func WriteSettings(filename string) error {
  50         var err error
  51         if _, e := os.Stat(configDir); e == nil {
  52                 txt, _ := json.MarshalIndent(settings, "", "    ")
  53                 err = ioutil.WriteFile(filename, txt, 0644)
  54         }
  55         return err
  56 }
  57
  58 // AddOption creates a new option. This is meant to be called by plugins to add options.
  59 func AddOption(name string, value interface{}) {
  60         settings[name] = value
  61         err := WriteSettings(configDir + "/settings.json")
  62         if err != nil {
  63                 TermMessage("Error writing settings.json file: " + err.Error())
  64         }
  65 }
  66
  67 // GetOption returns the specified option. This is meant to be called by plugins to add options.
  68 func GetOption(name string) interface{} {
  69         return settings[name]
  70 }
  71
  72 // DefaultSettings returns the default settings for micro
  73 func DefaultSettings() map[string]interface{} {
  74         return map[string]interface{}{
  75                 "autoindent":   true,
  76                 "colorscheme":  "monokai",
  77                 "cursorline":   false,
  78                 "ignorecase":   false,
  79                 "indentchar":   " ",
  80                 "ruler":        true,
  81                 "savecursor":   false,
  82                 "saveundo":     false,
  83                 "scrollspeed":  float64(2),
  84                 "scrollmargin": float64(3),
  85                 "statusline":   true,
  86                 "syntax":       true,
  87                 "tabsize":      float64(4),
  88                 "tabstospaces": false,
  89         }
  90 }
  91
  92 // SetOption attempts to set the given option to the value
  93 func SetOption(option, value string) error {
  94         if _, ok := settings[option]; !ok {
  95                 return errors.New("Invalid option")
  96         }
  97
  98         kind := reflect.TypeOf(settings[option]).Kind()
  99         if kind == reflect.Bool {
 100                 b, err := ParseBool(value)
 101                 if err != nil {
 102                         return errors.New("Invalid value")
 103                 }
 104                 settings[option] = b
 105         } else if kind == reflect.String {
 106                 settings[option] = value
 107         } else if kind == reflect.Float64 {
 108                 i, err := strconv.Atoi(value)
 109                 if err != nil {
 110                         return errors.New("Invalid value")
 111                 }
 112                 settings[option] = float64(i)
 113         }
 114
 115         if option == "colorscheme" {
 116                 LoadSyntaxFiles()
 117                 for _, tab := range tabs {
 118                         for _, view := range tab.views {
 119                                 view.Buf.UpdateRules()
 120                                 if settings["syntax"].(bool) {
 121                                         view.matches = Match(view)
 122                                 }
 123                         }
 124                 }
 125         }
 126
 127         if option == "statusline" {
 128                 for _, tab := range tabs {
 129                         for _, view := range tab.views {
 130                                 view.ToggleStatusLine()
 131                                 if settings["syntax"].(bool) {
 132                                         view.matches = Match(view)
 133                                 }
 134                         }
 135                 }
 136         }
 137
 138         return nil
 139 }
 140
 141 // SetOptionAndSettings sets the given option and saves the option setting to the settings config file
 142 func SetOptionAndSettings(option, value string) {
 143         filename := configDir + "/settings.json"
 144
 145         err := SetOption(option, value)
 146
 147         if err != nil {
 148                 messenger.Message(err.Error())
 149                 return
 150         }
 151
 152         err = WriteSettings(filename)
 153         if err != nil {
 154                 messenger.Error("Error writing to settings.json: " + err.Error())
 155                 return
 156         }
 157 }