.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/!burnt!sushi/toml@v0.3.1/cmd/toml-test-decoder/main.go

   1 // Command toml-test-decoder satisfies the toml-test interface for testing
   2 // TOML decoders. Namely, it accepts TOML on stdin and outputs JSON on stdout.
   3 package main
   4
   5 import (
   6         "encoding/json"
   7         "flag"
   8         "fmt"
   9         "log"
  10         "os"
  11         "path"
  12         "time"
  13
  14         "github.com/BurntSushi/toml"
  15 )
  16
  17 func init() {
  18         log.SetFlags(0)
  19
  20         flag.Usage = usage
  21         flag.Parse()
  22 }
  23
  24 func usage() {
  25         log.Printf("Usage: %s < toml-file\n", path.Base(os.Args[0]))
  26         flag.PrintDefaults()
  27
  28         os.Exit(1)
  29 }
  30
  31 func main() {
  32         if flag.NArg() != 0 {
  33                 flag.Usage()
  34         }
  35
  36         var tmp interface{}
  37         if _, err := toml.DecodeReader(os.Stdin, &tmp); err != nil {
  38                 log.Fatalf("Error decoding TOML: %s", err)
  39         }
  40
  41         typedTmp := translate(tmp)
  42         if err := json.NewEncoder(os.Stdout).Encode(typedTmp); err != nil {
  43                 log.Fatalf("Error encoding JSON: %s", err)
  44         }
  45 }
  46
  47 func translate(tomlData interface{}) interface{} {
  48         switch orig := tomlData.(type) {
  49         case map[string]interface{}:
  50                 typed := make(map[string]interface{}, len(orig))
  51                 for k, v := range orig {
  52                         typed[k] = translate(v)
  53                 }
  54                 return typed
  55         case []map[string]interface{}:
  56                 typed := make([]map[string]interface{}, len(orig))
  57                 for i, v := range orig {
  58                         typed[i] = translate(v).(map[string]interface{})
  59                 }
  60                 return typed
  61         case []interface{}:
  62                 typed := make([]interface{}, len(orig))
  63                 for i, v := range orig {
  64                         typed[i] = translate(v)
  65                 }
  66
  67                 // We don't really need to tag arrays, but let's be future proof.
  68                 // (If TOML ever supports tuples, we'll need this.)
  69                 return tag("array", typed)
  70         case time.Time:
  71                 return tag("datetime", orig.Format("2006-01-02T15:04:05Z"))
  72         case bool:
  73                 return tag("bool", fmt.Sprintf("%v", orig))
  74         case int64:
  75                 return tag("integer", fmt.Sprintf("%d", orig))
  76         case float64:
  77                 return tag("float", fmt.Sprintf("%v", orig))
  78         case string:
  79                 return tag("string", orig)
  80         }
  81
  82         panic(fmt.Sprintf("Unknown type: %T", tomlData))
  83 }
  84
  85 func tag(typeName string, data interface{}) map[string]interface{} {
  86         return map[string]interface{}{
  87                 "type":  typeName,
  88                 "value": data,
  89         }
  90 }