github.com/goki/ki@v1.1.17/toml/toml.go (about)

     1  // Copyright (c) 2023, The GoKi Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package toml
     6  
     7  import (
     8  	"bufio"
     9  	"bytes"
    10  	"io"
    11  	"io/fs"
    12  	"io/ioutil"
    13  	"log"
    14  	"os"
    15  
    16  	"github.com/BurntSushi/toml"
    17  	"github.com/goki/ki/dirs"
    18  )
    19  
    20  // OpenFromPaths reads object from given TOML file,
    21  // looking on paths for the file.
    22  func OpenFromPaths(obj any, file string, paths []string) error {
    23  	filename, err := dirs.FindFileOnPaths(paths, file)
    24  	if err != nil {
    25  		log.Println(err)
    26  		return err
    27  	}
    28  	// _, err = toml.DecodeFile(fp, obj)
    29  	fp, err := os.Open(filename)
    30  	defer fp.Close()
    31  	if err != nil {
    32  		log.Println(err)
    33  		return err
    34  	}
    35  	return Read(obj, bufio.NewReader(fp))
    36  }
    37  
    38  // Open reads object from given TOML file.
    39  func Open(obj any, filename string) error {
    40  	fp, err := os.Open(filename)
    41  	defer fp.Close()
    42  	if err != nil {
    43  		log.Println(err)
    44  		return err
    45  	}
    46  	return Read(obj, bufio.NewReader(fp))
    47  }
    48  
    49  // OpenFS reads object from given TOML file,
    50  // using the fs.FS filesystem -- e.g., for embed files.
    51  func OpenFS(obj any, fsys fs.FS, file string) error {
    52  	fp, err := fsys.Open(file)
    53  	defer fp.Close()
    54  	if err != nil {
    55  		log.Println(err)
    56  		return err
    57  	}
    58  	return Read(obj, bufio.NewReader(fp))
    59  }
    60  
    61  // Read reads object TOML encoding from given reader,
    62  func Read(obj any, reader io.Reader) error {
    63  	b, err := ioutil.ReadAll(reader)
    64  	if err != nil {
    65  		log.Println(err)
    66  		return err
    67  	}
    68  	return ReadBytes(obj, b)
    69  }
    70  
    71  // ReadBytes reads TOML from given bytes,
    72  func ReadBytes(obj any, b []byte) error {
    73  	err := toml.Unmarshal(b, obj)
    74  	if err != nil {
    75  		log.Println(err)
    76  		return err
    77  	}
    78  	return nil
    79  }
    80  
    81  // Save writes TOML to given file.
    82  func Save(obj any, file string) error {
    83  	fp, err := os.Create(file)
    84  	defer fp.Close()
    85  	if err != nil {
    86  		log.Println(err)
    87  		return err
    88  	}
    89  	bw := bufio.NewWriter(fp)
    90  	err = Write(obj, bw)
    91  	if err != nil {
    92  		log.Println(err)
    93  		return err
    94  	}
    95  	err = bw.Flush()
    96  	if err != nil {
    97  		log.Println(err)
    98  	}
    99  	return err
   100  }
   101  
   102  // Write writes TOML to given writer.
   103  func Write(obj any, writer io.Writer) error {
   104  	enc := toml.NewEncoder(writer)
   105  	return enc.Encode(obj)
   106  }
   107  
   108  // WriteBytes writes TOML returning bytes.
   109  func WriteBytes(obj any) []byte {
   110  	var b bytes.Buffer
   111  	enc := toml.NewEncoder(&b)
   112  	enc.Encode(obj)
   113  	return b.Bytes()
   114  }