makevar

#!/bin/bash
set -o errexit
set -o pipefail
set -o nounset

# 1. struct definition
# 2. parse structure defintion from pointer
# 3. iterate over structure fields
# 4. parse struct tags
# 5. assign default value to struct field
# 6. use environment text if present
# 7. create flag var

declare -a names=(
duration
int
int8
int16
int32
int64
uint
uint8
uint16
uint32
uint64
float64
float32
bool
string
)

makeVarHead='package flag

import (
        "fmt"
        "strings"
        "time"
)

// TypeName typename from environment variable TYPENAME 
// KeyName typename from environment variable KEYNAME
// SetterTypeName "typename" + "Value"
// MapCastType and MapSetterTypeName from transform of type & key
// Special case time.Duration

// MakeVar type cast to type with interface matching Set, Value
func MakeVar(addr interface{}, name, defaultValue, usage, override string, required, isset bool) {
  defaultValue = strings.TrimSpace(defaultValue)
  override = strings.TrimSpace(override)
  switch ptr := addr.(type) {
'

makeVarTail='  default:
    // panic("Unhandled Type %T\n", ptr)
    panic(fmt.Sprintf("Unhandled Type %v %T\n", ptr, ptr))
  }
}'



template='  case *{{.CastTypeName}}:
    var varType = (*{{.SetterTypeName}})(ptr)
    if len(defaultValue) > 0 {
      if err := varType.Set(defaultValue); err != nil {
         panic(fmt.Sprintf("Error setting {{.SetterTypeName}} %T %v\n", ptr, err))
      }
    }
    CommandLine.Var(varType, name, usage, required, isset)
    if len(override) > 0 {
      if err := varType.Set(override); err != nil {
         panic(fmt.Sprintf("Error setting {{.SetterTypeName}} %T %v\n", ptr, err))
      }
    }'


# Var defines a flag with the specified name and usage string
maptemplate='  case *{{.MapCastType}}:
    var varType = (*{{.MapSetterTypeNameValue}})(ptr)
    if len(defaultValue) > 0 {
      if err := varType.Set(defaultValue); err != nil {
         panic(fmt.Sprintf("Error setting {{.MapSetterTypeNameValue}} %T %v\n", ptr, err))
      }
    }
    CommandLine.Var(varType, name, usage, required, isset)
    if len(override) > 0 {
      if err := varType.Set(override); err != nil {
         panic(fmt.Sprintf("Error setting {{.MapSetterTypeNameValue}} %T %v\n", ptr, err))
      }
    }'

sliceTemplate='   case *{{.SliceType}}:
    var varType = (*{{.SliceTypeValueName}})(ptr)
    if len(defaultValue) > 0 {
      if err := varType.Set(defaultValue); err != nil {
         panic(fmt.Sprintf("Error setting {{.SliceTypeValueName}} %T %v\n", ptr, err))
      }
    }
    CommandLine.Var(varType, name, usage, required, isset)
    if len(override) > 0 {
      if err := varType.Set(override); err != nil {
         panic(fmt.Sprintf("Error setting {{.SliceTypeValueName}} %T %v\n", ptr, err))
      }
    }'


(
    echo "${makeVarHead}"
    for key in  $(echo ${names[@]}); do
        for value in  $(echo ${names[@]}); do
            export KEYNAME=${key}
            export TYPENAME=${value}
            echo "${maptemplate}" | k8s-template --mappings tmpl/mappings.yaml
        done
    done
    unset TYPENAME
    unset KEYNAME

    for name in  $(echo ${names[@]}); do
        export TYPENAME=${name}
        echo "${template}" | k8s-template --mappings tmpl/mappings.yaml
    done
    unset TYPENAME
    unset KEYNAME
    for name in  $(echo ${names[@]}); do
        export TYPENAME=${name}
        echo "${sliceTemplate}" | k8s-template --mappings tmpl/mappings.yaml
    done
    unset TYPENAME
    unset KEYNAME

    echo "${makeVarTail}"
) > makevar.go


sliceTemplateBody="$(cat tmpl/flag-slice.go.body.tmpl)"
sliceTestTemplate="$(cat tmpl/flag-slice_test.go.body.tmpl)"

mapTemplateHeader='package flag

////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////
import (
        "fmt"
        "strings"
        "time"
)

'

sliceTemplateHeader='package flag

////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////
import (
        "fmt"
        "strings"
        "strconv"
        "reflect"
        "time"
)

'

sliceTestTemplateHeader='package flag

import (
        "fmt"
        "testing"
        "reflect"
)

var _ = func()bool{
   if false {
      fmt.Println("")
   }
   return true
}()

'
mapTypeTemplate="$(cat tmpl/map.go.tmpl)"
(
    echo "${mapTemplateHeader}"
    for key in  $(echo ${names[@]}); do
        for value in  $(echo ${names[@]}); do
            export KEYNAME=${key}
            export TYPENAME=${value}
            echo "${mapTypeTemplate}" | k8s-template --mappings tmpl/mappings.yaml
        done
    done
) > maptypes.go

(
    echo "${sliceTemplateHeader}"
    for TYPENAME in $(echo ${names[@]}); do
        export TYPENAME=${TYPENAME}
        echo "${sliceTemplateBody}"     | k8s-template --mappings tmpl/mappings.yaml
    done
) > slicetypes.go

(
    echo "${sliceTestTemplateHeader}"
    for TYPENAME in $(echo ${names[@]}); do
        export TYPENAME=${TYPENAME}
        echo "${sliceTestTemplate}" | k8s-template --mappings tmpl/mappings.yaml
    done
) > type_test.go

declare -a intArray=(-1)
declare -a uintArray=(2)
declare -a floatArray=(2.71828)
declare -a boolArray=(true)
declare -a stringArray=("one")
declare -a durationArray=("1h2m3s")

mapTestTypeTemplate="$(cat tmpl/map_test.go.tmpl)"
mapTestTemplateHeader='package flag

import (
        "fmt"
        "testing"
)

var _ = func()bool{
   if false {
      fmt.Println("")
   }
   return true
}()

'
(
    echo "${mapTestTemplateHeader}"
    for key in  $(echo ${names[@]}); do
        for value in  $(echo ${names[@]}); do
            export KEYNAME=${key}
            export TYPENAME=${value}

            case ${key} in
                int*) karray=(${intArray[@]});;
                uint*) karray=(${uintArray[@]});;
                float*) karray=(${floatArray[@]});;
                bool*) karray=(${boolArray[@]});;
                string) karray=(${stringArray[@]});;
                duration) karray=(${durationArray[@]});;
            esac

            case ${value} in
                int*) varray=(${intArray[@]});;
                uint*) varray=(${uintArray[@]});;
                float*) varray=(${floatArray[@]});;
                bool*) varray=(${boolArray[@]});;
                string) varray=(${stringArray[@]});;
                duration) varray=(${durationArray[@]});;
            esac
            MAP=""
            for k in $(echo ${karray[@]}); do
                for v in $(echo ${varray[@]}); do
                    if [[ -z ${MAP:-} ]]; then
                        MAP="${k}:${v}"  
                    else
                        MAP="${MAP},${k}:${v}"  
                    fi
                done
            done
            export MAPINIT="${MAP}"
            echo "${mapTestTypeTemplate}" | k8s-template --mappings tmpl/mappings.yaml
        done
    done
) > maptype_test.go
go fmt *.go