phoenix/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2024-07-02 15:20:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

page: make receiver name on Page methods consistent

Browse source 
Apply some Golint rules on Page, esp. making the method receiver names consistent:

(page *Page) ==> (p *Page)
This commit is contained in:
bep 2015-03-07 12:25:38 +01:00
parent 8539f78143
commit e24a775962
1 changed files with 103 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

208
hugolib/page.go
View file

@ -252,25 +252,25 @@ func (p *Page) IsRenderable() bool {
return p.renderable return p.renderable
} }
func (page *Page) Type() string { func (p *Page) Type() string {
if page.contentType != "" { if p.contentType != "" {
return page.contentType return p.contentType
} }
if x := page.Section(); x != "" { if x := p.Section(); x != "" {
return x return x
} }
return "page" return "page"
} }
func (page *Page) Section() string { func (p *Page) Section() string {
return page.Source.Section() return p.Source.Section()
} }
func (page *Page) Layout(l ...string) []string { func (p *Page) Layout(l ...string) []string {
if page.layout != "" { if p.layout != "" {
return layouts(page.Type(), page.layout) return layouts(p.Type(), p.layout)
} }
layout := "" layout := ""
@ -280,7 +280,7 @@ func (page *Page) Layout(l ...string) []string {
layout = l[0] layout = l[0]
} }
return layouts(page.Type(), layout) return layouts(p.Type(), layout)
} }
func layouts(types string, layout string) (layouts []string) { func layouts(types string, layout string) (layouts []string) {
@ -303,7 +303,7 @@ func layouts(types string, layout string) (layouts []string) {
return return
} }
func NewPageFrom(buf io.Reader, name string) (page *Page, err error) { func NewPageFrom(buf io.Reader, name string) (*Page, error) {
p, err := NewPage(name) p, err := NewPage(name)
if err != nil { if err != nil {
return p, err return p, err
@ -313,7 +313,7 @@ func NewPageFrom(buf io.Reader, name string) (page *Page, err error) {
return p, err return p, err
} }
func NewPage(name string) (page *Page, err error) { func NewPage(name string) (*Page, error) {
if len(name) == 0 { if len(name) == 0 {
return nil, errors.New("Zero length page name") return nil, errors.New("Zero length page name")
} }
@ -374,34 +374,32 @@ func (p *Page) permalink() (*url.URL, error) {
func (p *Page) Extension() string { func (p *Page) Extension() string {
if p.extension != "" { if p.extension != "" {
return p.extension return p.extension
} else {
return viper.GetString("DefaultExtension")
} }
return viper.GetString("DefaultExtension")
} }
func (p *Page) LinkTitle() string { func (p *Page) LinkTitle() string {
if len(p.linkTitle) > 0 { if len(p.linkTitle) > 0 {
return p.linkTitle return p.linkTitle
} else {
return p.Title
} }
return p.Title
} }
func (page *Page) ShouldBuild() bool { func (p *Page) ShouldBuild() bool {
if viper.GetBool("BuildFuture") || page.PublishDate.IsZero() || page.PublishDate.Before(time.Now()) { if viper.GetBool("BuildFuture") || p.PublishDate.IsZero() || p.PublishDate.Before(time.Now()) {
if viper.GetBool("BuildDrafts") || !page.Draft { if viper.GetBool("BuildDrafts") || !p.Draft {
return true return true
} }
} }
return false return false
} }
func (page *Page) IsDraft() bool { func (p *Page) IsDraft() bool {
return page.Draft return p.Draft
} }
func (page *Page) IsFuture() bool { func (p *Page) IsFuture() bool {
if page.PublishDate.Before(time.Now()) { if p.PublishDate.Before(time.Now()) {
return false return false
} }
return true return true
@ -438,7 +436,7 @@ func (p *Page) RelPermalink() (string, error) {
return link.String(), nil return link.String(), nil
} }
func (page *Page) update(f interface{}) error { func (p *Page) update(f interface{}) error {
if f == nil { if f == nil {
return fmt.Errorf("no metadata found") return fmt.Errorf("no metadata found")
} }
@ -448,66 +446,66 @@ func (page *Page) update(f interface{}) error {
loki := strings.ToLower(k) loki := strings.ToLower(k)
switch loki { switch loki {
case "title": case "title":
page.Title = cast.ToString(v) p.Title = cast.ToString(v)
case "linktitle": case "linktitle":
page.linkTitle = cast.ToString(v) p.linkTitle = cast.ToString(v)
case "description": case "description":
page.Description = cast.ToString(v) p.Description = cast.ToString(v)
case "slug": case "slug":
page.Slug = helpers.Urlize(cast.ToString(v)) p.Slug = helpers.Urlize(cast.ToString(v))
case "url": case "url":
if url := cast.ToString(v); strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") { if url := cast.ToString(v); strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
return fmt.Errorf("Only relative urls are supported, %v provided", url) return fmt.Errorf("Only relative urls are supported, %v provided", url)
} }
page.Url = helpers.Urlize(cast.ToString(v)) p.Url = helpers.Urlize(cast.ToString(v))
case "type": case "type":
page.contentType = cast.ToString(v) p.contentType = cast.ToString(v)
case "extension", "ext": case "extension", "ext":
page.extension = cast.ToString(v) p.extension = cast.ToString(v)
case "keywords": case "keywords":
page.Keywords = cast.ToStringSlice(v) p.Keywords = cast.ToStringSlice(v)
case "date": case "date":
page.Date, err = cast.ToTimeE(v) p.Date, err = cast.ToTimeE(v)
if err != nil { if err != nil {
jww.ERROR.Printf("Failed to parse date '%v' in page %s", v, page.File.Path()) jww.ERROR.Printf("Failed to parse date '%v' in page %s", v, p.File.Path())
} }
case "publishdate", "pubdate": case "publishdate", "pubdate":
page.PublishDate, err = cast.ToTimeE(v) p.PublishDate, err = cast.ToTimeE(v)
if err != nil { if err != nil {
jww.ERROR.Printf("Failed to parse publishdate '%v' in page %s", v, page.File.Path()) jww.ERROR.Printf("Failed to parse publishdate '%v' in page %s", v, p.File.Path())
} }
case "draft": case "draft":
page.Draft = cast.ToBool(v) p.Draft = cast.ToBool(v)
case "layout": case "layout":
page.layout = cast.ToString(v) p.layout = cast.ToString(v)
case "markup": case "markup":
page.Markup = cast.ToString(v) p.Markup = cast.ToString(v)
case "weight": case "weight":
page.Weight = cast.ToInt(v) p.Weight = cast.ToInt(v)
case "aliases": case "aliases":
page.Aliases = cast.ToStringSlice(v) p.Aliases = cast.ToStringSlice(v)
for _, alias := range page.Aliases { for _, alias := range p.Aliases {
if strings.HasPrefix(alias, "http://") || strings.HasPrefix(alias, "https://") { if strings.HasPrefix(alias, "http://") || strings.HasPrefix(alias, "https://") {
return fmt.Errorf("Only relative aliases are supported, %v provided", alias) return fmt.Errorf("Only relative aliases are supported, %v provided", alias)
} }
} }
case "status": case "status":
page.Status = cast.ToString(v) p.Status = cast.ToString(v)
case "sitemap": case "sitemap":
page.Sitemap = parseSitemap(cast.ToStringMap(v)) p.Sitemap = parseSitemap(cast.ToStringMap(v))
default: default:
// If not one of the explicit values, store in Params // If not one of the explicit values, store in Params
switch vv := v.(type) { switch vv := v.(type) {
case bool: case bool:
page.Params[loki] = vv p.Params[loki] = vv
case string: case string:
page.Params[loki] = vv p.Params[loki] = vv
case int64, int32, int16, int8, int: case int64, int32, int16, int8, int:
page.Params[loki] = vv p.Params[loki] = vv
case float64, float32: case float64, float32:
page.Params[loki] = vv p.Params[loki] = vv
case time.Time: case time.Time:
page.Params[loki] = vv p.Params[loki] = vv
default: // handle array of strings as well default: // handle array of strings as well
switch vvv := vv.(type) { switch vvv := vv.(type) {
case []interface{}: case []interface{}:
@ -515,9 +513,9 @@ func (page *Page) update(f interface{}) error {
for i, u := range vvv { for i, u := range vvv {
a[i] = cast.ToString(u) a[i] = cast.ToString(u)
} }
page.Params[loki] = a p.Params[loki] = a
default: default:
page.Params[loki] = vv p.Params[loki] = vv
} }
} }
} }
@ -526,8 +524,8 @@ func (page *Page) update(f interface{}) error {
} }
func (page *Page) GetParam(key string) interface{} { func (p *Page) GetParam(key string) interface{} {
v := page.Params[strings.ToLower(key)] v := p.Params[strings.ToLower(key)]
if v == nil { if v == nil {
return nil return nil
@ -556,8 +554,8 @@ func (page *Page) GetParam(key string) interface{} {
return nil return nil
} }
func (page *Page) HasMenuCurrent(menu string, me *MenuEntry) bool { func (p *Page) HasMenuCurrent(menu string, me *MenuEntry) bool {
menus := page.Menus() menus := p.Menus()
if m, ok := menus[menu]; ok { if m, ok := menus[menu]; ok {
if me.HasChildren() { if me.HasChildren() {
@ -573,8 +571,8 @@ func (page *Page) HasMenuCurrent(menu string, me *MenuEntry) bool {
} }
func (page *Page) IsMenuCurrent(menu string, inme *MenuEntry) bool { func (p *Page) IsMenuCurrent(menu string, inme *MenuEntry) bool {
menus := page.Menus() menus := p.Menus()
if me, ok := menus[menu]; ok { if me, ok := menus[menu]; ok {
return me.IsEqual(inme) return me.IsEqual(inme)
@ -583,21 +581,21 @@ func (page *Page) IsMenuCurrent(menu string, inme *MenuEntry) bool {
return false return false
} }
func (page *Page) Menus() PageMenus { func (p *Page) Menus() PageMenus {
page.pageMenusInit.Do(func() { p.pageMenusInit.Do(func() {
page.pageMenus = PageMenus{} p.pageMenus = PageMenus{}
if ms, ok := page.Params["menu"]; ok { if ms, ok := p.Params["menu"]; ok {
link, _ := page.RelPermalink() link, _ := p.RelPermalink()
me := MenuEntry{Name: page.LinkTitle(), Weight: page.Weight, Url: link} me := MenuEntry{Name: p.LinkTitle(), Weight: p.Weight, Url: link}
// Could be the name of the menu to attach it to // Could be the name of the menu to attach it to
mname, err := cast.ToStringE(ms) mname, err := cast.ToStringE(ms)
if err == nil { if err == nil {
me.Menu = mname me.Menu = mname
page.pageMenus[mname] = &me p.pageMenus[mname] = &me
return return
} }
@ -607,7 +605,7 @@ func (page *Page) Menus() PageMenus {
if err == nil { if err == nil {
for _, mname := range mnames { for _, mname := range mnames {
me.Menu = mname me.Menu = mname
page.pageMenus[mname] = &me p.pageMenus[mname] = &me
return return
} }
} }
@ -616,25 +614,25 @@ func (page *Page) Menus() PageMenus {
menus, err := cast.ToStringMapE(ms) menus, err := cast.ToStringMapE(ms)
if err != nil { if err != nil {
jww.ERROR.Printf("unable to process menus for %q\n", page.Title) jww.ERROR.Printf("unable to process menus for %q\n", p.Title)
} }
for name, menu := range menus { for name, menu := range menus {
menuEntry := MenuEntry{Name: page.LinkTitle(), Url: link, Weight: page.Weight, Menu: name} menuEntry := MenuEntry{Name: p.LinkTitle(), Url: link, Weight: p.Weight, Menu: name}
jww.DEBUG.Printf("found menu: %q, in %q\n", name, page.Title) jww.DEBUG.Printf("found menu: %q, in %q\n", name, p.Title)
ime, err := cast.ToStringMapE(menu) ime, err := cast.ToStringMapE(menu)
if err != nil { if err != nil {
jww.ERROR.Printf("unable to process menus for %q\n", page.Title) jww.ERROR.Printf("unable to process menus for %q\n", p.Title)
} }
menuEntry.MarshallMap(ime) menuEntry.MarshallMap(ime)
page.pageMenus[name] = &menuEntry p.pageMenus[name] = &menuEntry
} }
} }
}) })
return page.pageMenus return p.pageMenus
} }
func (p *Page) Render(layout ...string) template.HTML { func (p *Page) Render(layout ...string) template.HTML {
@ -647,89 +645,89 @@ func (p *Page) Render(layout ...string) template.HTML {
return tpl.ExecuteTemplateToHTML(p, p.Layout(curLayout)...) return tpl.ExecuteTemplateToHTML(p, p.Layout(curLayout)...)
} }
func (page *Page) guessMarkupType() string { func (p *Page) guessMarkupType() string {
// First try the explicitly set markup from the frontmatter // First try the explicitly set markup from the frontmatter
if page.Markup != "" { if p.Markup != "" {
format := helpers.GuessType(page.Markup) format := helpers.GuessType(p.Markup)
if format != "unknown" { if format != "unknown" {
return format return format
} }
} }
return helpers.GuessType(page.Source.Ext()) return helpers.GuessType(p.Source.Ext())
} }
func (page *Page) detectFrontMatter() (f *parser.FrontmatterType) { func (p *Page) detectFrontMatter() (f *parser.FrontmatterType) {
return parser.DetectFrontMatter(rune(page.frontmatter[0])) return parser.DetectFrontMatter(rune(p.frontmatter[0]))
} }
func (page *Page) parse(reader io.Reader) error { func (p *Page) parse(reader io.Reader) error {
psr, err := parser.ReadFrom(reader) psr, err := parser.ReadFrom(reader)
if err != nil { if err != nil {
return err return err
} }
page.renderable = psr.IsRenderable() p.renderable = psr.IsRenderable()
page.frontmatter = psr.FrontMatter() p.frontmatter = psr.FrontMatter()
meta, err := psr.Metadata() meta, err := psr.Metadata()
if meta != nil { if meta != nil {
if err != nil { if err != nil {
jww.ERROR.Printf("Error parsing page meta data for %s", page.File.Path()) jww.ERROR.Printf("Error parsing page meta data for %s", p.File.Path())
jww.ERROR.Println(err) jww.ERROR.Println(err)
return err return err
} }
if err = page.update(meta); err != nil { if err = p.update(meta); err != nil {
return err return err
} }
} }
page.rawContent = psr.Content() p.rawContent = psr.Content()
return nil return nil
} }
func (page *Page) SetSourceContent(content []byte) { func (p *Page) SetSourceContent(content []byte) {
page.Source.Content = content p.Source.Content = content
} }
func (page *Page) SetSourceMetaData(in interface{}, mark rune) (err error) { func (p *Page) SetSourceMetaData(in interface{}, mark rune) (err error) {
by, err := parser.InterfaceToFrontMatter(in, mark) by, err := parser.InterfaceToFrontMatter(in, mark)
if err != nil { if err != nil {
return err return err
} }
by = append(by, '\n') by = append(by, '\n')
page.Source.Frontmatter = by p.Source.Frontmatter = by
return nil return nil
} }
func (page *Page) SafeSaveSourceAs(path string) error { func (p *Page) SafeSaveSourceAs(path string) error {
return page.saveSourceAs(path, true) return p.saveSourceAs(path, true)
} }
func (page *Page) SaveSourceAs(path string) error { func (p *Page) SaveSourceAs(path string) error {
return page.saveSourceAs(path, false) return p.saveSourceAs(path, false)
} }
func (page *Page) saveSourceAs(path string, safe bool) error { func (p *Page) saveSourceAs(path string, safe bool) error {
b := bp.GetBuffer() b := bp.GetBuffer()
defer bp.PutBuffer(b) defer bp.PutBuffer(b)
b.Write(page.Source.Frontmatter) b.Write(p.Source.Frontmatter)
b.Write(page.Source.Content) b.Write(p.Source.Content)
bc := make([]byte, b.Len(), b.Len()) bc := make([]byte, b.Len(), b.Len())
copy(bc, b.Bytes()) copy(bc, b.Bytes())
err := page.saveSource(bc, path, safe) err := p.saveSource(bc, path, safe)
if err != nil { if err != nil {
return err return err
} }
return nil return nil
} }
func (page *Page) saveSource(by []byte, inpath string, safe bool) (err error) { func (p *Page) saveSource(by []byte, inpath string, safe bool) (err error) {
if !filepath.IsAbs(inpath) { if !filepath.IsAbs(inpath) {
inpath = helpers.AbsPathify(inpath) inpath = helpers.AbsPathify(inpath)
} }
@ -746,8 +744,8 @@ func (page *Page) saveSource(by []byte, inpath string, safe bool) (err error) {
return nil return nil
} }
func (page *Page) SaveSource() error { func (p *Page) SaveSource() error {
return page.SaveSourceAs(page.FullFilePath()) return p.SaveSourceAs(p.FullFilePath())
} }
func (p *Page) ProcessShortcodes(t tpl.Template) { func (p *Page) ProcessShortcodes(t tpl.Template) {
@ -762,21 +760,21 @@ func (p *Page) ProcessShortcodes(t tpl.Template) {
// TODO(spf13): Remove this entirely // TODO(spf13): Remove this entirely
// Here for backwards compatibility & testing. Only works in isolation // Here for backwards compatibility & testing. Only works in isolation
func (page *Page) Convert() error { func (p *Page) Convert() error {
var h Handler var h Handler
if page.Markup != "" { if p.Markup != "" {
h = FindHandler(page.Markup) h = FindHandler(p.Markup)
} else { } else {
h = FindHandler(page.File.Extension()) h = FindHandler(p.File.Extension())
} }
if h != nil { if h != nil {
h.PageConvert(page, tpl.T()) h.PageConvert(p, tpl.T())
} }
//// now we know enough to create a summary of the page and count some words //// now we know enough to create a summary of the page and count some words
page.setSummary() p.setSummary()
//analyze for raw stats //analyze for raw stats
page.analyzePage() p.analyzePage()
return nil return nil
} }