otiai10/opengraph

// Package opengraph implements and parses "The Open Graph Protocol" of web pages.
// See http://ogp.me/ for more information.
package opengraph

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "path"
    "strings"

    "golang.org/x/net/html"
)

const (
    // HTMLMetaTag is a tag name of <meta>
    HTMLMetaTag string = "meta"
    // HTMLLinkTag is a tag name of <link>
    HTMLLinkTag string = "link"
    // HTMLTitleTag is a tag name of <title>
    HTMLTitleTag string = "title"
)

// OpenGraph represents web page information according to OGP <ogp.me>,
// and some more additional informations like URL.Host and so.
type OpenGraph struct {

    // Basic Metadata
    // https://ogp.me/#metadata
    Title string  `json:"title"`
    Type  string  `json:"type"`
    Image []Image `json:"image"` // could be multiple
    URL   string  `json:"url"`

    // Optional Metadata
    // https://ogp.me/#optional
    Audio       []Audio  `json:"audio"` // could be multiple
    Description string   `json:"description"`
    Determiner  string   `json:"determiner"` // TODO: enum of (a, an, the, "", auto)
    Locale      string   `json:"locale"`
    LocaleAlt   []string `json:"locale_alternate"`
    SiteName    string   `json:"site_name"`
    Video       []Video  `json:"video"`

    // Additional (unofficial)
    Favicon Favicon `json:"favicon"`

    // Intent represents how to fetch, parse, and complete properties
    // of this OpenGraph object.
    // This SHOULD NOT have any meaning for "OpenGraph Protocol".
    Intent Intent `json:"-"`
}

// New constructs new OpenGraph struct and fill nullable fields.
func New(rawurl string) *OpenGraph {
    return &OpenGraph{
        Image:     []Image{},
        Audio:     []Audio{},
        Video:     []Video{},
        LocaleAlt: []string{},
        Intent: Intent{
            URL: rawurl,
        },
    }
}

// Fetch creates and parses OpenGraph with specified URL.
func Fetch(url string, intent ...Intent) (*OpenGraph, error) {
    ogp := New(url)
    if len(intent) > 0 {
        ogp.Intent = intent[0]
    }
    ogp.Intent.URL = url
    err := ogp.Fetch()
    return ogp, err
}

// Fetch ...
func (og *OpenGraph) Fetch() error {
    if og.Intent.URL == "" {
        return fmt.Errorf("no URL given yet")
    }

    if og.Intent.HTTPClient == nil {
        og.Intent.HTTPClient = http.DefaultClient
    }

    req, err := http.NewRequest("GET", og.Intent.URL, nil)
    if err != nil {
        return err
    }

    if og.Intent.Context == nil {
        og.Intent.Context = context.Background()
    }

    req = req.WithContext(og.Intent.Context)

    res, err := og.Intent.HTTPClient.Do(req)
    if err != nil {
        return err
    }
    defer res.Body.Close()

    if !strings.HasPrefix(res.Header.Get("Content-Type"), "text/html") {
        return fmt.Errorf("Content type must be text/html")
    }

    if err = og.Parse(res.Body); err != nil {
        return err
    }

    if !og.Intent.Strict && og.Favicon.URL == "" {
        og.Favicon.URL = "/favicon.ico"
    }

    return nil
}

// Parse parses http.Response.Body and construct OpenGraph informations.
// Caller should close body after it gets parsed.
func (og *OpenGraph) Parse(body io.Reader) error {
    node, err := html.Parse(body)
    if err != nil {
        return err
    }
    return og.Walk(node)
}

// Walk scans HTML nodes to pick up meaningful OGP data.
func (og *OpenGraph) Walk(node *html.Node) error {
    if len(og.Intent.TrustedTags) == 0 {
        if og.Intent.Strict {
            og.Intent.TrustedTags = []string{HTMLMetaTag}
        } else {
            og.Intent.TrustedTags = []string{HTMLMetaTag, HTMLTitleTag, HTMLLinkTag}
        }
    }
    return og.walk(node)
}

func (og *OpenGraph) walk(node *html.Node) error {
    if node.Type == html.ElementNode {
        switch {
        case node.Data == HTMLMetaTag && og.trust(node.Data):
            return MetaTag(node).Contribute(og)
        case node.Data == HTMLTitleTag && og.trust(node.Data):
            return TitleTag(node).Contribute(og)
        case node.Data == HTMLLinkTag && og.trust(node.Data):
            return LinkTag(node).Contribute(og)
        }
    }

    for child := node.FirstChild; child != nil; child = child.NextSibling {
        og.walk(child)
    }

    return nil
}

func (og *OpenGraph) trust(tagName string) bool {
    for _, name := range og.Intent.TrustedTags {
        if name == tagName {
            return true
        }
    }
    return false
}

// ToAbs makes all relative URLs to absolute URLs
// by applying hostname of ogp.URL or Intent.URL.
func (og *OpenGraph) ToAbs() error {
    raw := og.URL
    if raw == "" {
        raw = og.Intent.URL
    }
    base, err := url.Parse(raw)
    if err != nil {
        return err
    }
    // For og:image.
    for i, img := range og.Image {
        og.Image[i].URL = og.joinToAbsolute(base, img.URL)
    }
    // For og:audio
    for i, audio := range og.Audio {
        og.Audio[i].URL = og.joinToAbsolute(base, audio.URL)
    }
    // For og:video
    for i, video := range og.Video {
        og.Video[i].URL = og.joinToAbsolute(base, video.URL)
    }
    // For favicon
    if og.Favicon.URL != "" {
        og.Favicon.URL = og.joinToAbsolute(base, og.Favicon.URL)
    }
    return nil
}

func (og *OpenGraph) joinToAbsolute(base *url.URL, relpath string) string {
    src, err := url.Parse(relpath)
    if err == nil && src.IsAbs() {
        return src.String()
    }
    if strings.HasPrefix(relpath, "//") {
        return fmt.Sprintf("%s:%s", base.Scheme, relpath)
    }
    if strings.HasPrefix(relpath, "/") {
        return fmt.Sprintf("%s://%s%s", base.Scheme, base.Host, relpath)
    }
    return fmt.Sprintf("%s://%s%s", base.Scheme, base.Host, path.Join(base.Path, relpath))
}