func (v *Viper) Get(key string) interface{} {
lcaseKey := strings.ToLower(key)
val := v.find(lcaseKey)
if val == nil {
return nil
}
valType := val
if v.typeByDefValue {
// TODO(bep) this branch isn't covered by a single test.
path := strings.Split(lcaseKey, v.keyDelim)
defVal := v.searchMap(v.defaults, path)
if defVal != nil {
valType = defVal
}
}
switch valType.(type) {
case bool:
return cast.ToBool(val)
case string:
return cast.ToString(val)
case int64, int32, int16, int8, int:
return cast.ToInt(val)
case float64, float32:
return cast.ToFloat64(val)
case time.Time:
return cast.ToTime(val)
case time.Duration:
return cast.ToDuration(val)
case []string:
return cast.ToStringSlice(val)
}
return val
}
func readSetting(name string, lpkg *pkg.LocalPackage,
vals map[interface{}]interface{}) (CfgEntry, error) {
entry := CfgEntry{}
entry.Name = name
entry.Description = stringValue(vals["description"])
entry.Value = stringValue(vals["value"])
if vals["type"] == nil {
entry.SettingType = CFG_SETTING_TYPE_RAW
} else {
var ok bool
typename := stringValue(vals["type"])
entry.SettingType, ok = cfgSettingNameTypeMap[typename]
if !ok {
return entry, util.FmtNewtError(
"setting %s specifies invalid type: %s", name, typename)
}
}
entry.appendValue(lpkg, entry.Value)
entry.Restrictions = []CfgRestriction{}
restrictionStrings := cast.ToStringSlice(vals["restrictions"])
for _, rstring := range restrictionStrings {
r, err := readRestriction(name, rstring)
if err != nil {
return entry,
util.PreNewtError(err, "error parsing setting %s", name)
}
entry.Restrictions = append(entry.Restrictions, r)
}
return entry, nil
}
func GetStringSliceFeatures(v *viper.Viper, features map[string]bool,
key string) []string {
vals := GetSliceFeatures(v, features, key)
strVals := []string{}
for _, v := range vals {
subVals := cast.ToStringSlice(v)
strVals = append(strVals, subVals...)
}
return strVals
}
func (v *Viper) Get(key string) interface{} {
path := strings.Split(key, v.keyDelim)
var val interface{}
lcaseKey := strings.ToLower(key)
source := v.find(path[0])
if source != nil {
if reflect.TypeOf(source).Kind() == reflect.Map {
val = v.searchMap(cast.ToStringMap(source), path[1:])
}
}
if val == nil {
val = v.find(lcaseKey)
}
if val == nil {
return nil
}
var valType interface{}
if !v.typeByDefValue {
valType = val
} else {
defVal, defExists := v.defaults[lcaseKey]
if defExists {
valType = defVal
} else {
valType = val
}
}
switch valType.(type) {
case bool:
return cast.ToBool(val)
case string:
return cast.ToString(val)
case int64, int32, int16, int8, int:
return cast.ToInt(val)
case float64, float32:
return cast.ToFloat64(val)
case time.Time:
return cast.ToTime(val)
case time.Duration:
return cast.ToDuration(val)
case []string:
return cast.ToStringSlice(val)
}
return val
}
func (p *Page) update(f interface{}) error {
if f == nil {
return fmt.Errorf("no metadata found")
}
m := f.(map[string]interface{})
var err error
var draft, published, isCJKLanguage *bool
for k, v := range m {
loki := strings.ToLower(k)
switch loki {
case "title":
p.Title = cast.ToString(v)
case "linktitle":
p.linkTitle = cast.ToString(v)
case "description":
p.Description = cast.ToString(v)
case "slug":
p.Slug = cast.ToString(v)
case "url":
if url := cast.ToString(v); strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
return fmt.Errorf("Only relative URLs are supported, %v provided", url)
}
p.URL = cast.ToString(v)
case "type":
p.contentType = cast.ToString(v)
case "extension", "ext":
p.extension = cast.ToString(v)
case "keywords":
p.Keywords = cast.ToStringSlice(v)
case "date":
p.Date, err = cast.ToTimeE(v)
if err != nil {
jww.ERROR.Printf("Failed to parse date '%v' in page %s", v, p.File.Path())
}
case "lastmod":
p.Lastmod, err = cast.ToTimeE(v)
if err != nil {
jww.ERROR.Printf("Failed to parse lastmod '%v' in page %s", v, p.File.Path())
}
case "publishdate", "pubdate":
p.PublishDate, err = cast.ToTimeE(v)
if err != nil {
jww.ERROR.Printf("Failed to parse publishdate '%v' in page %s", v, p.File.Path())
}
case "draft":
draft = new(bool)
*draft = cast.ToBool(v)
case "published": // Intentionally undocumented
published = new(bool)
*published = cast.ToBool(v)
case "layout":
p.Layout = cast.ToString(v)
case "markup":
p.Markup = cast.ToString(v)
case "weight":
p.Weight = cast.ToInt(v)
case "aliases":
p.Aliases = cast.ToStringSlice(v)
for _, alias := range p.Aliases {
if strings.HasPrefix(alias, "http://") || strings.HasPrefix(alias, "https://") {
return fmt.Errorf("Only relative aliases are supported, %v provided", alias)
}
}
case "status":
p.Status = cast.ToString(v)
case "sitemap":
p.Sitemap = parseSitemap(cast.ToStringMap(v))
case "iscjklanguage":
isCJKLanguage = new(bool)
*isCJKLanguage = cast.ToBool(v)
default:
// If not one of the explicit values, store in Params
switch vv := v.(type) {
case bool:
p.Params[loki] = vv
case string:
p.Params[loki] = vv
case int64, int32, int16, int8, int:
p.Params[loki] = vv
case float64, float32:
p.Params[loki] = vv
case time.Time:
p.Params[loki] = vv
default: // handle array of strings as well
switch vvv := vv.(type) {
case []interface{}:
if len(vvv) > 0 {
switch vvv[0].(type) {
case map[interface{}]interface{}: // Proper parsing structured array from YAML based FrontMatter
p.Params[loki] = vvv
case map[string]interface{}: // Proper parsing structured array from JSON based FrontMatter
p.Params[loki] = vvv
default:
a := make([]string, len(vvv))
for i, u := range vvv {
a[i] = cast.ToString(u)
}
p.Params[loki] = a
}
} else {
p.Params[loki] = []string{}
}
default:
p.Params[loki] = vv
}
}
}
}
if draft != nil && published != nil {
p.Draft = *draft
jww.ERROR.Printf("page %s has both draft and published settings in its frontmatter. Using draft.", p.File.Path())
return ErrHasDraftAndPublished
} else if draft != nil {
p.Draft = *draft
} else if published != nil {
p.Draft = !*published
}
if p.Lastmod.IsZero() {
p.Lastmod = p.Date
}
if isCJKLanguage != nil {
p.isCJKLanguage = *isCJKLanguage
} else if viper.GetBool("HasCJKLanguage") {
if cjk.Match(p.rawContent) {
p.isCJKLanguage = true
} else {
p.isCJKLanguage = false
}
}
return nil
}
func (v *Viper) GetStringSlice(key string) []string {
return cast.ToStringSlice(v.Get(key))
}
func (page *Page) update(f interface{}) error {
if f == nil {
return fmt.Errorf("no metadata found")
}
m := f.(map[string]interface{})
for k, v := range m {
loki := strings.ToLower(k)
switch loki {
case "title":
page.Title = cast.ToString(v)
case "linktitle":
page.linkTitle = cast.ToString(v)
case "description":
page.Description = cast.ToString(v)
case "slug":
page.Slug = helpers.Urlize(cast.ToString(v))
case "url":
if url := cast.ToString(v); strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
return fmt.Errorf("Only relative urls are supported, %v provided", url)
}
page.Url = helpers.Urlize(cast.ToString(v))
case "type":
page.contentType = cast.ToString(v)
case "keywords":
page.Keywords = cast.ToStringSlice(v)
case "date", "pubdate":
page.Date = cast.ToTime(v)
case "draft":
page.Draft = cast.ToBool(v)
case "layout":
page.layout = cast.ToString(v)
case "markup":
page.Markup = cast.ToString(v)
case "weight":
page.Weight = cast.ToInt(v)
case "aliases":
page.Aliases = cast.ToStringSlice(v)
for _, alias := range page.Aliases {
if strings.HasPrefix(alias, "http://") || strings.HasPrefix(alias, "https://") {
return fmt.Errorf("Only relative aliases are supported, %v provided", alias)
}
}
case "status":
page.Status = cast.ToString(v)
case "sitemap":
page.Sitemap = parseSitemap(cast.ToStringMap(v))
default:
// If not one of the explicit values, store in Params
switch vv := v.(type) {
case bool:
page.Params[loki] = vv
case string:
page.Params[loki] = vv
case int64, int32, int16, int8, int:
page.Params[loki] = vv
case float64, float32:
page.Params[loki] = vv
case time.Time:
page.Params[loki] = vv
default: // handle array of strings as well
switch vvv := vv.(type) {
case []interface{}:
var a = make([]string, len(vvv))
for i, u := range vvv {
a[i] = cast.ToString(u)
}
page.Params[loki] = a
default:
page.Params[loki] = vv
}
}
}
}
return nil
}
func GetStringSlice(key string) []string {
return cast.ToStringSlice(Get(key))
}
// Returns the value associated with the key as a slice of strings
func (c RawConfig) GetStringSlice(key string) []string {
return cast.ToStringSlice(c.Get(key))
}
func (manager *Config) GetStringSlice(key string) []string {
return cast.ToStringSlice(manager.Get(key))
}
func (v *Viper) Get(key string) interface{} {
path := strings.Split(key, v.keyDelim)
lcaseKey := strings.ToLower(key)
val := v.find(lcaseKey)
if val == nil {
source := v.find(strings.ToLower(path[0]))
if source != nil {
if reflect.TypeOf(source).Kind() == reflect.Map {
val = v.searchMap(cast.ToStringMap(source), path[1:])
}
}
}
// if no other value is returned and a flag does exist for the value,
// get the flag's value even if the flag's value has not changed
if val == nil {
if flag, exists := v.pflags[lcaseKey]; exists {
jww.TRACE.Println(key, "get pflag default", val)
switch flag.ValueType() {
case "int", "int8", "int16", "int32", "int64":
val = cast.ToInt(flag.ValueString())
case "bool":
val = cast.ToBool(flag.ValueString())
default:
val = flag.ValueString()
}
}
}
if val == nil {
return nil
}
var valType interface{}
if !v.typeByDefValue {
valType = val
} else {
defVal, defExists := v.defaults[lcaseKey]
if defExists {
valType = defVal
} else {
valType = val
}
}
switch valType.(type) {
case bool:
return cast.ToBool(val)
case string:
return cast.ToString(val)
case int64, int32, int16, int8, int:
return cast.ToInt(val)
case float64, float32:
return cast.ToFloat64(val)
case time.Time:
return cast.ToTime(val)
case time.Duration:
return cast.ToDuration(val)
case []string:
return cast.ToStringSlice(val)
}
return val
}
func (p *Page) update(f interface{}) error {
if f == nil {
return fmt.Errorf("no metadata found")
}
m := f.(map[string]interface{})
var err error
for k, v := range m {
loki := strings.ToLower(k)
switch loki {
case "title":
p.Title = cast.ToString(v)
case "linktitle":
p.linkTitle = cast.ToString(v)
case "description":
p.Description = cast.ToString(v)
case "slug":
p.Slug = cast.ToString(v)
case "url":
if url := cast.ToString(v); strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
return fmt.Errorf("Only relative URLs are supported, %v provided", url)
}
p.URL = cast.ToString(v)
case "type":
p.contentType = cast.ToString(v)
case "extension", "ext":
p.extension = cast.ToString(v)
case "keywords":
p.Keywords = cast.ToStringSlice(v)
case "date":
p.Date, err = cast.ToTimeE(v)
if err != nil {
jww.ERROR.Printf("Failed to parse date '%v' in page %s", v, p.File.Path())
}
case "lastmod":
p.Lastmod, err = cast.ToTimeE(v)
if err != nil {
jww.ERROR.Printf("Failed to parse lastmod '%v' in page %s", v, p.File.Path())
}
case "publishdate", "pubdate":
p.PublishDate, err = cast.ToTimeE(v)
if err != nil {
jww.ERROR.Printf("Failed to parse publishdate '%v' in page %s", v, p.File.Path())
}
case "draft":
p.Draft = cast.ToBool(v)
case "layout":
p.layout = cast.ToString(v)
case "markup":
p.Markup = cast.ToString(v)
case "weight":
p.Weight = cast.ToInt(v)
case "aliases":
p.Aliases = cast.ToStringSlice(v)
for _, alias := range p.Aliases {
if strings.HasPrefix(alias, "http://") || strings.HasPrefix(alias, "https://") {
return fmt.Errorf("Only relative aliases are supported, %v provided", alias)
}
}
case "status":
p.Status = cast.ToString(v)
case "sitemap":
p.Sitemap = parseSitemap(cast.ToStringMap(v))
default:
// If not one of the explicit values, store in Params
switch vv := v.(type) {
case bool:
p.Params[loki] = vv
case string:
p.Params[loki] = vv
case int64, int32, int16, int8, int:
p.Params[loki] = vv
case float64, float32:
p.Params[loki] = vv
case time.Time:
p.Params[loki] = vv
default: // handle array of strings as well
switch vvv := vv.(type) {
case []interface{}:
var a = make([]string, len(vvv))
for i, u := range vvv {
a[i] = cast.ToString(u)
}
p.Params[loki] = a
default:
p.Params[loki] = vv
}
}
}
}
if p.Lastmod.IsZero() {
p.Lastmod = p.Date
}
return nil
}
