cmd/bpa-operator/vendor/github.com/markbates/inflect/name.go

   1 package inflect
   2
   3 import (
   4         "fmt"
   5         "path/filepath"
   6         "strings"
   7
   8         "github.com/gobuffalo/envy"
   9 )
  10
  11 // Name is a string that represents the "name" of a thing, like an app, model, etc...
  12 type Name string
  13
  14 // Title version of a name. ie. "foo_bar" => "Foo Bar"
  15 func (n Name) Title() string {
  16         x := strings.Split(string(n), "/")
  17         for i, s := range x {
  18                 x[i] = Titleize(s)
  19         }
  20
  21         return strings.Join(x, " ")
  22 }
  23
  24 // Underscore version of a name. ie. "FooBar" => "foo_bar"
  25 func (n Name) Underscore() string {
  26         w := string(n)
  27         if strings.ToUpper(w) == w {
  28                 return strings.ToLower(w)
  29         }
  30         return Underscore(w)
  31 }
  32
  33 // Plural version of a name
  34 func (n Name) Plural() string {
  35         return Pluralize(string(n))
  36 }
  37
  38 // Singular version of a name
  39 func (n Name) Singular() string {
  40         return Singularize(string(n))
  41 }
  42
  43 // Camel version of a name
  44 func (n Name) Camel() string {
  45         c := Camelize(string(n))
  46         if strings.HasSuffix(c, "Id") {
  47                 c = strings.TrimSuffix(c, "Id")
  48                 c += "ID"
  49         }
  50         return c
  51 }
  52
  53 // Model version of a name. ie. "user" => "User"
  54 func (n Name) Model() string {
  55         x := strings.Split(string(n), "/")
  56         for i, s := range x {
  57                 x[i] = Camelize(Singularize(s))
  58         }
  59
  60         return strings.Join(x, "")
  61 }
  62
  63 // Resource version of a name
  64 func (n Name) Resource() string {
  65         name := n.Underscore()
  66         x := strings.FieldsFunc(name, func(r rune) bool {
  67                 return r == '_' || r == '/'
  68         })
  69
  70         for i, w := range x {
  71                 if i == len(x)-1 {
  72                         x[i] = Camelize(Pluralize(strings.ToLower(w)))
  73                         continue
  74                 }
  75
  76                 x[i] = Camelize(w)
  77         }
  78
  79         return strings.Join(x, "")
  80 }
  81
  82 // ModelPlural version of a name. ie. "user" => "Users"
  83 func (n Name) ModelPlural() string {
  84         return Camelize(Pluralize(n.Model()))
  85 }
  86
  87 // File version of a name
  88 func (n Name) File() string {
  89         return Underscore(Camelize(string(n)))
  90 }
  91
  92 // Table version of a name
  93 func (n Name) Table() string {
  94         return Underscore(Pluralize(string(n)))
  95 }
  96
  97 // UnderSingular version of a name
  98 func (n Name) UnderSingular() string {
  99         return Underscore(Singularize(string(n)))
 100 }
 101
 102 // PluralCamel version of a name
 103 func (n Name) PluralCamel() string {
 104         return Pluralize(Camelize(string(n)))
 105 }
 106
 107 // PluralUnder version of a name
 108 func (n Name) PluralUnder() string {
 109         return Pluralize(Underscore(string(n)))
 110 }
 111
 112 // URL version of a name
 113 func (n Name) URL() string {
 114         return n.PluralUnder()
 115 }
 116
 117 // CamelSingular version of a name
 118 func (n Name) CamelSingular() string {
 119         return Camelize(Singularize(string(n)))
 120 }
 121
 122 // VarCaseSingular version of a name. ie. "FooBar" => "fooBar"
 123 func (n Name) VarCaseSingular() string {
 124         return CamelizeDownFirst(Singularize(Underscore(n.Resource())))
 125 }
 126
 127 // VarCasePlural version of a name. ie. "FooBar" => "fooBar"
 128 func (n Name) VarCasePlural() string {
 129         return CamelizeDownFirst(n.Resource())
 130 }
 131
 132 // Lower case version of a string
 133 func (n Name) Lower() string {
 134         return strings.ToLower(string(n))
 135 }
 136
 137 // ParamID returns foo_bar_id
 138 func (n Name) ParamID() string {
 139         return fmt.Sprintf("%s_id", strings.Replace(n.UnderSingular(), "/", "_", -1))
 140 }
 141
 142 // Package returns go package
 143 func (n Name) Package() string {
 144         key := string(n)
 145
 146         for _, gp := range envy.GoPaths() {
 147                 key = strings.TrimPrefix(key, filepath.Join(gp, "src"))
 148                 key = strings.TrimPrefix(key, gp)
 149         }
 150         key = strings.TrimPrefix(key, string(filepath.Separator))
 151
 152         key = strings.Replace(key, "\\", "/", -1)
 153         return key
 154 }
 155
 156 // Char returns first character in lower case, this is useful for methods inside a struct.
 157 func (n Name) Char() string {
 158         return strings.ToLower(string(n[0]))
 159 }
 160
 161 func (n Name) String() string {
 162         return string(n)
 163 }