mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-04 22:36:34 +00:00
0884f89431
* start pulling out + replacing urfave and config * replace many many instances of config * move more stuff => viper * properly remove urfave * move some flags to root command * add testrig commands to root * alias config file keys * start adding cli parsing tests * reorder viper init * remove config path alias * fmt * change config file keys to non-nested * we're more or less in business now * tidy up the common func * go fmt * get tests passing again * add note about the cliparsing tests * reorganize * update docs with changes * structure cmd dir better * rename + move some files around * fix dangling comma
256 lines
5.9 KiB
Go
256 lines
5.9 KiB
Go
// 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
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// Section represents a config section.
|
|
type Section struct {
|
|
f *File
|
|
Comment string
|
|
name string
|
|
keys map[string]*Key
|
|
keyList []string
|
|
keysHash map[string]string
|
|
|
|
isRawSection bool
|
|
rawBody string
|
|
}
|
|
|
|
func newSection(f *File, name string) *Section {
|
|
return &Section{
|
|
f: f,
|
|
name: name,
|
|
keys: make(map[string]*Key),
|
|
keyList: make([]string, 0, 10),
|
|
keysHash: make(map[string]string),
|
|
}
|
|
}
|
|
|
|
// Name returns name of Section.
|
|
func (s *Section) Name() string {
|
|
return s.name
|
|
}
|
|
|
|
// Body returns rawBody of Section if the section was marked as unparseable.
|
|
// It still follows the other rules of the INI format surrounding leading/trailing whitespace.
|
|
func (s *Section) Body() string {
|
|
return strings.TrimSpace(s.rawBody)
|
|
}
|
|
|
|
// SetBody updates body content only if section is raw.
|
|
func (s *Section) SetBody(body string) {
|
|
if !s.isRawSection {
|
|
return
|
|
}
|
|
s.rawBody = body
|
|
}
|
|
|
|
// NewKey creates a new key to given section.
|
|
func (s *Section) NewKey(name, val string) (*Key, error) {
|
|
if len(name) == 0 {
|
|
return nil, errors.New("error creating new key: empty key name")
|
|
} else if s.f.options.Insensitive || s.f.options.InsensitiveKeys {
|
|
name = strings.ToLower(name)
|
|
}
|
|
|
|
if s.f.BlockMode {
|
|
s.f.lock.Lock()
|
|
defer s.f.lock.Unlock()
|
|
}
|
|
|
|
if inSlice(name, s.keyList) {
|
|
if s.f.options.AllowShadows {
|
|
if err := s.keys[name].addShadow(val); err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
s.keys[name].value = val
|
|
s.keysHash[name] = val
|
|
}
|
|
return s.keys[name], nil
|
|
}
|
|
|
|
s.keyList = append(s.keyList, name)
|
|
s.keys[name] = newKey(s, name, val)
|
|
s.keysHash[name] = val
|
|
return s.keys[name], nil
|
|
}
|
|
|
|
// NewBooleanKey creates a new boolean type key to given section.
|
|
func (s *Section) NewBooleanKey(name string) (*Key, error) {
|
|
key, err := s.NewKey(name, "true")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
key.isBooleanType = true
|
|
return key, nil
|
|
}
|
|
|
|
// GetKey returns key in section by given name.
|
|
func (s *Section) GetKey(name string) (*Key, error) {
|
|
if s.f.BlockMode {
|
|
s.f.lock.RLock()
|
|
}
|
|
if s.f.options.Insensitive || s.f.options.InsensitiveKeys {
|
|
name = strings.ToLower(name)
|
|
}
|
|
key := s.keys[name]
|
|
if s.f.BlockMode {
|
|
s.f.lock.RUnlock()
|
|
}
|
|
|
|
if key == nil {
|
|
// Check if it is a child-section.
|
|
sname := s.name
|
|
for {
|
|
if i := strings.LastIndex(sname, s.f.options.ChildSectionDelimiter); i > -1 {
|
|
sname = sname[:i]
|
|
sec, err := s.f.GetSection(sname)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
return sec.GetKey(name)
|
|
}
|
|
break
|
|
}
|
|
return nil, fmt.Errorf("error when getting key of section %q: key %q not exists", s.name, name)
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
// HasKey returns true if section contains a key with given name.
|
|
func (s *Section) HasKey(name string) bool {
|
|
key, _ := s.GetKey(name)
|
|
return key != nil
|
|
}
|
|
|
|
// Deprecated: Use "HasKey" instead.
|
|
func (s *Section) Haskey(name string) bool {
|
|
return s.HasKey(name)
|
|
}
|
|
|
|
// HasValue returns true if section contains given raw value.
|
|
func (s *Section) HasValue(value string) bool {
|
|
if s.f.BlockMode {
|
|
s.f.lock.RLock()
|
|
defer s.f.lock.RUnlock()
|
|
}
|
|
|
|
for _, k := range s.keys {
|
|
if value == k.value {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Key assumes named Key exists in section and returns a zero-value when not.
|
|
func (s *Section) Key(name string) *Key {
|
|
key, err := s.GetKey(name)
|
|
if err != nil {
|
|
// It's OK here because the only possible error is empty key name,
|
|
// but if it's empty, this piece of code won't be executed.
|
|
key, _ = s.NewKey(name, "")
|
|
return key
|
|
}
|
|
return key
|
|
}
|
|
|
|
// Keys returns list of keys of section.
|
|
func (s *Section) Keys() []*Key {
|
|
keys := make([]*Key, len(s.keyList))
|
|
for i := range s.keyList {
|
|
keys[i] = s.Key(s.keyList[i])
|
|
}
|
|
return keys
|
|
}
|
|
|
|
// ParentKeys returns list of keys of parent section.
|
|
func (s *Section) ParentKeys() []*Key {
|
|
var parentKeys []*Key
|
|
sname := s.name
|
|
for {
|
|
if i := strings.LastIndex(sname, s.f.options.ChildSectionDelimiter); i > -1 {
|
|
sname = sname[:i]
|
|
sec, err := s.f.GetSection(sname)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
parentKeys = append(parentKeys, sec.Keys()...)
|
|
} else {
|
|
break
|
|
}
|
|
|
|
}
|
|
return parentKeys
|
|
}
|
|
|
|
// KeyStrings returns list of key names of section.
|
|
func (s *Section) KeyStrings() []string {
|
|
list := make([]string, len(s.keyList))
|
|
copy(list, s.keyList)
|
|
return list
|
|
}
|
|
|
|
// KeysHash returns keys hash consisting of names and values.
|
|
func (s *Section) KeysHash() map[string]string {
|
|
if s.f.BlockMode {
|
|
s.f.lock.RLock()
|
|
defer s.f.lock.RUnlock()
|
|
}
|
|
|
|
hash := make(map[string]string, len(s.keysHash))
|
|
for key, value := range s.keysHash {
|
|
hash[key] = value
|
|
}
|
|
return hash
|
|
}
|
|
|
|
// DeleteKey deletes a key from section.
|
|
func (s *Section) DeleteKey(name string) {
|
|
if s.f.BlockMode {
|
|
s.f.lock.Lock()
|
|
defer s.f.lock.Unlock()
|
|
}
|
|
|
|
for i, k := range s.keyList {
|
|
if k == name {
|
|
s.keyList = append(s.keyList[:i], s.keyList[i+1:]...)
|
|
delete(s.keys, name)
|
|
delete(s.keysHash, name)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// ChildSections returns a list of child sections of current section.
|
|
// For example, "[parent.child1]" and "[parent.child12]" are child sections
|
|
// of section "[parent]".
|
|
func (s *Section) ChildSections() []*Section {
|
|
prefix := s.name + s.f.options.ChildSectionDelimiter
|
|
children := make([]*Section, 0, 3)
|
|
for _, name := range s.f.sectionList {
|
|
if strings.HasPrefix(name, prefix) {
|
|
children = append(children, s.f.sections[name]...)
|
|
}
|
|
}
|
|
return children
|
|
}
|