vendor/github.com/johngb/langreg/datagen/region/genreg.go

   1 package main
   2
   3 import (
   4         "encoding/csv"
   5         "errors"
   6         "fmt"
   7         "io/ioutil"
   8         "os"
   9 )
  10
  11 const (
  12         langSource     = "datagen/region/region_codes.csv"
  13         outputFileName = "region_code_info.go"
  14 )
  15
  16 type reg struct {
  17         code string
  18         name string
  19 }
  20
  21 func decodeRegion() *[]reg {
  22
  23         // read the csv file
  24         csvfile, err := os.Open(langSource)
  25         if err != nil {
  26                 fmt.Println(err)
  27                 os.Exit(1)
  28         }
  29         defer csvfile.Close()
  30
  31         // decode csv file
  32         reader := csv.NewReader(csvfile)
  33         // there are no empty fields
  34         reader.FieldsPerRecord = 2
  35
  36         rawCSVdata, err := reader.ReadAll()
  37         if err != nil {
  38                 fmt.Println(err)
  39                 os.Exit(1)
  40         }
  41
  42         // move raw CSV data to struct
  43         var row reg
  44         var rows []reg
  45
  46         for _, v := range rawCSVdata {
  47                 row.code = v[0]
  48                 row.name = v[1]
  49                 rows = append(rows, row)
  50         }
  51         return &rows
  52 }
  53
  54 func generateSwitch(d []reg) (string, error) {
  55         out := `// generated by "go generate"; DO NOT EDIT
  56
  57 package langreg
  58
  59 import (
  60         "errors"
  61         "fmt"
  62 )
  63
  64 // RegionCodeInfo returns the English regional name that
  65 // corresponds to the ISO 3166-1 alpha-2 region codes.
  66 // Region codes should always be uppercase, and this is enforced.
  67 // E.g. "US" is valid, but "us" is not.
  68 func RegionCodeInfo(s string) (region string, err error) {
  69
  70         // codes have to be two characters long
  71         if len(s) != 2 {
  72                 return "",
  73                         errors.New("ISO 3166-1 alpha-2 region codes must be 2 characters long")
  74         }
  75   `
  76
  77         c1 := d[0].code[0]
  78         out += fmt.Sprintf("\nswitch s[0] {\n\ncase %q:\nswitch s[1]{\n", c1)
  79         for _, r := range d {
  80                 // check that the code is exactly 2 characters long
  81                 if !isCodeValid(r.code) {
  82                         return "", fmt.Errorf("The code %q is not 2 characters long", r.code)
  83                 }
  84                 // new first letter of code
  85                 if r.code[0] != c1 {
  86                         // new first char
  87                         c1 = r.code[0]
  88                         out += fmt.Sprintf("}\n\ncase %q:\nswitch s[1]{\n", c1)
  89                 }
  90                 out += fmt.Sprintf("case %q:\nreturn %q, nil\n", r.code[1], r.name)
  91         }
  92
  93         out += `}
  94         }
  95         return "",
  96                 fmt.Errorf("%q is not a valid ISO 3166-1 alpha-2 region code", s)
  97 }`
  98
  99         return out, nil
 100 }
 101
 102 func isCodeValid(s string) bool {
 103         if len(s) != 2 {
 104                 return false
 105         }
 106         if s[0] < 'A' || s[0] > 'Z' || s[1] < 'A' || s[1] > 'Z' {
 107                 return false
 108         }
 109         return true
 110 }
 111
 112 func writeFile(s, fileName string) error {
 113
 114         b := []byte(s)
 115         err := ioutil.WriteFile(fileName, b, 0644)
 116         if err != nil {
 117                 return errors.New("Couldn't write the file")
 118         }
 119         return nil
 120 }
 121
 122 func main() {
 123         rows := decodeRegion()
 124         res, _ := generateSwitch(*rows)
 125         err := writeFile(res, outputFileName)
 126         if err != nil {
 127                 fmt.Println(err)
 128         } else {
 129                 fmt.Println("region_code_info.go generated")
 130         }
 131 }