/preview/pr#/ directory
27 | pkgdown:::build_site_github_pages(
28 | dest_dir = dest_dir_preview,
29 | override = list(
30 | url = file.path(url_base, dest_preview)
31 | ),
32 | clean = TRUE
33 | )
34 |
35 | msg <- paste("[preview]", pkgdown:::construct_commit_message("."))
36 | pkgdown:::github_push(dest_dir, msg, "origin", "gh-pages")
37 |
38 | message(
39 | "::notice title=pkgdown preview::",
40 | file.path(url_base, dest_preview)
41 | )
42 | })
43 |
44 |
--------------------------------------------------------------------------------
/man/debug_exercise_checker.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/debug_exercise_checker.R
3 | \name{debug_exercise_checker}
4 | \alias{debug_exercise_checker}
5 | \title{An Exercise Checker for Debugging}
6 | \usage{
7 | debug_exercise_checker(
8 | label,
9 | user_code,
10 | solution_code,
11 | check_code,
12 | envir_result,
13 | evaluate_result,
14 | envir_prep,
15 | last_value,
16 | engine,
17 | ...
18 | )
19 | }
20 | \arguments{
21 | \item{label}{Exercise label}
22 |
23 | \item{user_code}{Submitted user code}
24 |
25 | \item{solution_code}{The code in the \verb{*-solution} chunk}
26 |
27 | \item{check_code}{The checking code that originates from the \verb{*-check} chunk,
28 | the \verb{*-code-check} chunk, or the \verb{*-error-check} chunk.}
29 |
30 | \item{evaluate_result}{The return value from \code{evaluate::evaluate()}, called
31 | on \code{user_code}}
32 |
33 | \item{envir_prep, envir_result}{The environment before running user code
34 | (\code{envir_prep}) and the environment just after running the user's code
35 | (\code{envir_result}).}
36 |
37 | \item{last_value}{The last value after evaluating \code{user_code}}
38 |
39 | \item{engine}{The engine of the exercise chunk}
40 |
41 | \item{...}{Not used (future compatibility)}
42 | }
43 | \value{
44 | Feedback for use in exercise debugging.
45 | }
46 | \description{
47 | An exercise checker for debugging that renders all of the expected arguments
48 | of the \code{exercise.checker} option into HTML. Additionally, this function is
49 | used in testing of \code{evaluate_exercise()}.
50 | }
51 | \keyword{internal}
52 |
--------------------------------------------------------------------------------
/man/safe.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/run.R
3 | \name{safe}
4 | \alias{safe}
5 | \title{Execute R code in a safe R environment}
6 | \usage{
7 | safe(expr, ..., show = TRUE, env = safe_env())
8 | }
9 | \arguments{
10 | \item{expr}{expression that contains all the necessary library calls to
11 | execute. Expressions within callr do not inherit the existing,
12 | loaded libraries.}
13 |
14 | \item{...}{parameters passed to \code{callr::\link[callr]{r}}}
15 |
16 | \item{show}{Logical that determines if output should be displayed}
17 |
18 | \item{env}{Environment to evaluate the document in}
19 | }
20 | \value{
21 | The result of \code{expr}.
22 | }
23 | \description{
24 | When rendering (or running) a document with R markdown, it inherits the
25 | current R Global environment. This will produce unexpected behaviors,
26 | such as poisoning the R Global environment with existing variables. By
27 | rendering the document in a new, safe R environment, a \emph{vanilla},
28 | rendered document is produced.
29 | }
30 | \details{
31 | The environment variable \code{LEARNR_INTERACTIVE} will be set to \code{"1"}
32 | or \code{"0"} depending on if the calling session is interactive or not.
33 |
34 | Using \code{safe} should only be necessary when locally deployed.
35 | }
36 | \examples{
37 | \dontrun{
38 | # Direct usage
39 | safe(run_tutorial("hello", package = "learnr"))
40 |
41 | # Programmatic usage
42 | library(rlang)
43 |
44 | expr <- quote(run_tutorial("hello", package = "learnr"))
45 | safe(!!expr)
46 |
47 | tutorial <- "hello"
48 | safe(run_tutorial(!!tutorial, package = "learnr"))
49 | }
50 |
51 | }
52 |
--------------------------------------------------------------------------------
/vignettes/articles/example_cards.R:
--------------------------------------------------------------------------------
1 | card <- function(
2 | ...,
3 | class_card = NULL,
4 | class_card_body = NULL,
5 | class_card_title = NULL,
6 | class_card_footer = "text-end"
7 | ) {
8 | card_data <- list(...)
9 | htmltools::withTags(
10 | div(
11 | class = "col",
12 | div(
13 | class = c("card h-100 shadow-sm", class_card),
14 | a(
15 | href = card_data$link,
16 | img(
17 | src = card_data$image,
18 | class = "card-img-top",
19 | alt = paste0("Preview image of ", card_data$title)
20 | )
21 | ),
22 | div(
23 | class = c("card-body", class_card_body),
24 | h5(class = c("card-title", class_card_title), a(href = card_data$link, card_data$title)),
25 | if (!is.null(card_data$text)) div(
26 | class = "card-text text-muted fs-6",
27 | htmltools::HTML(commonmark::markdown_html(card_data$text))
28 | ),
29 | ),
30 | if (!is.null(card_data$footer)) div(
31 | class = c("card-footer", class_card_footer),
32 | htmltools::HTML(card_data$footer)
33 | )
34 | )
35 | )
36 | )
37 | }
38 |
39 | example_cards <- function(yml, group = NULL, class_row = "row-cols-1 row-cols-md-2 row-cols-lg-3") {
40 | examples <- if (is.list(yml)) {
41 | yml
42 | } else {
43 | yaml::read_yaml(yml)
44 | }
45 |
46 | examples <- purrr::keep(examples, function(x) x[["group"]] %in% group)
47 | examples <- purrr::transpose(examples)
48 |
49 | htmltools::tags$div(
50 | class = paste("row g-4", class_row),
51 | purrr::pmap(examples, card)
52 | )
53 | }
54 |
--------------------------------------------------------------------------------
/man/format_quiz.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/quiz_print.R
3 | \name{format.tutorial_question_answer}
4 | \alias{format.tutorial_question_answer}
5 | \alias{format.tutorial_question}
6 | \alias{format.tutorial_quiz}
7 | \alias{print.tutorial_question}
8 | \alias{print.tutorial_question_answer}
9 | \alias{print.tutorial_quiz}
10 | \title{Formatting and printing quizzes, questions, and answers}
11 | \usage{
12 | \method{format}{tutorial_question_answer}(x, ..., spacing = "")
13 |
14 | \method{format}{tutorial_question}(x, ..., spacing = "")
15 |
16 | \method{format}{tutorial_quiz}(x, ...)
17 |
18 | \method{print}{tutorial_question}(x, ...)
19 |
20 | \method{print}{tutorial_question_answer}(x, ...)
21 |
22 | \method{print}{tutorial_quiz}(x, ...)
23 | }
24 | \arguments{
25 | \item{x}{object of interest}
26 |
27 | \item{...}{ignored}
28 |
29 | \item{spacing}{Text to be placed at the beginning of each new line}
30 | }
31 | \description{
32 | Notes:
33 | \itemize{
34 | \item If custom question types are created, custom s3 formating methods may be implemented as well.
35 | \item Due to the shiny runtime of questions, a text representation of quizzes, questions, and answers will be presented.
36 | }
37 | }
38 | \examples{
39 | ex_question <- question("What number is the letter A in the alphabet?",
40 | answer("8"),
41 | answer("14"),
42 | answer("1", correct = TRUE),
43 | answer("23"),
44 | incorrect = "See [here](https://en.wikipedia.org/wiki/English_alphabet) and try again.",
45 | allow_retry = TRUE
46 | )
47 | cat(format(ex_question), "\n")
48 | }
49 | \seealso{
50 | \code{\link{quiz}}, \code{\link{question}}, \code{\link{answer}}
51 | }
52 |
--------------------------------------------------------------------------------
/man/rmd-fragments/learnr-examples-showcase.Rmd:
--------------------------------------------------------------------------------
1 | Here are some simple examples of tutorials created with the **learnr** package:
2 |
3 | ```{r, eval=FALSE, echo=FALSE}
4 | ## Not included to avoid rcmdcheck warnings about dependency on {quillt}
5 | # cat(format(quillt::examples("examples.yml", showcaseOnly = TRUE)))
6 | ```
7 |
8 |
45 |
--------------------------------------------------------------------------------
/learnr-js/build.js:
--------------------------------------------------------------------------------
1 | const { readFileSync } = require('fs')
2 | const { build } = require('esbuild')
3 | const babelPlugin = require('esbuild-plugin-babel')
4 |
5 | const excludeVendorFromSourceMapPlugin = ({ filter }) => ({
6 | name: 'excludeVendorFromSourceMap',
7 | setup (build) {
8 | build.onLoad({ filter }, args => {
9 | if (args.path.endsWith('.js')) {
10 | return {
11 | contents:
12 | readFileSync(args.path, 'utf8') +
13 | '\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIiJdLCJtYXBwaW5ncyI6IkEifQ==',
14 | loader: 'default'
15 | }
16 | }
17 | })
18 | }
19 | })
20 |
21 | const excludeNodeModules = excludeVendorFromSourceMapPlugin({
22 | filter: /node_modules/
23 | })
24 |
25 | const buildConfig = {
26 | sourcemap: true,
27 | bundle: true,
28 | minify: true,
29 | allowOverwrite: true,
30 | logLevel: 'info',
31 | target: ['es5'],
32 | plugins: [excludeNodeModules, babelPlugin()]
33 | }
34 |
35 | const buildTutorial = {
36 | entryPoints: ['learnr-js/tutorial/tutorial.js'],
37 | outfile: 'inst/lib/tutorial/tutorial.js',
38 | ...buildConfig
39 | }
40 |
41 | const buildTutorialFormat = {
42 | entryPoints: ['learnr-js/format/tutorial-format.js'],
43 | outfile: 'inst/rmarkdown/templates/tutorial/resources/tutorial-format.js',
44 | ...buildConfig
45 | }
46 |
47 | const buildI18N = {
48 | entryPoints: ['learnr-js/i18n/tutorial-i18n-init.js'],
49 | outfile: 'inst/lib/i18n/tutorial-i18n-init.js',
50 | ...buildConfig
51 | }
52 |
53 | build(buildTutorial).catch(() => process.exit(1))
54 | build(buildTutorialFormat).catch(() => process.exit(1))
55 | build(buildI18N).catch(() => process.exit(1))
56 |
--------------------------------------------------------------------------------
/vignettes/articles/examples.Rmd:
--------------------------------------------------------------------------------
1 | ---
2 | title: "learnr Tutorial Examples"
3 | description: >
4 | A collection of example interactive tutorials that use the learnr package.
5 | toc: false
6 | output:
7 | html_document:
8 | toc_float: false
9 | editor_options:
10 | chunk_output_type: console
11 | ---
12 |
13 | ```{r setup, include=FALSE}
14 | knitr::opts_chunk$set(echo = FALSE)
15 | source("example_cards.R", local = TRUE)
16 | ```
17 |
18 | ```{css echo=FALSE}
19 | .row > main { max-width: 100%; }
20 | ```
21 |
22 | ## Complete Tutorials
23 |
24 | These tutorials were designed to showcase the features of the learnr package --- and to teach learners how to use R!
25 | Try working through these tutorials to get a sense of the look and feel of a learnr tutorial.
26 | Then check out the source code to see how these tutorials were made!
27 |
28 | ```{r example-cards-showcase}
29 | example_cards("examples.yml", "showcase")
30 | ```
31 |
32 | ## Demo Tutorials
33 |
34 | There's a lot that learnr can do.
35 | These tutorials showcase specific learnr features or show you some possibilities that build on other packages designed to work with R Markdown and learnr.
36 |
37 | ```{r example-cards-demo}
38 | example_cards("examples.yml", "demo")
39 | ```
40 |
41 | ## Community Showcase
42 |
43 | learnr's community has built some excellent tutorials and resources
44 | for learning data science and programming.
45 | Here are just a few highlights.
46 | (Please [suggest your favorite learnr resources](https://github.com/rstudio/learnr/discussions/categories/show-and-tell).)
47 |
48 | ```{r example-cards-community}
49 | example_cards("examples.yml", "community")
50 | ```
51 |
52 | ```{js echo=FALSE}
53 | document.getElementById('main').classList = ''
54 | ```
55 |
--------------------------------------------------------------------------------
/tests/testthat/helpers.R:
--------------------------------------------------------------------------------
1 |
2 | # https://github.com/rstudio/rmarkdown/blob/2faee0040a39008a47bdf1ba840bf402cba15a65/tests/testthat/helpers.R
3 |
4 | skip_if_not_pandoc <- function(ver = NULL) {
5 | if (!rmarkdown::pandoc_available(ver)) {
6 | msg <- if (is.null(ver)) {
7 | "Pandoc is not available"
8 | } else {
9 | sprintf("Version of Pandoc is lower than %s.", ver)
10 | }
11 | skip(msg)
12 | }
13 | }
14 |
15 | skip_if_pandoc <- function(ver = NULL) {
16 | if (rmarkdown::pandoc_available(ver)) {
17 | msg <- if (is.null(ver)) {
18 | "Pandoc is available"
19 | } else {
20 | sprintf("Version of Pandoc is greater than %s.", ver)
21 | }
22 | skip(msg)
23 | }
24 | }
25 |
26 | skip_on_ci_if_not_pr <- function() {
27 | # Don't skip locally
28 | if (!nzchar(Sys.getenv("CI", ""))) return()
29 | # If on CI, don't skip if envvar set by workflow is present
30 | if (nzchar(Sys.getenv("CI_IN_PR", ""))) return()
31 | # If on CI and not in a PR branch workflow... skip these tests
32 | skip("Skipping on CI, tests run in PR checks only")
33 | }
34 |
35 | skip_if_not_py_available <- function() {
36 | skip_if_not(reticulate::py_available(initialize = TRUE), "Python not available on this system")
37 | }
38 |
39 | expect_marked_as <- function(object, correct, messages = NULL) {
40 | if (is.null(messages)) {
41 | expect_equal(object, mark_as(correct))
42 | return()
43 | }
44 |
45 | if (length(messages) > 1) {
46 | messages_orig <- messages
47 | messages <- quiz_text(messages_orig[[1]])
48 | for (i in seq_along(messages_orig)[-1]) {
49 | messages <- htmltools::tagList(messages, messages_orig[[i]])
50 | }
51 | }
52 |
53 | expect_equal(object, mark_as(correct, messages))
54 | }
55 |
--------------------------------------------------------------------------------
/pkgdown/templates/content-article.html:
--------------------------------------------------------------------------------
1 | {{^as_is}}$for(header-includes)$
2 | $header-includes$
3 | $endfor${{/as_is}}
4 |
5 | $if(banner)$
$endif$
6 |
7 |
8 |
9 |
37 |
38 | $for(include-before)$
39 | $include-before$
40 | $endfor$
41 |
42 | $if(abstract)$
43 |
44 |
Abstract
45 | $abstract$
46 |
51 | {{#toc}}
52 |
53 |
54 | {{#translate}}{{on_this_page}}{{/translate}}
55 |
56 |
57 | {{/toc}}
58 |
59 |
}}\preformatted{```\{r setup, include = FALSE\}`r ''`
32 | library(learnr)
33 | random_phrases_add(
34 | language = "en",
35 | praise = "Great work!",
36 | encouragement = "I believe in you."
37 | )
38 | ```
39 | }\if{html}{\out{
}}
40 |
41 | Alternatively, you can call \code{random_phrases_add()} in a separate, standard
42 | R chunk (with \code{echo = FALSE}):
43 |
44 | \if{html}{\out{}}\preformatted{```\{r setup-phrases, echo = FALSE\}`r ''`
45 | random_phrases_add(
46 | language = "en",
47 | praise = c("Great work!", "You're awesome!"),
48 | encouragement = c("I believe in you.", "Yes we can!")
49 | )
50 | ```
51 | }\if{html}{\out{
}}
52 | }
53 |
54 | \examples{
55 | random_phrases_add("demo", praise = "Great!", encouragement = "Try again.")
56 | random_praise(language = "demo")
57 | random_encouragement(language = "demo")
58 |
59 |
60 | }
61 |
--------------------------------------------------------------------------------
/R/html_selector.R:
--------------------------------------------------------------------------------
1 |
2 | # only handles id and classes
3 | as_selector <- function(selector) {
4 | if (inherits(selector, "shiny_selector") || inherits(selector, "shiny_selector_list")) {
5 | return(selector)
6 | }
7 |
8 | # make sure it's a trimmed string
9 | selector <- str_trim(selector)
10 |
11 | # yell if there is a comma
12 | if (grepl(",", selector, fixed = TRUE)) {
13 | stop("Do not know how to handle comma separated selector values")
14 | }
15 |
16 | # if it contains multiple elements, recurse
17 | if (grepl(" ", selector)) {
18 | selector <- lapply(strsplit(selector, "\\s+"), as_selector)
19 | selector <- structure(class = "shiny_selector_list", selector)
20 | return(selector)
21 | }
22 |
23 | match_everything <- isTRUE(all.equal(selector, "*"))
24 |
25 | element <- str_match(selector, "^([^#.]+)")
26 | selector <- str_remove(selector, "^[^#.]+")
27 |
28 | id <- str_remove(str_match(selector, "^#([^.]+)"), "#")
29 | selector <- str_remove(selector, "^#[^.]+")
30 |
31 | classes <- str_remove(str_match_all(selector, "\\.([^.]+)"), "^\\.")
32 |
33 | structure(class = "shiny_selector", list(
34 | element = element,
35 | id = id,
36 | classes = classes,
37 | match_everything = match_everything
38 | ))
39 | }
40 |
41 | as_selector_list <- function(selector) {
42 | selector <- as_selector(selector)
43 | if (inherits(selector, "shiny_selector")) {
44 | selector <- structure(class = "shiny_selector_list", list(selector))
45 | }
46 | selector
47 | }
48 |
49 | format.shiny_selector <- function(x, ...) {
50 | if (x$match_everything) {
51 | paste0("* // match everything")
52 | } else {
53 | paste0(x$element, if (!is.null(x$id)) paste0("#", x$id), paste0(".", x$classes, collapse = ""))
54 | }
55 | }
56 | format.shiny_selector_list <- function(x, ...) {
57 | paste0(unlist(lapply(x, format, ...)), collapse = " ")
58 | }
59 |
60 | print.shiny_selector <- function(x, ...) {
61 | cat("// css selector\n")
62 | cat(format(x, ...), "\n")
63 | }
64 | print.shiny_selector_list <- function(x, ...) {
65 | cat("// css selector list\n")
66 | cat(format(x, ...), "\n")
67 | }
68 |
--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | ## Pull Request
2 |
3 | Before you submit a pull request, please do the following:
4 |
5 | * Add an entry to NEWS concisely describing what you changed.
6 |
7 | * Add unit tests in the tests/testthat directory.
8 |
9 | * Run Build->Check Package in the RStudio IDE, or `devtools::check()`, to make sure your change did not add any messages, warnings, or errors.
10 |
11 | Doing these things will make it easier for the learnr development team to evaluate your pull request. Even so, we may still decide to modify your code or even not merge it at all. Factors that may prevent us from merging the pull request include:
12 |
13 | * breaking backward compatibility
14 | * adding a feature that we do not consider relevant for learnr
15 | * is hard to understand
16 | * is hard to maintain in the future
17 | * is computationally expensive
18 | * is not intuitive for people to use
19 |
20 | We will try to be responsive and provide feedback in case we decide not to merge your pull request.
21 |
22 |
23 | ## Minimal reproducible example
24 |
25 | Finally, please include a minimal reprex. The goal of a reprex is to make it as easy as possible for me to recreate your problem so that I can fix it. If you've never heard of a reprex before, start by reading , and follow the advice further down the page. Do NOT include session info unless it's explicitly asked for, or you've used `reprex::reprex(..., si = TRUE)` to hide it away.
26 | ```r
27 | reprex::reprex({
28 | library(learnr)
29 | # insert minimal reprex here
30 | })
31 | ```
32 |
33 | Due to the nature of learnr being interactive, if a reprex is not possible, please include a minimal learnr tutorial RMarkdown file that can be called with `rmarkdown::run` to produce an error or display the error has been fixed.
34 |
35 | Delete these instructions once you have read them.
36 |
37 | ---
38 |
39 | Brief description of the original problem and the approach behind your solution.
40 |
41 | ```r
42 | # insert reprex here
43 | ```
44 |
45 | PR task list:
46 | - [ ] Update NEWS
47 | - [ ] Add tests (if possible)
48 | - [ ] Update documentation with `devtools::document()`
49 |
--------------------------------------------------------------------------------
/inst/rmarkdown/templates/tutorial/skeleton/skeleton.Rmd:
--------------------------------------------------------------------------------
1 | ---
2 | title: "Tutorial"
3 | output: learnr::tutorial
4 | runtime: shiny_prerendered
5 | ---
6 |
7 | ```{r setup, include=FALSE}
8 | library(learnr)
9 | knitr::opts_chunk$set(echo = FALSE)
10 | ```
11 |
12 |
13 | ## Topic 1
14 |
15 | ### Exercise
16 |
17 | *Here's a simple exercise with an empty code chunk provided for entering the answer.*
18 |
19 | Write the R code required to add two plus two:
20 |
21 | ```{r two-plus-two, exercise=TRUE}
22 |
23 | ```
24 |
25 | ### Exercise with Code
26 |
27 | *Here's an exercise with some prepopulated code as well as `exercise.lines = 5` to provide a bit more initial room to work.*
28 |
29 | Now write a function that adds any two numbers and then call it:
30 |
31 | ```{r add-function, exercise=TRUE, exercise.lines = 5}
32 | add <- function() {
33 |
34 | }
35 | ```
36 |
37 | ## Topic 2
38 |
39 | ### Exercise with Hint
40 |
41 | *Here's an exercise where the chunk is pre-evaluated via the `exercise.eval` option (so the user can see the default output we'd like them to customize). We also add a "hint" to the correct solution via the chunk immediate below labeled `print-limit-hint`.*
42 |
43 | Modify the following code to limit the number of rows printed to 5:
44 |
45 | ```{r print-limit, exercise=TRUE, exercise.eval=TRUE}
46 | mtcars
47 | ```
48 |
49 | ```{r print-limit-hint}
50 | head(mtcars)
51 | ```
52 |
53 | ### Quiz
54 |
55 | *You can include any number of single or multiple choice questions as a quiz. Use the `question` function to define a question and the `quiz` function for grouping multiple questions together.*
56 |
57 | Some questions to verify that you understand the purposes of various base and recommended R packages:
58 |
59 | ```{r quiz}
60 | quiz(
61 | question("Which package contains functions for installing other R packages?",
62 | answer("base"),
63 | answer("tools"),
64 | answer("utils", correct = TRUE),
65 | answer("codetools")
66 | ),
67 | question("Which of the R packages listed below are used to create plots?",
68 | answer("lattice", correct = TRUE),
69 | answer("tools"),
70 | answer("stats"),
71 | answer("grid", correct = TRUE)
72 | )
73 | )
74 | ```
75 |
76 |
--------------------------------------------------------------------------------
/man/one_time.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/events.R
3 | \name{one_time}
4 | \alias{one_time}
5 | \title{Wrap an expression that will be executed one time in an event handler}
6 | \usage{
7 | one_time(session, cond, expr, label = deparse(substitute(cond)))
8 | }
9 | \arguments{
10 | \item{session}{A Shiny session object.}
11 |
12 | \item{cond}{A condition that is used as a filter. The first time the
13 | condition evaluates to true, \code{expr} will be evaluated; after that, \code{expr}
14 | will not be evaluated again.}
15 |
16 | \item{expr}{An expression that will be evaluated once, the first time that
17 | \code{cond} is true.}
18 |
19 | \item{label}{A unique identifier. This is used as an ID for the condition and
20 | expression; if two calls to \code{one_time()} uses the same label, there will be
21 | an ID collision and only one of them will execute. By default, \code{cond} is
22 | deparsed and used as the label.}
23 | }
24 | \value{
25 | The result of evaluating \code{expr} (\code{one_time()} is intended to be
26 | called within an event handler).
27 | }
28 | \description{
29 | This wraps an expression so that it will be executed one time for a tutorial,
30 | based on some condition. The first time the condition is true, the expression
31 | will be executed; after that, the expression will not be evaluated again.
32 |
33 | The execution state is stored so that if the expression is executed, then the
34 | user quits the tutorial and then returns to it, the expression will not be
35 | executed a second time.
36 |
37 | A common use for \code{one_time} is to execute an expression when a section is
38 | viewed for the first time.
39 | }
40 | \examples{
41 | \dontrun{
42 | # This goes in a {r context="server-start"} chunk
43 |
44 | # The expression with message() will be executed the first time the user
45 | # sees the section with ID "section-exercise-with-hint".
46 | event_register_handler("section_viewed",
47 | function(session, event, data) {
48 | one_time(
49 | session,
50 | data$sectionId == "section-exercise-with-hint",
51 | {
52 | message("Seeing ", data$sectionId, " for the first time.")
53 | }
54 | )
55 | }
56 | )
57 |
58 |
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/tests/testthat/test-events.R:
--------------------------------------------------------------------------------
1 | test_that("Event handlers", {
2 | # Check that session, event, data are passed to callback.
3 | result <- NULL
4 | cancel <- event_register_handler("foo",
5 | function(session, event, data) { result <<- list(session, event, data) }
6 | )
7 | on.exit(cancel(), add = TRUE)
8 | event_trigger("session_obj", "foo", "data")
9 | expect_identical(result, list("session_obj", "foo", "data"))
10 | cancel()
11 |
12 |
13 | # Testing multiple event handlers for same event, checking for order
14 | x <- numeric()
15 | cancel1 <- event_register_handler(
16 | "foo",
17 | function(session, event, data) { x <<- c(x, 1) }
18 | )
19 | on.exit(cancel1(), add = TRUE)
20 |
21 | cancel2 <- event_register_handler(
22 | "foo",
23 | function(session, event, data) { x <<- c(x, 2) }
24 | )
25 | on.exit(cancel2(), add = TRUE)
26 |
27 | event_trigger(NULL, "foo", NA)
28 | expect_identical(x, c(1, 2))
29 |
30 | event_trigger(NULL, "foo", NA)
31 | expect_identical(x, c(1, 2, 1, 2))
32 |
33 | # Cancel first handler
34 | expect_true(cancel1())
35 | expect_false(cancel1())
36 |
37 | event_trigger(NULL, "foo", NA)
38 | expect_identical(x, c(1, 2, 1, 2, 2))
39 | })
40 |
41 |
42 | test_that("Event handler input checking", {
43 | # Should error if callback has incorrect args (session, event, data)
44 | expect_error(
45 | event_register_handler("foo", function(session, data) NULL)
46 | )
47 | expect_error(
48 | event_register_handler("foo", function(session, data, event) NULL)
49 | )
50 |
51 | # Error for empty event name
52 | expect_error(
53 | event_register_handler("", function(session, event, data) NULL)
54 | )
55 | })
56 |
57 |
58 | test_that("Errors are converted to warnings", {
59 | n <- 0
60 | f <- function() g()
61 | g <- function() stop("error in g")
62 | cancel1 <- event_register_handler("foo", function(session, event, data) f())
63 | on.exit(cancel1(), add = TRUE)
64 | cancel2 <- event_register_handler("foo", function(session, event, data) n <<- n + 1)
65 | on.exit(cancel2(), add = TRUE)
66 |
67 | expect_warning(event_trigger(NULL, "foo", NA), "error in g")
68 | # Other callbacks should still have executed.
69 | expect_identical(n, 1)
70 | })
71 |
--------------------------------------------------------------------------------
/man/run_tutorial.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/run.R
3 | \name{run_tutorial}
4 | \alias{run_tutorial}
5 | \title{Run a tutorial}
6 | \usage{
7 | run_tutorial(
8 | name = NULL,
9 | package = NULL,
10 | ...,
11 | shiny_args = NULL,
12 | clean = FALSE,
13 | as_rstudio_job = NULL
14 | )
15 | }
16 | \arguments{
17 | \item{name}{Tutorial name (subdirectory within \code{tutorials/} directory of
18 | installed \code{package}). Alternatively, if \code{package} is not provided, \code{name}
19 | may be a path to a local tutorial R Markdown file or a local directory
20 | containing a learnr tutorial. If \code{package} is provided, \code{name} must be the
21 | tutorial name.}
22 |
23 | \item{package}{Name of package. If \code{name} is a path to the local directory
24 | containing a learnr tutorial, then \code{package} should not be provided.}
25 |
26 | \item{...}{Unused. Included for future expansion and to ensure named
27 | arguments are used.}
28 |
29 | \item{shiny_args}{Additional arguments to forward to
30 | \code{\link[shiny:runApp]{shiny::runApp}}.}
31 |
32 | \item{clean}{When \code{TRUE}, the shiny prerendered HTML files are removed and
33 | the tutorial is re-rendered prior to starting the tutorial.}
34 |
35 | \item{as_rstudio_job}{Runs the tutorial in the background as an RStudio job.
36 | This is the default behavior when \code{run_tutorial()} detects that RStudio is
37 | available and can run jobs. Set to \code{FALSE} to disable and to run the
38 | tutorial in the current R session.
39 |
40 | When running as an RStudio job, \code{run_tutorial()} sets or overrides the
41 | \code{launch.browser} option for \code{shiny_args}. You can instead use the
42 | \code{shiny.launch.browser} global option in your current R session to set
43 | the default behavior when the tutorial is run. See \link[shiny:shinyOptions]{the shiny options documentation} for more information.}
44 | }
45 | \value{
46 | Starts a Shiny server running the learnr tutorial.
47 | }
48 | \description{
49 | Run a tutorial provided by an installed R package.
50 | }
51 | \examples{
52 | # display all "learnr" tutorials
53 | available_tutorials("learnr")
54 |
55 | # run basic example within learnr
56 | \dontrun{
57 | run_tutorial("hello", "learnr")
58 | }
59 |
60 | }
61 | \seealso{
62 | \code{\link{safe}} and \code{\link{available_tutorials}}
63 | }
64 |
--------------------------------------------------------------------------------
/tests/testthat/tutorials/basic.Rmd:
--------------------------------------------------------------------------------
1 | ---
2 | title: "Tutorial"
3 | output: learnr::tutorial
4 | tutorial:
5 | id: test-basic
6 | version: 9.9.9
7 | runtime: shiny_prerendered
8 | ---
9 |
10 | ```{r setup, include=FALSE}
11 | library(learnr)
12 | knitr::opts_chunk$set(echo = FALSE)
13 | ```
14 |
15 |
16 | ## Topic 1
17 |
18 | ### Exercise
19 |
20 | *Here's a simple exercise with an empty code chunk provided for entering the answer.*
21 |
22 | Write the R code required to add two plus two:
23 |
24 | ```{r two-plus-two, exercise=TRUE}
25 |
26 | ```
27 |
28 | ### Exercise with Code
29 |
30 | *Here's an exercise with some prepopulated code as well as `exercise.lines = 5` to provide a bit more initial room to work.*
31 |
32 | Now write a function that adds any two numbers and then call it:
33 |
34 | ```{r add-function, exercise=TRUE, exercise.lines = 5}
35 | add <- function() {
36 |
37 | }
38 | ```
39 |
40 | ## Topic 2
41 |
42 | ### Exercise with Hint
43 |
44 | *Here's an exercise where the chunk is pre-evaluated via the `exercise.eval` option (so the user can see the default output we'd like them to customize). We also add a "hint" to the correct solution via the chunk immediate below labeled `print-limit-hint`.*
45 |
46 | Modify the following code to limit the number of rows printed to 5:
47 |
48 | ```{r print-limit, exercise=TRUE, exercise.eval=TRUE}
49 | mtcars
50 | ```
51 |
52 | ```{r print-limit-hint}
53 | head(mtcars)
54 | ```
55 |
56 | ### Quiz
57 |
58 | *You can include any number of single or multiple choice questions as a quiz. Use the `question` function to define a question and the `quiz` function for grouping multiple questions together.*
59 |
60 | Some questions to verify that you understand the purposes of various base and recommended R packages:
61 |
62 | ```{r quiz}
63 | # Quiz answers create a stochastic ID that changes when rendered from a clean state
64 | # so this chunk has been disabled.
65 | quiz(
66 | question("Which package contains functions for installing other R packages?",
67 | answer("base"),
68 | answer("tools"),
69 | answer("utils", correct = TRUE),
70 | answer("codetools")
71 | ),
72 | question("Which of the R packages listed below are used to create plots?",
73 | answer("lattice", correct = TRUE),
74 | answer("tools"),
75 | answer("stats"),
76 | answer("grid", correct = TRUE)
77 | )
78 | )
79 | ```
80 |
81 |
--------------------------------------------------------------------------------
/man/tutorial_options.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/options.R
3 | \name{tutorial_options}
4 | \alias{tutorial_options}
5 | \title{Set tutorial options}
6 | \usage{
7 | tutorial_options(
8 | exercise.cap = NULL,
9 | exercise.eval = FALSE,
10 | exercise.timelimit = 30,
11 | exercise.lines = NULL,
12 | exercise.blanks = NULL,
13 | exercise.checker = NULL,
14 | exercise.error.check.code = NULL,
15 | exercise.completion = TRUE,
16 | exercise.diagnostics = TRUE,
17 | exercise.startover = TRUE,
18 | exercise.reveal_solution = TRUE
19 | )
20 | }
21 | \arguments{
22 | \item{exercise.cap}{Caption for exercise chunk (defaults to the engine's icon or the combination of the engine and \code{" code"}).}
23 |
24 | \item{exercise.eval}{Whether to pre-evaluate the exercise so the reader can
25 | see some default output (defaults to \code{FALSE}).}
26 |
27 | \item{exercise.timelimit}{Number of seconds to limit execution time to
28 | (defaults to \code{30}).}
29 |
30 | \item{exercise.lines}{Lines of code for exercise editor (defaults to the
31 | number of lines in the code chunk).}
32 |
33 | \item{exercise.blanks}{A regular expression to be used to identify blanks in
34 | submitted code that the user should fill in. If \code{TRUE} (default), blanks
35 | are three or more underscores in a row. If \code{FALSE}, blank checking is not
36 | performed.}
37 |
38 | \item{exercise.checker}{Function used to check exercise answers
39 | (e.g., \code{gradethis::grade_learnr()}).}
40 |
41 | \item{exercise.error.check.code}{A string containing R code to use for checking
42 | code when an exercise evaluation error occurs (e.g., \code{"gradethis::grade_code()"}).}
43 |
44 | \item{exercise.completion}{Use code completion in exercise editors.}
45 |
46 | \item{exercise.diagnostics}{Show diagnostics in exercise editors.}
47 |
48 | \item{exercise.startover}{Show "Start Over" button on exercise.}
49 |
50 | \item{exercise.reveal_solution}{Whether to reveal the exercise solution if
51 | a solution chunk is provided.}
52 | }
53 | \value{
54 | Nothing. Invisibly sets \link[knitr:opts_chunk]{knitr::opts_chunk} settings.
55 | }
56 | \description{
57 | Set various tutorial options that control the display and evaluation of
58 | exercises.
59 | }
60 | \examples{
61 | if (interactive()) {
62 | tutorial_options(exercise.eval = TRUE, exercise.timelimt = 10)
63 | }
64 |
65 | }
66 |
--------------------------------------------------------------------------------
/tests/testthat/tutorials/optional-show-solution.Rmd:
--------------------------------------------------------------------------------
1 | ---
2 | title: "Optionally Reveal Exercise Solution"
3 | output: learnr::tutorial
4 | runtime: shiny_prerendered
5 | ---
6 |
7 | ```{r setup, include=FALSE}
8 | library(learnr)
9 |
10 | HIDE_SOLUTION <- FALSE
11 | SHOW_SOLUTION <- TRUE
12 |
13 | # Set global option reveal solution option
14 | # options(tutorial.exercise.reveal_solution = FALSE)
15 | # tutorial_options(exercise.reveal_solution = TRUE)
16 | #<>
17 | ```
18 |
19 | ## Intro
20 |
21 | ### Default
22 |
23 | ```{r default, exercise = TRUE}
24 | 1 + 1
25 | ```
26 |
27 | ```{r default-hint-1}
28 | # DEFAULT HINT 1
29 | ```
30 |
31 | ```{r default-hint-2}
32 | # DEFAULT HINT 2
33 | ```
34 |
35 | ```{r default-solution}
36 | # DEFAULT SOLUTION 4631b0
37 | ```
38 |
39 | ### Reveal Set on Exercise
40 |
41 | ```{r set-on-ex, exercise = TRUE, exercise.reveal_solution = TRUE}
42 | 1 + 1
43 | ```
44 |
45 | ```{r set-on-ex-hint-1}
46 | # EXERCISE OPT HINT 1
47 | ```
48 |
49 | ```{r set-on-ex-hint-2}
50 | # EXERCISE OPT HINT 2
51 | ```
52 |
53 | ```{r set-on-ex-solution}
54 | # EXERCISE OPT SOLUTION 15c861
55 | ```
56 |
57 | ### Always Hides Solution
58 |
59 | ```{r hide, exercise = TRUE, exercise.reveal_solution = TRUE}
60 | 1 + 1
61 | ```
62 |
63 | ```{r hide-hint-1}
64 | # HIDDEN HINT 1
65 | ```
66 |
67 | ```{r hide-hint-2}
68 | # HIDDEN HINT 2
69 | ```
70 |
71 | ```{r hide-solution, exercise.reveal_solution = FALSE}
72 | # HIDDEN SOLUTION 48da3c
73 | ```
74 |
75 | ### Always Shows Solution
76 |
77 | ```{r show, exercise = TRUE, exercise.reveal_solution = FALSE}
78 | 1 + 1
79 | ```
80 |
81 | ```{r show-hint-1}
82 | # SHOWN HINT 1
83 | ```
84 |
85 | ```{r show-hint-2}
86 | # SHOWN HINT 2
87 | ```
88 |
89 | ```{r show-solution, exercise.reveal_solution = TRUE}
90 | # SHOWN SOLUTION 781cbb
91 | ```
92 |
93 | ### Hidden Using Variable in Chunk Opt
94 |
95 | ```{r var-hide, exercise = TRUE, exercise.reveal_solution = HIDE_SOLUTION}
96 | 1 + 1
97 | ```
98 |
99 | ```{r var-hide-solution}
100 | # HIDDEN VAR SOLUTION 0b219b
101 | ```
102 |
103 | ### Shown Using Variable in Chunk Opt
104 |
105 | ```{r var-shown, exercise = TRUE, exercise.reveal_solution = SHOW_SOLUTION}
106 | 1 + 1
107 | ```
108 |
109 | ```{r var-shown-solution}
110 | # SHOWN VAR SOLUTION aba888
111 | ```
112 |
--------------------------------------------------------------------------------
/R/initialize.R:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | #' Initialize tutorial R Markdown extensions
5 | #'
6 | #' One time initialization of R Markdown extensions required by the
7 | #' \pkg{learnr} package. This function is typically called automatically
8 | #' as a result of using exercises or questions.
9 | #'
10 | #' @return If not previously run, initializes knitr hooks and provides the
11 | #' required [rmarkdown::shiny_prerendered_chunk()]s to initialize \pkg{learnr}.
12 | #'
13 | #' @export
14 | initialize_tutorial <- function() {
15 |
16 | # helper function for one time initialization
17 | if (isTRUE(getOption("knitr.in.progress")) &&
18 | !isTRUE(knitr::opts_knit$get("tutorial.initialized"))) {
19 |
20 | # html dependencies
21 | knitr::knit_meta_add(list(
22 | rmarkdown::html_dependency_jquery(),
23 | rmarkdown::html_dependency_font_awesome(),
24 | bootbox_html_dependency(),
25 | idb_html_dependency(),
26 | tutorial_html_dependency()
27 | ))
28 |
29 | # session initialization (forward tutorial metadata)
30 | rmarkdown::shiny_prerendered_chunk(
31 | 'server',
32 | sprintf('learnr:::register_http_handlers(session, metadata = %s)',
33 | dput_to_string(rmarkdown::metadata$tutorial)),
34 | singleton = TRUE
35 | )
36 |
37 | # clear exercise/question and initialize user state reactive
38 | rmarkdown::shiny_prerendered_chunk(
39 | 'server',
40 | 'learnr:::prepare_tutorial_state(session)',
41 | singleton = TRUE
42 | )
43 |
44 | # record tutorial language in session object
45 | rmarkdown::shiny_prerendered_chunk(
46 | "server",
47 | "learnr:::i18n_observe_tutorial_language(input, session)"
48 | )
49 |
50 | # Register session stop handler
51 | rmarkdown::shiny_prerendered_chunk(
52 | 'server',
53 | sprintf('session$onSessionEnded(function() {
54 | learnr:::event_trigger(session, "session_stop")
55 | })'),
56 | singleton = TRUE
57 | )
58 |
59 | # set initialized flag to ensure single initialization
60 | knitr::opts_knit$set(tutorial.initialized = TRUE)
61 | }
62 | }
63 |
64 |
65 | dput_to_string <- function(x) {
66 | conn <- textConnection("dput_to_string", "w")
67 | on.exit({close(conn)})
68 | dput(x, file = conn)
69 | # Must use a `"\n"` if `dput()`ing a function
70 | paste0(textConnectionValue(conn), collapse = "\n")
71 | }
72 |
--------------------------------------------------------------------------------
/inst/lib/idb-keyval/idb-keyval-iife-compat.min.js:
--------------------------------------------------------------------------------
1 | /*!
2 | idb-keyval -- super-simple-small promise-based keyval store implemented with IndexedDB
3 | Version 3.2.0
4 | https: //github.com/jakearchibald/idb-keyval
5 | (c) 2016 Jake Archibald, Apache License 2.0
6 | */
7 | "use strict";var _createClass=function(){function e(e,n){for(var t=0;t0&&void 0!==arguments[0]?arguments[0]:"keyval-store",r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"keyval";_classCallCheck(this,e),this.storeName=r,this._dbp=n(indexedDB.open(t),r).then(function(e){return e.objectStoreNames.contains(r)?e:(e.close(),n(indexedDB.open(t,e.version+1),r))})}return _createClass(e,[{key:"_withIDBStore",value:function(e,n){var t=this;return this._dbp.then(function(r){return new Promise(function(o,i){var u=r.transaction(t.storeName,e);u.oncomplete=function(){return o()},u.onabort=u.onerror=function(){return i(u.error)},n(u.objectStore(t.storeName))})})}}]),e}(),r=void 0;function o(){return r||(r=new t),r}return e.Store=t,e.get=function(e){var n=void 0;return(arguments.length>1&&void 0!==arguments[1]?arguments[1]:o())._withIDBStore("readonly",function(t){n=t.get(e)}).then(function(){return n.result})},e.set=function(e,n){return(arguments.length>2&&void 0!==arguments[2]?arguments[2]:o())._withIDBStore("readwrite",function(t){t.put(n,e)})},e.del=function(e){return(arguments.length>1&&void 0!==arguments[1]?arguments[1]:o())._withIDBStore("readwrite",function(n){n.delete(e)})},e.clear=function(){return(arguments.length>0&&void 0!==arguments[0]?arguments[0]:o())._withIDBStore("readwrite",function(e){e.clear()})},e.keys=function(){var e=[];return(arguments.length>0&&void 0!==arguments[0]?arguments[0]:o())._withIDBStore("readonly",function(n){(n.openKeyCursor||n.openCursor).call(n).onsuccess=function(){this.result&&(e.push(this.result.key),this.result.continue())}}).then(function(){return e})},e}({});
8 |
--------------------------------------------------------------------------------
/R/tutorial_package_dependencies.R:
--------------------------------------------------------------------------------
1 | get_needed_pkgs <- function(dir) {
2 |
3 | pkgs <- tutorial_dir_package_dependencies(dir)
4 |
5 | pkgs[!pkgs %in% utils::installed.packages()]
6 | }
7 |
8 | format_needed_pkgs <- function(needed_pkgs) {
9 | paste(" -", needed_pkgs, collapse = "\n")
10 | }
11 |
12 | ask_pkgs_install <- function(needed_pkgs) {
13 | question <- sprintf("Would you like to install the following packages?\n%s",
14 | format_needed_pkgs(needed_pkgs))
15 |
16 | utils::menu(choices = c("yes", "no"),
17 | title = question)
18 | }
19 |
20 | install_tutorial_dependencies <- function(dir) {
21 | needed_pkgs <- get_needed_pkgs(dir)
22 |
23 | if(length(needed_pkgs) == 0) {
24 | return(invisible(NULL))
25 | }
26 |
27 | if(!interactive()) {
28 | stop("The following packages need to be installed:\n",
29 | format_needed_pkgs(needed_pkgs))
30 | }
31 |
32 | answer <- ask_pkgs_install(needed_pkgs)
33 |
34 | if(answer == 2) {
35 | stop("The tutorial is missing required packages and cannot be rendered.")
36 | }
37 |
38 | utils::install.packages(needed_pkgs)
39 | }
40 |
41 |
42 |
43 |
44 | #' List tutorial dependencies
45 | #'
46 | #' List the \R packages required to run a particular tutorial.
47 | #'
48 | #' @param name The tutorial name. If \code{name} is \code{NULL}, then all
49 | #' tutorials within \code{package} will be searched.
50 | #' @param package The \R package providing the tutorial. If \code{package} is
51 | #' \code{NULL}, then all tutorials will be searched.
52 | #'
53 | #' @return A character vector of package names that are required for execution.
54 | #'
55 | #' @examples
56 | #' tutorial_package_dependencies(package = "learnr")
57 | #'
58 | #' @export
59 | tutorial_package_dependencies <- function(name = NULL, package = NULL) {
60 | if (identical(name, NULL)) {
61 | info <- available_tutorials(package = package)
62 | return(
63 | sort(unique(unlist(info$package_dependencies)))
64 | )
65 | }
66 |
67 | tutorial_dir_package_dependencies(
68 | get_tutorial_path(name = name, package = package)
69 | )
70 | }
71 |
72 | tutorial_dir_package_dependencies <- function(dir) {
73 | # enumerate tutorial package dependencies
74 | deps <- renv::dependencies(dir, quiet = TRUE)
75 |
76 | # R <= 3.4 can not sort(NULL)
77 | # if no deps are found, renv::dependencies returns NULL
78 | if (is.null(deps)) {
79 | return(NULL)
80 | }
81 |
82 | sort(unique(deps$Package))
83 | }
84 |
--------------------------------------------------------------------------------
/.github/workflows/pr-commands.yaml:
--------------------------------------------------------------------------------
1 | on:
2 | issue_comment:
3 | types: [created]
4 | name: Commands
5 | jobs:
6 | document:
7 | if: startsWith(github.event.comment.body, '/document')
8 | name: document
9 | runs-on: ubuntu-18.04
10 | env:
11 | GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
12 | steps:
13 | - uses: actions/checkout@v2
14 | - uses: r-lib/actions/pr-fetch@v2
15 | with:
16 | repo-token: ${{ secrets.GITHUB_TOKEN }}
17 | - uses: r-lib/actions/setup-r@v2
18 | - name: Install dependencies
19 | run: |
20 | options(repos = c(CRAN = "https://demo.rstudiopm.com/all/__linux__/bionic/latest"))
21 | install.packages(c("remotes", "roxygen2"))
22 | remotes::install_deps(dependencies = TRUE)
23 | shell: Rscript {0}
24 | - name: Document
25 | run: Rscript -e 'roxygen2::roxygenise()'
26 | - name: commit
27 | run: |
28 | git config --local user.name "$GITHUB_ACTOR"
29 | git config --local user.email "$GITHUB_ACTOR@users.noreply.github.com"
30 | git add man/\* NAMESPACE
31 | git commit -m 'Document'
32 | - uses: r-lib/actions/pr-push@v2
33 | with:
34 | repo-token: ${{ secrets.GITHUB_TOKEN }}
35 | i18n:
36 | if: startsWith(github.event.comment.body, '/i18nize')
37 | name: i18nize
38 | runs-on: ubuntu-18.04
39 | env:
40 | GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
41 | steps:
42 | - uses: actions/checkout@v2
43 | - uses: r-lib/actions/pr-fetch@v2
44 | with:
45 | repo-token: ${{ secrets.GITHUB_TOKEN }}
46 | - uses: r-lib/actions/setup-r@v2
47 | - name: Install dependencies
48 | run: |
49 | options(repos = c(CRAN = "https://demo.rstudiopm.com/all/__linux__/bionic/latest"))
50 | install.packages(c("cli", "here", "purrr", "stringi", "yaml"))
51 | shell: Rscript {0}
52 | - name: Internationalize
53 | run: Rscript data-raw/i18n_translations.R
54 | - name: commit
55 | run: |
56 | git config --local user.name "$GITHUB_ACTOR"
57 | git config --local user.email "$GITHUB_ACTOR@users.noreply.github.com"
58 | git commit inst/internals/i18n* -m 'Re-build internal internationalization data' || echo "No changes to commit"
59 | git push origin || echo "No changes to commit"
60 | - uses: r-lib/actions/pr-push@v2
61 | with:
62 | repo-token: ${{ secrets.GITHUB_TOKEN }}
--------------------------------------------------------------------------------
/pkgdown/assets/snippets/ace/theme-textmate.js:
--------------------------------------------------------------------------------
1 | ace.define("ace/theme/textmate",["require","exports","module","ace/lib/dom"],function(e,t,n){"use strict";t.isDark=!1,t.cssClass="ace-tm",t.cssText='.ace-tm .ace_gutter {background: #f0f0f0;color: #333;}.ace-tm .ace_print-margin {width: 1px;background: #e8e8e8;}.ace-tm .ace_fold {background-color: #6B72E6;}.ace-tm {background-color: #FFFFFF;color: black;}.ace-tm .ace_cursor {color: black;}.ace-tm .ace_invisible {color: rgb(191, 191, 191);}.ace-tm .ace_storage,.ace-tm .ace_keyword {color: blue;}.ace-tm .ace_constant {color: rgb(197, 6, 11);}.ace-tm .ace_constant.ace_buildin {color: rgb(88, 72, 246);}.ace-tm .ace_constant.ace_language {color: rgb(88, 92, 246);}.ace-tm .ace_constant.ace_library {color: rgb(6, 150, 14);}.ace-tm .ace_invalid {background-color: rgba(255, 0, 0, 0.1);color: red;}.ace-tm .ace_support.ace_function {color: rgb(60, 76, 114);}.ace-tm .ace_support.ace_constant {color: rgb(6, 150, 14);}.ace-tm .ace_support.ace_type,.ace-tm .ace_support.ace_class {color: rgb(109, 121, 222);}.ace-tm .ace_keyword.ace_operator {color: rgb(104, 118, 135);}.ace-tm .ace_string {color: rgb(3, 106, 7);}.ace-tm .ace_comment {color: rgb(76, 136, 107);}.ace-tm .ace_comment.ace_doc {color: rgb(0, 102, 255);}.ace-tm .ace_comment.ace_doc.ace_tag {color: rgb(128, 159, 191);}.ace-tm .ace_constant.ace_numeric {color: rgb(0, 0, 205);}.ace-tm .ace_variable {color: rgb(49, 132, 149);}.ace-tm .ace_xml-pe {color: rgb(104, 104, 91);}.ace-tm .ace_entity.ace_name.ace_function {color: #0000A2;}.ace-tm .ace_heading {color: rgb(12, 7, 255);}.ace-tm .ace_list {color:rgb(185, 6, 144);}.ace-tm .ace_meta.ace_tag {color:rgb(0, 22, 142);}.ace-tm .ace_string.ace_regex {color: rgb(255, 0, 0)}.ace-tm .ace_marker-layer .ace_selection {background: rgb(181, 213, 255);}.ace-tm.ace_multiselect .ace_selection.ace_start {box-shadow: 0 0 3px 0px white;}.ace-tm .ace_marker-layer .ace_step {background: rgb(252, 255, 0);}.ace-tm .ace_marker-layer .ace_stack {background: rgb(164, 229, 101);}.ace-tm .ace_marker-layer .ace_bracket {margin: -1px 0 0 -1px;border: 1px solid rgb(192, 192, 192);}.ace-tm .ace_marker-layer .ace_active-line {background: rgba(0, 0, 0, 0.07);}.ace-tm .ace_gutter-active-line {background-color : #dcdcdc;}.ace-tm .ace_marker-layer .ace_selected-word {background: rgb(250, 250, 255);border: 1px solid rgb(200, 200, 250);}.ace-tm .ace_indent-guide {background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==") right repeat-y;}';var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)})
--------------------------------------------------------------------------------
/man/get_tutorial_state.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/tutorial-state.R
3 | \name{get_tutorial_state}
4 | \alias{get_tutorial_state}
5 | \title{Observe the user's progress in the tutorial}
6 | \usage{
7 | get_tutorial_state(label = NULL, session = getDefaultReactiveDomain())
8 | }
9 | \arguments{
10 | \item{label}{A length-1 character label of the exercise or question.}
11 |
12 | \item{session}{The \code{session} object passed to function given to
13 | \code{shinyServer.} Default is \code{\link[shiny:domains]{shiny::getDefaultReactiveDomain()}}.}
14 | }
15 | \value{
16 | A reactiveValues object or a single reactive value (if \code{label} is
17 | provided). The names of the full reactiveValues object correspond to the
18 | label of the question or exercise. Each item contains the following
19 | entries:
20 | \itemize{
21 | \item \code{type}: One of \code{"question"} or \code{"exercise"}.
22 | \item \code{answer}: A character vector containing the user's submitted answer(s).
23 | \item \code{correct}: A logical indicating whether the user's answer was correct,
24 | or a logical \code{NA} if the submission was not checked for correctness.
25 | \item \code{timestamp}: The time at which the user's submission was completed, as
26 | a character string in UTC, formatted as \code{"\%F \%H:\%M:\%OS3 \%Z"}.
27 | }
28 | }
29 | \description{
30 | As a student progresses through a \pkg{learnr} tutorial, their progress is
31 | stored in a Shiny reactive values list for their session (see
32 | \code{\link[shiny:reactiveValues]{shiny::reactiveValues()}}). Without arguments, \code{get_tutorial_state()} returns
33 | the full reactiveValues object that can be converted to a conventional list
34 | with \code{\link[shiny:reactiveValuesToList]{shiny::reactiveValuesToList()}}. If the \code{label} argument is provided,
35 | the state of an individual question or exercise with that label is returned.
36 |
37 | Calling \code{get_tutorial_state()} introduces a reactive dependency on the state
38 | of returned questions or exercises unless called within \code{isolate()}. Note
39 | that \code{get_tutorial_state()} will only work for the tutorial author and must
40 | be used in a reactive context, i.e. within \code{\link[shiny:observe]{shiny::observe()}},
41 | \code{\link[shiny:observeEvent]{shiny::observeEvent()}}, or \code{\link[shiny:reactive]{shiny::reactive()}}. Any logic observing the
42 | user's tutorial state must be written inside a \code{context="server"} chunk in
43 | the tutorial's R Markdown source.
44 | }
45 | \seealso{
46 | \code{\link[=get_tutorial_info]{get_tutorial_info()}}
47 | }
48 |
--------------------------------------------------------------------------------
/R/learnr_messages.R:
--------------------------------------------------------------------------------
1 | # {learnr} functions are intended to be written into R Markdown documents,
2 | # but there are certain times when we'd like to warn tutorial authors of
3 | # potential issues without the warning text appearing in the actual tutorial.
4 | # Since we can't ask users to set message = FALSE globally, we have to do our
5 | # own thing. Instead, we have a way to create messages that are automatically
6 | # added to a queue of items when knitting is in progress -- if we're not knitting
7 | # then we just emit the message immediately. Then we take advantage of the
8 | # `tutorial` knit hook that runs before and after each chunk in the tutorial.
9 | # In the after run, we flush the queue and re-signal the condition so that it
10 | # appears in the render console, thus avoiding writing to the tutorial HTML.
11 |
12 | .learnr_messages <- local({
13 | queue <- list()
14 | list(
15 | peek = function() {
16 | if (length(queue)) queue
17 | },
18 | flush = function() {
19 | while(length(queue)) {
20 | cnd <- queue[[1]]
21 | if (inherits(cnd, "error")) {
22 | # throw errors, they're immediate
23 | rlang::cnd_signal(cnd)
24 | } else {
25 | # otherwise report condition as a message, but re-signal warnings
26 | msg <- rlang::cnd_message(cnd)
27 |
28 | if (inherits(cnd, "warning")) {
29 | mgs <- paste0("Warning: ", msg)
30 | rlang::cnd_signal(cnd)
31 | }
32 |
33 | rlang::inform(msg, class = "learnr_render_message")
34 | }
35 | queue[[1]] <<- NULL
36 | }
37 | },
38 | add = function(cnd) {
39 | queue <<- c(queue, list(cnd))
40 | invisible(cnd)
41 | }
42 | )
43 | })
44 |
45 | learnr_render_message <- function(..., level = c("inform", "warn", "abort")) {
46 | create_cnd <- switch(
47 | tolower(level),
48 | inform = rlang::inform,
49 | warn = rlang::warn,
50 | abort = rlang::abort
51 | )
52 | cnd <- rlang::catch_cnd(create_cnd(paste0(..., "\n"), "learnr_render_message"))
53 |
54 | if (isTRUE(getOption('knitr.in.progress'))) {
55 | .learnr_messages$add(cnd)
56 | } else {
57 | rlang::cnd_signal(cnd)
58 | }
59 | }
60 |
61 | learnr_render_catch <- function(expr, env = rlang::caller_env()) {
62 | cnd <- tryCatch(
63 | rlang::eval_bare(expr, env),
64 | error = identity,
65 | warning = identity,
66 | message = identity
67 | )
68 |
69 | if (!inherits(cnd, "condition")) {
70 | return(invisible())
71 | }
72 |
73 | if (isTRUE(getOption('knitr.in.progress'))) {
74 | .learnr_messages$add(cnd)
75 | } else {
76 | rlang::cnd_signal(cnd)
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/R/html-dependencies.R:
--------------------------------------------------------------------------------
1 |
2 | #' Tutorial HTML dependency
3 | #'
4 | #' HTML dependency for core tutorial JS and CSS. This should be included as a
5 | #' dependency for custom tutorial formats that wish to ensure that that
6 | #' `tutorial.js` and `tutorial.css` are loaded prior their own scripts and
7 | #' stylesheets.
8 | #'
9 | #' @return \pkg{learnr}'s HTML dependencies
10 | #'
11 | #' @export
12 | tutorial_html_dependency <- function() {
13 | htmltools::htmlDependency(
14 | name = "tutorial",
15 | version = utils::packageVersion("learnr"),
16 | src = html_dependency_src("lib", "tutorial"),
17 | script = "tutorial.js",
18 | stylesheet = "tutorial.css",
19 | all_files = TRUE
20 | )
21 | }
22 |
23 | html_dependency_src <- function(...) {
24 | if (nzchar(Sys.getenv("RMARKDOWN_SHINY_PRERENDERED_DEVMODE"))) {
25 | r_dir <- utils::getSrcDirectory(html_dependency_src, unique = TRUE)
26 | pkg_dir <- dirname(r_dir)
27 | file.path(pkg_dir, "inst", ...)
28 | }
29 | else {
30 | system.file(..., package = "learnr")
31 | }
32 | }
33 |
34 | idb_html_dependency <- function() {
35 | htmltools::htmlDependency(
36 | name = "idb-keyvalue",
37 | version = "3.2.0",
38 | src = system.file("lib/idb-keyval", package = "learnr"),
39 | script = "idb-keyval-iife-compat.min.js",
40 | all_files = FALSE
41 | )
42 | }
43 |
44 | bootbox_html_dependency <- function() {
45 | htmltools::htmlDependency(
46 | name = "bootbox",
47 | version = "5.5.2",
48 | src = system.file("lib/bootbox", package = "learnr"),
49 | script = "bootbox.min.js"
50 | )
51 | }
52 |
53 | clipboardjs_html_dependency <- function() {
54 | htmltools::htmlDependency(
55 | name = "clipboardjs",
56 | version = "2.0.10",
57 | src = system.file("lib/clipboardjs", package = "learnr"),
58 | script = "clipboard.min.js"
59 | )
60 | }
61 |
62 |
63 | ace_html_dependency <- function() {
64 | htmltools::htmlDependency(
65 | name = "ace",
66 | version = ACE_VERSION,
67 | src = system.file("lib/ace", package = "learnr"),
68 | script = "ace.js"
69 | )
70 | }
71 |
72 | tutorial_i18n_html_dependency <- function(language = NULL) {
73 | htmltools::htmlDependency(
74 | name = "i18n",
75 | version = "21.6.10",
76 | src = system.file("lib/i18n", package = "learnr"),
77 | script = c("i18next.min.js", "tutorial-i18n-init.js"),
78 | head = format(htmltools::tags$script(
79 | id = "i18n-cstm-trns",
80 | type = "application/json",
81 | htmltools::HTML(
82 | jsonlite::toJSON(
83 | i18n_process_language_options(language),
84 | auto_unbox = TRUE
85 | )
86 | )
87 | ))
88 | )
89 | }
90 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # learnr 
15 |
--------------------------------------------------------------------------------
/man/random_praise.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/praise.R
3 | \name{random_praise}
4 | \alias{random_praise}
5 | \alias{random_encouragement}
6 | \title{Random praise and encouragement}
7 | \usage{
8 | random_praise(language = NULL)
9 |
10 | random_encouragement(language = NULL)
11 | }
12 | \arguments{
13 | \item{language}{The language for the random phrase. The currently supported
14 | languages include: \code{en}, \code{es}, \code{pt}, \code{pl}, \code{tr}, \code{de}, \code{emo}, and \code{testing}
15 | (static phrases).}
16 | }
17 | \value{
18 | Character string with a random saying
19 | }
20 | \description{
21 | Random praises and encouragements sayings to compliment your question and
22 | quiz experience.
23 | }
24 | \examples{
25 | random_praise()
26 | random_praise()
27 |
28 | random_encouragement()
29 | random_encouragement()
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/man/tutorial_package_dependencies.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/tutorial_package_dependencies.R
3 | \name{tutorial_package_dependencies}
4 | \alias{tutorial_package_dependencies}
5 | \title{List tutorial dependencies}
6 | \usage{
7 | tutorial_package_dependencies(name = NULL, package = NULL)
8 | }
9 | \arguments{
10 | \item{name}{The tutorial name. If \code{name} is \code{NULL}, then all
11 | tutorials within \code{package} will be searched.}
12 |
13 | \item{package}{The \R package providing the tutorial. If \code{package} is
14 | \code{NULL}, then all tutorials will be searched.}
15 | }
16 | \value{
17 | A character vector of package names that are required for execution.
18 | }
19 | \description{
20 | List the \R packages required to run a particular tutorial.
21 | }
22 | \examples{
23 | tutorial_package_dependencies(package = "learnr")
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/inst/staticexports/knitr_engine_caption.R:
--------------------------------------------------------------------------------
1 |
2 | knitr_engine_caption <- function(engine = NULL) {
3 | if (is.null(engine)) {
4 | engine <- "r"
5 | }
6 |
7 | switch(
8 | tolower(engine),
9 | "bash" = "Bash",
10 | "c" = "C",
11 | "coffee" = "CoffeeScript",
12 | "cc" = "C++",
13 | "css" = "CSS",
14 | "go" = "Go",
15 | "groovy" = "Groovy",
16 | "haskell" = "Haskell",
17 | "js" = "JavaScript",
18 | "mysql" = "MySQL",
19 | "node" = "Node.js",
20 | "octave" = "Octave",
21 | "psql" = "PostgreSQL",
22 | "python" = "Python",
23 | "r" = "R",
24 | "rcpp" = "Rcpp",
25 | "cpp11" = "cpp11",
26 | "rscript" = "Rscript",
27 | "ruby" = "Ruby",
28 | "perl" = "Perl",
29 | "sass" = "Sass",
30 | "scala" = "Scala",
31 | "scss" = "SCSS",
32 | "sql" = "SQL",
33 | # else, return as the user provided
34 | engine
35 | )
36 | }
37 |
--------------------------------------------------------------------------------
/.github/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing
2 |
3 | We welcome contributions to the **learnr** package!
4 |
5 | To submit a contribution:
6 |
7 | 1. [Fork](https://github.com/rstudio/learnr/fork) the repository and make your changes.
8 |
9 | 2. Ensure that you have signed the [individual](https://www.rstudio.com/wp-content/uploads/2014/06/rstudioindividualcontributoragreement.pdf) or [corporate](https://www.rstudio.com/wp-content/uploads/2014/06/rstudiocorporatecontributoragreement.pdf) contributor agreement as appropriate. You can send the signed copy to contribute@rstudio.com, cc'ing barret@rstudio.com.
10 |
11 | 3. Submit a [pull request](https://help.github.com/articles/using-pull-requests).
12 |
13 | We generally do not merge pull requests that update included web libraries (such as Bootstrap or jQuery) because it is difficult for us to verify that the update is done correctly; we prefer to update these libraries ourselves.
14 |
--------------------------------------------------------------------------------
/man/finalize_question.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/mutate_tags.R
3 | \name{finalize_question}
4 | \alias{finalize_question}
5 | \title{Finalize a question}
6 | \usage{
7 | finalize_question(ele)
8 | }
9 | \arguments{
10 | \item{ele}{html tag element}
11 | }
12 | \value{
13 | An \pkg{htmltools} HTML object with appropriately appended classes
14 | such that a tutorial question is marked as the final answer.
15 | }
16 | \description{
17 | Mark a question as finalized by adding a \code{question-final} class to the HTML
18 | output at the top level, in addition to disabling all tags with
19 | \code{\link[=disable_all_tags]{disable_all_tags()}}.
20 | }
21 | \examples{
22 | # finalize the question UI
23 | finalize_question(
24 | htmltools::div(
25 | class = "custom-question",
26 | htmltools::div("answer 1"),
27 | htmltools::div("answer 2")
28 | )
29 | )
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/pkgdown/index.Rmd:
--------------------------------------------------------------------------------
1 | ---
2 | title: "learnr"
3 | output: md_document
4 | ---
5 |
6 | # learnr 
{{/logo}}
11 |