Browse Source
Update go-ini dependency and remove semicolon hack in translations (#2913)
release/v1.4
Update go-ini dependency and remove semicolon hack in translations (#2913)
release/v1.4
Lauris BH
5 years ago
committed by
Lunny Xiao
Lunny Xiao
17 changed files with 584 additions and 429 deletions
-
4modules/templates/helper.go
-
4options/locale/locale_en-US.ini
-
2templates/repo/issue/view_content/comments.tmpl
-
12vendor/github.com/Unknwon/i18n/Makefile
-
6vendor/github.com/Unknwon/i18n/README.md
-
32vendor/github.com/Unknwon/i18n/i18n.go
-
2vendor/gopkg.in/ini.v1/LICENSE
-
5vendor/gopkg.in/ini.v1/Makefile
-
29vendor/gopkg.in/ini.v1/README.md
-
29vendor/gopkg.in/ini.v1/README_ZH.md
-
392vendor/gopkg.in/ini.v1/file.go
-
381vendor/gopkg.in/ini.v1/ini.go
-
42vendor/gopkg.in/ini.v1/key.go
-
36vendor/gopkg.in/ini.v1/parser.go
-
9vendor/gopkg.in/ini.v1/section.go
-
16vendor/gopkg.in/ini.v1/struct.go
-
12vendor/vendor.json
@ -0,0 +1,12 @@ |
|||
.PHONY: build test bench vet |
|||
|
|||
build: vet bench |
|||
|
|||
test: |
|||
go test -v -cover |
|||
|
|||
bench: |
|||
go test -v -cover -test.bench=. -test.benchmem |
|||
|
|||
vet: |
|||
go vet |
|||
@ -0,0 +1,392 @@ |
|||
// Copyright 2017 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 ( |
|||
"bytes" |
|||
"errors" |
|||
"fmt" |
|||
"io" |
|||
"io/ioutil" |
|||
"os" |
|||
"strings" |
|||
"sync" |
|||
) |
|||
|
|||
// File represents a combination of a or more INI file(s) in memory.
|
|||
type File struct { |
|||
options LoadOptions |
|||
dataSources []dataSource |
|||
|
|||
// Should make things safe, but sometimes doesn't matter.
|
|||
BlockMode bool |
|||
lock sync.RWMutex |
|||
|
|||
// To keep data in order.
|
|||
sectionList []string |
|||
// Actual data is stored here.
|
|||
sections map[string]*Section |
|||
|
|||
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, |
|||
} |
|||
} |
|||
|
|||
// 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 |
|||
} |
|||
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 |
|||
} |
|||
|
|||
// ChildSections returns a list of child sections of given section name.
|
|||
func (f *File) ChildSections(name string) []*Section { |
|||
return f.Section(name).ChildSections() |
|||
} |
|||
|
|||
// 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() |
|||
} |
|||
|
|||
func (f *File) writeToBuffer(indent string) (*bytes.Buffer, 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 |
|||
} else { |
|||
sec.Comment = sec.Comment[:1] + " " + strings.TrimSpace(sec.Comment[1:]) |
|||
} |
|||
if _, err := buf.WriteString(sec.Comment + LineBreak); err != nil { |
|||
return nil, err |
|||
} |
|||
} |
|||
|
|||
if i > 0 || DefaultHeader { |
|||
if _, err := buf.WriteString("[" + sname + "]" + LineBreak); err != nil { |
|||
return nil, 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 nil, err |
|||
} |
|||
|
|||
if PrettySection { |
|||
// Put a line between sections
|
|||
if _, err := buf.WriteString(LineBreak); err != nil { |
|||
return nil, 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 |
|||
} else { |
|||
key.Comment = key.Comment[:1] + " " + strings.TrimSpace(key.Comment[1:]) |
|||
} |
|||
if _, err := buf.WriteString(key.Comment + LineBreak); err != nil { |
|||
return nil, 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 nil, 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 !f.options.IgnoreInlineComment && strings.ContainsAny(val, "#;") { |
|||
val = "`" + val + "`" |
|||
} |
|||
if _, err := buf.WriteString(equalSign + val + LineBreak); err != nil { |
|||
return nil, err |
|||
} |
|||
} |
|||
} |
|||
|
|||
if PrettySection { |
|||
// Put a line between sections
|
|||
if _, err := buf.WriteString(LineBreak); err != nil { |
|||
return nil, err |
|||
} |
|||
} |
|||
} |
|||
|
|||
return buf, nil |
|||
} |
|||
|
|||
// 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) (int64, error) { |
|||
buf, err := f.writeToBuffer(indent) |
|||
if 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.
|
|||
buf, err := f.writeToBuffer(indent) |
|||
if err != nil { |
|||
return err |
|||
} |
|||
|
|||
return ioutil.WriteFile(filename, buf.Bytes(), 0666) |
|||
} |
|||
|
|||
// SaveTo writes content to file system.
|
|||
func (f *File) SaveTo(filename string) error { |
|||
return f.SaveToIndent(filename, "") |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue