cmd/bpa-operator/vendor/gopkg.in/ini.v1/file.go

   1 // Copyright 2017 Unknwon
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License"): you may
   4 // not use this file except in compliance with the License. You may obtain
   5 // a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 // License for the specific language governing permissions and limitations
  13 // under the License.
  14
  15 package ini
  16
  17 import (
  18         "bytes"
  19         "errors"
  20         "fmt"
  21         "io"
  22         "io/ioutil"
  23         "os"
  24         "strings"
  25         "sync"
  26 )
  27
  28 // File represents a combination of a or more INI file(s) in memory.
  29 type File struct {
  30         options     LoadOptions
  31         dataSources []dataSource
  32
  33         // Should make things safe, but sometimes doesn't matter.
  34         BlockMode bool
  35         lock      sync.RWMutex
  36
  37         // To keep data in order.
  38         sectionList []string
  39         // Actual data is stored here.
  40         sections map[string]*Section
  41
  42         NameMapper
  43         ValueMapper
  44 }
  45
  46 // newFile initializes File object with given data sources.
  47 func newFile(dataSources []dataSource, opts LoadOptions) *File {
  48         if len(opts.KeyValueDelimiters) == 0 {
  49                 opts.KeyValueDelimiters = "=:"
  50         }
  51         return &File{
  52                 BlockMode:   true,
  53                 dataSources: dataSources,
  54                 sections:    make(map[string]*Section),
  55                 sectionList: make([]string, 0, 10),
  56                 options:     opts,
  57         }
  58 }
  59
  60 // Empty returns an empty file object.
  61 func Empty() *File {
  62         // Ignore error here, we sure our data is good.
  63         f, _ := Load([]byte(""))
  64         return f
  65 }
  66
  67 // NewSection creates a new section.
  68 func (f *File) NewSection(name string) (*Section, error) {
  69         if len(name) == 0 {
  70                 return nil, errors.New("error creating new section: empty section name")
  71         } else if f.options.Insensitive && name != DefaultSection {
  72                 name = strings.ToLower(name)
  73         }
  74
  75         if f.BlockMode {
  76                 f.lock.Lock()
  77                 defer f.lock.Unlock()
  78         }
  79
  80         if inSlice(name, f.sectionList) {
  81                 return f.sections[name], nil
  82         }
  83
  84         f.sectionList = append(f.sectionList, name)
  85         f.sections[name] = newSection(f, name)
  86         return f.sections[name], nil
  87 }
  88
  89 // NewRawSection creates a new section with an unparseable body.
  90 func (f *File) NewRawSection(name, body string) (*Section, error) {
  91         section, err := f.NewSection(name)
  92         if err != nil {
  93                 return nil, err
  94         }
  95
  96         section.isRawSection = true
  97         section.rawBody = body
  98         return section, nil
  99 }
 100
 101 // NewSections creates a list of sections.
 102 func (f *File) NewSections(names ...string) (err error) {
 103         for _, name := range names {
 104                 if _, err = f.NewSection(name); err != nil {
 105                         return err
 106                 }
 107         }
 108         return nil
 109 }
 110
 111 // GetSection returns section by given name.
 112 func (f *File) GetSection(name string) (*Section, error) {
 113         if len(name) == 0 {
 114                 name = DefaultSection
 115         }
 116         if f.options.Insensitive {
 117                 name = strings.ToLower(name)
 118         }
 119
 120         if f.BlockMode {
 121                 f.lock.RLock()
 122                 defer f.lock.RUnlock()
 123         }
 124
 125         sec := f.sections[name]
 126         if sec == nil {
 127                 return nil, fmt.Errorf("section '%s' does not exist", name)
 128         }
 129         return sec, nil
 130 }
 131
 132 // Section assumes named section exists and returns a zero-value when not.
 133 func (f *File) Section(name string) *Section {
 134         sec, err := f.GetSection(name)
 135         if err != nil {
 136                 // Note: It's OK here because the only possible error is empty section name,
 137                 // but if it's empty, this piece of code won't be executed.
 138                 sec, _ = f.NewSection(name)
 139                 return sec
 140         }
 141         return sec
 142 }
 143
 144 // Sections returns a list of Section stored in the current instance.
 145 func (f *File) Sections() []*Section {
 146         if f.BlockMode {
 147                 f.lock.RLock()
 148                 defer f.lock.RUnlock()
 149         }
 150
 151         sections := make([]*Section, len(f.sectionList))
 152         for i, name := range f.sectionList {
 153                 sections[i] = f.sections[name]
 154         }
 155         return sections
 156 }
 157
 158 // ChildSections returns a list of child sections of given section name.
 159 func (f *File) ChildSections(name string) []*Section {
 160         return f.Section(name).ChildSections()
 161 }
 162
 163 // SectionStrings returns list of section names.
 164 func (f *File) SectionStrings() []string {
 165         list := make([]string, len(f.sectionList))
 166         copy(list, f.sectionList)
 167         return list
 168 }
 169
 170 // DeleteSection deletes a section.
 171 func (f *File) DeleteSection(name string) {
 172         if f.BlockMode {
 173                 f.lock.Lock()
 174                 defer f.lock.Unlock()
 175         }
 176
 177         if len(name) == 0 {
 178                 name = DefaultSection
 179         }
 180
 181         for i, s := range f.sectionList {
 182                 if s == name {
 183                         f.sectionList = append(f.sectionList[:i], f.sectionList[i+1:]...)
 184                         delete(f.sections, name)
 185                         return
 186                 }
 187         }
 188 }
 189
 190 func (f *File) reload(s dataSource) error {
 191         r, err := s.ReadCloser()
 192         if err != nil {
 193                 return err
 194         }
 195         defer r.Close()
 196
 197         return f.parse(r)
 198 }
 199
 200 // Reload reloads and parses all data sources.
 201 func (f *File) Reload() (err error) {
 202         for _, s := range f.dataSources {
 203                 if err = f.reload(s); err != nil {
 204                         // In loose mode, we create an empty default section for nonexistent files.
 205                         if os.IsNotExist(err) && f.options.Loose {
 206                                 f.parse(bytes.NewBuffer(nil))
 207                                 continue
 208                         }
 209                         return err
 210                 }
 211         }
 212         return nil
 213 }
 214
 215 // Append appends one or more data sources and reloads automatically.
 216 func (f *File) Append(source interface{}, others ...interface{}) error {
 217         ds, err := parseDataSource(source)
 218         if err != nil {
 219                 return err
 220         }
 221         f.dataSources = append(f.dataSources, ds)
 222         for _, s := range others {
 223                 ds, err = parseDataSource(s)
 224                 if err != nil {
 225                         return err
 226                 }
 227                 f.dataSources = append(f.dataSources, ds)
 228         }
 229         return f.Reload()
 230 }
 231
 232 func (f *File) writeToBuffer(indent string) (*bytes.Buffer, error) {
 233         equalSign := DefaultFormatLeft + "=" + DefaultFormatRight
 234
 235         if PrettyFormat || PrettyEqual {
 236                 equalSign = " = "
 237         }
 238
 239         // Use buffer to make sure target is safe until finish encoding.
 240         buf := bytes.NewBuffer(nil)
 241         for i, sname := range f.sectionList {
 242                 sec := f.Section(sname)
 243                 if len(sec.Comment) > 0 {
 244                         // Support multiline comments
 245                         lines := strings.Split(sec.Comment, LineBreak)
 246                         for i := range lines {
 247                                 if lines[i][0] != '#' && lines[i][0] != ';' {
 248                                         lines[i] = "; " + lines[i]
 249                                 } else {
 250                                         lines[i] = lines[i][:1] + " " + strings.TrimSpace(lines[i][1:])
 251                                 }
 252
 253                                 if _, err := buf.WriteString(lines[i] + LineBreak); err != nil {
 254                                         return nil, err
 255                                 }
 256                         }
 257                 }
 258
 259                 if i > 0 || DefaultHeader {
 260                         if _, err := buf.WriteString("[" + sname + "]" + LineBreak); err != nil {
 261                                 return nil, err
 262                         }
 263                 } else {
 264                         // Write nothing if default section is empty
 265                         if len(sec.keyList) == 0 {
 266                                 continue
 267                         }
 268                 }
 269
 270                 if sec.isRawSection {
 271                         if _, err := buf.WriteString(sec.rawBody); err != nil {
 272                                 return nil, err
 273                         }
 274
 275                         if PrettySection {
 276                                 // Put a line between sections
 277                                 if _, err := buf.WriteString(LineBreak); err != nil {
 278                                         return nil, err
 279                                 }
 280                         }
 281                         continue
 282                 }
 283
 284                 // Count and generate alignment length and buffer spaces using the
 285                 // longest key. Keys may be modifed if they contain certain characters so
 286                 // we need to take that into account in our calculation.
 287                 alignLength := 0
 288                 if PrettyFormat {
 289                         for _, kname := range sec.keyList {
 290                                 keyLength := len(kname)
 291                                 // First case will surround key by ` and second by """
 292                                 if strings.Contains(kname, "\"") || strings.ContainsAny(kname, f.options.KeyValueDelimiters) {
 293                                         keyLength += 2
 294                                 } else if strings.Contains(kname, "`") {
 295                                         keyLength += 6
 296                                 }
 297
 298                                 if keyLength > alignLength {
 299                                         alignLength = keyLength
 300                                 }
 301                         }
 302                 }
 303                 alignSpaces := bytes.Repeat([]byte(" "), alignLength)
 304
 305         KEY_LIST:
 306                 for _, kname := range sec.keyList {
 307                         key := sec.Key(kname)
 308                         if len(key.Comment) > 0 {
 309                                 if len(indent) > 0 && sname != DefaultSection {
 310                                         buf.WriteString(indent)
 311                                 }
 312
 313                                 // Support multiline comments
 314                                 lines := strings.Split(key.Comment, LineBreak)
 315                                 for i := range lines {
 316                                         if lines[i][0] != '#' && lines[i][0] != ';' {
 317                                                 lines[i] = "; " + strings.TrimSpace(lines[i])
 318                                         } else {
 319                                                 lines[i] = lines[i][:1] + " " + strings.TrimSpace(lines[i][1:])
 320                                         }
 321
 322                                         if _, err := buf.WriteString(lines[i] + LineBreak); err != nil {
 323                                                 return nil, err
 324                                         }
 325                                 }
 326                         }
 327
 328                         if len(indent) > 0 && sname != DefaultSection {
 329                                 buf.WriteString(indent)
 330                         }
 331
 332                         switch {
 333                         case key.isAutoIncrement:
 334                                 kname = "-"
 335                         case strings.Contains(kname, "\"") || strings.ContainsAny(kname, f.options.KeyValueDelimiters):
 336                                 kname = "`" + kname + "`"
 337                         case strings.Contains(kname, "`"):
 338                                 kname = `"""` + kname + `"""`
 339                         }
 340
 341                         for _, val := range key.ValueWithShadows() {
 342                                 if _, err := buf.WriteString(kname); err != nil {
 343                                         return nil, err
 344                                 }
 345
 346                                 if key.isBooleanType {
 347                                         if kname != sec.keyList[len(sec.keyList)-1] {
 348                                                 buf.WriteString(LineBreak)
 349                                         }
 350                                         continue KEY_LIST
 351                                 }
 352
 353                                 // Write out alignment spaces before "=" sign
 354                                 if PrettyFormat {
 355                                         buf.Write(alignSpaces[:alignLength-len(kname)])
 356                                 }
 357
 358                                 // In case key value contains "\n", "`", "\"", "#" or ";"
 359                                 if strings.ContainsAny(val, "\n`") {
 360                                         val = `"""` + val + `"""`
 361                                 } else if !f.options.IgnoreInlineComment && strings.ContainsAny(val, "#;") {
 362                                         val = "`" + val + "`"
 363                                 }
 364                                 if _, err := buf.WriteString(equalSign + val + LineBreak); err != nil {
 365                                         return nil, err
 366                                 }
 367                         }
 368
 369                         for _, val := range key.nestedValues {
 370                                 if _, err := buf.WriteString(indent + "  " + val + LineBreak); err != nil {
 371                                         return nil, err
 372                                 }
 373                         }
 374                 }
 375
 376                 if PrettySection {
 377                         // Put a line between sections
 378                         if _, err := buf.WriteString(LineBreak); err != nil {
 379                                 return nil, err
 380                         }
 381                 }
 382         }
 383
 384         return buf, nil
 385 }
 386
 387 // WriteToIndent writes content into io.Writer with given indention.
 388 // If PrettyFormat has been set to be true,
 389 // it will align "=" sign with spaces under each section.
 390 func (f *File) WriteToIndent(w io.Writer, indent string) (int64, error) {
 391         buf, err := f.writeToBuffer(indent)
 392         if err != nil {
 393                 return 0, err
 394         }
 395         return buf.WriteTo(w)
 396 }
 397
 398 // WriteTo writes file content into io.Writer.
 399 func (f *File) WriteTo(w io.Writer) (int64, error) {
 400         return f.WriteToIndent(w, "")
 401 }
 402
 403 // SaveToIndent writes content to file system with given value indention.
 404 func (f *File) SaveToIndent(filename, indent string) error {
 405         // Note: Because we are truncating with os.Create,
 406         //      so it's safer to save to a temporary file location and rename afte done.
 407         buf, err := f.writeToBuffer(indent)
 408         if err != nil {
 409                 return err
 410         }
 411
 412         return ioutil.WriteFile(filename, buf.Bytes(), 0666)
 413 }
 414
 415 // SaveTo writes content to file system.
 416 func (f *File) SaveTo(filename string) error {
 417         return f.SaveToIndent(filename, "")
 418 }