Repository navigation
Expand file tree
/
Copy pathparser.go
More file actions
162 lines (139 loc) · 3.59 KB
/
Copy pathparser.go
File metadata and controls
162 lines (139 loc) · 3.59 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
package readability
import (
"bytes"
"io"
"net/url"
"regexp"
"strings"
"golang.org/x/net/html"
)
const (
defaultMaxElemsToParse = 0
defaultNTopCandidates = 5
defaultCharThreshold = 500
)
type parseFlag int
const (
flagStripUnlikelys parseFlag = 1 << iota // 0x1
flagWeightClasses // 0x2
flagCleanConditionally // 0x4
)
type parseAttempt struct {
articleContent *html.Node
textLength int
}
type parser struct {
doc *html.Node
rawHTML []byte
articleTitle string
articleByline string
articleDir string
articleLang string
articleSiteName string
metadata articleMetadata
flags parseFlag
attempts []parseAttempt
scores map[*html.Node]*contentScore
dataTableFlags map[*html.Node]bool
// options
maxElemsToParse int
nbTopCandidates int
charThreshold int
classesToPreserve []string
keepClasses bool
disableJSONLD bool
allowedVideoRegex *regexp.Regexp
linkDensityModifier float64
baseURI string
documentURI string
debugWriter io.Writer
}
func newParser(documentURI string, opts ...Option) *parser {
p := &parser{
flags: flagStripUnlikelys | flagWeightClasses | flagCleanConditionally,
scores: make(map[*html.Node]*contentScore),
dataTableFlags: make(map[*html.Node]bool),
maxElemsToParse: defaultMaxElemsToParse,
nbTopCandidates: defaultNTopCandidates,
charThreshold: defaultCharThreshold,
classesToPreserve: []string{"page"},
allowedVideoRegex: rxVideos,
documentURI: documentURI,
baseURI: documentURI,
}
for _, opt := range opts {
opt(p)
}
return p
}
func (p *parser) flagIsActive(flag parseFlag) bool {
return p.flags&flag != 0
}
func (p *parser) removeFlag(flag parseFlag) {
p.flags = p.flags &^ flag
}
func (p *parser) reparseDoc() {
doc, err := html.Parse(bytes.NewReader(p.rawHTML))
if err != nil {
return
}
p.doc = doc
p.scores = make(map[*html.Node]*contentScore)
p.dataTableFlags = make(map[*html.Node]bool)
}
func (p *parser) run() (*Article, error) {
if p.maxElemsToParse > 0 {
allElems := getElementsByTagName(p.doc, "*")
if len(allElems) > p.maxElemsToParse {
return nil, ErrTooManyElements
}
}
p.unwrapNoscriptImages()
var jsonld articleMetadata
if !p.disableJSONLD {
jsonld = p.getJSONLD()
}
p.removeScripts()
p.prepDocument()
metadata := p.getArticleMetadata(jsonld)
p.metadata = metadata
p.articleTitle = metadata.title
baseFromDoc := findDocumentBaseURI(p.doc)
if baseFromDoc != "" {
docBase, err := url.Parse(p.documentURI)
if err == nil {
ref, err := url.Parse(baseFromDoc)
if err == nil {
p.baseURI = docBase.ResolveReference(ref).String()
} else {
p.baseURI = baseFromDoc
}
} else {
p.baseURI = baseFromDoc
}
}
articleContent := p.grabArticle()
if articleContent == nil {
return nil, nil
}
p.postProcessContent(articleContent)
if metadata.excerpt == "" {
paragraphs := getElementsByTagName(articleContent, "p")
if len(paragraphs) > 0 {
metadata.excerpt = strings.TrimSpace(textContent(paragraphs[0]))
}
}
tc := textContent(articleContent)
return &Article{
Title: p.articleTitle,
Byline: firstNonEmpty(metadata.byline, p.articleByline),
Dir: p.articleDir,
Lang: p.articleLang,
Content: innerHTML(articleContent),
TextContent: tc,
Length: len(tc),
Excerpt: metadata.excerpt,
SiteName: firstNonEmpty(metadata.siteName, p.articleSiteName),
PublishedTime: metadata.publishedTime,
}, nil
}