` (table row), `` (table heading), and ` ` (table data).
Here's a simple HTML table with two columns and three rows:
```{r}
html <- minimal_html("
x
y
1.5
2.7
4.9
1.3
7.2
8.1
")
```
Because tables are a common way to store data, rvest includes the handy `html_table()` which converts a table into a data frame:
```{r}
html %>%
html_node("table") %>%
html_table()
```
## Element vs elements
When using rvest, your eventual goal is usually to build up a data frame, and you want each row to correspond some repeated unit on the HTML page.
In this case, you should generally start by using `html_elements()` to select the elements that contain each observation then use `html_element()` to extract the variables from each observation.
This guarantees that you'll get the same number of values for each variable because `html_element()` always returns the same number of outputs as inputs.
To illustrate this problem take a look at this simple example I constructed using a few entries from `dplyr::starwars`:
```{r}
html <- minimal_html("
C-3PO is a droid that weighs 167 kg R2-D2 is a droid that weighs 96 kg Yoda weighs 66 kg R4-P17 is a droid
")
```
If you try to extract name, species, and weight directly, you end up with one vector of length four and two vectors of length three, and no way to align them:
```{r}
html %>% html_elements("b") %>% html_text2()
html %>% html_elements("i") %>% html_text2()
html %>% html_elements(".weight") %>% html_text2()
```
Instead, use `html_elements()` to find a element that corresponds to each character, then use `html_element()` to extract each variable for all observations:
```{r}
characters <- html %>% html_elements("li")
characters %>% html_element("b") %>% html_text2()
characters %>% html_element("i") %>% html_text2()
characters %>% html_element(".weight") %>% html_text2()
```
`html_element()` automatically fills in `NA` when no elements match, keeping all of the variables aligned and making it easy to create a data frame:
```{r}
data.frame(
name = characters %>% html_element("b") %>% html_text2(),
species = characters %>% html_element("i") %>% html_text2(),
weight = characters %>% html_element(".weight") %>% html_text2()
)
```
rvest/vignettes/starwars.Rmd 0000644 0001750 0001750 00000001651 13775161316 016106 0 ustar nilesh nilesh ---
title: "Star Wars films"
output: rmarkdown::html_vignette
vignette: >
%\VignetteIndexEntry{Star Wars films}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
This vignette contains some data about the Star Wars films for use in rvest examples and vignettes.
```{r, echo = FALSE, results = "asis"}
library(rvest)
crawl_html <- function(x) {
x %>%
gsub("\r", "", .) %>%
gsub("\n\n", "", .) %>%
gsub("\n", " ", .) %>%
paste0("
", ., "
")
}
film_desc <- function(x) {
glue::glue_data(x, "
{title}
Released: {release_date}
Director: {director}
{crawl_html(opening_crawl)}
")
}
films <- repurrrsive::sw_films
films <- films[order(sapply(films, "[[", "episode_id"))]
descs <- vapply(films, film_desc, character(1))
writeLines(descs)
```
rvest/build/ 0000755 0001750 0001750 00000000000 14132343545 012652 5 ustar nilesh nilesh rvest/build/vignette.rds 0000644 0001750 0001750 00000000347 14132343545 015215 0 ustar nilesh nilesh uM0h8;6nBQ6w ab3뼓MLDQw[-~cBz"Arѳ:bgWĜYyq|u M?6{qEd>/p4iZ҂p3FL- 3.qT3`5+reLJ,^5:|%{@麮MTD
K9AO)# rvest/tests/ 0000755 0001750 0001750 00000000000 13767413737 012733 5 ustar nilesh nilesh rvest/tests/testthat/ 0000755 0001750 0001750 00000000000 14132660177 014560 5 ustar nilesh nilesh rvest/tests/testthat/test-rename.R 0000644 0001750 0001750 00000001724 13775436633 017145 0 ustar nilesh nilesh test_that("xml functions are deprecated", {
x <- minimal_html("Hello
")
expect_snapshot(. <- xml_tag(x))
expect_snapshot(. <- xml_node(x, "p"))
expect_snapshot(. <- xml_nodes(x, "p"))
})
test_that("html_node(s) is superseded (no warnings)", {
x <- minimal_html("Hello
")
expect_equal(html_node(x, "p"), html_element(x, "p"))
expect_equal(html_nodes(x, "p"), html_elements(x, "p"))
})
test_that("set_values() is deprecated", {
html <- minimal_html('
')
form <- html_form(html)[[1]]
expect_snapshot(set_values(form, text = "abc"))
})
test_that("prefixless session functions are deprecated", {
expect_snapshot({
s <- html_session("http://rvest.tidyverse.org/")
. <- follow_link(s, i = 1)
s <- jump_to(s, "https://rvest.tidyverse.org/reference/index.html")
s <- back(s)
s <- forward(s)
})
})
# session_submit() is tested in form-submit because it needs a test server
rvest/tests/testthat/test-encoding.R 0000644 0001750 0001750 00000001040 14132340655 017435 0 ustar nilesh nilesh test_that("can guess encoding", {
path <- system.file("html-ex", "bad-encoding.html", package = "rvest")
x <- read_html(path)
expect_snapshot(html_encoding_guess(x))
# deprecated
expect_snapshot(guess_encoding(x))
})
test_that("encoding repair is deprecated", {
skip_on_cran()
path <- system.file("html-ex", "bad-encoding.html", package = "rvest")
x <- read_html(path)
text <- html_text(html_element(x, "p"))
expect_snapshot(repair_encoding(text), error = TRUE)
expect_snapshot(repair_encoding(text, "ISO-8859-1"))
})
rvest/tests/testthat/test-selectors.R 0000644 0001750 0001750 00000004163 13775423620 017671 0 ustar nilesh nilesh test_that("can select one or more nodes", {
html <- minimal_html("
")
expect_s3_class(html_elements(html, "p"), "xml_nodeset")
expect_s3_class(html_element(html, "p"), "xml_node")
})
test_that("xpath with // selects from root", {
test <- read_html(test_path("test.html"))
p <- html_elements(test, xpath = "//p")
expect_equal(length(p), 4)
p2 <- html_elements(p[[1]], xpath = "//p")
expect_equal(length(p2), 4)
p3 <- html_elements(p[[3]], xpath = "b")
expect_equal(length(p3), 1)
b <- html_elements(p, xpath = "b")
expect_equal(length(b), 2)
})
test_that("css class selects from current value", {
test <- read_html(test_path("test.html"))
p <- html_elements(test, css = "p")
expect_equal(length(p), 4)
p3 <- html_elements(p[[3]], css = "b")
expect_equal(length(p3), 1)
b <- html_elements(p, css = "b")
expect_equal(length(b), 2)
})
test_that("css selects don't select themselves", {
test <- read_html(test_path("test.html"))
p <- test %>% html_elements("p") %>% html_elements("p")
expect_equal(length(p), 0)
p <- test %>% html_elements("p") %>% `[[`(1) %>% html_elements("p")
expect_equal(length(p), 0)
})
test_that("css selects find all children", {
test <- read_html(test_path("test.html"))
b <- test %>% html_elements("body") %>% html_elements("b")
expect_equal(length(b), 3)
})
test_that("empty matches returns empty list", {
test <- read_html(test_path("test.html"))
none <- test %>% html_elements("none")
expect_equal(length(none), 0)
expect_equal(none %>% html_element("none") %>% length(), 0)
expect_equal(none %>% html_elements("none") %>% length(), 0)
})
# make_selector -----------------------------------------------------------
test_that("validates inputs", {
expect_snapshot(make_selector(), error = TRUE)
expect_snapshot(make_selector("a", "b"), error = TRUE)
expect_snapshot(make_selector(css = 1), error = TRUE)
expect_snapshot(make_selector(xpath = 1), error = TRUE)
})
test_that("converts css to xpath", {
expect_equal(make_selector(css = "p"), ".//p")
})
test_that("preserves xpath", {
expect_equal(make_selector(xpath = ".//p"), ".//p")
})
rvest/tests/testthat/test-form.R 0000644 0001750 0001750 00000013614 13775645536 016646 0 ustar nilesh nilesh test_that("can find from from doc, nodes, and node", {
html <- minimal_html('
')
forms <- html_form(html)
expect_type(forms, "list")
expect_length(forms, 2)
forms <- html_form(html_elements(html, "form"))
expect_type(forms, "list")
expect_length(forms, 2)
form <- html_form(html_element(html, "form"))
expect_s3_class(form, "rvest_form")
})
test_that("has useful print method", {
html <- minimal_html('
')
expect_snapshot(html_form(html, base_url = "http://google.com")[[1]])
expect_snapshot(html_form(html)[[1]]$fields[[2]])
})
test_that("select options are named character vector", {
select <- minimal_html("select parsing", '
')
form <- select %>% html_element("form") %>% html_form()
expect_equal(form$fields[[1]]$options, c(a = "1", b = "2"))
})
test_that("select values are inherited from names", {
page <- minimal_html("optional values", '
x
y
')
opts <- page %>% html_element('select') %>% parse_select()
expect_equal(opts$options, c(x = "1", y = "y"))
})
test_that("parse_fields gets the button", {
select <- minimal_html("button test", '
')
form <- select %>% html_element("form") %>% html_form()
expect_equal(form$fields[[1]]$type, "button")
})
test_that("handles different encoding types", {
expect_equal(convert_enctype(NULL), "form")
expect_equal(convert_enctype("application/x-www-form-urlencoded"), "form")
expect_equal(convert_enctype("multipart/form-data"), "multipart")
expect_snapshot(convert_enctype("unknown"))
})
# set --------------------------------------------------------------
test_that("can set values of inputs", {
html <- minimal_html('
')
form <- html_form(html)[[1]]
form <- html_form_set(form, text = "abc")
expect_equal(form$fields$text$value, "abc")
# warns that setting hidden field
expect_snapshot(form <- html_form_set(form, hidden = "abc"))
expect_equal(form$fields$hidden$value, "abc")
})
test_that("has informative errors", {
html <- minimal_html('
')
form <- html_form(html)[[1]]
expect_snapshot(html_form_set(form, text = "x"), error = TRUE)
expect_snapshot(html_form_set(form, missing = "x"), error = TRUE)
})
# submit ------------------------------------------------------------------
test_that("works as expected in simple case", {
html <- minimal_html('
')
form <- html_form(html, base_url = "http://here.com")[[1]]
sub <- submission_build(form, "clickMe")
expect_equal(sub$method, "POST")
expect_equal(sub$action, "http://here.com/test-path")
expect_equal(sub$values, list(x = "1"))
})
test_that("useful feedback on invalid forms", {
html <- minimal_html("")
form <- html_form(html)[[1]]
expect_snapshot(submission_build(form, NULL), error = TRUE)
html <- minimal_html("")
form <- html_form(html)[[1]]
expect_snapshot(x <- submission_build(form, NULL))
})
test_that("can handle multiple values", {
html <- minimal_html('
')
form <- html_form(html)[[1]]
form <- html_form_set(form, x = c("1", "2", "3"), y = character())
expect_equal(
submission_build_values(form),
list(x = "1", x = "2", x = "3")
)
})
test_that("handles multiple buttons", {
html <- minimal_html('
')
form <- html_form(html)[[1]]
# Messages when picking automatically
expect_snapshot(vals <- submission_build_values(form, NULL))
expect_equal(vals, list(one = "1"))
expect_equal(submission_build_values(form, "two"), list(two = "2"))
expect_equal(submission_build_values(form, 2L), list(two = "2"))
# Useful failure messages
expect_snapshot(submission_build_values(form, 3L), error = TRUE)
expect_snapshot(submission_build_values(form, "three"), error = TRUE)
expect_snapshot(submission_build_values(form, TRUE), error = TRUE)
})
test_that("handles no buttons", {
html <- minimal_html('
')
form <- html_form(html)[[1]]
expect_equal(
submission_build_values(form),
list(x = "1")
)
})
test_that("can submit using three primary techniques", {
app <- webfakes::local_app_process(app_request())
html <- minimal_html('
')
form <- html_form(html, base_url = app$url())[[1]]
expect_snapshot({
show_response(html_form_submit(form))
form$method <- "POST"
show_response(html_form_submit(form))
form$enctype <- "multipart"
show_response(html_form_submit(form))
})
})
rvest/tests/testthat/test-session.R 0000644 0001750 0001750 00000005634 14017431436 017347 0 ustar nilesh nilesh test_that("basic session process works as expected", {
expect_snapshot({
s <- session("http://hadley.nz/")
s
expect_true(is.session(s))
s <- session_follow_link(s, css = "p a")
session_history(s)
})
})
test_that("session caches xml parsing and sets base url", {
s <- session("https://rvest.tidyverse.org/")
expect_equal(s$cache$html, NULL)
html <- read_html(s)
expect_true(rlang::is_reference(s$cache$html, html))
expect_equal(xml2::xml_url(html), "https://rvest.tidyverse.org/")
})
test_that("errors if try to access HTML from non-HTML page", {
expect_snapshot(error = TRUE, {
s <- session("https://rvest.tidyverse.org/logo.png")
read_html(s)
})
})
test_that("session responds to httr and rvest methods", {
# skip_on_cran()
s <- session("http://rstudio.com/")
expect_silent(html_form(s))
expect_silent(html_table(s))
expect_silent(html_element(s, "body"))
expect_silent(html_element(s, "body"))
expect_silent(status_code(s))
expect_silent(headers(s))
expect_silent(cookies(s))
})
test_that("informative errors for bad inputs", {
expect_snapshot_error(check_form(1))
expect_snapshot_error(check_session(1))
})
# navigation --------------------------------------------------------------
test_that("can navigate back and forward", {
s <- session("http://hadley.nz/")
expect_equal(s$back, character())
expect_equal(s$forward, character())
expect_snapshot_error(session_back(s))
expect_snapshot_error(session_forward(s))
s <- session_jump_to(s, "hadley-wickham.jpg")
expect_equal(s$back, "http://hadley.nz/")
expect_equal(s$forward, character())
expect_equal(session_forward(session_back(s))$url, s$url)
s <- session_back(s)
expect_equal(s$back, character())
expect_equal(s$forward, "http://hadley.nz/hadley-wickham.jpg")
s <- session_forward(s)
expect_equal(s$back, "http://hadley.nz/")
expect_equal(s$forward, character())
})
test_that("can find link by position, content, css, or xpath", {
html <- minimal_html("
a
b
")
expect_equal(find_href(html, i = 1), "a")
expect_equal(find_href(html, i = "b"), "b")
expect_equal(find_href(html, css = "a.b"), "b")
# Failure modes
expect_snapshot(find_href(html, i = 1, css = "a"), error = TRUE)
expect_snapshot(find_href(html, i = TRUE), error = TRUE)
expect_snapshot(find_href(html, i = "c"), error = TRUE)
expect_snapshot(find_href(html, css = "p a"), error = TRUE)
})
test_that("can submit a form", {
app <- webfakes::local_app_process(app_request())
html <- minimal_html('
')
form <- html_form(html, base_url = app$url())[[1]]
s <- session("http://hadley.nz/")
s <- session_submit(s, form)
expect_s3_class(s, "rvest_session")
resp <- httr::content(s$response)
expect_equal(resp$query, "x=1&y=2")
})
rvest/tests/testthat/test-html.R 0000644 0001750 0001750 00000000567 13775424427 016644 0 ustar nilesh nilesh test_that("forwards to xml2 functions", {
html <- minimal_html("Hello children
")
p <- html_elements(html, "p")
expect_equal(html_name(p), "p")
expect_equal(html_attr(p, "id"), "x")
expect_equal(html_attr(p, "id2"), NA_character_)
expect_equal(html_attrs(p), list(c(id = "x")))
expect_equal(html_children(p), html_elements(html, "i"))
})
rvest/tests/testthat/test-table.R 0000644 0001750 0001750 00000010261 14101012613 016725 0 ustar nilesh nilesh test_that("can parse simple table", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("strips whitespace", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_equal(table$x, c("x", "x", "x"))
})
test_that("can parse with colspan", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("can parse with rowspan", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("can handle wobbling rowspan", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("can handle trailing rowspans", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("can handle blank colspans", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("can handle blank rowspans", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("can handle empty row", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
test_that("defaults to minimal name repair", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_named(table, c("x", "x", ""))
})
test_that("adds names if needed", {
html <- minimal_html('
')
table <- html_table(html)[[1]]
expect_named(table, c("X1", "X2"))
})
test_that("passes arguments to type.convert", {
html <- minimal_html("
")
table <- html_table(html, na.strings = "")[[1]]
expect_equal(table$x, "NA")
table <- html_table(html, dec = ",")[[1]]
expect_equal(table$y, 1.2)
})
test_that("no conversion", {
html <- minimal_html('
')
table <- html_table(html, convert = FALSE)[[1]]
expect_snapshot_output(table)
})
test_that("fill = FALSE is deprecated", {
html <- minimal_html('
')
expect_snapshot({
. <- html_table(html, fill = FALSE)
. <- html_table(html, fill = TRUE)
})
})
test_that("can handle empty tables", {
html <- minimal_html('')
table <- html_table(html)[[1]]
expect_snapshot_output(table)
})
rvest/tests/testthat/test.html 0000644 0001750 0001750 00000000134 12362565206 016423 0 ustar nilesh nilesh
x\nyz
")
p <- html_elements(html, "p")
expect_equal(html_text(p), "x\nyz")
})
# html_text2 --------------------------------------------------------------
test_that("handles block containing only inline elements", {
html <- minimal_html("a b c
")
expect_equal(html_text2(html), "a b c")
# internal newlines are trimmed
html <- minimal_html("a\n\nb\nc
")
expect_equal(html_text2(html), "a b c")
})
test_that("handles multiple paragraphs with line breaks", {
html <- minimal_html("
a
b
")
expect_equal(html_text2(html), "a\tb\n1\t2\n2\t3")
})
test_that("handles mixed block as well as can be expected", {
html <- minimal_html("
")
expect_equal(html_text2(html_element(html, "div")), "a\n\nb\n")
})
test_that("returns NA for xml_missing", {
expect_equal(html_text2(xml2::xml_missing()), NA_character_)
})
test_that("breaks as expected", {
expect_identical(tag_margin("p"), 2L)
expect_identical(tag_margin("li"), 1L)
expect_identical(tag_margin("b"), 0L)
})
# inline ------------------------------------------------------------------
test_that("handle single line of text", {
html <- minimal_html("a b c
")
expect_equal(html_text_inline(html_element(html, "p")), "a b c")
# collapses space across nodes
html <- minimal_html("a b c
")
expect_equal(html_text_inline(html_element(html, "p")), "a b c")
})
test_that("converts br to \n", {
html <- minimal_html("
")
expect_equal(html_text_inline(html_element(html, "p")), "\nx")
html <- minimal_html("x
")
expect_equal(html_text_inline(html_element(html, "p")), "x\n")
html <- minimal_html("
")
expect_equal(html_text_inline(html_element(html, "p")), "\n\n")
})
test_that("empty block returns empty string", {
html <- minimal_html("
")
expect_equal(html_text_inline(html_element(html, "p")), "")
})
test_that("collapse whitespace handles single line", {
expect_equal(collapse_whitespace("\n\tx\t\n"), "x")
expect_equal(collapse_whitespace("x y"), "x y")
})
test_that("optionally preserve nbsp", {
expect_equal(collapse_whitespace("x \u00a0 y"), "x y")
expect_equal(collapse_whitespace("x\u00a0y", TRUE), "x\u00a0y")
})
# PaddedText --------------------------------------------------------------
test_that("margins only added within text", {
text <- PaddedText$new()
text$add_margin(1)
text$add_text("x")
text$add_margin(1)
expect_equal(text$output(), "x")
})
test_that("margins are collapsed", {
text <- PaddedText$new()
text$add_text("x")
text$add_margin(1)
expect_equal(text$lines, 1)
text$add_margin(2)
expect_equal(text$lines, 2)
text$add_text("y")
expect_equal(text$output(), "x\n\ny")
})
test_that("empty text is ignored", {
text <- PaddedText$new()
text$add_text("")
text$add_margin(1)
text$add_text("x")
expect_equal(text$output(), "x")
})
rvest/tests/testthat/test-utils.R 0000644 0001750 0001750 00000000400 13775334175 017022 0 ustar nilesh nilesh test_that("can truncate strings", {
expect_equal(str_trunc("abcdef", 10), "abcdef")
expect_equal(str_trunc("abcdef", 4), "a...")
})
test_that("minimal html doesn't change unexpectedly", {
expect_snapshot(cat(as.character(minimal_html("Hi"))))
})
rvest/tests/testthat/_snaps/ 0000755 0001750 0001750 00000000000 14132340572 016035 5 ustar nilesh nilesh rvest/tests/testthat/_snaps/table.md 0000644 0001750 0001750 00000003177 14132340572 017456 0 ustar nilesh nilesh # can parse simple table
# A tibble: 2 x 3
x y z
1 1 Eve Jackson
2 2 John Doe
# can parse with colspan
# A tibble: 3 x 3
x y z
1 1 1 1
2 1 1 2
3 1 2 2
# can parse with rowspan
# A tibble: 3 x 3
x y z
1 1 2 3
2 1 2 3
3 1 2 3
# can handle wobbling rowspan
# A tibble: 3 x 3
x y z
1 1a 1b 1c
2 1a 2b 1c
3 3a 2b 3c
# can handle trailing rowspans
# A tibble: 4 x 3
x y z
1 1 2 3
2 NA 2 3
3 NA 2 NA
4 NA 2 NA
# can handle blank colspans
# A tibble: 2 x 2
x y
1 1 2
2 3 3
# can handle blank rowspans
# A tibble: 2 x 2
x y
1 1 2
2 3 3
# can handle empty row
# A tibble: 1 x 1
x
1 2
# no conversion
# A tibble: 1 x 2
x y
1 001 100.0
# fill = FALSE is deprecated
Code
. <- html_table(html, fill = FALSE)
Warning
The `fill` argument of `html_table()` is deprecated as of rvest 1.0.0.
An improved algorithm fills by default so it is no longer needed.
Code
. <- html_table(html, fill = TRUE)
# can handle empty tables
# A tibble: 0 x 0
rvest/tests/testthat/_snaps/selectors.md 0000644 0001750 0001750 00000000652 14132340566 020370 0 ustar nilesh nilesh # validates inputs
Code
make_selector()
Error
Please supply one of css or xpath
---
Code
make_selector("a", "b")
Error
Please supply css or xpath, not both
---
Code
make_selector(css = 1)
Error
`css` must be a string
---
Code
make_selector(xpath = 1)
Error
`xpath` must be a string
rvest/tests/testthat/_snaps/session.md 0000644 0001750 0001750 00000002601 14132340572 020041 0 ustar nilesh nilesh # basic session process works as expected
Code
s <- session("http://hadley.nz/")
s
Output
http://hadley.nz/
Status: 200
Type: text/html
Size: 9090
Code
expect_true(is.session(s))
s <- session_follow_link(s, css = "p a")
Message
Navigating to http://rstudio.com
Code
session_history(s)
Output
http://hadley.nz/
- https://www.rstudio.com/
# errors if try to access HTML from non-HTML page
Code
s <- session("https://rvest.tidyverse.org/logo.png")
read_html(s)
Error
Page doesn't appear to be html.
# informative errors for bad inputs
`form` must be a single form produced by html_form()
---
`x` must be produced by session()
# can navigate back and forward
Can't go back any further
---
Can't go forward any further
# can find link by position, content, css, or xpath
Code
find_href(html, i = 1, css = "a")
Error
Must supply exactly one of `i`, `css`, or `xpath`
---
Code
find_href(html, i = TRUE)
Error
`i` must a string or integer
---
Code
find_href(html, i = "c")
Error
No links have text 'c'
---
Code
find_href(html, css = "p a")
Error
No links matched `css`/`xpath`
rvest/tests/testthat/_snaps/encoding.md 0000644 0001750 0001750 00000003202 14132340564 020143 0 ustar nilesh nilesh # can guess encoding
Code
html_encoding_guess(x)
Output
encoding language confidence
1 ISO-8859-1 fr 0.31
2 ISO-8859-2 ro 0.22
3 UTF-16BE 0.10
4 UTF-16LE 0.10
5 GB18030 zh 0.10
6 Big5 zh 0.10
7 ISO-8859-9 tr 0.06
8 IBM424_rtl he 0.01
9 IBM424_ltr he 0.01
---
Code
guess_encoding(x)
Warning
`guess_encoding()` was deprecated in rvest 1.0.0.
Please use `html_encoding_guess()` instead.
Output
encoding language confidence
1 ISO-8859-1 fr 0.31
2 ISO-8859-2 ro 0.22
3 UTF-16BE 0.10
4 UTF-16LE 0.10
5 GB18030 zh 0.10
6 Big5 zh 0.10
7 ISO-8859-9 tr 0.06
8 IBM424_rtl he 0.01
9 IBM424_ltr he 0.01
# encoding repair is deprecated
Code
repair_encoding(text)
Warning
`html_encoding_repair()` was deprecated in rvest 1.0.0.
Instead, re-load using the `encoding` argument of `read_html()`
Error
No guess has more than 50% confidence
---
Code
repair_encoding(text, "ISO-8859-1")
Warning
`html_encoding_repair()` was deprecated in rvest 1.0.0.
Instead, re-load using the `encoding` argument of `read_html()`
Output
[1] "Émigré cause célèbre déjà vu."
rvest/tests/testthat/_snaps/rename.md 0000644 0001750 0001750 00000003537 14132340566 017641 0 ustar nilesh nilesh # xml functions are deprecated
Code
. <- xml_tag(x)
Warning
`xml_tag()` was deprecated in rvest 1.0.0.
Please use `html_name()` instead.
---
Code
. <- xml_node(x, "p")
Warning
`xml_node()` was deprecated in rvest 1.0.0.
Please use `html_element()` instead.
---
Code
. <- xml_nodes(x, "p")
Warning
`xml_nodes()` was deprecated in rvest 1.0.0.
Please use `html_elements()` instead.
# set_values() is deprecated
Code
set_values(form, text = "abc")
Warning
`set_values()` was deprecated in rvest 1.0.0.
Please use `html_form_set()` instead.
Output