| // Copyright 2014 Unknwon |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"): you may |
| // not use this file except in compliance with the License. You may obtain |
| // a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations |
| // under the License. |
| |
| // Package ini provides INI file read and write functionality in Go. |
| package ini |
| |
| import ( |
| "bytes" |
| "errors" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "os" |
| "regexp" |
| "runtime" |
| "strconv" |
| "strings" |
| "sync" |
| "time" |
| ) |
| |
| const ( |
| // Name for default section. You can use this constant or the string literal. |
| // In most of cases, an empty string is all you need to access the section. |
| DEFAULT_SECTION = "DEFAULT" |
| |
| // Maximum allowed depth when recursively substituing variable names. |
| _DEPTH_VALUES = 99 |
| _VERSION = "1.25.4" |
| ) |
| |
| // Version returns current package version literal. |
| func Version() string { |
| return _VERSION |
| } |
| |
| var ( |
| // Delimiter to determine or compose a new line. |
| // This variable will be changed to "\r\n" automatically on Windows |
| // at package init time. |
| LineBreak = "\n" |
| |
| // Variable regexp pattern: %(variable)s |
| varPattern = regexp.MustCompile(`%\(([^\)]+)\)s`) |
| |
| // Indicate whether to align "=" sign with spaces to produce pretty output |
| // or reduce all possible spaces for compact format. |
| PrettyFormat = true |
| |
| // Explicitly write DEFAULT section header |
| DefaultHeader = false |
| ) |
| |
| func init() { |
| if runtime.GOOS == "windows" { |
| LineBreak = "\r\n" |
| } |
| } |
| |
| func inSlice(str string, s []string) bool { |
| for _, v := range s { |
| if str == v { |
| return true |
| } |
| } |
| return false |
| } |
| |
| // dataSource is an interface that returns object which can be read and closed. |
| type dataSource interface { |
| ReadCloser() (io.ReadCloser, error) |
| } |
| |
| // sourceFile represents an object that contains content on the local file system. |
| type sourceFile struct { |
| name string |
| } |
| |
| func (s sourceFile) ReadCloser() (_ io.ReadCloser, err error) { |
| return os.Open(s.name) |
| } |
| |
| type bytesReadCloser struct { |
| reader io.Reader |
| } |
| |
| func (rc *bytesReadCloser) Read(p []byte) (n int, err error) { |
| return rc.reader.Read(p) |
| } |
| |
| func (rc *bytesReadCloser) Close() error { |
| return nil |
| } |
| |
| // sourceData represents an object that contains content in memory. |
| type sourceData struct { |
| data []byte |
| } |
| |
| func (s *sourceData) ReadCloser() (io.ReadCloser, error) { |
| return ioutil.NopCloser(bytes.NewReader(s.data)), nil |
| } |
| |
| // sourceReadCloser represents an input stream with Close method. |
| type sourceReadCloser struct { |
| reader io.ReadCloser |
| } |
| |
| func (s *sourceReadCloser) ReadCloser() (io.ReadCloser, error) { |
| return s.reader, nil |
| } |
| |
| // File represents a combination of a or more INI file(s) in memory. |
| type File struct { |
| // Should make things safe, but sometimes doesn't matter. |
| BlockMode bool |
| // Make sure data is safe in multiple goroutines. |
| lock sync.RWMutex |
| |
| // Allow combination of multiple data sources. |
| dataSources []dataSource |
| // Actual data is stored here. |
| sections map[string]*Section |
| |
| // To keep data in order. |
| sectionList []string |
| |
| options LoadOptions |
| |
| NameMapper |
| ValueMapper |
| } |
| |
| // newFile initializes File object with given data sources. |
| func newFile(dataSources []dataSource, opts LoadOptions) *File { |
| return &File{ |
| BlockMode: true, |
| dataSources: dataSources, |
| sections: make(map[string]*Section), |
| sectionList: make([]string, 0, 10), |
| options: opts, |
| } |
| } |
| |
| func parseDataSource(source interface{}) (dataSource, error) { |
| switch s := source.(type) { |
| case string: |
| return sourceFile{s}, nil |
| case []byte: |
| return &sourceData{s}, nil |
| case io.ReadCloser: |
| return &sourceReadCloser{s}, nil |
| default: |
| return nil, fmt.Errorf("error parsing data source: unknown type '%s'", s) |
| } |
| } |
| |
| type LoadOptions struct { |
| // Loose indicates whether the parser should ignore nonexistent files or return error. |
| Loose bool |
| // Insensitive indicates whether the parser forces all section and key names to lowercase. |
| Insensitive bool |
| // IgnoreContinuation indicates whether to ignore continuation lines while parsing. |
| IgnoreContinuation bool |
| // AllowBooleanKeys indicates whether to allow boolean type keys or treat as value is missing. |
| // This type of keys are mostly used in my.cnf. |
| AllowBooleanKeys bool |
| // AllowShadows indicates whether to keep track of keys with same name under same section. |
| AllowShadows bool |
| // Some INI formats allow group blocks that store a block of raw content that doesn't otherwise |
| // conform to key/value pairs. Specify the names of those blocks here. |
| UnparseableSections []string |
| } |
| |
| func LoadSources(opts LoadOptions, source interface{}, others ...interface{}) (_ *File, err error) { |
| sources := make([]dataSource, len(others)+1) |
| sources[0], err = parseDataSource(source) |
| if err != nil { |
| return nil, err |
| } |
| for i := range others { |
| sources[i+1], err = parseDataSource(others[i]) |
| if err != nil { |
| return nil, err |
| } |
| } |
| f := newFile(sources, opts) |
| if err = f.Reload(); err != nil { |
| return nil, err |
| } |
| return f, nil |
| } |
| |
| // Load loads and parses from INI data sources. |
| // Arguments can be mixed of file name with string type, or raw data in []byte. |
| // It will return error if list contains nonexistent files. |
| func Load(source interface{}, others ...interface{}) (*File, error) { |
| return LoadSources(LoadOptions{}, source, others...) |
| } |
| |
| // LooseLoad has exactly same functionality as Load function |
| // except it ignores nonexistent files instead of returning error. |
| func LooseLoad(source interface{}, others ...interface{}) (*File, error) { |
| return LoadSources(LoadOptions{Loose: true}, source, others...) |
| } |
| |
| // InsensitiveLoad has exactly same functionality as Load function |
| // except it forces all section and key names to be lowercased. |
| func InsensitiveLoad(source interface{}, others ...interface{}) (*File, error) { |
| return LoadSources(LoadOptions{Insensitive: true}, source, others...) |
| } |
| |
| // InsensitiveLoad has exactly same functionality as Load function |
| // except it allows have shadow keys. |
| func ShadowLoad(source interface{}, others ...interface{}) (*File, error) { |
| return LoadSources(LoadOptions{AllowShadows: true}, source, others...) |
| } |
| |
| // Empty returns an empty file object. |
| func Empty() *File { |
| // Ignore error here, we sure our data is good. |
| f, _ := Load([]byte("")) |
| return f |
| } |
| |
| // NewSection creates a new section. |
| func (f *File) NewSection(name string) (*Section, error) { |
| if len(name) == 0 { |
| return nil, errors.New("error creating new section: empty section name") |
| } else if f.options.Insensitive && name != DEFAULT_SECTION { |
| name = strings.ToLower(name) |
| } |
| |
| if f.BlockMode { |
| f.lock.Lock() |
| defer f.lock.Unlock() |
| } |
| |
| if inSlice(name, f.sectionList) { |
| return f.sections[name], nil |
| } |
| |
| f.sectionList = append(f.sectionList, name) |
| f.sections[name] = newSection(f, name) |
| return f.sections[name], nil |
| } |
| |
| // NewRawSection creates a new section with an unparseable body. |
| func (f *File) NewRawSection(name, body string) (*Section, error) { |
| section, err := f.NewSection(name) |
| if err != nil { |
| return nil, err |
| } |
| |
| section.isRawSection = true |
| section.rawBody = body |
| return section, nil |
| } |
| |
| // NewSections creates a list of sections. |
| func (f *File) NewSections(names ...string) (err error) { |
| for _, name := range names { |
| if _, err = f.NewSection(name); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| // GetSection returns section by given name. |
| func (f *File) GetSection(name string) (*Section, error) { |
| if len(name) == 0 { |
| name = DEFAULT_SECTION |
| } else if f.options.Insensitive { |
| name = strings.ToLower(name) |
| } |
| |
| if f.BlockMode { |
| f.lock.RLock() |
| defer f.lock.RUnlock() |
| } |
| |
| sec := f.sections[name] |
| if sec == nil { |
| return nil, fmt.Errorf("section '%s' does not exist", name) |
| } |
| return sec, nil |
| } |
| |
| // Section assumes named section exists and returns a zero-value when not. |
| func (f *File) Section(name string) *Section { |
| sec, err := f.GetSection(name) |
| if err != nil { |
| // Note: It's OK here because the only possible error is empty section name, |
| // but if it's empty, this piece of code won't be executed. |
| sec, _ = f.NewSection(name) |
| return sec |
| } |
| return sec |
| } |
| |
| // Section returns list of Section. |
| func (f *File) Sections() []*Section { |
| sections := make([]*Section, len(f.sectionList)) |
| for i := range f.sectionList { |
| sections[i] = f.Section(f.sectionList[i]) |
| } |
| return sections |
| } |
| |
| // SectionStrings returns list of section names. |
| func (f *File) SectionStrings() []string { |
| list := make([]string, len(f.sectionList)) |
| copy(list, f.sectionList) |
| return list |
| } |
| |
| // DeleteSection deletes a section. |
| func (f *File) DeleteSection(name string) { |
| if f.BlockMode { |
| f.lock.Lock() |
| defer f.lock.Unlock() |
| } |
| |
| if len(name) == 0 { |
| name = DEFAULT_SECTION |
| } |
| |
| for i, s := range f.sectionList { |
| if s == name { |
| f.sectionList = append(f.sectionList[:i], f.sectionList[i+1:]...) |
| delete(f.sections, name) |
| return |
| } |
| } |
| } |
| |
| func (f *File) reload(s dataSource) error { |
| r, err := s.ReadCloser() |
| if err != nil { |
| return err |
| } |
| defer r.Close() |
| |
| return f.parse(r) |
| } |
| |
| // Reload reloads and parses all data sources. |
| func (f *File) Reload() (err error) { |
| for _, s := range f.dataSources { |
| if err = f.reload(s); err != nil { |
| // In loose mode, we create an empty default section for nonexistent files. |
| if os.IsNotExist(err) && f.options.Loose { |
| f.parse(bytes.NewBuffer(nil)) |
| continue |
| } |
| return err |
| } |
| } |
| return nil |
| } |
| |
| // Append appends one or more data sources and reloads automatically. |
| func (f *File) Append(source interface{}, others ...interface{}) error { |
| ds, err := parseDataSource(source) |
| if err != nil { |
| return err |
| } |
| f.dataSources = append(f.dataSources, ds) |
| for _, s := range others { |
| ds, err = parseDataSource(s) |
| if err != nil { |
| return err |
| } |
| f.dataSources = append(f.dataSources, ds) |
| } |
| return f.Reload() |
| } |
| |
| // WriteToIndent writes content into io.Writer with given indention. |
| // If PrettyFormat has been set to be true, |
| // it will align "=" sign with spaces under each section. |
| func (f *File) WriteToIndent(w io.Writer, indent string) (n int64, err error) { |
| equalSign := "=" |
| if PrettyFormat { |
| equalSign = " = " |
| } |
| |
| // Use buffer to make sure target is safe until finish encoding. |
| buf := bytes.NewBuffer(nil) |
| for i, sname := range f.sectionList { |
| sec := f.Section(sname) |
| if len(sec.Comment) > 0 { |
| if sec.Comment[0] != '#' && sec.Comment[0] != ';' { |
| sec.Comment = "; " + sec.Comment |
| } |
| if _, err = buf.WriteString(sec.Comment + LineBreak); err != nil { |
| return 0, err |
| } |
| } |
| |
| if i > 0 || DefaultHeader { |
| if _, err = buf.WriteString("[" + sname + "]" + LineBreak); err != nil { |
| return 0, err |
| } |
| } else { |
| // Write nothing if default section is empty |
| if len(sec.keyList) == 0 { |
| continue |
| } |
| } |
| |
| if sec.isRawSection { |
| if _, err = buf.WriteString(sec.rawBody); err != nil { |
| return 0, err |
| } |
| continue |
| } |
| |
| // Count and generate alignment length and buffer spaces using the |
| // longest key. Keys may be modifed if they contain certain characters so |
| // we need to take that into account in our calculation. |
| alignLength := 0 |
| if PrettyFormat { |
| for _, kname := range sec.keyList { |
| keyLength := len(kname) |
| // First case will surround key by ` and second by """ |
| if strings.ContainsAny(kname, "\"=:") { |
| keyLength += 2 |
| } else if strings.Contains(kname, "`") { |
| keyLength += 6 |
| } |
| |
| if keyLength > alignLength { |
| alignLength = keyLength |
| } |
| } |
| } |
| alignSpaces := bytes.Repeat([]byte(" "), alignLength) |
| |
| KEY_LIST: |
| for _, kname := range sec.keyList { |
| key := sec.Key(kname) |
| if len(key.Comment) > 0 { |
| if len(indent) > 0 && sname != DEFAULT_SECTION { |
| buf.WriteString(indent) |
| } |
| if key.Comment[0] != '#' && key.Comment[0] != ';' { |
| key.Comment = "; " + key.Comment |
| } |
| if _, err = buf.WriteString(key.Comment + LineBreak); err != nil { |
| return 0, err |
| } |
| } |
| |
| if len(indent) > 0 && sname != DEFAULT_SECTION { |
| buf.WriteString(indent) |
| } |
| |
| switch { |
| case key.isAutoIncrement: |
| kname = "-" |
| case strings.ContainsAny(kname, "\"=:"): |
| kname = "`" + kname + "`" |
| case strings.Contains(kname, "`"): |
| kname = `"""` + kname + `"""` |
| } |
| |
| for _, val := range key.ValueWithShadows() { |
| if _, err = buf.WriteString(kname); err != nil { |
| return 0, err |
| } |
| |
| if key.isBooleanType { |
| if kname != sec.keyList[len(sec.keyList)-1] { |
| buf.WriteString(LineBreak) |
| } |
| continue KEY_LIST |
| } |
| |
| // Write out alignment spaces before "=" sign |
| if PrettyFormat { |
| buf.Write(alignSpaces[:alignLength-len(kname)]) |
| } |
| |
| // In case key value contains "\n", "`", "\"", "#" or ";" |
| if strings.ContainsAny(val, "\n`") { |
| val = `"""` + val + `"""` |
| } else if strings.ContainsAny(val, "#;") { |
| val = "`" + val + "`" |
| } |
| if _, err = buf.WriteString(equalSign + val + LineBreak); err != nil { |
| return 0, err |
| } |
| } |
| } |
| |
| // Put a line between sections |
| if _, err = buf.WriteString(LineBreak); err != nil { |
| return 0, err |
| } |
| } |
| |
| return buf.WriteTo(w) |
| } |
| |
| // WriteTo writes file content into io.Writer. |
| func (f *File) WriteTo(w io.Writer) (int64, error) { |
| return f.WriteToIndent(w, "") |
| } |
| |
| // SaveToIndent writes content to file system with given value indention. |
| func (f *File) SaveToIndent(filename, indent string) error { |
| // Note: Because we are truncating with os.Create, |
| // so it's safer to save to a temporary file location and rename afte done. |
| tmpPath := filename + "." + strconv.Itoa(time.Now().Nanosecond()) + ".tmp" |
| defer os.Remove(tmpPath) |
| |
| fw, err := os.Create(tmpPath) |
| if err != nil { |
| return err |
| } |
| |
| if _, err = f.WriteToIndent(fw, indent); err != nil { |
| fw.Close() |
| return err |
| } |
| fw.Close() |
| |
| // Remove old file and rename the new one. |
| os.Remove(filename) |
| return os.Rename(tmpPath, filename) |
| } |
| |
| // SaveTo writes content to file system. |
| func (f *File) SaveTo(filename string) error { |
| return f.SaveToIndent(filename, "") |
| } |