r - बुनना डीटी:: पैंडोक के बिना डाटालेट




datatables knitr (2)

यहाँ एक समाधान है जो संकुलों को knitr , base64enc , base64enc और htmltools का उपयोग करता है। यह rmarkdown::render में आंतरिक रूप से क्या होता है पर मॉडलिंग है, लेकिन pandoc पर कोई निर्भरता नहीं है यह डिफ़ॉल्ट रूप से एक स्व-निहित HTML फ़ाइल उत्पन्न करता है, या वैकल्पिक रूप से एक फ़ोल्डर में सभी निर्भरताएं प्रतिलिपि बनाता है। उत्तरार्द्ध के साथ, यह मानता है कि सभी सीएसएस और जेएस फाइलें विशिष्ट रूप से नामित हैं (यानी ये दोनों आयात नहीं करेगा अगर दो एचटीएमएल विदट्स दोनों अपनी सीएसएस फ़ाइल स्टाइल सीएसएस कॉल करने का निर्णय लेते हैं)।

library("knitr")
library("htmltools")
library("base64enc")
library("markdown")
render_with_widgets <- function(input_file,
                                output_file = sub("\\.Rmd$", ".html", input_file, ignore.case = TRUE),
                                self_contained = TRUE,
                                deps_path = file.path(dirname(output_file), "deps")) {

  # Read input and convert to Markdown
  input <- readLines(input_file)
  md <- knit(text = input)
  # Get dependencies from knitr
  deps <- knit_meta()

  # Convert script dependencies into data URIs, and stylesheet
  # dependencies into inline stylesheets

  dep_scripts <-
    lapply(deps, function(x) {
      lapply(x$script, function(script) file.path(x$src$file, script))})
  dep_stylesheets <- 
    lapply(deps, function(x) {
      lapply(x$stylesheet, function(stylesheet) file.path(x$src$file, stylesheet))})
  dep_scripts <- unique(unlist(dep_scripts))
  dep_stylesheets <- unique(unlist(dep_stylesheets))
  if (self_contained) {
    dep_html <- c(
      sapply(dep_scripts, function(script) {
        sprintf('<script type="text/javascript" src="%s"></script>',
                dataURI(file = script))
      }),
      sapply(dep_stylesheets, function(sheet) {
        sprintf('<style>%s</style>',
                paste(readLines(sheet), collapse = "\n"))
      })
    )
  } else {
    if (!dir.exists(deps_path)) {
      dir.create(deps_path)
    }
    for (fil in c(dep_scripts, dep_stylesheets)) {
      file.copy(fil, file.path(deps_path, basename(fil)))
    }
    dep_html <- c(
        sprintf('<script type="text/javascript" src="%s"></script>',
                file.path(deps_path, basename(dep_scripts))),
        sprintf('<link href="%s" type="text/css" rel="stylesheet">',
                file.path(deps_path, basename(dep_stylesheets)))
    )
  }

  # Extract the <!--html_preserve--> bits
  preserved <- extractPreserveChunks(md)

  # Render the HTML, and then restore the preserved chunks
  html <- markdownToHTML(text = preserved$value, header = dep_html)
  html <- restorePreserveChunks(html, preserved$chunks)

  # Write the output
  writeLines(html, output_file)
}

इसे इस तरह से बुलाया जा सकता है:

render_with_widgets("testing.Rmd")

यह किसी भी htmlwidgets के लिए काम करना चाहिए, यहां तक ​​कि संयोजन में भी। उदाहरण:

TestWidgets.Rmd

---
title: "TestWidgets"
author: "Nick Kennedy"
date: "5 August 2015"
output: html_document
---

First test a dygraph
```{r}
library(dygraphs)
dygraph(nhtemp, main = "New Haven Temperatures") %>% 
  dyRangeSelector(dateWindow = c("1920-01-01", "1960-01-01"))
```

Now a datatable
```{r}
library(DT)
datatable(iris, options = list(pageLength = 5))
```

```{r}
library(d3heatmap)
d3heatmap(mtcars, scale="column", colors="Blues")
```

और फिर आर से

render_with_widgets("TestWidgets.Rmd")

आर डी में एक अच्छी तरह से स्वरूपित, इंटरैक्टिव टेबल को आउटपुट करने के लिए मैं DT::datatable का उपयोग करने की कोशिश कर रहा हूं।

... केवल समस्या यह है कि मैं अपने लिए एक दस्तावेज बुनना करने के लिए एक हौकोक काम करना चाहता हूं, और मुझे पता चला है कि RStudio और rmarkdown::render() हुड के तहत पांडोक का उपयोग करें - लेकिन पांडॉक नीचे छीनने में नहीं है हेरोको के लिए बिल्डपैक

जावास्क्रिप्ट पास करने के लिए पुराने knitr:knit2html इंजन ( knitr:knit2html या knitr:knit2html ) प्राप्त करने का कोई तरीका क्या है जो कि शक्तियों के माध्यम से knitr:knit2html ? या अधिक सटीक होना, pandoc का उपयोग किए बिना नीचे नमूना तालिका उत्पन्न करने के लिए?

यहां एक न्यूनतम उदाहरण है:

testing.Rmd

---
title: "testing"
output: html_document
---

this is a datatable table
```{r test2, echo=FALSE}
library(DT)
DT::datatable(
  iris, 
  rownames = FALSE,
  options = list(pageLength = 12, dom = 'tip')
)
```

this is regular R output
```{r}
head(iris)

```

knit_test.R

require(knitr)
knitr::knit2html('testing.Rmd')

उत्पन्न करता है:

this is a datatable table <!–html_preserve–>

<!/html_preserve–>
this is regular R output

head(iris)
##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1          5.1         3.5          1.4         0.2  setosa
## 2          4.9         3.0          1.4         0.2  setosa
## 3          4.7         3.2          1.3         0.2  setosa
## 4          4.6         3.1          1.5         0.2  setosa
## 5          5.0         3.6          1.4         0.2  setosa
## 6          5.4         3.9          1.7         0.4  setosa

वांछित व्यवहार: मेरे <!–html_preserve–> आते हैं (नहीं <!–html_preserve–> )

मैंने जो कोशिश की है मैंने htmltools और htmlPreserve सामग्री को देखा, लेकिन यह समझ नहीं सका कि यहां कैसे लागू करना है। saveWidget साथ कुछ पागल सामान था जो कि सफल नहीं था और दोहराते नहीं सहन करता है।

धन्यवाद!


श्रेणी से कुछ saveWidget साथ कुछ पागल सामान है, लेकिन अगर आप XML पैकेज का इस्तेमाल कर सकते हैं (आपको इसके लिए देवदार -14 की आवश्यकता होगी) नीचे की तरह कुछ ऐसा करना चाहिए:

#' http://.com/q/31645528/1560062
#'
#' @param dt datatables object as returned from DT::datatable
#' @param rmd_path character path to the rmd template
#' @param libdir path to the directory with datatable static files
#' @param output_path where to write output file
#'
process <- function(dt, rmd_path, libdir, output_path) {

    widget_path <- tempfile()
    template_path <- tempfile()

    # Save widget and process Rmd template
    DT::saveWidget(dt, widget_path, selfcontained=FALSE)
    knitr::knit2html(input=rmd_path, output=template_path)

    # Parse html files
    widget <- XML::htmlParse(widget_path)
    template <- XML::htmlParse(paste0(template_path, ".html"))

    # Extract elements from the body of widget file
    widget_container <- XML::getNodeSet(
        widget, "/html/body/div[@id = 'htmlwidget_container']")
    body_scripts <- XML::getNodeSet(widget, "/html/body/script")

    # Make sure we point to the correct static dir
    # Using lapply purely for side effect is kind of
    # wrong but it is cheaper than a for loop if we use ::
    correct_libdir <- function(nodeset, attr_name) {
        lapply(nodeset, function(el) {
            src <- XML::xmlAttrs(el)[[attr_name]]
            XML::xmlAttrs(el)[[attr_name]] <- file.path(
                libdir, sub("^.*?/", "", src))
        })
        nodeset
    }

    # Extract script and link tags, correct paths
    head_scripts <- correct_libdir(
        XML::getNodeSet(widget, "/html/head/script"), "src")

    head_links <- correct_libdir(
        XML::getNodeSet(widget, "/html/head/link"), "href")

    # Get template root    
    root <- XML::xmlRoot(template)

    # Append above in the right place
    root[[2]] <- XML::addChildren(root[[2]], widget_container)
    root[[2]] <- XML::addChildren(root[[2]], body_scripts)
    root[[1]] <- XML::addChildren(root[[1]], head_scripts)
    root[[1]] <- XML::addChildren(root[[1]], head_links)

    # Write output
    XML::saveXML(template, output_path)
}




pandoc