Merge pull request #6 from dnesting/master

Ensure itemscope always starts a new item
master
Ian Davis 2020-10-11 17:59:04 +01:00 committed by GitHub
commit f9a084323d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 133 additions and 84 deletions

View File

@ -121,8 +121,18 @@ func (p *Parser) Parse() (*Microdata, error) {
}) })
for _, node := range topLevelItemNodes { for _, node := range topLevelItemNodes {
item := NewItem() p.data.Items = append(p.data.Items, p.readItem(nil, node))
p.data.Items = append(p.data.Items, item) }
return p.data, nil
}
func (p *Parser) readItem(item *Item, node *html.Node) *Item {
var parent *Item
if _, exists := getAttr("itemscope", node); exists {
parent, item = item, NewItem()
if itemtypes, exists := getAttr("itemtype", node); exists { if itemtypes, exists := getAttr("itemtype", node); exists {
for _, itemtype := range strings.Split(strings.TrimSpace(itemtypes), " ") { for _, itemtype := range strings.Split(strings.TrimSpace(itemtypes), " ") {
itemtype = strings.TrimSpace(itemtype) itemtype = strings.TrimSpace(itemtype)
@ -143,105 +153,76 @@ func (p *Parser) Parse() (*Microdata, error) {
itemref = strings.TrimSpace(itemref) itemref = strings.TrimSpace(itemref)
if refnode, exists := p.identifiedNodes[itemref]; exists { if refnode, exists := p.identifiedNodes[itemref]; exists {
p.readItem(item, refnode) if refnode != node {
} p.readItem(item, refnode)
}
}
for child := node.FirstChild; child != nil; {
p.readItem(item, child)
child = child.NextSibling
}
}
return p.data, nil
}
func (p *Parser) readItem(item *Item, node *html.Node) {
if itemprop, exists := getAttr("itemprop", node); exists {
if _, exists := getAttr("itemscope", node); exists {
subitem := NewItem()
if itemrefs, exists := getAttr("itemref", node); exists {
for _, itemref := range strings.Split(strings.TrimSpace(itemrefs), " ") {
itemref = strings.TrimSpace(itemref)
if refnode, exists := p.identifiedNodes[itemref]; exists {
if refnode != node {
p.readItem(subitem, refnode)
}
} }
} }
} }
}
}
for child := node.FirstChild; child != nil; { if itemprop, exists := getAttr("itemprop", node); exists {
p.readItem(subitem, child) if parent != nil {
child = child.NextSibling // an itemprop on an itemscope has value of the item created by the itemscope
}
for _, propertyName := range strings.Split(strings.TrimSpace(itemprop), " ") { for _, propertyName := range strings.Split(strings.TrimSpace(itemprop), " ") {
propertyName = strings.TrimSpace(propertyName) propertyName = strings.TrimSpace(propertyName)
if propertyName != "" { if propertyName != "" {
item.AddItem(propertyName, subitem) parent.AddItem(propertyName, item)
} }
} }
} else {
var propertyValue string
return switch node.DataAtom {
case atom.Meta:
} if val, exists := getAttr("content", node); exists {
propertyValue = val
var propertyValue string
switch node.DataAtom {
case atom.Meta:
if val, exists := getAttr("content", node); exists {
propertyValue = val
}
case atom.Audio, atom.Embed, atom.Iframe, atom.Img, atom.Source, atom.Track, atom.Video:
if urlValue, exists := getAttr("src", node); exists {
if parsedURL, err := p.base.Parse(urlValue); err == nil {
propertyValue = parsedURL.String()
} }
} case atom.Audio, atom.Embed, atom.Iframe, atom.Img, atom.Source, atom.Track, atom.Video:
case atom.A, atom.Area, atom.Link: if urlValue, exists := getAttr("src", node); exists {
if urlValue, exists := getAttr("href", node); exists { if parsedURL, err := p.base.Parse(urlValue); err == nil {
if parsedURL, err := p.base.Parse(urlValue); err == nil { propertyValue = parsedURL.String()
propertyValue = parsedURL.String() }
} }
} case atom.A, atom.Area, atom.Link:
case atom.Object: if urlValue, exists := getAttr("href", node); exists {
if urlValue, exists := getAttr("data", node); exists { if parsedURL, err := p.base.Parse(urlValue); err == nil {
propertyValue = urlValue propertyValue = parsedURL.String()
} }
case atom.Data, atom.Meter: }
if urlValue, exists := getAttr("value", node); exists { case atom.Object:
propertyValue = urlValue if urlValue, exists := getAttr("data", node); exists {
} propertyValue = urlValue
case atom.Time: }
if urlValue, exists := getAttr("datetime", node); exists { case atom.Data, atom.Meter:
propertyValue = urlValue if urlValue, exists := getAttr("value", node); exists {
} propertyValue = urlValue
}
default: case atom.Time:
var text bytes.Buffer if urlValue, exists := getAttr("datetime", node); exists {
walk(node, func(n *html.Node) { propertyValue = urlValue
if n.Type == html.TextNode {
text.WriteString(n.Data)
} }
}) default:
propertyValue = text.String() var text bytes.Buffer
} walk(node, func(n *html.Node) {
if n.Type == html.TextNode {
text.WriteString(n.Data)
}
if len(propertyValue) > 0 { })
for _, propertyName := range strings.Split(strings.TrimSpace(itemprop), " ") { propertyValue = text.String()
propertyName = strings.TrimSpace(propertyName) }
if propertyName != "" {
item.AddString(propertyName, propertyValue) if len(propertyValue) > 0 {
for _, propertyName := range strings.Split(strings.TrimSpace(itemprop), " ") {
propertyName = strings.TrimSpace(propertyName)
if propertyName != "" {
item.AddString(propertyName, propertyValue)
}
} }
} }
} }
} }
for child := node.FirstChild; child != nil; { for child := node.FirstChild; child != nil; {
@ -249,6 +230,7 @@ func (p *Parser) readItem(item *Item, node *html.Node) {
child = child.NextSibling child = child.NextSibling
} }
return item
} }
func getAttr(name string, node *html.Node) (string, bool) { func getAttr(name string, node *html.Node) (string, bool) {

View File

@ -583,8 +583,9 @@ func TestSkipSelfReferencingItemref(t *testing.T) {
actual := ParseData(html, t) actual := ParseData(html, t)
child := NewItem() child := NewItem()
child.AddString("title", "Foo") child.AddType("http://data-vocabulary.org/Breadcrumb")
child.AddString("url", "http://example.com/foo/bar") child.AddString("url", "http://example.com/foo/bar")
child.AddString("title", "Foo")
item := NewItem() item := NewItem()
item.AddType("http://schema.org/WebPage") item.AddType("http://schema.org/WebPage")
@ -597,3 +598,69 @@ func TestSkipSelfReferencingItemref(t *testing.T) {
t.Errorf("Expecting %v but got %v", expected, actual) t.Errorf("Expecting %v but got %v", expected, actual)
} }
} }
// This test validates that properties within an itemscope'd element remain
// with that contained item even if it is not, via itemprop, made an explicit child
// of its container item.
func TestPropertiesInContainedItem(t *testing.T) {
html := `
<body itemscope itemtype="http://schema.org/WebPage">
<meta itemprop="foo" content="foo value">
<div itemscope itemtype="http://schema.org/Person">
<meta itemprop="bar" content="bar value">
</div>
<div itemscope itemtype="http://schema.org/Person" itemprop="author">
<meta itemprop="baz" content="baz value">
</div>
</body>`
actual := ParseData(html, t)
// There should be two top-level items: WebPage and the Person that isn't an author.
if len(actual.Items) != 2 {
t.Fatalf("expected 2 top-level items, got %d", len(actual.Items))
}
outer := actual.Items[0]
inner := actual.Items[1]
// The first item should be a WebPage. The properties in its contained items should
// not be properties of the containing item.
if len(outer.Types) != 1 || outer.Types[0] != "http://schema.org/WebPage" {
t.Fatalf("expected outer to be http://schema.org/WebPage, got %v", outer.Types)
}
if _, present := outer.Properties["bar"]; present {
t.Errorf("outer should not have a 'bar' property, got %v", outer.Properties["bar"])
}
if _, present := outer.Properties["baz"]; present {
t.Errorf("outer should not have a 'baz' property, got %v", outer.Properties["baz"])
}
// The second item should be the non-author child element of outer. Since there is
// no itemprop attribute, it's not a child *item* of outer but it should stand as its
// own item.
if len(inner.Types) != 1 || inner.Types[0] != "http://schema.org/Person" {
t.Fatalf("expected inner to be http://schema.org/Person, got %v", inner.Types)
}
if _, present := inner.Properties["bar"]; !present {
t.Errorf("inner should have a 'bar' property")
}
// The third item is the author, which should be a child item (via the 'author' itemprop)
// of outer. It, too, should have its own discrete type and property.
if list := outer.Properties["author"]; len(list) == 1 {
if author, ok := list[0].(*Item); ok {
if len(author.Types) != 1 || author.Types[0] != "http://schema.org/Person" {
t.Fatalf("expected author to be http://schema.org/Person, got %v", author.Types)
}
if _, present := author.Properties["baz"]; !present {
t.Errorf("inner should have a 'baz' property")
}
} else {
t.Errorf("expected author item, got %v", list)
}
} else {
t.Errorf("expected outer to have a child of author, got %v", outer.Properties["author"])
}
}