Fix NEWS formatting

Fix runGist

.Rbuildignore

@@ -1,11 +1,16 @@
 ^\.Rproj\.user$
 ^\.git$
 ^examples$
-^README\.md$
 ^shiny\.Rproj$
 ^shiny\.sh$
 ^shiny\.cmd$
 ^run\.R$
 ^\.gitignore$
 ^res$
+^man-roxygen$
+^\.travis\.yml$
+^staticdocs$
 ^tools$
+^srcjs$
+^CONTRIBUTING.md$
+^cran-comments.md$

.Rinstignore

@@ -0,0 +1,2 @@
+^tools$
+^Rmd$

.gitattributes

@@ -0,0 +1,4 @@
+/NEWS merge=union
+/inst/www/shared/shiny.js -merge -diff
+*.min.js -merge -diff
+*.js.map -merge -diff

.gitignore

@@ -6,4 +6,5 @@
 *.so
 /src-i386/
 /src-x86_64/
+shinyapps/
 README.html

.travis.yml

@@ -0,0 +1,12 @@
+language: r
+warnings_are_errors: true
+
+r_binary_packages:
+  - Rcpp
+  - cairo
+  - knitr
+
+notifications:
+  email:
+    on_success: change
+    on_failure: change

CONTRIBUTING.md

@@ -0,0 +1,10 @@
+
+We welcome contributions to the **shiny** package. To submit a contribution:
+
+1. [Fork](https://github.com/rstudio/shiny/fork) the repository and make your changes.
+
+2. Ensure that you have signed the [individual](http://www.rstudio.com/wp-content/uploads/2014/06/RStudioIndividualContributorAgreement.pdf) or [corporate](http://www.rstudio.com/wp-content/uploads/2014/06/RStudioCorporateContributorAgreement.pdf) contributor agreement as appropriate. You can send the signed copy to jj@rstudio.com.
+
+3. Submit a [pull request](https://help.github.com/articles/using-pull-requests).
+
+We'll try to be as responsive as possible in reviewing and accepting pull requests. We appreciate your contributions!

DESCRIPTION

@@ -1,51 +1,133 @@
 Package: shiny
 Type: Package
 Title: Web Application Framework for R
-Version: 0.6.0.99
-Date: 2013-01-23
-Author: RStudio, Inc.
-Maintainer: Winston Chang <winston@rstudio.com>
-Description: Shiny makes it incredibly easy to build interactive web
+Version: 0.12.2
+Date: 2015-08-04
+Authors@R: c(
+    person("Winston", "Chang", role = c("aut", "cre"), email = "winston@rstudio.com"),
+    person("Joe", "Cheng", role = "aut", email = "joe@rstudio.com"),
+    person("JJ", "Allaire", role = "aut", email = "jj@rstudio.com"),
+    person("Yihui", "Xie", role = "aut", email = "yihui@rstudio.com"),
+    person("Jonathan", "McPherson", role = "aut", email = "jonathan@rstudio.com"),
+    person(family = "RStudio", role = "cph"),
+    person(family = "jQuery Foundation", role = "cph",
+    comment = "jQuery library and jQuery UI library"),
+    person(family = "jQuery contributors", role = c("ctb", "cph"),
+    comment = "jQuery library; authors listed in inst/www/shared/jquery-AUTHORS.txt"),
+    person(family = "jQuery UI contributors", role = c("ctb", "cph"),
+    comment = "jQuery UI library; authors listed in inst/www/shared/jqueryui/1.10.4/AUTHORS.txt"),
+    person("Mark", "Otto", role = "ctb",
+    comment = "Bootstrap library"),
+    person("Jacob", "Thornton", role = "ctb",
+    comment = "Bootstrap library"),
+    person(family = "Bootstrap contributors", role = "ctb",
+    comment = "Bootstrap library"),
+    person(family = "Twitter, Inc", role = "cph",
+    comment = "Bootstrap library"),
+    person("Alexander", "Farkas", role = c("ctb", "cph"),
+    comment = "html5shiv library"),
+    person("Scott", "Jehl", role = c("ctb", "cph"),
+    comment = "Respond.js library"),
+    person("Stefan", "Petre", role = c("ctb", "cph"),
+    comment = "Bootstrap-datepicker library"),
+    person("Andrew", "Rowls", role = c("ctb", "cph"),
+    comment = "Bootstrap-datepicker library"),
+    person("Dave", "Gandy", role = c("ctb", "cph"),
+    comment = "Font-Awesome font"),
+    person("Brian", "Reavis", role = c("ctb", "cph"),
+    comment = "selectize.js library"),
+    person("Kristopher Michael", "Kowal", role = c("ctb", "cph"),
+    comment = "es5-shim library"),
+    person(family = "es5-shim contributors", role = c("ctb", "cph"),
+    comment = "es5-shim library"),
+    person("Denis", "Ineshin", role = c("ctb", "cph"),
+    comment = "ion.rangeSlider library"),
+    person("Sami", "Samhuri", role = c("ctb", "cph"),
+    comment = "Javascript strftime library"),
+    person(family = "SpryMedia Limited", role = c("ctb", "cph"),
+    comment = "DataTables library"),
+    person("John", "Fraser", role = c("ctb", "cph"),
+    comment = "showdown.js library"),
+    person("John", "Gruber", role = c("ctb", "cph"),
+    comment = "showdown.js library"),
+    person("Ivan", "Sagalaev", role = c("ctb", "cph"),
+    comment = "highlight.js library"),
+    person(family = "R Core Team", role = c("ctb", "cph"),
+    comment = "tar implementation from R")
+    )
+Description: Makes it incredibly easy to build interactive web
     applications with R. Automatic "reactive" binding between inputs and
     outputs and extensive pre-built widgets make it possible to build
     beautiful, responsive, and powerful applications with minimal effort.
-License: GPL-3
+License: GPL-3 | file LICENSE
 Depends:
-    R (>= 2.14.1)
+    R (>= 3.0.0),
+    methods
 Imports:
-    stats,
-    tools,
     utils,
-    datasets,
-    methods,
-    httpuv (>= 1.0.6.2),
-    caTools,
-    RJSONIO,
+    httpuv (>= 1.3.3),
+    mime (>= 0.3),
+    jsonlite (>= 0.9.16),
     xtable,
-    digest
+    digest,
+    htmltools (>= 0.2.6),
+    R6 (>= 2.0)
 Suggests:
+    datasets,
+    Cairo (>= 1.5-5),
+    testthat,
+    knitr (>= 1.6),
     markdown,
-    Cairo,
-    testthat
-URL: http://www.rstudio.com/shiny/
+    ggplot2
+URL: http://shiny.rstudio.com
 BugReports: https://github.com/rstudio/shiny/issues
 Collate:
+    'app.R'
+    'bootstrap-layout.R'
     'map.R'
-    'priorityqueue.R'
+    'globals.R'
     'utils.R'
+    'bootstrap.R'
+    'cache.R'
+    'fileupload.R'
+    'stack.R'
+    'graph.R'
+    'hooks.R'
+    'html-deps.R'
+    'htmltools.R'
+    'image-interact-opts.R'
+    'image-interact.R'
+    'imageutils.R'
+    'input-action.R'
+    'input-checkbox.R'
+    'input-checkboxgroup.R'
+    'input-date.R'
+    'input-daterange.R'
+    'input-file.R'
+    'input-numeric.R'
+    'input-password.R'
+    'input-radiobuttons.R'
+    'input-select.R'
+    'input-slider.R'
+    'input-submit.R'
+    'input-text.R'
+    'input-utils.R'
+    'jqueryui.R'
+    'middleware-shiny.R'
+    'middleware.R'
+    'priorityqueue.R'
+    'progress.R'
+    'react.R'
+    'reactive-domains.R'
+    'reactives.R'
+    'render-plot.R'
+    'run-url.R'
+    'server-input-handlers.R'
+    'server.R'
+    'shiny.R'
+    'shinyui.R'
+    'shinywrappers.R'
+    'showcase.R'
     'tar.R'
     'timer.R'
-    'tags.R'
-    'cache.R'
-    'graph.R'
-    'react.R'
-    'reactives.R'
-    'fileupload.R'
-    'shiny.R'
-    'shinywrappers.R'
-    'shinyui.R'
-    'slider.R'
-    'bootstrap.R'
-    'run-url.R'
-    'imageutils.R'
     'update-input.R'

NAMESPACE

@@ -1,3 +1,5 @@
+# Generated by roxygen2 (4.1.1): do not edit by hand
+
 S3method("$",reactivevalues)
 S3method("$",shinyoutput)
 S3method("$<-",reactivevalues)
@@ -11,35 +13,56 @@ S3method("[[",shinyoutput)
 S3method("[[<-",reactivevalues)
 S3method("[[<-",shinyoutput)
 S3method("names<-",reactivevalues)
-S3method(as.character,shiny.tag)
-S3method(as.character,shiny.tag.list)
 S3method(as.list,reactivevalues)
-S3method(format,shiny.tag)
-S3method(format,shiny.tag.list)
+S3method(as.shiny.appobj,character)
+S3method(as.shiny.appobj,list)
+S3method(as.shiny.appobj,shiny.appobj)
+S3method(as.tags,shiny.appobj)
+S3method(as.tags,shiny.render.function)
 S3method(names,reactivevalues)
-S3method(print,shiny.tag)
-S3method(print,shiny.tag.list)
+S3method(print,reactive)
+S3method(print,shiny.appobj)
+S3method(str,reactivevalues)
 export(HTML)
+export(Progress)
 export(a)
+export(absolutePanel)
 export(actionButton)
+export(actionLink)
 export(addResourcePath)
 export(animationOptions)
+export(as.shiny.appobj)
 export(basicPage)
 export(bootstrapPage)
 export(br)
+export(brushOpts)
+export(brushedPoints)
 export(checkboxGroupInput)
 export(checkboxInput)
+export(clickOpts)
 export(code)
+export(column)
 export(conditionalPanel)
+export(createWebDependency)
+export(dataTableOutput)
 export(dateInput)
 export(dateRangeInput)
+export(dblclickOpts)
 export(div)
 export(downloadButton)
 export(downloadHandler)
 export(downloadLink)
 export(em)
+export(eventReactive)
 export(exprToFunction)
 export(fileInput)
+export(fixedPage)
+export(fixedPanel)
+export(fixedRow)
+export(flowLayout)
+export(fluidPage)
+export(fluidRow)
+export(getDefaultReactiveDomain)
 export(h1)
 export(h2)
 export(h3)
@@ -48,29 +71,57 @@ export(h5)
 export(h6)
 export(headerPanel)
 export(helpText)
+export(hoverOpts)
+export(hr)
 export(htmlOutput)
+export(icon)
 export(imageOutput)
 export(img)
+export(incProgress)
 export(includeCSS)
 export(includeHTML)
 export(includeMarkdown)
 export(includeScript)
 export(includeText)
+export(inputPanel)
+export(installExprFunction)
 export(invalidateLater)
+export(is.reactive)
+export(is.reactivevalues)
+export(is.shiny.appobj)
+export(is.singleton)
 export(isolate)
+export(knit_print.html)
+export(knit_print.shiny.appobj)
+export(knit_print.shiny.render.function)
+export(knit_print.shiny.tag)
+export(knit_print.shiny.tag.list)
 export(mainPanel)
+export(makeReactiveBinding)
+export(markRenderFunction)
+export(maskReactiveContext)
+export(navbarMenu)
+export(navbarPage)
+export(navlistPanel)
+export(nearPoints)
+export(need)
 export(numericInput)
 export(observe)
+export(observeEvent)
+export(onReactiveDomainEnded)
 export(outputOptions)
 export(p)
 export(pageWithSidebar)
 export(parseQueryString)
+export(passwordInput)
 export(plotOutput)
 export(plotPNG)
 export(pre)
 export(radioButtons)
 export(reactive)
+export(reactiveFileReader)
 export(reactivePlot)
+export(reactivePoll)
 export(reactivePrint)
 export(reactiveTable)
 export(reactiveText)
@@ -78,6 +129,9 @@ export(reactiveTimer)
 export(reactiveUI)
 export(reactiveValues)
 export(reactiveValuesToList)
+export(registerInputHandler)
+export(removeInputHandler)
+export(renderDataTable)
 export(renderImage)
 export(renderPlot)
 export(renderPrint)
@@ -91,13 +145,20 @@ export(runGist)
 export(runGitHub)
 export(runUrl)
 export(selectInput)
+export(selectizeInput)
+export(serverInfo)
+export(setProgress)
+export(shinyApp)
+export(shinyAppDir)
 export(shinyServer)
 export(shinyUI)
 export(showReactLog)
+export(sidebarLayout)
 export(sidebarPanel)
 export(singleton)
 export(sliderInput)
 export(span)
+export(splitLayout)
 export(stopApp)
 export(strong)
 export(submitButton)
@@ -105,6 +166,7 @@ export(tabPanel)
 export(tableOutput)
 export(tabsetPanel)
 export(tag)
+export(tagAppendAttributes)
 export(tagAppendChild)
 export(tagAppendChildren)
 export(tagList)
@@ -112,24 +174,34 @@ export(tagSetChildren)
 export(tags)
 export(textInput)
 export(textOutput)
+export(titlePanel)
 export(uiOutput)
 export(updateCheckboxGroupInput)
 export(updateCheckboxInput)
 export(updateDateInput)
 export(updateDateRangeInput)
+export(updateNavbarPage)
+export(updateNavlistPanel)
 export(updateNumericInput)
 export(updateRadioButtons)
 export(updateSelectInput)
+export(updateSelectizeInput)
 export(updateSliderInput)
 export(updateTabsetPanel)
 export(updateTextInput)
+export(validate)
 export(validateCssUnit)
 export(verbatimTextOutput)
+export(verticalLayout)
 export(wellPanel)
+export(withMathJax)
+export(withProgress)
+export(withReactiveDomain)
 export(withTags)
-export(writeReactLog)
-import(RJSONIO)
-import(caTools)
+import(R6)
 import(digest)
+import(htmltools)
 import(httpuv)
+import(methods)
+import(mime)
 import(xtable)

NEWS

@@ -1,6 +1,578 @@
-shiny 0.6.0.99
+shiny 0.12.2
 --------------------------------------------------------------------------------
 
+* GitHub changed URLs for gists from .tar.gz to .zip, so `runGist` was updated
+  to work with the new URLs.
+
+* Callbacks from the session object are now guaranteed to execute in the order
+  in which registration occurred.
+
+* Minor bugs in sliderInput's animation behavior have been fixed. (#852)
+
+* Updated to ion.rangeSlider to 2.0.12.
+
+* Added `shiny.minified` option, which controls whether the minified version
+  of shiny.js is used. Setting it to FALSe can be useful for debugging. (#826,
+  #850)
+
+* Fixed an issue for outputting plots from ggplot objects which also have an
+  additional class whose print method takes precedence over `print.ggplot`.
+  (#840, 841)
+
+* Added `width` option to Shiny's input functions. (#589, #834)
+
+* Added two alias functions of `updateTabsetPanel()` to update the selected tab:
+  `updateNavbarPage()` and `updateNavlistPanel()`. (#881)
+
+* All non-base functions are now explicitly namespaced, to pass checks in
+  R-devel.
+
+* Shiny now correctly handles HTTP HEAD requests. (#876)
+
+shiny 0.12.1
+--------------------------------------------------------------------------------
+
+* Fixed an issue where unbindAll() causes subsequent bindAll() to be ignored for
+  previously bound outputs. (#856)
+
+* Undeprecate `dataTableOutput` and `renderDataTable`, which had been deprecated
+  in favor of the new DT package. The DT package is a bit too new and has a
+  slightly different API, we were too hasty in deprecating the existing Shiny
+  functions.
+
+shiny 0.12.0
+--------------------------------------------------------------------------------
+
+* Switched from RJSONIO to jsonlite. This improves consistency and speed when
+  converting between R data structures and JSON. One notable change is that
+  POSIXt objects are now serialized to JSON in UTC8601 format (like
+  "2015-03-20T20:00:00Z"), instead of as seconds from the epoch).
+
+* In addition to the existing support for clicking and hovering on plots
+  created by base graphics, added support for double-clicking and brushing.
+  (#769)
+
+* Added support for clicking, hovering, double-clicking, and brushing for
+  plots created by ggplot2, including support for facets. (#802)
+
+* Added `nearPoints` and `brushedPoints` functions for easily selecting rows of
+  data that are clicked/hovered, or brushed. (#802)
+
+* Added `shiny.port` option. If this is option is set, `runApp()` will listen on
+  this port by default. (#756)
+
+* `runUrl`, `runGist`, and `runGitHub` now can save downloaded applications,
+  with the `destdir` argument. (#688)
+
+* Restored ability to set labels for `selectInput`. (#741)
+
+* Travis continuous integration now uses Travis's native R support.
+
+* Fixed encoding issue when the server receives data from the client browser.
+  (#742)
+
+* The `session` object now has class `ShinySession`, making it easier to test
+  whether an object is indeed a session object. (#720, #746)
+
+* Fix JavaScript error when an output appears in nested uiOutputs. (Thanks,
+  Gregory Zhang. #749)
+
+* Eliminate delay on receiving new value when `updateSliderInput(value=...)` is
+  called.
+
+* Updated to DataTables (Javascript library) 1.10.5.
+
+* Fixed downloading of files that have no filename extension. (#575, #753)
+
+* Fixed bug where nested UI outputs broke outputs. (#749, #750)
+
+* Removed unneeded HTML ID attributes for `checkboxGroupInputs` and
+  `radioButtons`. (#684)
+
+* Fixed bug where checkboxes were still active even after `Shiny.unbindAll()`
+  was called. (#206)
+
+* The server side selectize input will load the first 1000 options by default
+  before users start to type and search in the box. (#823)
+
+* renderDataTable() and dataTableOutput() have been deprecated in shiny and will
+  be removed in future versions of shiny. Please use the DT package instead:
+  http://rstudio.github.io/DT/ (#807)
+
+shiny 0.11.1
+--------------------------------------------------------------------------------
+
+* Major client-side performance improvements for pages that have many
+  conditionalPanels, tabPanels, and plotOutputs. (#693, #717, #723)
+
+* `tabPanel`s now use the `title` for `value` by default. This fixes a bug
+  in which an icon in the title caused problems with a conditionalPanel's test
+  condition. (#725, #728)
+
+* `selectInput` now has a `size` argument to control the height of the input
+  box. (#729)
+
+* `navbarPage` no longer includes a first row of extra whitespace when
+  `header=NULL`. (#722)
+
+* `selectInput`s now use Bootstrap styling when `selectize=FALSE`. (#724)
+
+* Better vertical spacing of label for checkbox groups and radio buttons.
+
+* `selectInput` correctly uses width for both selectize and non-selectize
+  inputs. (#702)
+
+* The wrapper tag generated by `htmlOutput` and `uiOutput` can now be any type
+  of HTML tag, instead of just span and div. Also, custom classes are now
+  allowed on the tag. (#704)
+
+* Slider problems in IE 11 and Chrome on touchscreen-equipped Windows computers
+  have been fixed. (#700)
+
+* Sliders now work correctly with draggable panels. (#711)
+
+* Fixed arguments in `fixedPanel`. (#709)
+
+* downloadHandler content callback functions are now invoked with a temp file
+  name that has the same extension as the final filename that will be used by
+  the download. This is to deal with the fact that some file writing functions
+  in R will auto-append the extension for their file type (pdf, zip).
+
+shiny 0.11
+--------------------------------------------------------------------------------
+
+* Changed sliders from jquery-slider to ion.rangeSlider. These sliders have
+  an improved appearance, support updating more properties from the server,
+  and can be controlled with keyboard input.
+
+* Switched from Bootstrap 2 to Bootstrap 3. For most users, this will work
+  seamlessly, but some users may need to use the shinybootstrap2 package for
+  backward compatibility.
+
+* The UI of a Shiny app can now have a body tag. This is useful for CSS
+  templates that use classes on the body tag.
+
+* `actionButton` and `actionLink` now pass their `...` arguments to the
+  underlying tag function. (#607)
+
+* Added `observeEvent` and `eventReactive` functions for clearer, more concise
+  handling of `actionButton`, plot clicks, and other naturally-imperative
+  inputs.
+
+* Errors that happen in reactives no longer prevent any remaining pending
+  observers from executing. It is also now possible for users to control how
+  errors are handled, with the 'shiny.observer.error' global option. (#603,
+  #604)
+
+* Added an `escape` argument to `renderDataTable()` to escape the HTML entities
+  in the data table for security reasons. This might break tables from previous
+  versions of shiny that use raw HTML in the table content, and the old behavior
+  can be brought back by `escape = FALSE` if you are aware of the security
+  implications. (#627)
+
+* Changed the URI encoding/decoding functions internally to use `encodeURI()`,
+  `encodeURIComponent()`, and `decodeURIComponent()` from the httpuv package
+  instead of `utils::URLencode()` and `utils::URLdecode()`. (#630)
+
+* Shiny's web assets are now minified.
+
+* The default reactive domain is now available in event handler functions. (#669)
+
+* Password input fields can now be used, with `passwordInput()`. (#672)
+
+shiny 0.10.2.2
+--------------------------------------------------------------------------------
+
+* Remove use of `rstudio::viewer` in a code example, for R CMD check.
+
+shiny 0.10.2.1
+--------------------------------------------------------------------------------
+
+* Changed some examples to use \donttest instead of \dontrun.
+
+shiny 0.10.2
+--------------------------------------------------------------------------------
+
+* The minimal version of R required for the shiny package is 3.0.0 now.
+
+* Shiny apps can now consist of a single file, app.R, instead of ui.R and
+  server.R.
+
+* Upgraded DataTables from 1.9.4 to 1.10.2. This might be a breaking change if
+  you have customized the DataTables options in your apps. (More info:
+  https://github.com/rstudio/shiny/pull/558)
+
+* File uploading via `fileInput()` works for Internet Explorer 8 and 9 now. Note
+  IE8/9 do not support multiple files from a single file input. If you need to
+  upload multiple files, you have to use one file input for each file.
+
+* Switched away from reference classes to R6.
+
+* Reactive log performance has been greatly improved.
+
+* Added `Progress` and `withProgress`, to display the progress of computation
+  on the client browser.
+
+* Fixed #557: updateSelectizeInput(choices, server = TRUE) did not work when
+  `choices` is a character vector.
+
+* Searching in DataTables is case-insensitive and the search strings are not
+  treated as regular expressions by default now. If you want case-sensitive
+  searching or regular expressions, you can use the configuration options
+  `search$caseInsensitive` and `search$regex`, e.g. `renderDataTable(...,
+  options = list(search = list(caseInsensitve = FALSE, regex = TRUE)))`.
+
+* Added support for `htmltools::htmlDependency`'s new `attachment` parameter to
+  `renderUI`/`uiOutput`.
+
+* Exported `createWebDependency`. It takes an `htmltools::htmlDependency` object
+  and makes it available over Shiny's built-in web server.
+
+* Custom output bindings can now render `htmltools::htmlDependency` objects at
+  runtime using `Shiny.renderDependencies()`.
+
+* Fixes to rounding behavior of sliderInput. (#301, #502)
+
+* Updated selectize.js to version 0.11.2. (#596)
+* Added `position` parameter to `navbarPage`.
+
+shiny 0.10.1
+--------------------------------------------------------------------------------
+
+* Added Unicode support for Windows. Shiny apps running on Windows must use the
+  UTF-8 encoding for ui.R and server.R (also the optional global.R) if they
+  contain non-ASCII characters. See this article for details and examples:
+  http://shiny.rstudio.com/gallery/unicode-characters.html (#516)
+
+* `runGitHub()` also allows the 'username/repo' syntax now, which is equivalent
+  to `runGitHub('repo', 'username')`. (#427)
+
+* `navbarPage()` now accepts a `windowTitle` parameter to set the web browser
+  page title to something other than the title displayed in the navbar.
+
+* Added an `inline` argument to `textOutput()`, `imageOutput()`, `plotOutput()`,
+  and `htmlOutput()`. When `inline = TRUE`, these outputs will be put in
+  `span()` instead of the default `div()`. This occurs automatically when these
+  outputs are created via the inline expressions (e.g. `r renderText(expr)`) in
+  R Markdown documents. See an R Markdown example at
+  http://shiny.rstudio.com/gallery/inline-output.html (#512)
+
+* Added support for option groups in the select/selectize inputs. When the
+  `choices` argument for `selectInput()`/`selectizeInput()` is a list of
+  sub-lists and any sub-list is of length greater than 1, the HTML tag
+  `<optgroup>` will be used. See an example at
+  http://shiny.rstudio.com/gallery/option-groups-for-selectize-input.html (#542)
+
+shiny 0.10.0
+--------------------------------------------------------------------------------
+
+* BREAKING CHANGE: By default, observers now terminate themselves if they were
+  created during a session and that session ends. See ?domains for more details.
+
+* Shiny can now be used in R Markdown v2 documents, to create "Shiny Docs":
+  reports and presentations that combine narrative, statically computed output,
+  and fully dynamic inputs and outputs. For more info, including examples, see
+  http://rmarkdown.rstudio.com/authoring_shiny.html.
+
+* The `session` object that can be passed into a server function (e.g.
+  shinyServer(function(input, output, session) {...})) is now documented: see
+  `?session`.
+
+* Most inputs can now accept `NULL` label values to omit the label altogether.
+
+* New `actionLink` input control; like `actionButton`, but with the appearance
+  of a normal link.
+
+* `renderPlot` now calls `print` on its result if it's visible (i.e. no more
+  explicit `print()` required for ggplot2).
+
+* Introduced Shiny app objects (see `?shinyApp`). These essentially replace the
+  little-advertised ability for `runApp` to take a `list(ui=..., server=...)`
+  as the first argument instead of a directory (though that ability remains for
+  backward compatibility). Unlike those lists, Shiny app objects are tagged with
+  class `shiny.appobj` so they can be run simply by printing them.
+
+* Added `maskReactiveContext` function. It blocks the current reactive context,
+  to evaluate expressions that shouldn't use reactive sources directly. (This
+  should not be commonly needed.)
+
+* Added `flowLayout`, `splitLayout`, and `inputPanel` functions for putting UI
+  elements side by side. `flowLayout` lays out its children in a left-to-right,
+  top-to-bottom arrangement. `splitLayout` evenly divides its horizontal space
+  among its children (or unevenly divides if `cellWidths` argument is provided).
+  `inputPanel` is like `flowPanel`, but with a light grey background, and is
+  intended to be used to encapsulate small input controls wherever vertical
+  space is at a premium.
+
+* Added `serverInfo` to obtain info about the Shiny Server if the app is served
+  through it.
+
+* Added an `inline` argument (TRUE/FALSE) in `checkboxGroupInput()` and
+  `radioButtons()` to allow the horizontal layout (inline = TRUE) of checkboxes
+  or radio buttons. (Thanks, @saurfang, #481)
+
+* `sliderInput` and `selectizeInput`/`selectInput` now use a standard horizontal
+  size instead of filling up all available horizontal space. Pass `width="100%"`
+  explicitly for the old behavior.
+
+* Added the `updateSelectizeInput()` function to make it possible to process
+  searching on the server side (i.e. using R), which can be much faster than the
+  client side processing (i.e. using HTML and JavaScript). See the article at
+  http://shiny.rstudio.com/articles/selectize.html for a detailed introduction.
+
+* Fixed a bug of renderDataTable() when the data object only has 1 row and 1
+  column. (Thanks, ZJ Dai, #429)
+
+* `renderPrint` gained a new argument 'width' to control the width of the text
+  output, e.g. renderPrint({mtcars}, width = 40).
+
+* Fixed #220: the zip file for a directory created by some programs may not have
+  the directory name as its first entry, in which case runUrl() can fail. (#220)
+
+* `runGitHub()` can also take a value of the form "username/repo" in its first
+  argument, e.g. both runGitHub("shiny_example", "rstudio") and
+  runGitHub("rstudio/shiny_example") are valid ways to run the GitHub repo.
+
+shiny 0.9.1
+--------------------------------------------------------------------------------
+
+* Fixed warning 'Error in Context$new : could not find function "loadMethod"'
+  that was happening to dependent packages on "R CMD check".
+
+shiny 0.9.0
+--------------------------------------------------------------------------------
+
+* BREAKING CHANGE: Added a `host` parameter to runApp() and runExample(),
+  which defaults to the shiny.host option if it is non-NULL, or "127.0.0.1"
+  otherwise. This means that by default, Shiny applications can only be
+  accessed on the same machine from which they are served. To allow other
+  clients to connect, as in previous versions of Shiny, use "0.0.0.0"
+  (or the IP address of one of your network interfaces, if you care to be
+  explicit about it).
+
+* Added a new function `selectizeInput()` to use the JavaScript library
+  selectize.js (https://github.com/brianreavis/selectize.js), which extends
+  the basic select input in many aspects.
+
+* The `selectInput()` function also gained a new argument `selectize = TRUE`
+  to makes use of selectize.js by default. If you want to revert back to the
+  original select input, you have to call selectInput(..., selectize = FALSE).
+
+* Added Showcase mode, which displays the R code for an app right in the app
+  itself. You can invoke Showcase mode by passing `display.mode="showcase"`
+  to the `runApp()` function. Or, if an app is designed to run in Showcase
+  mode by default, add a DESCRIPTION file in the app dir with Title, Author,
+  and License fields; with "Type: Shiny"; and with "DisplayMode: Showcase".
+
+* Upgraded to Bootstrap 2.3.2 and jQuery 1.11.0.
+
+* Make `tags$head()` and `singleton()` behave correctly when used with
+  `renderUI()` and `uiOutput()`. Previously, "hoisting content to the head"
+  and "only rendering items a single time" were features that worked only
+  when the page was initially loading, not in dynamic rendering.
+
+* Files are now sourced with the `keep.source` option, to help with debugging
+  and profiling.
+
+* Support user-defined input parsers for data coming in from JavaScript using
+  the parseShinyInput method.
+
+* Fixed the bug #299: renderDataTable() can deal with 0-row data frames now.
+  (reported by Harlan Harris)
+
+* Added `navbarPage()` and `navbarMenu()` functions to create applications
+  with multiple top level panels.
+
+* Added `navlistPanel()` function to create layouts with a a bootstrap
+  navlist on the left and tabPanels on the right
+
+* Added `type` parameter to `tabsetPanel()` to enable the use of pill
+  style tabs in addition to the standard ones.
+
+* Added `position` paramter to `tabsetPanel()` to enable positioning of tabs
+  above, below, left, or right of tab content.
+
+* Added `fluidPage()` and `fixedPage()` functions as well as related row and
+  column layout functions for creating arbitrary bootstrap grid layouts.
+
+* Added `hr()` builder function for creating horizontal rules.
+
+* Automatically concatenate duplicate attributes in tag definitions
+
+* Added `responsive` parameter to page building functions for opting-out of
+  bootstrap responsive css.
+
+* Added `theme` parameter to page building functions for specifying alternate
+  bootstrap css styles.
+
+* Added `icon()` function for embedding icons from the
+  [font awesome](http://fontawesome.io/) icon library
+
+* Added `makeReactiveBinding` function to turn a "regular" variable into a
+  reactive one (i.e. reading the variable makes the current reactive context
+  dependent on it, and setting the variable is a source of reactivity).
+
+* Added a function `withMathJax()` to include the MathJax library in an app.
+
+* The argument `selected` in checkboxGroupInput(), selectInput(), and
+  radioButtons() refers to the value(s) instead of the name(s) of the
+  argument `choices` now. For example, the value of the `selected` argument
+  in selectInput(..., choices = c('Label 1' = 'x1', 'Label 2' = 'x2'),
+  selected = 'Label 2') must be updated to 'x2', although names/labels will
+  be automatically converted to values internally for backward
+  compatibility. The same change applies to updateCheckboxGroupInput(),
+  updateSelectInput(), and updateRadioButtons() as well. (#340)
+
+* Now it is possible to only update the value of a checkbox group, select input,
+  or radio buttons using the `selected` argument without providing the
+  `choices` argument in updateCheckboxGroupInput(), updateSelectInput(), and
+  updateRadioButtons(), respectively. (#340)
+
+* Added `absolutePanel` and `fixedPanel` functions for creating absolute-
+  and fixed-position panels. They can be easily made user-draggable by
+  specifying `draggable = TRUE`.
+
+* For the `options` argument of the function `renderDataTable()`, we can
+  pass literal JavaScript code to the DataTables library via `I()`. This
+  makes it possible to use any JavaScript object in the options, e.g. a
+  JavaScript function (which is not supported in JSON). See
+  `?renderDataTable` for details and examples.
+
+* DataTables also works under IE8 now.
+
+* Fixed a bug in DataTables pagination when searching is turned on, which
+  caused failures for matrices as well as empty rows when displaying data
+  frames using renderDataTable().
+
+* The `options` argument in `renderDataTable()` can also take a function
+  that returns a list. This makes it possible to use reactive values in the
+  options. (#392)
+
+* `renderDataTable()` respects more DataTables options now: (1) either
+  bPaginate = FALSE or iDisplayLength = -1 will disable pagination (i.e. all
+  rows are returned from the data); besides, this means we can also use -1
+  in the length menu, e.g. aLengthMenu = list(c(10, 30, -1), list(10, 30,
+  'All')); (2) we can disable searching for individual columns through the
+  bSearchable option, e.g. aoColumns = list(list(bSearchable = FALSE),
+  list(bSearchable = TRUE),...) (the search box for the first column is
+  hidden); (3) we can turn off searching entirely (for both global searching
+  and individual columns) using the option bFilter = FALSE.
+
+* Added an argument `callback` in `renderDataTable()` so that a custom
+  JavaScript function can be applied to the DataTable object. This makes it
+  much easier to use DataTables plug-ins.
+
+* For numeric columns in a DataTable, the search boxes support lower and
+  upper bounds now: a search query of the form "lower,upper" (without
+  quotes) indicates the limits [lower, upper]. For a column X, this means
+  the rows corresponding to X >= lower & X <= upper are returned. If we omit
+  either the lower limit or the upper limit, only the other limit will be
+  used, e.g. ",upper" means X <= upper.
+
+* `updateNumericInput(value)` tries to preserve numeric precision by avoiding
+  scientific notation when possible, e.g. 102145 is no longer rounded to
+  1.0214e+05 = 102140. (Thanks, Martin Loos. #401)
+
+* `sliderInput()` no longer treats a label wrapped in HTML() as plain text,
+  e.g. the label in sliderInput(..., label = HTML('<em>A Label</em>')) will
+  not be escaped any more. (#119)
+
+* Fixed #306: the trailing slash in a path could fail `addResourcePath()`
+  under Windows. (Thanks, ZJ Dai)
+
+* Dots are now legal characters for inputId/outputId. (Thanks, Kevin
+  Lindquist. #358)
+
+shiny 0.8.0
+--------------------------------------------------------------------------------
+
+* Debug hooks are registered on all user-provided functions and (reactive)
+  expressions (e.g., in renderPlot()), which makes it possible to set
+  breakpoints in these functions using the latest version of the RStudio
+  IDE, and the RStudio visual debugging tools can be used to debug Shiny
+  apps. Internally, the registration is done via installExprFunction(),
+  which is a new function introduced in this version to replace
+  exprToFunction() so that the registration can be automatically done.
+
+* Added a new function renderDataTable() to display tables using the
+  JavaScript library DataTables. It includes basic features like pagination,
+  searching (global search or search by individual columns), sorting (by
+  single or multiple columns). All these features are implemented on the R
+  side; for example, we can use R regular expressions for searching.
+  Besides, it also uses the Bootstrap CSS style. See the full
+  documentation and examples in the tutorial:
+  http://rstudio.github.io/shiny/tutorial/#datatables
+
+* Added a new option `shiny.error` which can take a function as an error
+  handler. It is called when an error occurs in an app (in user-provided
+  code), e.g., after we set options(shiny.error = recover), we can enter a
+  specified environment in the call stack to debug our code after an error
+  occurs.
+
+* The argument `launch.browser` in runApp() can also be a function,
+  which takes the URL of the shiny app as its input value.
+
+* runApp() uses a random port between 3000 and 8000 instead of 8100 now. It
+  will try up to 20 ports in case certain ports are not available.
+
+* Fixed a bug for conditional panels: the value `input.id` in the condition
+  was not correctly retrieved when the input widget had a type, such as
+  numericInput(). (reported by Jason Bryer)
+
+* Fixed two bugs in plotOutput(); clickId and hoverId did not give correct
+  coordinates in Firefox, or when the axis limits of the plot were changed.
+  (reported by Chris Warth and Greg D)
+
+* The minimal required version for the httpuv package was increased to 1.2
+  (on CRAN now).
+
+
+shiny 0.7.0
+--------------------------------------------------------------------------------
+
+* Stopped sending websocket subprotocol. This fixes a compatibility issue with
+  Google Chrome 30.
+
+* The `input` and `output` objects are now also accessible via `session$input`
+  and `session$output`.
+
+* Added click and hover events for static plots; see `?plotOutput` for details.
+
+* Added optional logging of the execution states of a reactive program, and
+  tools for visualizing the log data. To use, start a new R session and call
+  `options(shiny.reactlog=TRUE)`. Then launch a Shiny app and interact with it.
+  Press Ctrl+F3 (or for Mac, Cmd+F3) in the browser to launch an interactive
+  visualization of the reactivity that has occurred. See `?showReactLog` for
+  more information.
+
+* Added `includeScript()` and `includeCSS()` functions.
+
+* Reactive expressions now have class="reactive" attribute. Also added
+  `is.reactive()` and `is.reactivevalues()` functions.
+
+* New `stopApp()` function, which stops an app and returns a value to the caller
+  of `runApp()`.
+
+* Added the `shiny.usecairo` option, which can be used to tell Shiny not to use
+  Cairo for PNG output even when it is installed. (Defaults to `TRUE`.)
+
+* Speed increases for `selectInput()` and `radioButtons()`, and their
+  corresponding updater functions, for when they have many options.
+
+* Added `tagSetChildren()` and `tagAppendChildren()` functions.
+
+* The HTTP request object that created the websocket is now accessible from the
+  `session` object, as `session$request`. This is a Rook-like request
+  environment that can be used to access HTTP headers, among other things.
+  (Note: When running in a Shiny Server environment, the request will reflect
+  the proxy HTTP request that was made from the Shiny Server process to the R
+  process, not the request that was made from the web browser to Shiny Server.)
+
+* Fix `getComputedStyle` issue, for IE8 browser compatibility (#196). Note:
+  Shiny Server is still required for IE8/9 compatibility.
+
+* Add shiny.sharedSecret option, to require the HTTP header Shiny-Shared-Secret
+  to be set to the given value.
 
 shiny 0.6.0
 --------------------------------------------------------------------------------
@@ -226,7 +798,7 @@ shiny 0.1.8
 * Fix issue #27: Warnings cause reactive functions to stop executing.
 * The server.R and ui.R filenames are now case insensitive.
 * Add `wellPanel` function for creating inset areas on the page.
-* Add `bootstrapPage` function for creating new Twitter Bootstrap based
+* Add `bootstrapPage` function for creating new Bootstrap based
   layouts from scratch.
 
 
@@ -288,11 +860,11 @@ shiny 0.1.3
   creating custom input controls
 * Add `step` parameter to numericInput
 * Read names of input using `names(input)`
-* Access snapshot of input as a list using `as.list(input)` 
+* Access snapshot of input as a list using `as.list(input)`
 * Fix issue #10: Plots in tabsets not rendered
 
 
 shiny 0.1.2
 --------------------------------------------------------------------------------
 
-Initial private beta release!
+Initial private beta release!

R/app.R

@@ -0,0 +1,380 @@
+# TODO: Subapp global.R
+
+#' Create a Shiny app object
+#'
+#' These functions create Shiny app objects from either an explicit UI/server
+#' pair (\code{shinyApp}), or by passing the path of a directory that contains a
+#' Shiny app (\code{shinyAppDir}). You generally shouldn't need to use these
+#' functions to create/run applications; they are intended for interoperability
+#' purposes, such as embedding Shiny apps inside a \pkg{knitr} document.
+#'
+#' Normally when this function is used at the R console, the Shiny app object is
+#' automatically passed to the \code{print()} function, which runs the app. If
+#' this is called in the middle of a function, the value will not be passed to
+#' \code{print()} and the app will not be run. To make the app run, pass the app
+#' object to \code{print()} or \code{\link{runApp}()}.
+#'
+#' @param ui The UI definition of the app (for example, a call to
+#'   \code{fluidPage()} with nested controls)
+#' @param server A server function
+#' @param onStart A function that will be called before the app is actually run.
+#'   This is only needed for \code{shinyAppObj}, since in the \code{shinyAppDir}
+#'   case, a \code{global.R} file can be used for this purpose.
+#' @param options Named options that should be passed to the `runApp` call. You
+#'   can also specify \code{width} and \code{height} parameters which provide a
+#'   hint to the embedding environment about the ideal height/width for the app.
+#' @param uiPattern A regular expression that will be applied to each \code{GET}
+#'   request to determine whether the \code{ui} should be used to handle the
+#'   request. Note that the entire request path must match the regular
+#'   expression in order for the match to be considered successful.
+#' @return An object that represents the app. Printing the object or passing it
+#'   to \code{\link{runApp}} will run the app.
+#'
+#' @examples
+#' ## Only run this example in interactive R sessions
+#' if (interactive()) {
+#'   shinyApp(
+#'     ui = fluidPage(
+#'       numericInput("n", "n", 1),
+#'       plotOutput("plot")
+#'     ),
+#'     server = function(input, output) {
+#'       output$plot <- renderPlot( plot(head(cars, input$n)) )
+#'     }
+#'   )
+#'
+#'   shinyAppDir(system.file("examples/01_hello", package="shiny"))
+#'
+#'
+#'   # The object can be passed to runApp()
+#'   app <- shinyApp(
+#'     ui = fluidPage(
+#'       numericInput("n", "n", 1),
+#'       plotOutput("plot")
+#'     ),
+#'     server = function(input, output) {
+#'       output$plot <- renderPlot( plot(head(cars, input$n)) )
+#'     }
+#'   )
+#'
+#'   runApp(app)
+#' }
+#'
+#' @export
+shinyApp <- function(ui=NULL, server=NULL, onStart=NULL, options=list(),
+                     uiPattern="/") {
+  if (is.null(server)) {
+    stop("`server` missing from shinyApp")
+  }
+
+  # Ensure that the entire path is a match
+  uiPattern <- sprintf("^%s$", uiPattern)
+
+  httpHandler <- uiHttpHandler(ui, uiPattern)
+
+  serverFuncSource <- function() {
+    server
+  }
+
+  structure(
+    list(
+      httpHandler = httpHandler,
+      serverFuncSource = serverFuncSource,
+      onStart = onStart,
+      options = options),
+    class = "shiny.appobj"
+  )
+}
+
+#' @rdname shinyApp
+#' @param appDir Path to directory that contains a Shiny app (i.e. a server.R
+#'   file and either ui.R or www/index.html)
+#' @export
+shinyAppDir <- function(appDir, options=list()) {
+  if (!utils::file_test('-d', appDir)) {
+    stop("No Shiny application exists at the path \"", appDir, "\"")
+  }
+
+  # In case it's a relative path, convert to absolute (so we're not adversely
+  # affected by future changes to the path)
+  appDir <- normalizePath(appDir, mustWork = TRUE)
+
+  if (file.exists.ci(appDir, "server.R")) {
+    shinyAppDir_serverR(appDir, options = options)
+  } else if (file.exists.ci(appDir, "app.R")) {
+    shinyAppDir_appR(appDir, options = options)
+  } else {
+    stop("App dir must contain either app.R or server.R.")
+  }
+}
+
+# This reads in an app dir in the case that there's a server.R (and ui.R/www)
+# present, and returns a shiny.appobj.
+shinyAppDir_serverR <- function(appDir, options=list()) {
+  # Most of the complexity here comes from needing to hot-reload if the .R files
+  # change on disk, or are created, or are removed.
+
+  # uiHandlerSource is a function that returns an HTTP handler for serving up
+  # ui.R as a webpage. The "cachedFuncWithFile" call makes sure that the closure
+  # we're creating here only gets executed when ui.R's contents change.
+  uiHandlerSource <- cachedFuncWithFile(appDir, "ui.R", case.sensitive = FALSE,
+    function(uiR) {
+      if (file.exists(uiR)) {
+        # If ui.R contains a call to shinyUI (which sets .globals$ui), use that.
+        # If not, then take the last expression that's returned from ui.R.
+        .globals$ui <- NULL
+        on.exit(.globals$ui <- NULL, add = FALSE)
+        ui <- sourceUTF8(uiR, local = new.env(parent = globalenv()))$value
+        if (!is.null(.globals$ui)) {
+          ui <- .globals$ui[[1]]
+        }
+        return(uiHttpHandler(ui))
+      } else {
+        return(function(req) NULL)
+      }
+    }
+  )
+  uiHandler <- function(req) {
+    uiHandlerSource()(req)
+  }
+
+  wwwDir <- file.path.ci(appDir, "www")
+  fallbackWWWDir <- system.file("www-dir", package = "shiny")
+  serverSource <- cachedFuncWithFile(appDir, "server.R", case.sensitive = FALSE,
+    function(serverR) {
+      # If server.R contains a call to shinyServer (which sets .globals$server),
+      # use that. If not, then take the last expression that's returned from
+      # server.R.
+      .globals$server <- NULL
+      on.exit(.globals$server <- NULL, add = TRUE)
+      result <- sourceUTF8(serverR, local = new.env(parent = globalenv()))$value
+      if (!is.null(.globals$server)) {
+        result <- .globals$server[[1]]
+      }
+      return(result)
+    }
+  )
+
+  # This function stands in for the server function, and reloads the
+  # real server function as necessary whenever server.R changes
+  serverFuncSource <- function() {
+    serverFunction <- serverSource()
+    if (is.null(serverFunction)) {
+      return(function(input, output) NULL)
+    } else if (is.function(serverFunction)) {
+      # This is what we normally expect; run the server function
+      return(serverFunction)
+    } else {
+      stop("server.R returned an object of unexpected type: ",
+        typeof(serverFunction))
+    }
+  }
+
+  oldwd <- NULL
+  onStart <- function() {
+    oldwd <<- getwd()
+    setwd(appDir)
+    if (file.exists(file.path.ci(appDir, "global.R")))
+      sourceUTF8(file.path.ci(appDir, "global.R"))
+  }
+  onEnd <- function() {
+    setwd(oldwd)
+  }
+
+  structure(
+    list(
+      httpHandler = joinHandlers(c(uiHandler, wwwDir, fallbackWWWDir)),
+      serverFuncSource = serverFuncSource,
+      onStart = onStart,
+      onEnd = onEnd,
+      options = options),
+    class = "shiny.appobj"
+  )
+}
+
+# This reads in an app dir in the case that there's a app.R present, and returns
+# a shiny.appobj.
+shinyAppDir_appR <- function(appDir, options=list()) {
+  fullpath <- file.path.ci(appDir, "app.R")
+
+  # This sources app.R and caches the content. When appObj() is called but
+  # app.R hasn't changed, it won't re-source the file. But if called and
+  # app.R has changed, it'll re-source the file and return the result.
+  appObj <- cachedFuncWithFile(appDir, "app.R", case.sensitive = FALSE,
+    function(appR) {
+      result <- sourceUTF8(fullpath, local = new.env(parent = globalenv()))$value
+
+      if (!is.shiny.appobj(result))
+        stop("app.R did not return a shiny.appobj object.")
+
+      return(result)
+    }
+  )
+
+  # A function that invokes the http handler from the appObj in app.R, but
+  # since this uses appObj(), it only re-sources the file when it changes.
+  dynHttpHandler <- function(...) {
+    appObj()$httpHandler(...)
+  }
+
+  dynServerFuncSource <- function(...) {
+    appObj()$serverFuncSource(...)
+  }
+
+  wwwDir <- file.path.ci(appDir, "www")
+  fallbackWWWDir <- system.file("www-dir", package = "shiny")
+
+  oldwd <- NULL
+  onStart <- function() {
+    oldwd <<- getwd()
+    setwd(appDir)
+  }
+  onEnd <- function() {
+    setwd(oldwd)
+  }
+
+  structure(
+    list(
+      httpHandler = joinHandlers(c(dynHttpHandler, wwwDir, fallbackWWWDir)),
+      serverFuncSource = dynServerFuncSource,
+      onStart = onStart,
+      onEnd = onEnd,
+      options = options
+    ),
+    class = "shiny.appobj"
+  )
+}
+
+
+#' @rdname shinyApp
+#' @param x Object to convert to a Shiny app.
+#' @export
+as.shiny.appobj <- function(x) {
+  UseMethod("as.shiny.appobj", x)
+}
+
+#' @rdname shinyApp
+#' @export
+as.shiny.appobj.shiny.appobj <- function(x) {
+  x
+}
+
+#' @rdname shinyApp
+#' @export
+as.shiny.appobj.list <- function(x) {
+  shinyApp(ui = x$ui, server = x$server)
+}
+
+#' @rdname shinyApp
+#' @export
+as.shiny.appobj.character <- function(x) {
+  shinyAppDir(x)
+}
+
+#' @rdname shinyApp
+#' @export
+is.shiny.appobj <- function(x) {
+  inherits(x, "shiny.appobj")
+}
+
+#' @rdname shinyApp
+#' @param ... Additional parameters to be passed to print.
+#' @export
+print.shiny.appobj <- function(x, ...) {
+  opts <- x$options %OR% list()
+  opts <- opts[names(opts) %in%
+      c("port", "launch.browser", "host", "quiet", "display.mode")]
+
+  args <- c(list(x), opts)
+
+  do.call(runApp, args)
+}
+
+#' @rdname shinyApp
+#' @method as.tags shiny.appobj
+#' @export
+as.tags.shiny.appobj <- function(x, ...) {
+  # jcheng 06/06/2014: Unfortunate copy/paste between this function and
+  # knit_print.shiny.appobj, but I am trying to make the most conservative
+  # change possible due to upcoming release.
+  opts <- x$options %OR% list()
+  width <- if (is.null(opts$width)) "100%" else opts$width
+  height <- if (is.null(opts$height)) "400" else opts$height
+
+  path <- addSubApp(x)
+  tags$iframe(src=path, width=width, height=height, class="shiny-frame")
+}
+
+#' Knitr S3 methods
+#'
+#' These S3 methods are necessary to help Shiny applications and UI chunks embed
+#' themselves in knitr/rmarkdown documents.
+#'
+#' @name knitr_methods
+#' @param x Object to knit_print
+#' @param ... Additional knit_print arguments
+NULL
+
+# If there's an R Markdown runtime option set but it isn't set to Shiny, then
+# return a warning indicating the runtime is inappropriate for this object.
+# Returns NULL in all other cases.
+shiny_rmd_warning <- function() {
+  runtime <- knitr::opts_knit$get("rmarkdown.runtime")
+  if (!is.null(runtime) && runtime != "shiny")
+    # note that the RStudio IDE checks for this specific string to detect Shiny
+    # applications in static document
+    list(structure(
+      "Shiny application in a static R Markdown document",
+      class = "rmd_warning"))
+  else
+    NULL
+}
+
+#' @rdname knitr_methods
+#' @export
+knit_print.shiny.appobj <- function(x, ...) {
+  opts <- x$options %OR% list()
+  width <- if (is.null(opts$width)) "100%" else opts$width
+  height <- if (is.null(opts$height)) "400" else opts$height
+
+  runtime <- knitr::opts_knit$get("rmarkdown.runtime")
+  if (!is.null(runtime) && runtime != "shiny") {
+    # If not rendering to a Shiny document, create a box exactly the same
+    # dimensions as the Shiny app would have had (so the document continues to
+    # flow as it would have with the app), and display a diagnostic message
+    width <- validateCssUnit(width)
+    height <- validateCssUnit(height)
+    output <- tags$div(
+      style=paste("width:", width, "; height:", height, "; text-align: center;",
+                  "box-sizing: border-box;", "-moz-box-sizing: border-box;",
+                  "-webkit-box-sizing: border-box;"),
+      class="muted well",
+      "Shiny applications not supported in static R Markdown documents")
+  }
+  else {
+    path <- addSubApp(x)
+    output <- tags$iframe(src=path, width=width, height=height,
+                          class="shiny-frame")
+  }
+
+  # If embedded Shiny apps ever have JS/CSS dependencies (like pym.js) we'll
+  # need to grab those and put them in meta, like in knit_print.shiny.tag. But
+  # for now it's not an issue, so just return the HTML and warning.
+
+  knitr::asis_output(htmlPreserve(format(output, indent=FALSE)),
+                     meta = shiny_rmd_warning(), cacheable = FALSE)
+}
+
+# Let us use a nicer syntax in knitr chunks than literally
+# calling output$value <- renderFoo(...) and fooOutput().
+#' @rdname knitr_methods
+#' @param inline Whether the object is printed inline.
+#' @export
+knit_print.shiny.render.function <- function(x, ..., inline = FALSE) {
+  x <- htmltools::as.tags(x, inline = inline)
+  output <- knitr::knit_print(tagList(x))
+  attr(output, "knit_cacheable") <- FALSE
+  attr(output, "knit_meta") <- append(attr(output, "knit_meta"),
+                                      shiny_rmd_warning())
+  output
+}

R/bootstrap-layout.R

@@ -0,0 +1,419 @@
+
+#' Create a page with fluid layout
+#'
+#' Functions for creating fluid page layouts. A fluid page layout consists of
+#' rows which in turn include columns. Rows exist for the purpose of making sure
+#' their elements appear on the same line (if the browser has adequate width).
+#' Columns exist for the purpose of defining how much horizontal space within a
+#' 12-unit wide grid it's elements should occupy. Fluid pages scale their
+#' components in realtime to fill all available browser width.
+#'
+#' @param ... Elements to include within the page
+#' @param title The browser window title (defaults to the host URL of the page).
+#'   Can also be set as a side effect of the \code{\link{titlePanel}} function.
+#' @param responsive This option is deprecated; it is no longer optional with
+#'   Bootstrap 3.
+#' @param theme Alternative Bootstrap stylesheet (normally a css file within the
+#'   www directory). For example, to use the theme located at
+#'   \code{www/bootstrap.css} you would use \code{theme = "bootstrap.css"}.
+#'
+#' @return A UI defintion that can be passed to the \link{shinyUI} function.
+#'
+#' @details To create a fluid page use the \code{fluidPage} function and include
+#'   instances of \code{fluidRow} and \code{\link{column}} within it. As an
+#'   alternative to low-level row and column functions you can also use
+#'   higher-level layout functions like \code{\link{sidebarLayout}}.
+#'
+#' @note See the \href{http://shiny.rstudio.com/articles/layout-guide.html}{
+#'   Shiny-Application-Layout-Guide} for additional details on laying out fluid
+#'   pages.
+#'
+#' @seealso \code{\link{column}}, \code{\link{sidebarLayout}}
+#'
+#' @examples
+#' shinyUI(fluidPage(
+#'
+#'   # Application title
+#'   titlePanel("Hello Shiny!"),
+#'
+#'   sidebarLayout(
+#'
+#'     # Sidebar with a slider input
+#'     sidebarPanel(
+#'       sliderInput("obs",
+#'                   "Number of observations:",
+#'                   min = 0,
+#'                   max = 1000,
+#'                   value = 500)
+#'     ),
+#'
+#'     # Show a plot of the generated distribution
+#'     mainPanel(
+#'       plotOutput("distPlot")
+#'     )
+#'   )
+#' ))
+#'
+#' shinyUI(fluidPage(
+#'   title = "Hello Shiny!",
+#'   fluidRow(
+#'     column(width = 4,
+#'       "4"
+#'     ),
+#'     column(width = 3, offset = 2,
+#'       "3 offset 2"
+#'     )
+#'   )
+#' ))
+#'
+#' @rdname fluidPage
+#' @export
+fluidPage <- function(..., title = NULL, responsive = NULL, theme = NULL) {
+  bootstrapPage(div(class = "container-fluid", ...),
+                title = title,
+                responsive = responsive,
+                theme = theme)
+}
+
+
+#' @rdname fluidPage
+#' @export
+fluidRow <- function(...) {
+  div(class = "row", ...)
+}
+
+#' Create a page with a fixed layout
+#'
+#' Functions for creating fixed page layouts. A fixed page layout consists of
+#' rows which in turn include columns. Rows exist for the purpose of making sure
+#' their elements appear on the same line (if the browser has adequate width).
+#' Columns exist for the purpose of defining how much horizontal space within a
+#' 12-unit wide grid it's elements should occupy. Fixed pages limit their width
+#' to 940 pixels on a typical display, and 724px or 1170px on smaller and larger
+#' displays respectively.
+#'
+#' @param ... Elements to include within the container
+#' @param title The browser window title (defaults to the host URL of the page)
+#' @param responsive This option is deprecated; it is no longer optional with
+#'   Bootstrap 3.
+#' @param theme Alternative Bootstrap stylesheet (normally a css file within the
+#'   www directory). For example, to use the theme located at
+#'   \code{www/bootstrap.css} you would use \code{theme = "bootstrap.css"}.
+#'
+#' @return A UI defintion that can be passed to the \link{shinyUI} function.
+#'
+#' @details To create a fixed page use the \code{fixedPage} function and include
+#'   instances of \code{fixedRow} and \code{\link{column}} within it. Note that
+#'   unlike \code{\link{fluidPage}}, fixed pages cannot make use of higher-level
+#'   layout functions like \code{sidebarLayout}, rather, all layout must be done
+#'   with \code{fixedRow} and \code{column}.
+#'
+#' @note See the \href{http://shiny.rstudio.com/articles/layout-guide.html}{
+#'   Shiny Application Layout Guide} for additional details on laying out fixed
+#'   pages.
+#'
+#' @seealso \code{\link{column}}
+#'
+#' @examples
+#' shinyUI(fixedPage(
+#'   title = "Hello, Shiny!",
+#'   fixedRow(
+#'     column(width = 4,
+#'       "4"
+#'     ),
+#'     column(width = 3, offset = 2,
+#'       "3 offset 2"
+#'     )
+#'   )
+#' ))
+#'
+#' @rdname fixedPage
+#' @export
+fixedPage <- function(..., title = NULL, responsive = NULL, theme = NULL) {
+  bootstrapPage(div(class = "container", ...),
+                title = title,
+                responsive = responsive,
+                theme = theme)
+}
+
+#' @rdname fixedPage
+#' @export
+fixedRow <- function(...) {
+  div(class = "row", ...)
+}
+
+
+#' Create a column within a UI definition
+#'
+#' Create a column for use within a  \code{\link{fluidRow}} or
+#' \code{\link{fixedRow}}
+#'
+#' @param width The grid width of the column (must be between 1 and 12)
+#' @param ... Elements to include within the column
+#' @param offset The number of columns to offset this column from the end of the
+#'   previous column.
+#'
+#' @return A column that can be included within a
+#'   \code{\link{fluidRow}} or \code{\link{fixedRow}}.
+#'
+#'
+#' @seealso \code{\link{fluidRow}}, \code{\link{fixedRow}}.
+#'
+#' @examples
+#' fluidRow(
+#'   column(4,
+#'     sliderInput("obs", "Number of observations:",
+#'                 min = 1, max = 1000, value = 500)
+#'   ),
+#'   column(8,
+#'     plotOutput("distPlot")
+#'   )
+#' )
+#'
+#' fluidRow(
+#'   column(width = 4,
+#'     "4"
+#'   ),
+#'   column(width = 3, offset = 2,
+#'     "3 offset 2"
+#'   )
+#' )
+#' @export
+column <- function(width, ..., offset = 0) {
+
+  if (!is.numeric(width) || (width < 1) || (width > 12))
+    stop("column width must be between 1 and 12")
+
+  colClass <- paste0("col-sm-", width)
+  if (offset > 0)
+    colClass <- paste0(colClass, " col-sm-offset-", offset)
+  div(class = colClass, ...)
+}
+
+
+#' Create a panel containing an application title.
+#'
+#' @param title An application title to display
+#' @param windowTitle The title that should be displayed by the browser window.
+#'
+#' @details Calling this function has the side effect of including a
+#'   \code{title} tag within the head. You can also specify a page title
+#'   explicitly using the `title` parameter of the top-level page function.
+#'
+#'
+#' @examples
+#' titlePanel("Hello Shiny!")
+#'
+#' @export
+titlePanel <- function(title, windowTitle=title) {
+  tagList(
+    tags$head(tags$title(windowTitle)),
+    h2(title)
+  )
+}
+
+#' Layout a sidebar and main area
+#'
+#' Create a layout with a sidebar and main area. The sidebar is displayed with a
+#' distinct background color and typically contains input controls. The main
+#' area occupies 2/3 of the horizontal width and typically contains outputs.
+#'
+#' @param sidebarPanel The \link{sidebarPanel} containing input controls
+#' @param mainPanel The \link{mainPanel} containing outputs
+#' @param position The position of the sidebar relative to the main area ("left"
+#'   or "right")
+#' @param fluid \code{TRUE} to use fluid layout; \code{FALSE} to use fixed
+#'   layout.
+#'
+#' @examples
+#' # Define UI
+#' shinyUI(fluidPage(
+#'
+#'   # Application title
+#'   titlePanel("Hello Shiny!"),
+#'
+#'   sidebarLayout(
+#'
+#'     # Sidebar with a slider input
+#'     sidebarPanel(
+#'       sliderInput("obs",
+#'                   "Number of observations:",
+#'                   min = 0,
+#'                   max = 1000,
+#'                   value = 500)
+#'     ),
+#'
+#'     # Show a plot of the generated distribution
+#'     mainPanel(
+#'       plotOutput("distPlot")
+#'     )
+#'   )
+#' ))
+#'
+#' @export
+sidebarLayout <- function(sidebarPanel,
+                          mainPanel,
+                          position = c("left", "right"),
+                          fluid = TRUE) {
+
+  # determine the order
+  position <- match.arg(position)
+  if (position == "left") {
+    firstPanel <- sidebarPanel
+    secondPanel <- mainPanel
+  }
+  else if (position == "right") {
+    firstPanel <- mainPanel
+    secondPanel <- sidebarPanel
+  }
+
+  # return as as row
+  if (fluid)
+    fluidRow(firstPanel, secondPanel)
+  else
+    fixedRow(firstPanel, secondPanel)
+}
+
+#' Lay out UI elements vertically
+#'
+#' Create a container that includes one or more rows of content (each element
+#' passed to the container will appear on it's own line in the UI)
+#'
+#' @param ... Elements to include within the container
+#' @param fluid \code{TRUE} to use fluid layout; \code{FALSE} to use fixed
+#'   layout.
+#'
+#' @seealso \code{\link{fluidPage}}, \code{\link{flowLayout}}
+#'
+#' @examples
+#' shinyUI(fluidPage(
+#'   verticalLayout(
+#'     a(href="http://example.com/link1", "Link One"),
+#'     a(href="http://example.com/link2", "Link Two"),
+#'     a(href="http://example.com/link3", "Link Three")
+#'   )
+#' ))
+#' @export
+verticalLayout <- function(..., fluid = TRUE) {
+  lapply(list(...), function(row) {
+    col <- column(12, row)
+    if (fluid)
+      fluidRow(col)
+    else
+      fixedRow(col)
+  })
+}
+
+#' Flow layout
+#'
+#' Lays out elements in a left-to-right, top-to-bottom arrangement. The elements
+#' on a given row will be top-aligned with each other. This layout will not work
+#' well with elements that have a percentage-based width (e.g.
+#' \code{\link{plotOutput}} at its default setting of \code{width = "100\%"}).
+#'
+#' @param ... Unnamed arguments will become child elements of the layout. Named
+#'   arguments will become HTML attributes on the outermost tag.
+#' @param cellArgs Any additional attributes that should be used for each cell
+#'   of the layout.
+#'
+#' @seealso \code{\link{verticalLayout}}
+#'
+#' @examples
+#' flowLayout(
+#'   numericInput("rows", "How many rows?", 5),
+#'   selectInput("letter", "Which letter?", LETTERS),
+#'   sliderInput("value", "What value?", 0, 100, 50)
+#' )
+#' @export
+flowLayout <- function(..., cellArgs = list()) {
+
+  children <- list(...)
+  childIdx <- !nzchar(names(children) %OR% character(length(children)))
+  attribs <- children[!childIdx]
+  children <- children[childIdx]
+
+  do.call(tags$div, c(list(class = "shiny-flow-layout"),
+    attribs,
+    lapply(children, function(x) {
+      do.call(tags$div, c(cellArgs, list(x)))
+    })
+  ))
+}
+
+#' Input panel
+#'
+#' A \code{\link{flowLayout}} with a grey border and light grey background,
+#' suitable for wrapping inputs.
+#'
+#' @param ... Input controls or other HTML elements.
+#'
+#' @export
+inputPanel <- function(...) {
+  div(class = "shiny-input-panel",
+    flowLayout(...)
+  )
+}
+
+#' Split layout
+#'
+#' Lays out elements horizontally, dividing the available horizontal space into
+#' equal parts (by default).
+#'
+#' @param ... Unnamed arguments will become child elements of the layout. Named
+#'   arguments will become HTML attributes on the outermost tag.
+#' @param cellWidths Character or numeric vector indicating the widths of the
+#'   individual cells. Recycling will be used if needed. Character values will
+#'   be interpreted as CSS lengths (see \code{\link{validateCssUnit}}), numeric
+#'   values as pixels.
+#' @param cellArgs Any additional attributes that should be used for each cell
+#'   of the layout.
+#'
+#' @examples
+#' # Equal sizing
+#' splitLayout(
+#'   plotOutput("plot1"),
+#'   plotOutput("plot2")
+#' )
+#'
+#' # Custom widths
+#' splitLayout(cellWidths = c("25%", "75%"),
+#'   plotOutput("plot1"),
+#'   plotOutput("plot2")
+#' )
+#'
+#' # All cells at 300 pixels wide, with cell padding
+#' # and a border around everything
+#' splitLayout(
+#'   style = "border: 1px solid silver;",
+#'   cellWidths = 300,
+#'   cellArgs = list(style = "padding: 6px"),
+#'   plotOutput("plot1"),
+#'   plotOutput("plot2"),
+#'   plotOutput("plot3")
+#' )
+#' @export
+splitLayout <- function(..., cellWidths = NULL, cellArgs = list()) {
+
+  children <- list(...)
+  childIdx <- !nzchar(names(children) %OR% character(length(children)))
+  attribs <- children[!childIdx]
+  children <- children[childIdx]
+  count <- length(children)
+
+  if (length(cellWidths) == 0 || is.na(cellWidths)) {
+    cellWidths <- sprintf("%.3f%%", 100 / count)
+  }
+  cellWidths <- rep(cellWidths, length.out = count)
+  cellWidths <- sapply(cellWidths, validateCssUnit)
+
+  do.call(tags$div, c(list(class = "shiny-split-layout"),
+    attribs,
+    mapply(children, cellWidths, FUN = function(x, w) {
+      do.call(tags$div, c(
+        list(style = sprintf("width: %s;", w)),
+        cellArgs,
+        list(x)
+      ))
+    }, SIMPLIFY = FALSE)
+  ))
+}

R/cache.R

@@ -1,29 +1,26 @@
-# A context object for tracking a cache that needs to be dirtied when a set of 
-# files changes on disk. Each time the cache is dirtied, the set of files is 
+# A context object for tracking a cache that needs to be dirtied when a set of
+# files changes on disk. Each time the cache is dirtied, the set of files is
 # cleared. Therefore, the set of files needs to be re-built each time the cached
 # code executes. This approach allows for dynamic dependency graphs.
-CacheContext <- setRefClass(
+CacheContext <- R6Class(
   'CacheContext',
-  fields = list(
-    .dirty = 'logical',
-    .tests = 'list'
-  ),
-  methods = list(
-    initialize = function() {
-      .dirty <<- TRUE
-      # List of functions that return TRUE if dirty
-      .tests <<- list()
-    },
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+    .dirty = TRUE,
+    # List of functions that return TRUE if dirty
+    .tests = list(),
+
     addDependencyFile = function(file) {
       if (.dirty)
         return()
-      
+
       file <- normalizePath(file)
 
       mtime <- file.info(file)$mtime
       .tests <<- c(.tests, function() {
         newMtime <- try(file.info(file)$mtime, silent=TRUE)
-        if (is(newMtime, 'try-error'))
+        if (inherits(newMtime, 'try-error'))
           return(TRUE)
         return(!identical(mtime, newMtime))
       })
@@ -37,14 +34,14 @@ CacheContext <- setRefClass(
     isDirty = function() {
       if (.dirty)
         return(TRUE)
-      
+
       for (test in .tests) {
         if (test()) {
           forceDirty()
           return(TRUE)
         }
       }
-      
+
       return(FALSE)
     },
     reset = function() {
@@ -53,9 +50,9 @@ CacheContext <- setRefClass(
     },
     with = function(func) {
       oldCC <- .currentCacheContext$cc
-      .currentCacheContext$cc <- .self
+      .currentCacheContext$cc <- self
       on.exit(.currentCacheContext$cc <- oldCC)
-      
+
       return(func())
     }
   )
@@ -63,18 +60,18 @@ CacheContext <- setRefClass(
 
 .currentCacheContext <- new.env()
 
-# Indicates to Shiny that the given file path is part of the dependency graph 
+# Indicates to Shiny that the given file path is part of the dependency graph
 # for whatever is currently executing (so far, only ui.R). By default, ui.R only
 # gets re-executed when it is detected to have changed; this function allows the
 # caller to indicate that it should also re-execute if the given file changes.
-# 
+#
 # If NULL or NA is given as the argument, then ui.R will re-execute next time.
 dependsOnFile <- function(filepath) {
   if (is.null(.currentCacheContext$cc))
     return()
-  
+
   if (is.null(filepath) || is.na(filepath))
     .currentCacheContext$cc$forceDirty()
   else
     .currentCacheContext$cc$addDependencyFile(filepath)
-}
+}

R/fileupload.R

@@ -1,37 +1,38 @@
 # For HTML5-capable browsers, file uploads happen through a series of requests.
-# 
+#
 # 1. Client tells server that one or more files are about to be uploaded; the
 #    server responds with a "job ID" that the client should use for the rest of
 #    the upload.
-#    
+#
 # 2. For each file (sequentially):
 #    a. Client tells server the name, size, and type of the file.
 #    b. Client sends server a small-ish blob of data.
 #    c. Repeat 2b until the entire file has been uploaded.
 #    d. Client tells server that the current file is done.
-#    
+#
 # 3. Repeat 2 until all files have been uploaded.
-# 
+#
 # 4. Client tells server that all files have been uploaded, along with the
 #    input ID that this data should be associated with.
-# 
+#
 # Unfortunately this approach will not work for browsers that don't support
 # HTML5 File API, but the fallback approach we would like to use (multipart
 # form upload, i.e. traditional HTTP POST-based file upload) doesn't work with
 # the websockets package's HTTP server at the moment.
 
-FileUploadOperation <- setRefClass(
+FileUploadOperation <- R6Class(
   'FileUploadOperation',
-  fields = list(
-    .parent = 'ANY',
-    .id = 'character',
-    .files = 'data.frame',
-    .dir = 'character',
-    .currentFileInfo = 'list',
-    .currentFileData = 'ANY',
-    .pendingFileInfos = 'list'
-  ),
-  methods = list(
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+    .parent = NULL,
+    .id = character(0),
+    .files = data.frame(),
+    .dir = character(0),
+    .currentFileInfo = list(),
+    .currentFileData = NULL,
+    .pendingFileInfos = list(),
+
     initialize = function(parent, id, dir, fileInfos) {
       .parent <<- parent
       .id <<- id
@@ -54,12 +55,12 @@ FileUploadOperation <- setRefClass(
       filename <- file.path(.dir, as.character(length(.files$name)))
       row <- data.frame(name=file$name, size=file$size, type=file$type,
                         datapath=filename, stringsAsFactors=FALSE)
-      
+
       if (length(.files$name) == 0)
         .files <<- row
       else
         .files <<- rbind(.files, row)
-      
+
       .currentFileData <<- file(filename, open='wb')
     },
     fileChunk = function(rawdata) {
@@ -77,33 +78,50 @@ FileUploadOperation <- setRefClass(
   )
 )
 
-FileUploadContext <- setRefClass(
+#' @include map.R
+FileUploadContext <- R6Class(
   'FileUploadContext',
-  fields = list(
-    .basedir = 'character',
-    .operations = 'Map'
+  class = FALSE,
+  private = list(
+    basedir = character(0),
+    operations = 'Map',
+    ids = character(0)  # Keep track of all ids used for file uploads
   ),
-  methods = list(
+  public = list(
     initialize = function(dir=tempdir()) {
-      .basedir <<- dir
+      private$basedir <- dir
+      private$operations <- Map$new()
     },
     createUploadOperation = function(fileInfos) {
       while (TRUE) {
-        id <- paste(as.raw(runif(12, min=0, max=0xFF)), collapse='')
-        dir <- file.path(.basedir, id)
+        id <- paste(as.raw(p_runif(12, min=0, max=0xFF)), collapse='')
+        private$ids <- c(private$ids, id)
+        dir <- file.path(private$basedir, id)
         if (!dir.create(dir))
           next
-        
-        op <- FileUploadOperation$new(.self, id, dir, fileInfos)
-        .operations$set(id, op)
+
+        op <- FileUploadOperation$new(self, id, dir, fileInfos)
+        private$operations$set(id, op)
         return(id)
       }
     },
     getUploadOperation = function(jobId) {
-      .operations$get(jobId)
+      private$operations$get(jobId)
     },
     onJobFinished = function(jobId) {
-      .operations$remove(jobId)
+      private$operations$remove(jobId)
+    },
+    # Remove the directories containing file uploads; this is to be called when
+    # a session ends.
+    rmUploadDirs = function() {
+      # Make sure all_paths is underneath the tempdir()
+      if (!grepl(normalizePath(tempdir()), normalizePath(private$basedir), fixed = TRUE)) {
+        stop("Won't remove upload path ", private$basedir,
+          "because it is not under tempdir(): ", tempdir())
+      }
+
+      all_paths <- file.path(private$basedir, private$ids)
+      unlink(all_paths, recursive = TRUE)
     }
   )
 )

R/globals.R

@@ -0,0 +1,23 @@
+# A scope where we can put mutable global state
+.globals <- new.env(parent = emptyenv())
+
+.onLoad <- function(libname, pkgname) {
+  # R's lazy-loading package scheme causes the private seed to be cached in the
+  # package itself, making our PRNG completely deterministic. This line resets
+  # the private seed during load.
+  withPrivateSeed(reinitializeSeed())
+}
+
+.onAttach <- function(libname, pkgname) {
+  # Check for htmlwidgets version, if installed. As of Shiny 0.12.0 and
+  # htmlwidgets 0.4, both packages switched from RJSONIO to jsonlite. Because of
+  # this change, Shiny 0.12.0 will work only with htmlwidgets >= 0.4, and vice
+  # versa.
+  if (system.file(package = "htmlwidgets") != "" &&
+      utils::packageVersion("htmlwidgets") < "0.4") {
+    packageStartupMessage(
+      "This version of Shiny is designed to work with htmlwidgets >= 0.4. ",
+      "Please upgrade your version of htmlwidgets."
+    )
+  }
+}

R/graph.R

@@ -1,11 +1,43 @@
-#' @export
 writeReactLog <- function(file=stdout()) {
-  cat(RJSONIO::toJSON(.graphEnv$log, pretty=TRUE), file=file)
+  cat(toJSON(.graphStack$as_list(), pretty=TRUE), file=file)
 }
 
+#' Reactive Log Visualizer
+#'
+#' Provides an interactive browser-based tool for visualizing reactive
+#' dependencies and execution in your application.
+#'
+#' To use the reactive log visualizer, start with a fresh R session and
+#' run the command \code{options(shiny.reactlog=TRUE)}; then launch your
+#' application in the usual way (e.g. using \code{\link{runApp}}). At
+#' any time you can hit Ctrl+F3 (or for Mac users, Command+F3) in your
+#' web browser to launch the reactive log visualization.
+#'
+#' The reactive log visualization only includes reactive activity up
+#' until the time the report was loaded. If you want to see more recent
+#' activity, refresh the browser.
+#'
+#' Note that Shiny does not distinguish between reactive dependencies
+#' that "belong" to one Shiny user session versus another, so the
+#' visualization will include all reactive activity that has taken place
+#' in the process, not just for a particular application or session.
+#'
+#' As an alternative to pressing Ctrl/Command+F3--for example, if you
+#' are using reactives outside of the context of a Shiny
+#' application--you can run the \code{showReactLog} function, which will
+#' generate the reactive log visualization as a static HTML file and
+#' launch it in your default browser. In this case, refreshing your
+#' browser will not load new activity into the report; you will need to
+#' call \code{showReactLog()} explicitly.
+#'
+#' For security and performance reasons, do not enable
+#' \code{shiny.reactlog} in production environments. When the option is
+#' enabled, it's possible for any user of your app to see at least some
+#' of the source code of your reactive expressions and observers.
+#'
 #' @export
 showReactLog <- function() {
-  browseURL(renderReactLog())
+  utils::browseURL(renderReactLog())
 }
 
 renderReactLog <- function() {
@@ -22,52 +54,50 @@ renderReactLog <- function() {
   return(file)
 }
 
-.graphAppend <- function(logEntry) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE)))
-    .graphEnv$log <- c(.graphEnv$log, list(logEntry))
-}
+.graphAppend <- function(logEntry, domain = getDefaultReactiveDomain()) {
+  if (isTRUE(getOption('shiny.reactlog')))
+    .graphStack$push(logEntry)
 
-.graphDependsOn <- function(id, label) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE)))
-    .graphAppend(list(action='dep', id=id, dependsOn=label))
-}
-
-.graphDependsOnId <- function(id, dependee) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE)))
-    .graphAppend(list(action='depId', id=id, dependsOn=dependee))
-}
-
-.graphCreateContext <- function(id, label, type, prevId) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE)))
-    .graphAppend(list(
-      action='ctx', id=id, label=paste(label, collapse='\n'), type=type, prevId=prevId
-    ))
-}
-
-.graphEnterContext <- function(id) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE)))
-    .graphAppend(list(action='enter', id=id))
-}
-
-.graphExitContext <- function(id) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE)))
-    .graphAppend(list(action='exit', id=id))
-}
-
-.graphValueChange <- function(label, value) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE))) {
-    .graphAppend(list(
-      action = 'valueChange',
-      id = label,
-      value = paste(capture.output(str(value)), collapse='\n')
-    ))
+  if (!is.null(domain)) {
+    domain$reactlog(logEntry)
   }
 }
 
-.graphInvalidate <- function(id) {
-  if (isTRUE(getOption('shiny.reactlog', FALSE)))
-    .graphAppend(list(action='invalidate', id=id))
+.graphDependsOn <- function(id, label) {
+  .graphAppend(list(action='dep', id=id, dependsOn=label))
 }
 
-.graphEnv <- new.env()
-.graphEnv$log <- list()
+.graphDependsOnId <- function(id, dependee) {
+  .graphAppend(list(action='depId', id=id, dependsOn=dependee))
+}
+
+.graphCreateContext <- function(id, label, type, prevId, domain) {
+  .graphAppend(list(
+    action='ctx', id=id, label=paste(label, collapse='\n'),
+    srcref=attr(label, "srcref"), srcfile=attr(label, "srcfile"),
+    type=type, prevId=prevId
+  ), domain = domain)
+}
+
+.graphEnterContext <- function(id) {
+  .graphAppend(list(action='enter', id=id))
+}
+
+.graphExitContext <- function(id) {
+  .graphAppend(list(action='exit', id=id))
+}
+
+.graphValueChange <- function(label, value) {
+  .graphAppend(list(
+    action = 'valueChange',
+    id = label,
+    value = paste(utils::capture.output(utils::str(value)), collapse='\n')
+  ))
+}
+
+.graphInvalidate <- function(id, domain) {
+  .graphAppend(list(action='invalidate', id=id), domain)
+}
+
+#' @include stack.R
+.graphStack <- Stack$new()

R/hooks.R

@@ -0,0 +1,24 @@
+
+
+# Call an application hook. Application hooks are provided so that front ends
+# can know when a Shiny application is running:
+#
+# shiny.onAppStart -- called when an application begins running
+# shiny.onAppStop -- called when an appliation stops
+#
+# Both hooks are passed the url where the application is accessible (appUrl).
+# Note that the appUrl can be NULL if the application was run on a UNIX domain
+# socket rather than a TCP/IP port/
+callAppHook <- function(name, appUrl) {
+  for (hook in getHooksList(paste0("shiny.", name)))
+    hook(appUrl)
+}
+
+# The value for getHook can be a single function or a list of functions,
+# This function ensures that the result can always be processed as a list
+getHooksList <- function(name) {
+  hooks <- getHook(name)
+  if (!is.list(hooks))
+    hooks <- list(hooks)
+  hooks
+}

R/html-deps.R

@@ -0,0 +1,29 @@
+#' Create a web dependency
+#'
+#' Ensure that a file-based HTML dependency (from the htmltools package) can be
+#' served over Shiny's HTTP server. This function works by using
+#' \code{\link{addResourcePath}} to map the HTML dependency's directory to a
+#' URL.
+#'
+#' @param dependency A single HTML dependency object, created using
+#'   \code{\link{htmlDependency}}. If the \code{src} value is named, then
+#'   \code{href} and/or \code{file} names must be present.
+#'
+#' @return A single HTML dependency object that has an \code{href}-named element
+#'   in its \code{src}.
+#' @export
+createWebDependency <- function(dependency) {
+  if (is.null(dependency))
+    return(NULL)
+
+  if (!inherits(dependency, "html_dependency"))
+    stop("Unexpected non-html_dependency type")
+
+  if (is.null(dependency$src$href)) {
+    prefix <- paste(dependency$name, "-", dependency$version, sep = "")
+    addResourcePath(prefix, dependency$src$file)
+    dependency$src$href <- prefix
+  }
+
+  return(dependency)
+}

R/htmltools.R

@@ -0,0 +1,7 @@
+#' @export a br code div em h1 h2 h3 h4 h5 h6 hr HTML img p pre span strong
+#' @export includeCSS includeHTML includeMarkdown includeScript includeText
+#' @export is.singleton singleton
+#' @export tag tagAppendAttributes tagAppendChild tagAppendChildren tagList tags tagSetChildren withTags
+#' @export validateCssUnit
+#' @export knit_print.html knit_print.shiny.tag knit_print.shiny.tag.list
+NULL

R/image-interact-opts.R

@@ -0,0 +1,136 @@
+#' Create an object representing click options
+#'
+#' This generates an object representing click options, to be passed as the
+#' \code{click} argument of \code{\link{imageOutput}} or
+#' \code{\link{plotOutput}}.
+#'
+#' @param id Input value name. For example, if the value is \code{"plot_click"},
+#'   then the click coordinates will be available as \code{input$plot_click}.
+#' @param clip Should the click area be clipped to the plotting area? If FALSE,
+#'   then the server will receive click events even when the mouse is outside
+#'   the plotting area, as long as it is still inside the image.
+#' @export
+clickOpts <- function(id = NULL, clip = TRUE) {
+  if (is.null(id))
+    stop("id must not be NULL")
+
+  list(
+    id = id,
+    clip = clip
+  )
+}
+
+
+#' Create an object representing double-click options
+#'
+#' This generates an object representing dobule-click options, to be passed as
+#' the \code{dblclick} argument of \code{\link{imageOutput}} or
+#' \code{\link{plotOutput}}.
+#'
+#' @param id Input value name. For example, if the value is
+#'   \code{"plot_dblclick"}, then the click coordinates will be available as
+#'   \code{input$plot_dblclick}.
+#' @param clip Should the click area be clipped to the plotting area? If FALSE,
+#'   then the server will receive double-click events even when the mouse is
+#'   outside the plotting area, as long as it is still inside the image.
+#' @param delay Maximum delay (in ms) between a pair clicks for them to be
+#'   counted as a double-click.
+#' @export
+dblclickOpts <- function(id = NULL, clip = TRUE, delay = 400) {
+  if (is.null(id))
+    stop("id must not be NULL")
+
+  list(
+    id = id,
+    clip = clip,
+    delay = delay
+  )
+}
+
+#' Create an object representing hover options
+#'
+#' This generates an object representing hovering options, to be passed as the
+#' \code{hover} argument of \code{\link{imageOutput}} or
+#' \code{\link{plotOutput}}.
+#'
+#' @param id Input value name. For example, if the value is \code{"plot_hover"},
+#'   then the hover coordinates will be available as \code{input$plot_hover}.
+#' @param delay How long to delay (in milliseconds) when debouncing or
+#'   throttling, before sending the mouse location to the server.
+#' @param delayType The type of algorithm for limiting the number of hover
+#'   events. Use \code{"throttle"} to limit the number of hover events to one
+#'   every \code{delay} milliseconds. Use \code{"debounce"} to suspend events
+#'   while the cursor is moving, and wait until the cursor has been at rest for
+#'   \code{delay} milliseconds before sending an event.
+#' @param clip Should the hover area be clipped to the plotting area? If FALSE,
+#'   then the server will receive hover events even when the mouse is outside
+#'   the plotting area, as long as it is still inside the image.
+#' @param nullOutside If \code{TRUE} (the default), the value will be set to
+#'   \code{NULL} when the mouse exits the plotting area. If \code{FALSE}, the
+#'   value will stop changing when the cursor exits the plotting area.
+#' @export
+hoverOpts <- function(id = NULL, delay = 300,
+                      delayType = c("debounce", "throttle"), clip = TRUE,
+                      nullOutside = TRUE) {
+  if (is.null(id))
+    stop("id must not be NULL")
+
+  list(
+    id = id,
+    delay = delay,
+    delayType = match.arg(delayType),
+    clip = clip,
+    nullOutside = nullOutside
+  )
+}
+
+#' Create an object representing brushing options
+#'
+#' This generates an object representing brushing options, to be passed as the
+#' \code{brush} argument of \code{\link{imageOutput}} or
+#' \code{\link{plotOutput}}.
+#'
+#' @param id Input value name. For example, if the value is \code{"plot_brush"},
+#'   then the coordinates will be available as \code{input$plot_brush}.
+#' @param fill Fill color of the brush.
+#' @param stroke Outline color of the brush.
+#' @param opacity Opacity of the brush
+#' @param delay How long to delay (in milliseconds) when debouncing or
+#'   throttling, before sending the brush data to the server.
+#' @param delayType The type of algorithm for limiting the number of brush
+#'   events. Use \code{"throttle"} to limit the number of brush events to one
+#'   every \code{delay} milliseconds. Use \code{"debounce"} to suspend events
+#'   while the cursor is moving, and wait until the cursor has been at rest for
+#'   \code{delay} milliseconds before sending an event.
+#' @param clip Should the brush area be clipped to the plotting area? If FALSE,
+#'   then the user will be able to brush outside the plotting area, as long as
+#'   it is still inside the image.
+#' @param direction The direction for brushing. If \code{"xy"}, the brush can be
+#'   drawn and moved in both x and y directions. If \code{"x"}, or \code{"y"},
+#'   the brush wil work horizontally or vertically.
+#' @param resetOnNew When a new image is sent to the browser (via
+#'   \code{\link{renderImage}}), should the brush be reset? The default,
+#'   \code{FALSE}, is useful if you want to update the plot while keeping the
+#'   brush. Using \code{TRUE} is useful if you want to clear the brush whenever
+#'   the plot is updated.
+#' @export
+brushOpts <- function(id = NULL, fill = "#9cf", stroke = "#036",
+                      opacity = 0.25, delay = 300,
+                      delayType = c("debounce", "throttle"), clip = TRUE,
+                      direction = c("xy", "x", "y"),
+                      resetOnNew = FALSE) {
+  if (is.null(id))
+    stop("id must not be NULL")
+
+  list(
+    id = id,
+    fill = fill,
+    stroke = stroke,
+    opacity = opacity,
+    delay = delay,
+    delayType = match.arg(delayType),
+    clip = clip,
+    direction = match.arg(direction),
+    resetOnNew = resetOnNew
+  )
+}

R/image-interact.R

@@ -0,0 +1,437 @@
+#' Find rows of data that are selected by a brush
+#'
+#' This function returns rows from a data frame which are under a brush used
+#' with \code{\link{plotOutput}}.
+#'
+#' It is also possible for this function to return all rows from the input data
+#' frame, but with an additional column \code{selected_}, which indicates which
+#' rows of the input data frame are selected by the brush (\code{TRUE} for
+#' selected, \code{FALSE} for not-selected). This is enabled by setting
+#' \code{allRows=TRUE} option.
+#'
+#' The \code{xvar}, \code{yvar}, \code{panelvar1}, and \code{panelvar2}
+#' arguments specify which columns in the data correspond to the x variable, y
+#' variable, and panel variables of the plot. For example, if your plot is
+#' \code{plot(x=cars$speed, y=cars$dist)}, and your brush is named
+#' \code{"cars_brush"}, then you would use \code{brushedPoints(cars,
+#' input$cars_brush, "speed", "dist")}.
+#'
+#' For plots created with ggplot2, it should not be necessary to specify the
+#' column names; that information will already be contained in the brush,
+#' provided that variables are in the original data, and not computed. For
+#' example, with \code{ggplot(cars, aes(x=speed, y=dist)) + geom_point()}, you
+#' could use \code{brushedPoints(cars, input$cars_brush)}. If, however, you use
+#' a computed column, like \code{ggplot(cars, aes(x=speed/2, y=dist)) +
+#' geom_point()}, then it will not be able to automatically extract column names
+#' and filter on them. If you want to use this function to filter data, it is
+#' recommended that you not use computed columns; instead, modify the data
+#' first, and then make the plot with "raw" columns in the modified data.
+#'
+#' If a specified x or y column is a factor, then it will be coerced to an
+#' integer vector. If it is a character vector, then it will be coerced to a
+#' factor and then integer vector. This means that the brush will be considered
+#' to cover a given character/factor value when it covers the center value.
+#'
+#' If the brush is operating in just the x or y directions (e.g., with
+#' \code{brushOpts(direction = "x")}, then this function will filter out points
+#' using just the x or y variable, whichever is appropriate.
+#'
+#' @param brush The data from a brush, such as \code{input$plot_brush}.
+#' @param df A data frame from which to select rows.
+#' @param xvar,yvar A string with the name of the variable on the x or y axis.
+#'   This must also be the name of a column in \code{df}. If absent, then this
+#'   function will try to infer the variable from the brush (only works for
+#'   ggplot2).
+#' @param panelvar1,panelvar2 Each of these is a string with the name of a panel
+#'   variable. For example, if with ggplot2, you facet on a variable called
+#'   \code{cyl}, then you can use \code{"cyl"} here. However, specifying the
+#'   panel variable should not be necessary with ggplot2; Shiny should be able
+#'   to auto-detect the panel variable.
+#' @param allRows If \code{FALSE} (the default) return a data frame containing
+#'   the selected rows. If \code{TRUE}, the input data frame will have a new
+#'   column, \code{selected_}, which indicates whether the row was inside the
+#'   brush (\code{TRUE}) or outside the brush (\code{FALSE}).
+#'
+#' @seealso \code{\link{plotOutput}} for example usage.
+#' @export
+brushedPoints <- function(df, brush, xvar = NULL, yvar = NULL,
+                          panelvar1 = NULL, panelvar2 = NULL,
+                          allRows = FALSE) {
+  if (is.null(brush)) {
+    if (allRows)
+      df$selected_ <- FALSE
+    else
+      df <- df[0, , drop = FALSE]
+
+    return(df)
+  }
+
+  if (is.null(brush$xmin)) {
+    stop("brushedPoints requires a brush object with xmin, xmax, ymin, and ymax.")
+  }
+
+  # Which direction(s) the brush is selecting over. Direction can be 'x', 'y',
+  # or 'xy'.
+  use_x <- grepl("x", brush$direction)
+  use_y <- grepl("y", brush$direction)
+
+  # Try to extract vars from brush object
+  xvar      <- xvar      %OR% brush$mapping$x
+  yvar      <- yvar      %OR% brush$mapping$y
+  panelvar1 <- panelvar1 %OR% brush$mapping$panelvar1
+  panelvar2 <- panelvar2 %OR% brush$mapping$panelvar2
+
+  # Filter out x and y values
+  keep_rows <- rep(TRUE, nrow(df))
+  if (use_x) {
+    if (is.null(xvar))
+      stop("brushedPoints: not able to automatically infer `xvar` from brush")
+    # Extract data values from the data frame
+    x <- asNumber(df[[xvar]])
+    keep_rows <- keep_rows & (x >= brush$xmin & x <= brush$xmax)
+  }
+  if (use_y) {
+    if (is.null(yvar))
+      stop("brushedPoints: not able to automatically infer `yvar` from brush")
+    y <- asNumber(df[[yvar]])
+    keep_rows <- keep_rows & (y >= brush$ymin & y <= brush$ymax)
+  }
+
+  # Find which rows are matches for the panel vars (if present)
+  if (!is.null(panelvar1))
+    keep_rows <- keep_rows & panelMatch(brush$panelvar1, df[[panelvar1]])
+  if (!is.null(panelvar2))
+    keep_rows <- keep_rows & panelMatch(brush$panelvar2, df[[panelvar2]])
+
+  if (allRows) {
+    df$selected_ <- keep_rows
+    df
+  } else {
+    df[keep_rows, , drop = FALSE]
+  }
+}
+
+# The `brush` data structure will look something like the examples below.
+# For base graphics, `mapping` is empty, and there are no panelvars:
+# List of 8
+#  $ xmin   : num 3.73
+#  $ xmax   : num 4.22
+#  $ ymin   : num 13.9
+#  $ ymax   : num 19.8
+#  $ mapping: Named list()
+#  $ domain :List of 4
+#   ..$ left  : num 1.36
+#   ..$ right : num 5.58
+#   ..$ bottom: num 9.46
+#   ..$ top   : num 34.8
+#  $ range  :List of 4
+#   ..$ left  : num 58
+#   ..$ right : num 429
+#   ..$ bottom: num 226
+#   ..$ top   : num 58
+#  $ log    :List of 2
+#   ..$ x: NULL
+#   ..$ y: NULL
+#  $ direction: chr "y"
+#
+# For ggplot2, the mapping vars usually will be included, and if faceting is
+# used, they will be listed as panelvars:
+# List of 10
+#  $ xmin     : num 3.18
+#  $ xmax     : num 3.78
+#  $ ymin     : num 17.1
+#  $ ymax     : num 20.4
+#  $ panelvar1: int 6
+#  $ panelvar2: int 0
+#  $ mapping  :List of 4
+#   ..$ x        : chr "wt"
+#   ..$ y        : chr "mpg"
+#   ..$ panelvar1: chr "cyl"
+#   ..$ panelvar2: chr "am"
+#  $ domain   :List of 4
+#   ..$ left  : num 1.32
+#   ..$ right : num 5.62
+#   ..$ bottom: num 9.22
+#   ..$ top   : num 35.1
+#  $ range    :List of 4
+#   ..$ left  : num 172
+#   ..$ right : num 300
+#   ..$ bottom: num 144
+#   ..$ top   : num 28.5
+#  $ log      :List of 2
+#   ..$ x: NULL
+#   ..$ y: NULL
+#  $ direction: chr "y"
+
+
+#'Find rows of data that are near a click/hover/double-click
+#'
+#'This function returns rows from a data frame which are near a click, hover, or
+#'double-click, when used with \code{\link{plotOutput}}. The rows will be sorted
+#'by their distance to the mouse event.
+#'
+#'It is also possible for this function to return all rows from the input data
+#'frame, but with an additional column \code{selected_}, which indicates which
+#'rows of the input data frame are selected by the brush (\code{TRUE} for
+#'selected, \code{FALSE} for not-selected). This is enabled by setting
+#'\code{allRows=TRUE} option. If this is used, the resulting data frame will not
+#'be sorted by distance to the mouse event.
+#'
+#'The \code{xvar}, \code{yvar}, \code{panelvar1}, and \code{panelvar2} arguments
+#'specify which columns in the data correspond to the x variable, y variable,
+#'and panel variables of the plot. For example, if your plot is
+#'\code{plot(x=cars$speed, y=cars$dist)}, and your click variable is named
+#'\code{"cars_click"}, then you would use \code{nearPoints(cars,
+#'input$cars_brush, "speed", "dist")}.
+#'
+#'@inheritParams brushedPoints
+#'@param coordinfo The data from a mouse event, such as \code{input$plot_click}.
+#'@param threshold A maxmimum distance to the click point; rows in the data
+#'  frame where the distance to the click is less than \code{threshold} will be
+#'  returned.
+#'@param maxpoints Maximum number of rows to return. If NULL (the default),
+#'  return all rows that are within the threshold distance.
+#'@param addDist If TRUE, add a column named \code{dist_} that contains the
+#'  distance from the coordinate to the point, in pixels. When no mouse event
+#'  has yet occured, the value of \code{dist_} will be \code{NA}.
+#'@param allRows If \code{FALSE} (the default) return a data frame containing
+#'  the selected rows. If \code{TRUE}, the input data frame will have a new
+#'  column, \code{selected_}, which indicates whether the row was inside the
+#'  selected by the mouse event (\code{TRUE}) or not (\code{FALSE}).
+#'
+#'@seealso \code{\link{plotOutput}} for more examples.
+#'
+#' @examples
+#' \dontrun{
+#' # Note that in practice, these examples would need to go in reactives
+#' # or observers.
+#'
+#' # This would select all points within 5 pixels of the click
+#' nearPoints(mtcars, input$plot_click)
+#'
+#' # Select just the nearest point within 10 pixels of the click
+#' nearPoints(mtcars, input$plot_click, threshold = 10, maxpoints = 1)
+#'
+#' }
+#'@export
+nearPoints <- function(df, coordinfo, xvar = NULL, yvar = NULL,
+                       panelvar1 = NULL, panelvar2 = NULL,
+                       threshold = 5, maxpoints = NULL, addDist = FALSE,
+                       allRows = FALSE) {
+  if (is.null(coordinfo)) {
+    if (addDist)
+      df$dist_ <- NA_real_
+
+    if (allRows)
+      df$selected_ <- FALSE
+    else
+      df <- df[0, , drop = FALSE]
+
+    return(df)
+  }
+
+  if (is.null(coordinfo$x)) {
+    stop("nearPoints requires a click/hover/double-click object with x and y values.")
+  }
+
+  # Try to extract vars from coordinfo object
+  xvar      <- xvar      %OR% coordinfo$mapping$x
+  yvar      <- yvar      %OR% coordinfo$mapping$y
+  panelvar1 <- panelvar1 %OR% coordinfo$mapping$panelvar1
+  panelvar2 <- panelvar2 %OR% coordinfo$mapping$panelvar2
+
+  if (is.null(xvar))
+    stop("nearPoints: not able to automatically infer `xvar` from coordinfo")
+  if (is.null(yvar))
+    stop("nearPoints: not able to automatically infer `yvar` from coordinfo")
+
+  # Extract data values from the data frame
+  x <- asNumber(df[[xvar]])
+  y <- asNumber(df[[yvar]])
+
+  # Get the pixel coordinates of the point
+  coordPx <- scaleCoords(coordinfo$x, coordinfo$y, coordinfo)
+
+  # Get pixel coordinates of data points
+  dataPx <- scaleCoords(x, y, coordinfo)
+
+  # Distances of data points to coordPx
+  dists <- sqrt((dataPx$x - coordPx$x) ^ 2 + (dataPx$y - coordPx$y) ^ 2)
+
+  if (addDist)
+    df$dist_ <- dists
+
+  keep_rows <- (dists <= threshold)
+
+  # Find which rows are matches for the panel vars (if present)
+  if (!is.null(panelvar1))
+    keep_rows <- keep_rows & panelMatch(coordinfo$panelvar1, df[[panelvar1]])
+  if (!is.null(panelvar2))
+    keep_rows <- keep_rows & panelMatch(coordinfo$panelvar2, df[[panelvar2]])
+
+  # Track the indices to keep
+  keep_idx <- which(keep_rows)
+
+  # Order by distance
+  dists <- dists[keep_idx]
+  keep_idx <- keep_idx[order(dists)]
+
+  # Keep max number of rows
+  if (!is.null(maxpoints) && length(keep_idx) > maxpoints) {
+    keep_idx <- keep_idx[seq_len(maxpoints)]
+  }
+
+  if (allRows) {
+    # Add selected_ column if needed
+    df$selected_ <- FALSE
+    df$selected_[keep_idx] <- TRUE
+
+  } else {
+    # If we don't keep all rows, return just the selected rows, sorted by
+    # distance.
+    df <- df[keep_idx, , drop = FALSE]
+  }
+
+  df
+}
+
+# The coordinfo data structure will look something like the examples below.
+# For base graphics, `mapping` is empty, and there are no panelvars:
+# List of 7
+#  $ x      : num 4.37
+#  $ y      : num 12
+#  $ mapping: Named list()
+#  $ domain :List of 4
+#   ..$ left  : num 1.36
+#   ..$ right : num 5.58
+#   ..$ bottom: num 9.46
+#   ..$ top   : num 34.8
+#  $ range  :List of 4
+#   ..$ left  : num 58
+#   ..$ right : num 429
+#   ..$ bottom: num 226
+#   ..$ top   : num 58
+#  $ log    :List of 2
+#   ..$ x: NULL
+#   ..$ y: NULL
+#  $ .nonce : num 0.343
+#
+# For ggplot2, the mapping vars usually will be included, and if faceting is
+# used, they will be listed as panelvars:
+# List of 9
+#  $ x        : num 3.78
+#  $ y        : num 17.1
+#  $ panelvar1: int 6
+#  $ panelvar2: int 0
+#  $ mapping  :List of 4
+#   ..$ x        : chr "wt"
+#   ..$ y        : chr "mpg"
+#   ..$ panelvar1: chr "cyl"
+#   ..$ panelvar2: chr "am"
+#  $ domain   :List of 4
+#   ..$ left  : num 1.32
+#   ..$ right : num 5.62
+#   ..$ bottom: num 9.22
+#   ..$ top   : num 35.1
+#  $ range    :List of 4
+#   ..$ left  : num 172
+#   ..$ right : num 300
+#   ..$ bottom: num 144
+#   ..$ top   : num 28.5
+#  $ log      :List of 2
+#   ..$ x: NULL
+#   ..$ y: NULL
+#  $ .nonce   : num 0.603
+
+
+
+# Coerce various types of variables to numbers. This works for Date, POSIXt,
+# characters, and factors. Used because the mouse coords are numeric.
+asNumber <- function(x) {
+  if (is.character(x)) x <- as.factor(x)
+  if (is.factor(x)) x <- as.integer(x)
+  as.numeric(x)
+}
+
+# Given a panelvar value and a vector x, return logical vector indicating which
+# items match the panelvar value. Because the panelvar value is always a
+# string but the vector could be numeric, it might be necessary to coerce the
+# panelvar to a number before comparing to the vector.
+panelMatch <- function(search_value, x) {
+  if (is.numeric(x)) search_value <- as.numeric(search_value)
+  x == search_value
+}
+
+#  ----------------------------------------------------------------------------
+# Scaling functions
+# These functions have direct analogs in Javascript code, except these are
+# vectorized for x and y.
+
+# Map a value x from a domain to a range. If clip is true, clip it to the
+# range.
+mapLinear <- function(x, domainMin, domainMax, rangeMin, rangeMax, clip = TRUE) {
+  factor <- (rangeMax - rangeMin) / (domainMax - domainMin)
+  val <- x - domainMin
+  newval <- (val * factor) + rangeMin
+
+  if (clip) {
+    maxval <- max(rangeMax, rangeMin)
+    minval <- min(rangeMax, rangeMin)
+    newval[newval > maxval] <- maxval
+    newval[newval < minval] <- minval
+  }
+  newval
+}
+
+# Scale val from domain to range. If logbase is present, use log scaling.
+scale1D <- function(val, domainMin, domainMax, rangeMin, rangeMax,
+                    logbase = NULL, clip = TRUE) {
+  if (!is.null(logbase))
+    val <- log(val, logbase)
+  mapLinear(val, domainMin, domainMax, rangeMin, rangeMax, clip)
+}
+
+# Inverse scale val, from range to domain. If logbase is present, use inverse
+# log (power) transformation.
+scaleInv1D <- function(val, domainMin, domainMax, rangeMin, rangeMax,
+                       logbase = NULL, clip = TRUE) {
+    res <- mapLinear(val, rangeMin, rangeMax, domainMin, domainMax, clip)
+    if (!is.null(logbase))
+      res <- logbase ^ res
+    res
+}
+
+# Scale x and y coordinates from domain to range, using information in
+# scaleinfo. scaleinfo must contain items $domain, $range, and $log. The
+# scaleinfo object corresponds to one element from the coordmap object generated
+# by getPrevPlotCoordmap or getGgplotCoordmap; it is the scaling information for
+# one panel in a plot.
+scaleCoords <- function(x, y, scaleinfo) {
+  if (is.null(scaleinfo))
+    return(NULL)
+
+  domain <- scaleinfo$domain
+  range <- scaleinfo$range
+  log <- scaleinfo$log
+
+  list(
+    x = scale1D(x, domain$left, domain$right, range$left, range$right, log$x),
+    y = scale1D(y, domain$bottom, domain$top, range$bottom, range$top, log$y)
+  )
+}
+
+# Inverse scale x and y coordinates from range to domain, using information in
+# scaleinfo.
+scaleInvCoords <- function(x, y, scaleinfo) {
+  if (is.null(scaleinfo))
+    return(NULL)
+
+  domain <- scaleinfo$domain
+  range <- scaleinfo$range
+  log <- scaleinfo$log
+
+  list(
+    x = scaleInv1D(x, domain$left, domain$right, range$left, range$right, log$x),
+    y = scaleInv1D(y, domain$bottom, domain$top, range$bottom, range$top, log$y)
+  )
+}

R/imageutils.R

@@ -33,24 +33,26 @@ plotPNG <- function(func, filename=tempfile(fileext='.png'),
   # Otherwise, if the Cairo package is installed, use CairoPNG().
   # Finally, if neither quartz nor Cairo, use png().
   if (capabilities("aqua")) {
-    pngfun <- png
-  } else if (getOption('shiny.usecairo', TRUE) &&
+    pngfun <- grDevices::png
+  } else if ((getOption('shiny.usecairo') %OR% TRUE) &&
              nchar(system.file(package = "Cairo"))) {
-    # Workaround for issue #140: Cairo ignores res and dpi settings. Need to
-    # use regular png function.
-    if (res == 72) {
-      pngfun <- Cairo::CairoPNG
-    } else {
-      pngfun <- png
-    }
+    pngfun <- Cairo::CairoPNG
   } else {
-    pngfun <- png
+    pngfun <- grDevices::png
   }
 
-  do.call(pngfun, c(filename=filename, width=width, height=height, res=res, list(...)))
-  tryCatch(
-    func(),
-    finally=dev.off())
+  pngfun(filename=filename, width=width, height=height, res=res, ...)
+  # Call plot.new() so that even if no plotting operations are performed at
+  # least we have a blank background. N.B. we need to set the margin to 0
+  # temporarily before plot.new() because when the plot size is small (e.g.
+  # 200x50), we will get an error "figure margin too large", which is triggered
+  # by plot.new() with the default (large) margin. However, this does not
+  # guarantee user's code in func() will not trigger the error -- they may have
+  # to set par(mar = smaller_value) before they draw base graphics.
+  op <- graphics::par(mar = rep(0, 4))
+  tryCatch(graphics::plot.new(), finally = graphics::par(op))
+  dv <- grDevices::dev.cur()
+  tryCatch(shinyCallingHandlers(func()), finally = grDevices::dev.off(dv))
 
   filename
 }

R/input-action.R

@@ -0,0 +1,51 @@
+#' Action button/link
+#'
+#' Creates an action button or link whose value is initially zero, and increments by one
+#' each time it is pressed.
+#'
+#' @inheritParams textInput
+#' @param label The contents of the button or link--usually a text label, but
+#'   you could also use any other HTML, like an image.
+#' @param icon An optional \code{\link{icon}} to appear on the button.
+#' @param ... Named attributes to be applied to the button or link.
+#'
+#' @family input elements
+#' @examples
+#' \dontrun{
+#' # In server.R
+#' output$distPlot <- renderPlot({
+#'   # Take a dependency on input$goButton
+#'   input$goButton
+#'
+#'   # Use isolate() to avoid dependency on input$obs
+#'   dist <- isolate(rnorm(input$obs))
+#'   hist(dist)
+#' })
+#'
+#' # In ui.R
+#' actionButton("goButton", "Go!")
+#' }
+#'
+#' @seealso \code{\link{observeEvent}} and \code{\link{eventReactive}}
+#'
+#' @export
+actionButton <- function(inputId, label, icon = NULL, width = NULL, ...) {
+  tags$button(id=inputId,
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    type="button",
+    class="btn btn-default action-button",
+    list(icon, label),
+    ...
+  )
+}
+
+#' @rdname actionButton
+#' @export
+actionLink <- function(inputId, label, icon = NULL, ...) {
+  tags$a(id=inputId,
+    href="#",
+    class="action-button",
+    list(icon, label),
+    ...
+  )
+}

R/input-checkbox.R

@@ -0,0 +1,26 @@
+#' Checkbox Input Control
+#'
+#' Create a checkbox that can be used to specify logical values.
+#'
+#' @inheritParams textInput
+#' @param value Initial value (\code{TRUE} or \code{FALSE}).
+#' @return A checkbox control that can be added to a UI definition.
+#'
+#' @family input elements
+#' @seealso \code{\link{checkboxGroupInput}}, \code{\link{updateCheckboxInput}}
+#'
+#' @examples
+#' checkboxInput("outliers", "Show outliers", FALSE)
+#' @export
+checkboxInput <- function(inputId, label, value = FALSE, width = NULL) {
+  inputTag <- tags$input(id = inputId, type="checkbox")
+  if (!is.null(value) && value)
+    inputTag$attribs$checked <- "checked"
+
+  div(class = "form-group shiny-input-container",
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    div(class = "checkbox",
+      tags$label(inputTag, tags$span(label))
+    )
+  )
+}

R/input-checkboxgroup.R

@@ -0,0 +1,45 @@
+#' Checkbox Group Input Control
+#'
+#' Create a group of checkboxes that can be used to toggle multiple choices
+#' independently. The server will receive the input as a character vector of the
+#' selected values.
+#'
+#' @inheritParams textInput
+#' @param choices List of values to show checkboxes for. If elements of the list
+#'   are named then that name rather than the value is displayed to the user.
+#' @param selected The values that should be initially selected, if any.
+#' @param inline If \code{TRUE}, render the choices inline (i.e. horizontally)
+#' @return A list of HTML elements that can be added to a UI definition.
+#'
+#' @family input elements
+#' @seealso \code{\link{checkboxInput}}, \code{\link{updateCheckboxGroupInput}}
+#'
+#' @examples
+#' checkboxGroupInput("variable", "Variable:",
+#'                    c("Cylinders" = "cyl",
+#'                      "Transmission" = "am",
+#'                      "Gears" = "gear"))
+#'
+#' @export
+checkboxGroupInput <- function(inputId, label, choices, selected = NULL,
+  inline = FALSE, width = NULL) {
+
+  # resolve names
+  choices <- choicesWithNames(choices)
+  if (!is.null(selected))
+    selected <- validateSelected(selected, choices, inputId)
+
+  options <- generateOptions(inputId, choices, selected, inline)
+
+  divClass <- "form-group shiny-input-checkboxgroup shiny-input-container"
+  if (inline)
+    divClass <- paste(divClass, "shiny-input-container-inline")
+
+  # return label and select tag
+  tags$div(id = inputId,
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    class = divClass,
+    controlLabel(inputId, label),
+    options
+  )
+}

R/input-date.R

@@ -0,0 +1,102 @@
+#' Create date input
+#'
+#' Creates a text input which, when clicked on, brings up a calendar that
+#' the user can click on to select dates.
+#'
+#' The date \code{format} string specifies how the date will be displayed in
+#' the browser. It allows the following values:
+#'
+#' \itemize{
+#'   \item \code{yy} Year without century (12)
+#'   \item \code{yyyy} Year with century (2012)
+#'   \item \code{mm} Month number, with leading zero (01-12)
+#'   \item \code{m} Month number, without leading zero (01-12)
+#'   \item \code{M} Abbreviated month name
+#'   \item \code{MM} Full month name
+#'   \item \code{dd} Day of month with leading zero
+#'   \item \code{d} Day of month without leading zero
+#'   \item \code{D} Abbreviated weekday name
+#'   \item \code{DD} Full weekday name
+#' }
+#'
+#' @inheritParams textInput
+#' @param value The starting date. Either a Date object, or a string in
+#'   \code{yyyy-mm-dd} format. If NULL (the default), will use the current
+#'   date in the client's time zone.
+#' @param min The minimum allowed date. Either a Date object, or a string in
+#'   \code{yyyy-mm-dd} format.
+#' @param max The maximum allowed date. Either a Date object, or a string in
+#'   \code{yyyy-mm-dd} format.
+#' @param format The format of the date to display in the browser. Defaults to
+#'   \code{"yyyy-mm-dd"}.
+#' @param startview The date range shown when the input object is first
+#'   clicked. Can be "month" (the default), "year", or "decade".
+#' @param weekstart Which day is the start of the week. Should be an integer
+#'   from 0 (Sunday) to 6 (Saturday).
+#' @param language The language used for month and day names. Default is "en".
+#'   Other valid values include "bg", "ca", "cs", "da", "de", "el", "es", "fi",
+#'   "fr", "he", "hr", "hu", "id", "is", "it", "ja", "kr", "lt", "lv", "ms",
+#'   "nb", "nl", "pl", "pt", "pt-BR", "ro", "rs", "rs-latin", "ru", "sk", "sl",
+#'   "sv", "sw", "th", "tr", "uk", "zh-CN", and "zh-TW".
+#'
+#' @family input elements
+#' @seealso \code{\link{dateRangeInput}}, \code{\link{updateDateInput}}
+#'
+#' @examples
+#' dateInput("date", "Date:", value = "2012-02-29")
+#'
+#' # Default value is the date in client's time zone
+#' dateInput("date", "Date:")
+#'
+#' # value is always yyyy-mm-dd, even if the display format is different
+#' dateInput("date", "Date:", value = "2012-02-29", format = "mm/dd/yy")
+#'
+#' # Pass in a Date object
+#' dateInput("date", "Date:", value = Sys.Date()-10)
+#'
+#' # Use different language and different first day of week
+#' dateInput("date", "Date:",
+#'           language = "de",
+#'           weekstart = 1)
+#'
+#' # Start with decade view instead of default month view
+#' dateInput("date", "Date:",
+#'           startview = "decade")
+#'
+#' @export
+dateInput <- function(inputId, label, value = NULL, min = NULL, max = NULL,
+  format = "yyyy-mm-dd", startview = "month", weekstart = 0, language = "en",
+  width = NULL) {
+
+  # If value is a date object, convert it to a string with yyyy-mm-dd format
+  # Same for min and max
+  if (inherits(value, "Date"))  value <- format(value, "%Y-%m-%d")
+  if (inherits(min,   "Date"))  min   <- format(min,   "%Y-%m-%d")
+  if (inherits(max,   "Date"))  max   <- format(max,   "%Y-%m-%d")
+
+  attachDependencies(
+    tags$div(id = inputId,
+      class = "shiny-date-input form-group shiny-input-container",
+      style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+
+      controlLabel(inputId, label),
+      tags$input(type = "text",
+                 # datepicker class necessary for dropdown to display correctly
+                 class = "form-control datepicker",
+                 `data-date-language` = language,
+                 `data-date-weekstart` = weekstart,
+                 `data-date-format` = format,
+                 `data-date-start-view` = startview,
+                 `data-min-date` = min,
+                 `data-max-date` = max,
+                 `data-initial-date` = value
+      )
+    ),
+    datePickerDependency
+  )
+}
+
+datePickerDependency <- htmlDependency(
+  "bootstrap-datepicker", "1.0.2", c(href = "shared/datepicker"),
+  script = "js/bootstrap-datepicker.min.js",
+  stylesheet = "css/datepicker.css")

R/input-daterange.R

@@ -0,0 +1,113 @@
+#' Create date range input
+#'
+#' Creates a pair of text inputs which, when clicked on, bring up calendars that
+#' the user can click on to select dates.
+#'
+#' The date \code{format} string specifies how the date will be displayed in
+#' the browser. It allows the following values:
+#'
+#' \itemize{
+#'   \item \code{yy} Year without century (12)
+#'   \item \code{yyyy} Year with century (2012)
+#'   \item \code{mm} Month number, with leading zero (01-12)
+#'   \item \code{m} Month number, without leading zero (01-12)
+#'   \item \code{M} Abbreviated month name
+#'   \item \code{MM} Full month name
+#'   \item \code{dd} Day of month with leading zero
+#'   \item \code{d} Day of month without leading zero
+#'   \item \code{D} Abbreviated weekday name
+#'   \item \code{DD} Full weekday name
+#' }
+#'
+#' @inheritParams dateInput
+#' @param start The initial start date. Either a Date object, or a string in
+#'   \code{yyyy-mm-dd} format. If NULL (the default), will use the current
+#'   date in the client's time zone.
+#' @param end The initial end date. Either a Date object, or a string in
+#'   \code{yyyy-mm-dd} format. If NULL (the default), will use the current
+#'   date in the client's time zone.
+#' @param separator String to display between the start and end input boxes.
+#'
+#' @family input elements
+#' @seealso \code{\link{dateInput}}, \code{\link{updateDateRangeInput}}
+#'
+#' @examples
+#' dateRangeInput("daterange", "Date range:",
+#'                start = "2001-01-01",
+#'                end   = "2010-12-31")
+#'
+#' # Default start and end is the current date in the client's time zone
+#' dateRangeInput("daterange", "Date range:")
+#'
+#' # start and end are always specified in yyyy-mm-dd, even if the display
+#' # format is different
+#' dateRangeInput("daterange", "Date range:",
+#'                start  = "2001-01-01",
+#'                end    = "2010-12-31",
+#'                min    = "2001-01-01",
+#'                max    = "2012-12-21",
+#'                format = "mm/dd/yy",
+#'                separator = " - ")
+#'
+#' # Pass in Date objects
+#' dateRangeInput("daterange", "Date range:",
+#'                start = Sys.Date()-10,
+#'                end = Sys.Date()+10)
+#'
+#' # Use different language and different first day of week
+#' dateRangeInput("daterange", "Date range:",
+#'                language = "de",
+#'                weekstart = 1)
+#'
+#' # Start with decade view instead of default month view
+#' dateRangeInput("daterange", "Date range:",
+#'                startview = "decade")
+#'
+#' @export
+dateRangeInput <- function(inputId, label, start = NULL, end = NULL,
+    min = NULL, max = NULL, format = "yyyy-mm-dd", startview = "month",
+    weekstart = 0, language = "en", separator = " to ", width = NULL) {
+
+  # If start and end are date objects, convert to a string with yyyy-mm-dd format
+  # Same for min and max
+  if (inherits(start, "Date"))  start <- format(start, "%Y-%m-%d")
+  if (inherits(end,   "Date"))  end   <- format(end,   "%Y-%m-%d")
+  if (inherits(min,   "Date"))  min   <- format(min,   "%Y-%m-%d")
+  if (inherits(max,   "Date"))  max   <- format(max,   "%Y-%m-%d")
+
+  attachDependencies(
+    div(id = inputId,
+      class = "shiny-date-range-input form-group shiny-input-container",
+      style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+
+      controlLabel(inputId, label),
+      # input-daterange class is needed for dropdown behavior
+      div(class = "input-daterange input-group",
+        tags$input(
+          class = "input-sm form-control",
+          type = "text",
+          `data-date-language` = language,
+          `data-date-weekstart` = weekstart,
+          `data-date-format` = format,
+          `data-date-start-view` = startview,
+          `data-min-date` = min,
+          `data-max-date` = max,
+          `data-initial-date` = start
+        ),
+        span(class = "input-group-addon", separator),
+        tags$input(
+          class = "input-sm form-control",
+          type = "text",
+          `data-date-language` = language,
+          `data-date-weekstart` = weekstart,
+          `data-date-format` = format,
+          `data-date-start-view` = startview,
+          `data-min-date` = min,
+          `data-max-date` = max,
+          `data-initial-date` = end
+        )
+      )
+    ),
+    datePickerDependency
+  )
+}

R/input-file.R

@@ -0,0 +1,51 @@
+#' File Upload Control
+#'
+#' Create a file upload control that can be used to upload one or more files.
+#'
+#' Whenever a file upload completes, the corresponding input variable is set
+#' to a dataframe. This dataframe contains one row for each selected file, and
+#' the following columns:
+#' \describe{
+#'   \item{\code{name}}{The filename provided by the web browser. This is
+#'   \strong{not} the path to read to get at the actual data that was uploaded
+#'   (see
+#'   \code{datapath} column).}
+#'   \item{\code{size}}{The size of the uploaded data, in
+#'   bytes.}
+#'   \item{\code{type}}{The MIME type reported by the browser (for example,
+#'   \code{text/plain}), or empty string if the browser didn't know.}
+#'   \item{\code{datapath}}{The path to a temp file that contains the data that was
+#'   uploaded. This file may be deleted if the user performs another upload
+#'   operation.}
+#' }
+#'
+#' @family input elements
+#'
+#' @inheritParams textInput
+#' @param multiple Whether the user should be allowed to select and upload
+#'   multiple files at once. \bold{Does not work on older browsers, including
+#'   Internet Explorer 9 and earlier.}
+#' @param accept A character vector of MIME types; gives the browser a hint of
+#'   what kind of files the server is expecting.
+#'
+#' @export
+fileInput <- function(inputId, label, multiple = FALSE, accept = NULL,
+  width = NULL) {
+
+  inputTag <- tags$input(id = inputId, name = inputId, type = "file")
+  if (multiple)
+    inputTag$attribs$multiple <- "multiple"
+  if (length(accept) > 0)
+    inputTag$attribs$accept <- paste(accept, collapse=',')
+
+  div(class = "form-group shiny-input-container",
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    label %AND% tags$label(label),
+    inputTag,
+    tags$div(
+      id=paste(inputId, "_progress", sep=""),
+      class="progress progress-striped active shiny-file-input-progress",
+      tags$div(class="progress-bar")
+    )
+  )
+}

R/input-numeric.R

@@ -0,0 +1,37 @@
+
+#' Create a numeric input control
+#'
+#' Create an input control for entry of numeric values
+#'
+#' @inheritParams textInput
+#' @param min Minimum allowed value
+#' @param max Maximum allowed value
+#' @param step Interval to use when stepping between min and max
+#' @return A numeric input control that can be added to a UI definition.
+#'
+#' @family input elements
+#' @seealso \code{\link{updateNumericInput}}
+#'
+#' @examples
+#' numericInput("obs", "Observations:", 10,
+#'              min = 1, max = 100)
+#' @export
+numericInput <- function(inputId, label, value, min = NA, max = NA, step = NA,
+  width = NULL) {
+
+  # build input tag
+  inputTag <- tags$input(id = inputId, type = "number", class="form-control",
+                         value = formatNoSci(value))
+  if (!is.na(min))
+    inputTag$attribs$min = min
+  if (!is.na(max))
+    inputTag$attribs$max = max
+  if (!is.na(step))
+    inputTag$attribs$step = step
+
+  div(class = "form-group shiny-input-container",
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    label %AND% tags$label(label, `for` = inputId),
+    inputTag
+  )
+}

R/input-password.R

@@ -0,0 +1,20 @@
+#' Create a password input control
+#'
+#' Create an password control for entry of passwords.
+#'
+#' @inheritParams textInput
+#' @return A text input control that can be added to a UI definition.
+#'
+#' @family input elements
+#' @seealso \code{\link{updateTextInput}}
+#'
+#' @examples
+#' passwordInput("password", "Password:")
+#' @export
+passwordInput <- function(inputId, label, value = "", width = NULL) {
+  div(class = "form-group shiny-input-container",
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    label %AND% tags$label(label, `for` = inputId),
+    tags$input(id = inputId, type="password", class="form-control", value=value)
+  )
+}

R/input-radiobuttons.R

@@ -0,0 +1,54 @@
+#' Create radio buttons
+#'
+#' Create a set of radio buttons used to select an item from a list.
+#'
+#' If you need to represent a "None selected" state, it's possible to default
+#' the radio buttons to have no options selected by using
+#' \code{selected = character(0)}. However, this is not recommended, as it gives
+#' the user no way to return to that state once they've made a selection.
+#' Instead, consider having the first of your choices be \code{c("None selected"
+#' = "")}.
+#'
+#' @inheritParams textInput
+#' @param choices List of values to select from (if elements of the list are
+#' named then that name rather than the value is displayed to the user)
+#' @param selected The initially selected value (if not specified then
+#' defaults to the first value)
+#' @param inline If \code{TRUE}, render the choices inline (i.e. horizontally)
+#' @return A set of radio buttons that can be added to a UI definition.
+#'
+#' @family input elements
+#' @seealso \code{\link{updateRadioButtons}}
+#'
+#' @examples
+#' radioButtons("dist", "Distribution type:",
+#'              c("Normal" = "norm",
+#'                "Uniform" = "unif",
+#'                "Log-normal" = "lnorm",
+#'                "Exponential" = "exp"))
+#' @export
+radioButtons <- function(inputId, label, choices, selected = NULL,
+  inline = FALSE, width = NULL) {
+
+  # resolve names
+  choices <- choicesWithNames(choices)
+
+  # default value if it's not specified
+  selected <- if (is.null(selected)) choices[[1]] else {
+    validateSelected(selected, choices, inputId)
+  }
+  if (length(selected) > 1) stop("The 'selected' argument must be of length 1")
+
+  options <- generateOptions(inputId, choices, selected, inline, type = 'radio')
+
+  divClass <- "form-group shiny-input-radiogroup shiny-input-container"
+  if (inline)
+    divClass <- paste(divClass, "shiny-input-container-inline")
+
+  tags$div(id = inputId,
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    class = divClass,
+    controlLabel(inputId, label),
+    options
+  )
+}

R/input-select.R

@@ -0,0 +1,167 @@
+#' Create a select list input control
+#'
+#' Create a select list that can be used to choose a single or multiple items
+#' from a list of values.
+#'
+#' By default, \code{selectInput()} and \code{selectizeInput()} use the
+#' JavaScript library \pkg{selectize.js}
+#' (\url{https://github.com/brianreavis/selectize.js}) to instead of the basic
+#' select input element. To use the standard HTML select input element, use
+#' \code{selectInput()} with \code{selectize=FALSE}.
+#'
+#' In selectize mode, if the first element in \code{choices} has a value of
+#' \code{""}, its name will be treated as a placeholder prompt. For example:
+#' \code{selectInput("letter", "Letter", c("Choose one" = "", LETTERS))}
+#'
+#' @inheritParams textInput
+#' @param choices List of values to select from. If elements of the list are
+#'   named then that name rather than the value is displayed to the user.
+#' @param selected The initially selected value (or multiple values if
+#'   \code{multiple = TRUE}). If not specified then defaults to the first value
+#'   for single-select lists and no values for multiple select lists.
+#' @param multiple Is selection of multiple items allowed?
+#' @param selectize Whether to use \pkg{selectize.js} or not.
+#' @param size Number of items to show in the selection box; a larger number
+#'   will result in a taller box. Not compatible with \code{selectize=TRUE}.
+#'   Normally, when \code{multiple=FALSE}, a select input will be a drop-down
+#'   list, but when \code{size} is set, it will be a box instead.
+#' @return A select list control that can be added to a UI definition.
+#'
+#' @family input elements
+#' @seealso \code{\link{updateSelectInput}}
+#'
+#' @examples
+#' selectInput("variable", "Variable:",
+#'             c("Cylinders" = "cyl",
+#'               "Transmission" = "am",
+#'               "Gears" = "gear"))
+#' @export
+selectInput <- function(inputId, label, choices, selected = NULL,
+                        multiple = FALSE, selectize = TRUE, width = NULL,
+                        size = NULL) {
+  # resolve names
+  choices <- choicesWithNames(choices)
+
+  # default value if it's not specified
+  if (is.null(selected)) {
+    if (!multiple) selected <- firstChoice(choices)
+  } else selected <- validateSelected(selected, choices, inputId)
+
+  if (!is.null(size) && selectize) {
+    stop("'size' argument is incompatible with 'selectize=TRUE'.")
+  }
+
+  # create select tag and add options
+  selectTag <- tags$select(
+    id = inputId,
+    class = if (!selectize) "form-control",
+    size = size,
+    selectOptions(choices, selected)
+  )
+  if (multiple)
+    selectTag$attribs$multiple <- "multiple"
+
+  # return label and select tag
+  res <- div(
+    class = "form-group shiny-input-container",
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    controlLabel(inputId, label),
+    div(selectTag)
+  )
+
+  if (!selectize) return(res)
+
+  selectizeIt(inputId, res, NULL, nonempty = !multiple && !("" %in% choices))
+}
+
+firstChoice <- function(choices) {
+  if (length(choices) == 0L) return()
+  choice <- choices[[1]]
+  if (is.list(choice)) firstChoice(choice) else choice
+}
+
+# Create tags for each of the options; use <optgroup> if necessary.
+# This returns a HTML string instead of tags, because of the 'selected'
+# attribute.
+selectOptions <- function(choices, selected = NULL) {
+  html <- mapply(choices, names(choices), FUN = function(choice, label) {
+    if (is.list(choice)) {
+      # If sub-list, create an optgroup and recurse into the sublist
+      sprintf(
+        '<optgroup label="%s">\n%s\n</optgroup>',
+        htmlEscape(label),
+        selectOptions(choice, selected)
+      )
+
+    } else {
+      # If single item, just return option string
+      sprintf(
+        '<option value="%s"%s>%s</option>',
+        htmlEscape(choice),
+        if (choice %in% selected) ' selected' else '',
+        htmlEscape(label)
+      )
+    }
+  })
+
+  HTML(paste(html, collapse = '\n'))
+}
+
+# need <optgroup> when choices contains sub-lists
+needOptgroup <- function(choices) {
+  any(vapply(choices, is.list, logical(1)))
+}
+
+#' @rdname selectInput
+#' @param ... Arguments passed to \code{selectInput()}.
+#' @param options A list of options. See the documentation of \pkg{selectize.js}
+#'   for possible options (character option values inside \code{\link{I}()} will
+#'   be treated as literal JavaScript code; see \code{\link{renderDataTable}()}
+#'   for details).
+#' @param width The width of the input, e.g. \code{'400px'}, or \code{'100\%'};
+#'   see \code{\link{validateCssUnit}}.
+#' @note The selectize input created from \code{selectizeInput()} allows
+#'   deletion of the selected option even in a single select input, which will
+#'   return an empty string as its value. This is the default behavior of
+#'   \pkg{selectize.js}. However, the selectize input created from
+#'   \code{selectInput(..., selectize = TRUE)} will ignore the empty string
+#'   value when it is a single choice input and the empty string is not in the
+#'   \code{choices} argument. This is to keep compatibility with
+#'   \code{selectInput(..., selectize = FALSE)}.
+#' @export
+selectizeInput <- function(inputId, ..., options = NULL, width = NULL) {
+  selectizeIt(
+    inputId,
+    selectInput(inputId, ..., selectize = FALSE, width = width),
+    options
+  )
+}
+
+# given a select input and its id, selectize it
+selectizeIt <- function(inputId, select, options, nonempty = FALSE) {
+  res <- checkAsIs(options)
+
+  selectizeDep <- htmlDependency(
+    "selectize", "0.11.2", c(href = "shared/selectize"),
+    stylesheet = "css/selectize.bootstrap3.css",
+    head = format(tagList(
+      HTML('<!--[if lt IE 9]>'),
+      tags$script(src = 'shared/selectize/js/es5-shim.min.js'),
+      HTML('<![endif]-->'),
+      tags$script(src = 'shared/selectize/js/selectize.min.js')
+    ))
+  )
+
+  # Insert script on same level as <select> tag
+  select$children[[2]] <- tagAppendChild(
+    select$children[[2]],
+    tags$script(
+      type = 'application/json',
+      `data-for` = inputId, `data-nonempty` = if (nonempty) '',
+      `data-eval` = if (length(res$eval)) HTML(toJSON(res$eval)),
+      if (length(res$options)) HTML(toJSON(res$options)) else '{}'
+    )
+  )
+
+  attachDependencies(select, selectizeDep)
+}

R/input-slider.R

@@ -0,0 +1,234 @@
+#' Slider Input Widget
+#'
+#' Constructs a slider widget to select a numeric value from a range.
+#'
+#' @inheritParams textInput
+#' @param min The minimum value (inclusive) that can be selected.
+#' @param max The maximum value (inclusive) that can be selected.
+#' @param value The initial value of the slider. A numeric vector of length one
+#'   will create a regular slider; a numeric vector of length two will create a
+#'   double-ended range slider. A warning will be issued if the value doesn't
+#'   fit between \code{min} and \code{max}.
+#' @param step Specifies the interval between each selectable value on the
+#'   slider (if \code{NULL}, a heuristic is used to determine the step size). If
+#'   the values are dates, \code{step} is in days; if the values are times
+#'   (POSIXt), \code{step} is in seconds.
+#' @param round \code{TRUE} to round all values to the nearest integer;
+#'   \code{FALSE} if no rounding is desired; or an integer to round to that
+#'   number of digits (for example, 1 will round to the nearest 10, and -2 will
+#'   round to the nearest .01). Any rounding will be applied after snapping to
+#'   the nearest step.
+#' @param format Deprecated.
+#' @param locale Deprecated.
+#' @param ticks \code{FALSE} to hide tick marks, \code{TRUE} to show them
+#'   according to some simple heuristics.
+#' @param animate \code{TRUE} to show simple animation controls with default
+#'   settings; \code{FALSE} not to; or a custom settings list, such as those
+#'   created using \code{\link{animationOptions}}.
+#' @param sep Separator between thousands places in numbers.
+#' @param pre A prefix string to put in front of the value.
+#' @param post A suffix string to put after the value.
+#' @param dragRange This option is used only if it is a range slider (with two
+#'   values). If \code{TRUE} (the default), the range can be dragged. In other
+#'   words, the min and max can be dragged together. If \code{FALSE}, the range
+#'   cannot be dragged.
+#' @param timeFormat Only used if the values are Date or POSIXt objects. A time
+#'   format string, to be passed to the Javascript strftime library. See
+#'   \url{https://github.com/samsonjs/strftime} for more details. The allowed
+#'   format specifications are very similar, but not identical, to those for R's
+#'   \code{\link{strftime}} function. For Dates, the default is \code{"\%F"}
+#'   (like \code{"2015-07-01"}), and for POSIXt, the default is \code{"\%F \%T"}
+#'   (like \code{"2015-07-01 15:32:10"}).
+#' @param timezone Only used if the values are POSIXt objects. A string
+#'   specifying the time zone offset for the displayed times, in the format
+#'   \code{"+HHMM"} or \code{"-HHMM"}. If \code{NULL} (the default), times will
+#'   be displayed in the browser's time zone. The value \code{"+0000"} will
+#'   result in UTC time.
+#' @inheritParams selectizeInput
+#' @family input elements
+#' @seealso \code{\link{updateSliderInput}}
+#'
+#' @export
+sliderInput <- function(inputId, label, min, max, value, step = NULL,
+                        round = FALSE, format = NULL, locale = NULL,
+                        ticks = TRUE, animate = FALSE, width = NULL, sep = ",",
+                        pre = NULL, post = NULL, timeFormat = NULL,
+                        timezone = NULL, dragRange = TRUE)
+{
+  if (!missing(format)) {
+    shinyDeprecated(msg = "The `format` argument to sliderInput is deprecated. Use `sep`, `pre`, and `post` instead.",
+                    version = "0.10.2.2")
+  }
+  if (!missing(locale)) {
+    shinyDeprecated(msg = "The `locale` argument to sliderInput is deprecated. Use `sep`, `pre`, and `post` instead.",
+                    version = "0.10.2.2")
+  }
+
+  # If step is NULL, use heuristic to set the step size.
+  findStepSize <- function(min, max, step) {
+    if (!is.null(step)) return(step)
+
+    range <- max - min
+    # If short range or decimals, use continuous decimal with ~100 points
+    if (range < 2 || hasDecimals(min) || hasDecimals(max)) {
+      step <- pretty(c(min, max), n = 100)
+      step[2] - step[1]
+    } else {
+      1
+    }
+  }
+
+  if (inherits(min, "Date")) {
+    if (!inherits(max, "Date") || !inherits(value, "Date"))
+      stop("`min`, `max`, and `value must all be Date or non-Date objects")
+    dataType <- "date"
+
+    if (is.null(timeFormat))
+      timeFormat <- "%F"
+
+  } else if (inherits(min, "POSIXt")) {
+    if (!inherits(max, "POSIXt") || !inherits(value, "POSIXt"))
+      stop("`min`, `max`, and `value must all be POSIXt or non-POSIXt objects")
+    dataType <- "datetime"
+
+    if (is.null(timeFormat))
+      timeFormat <- "%F %T"
+
+  } else {
+    dataType <- "number"
+  }
+
+  step <- findStepSize(min, max, step)
+
+  if (dataType %in% c("date", "datetime")) {
+    # For Dates, this conversion uses midnight on that date in UTC
+    to_ms <- function(x) 1000 * as.numeric(as.POSIXct(x))
+
+    # Convert values to milliseconds since epoch (this is the value JS uses)
+    # Find step size in ms
+    step  <- to_ms(max) - to_ms(max - step)
+    min   <- to_ms(min)
+    max   <- to_ms(max)
+    value <- to_ms(value)
+  }
+
+  range <- max - min
+
+  # Try to get a sane number of tick marks
+  if (ticks) {
+    n_steps <- range / step
+
+    # Make sure there are <= 10 steps.
+    # n_ticks can be a noninteger, which is good when the range is not an
+    # integer multiple of the step size, e.g., min=1, max=10, step=4
+    scale_factor <- ceiling(n_steps / 10)
+    n_ticks <- n_steps / scale_factor
+
+  } else {
+    n_ticks <- NULL
+  }
+
+  sliderProps <- dropNulls(list(
+    class = "js-range-slider",
+    id = inputId,
+    `data-type` = if (length(value) > 1) "double",
+    `data-min` = formatNoSci(min),
+    `data-max` = formatNoSci(max),
+    `data-from` = formatNoSci(value[1]),
+    `data-to` = if (length(value) > 1) formatNoSci(value[2]),
+    `data-step` = formatNoSci(step),
+    `data-grid` = ticks,
+    `data-grid-num` = n_ticks,
+    `data-grid-snap` = FALSE,
+    `data-prettify-separator` = sep,
+    `data-prefix` = pre,
+    `data-postfix` = post,
+    `data-keyboard` = TRUE,
+    `data-keyboard-step` = step / (max - min) * 100,
+    `data-drag-interval` = dragRange,
+    # The following are ignored by the ion.rangeSlider, but are used by Shiny.
+    `data-data-type` = dataType,
+    `data-time-format` = timeFormat,
+    `data-timezone` = timezone
+  ))
+
+  # Replace any TRUE and FALSE with "true" and "false"
+  sliderProps <- lapply(sliderProps, function(x) {
+    if (identical(x, TRUE)) "true"
+    else if (identical(x, FALSE)) "false"
+    else x
+  })
+
+  sliderTag <- div(class = "form-group shiny-input-container",
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    if (!is.null(label)) controlLabel(inputId, label),
+    do.call(tags$input, sliderProps)
+  )
+
+  # Add animation buttons
+  if (identical(animate, TRUE))
+    animate <- animationOptions()
+
+  if (!is.null(animate) && !identical(animate, FALSE)) {
+    if (is.null(animate$playButton))
+      animate$playButton <- icon('play', lib = 'glyphicon')
+    if (is.null(animate$pauseButton))
+      animate$pauseButton <- icon('pause', lib = 'glyphicon')
+
+    sliderTag <- tagAppendChild(
+      sliderTag,
+      tags$div(class='slider-animate-container',
+        tags$a(href='#',
+          class='slider-animate-button',
+          'data-target-id'=inputId,
+          'data-interval'=animate$interval,
+          'data-loop'=animate$loop,
+          span(class = 'play', animate$playButton),
+          span(class = 'pause', animate$pauseButton)
+        )
+      )
+    )
+  }
+
+  dep <- list(
+    htmlDependency("ionrangeslider", "2.0.12", c(href="shared/ionrangeslider"),
+      script = "js/ion.rangeSlider.min.js",
+      # ion.rangeSlider also needs normalize.css, which is already included in
+      # Bootstrap.
+      stylesheet = c("css/ion.rangeSlider.css",
+                     "css/ion.rangeSlider.skinShiny.css")
+    ),
+    htmlDependency("strftime", "0.9.2", c(href="shared/strftime"),
+      script = "strftime-min.js"
+    )
+  )
+
+  attachDependencies(sliderTag, dep)
+}
+
+hasDecimals <- function(value) {
+  truncatedValue <- round(value)
+  return (!identical(value, truncatedValue))
+}
+
+#' @rdname sliderInput
+#'
+#' @param interval The interval, in milliseconds, between each animation step.
+#' @param loop \code{TRUE} to automatically restart the animation when it
+#'   reaches the end.
+#' @param playButton Specifies the appearance of the play button. Valid values
+#'   are a one-element character vector (for a simple text label), an HTML tag
+#'   or list of tags (using \code{\link{tag}} and friends), or raw HTML (using
+#'   \code{\link{HTML}}).
+#' @param pauseButton Similar to \code{playButton}, but for the pause button.
+#'
+#' @export
+animationOptions <- function(interval=1000,
+                             loop=FALSE,
+                             playButton=NULL,
+                             pauseButton=NULL) {
+  list(interval=interval,
+       loop=loop,
+       playButton=playButton,
+       pauseButton=pauseButton)
+}

R/input-submit.R

@@ -0,0 +1,28 @@
+#' Create a submit button
+#'
+#' Create a submit button for an input form. Forms that include a submit
+#' button do not automatically update their outputs when inputs change,
+#' rather they wait until the user explicitly clicks the submit button.
+#'
+#' @param text Button caption
+#' @param icon Optional \code{\link{icon}} to appear on the button
+#' @param width The width of the button, e.g. \code{'400px'}, or \code{'100\%'};
+#'   see \code{\link{validateCssUnit}}.
+#' @return A submit button that can be added to a UI definition.
+#'
+#' @family input elements
+#'
+#' @examples
+#' submitButton("Update View")
+#' submitButton("Update View", icon("refresh"))
+#' @export
+submitButton <- function(text = "Apply Changes", icon = NULL, width = NULL) {
+  div(
+    tags$button(
+      type="submit",
+      class="btn btn-primary",
+      style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+      list(icon, text)
+    )
+  )
+}

R/input-text.R

@@ -0,0 +1,24 @@
+#' Create a text input control
+#'
+#' Create an input control for entry of unstructured text values
+#'
+#' @param inputId The \code{input} slot that will be used to access the value.
+#' @param label Display label for the control, or \code{NULL} for no label.
+#' @param value Initial value.
+#' @param width The width of the input, e.g. \code{'400px'}, or \code{'100\%'};
+#'   see \code{\link{validateCssUnit}}.
+#' @return A text input control that can be added to a UI definition.
+#'
+#' @family input elements
+#' @seealso \code{\link{updateTextInput}}
+#'
+#' @examples
+#' textInput("caption", "Caption:", "Data Summary")
+#' @export
+textInput <- function(inputId, label, value = "", width = NULL) {
+  div(class = "form-group shiny-input-container",
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
+    label %AND% tags$label(label, `for` = inputId),
+    tags$input(id = inputId, type="text", class="form-control", value=value)
+  )
+}

R/input-utils.R

@@ -0,0 +1,105 @@
+controlLabel <- function(controlName, label) {
+  label %AND% tags$label(class = "control-label", `for` = controlName, label)
+}
+
+
+# Before shiny 0.9, `selected` refers to names/labels of `choices`; now it
+# refers to values. Below is a function for backward compatibility.
+validateSelected <- function(selected, choices, inputId) {
+  # drop names, otherwise toJSON() keeps them too
+  selected <- unname(selected)
+  # if you are using optgroups, you're using shiny > 0.10.0, and you should
+  # already know that `selected` must be a value instead of a label
+  if (needOptgroup(choices)) return(selected)
+
+  if (is.list(choices)) choices <- unlist(choices)
+
+  nms <- names(choices)
+  # labels and values are identical, no need to validate
+  if (identical(nms, unname(choices))) return(selected)
+  # when selected labels instead of values
+  i <- (selected %in% nms) & !(selected %in% choices)
+  if (any(i)) {
+    warnFun <- if (all(i)) {
+      # replace names with values
+      selected <- unname(choices[selected])
+      warning
+    } else stop  # stop when it is ambiguous (some labels == values)
+    warnFun("'selected' must be the values instead of names of 'choices' ",
+            "for the input '", inputId, "'")
+  }
+  selected
+}
+
+
+# generate options for radio buttons and checkbox groups (type = 'checkbox' or
+# 'radio')
+generateOptions <- function(inputId, choices, selected, inline, type = 'checkbox') {
+  # generate a list of <input type=? [checked] />
+  options <- mapply(
+    choices, names(choices),
+    FUN = function(value, name) {
+      inputTag <- tags$input(
+        type = type, name = inputId, value = value
+      )
+      if (value %in% selected)
+        inputTag$attribs$checked <- "checked"
+
+      # If inline, there's no wrapper div, and the label needs a class like
+      # checkbox-inline.
+      if (inline) {
+        tags$label(class = paste0(type, "-inline"), inputTag, tags$span(name))
+      } else {
+        tags$div(class = type,
+          tags$label(inputTag, tags$span(name))
+        )
+      }
+    },
+    SIMPLIFY = FALSE, USE.NAMES = FALSE
+  )
+
+  div(class = "shiny-options-group", options)
+}
+
+
+# Takes a vector or list, and adds names (same as the value) to any entries
+# without names.
+choicesWithNames <- function(choices) {
+  # Take a vector or list, and convert to list. Also, if any children are
+  # vectors with length > 1, convert those to list. If the list is unnamed,
+  # convert it to a named list with blank names.
+  listify <- function(obj) {
+    # If a list/vector is unnamed, give it blank names
+    makeNamed <- function(x) {
+      if (is.null(names(x))) names(x) <- character(length(x))
+      x
+    }
+
+    res <- lapply(obj, function(val) {
+      if (is.list(val))
+        listify(val)
+      else if (length(val) == 1 && is.null(names(val)))
+        val
+      else
+        makeNamed(as.list(val))
+    })
+
+    makeNamed(res)
+  }
+
+  choices <- listify(choices)
+  if (length(choices) == 0) return(choices)
+
+  # Recurse into any subgroups
+  choices <- mapply(choices, names(choices), FUN = function(choice, name) {
+    if (!is.list(choice)) return(choice)
+    if (name == "") stop('All sub-lists in "choices" must be named.')
+    choicesWithNames(choice)
+  }, SIMPLIFY = FALSE)
+
+  # default missing names to choice values
+  missing <- names(choices) == ""
+  names(choices)[missing] <- as.character(choices)[missing]
+
+  choices
+}

R/jqueryui.R

@@ -0,0 +1,104 @@
+#' Panel with absolute positioning
+#'
+#' Creates a panel whose contents are absolutely positioned.
+#'
+#' The \code{absolutePanel} function creates a \code{<div>} tag whose CSS
+#' position is set to \code{absolute} (or fixed if \code{fixed = TRUE}). The way
+#' absolute positioning works in HTML is that absolute coordinates are specified
+#' relative to its nearest parent element whose position is not set to
+#' \code{static} (which is the default), and if no such parent is found, then
+#' relative to the page borders. If you're not sure what that means, just keep
+#' in mind that you may get strange results if you use \code{absolutePanel} from
+#' inside of certain types of panels.
+#'
+#' The \code{fixedPanel} function is the same as \code{absolutePanel} with
+#' \code{fixed = TRUE}.
+#'
+#' The position (\code{top}, \code{left}, \code{right}, \code{bottom}) and size
+#' (\code{width}, \code{height}) parameters are all optional, but you should
+#' specify exactly two of \code{top}, \code{bottom}, and \code{height} and
+#' exactly two of \code{left}, \code{right}, and \code{width} for predictable
+#' results.
+#'
+#' Like most other distance parameters in Shiny, the position and size
+#' parameters take a number (interpreted as pixels) or a valid CSS size string,
+#' such as \code{"100px"} (100 pixels) or \code{"25\%"}.
+#'
+#' For arcane HTML reasons, to have the panel fill the page or parent you should
+#' specify \code{0} for \code{top}, \code{left}, \code{right}, and \code{bottom}
+#' rather than the more obvious \code{width = "100\%"} and \code{height =
+#' "100\%"}.
+#'
+#' @param ... Attributes (named arguments) or children (unnamed arguments) that
+#'   should be included in the panel.
+#'
+#' @param top Distance between the top of the panel, and the top of the page or
+#'   parent container.
+#' @param left Distance between the left side of the panel, and the left of the
+#'   page or parent container.
+#' @param right Distance between the right side of the panel, and the right of
+#'   the page or parent container.
+#' @param bottom Distance between the bottom of the panel, and the bottom of the
+#'   page or parent container.
+#' @param width Width of the panel.
+#' @param height Height of the panel.
+#' @param draggable If \code{TRUE}, allows the user to move the panel by
+#'   clicking and dragging.
+#' @param fixed Positions the panel relative to the browser window and prevents
+#'   it from being scrolled with the rest of the page.
+#' @param cursor The type of cursor that should appear when the user mouses over
+#'   the panel. Use \code{"move"} for a north-east-south-west icon,
+#'   \code{"default"} for the usual cursor arrow, or \code{"inherit"} for the
+#'   usual cursor behavior (including changing to an I-beam when the cursor is
+#'   over text). The default is \code{"auto"}, which is equivalent to
+#'   \code{ifelse(draggable, "move", "inherit")}.
+#' @return An HTML element or list of elements.
+#'
+#' @export
+absolutePanel <- function(...,
+                          top = NULL, left = NULL, right = NULL, bottom = NULL,
+                          width = NULL, height = NULL,
+                          draggable = FALSE, fixed = FALSE,
+                          cursor = c('auto', 'move', 'default', 'inherit')) {
+  cssProps <- list(
+    top = top,
+    left = left,
+    right = right,
+    bottom = bottom,
+    width = width,
+    height = height
+  )
+  cssProps <- cssProps[!sapply(cssProps, is.null)]
+  cssProps <- sapply(cssProps, validateCssUnit)
+  cssProps[['position']] <- ifelse(fixed, 'fixed', 'absolute')
+  cssProps[['cursor']] <- match.arg(cursor)
+  if (identical(cssProps[['cursor']], 'auto'))
+    cssProps[['cursor']] <- ifelse(draggable, 'move', 'inherit')
+
+  style <- paste(paste(names(cssProps), cssProps, sep = ':', collapse = ';'), ';', sep='')
+  divTag <- tags$div(style=style, ...)
+  if (isTRUE(draggable)) {
+    divTag <- tagAppendAttributes(divTag, class='draggable')
+    return(tagList(
+      # IMPORTANT NOTE: If you update jqueryui, make sure you DON'T include the datepicker,
+      # as it collides with our bootstrap datepicker!
+      singleton(tags$head(tags$script(src='shared/jqueryui/1.10.4/jquery-ui.min.js'))),
+      divTag,
+      tags$script('$(".draggable").draggable();')
+    ))
+  } else {
+    return(divTag)
+  }
+}
+
+#' @rdname absolutePanel
+#' @export
+fixedPanel <- function(...,
+                       top = NULL, left = NULL, right = NULL, bottom = NULL,
+                       width = NULL, height = NULL,
+                       draggable = FALSE,
+                       cursor = c('auto', 'move', 'default', 'inherit')) {
+  absolutePanel(..., top=top, left=left, right=right, bottom=bottom,
+                width=width, height=height, draggable=draggable, cursor=match.arg(cursor),
+                fixed=TRUE)
+}

R/map.R

@@ -9,62 +9,68 @@
 # Remove of unknown key does nothing
 # Setting a key twice always results in last-one-wins
 # /TESTS
-Map <- setRefClass(
+Map <- R6Class(
   'Map',
-  fields = list(
-    .env = 'environment'
-  ),
-  methods = list(
+  portable = FALSE,
+  public = list(
     initialize = function() {
-      .env <<- new.env(parent=emptyenv())
+      private$env <- new.env(parent=emptyenv())
     },
     get = function(key) {
-      if (.self$containsKey(key))
-        return(base::get(key, pos=.env, inherits=FALSE))
-      else
-        return(NULL)
+      env[[key]]
     },
     set = function(key, value) {
-      assign(key, value, pos=.env, inherits=FALSE)
-      return(value)
+      env[[key]] <- value
+      value
+    },
+    mget = function(keys) {
+      base::mget(keys, env)
     },
     mset = function(...) {
       args <- list(...)
-      for (key in names(args))
-        set(key, args[[key]])
-      return()
+      if (length(args) == 0)
+        return()
+
+      arg_names <- names(args)
+      if (is.null(arg_names) || any(!nzchar(arg_names)))
+        stop("All elements must be named")
+
+      list2env(args, envir = env)
     },
     remove = function(key) {
-      if (.self$containsKey(key)) {
-        result <- .self$get(key)
-        rm(list = key, pos=.env, inherits=FALSE)
-        return(result)
-      }
-      return(NULL)
+      if (!self$containsKey(key))
+        return(NULL)
+
+      result <- env[[key]]
+      rm(list=key, envir=env, inherits=FALSE)
+      result
     },
     containsKey = function(key) {
-      exists(key, where=.env, inherits=FALSE)
+      exists(key, envir=env, inherits=FALSE)
     },
     keys = function() {
-      ls(envir=.env, all.names=TRUE)
+      # Sadly, this is much faster than ls(), because it doesn't sort the keys.
+      names(as.list(env, all.names=TRUE))
     },
     values = function() {
-      mget(.self$keys(), envir=.env, inherits=FALSE)
+      as.list(env, all.names=TRUE)
     },
     clear = function() {
-      .env <<- new.env(parent=emptyenv())
+      private$env <- new.env(parent=emptyenv())
       invisible(NULL)
     },
     size = function() {
-      length(.env)
+      length(env)
     }
+  ),
+
+  private = list(
+    env = 'environment'
   )
 )
 
 as.list.Map <- function(map) {
-  sapply(map$keys(),
-         map$get,
-         simplify=FALSE)
+  map$values()
 }
 length.Map <- function(map) {
   map$size()

R/middleware-shiny.R

@@ -0,0 +1,73 @@
+#' @include globals.R
+NULL
+
+reactLogHandler <- function(req) {
+  if (!identical(req$PATH_INFO, '/reactlog'))
+    return(NULL)
+
+  if (!isTRUE(getOption('shiny.reactlog'))) {
+    return(NULL)
+  }
+
+  return(httpResponse(
+    status=200,
+    content=list(file=renderReactLog(), owned=TRUE)
+  ))
+}
+
+sessionHandler <- function(req) {
+  path <- req$PATH_INFO
+  if (is.null(path))
+    return(NULL)
+
+  matches <- regmatches(path, regexec('^(/session/([0-9a-f]+))(/.*)$', path))
+  if (length(matches[[1]]) == 0)
+    return(NULL)
+
+  session <- matches[[1]][3]
+  subpath <- matches[[1]][4]
+
+  shinysession <- appsByToken$get(session)
+  if (is.null(shinysession))
+    return(NULL)
+
+  subreq <- as.environment(as.list(req, all.names=TRUE))
+  subreq$PATH_INFO <- subpath
+  subreq$SCRIPT_NAME <- paste(subreq$SCRIPT_NAME, matches[[1]][2], sep='')
+
+  withReactiveDomain(shinysession, {
+    shinysession$handleRequest(subreq)
+  })
+}
+
+dynamicHandler <- function(filePath, dependencyFiles=filePath) {
+  lastKnownTimestamps <- NA
+  metaHandler <- function(req) NULL
+
+  if (!file.exists(filePath))
+    return(metaHandler)
+
+  cacheContext <- CacheContext$new()
+
+  return (function(req) {
+    # Check if we need to rebuild
+    if (cacheContext$isDirty()) {
+      cacheContext$reset()
+      for (dep in dependencyFiles)
+        cacheContext$addDependencyFile(dep)
+
+      clearClients()
+      if (file.exists(filePath)) {
+        local({
+          cacheContext$with(function() {
+            sys.source(filePath, envir=new.env(parent=globalenv()), keep.source=TRUE)
+          })
+        })
+      }
+      metaHandler <<- joinHandlers(.globals$clients)
+      clearClients()
+    }
+
+    return(metaHandler(req))
+  })
+}

R/middleware.R

@@ -0,0 +1,381 @@
+# This file contains a general toolkit for routing and combining bits of
+# HTTP-handling logic. It is similar in spirit to Rook (and Rack, and WSGI, and
+# Connect, and...) but adds cascading and routing.
+#
+# This file is called "middleware" because that's the term used for these bits
+# of logic in these other frameworks. However, our code uses the word "handler"
+# so we'll stick to that for the rest of this document; just know that they're
+# basically the same concept.
+#
+# ## Intro to handlers
+#
+# A **handler** (or sometimes, **httpHandler**) is a function that takes a
+# `req` parameter--a request object as described in the Rook specification--and
+# returns `NULL`, or an `httpResponse`.
+#
+## ------------------------------------------------------------------------
+httpResponse <- function(status = 200,
+                         content_type = "text/html; charset=UTF-8",
+                         content = "",
+                         headers = list()) {
+  # Make sure it's a list, not a vector
+  headers <- as.list(headers)
+  if (is.null(headers$`X-UA-Compatible`))
+    headers$`X-UA-Compatible` <- "IE=edge,chrome=1"
+  resp <- list(status = status, content_type = content_type, content = content,
+               headers = headers)
+  class(resp) <- 'httpResponse'
+  return(resp)
+}
+
+#
+# You can think of a web application as being simply an aggregation of these
+# functions, each of which performs one kind of duty. Each handler in turn gets
+# a look at the request and can decide whether it knows how to handle it. If
+# so, it returns an `httpResponse` and processing terminates; if not, it
+# returns `NULL` and the next handler gets to execute. If the final handler
+# returns `NULL`, a 404 response should be returned.
+#
+# We have a similar construct for websockets: **websocket handlers** or
+# **wsHandlers**. These take a single `ws` argument which is the websocket
+# connection that was just opened, and they can either return `TRUE` if they
+# are handling the connection, and `NULL` to pass responsibility on to the next
+# wsHandler.
+#
+# ### Combining handlers
+#
+# Since it's so common for httpHandlers to be invoked in this "cascading"
+# fashion, we'll introduce a function that takes zero or more handlers and
+# returns a single handler. And while we're at it, making a directory of static
+# content available is such a common thing to do, we'll allow strings
+# representing paths to be used instead of handlers; any such strings we
+# encounter will be converted into `staticHandler` objects.
+#
+## ------------------------------------------------------------------------
+joinHandlers <- function(handlers) {
+  # Zero handlers; return a null handler
+  if (length(handlers) == 0)
+    return(function(req) NULL)
+
+  # Just one handler (function)? Return it.
+  if (is.function(handlers))
+    return(handlers)
+
+  handlers <- lapply(handlers, function(h) {
+    if (is.character(h))
+      return(staticHandler(h))
+    else
+      return(h)
+  })
+
+  # Filter out NULL
+  handlers <- handlers[!sapply(handlers, is.null)]
+
+  if (length(handlers) == 0)
+    return(function(req) NULL)
+  if (length(handlers) == 1)
+    return(handlers[[1]])
+
+  function(req) {
+    for (handler in handlers) {
+      response <- handler(req)
+      if (!is.null(response))
+        return(response)
+    }
+    return(NULL)
+  }
+}
+
+#
+# Note that we don't have an equivalent of `joinHandlers` for wsHandlers. It's
+# easy to imagine it, we just haven't needed one.
+#
+# ### Handler routing
+#
+# Handlers do not have a built-in notion of routing. Conceptually, given a list
+# of handlers, all the handlers are peers and they all get to see every request
+# (well, up until the point that a handler returns a response).
+#
+# You could implement routing in each handler by checking the request's
+# `PATH_INFO` field, but since it's such a common need, let's make it simple by
+# introducing a `routeHandler` function. This is a handler
+# [decorator](http://en.wikipedia.org/wiki/Decorator_pattern) and it's
+# responsible for 1) filtering out requests that don't match the given route,
+# and 2) temporarily modifying the request object to take the matched part of
+# the route off of the `PATH_INFO` (and add it to the end of `SCRIPT_NAME`).
+# This way, the handler doesn't need to figure out about what part of its URL
+# path has already been matched via routing.
+#
+# (BTW, it's safe for `routeHandler` calls to nest.)
+#
+## ------------------------------------------------------------------------
+routeHandler <- function(prefix, handler) {
+  force(prefix)
+  force(handler)
+
+  if (identical("", prefix))
+    return(handler)
+
+  if (length(prefix) != 1 || !isTRUE(grepl("^/[^\\]+$", prefix))) {
+    stop("Invalid URL prefix \"", prefix, "\"")
+  }
+
+  pathPattern <- paste("^\\Q", prefix, "\\E/", sep = "")
+  function(req) {
+    if (isTRUE(grepl(pathPattern, req$PATH_INFO))) {
+      origScript <- req$SCRIPT_NAME
+      origPath <- req$PATH_INFO
+      on.exit({
+        req$SCRIPT_NAME <- origScript
+        req$PATH_INFO <- origPath
+      }, add = TRUE)
+      pathInfo <- substr(req$PATH_INFO, nchar(prefix)+1, nchar(req$PATH_INFO))
+      req$SCRIPT_NAME <- paste(req$SCRIPT_NAME, prefix, sep = "")
+      req$PATH_INFO <- pathInfo
+      return(handler(req))
+    } else {
+      return(NULL)
+    }
+  }
+}
+
+#
+# We have a version for websocket handlers as well. Pity about the copy/paste
+# job.
+#
+## ------------------------------------------------------------------------
+routeWSHandler <- function(prefix, wshandler) {
+  force(prefix)
+  force(wshandler)
+
+  if (identical("", prefix))
+    return(wshandler)
+
+  if (length(prefix) != 1 || !isTRUE(grepl("^/[^\\]+$", prefix))) {
+    stop("Invalid URL prefix \"", prefix, "\"")
+  }
+
+  pathPattern <- paste("^\\Q", prefix, "\\E/", sep = "")
+  function(ws) {
+    req <- ws$request
+    if (isTRUE(grepl(pathPattern, req$PATH_INFO))) {
+      origScript <- req$SCRIPT_NAME
+      origPath <- req$PATH_INFO
+      on.exit({
+        req$SCRIPT_NAME <- origScript
+        req$PATH_INFO <- origPath
+      }, add = TRUE)
+      pathInfo <- substr(req$PATH_INFO, nchar(prefix)+1, nchar(req$PATH_INFO))
+      req$SCRIPT_NAME <- paste(req$SCRIPT_NAME, prefix, sep = "")
+      req$PATH_INFO <- pathInfo
+      return(wshandler(ws))
+    } else {
+      return(NULL)
+    }
+  }
+}
+
+#
+# ### Handler implementations
+#
+# Now let's actually write some handlers. Note that these functions aren't
+# *themselves* handlers, you call them and they *return* a handler. Handler
+# factory functions, if you will.
+#
+# Here's one that serves up static assets from a directory.
+#
+## ------------------------------------------------------------------------
+staticHandler <- function(root) {
+  force(root)
+  return(function(req) {
+    if (!identical(req$REQUEST_METHOD, 'GET'))
+      return(NULL)
+
+    path <- req$PATH_INFO
+
+    if (is.null(path))
+      return(httpResponse(400, content="<h1>Bad Request</h1>"))
+
+    if (path == '/')
+      path <- '/index.html'
+
+    abs.path <- resolve(root, path)
+    if (is.null(abs.path))
+      return(NULL)
+
+    content.type <- getContentType(abs.path)
+    response.content <- readBin(abs.path, 'raw', n=file.info(abs.path)$size)
+    return(httpResponse(200, content.type, response.content))
+  })
+}
+
+#
+# ## Handler manager
+#
+# The handler manager gives you a place to register handlers (of both http and
+# websocket varieties) and provides an httpuv-compatible set of callbacks for
+# invoking them.
+#
+# Create one of these, make zero or more calls to `addHandler` and
+# `addWSHandler` methods (order matters--first one wins!), and then pass the
+# return value of `createHttpuvApp` to httpuv's `startServer` function.
+#
+## ------------------------------------------------------------------------
+HandlerList <- R6Class("HandlerList",
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+    handlers = list(),
+
+    add = function(handler, key, tail = FALSE) {
+      if (!is.null(handlers[[key]]))
+        stop("Key ", key, " already in use")
+      newList <- structure(names=key, list(handler))
+
+      if (length(handlers) == 0)
+        handlers <<- newList
+      else if (tail)
+        handlers <<- c(handlers, newList)
+      else
+        handlers <<- c(newList, handlers)
+    },
+    remove = function(key) {
+      handlers[key] <<- NULL
+    },
+    clear = function() {
+      handlers <<- list()
+    },
+    invoke = function(...) {
+      for (handler in handlers) {
+        result <- handler(...)
+        if (!is.null(result))
+          return(result)
+      }
+      return(NULL)
+    }
+  )
+)
+
+HandlerManager <- R6Class("HandlerManager",
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+    handlers = "HandlerList",
+    wsHandlers = "HandlerList",
+
+    initialize = function() {
+      handlers <<- HandlerList$new()
+      wsHandlers <<- HandlerList$new()
+    },
+
+    addHandler = function(handler, key, tail = FALSE) {
+      handlers$add(handler, key, tail)
+    },
+    removeHandler = function(key) {
+      handlers$remove(key)
+    },
+    addWSHandler = function(wsHandler, key, tail = FALSE) {
+      wsHandlers$add(wsHandler, key, tail)
+    },
+    removeWSHandler = function(key) {
+      wsHandlers$remove(key)
+    },
+    clear = function() {
+      handlers$clear()
+      wsHandlers$clear()
+    },
+    createHttpuvApp = function() {
+      list(
+        onHeaders = function(req) {
+          maxSize <- getOption('shiny.maxRequestSize') %OR% (5 * 1024 * 1024)
+          if (maxSize <= 0)
+            return(NULL)
+
+          reqSize <- 0
+          if (length(req$CONTENT_LENGTH) > 0)
+            reqSize <- as.numeric(req$CONTENT_LENGTH)
+          else if (length(req$HTTP_TRANSFER_ENCODING) > 0)
+            reqSize <- Inf
+
+          if (reqSize > maxSize) {
+            return(list(status = 413L,
+              headers = list(
+                'Content-Type' = 'text/plain'
+              ),
+              body = 'Maximum upload size exceeded'))
+          }
+          else {
+            return(NULL)
+          }
+        },
+        call = .httpServer(
+          function (req) {
+            return(handlers$invoke(req))
+          },
+          getOption('shiny.sharedSecret')
+        ),
+        onWSOpen = function(ws) {
+          return(wsHandlers$invoke(ws))
+        }
+      )
+    },
+    .httpServer = function(handler, sharedSecret) {
+      filter <- getOption('shiny.http.response.filter')
+      if (is.null(filter))
+        filter <- function(req, response) response
+
+      function(req) {
+        if (!is.null(sharedSecret)
+          && !identical(sharedSecret, req$HTTP_SHINY_SHARED_SECRET)) {
+          return(list(status=403,
+            body='<h1>403 Forbidden</h1><p>Shared secret mismatch</p>',
+            headers=list('Content-Type' = 'text/html')))
+        }
+
+        # Catch HEAD requests. For the purposes of handler functions, they
+        # should be treated like GET. The difference is that  they shouldn't
+        # return a body in the http response.
+        head_request <- FALSE
+        if (identical(req$REQUEST_METHOD, "HEAD")) {
+          head_request <- TRUE
+          req$REQUEST_METHOD <- "GET"
+        }
+
+        response <- handler(req)
+        if (is.null(response))
+          response <- httpResponse(404, content="<h1>Not Found</h1>")
+
+        if (inherits(response, "httpResponse")) {
+          headers <- as.list(response$headers)
+          headers$'Content-Type' <- response$content_type
+
+          response <- filter(req, response)
+          if (head_request) {
+            headers$`Content-Length` <- nchar(response$content, type = "bytes")
+            return(list(
+              status = response$status,
+              body = "",
+              headers = headers
+            ))
+          } else {
+            return(list(
+              status = response$status,
+              body = response$content,
+              headers = headers
+            ))
+          }
+
+        } else {
+          # Assume it's a Rook-compatible response
+          return(response)
+        }
+      }
+    }
+  )
+)
+
+#
+# ## Next steps
+#
+# See server.R and middleware-shiny.R to see actual implementation and usage of
+# handlers in the context of Shiny.

R/priorityqueue.R

@@ -4,20 +4,24 @@
 # elements have the same priority, they are served according to their order in
 # the queue." (http://en.wikipedia.org/wiki/Priority_queue)
 
-PriorityQueue <- setRefClass(
+PriorityQueue <- R6Class(
   'PriorityQueue',
-  fields = list(
+  portable = FALSE,
+  class = FALSE,
+  public = list(
     # Keys are priorities, values are subqueues (implemented as list)
     .itemsByPriority = 'Map',
     # Sorted vector (largest first)
-    .priorities = 'numeric'  
-  ),
-  methods = list(
-    # Enqueue an item, with the given priority level (must be integer). Higher 
+    .priorities = numeric(0),
+
+    initialize = function() {
+      .itemsByPriority <<- Map$new()
+    },
+    # Enqueue an item, with the given priority level (must be integer). Higher
     # priority numbers are dequeued earlier than lower.
     enqueue = function(item, priority) {
       priority <- normalizePriority(priority)
-      
+
       if (!(priority %in% .priorities)) {
         .priorities <<- c(.priorities, priority)
         .priorities <<- sort(.priorities, decreasing=TRUE)
@@ -30,14 +34,14 @@ PriorityQueue <- setRefClass(
       }
       return(invisible())
     },
-    # Retrieve a single item by 1) priority number (highest first) and then 2) 
-    # insertion order (first in, first out). If there are no items to be 
+    # Retrieve a single item by 1) priority number (highest first) and then 2)
+    # insertion order (first in, first out). If there are no items to be
     # dequeued, then NULL is returned. If it is necessary to distinguish between
     # a NULL value and the empty case, call isEmpty() before dequeue().
     dequeue = function() {
       if (length(.priorities) == 0)
         return(NULL)
-      
+
       maxPriority <- .priorities[[1]]
       items <- .itemsByPriority$get(.key(maxPriority))
       firstItem <- items[[1]]
@@ -67,17 +71,17 @@ PriorityQueue <- setRefClass(
 )
 
 normalizePriority <- function(priority) {
-  
+
   if (is.null(priority))
     priority <- 0
-  
+
   # Cast integers to numeric to prevent any inconsistencies
   if (is.integer(priority))
     priority <- as.numeric(priority)
-  
+
   if (!is.numeric(priority))
     stop('priority must be an integer or numeric')
-  
+
   # Check length
   if (length(priority) == 0) {
     warning('Zero-length priority vector was passed; using 0')
@@ -86,7 +90,7 @@ normalizePriority <- function(priority) {
     warning('Priority has length > 1 and only the first element will be used')
     priority <- priority[1]
   }
-  
+
   # NA == 0
   if (is.na(priority))
     priority <- 0

R/progress.R

@@ -0,0 +1,283 @@
+#' Reporting progress (object-oriented API)
+#'
+#' Reports progress to the user during long-running operations.
+#'
+#' This package exposes two distinct programming APIs for working with
+#' progress. \code{\link{withProgress}} and \code{\link{setProgress}}
+#' together provide a simple function-based interface, while the
+#' \code{Progress} reference class provides an object-oriented API.
+#'
+#' Instantiating a \code{Progress} object causes a progress panel to be
+#' created, and it will be displayed the first time the \code{set}
+#' method is called. Calling \code{close} will cause the progress panel
+#' to be removed.
+#'
+#' \strong{Methods}
+#'   \describe{
+#'     \item{\code{initialize(session, min = 0, max = 1)}}{
+#'       Creates a new progress panel (but does not display it).
+#'     }
+#'     \item{\code{set(value = NULL, message = NULL, detail = NULL)}}{
+#'       Updates the progress panel. When called the first time, the
+#'       progress panel is displayed.
+#'     }
+#'     \item{\code{inc(amount = 0.1, message = NULL, detail = NULL)}}{
+#'       Like \code{set}, this updates the progress panel. The difference is
+#'       that \code{inc} increases the progress bar by \code{amount}, instead
+#'       of setting it to a specific value.
+#'     }
+#'     \item{\code{close()}}{
+#'       Removes the progress panel. Future calls to \code{set} and
+#'       \code{close} will be ignored.
+#'     }
+#'   }
+#'
+#' @param session The Shiny session object, as provided by
+#'   \code{shinyServer} to the server function.
+#' @param min The value that represents the starting point of the
+#'   progress bar. Must be less tham \code{max}.
+#' @param max The value that represents the end of the progress bar.
+#'   Must be greater than \code{min}.
+#' @param message A single-element character vector; the message to be
+#'   displayed to the user, or \code{NULL} to hide the current message
+#'   (if any).
+#' @param detail A single-element character vector; the detail message
+#'   to be displayed to the user, or \code{NULL} to hide the current
+#'   detail message (if any). The detail message will be shown with a
+#'   de-emphasized appearance relative to \code{message}.
+#' @param value A numeric value at which to set
+#'   the progress bar, relative to \code{min} and \code{max}.
+#'   \code{NULL} hides the progress bar, if it is currently visible.
+#' @param amount Single-element numeric vector; the value at which to set
+#'   the progress bar, relative to \code{min} and \code{max}.
+#'   \code{NULL} hides the progress bar, if it is currently visible.
+#' @param amount For the \code{inc()} method, a numeric value to increment the
+#'   progress bar.
+#'
+#' @examples
+#' \dontrun{
+#' # server.R
+#' shinyServer(function(input, output, session) {
+#'   output$plot <- renderPlot({
+#'     progress <- shiny::Progress$new(session, min=1, max=15)
+#'     on.exit(progress$close())
+#'
+#'     progress$set(message = 'Calculation in progress',
+#'                  detail = 'This may take a while...')
+#'
+#'     for (i in 1:15) {
+#'       progress$set(value = i)
+#'       Sys.sleep(0.5)
+#'     }
+#'     plot(cars)
+#'   })
+#' })
+#' }
+#' @seealso \code{\link{withProgress}}
+#' @format NULL
+#' @usage NULL
+#' @export
+Progress <- R6Class(
+  'Progress',
+  portable = TRUE,
+  public = list(
+
+    initialize = function(session = getDefaultReactiveDomain(), min = 0, max = 1) {
+      if (!inherits(session, "ShinySession"))
+        stop("'session' is not a ShinySession object.")
+
+      private$session <- session
+      private$id <- paste(as.character(as.raw(stats::runif(8, min=0, max=255))), collapse='')
+      private$min <- min
+      private$max <- max
+      private$value <- NULL
+      private$closed <- FALSE
+
+      session$sendProgress('open', list(id = private$id))
+    },
+
+    set = function(value = NULL, message = NULL, detail = NULL) {
+      if (private$closed) {
+        warning("Attempting to set progress, but progress already closed.")
+        return()
+      }
+
+      if (is.null(value) || is.na(value)) {
+        value <- NULL
+      } else {
+        # Normalize value to number between 0 and 1
+        value <- min(1, max(0, (value - private$min) / (private$max - private$min)))
+      }
+
+      private$value <- value
+
+      data <- dropNulls(list(
+        id = private$id,
+        message = message,
+        detail = detail,
+        value = value
+      ))
+
+       private$session$sendProgress('update', data)
+    },
+
+    inc = function(amount = 0.1, message = NULL, detail = NULL) {
+      value <- min(self$getValue() + amount, private$max)
+      self$set(value, message, detail)
+    },
+
+    getMin = function() private$min,
+
+    getMax = function() private$max,
+
+    # Return value (not the normalized 0-1 value, but in the original range)
+    getValue = function() {
+      private$value * (private$max - private$min) + private$min
+    },
+
+    close = function() {
+      if (private$closed) {
+        warning("Attempting to close progress, but progress already closed.")
+        return()
+      }
+
+      private$session$sendProgress('close', list(id = private$id))
+      private$closed <- TRUE
+    }
+  ),
+
+  private = list(
+    session = 'environment',
+    id = character(0),
+    min = numeric(0),
+    max = numeric(0),
+    value = NULL,
+    closed = logical(0)
+  )
+)
+
+#' Reporting progress (functional API)
+#'
+#' Reports progress to the user during long-running operations.
+#'
+#' This package exposes two distinct programming APIs for working with progress.
+#' Using \code{withProgress} with \code{incProgress} or \code{setProgress}
+#' provide a simple function-based interface, while the \code{\link{Progress}}
+#' reference class provides an object-oriented API.
+#'
+#' Use \code{withProgress} to wrap the scope of your work; doing so will cause a
+#' new progress panel to be created, and it will be displayed the first time
+#' \code{incProgress} or \code{setProgress} are called. When \code{withProgress}
+#' exits, the corresponding progress panel will be removed.
+#'
+#' The \code{incProgress} function increments the status bar by a specified
+#' amount, whereas the \code{setProgress} function sets it to a specific value,
+#' and can also set the text displayed.
+#'
+#' Generally, \code{withProgress}/\code{incProgress}/\code{setProgress} should
+#' be sufficient; the exception is if the work to be done is asynchronous (this
+#' is not common) or otherwise cannot be encapsulated by a single scope. In that
+#' case, you can use the \code{Progress} reference class.
+#'
+#' @param session The Shiny session object, as provided by \code{shinyServer} to
+#'   the server function. The default is to automatically find the session by
+#'   using the current reactive domain.
+#' @param expr The work to be done. This expression should contain calls to
+#'   \code{setProgress}.
+#' @param min The value that represents the starting point of the progress bar.
+#'   Must be less tham \code{max}. Default is 0.
+#' @param max The value that represents the end of the progress bar. Must be
+#'   greater than \code{min}. Default is 1.
+#' @param amount For \code{incProgress}, the amount to increment the status bar.
+#'   Default is 0.1.
+#' @param env The environment in which \code{expr} should be evaluated.
+#' @param quoted Whether \code{expr} is a quoted expression (this is not
+#'   common).
+#' @param message A single-element character vector; the message to be displayed
+#'   to the user, or \code{NULL} to hide the current message (if any).
+#' @param detail A single-element character vector; the detail message to be
+#'   displayed to the user, or \code{NULL} to hide the current detail message
+#'   (if any). The detail message will be shown with a de-emphasized appearance
+#'   relative to \code{message}.
+#' @param value Single-element numeric vector; the value at which to set the
+#'   progress bar, relative to \code{min} and \code{max}. \code{NULL} hides the
+#'   progress bar, if it is currently visible.
+#'
+#' @examples
+#' \dontrun{
+#' # server.R
+#' shinyServer(function(input, output) {
+#'   output$plot <- renderPlot({
+#'     withProgress(message = 'Calculation in progress',
+#'                  detail = 'This may take a while...', value = 0, {
+#'       for (i in 1:15) {
+#'         incProgress(1/15)
+#'         Sys.sleep(0.25)
+#'       }
+#'     })
+#'     plot(cars)
+#'   })
+#' })
+#' }
+#' @seealso \code{\link{Progress}}
+#' @rdname withProgress
+#' @export
+withProgress <- function(expr, min = 0, max = 1,
+                         value = min + (max - min) * 0.1,
+                         message = NULL, detail = NULL,
+                         session = getDefaultReactiveDomain(),
+                         env = parent.frame(), quoted = FALSE) {
+
+  if (!quoted)
+    expr <- substitute(expr)
+
+  if (!inherits(session, "ShinySession"))
+    stop("'session' is not a ShinySession object.")
+
+  p <- Progress$new(session, min = min, max = max)
+
+  session$progressStack$push(p)
+  on.exit({
+    session$progressStack$pop()
+    p$close()
+  })
+
+  p$set(value, message, detail)
+
+  eval(expr, env)
+}
+
+#' @rdname withProgress
+#' @export
+setProgress <- function(value = NULL, message = NULL, detail = NULL,
+                        session = getDefaultReactiveDomain()) {
+
+  if (!inherits(session, "ShinySession"))
+    stop("'session' is not a ShinySession object.")
+
+  if (session$progressStack$size() == 0) {
+    warning('setProgress was called outside of withProgress; ignoring')
+    return()
+  }
+
+  session$progressStack$peek()$set(value, message, detail)
+  invisible()
+}
+
+#' @rdname withProgress
+#' @export
+incProgress <- function(amount = 0.1, message = NULL, detail = NULL,
+                        session = getDefaultReactiveDomain()) {
+
+  if (!inherits(session, "ShinySession"))
+    stop("'session' is not a ShinySession object.")
+
+  if (session$progressStack$size() == 0) {
+    warning('incProgress was called outside of withProgress; ignoring')
+    return()
+  }
+
+  p <- session$progressStack$peek()
+  p$inc(amount, message, detail)
+  invisible()
+}

R/react.R

@@ -1,27 +1,31 @@
-Context <- setRefClass(
+Context <- R6Class(
   'Context',
-  fields = list(
-    id = 'character',
-    .label = 'character',      # For debug purposes
-    .invalidated = 'logical',
-    .invalidateCallbacks = 'list',
-    .flushCallbacks = 'list'
-  ),
-  methods = list(
-    initialize = function(label='', type='other', prevId='') {
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+    id = character(0),
+    .label = character(0),      # For debug purposes
+    .invalidated = FALSE,
+    .invalidateCallbacks = list(),
+    .flushCallbacks = list(),
+    .domain = NULL,
+
+    initialize = function(domain, label='', type='other', prevId='') {
       id <<- .getReactiveEnvironment()$nextId()
-      .invalidated <<- FALSE
-      .invalidateCallbacks <<- list()
-      .flushCallbacks <<- list()
       .label <<- label
-      .graphCreateContext(id, label, type, prevId)
+      .domain <<- domain
+      .graphCreateContext(id, label, type, prevId, domain)
     },
     run = function(func) {
       "Run the provided function under this context."
-      env <- .getReactiveEnvironment()
-      .graphEnterContext(id)
-      on.exit(.graphExitContext(id))
-      env$runWith(.self, func)
+      withReactiveDomain(.domain, {
+        env <- .getReactiveEnvironment()
+        .graphEnterContext(id)
+        tryCatch(
+          env$runWith(self, func),
+          finally = .graphExitContext(id)
+        )
+      })
     },
     invalidate = function() {
       "Invalidate this context. It will immediately call the callbacks
@@ -30,10 +34,11 @@ Context <- setRefClass(
         return()
       .invalidated <<- TRUE
 
-      .graphInvalidate(id)
+      .graphInvalidate(id, .domain)
       lapply(.invalidateCallbacks, function(func) {
         func()
       })
+      .invalidateCallbacks <<- list()
       NULL
     },
     onInvalidate = function(func) {
@@ -49,7 +54,7 @@ Context <- setRefClass(
     addPendingFlush = function(priority) {
       "Tell the reactive environment that this context should be flushed the
         next time flushReact() called."
-      .getReactiveEnvironment()$addPendingFlush(.self, priority)
+      .getReactiveEnvironment()$addPendingFlush(self, priority)
     },
     onFlush = function(func) {
       "Register a function to be called when this context is flushed."
@@ -58,32 +63,24 @@ Context <- setRefClass(
     executeFlushCallbacks = function() {
       "For internal use only."
       lapply(.flushCallbacks, function(func) {
-        withCallingHandlers({
-          func()
-        }, warning = function(e) {
-          # TODO: Callbacks in app
-        }, error = function(e) {
-          # TODO: Callbacks in app
-        })
+        func()
       })
     }
   )
 )
 
-ReactiveEnvironment <- setRefClass(
+ReactiveEnvironment <- R6Class(
   'ReactiveEnvironment',
-  fields = list(
-    .currentContext = 'ANY',
-    .nextId = 'integer',
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+    .currentContext = NULL,
+    .nextId = 0L,
     .pendingFlush = 'PriorityQueue',
-    .inFlush = 'logical'
-  ),
-  methods = list(
+    .inFlush = FALSE,
+
     initialize = function() {
-      .currentContext <<- NULL
-      .nextId <<- 0L
       .pendingFlush <<- PriorityQueue$new()
-      .inFlush <<- FALSE
     },
     nextId = function() {
       .nextId <<- .nextId + 1L
@@ -91,9 +88,13 @@ ReactiveEnvironment <- setRefClass(
     },
     currentContext = function() {
       if (is.null(.currentContext)) {
-        stop('Operation not allowed without an active reactive context. ',
-             '(You tried to do something that can only be done from inside a ',
-             'reactive function.)')
+        if (isTRUE(getOption('shiny.suppressMissingContextError'))) {
+          return(getDummyContext())
+        } else {
+          stop('Operation not allowed without an active reactive context. ',
+               '(You tried to do something that can only be done from inside a ',
+               'reactive expression or observer.)')
+        }
       }
       return(.currentContext)
     },
@@ -101,7 +102,7 @@ ReactiveEnvironment <- setRefClass(
       old.ctx <- .currentContext
       .currentContext <<- ctx
       on.exit(.currentContext <<- old.ctx)
-      func()
+      shinyCallingHandlers(func())
     },
     addPendingFlush = function(ctx, priority) {
       .pendingFlush$enqueue(ctx, priority)
@@ -120,10 +121,14 @@ ReactiveEnvironment <- setRefClass(
   )
 )
 
-.reactiveEnvironment <- ReactiveEnvironment$new()
-.getReactiveEnvironment <- function() {
-  .reactiveEnvironment
-}
+.getReactiveEnvironment <- local({
+  reactiveEnvironment <- NULL
+  function() {
+    if (is.null(reactiveEnvironment))
+      reactiveEnvironment <<- ReactiveEnvironment$new()
+    return(reactiveEnvironment)
+  }
+})
 
 # Causes any pending invalidations to run.
 flushReact <- function() {
@@ -135,3 +140,15 @@ flushReact <- function() {
 getCurrentContext <- function() {
   .getReactiveEnvironment()$currentContext()
 }
+
+getDummyContext <- function() {}
+local({
+  dummyContext <- NULL
+  getDummyContext <<- function() {
+    if (is.null(dummyContext)) {
+      dummyContext <<- Context$new(getDefaultReactiveDomain(), '[none]',
+        type='isolate')
+    }
+    return(dummyContext)
+  }
+})

R/reactive-domains.R

@@ -0,0 +1,253 @@
+#' @include globals.R
+NULL
+
+#
+# Over the last few months we've seen a number of cases where it'd be helpful
+# for objects that are instantiated within a Shiny app to know what Shiny
+# session they are "owned" by. I put "owned" in quotes because there isn't a
+# built-in notion of object ownership in Shiny today, any more than there is a
+# notion of one object owning another in R.
+#
+# But it's intuitive to everyone, I think, that the outputs for a session are
+# owned by that session, and any logic that is executed as part of the output
+# is done on behalf of that session. And it seems like in the vast majority of
+# cases, observers that are created inside a shinyServer function (i.e. one per
+# session) are also intuitively owned by the session that's starting up.
+#
+# This notion of ownership is important/helpful for a few scenarios that have
+# come up in recent months:
+#
+# 1. The showcase mode that Jonathan implemented recently highlights
+# observers/reactives as they execute. In order for sessions to only receive
+# highlights for their own code execution, we need to know which sessions own
+# which observers. 2. We've seen a number of apps crash out when observers
+# outlive their sessions and then try to do things with their sessions (the
+# most common error message was something like "Can't write to a closed
+# websocket", but we now silently ignore writes to closed websockets). It'd be
+# convenient for the default behavior of observers to be that they don't
+# outlive their parent sessions. 3. The reactive log visualizer currently
+# visualizes all reactivity in the process; it would be great if by default it
+# only visualized the current session. 4. When an observer has an error, it
+# would be great to be able to send the error to the session so it can do its
+# own handling (such as sending the error info to the client so the user can be
+# notified). 5. Shiny Server Pro wants to show the admin how much time is being
+# spent servicing each session.
+#
+# So what are the rules for establishing ownership?
+#
+# 1. Define the "current domain" as a global variable whose value will own any
+# newly created observer (by default). A domain is a reference class or
+# environment that contains the functions `onEnded(callback)`, `isEnded()`, and
+# `reactlog(logEntry)`.
+#
+## ------------------------------------------------------------------------
+createMockDomain <- function() {
+  callbacks <- list()
+  ended <- FALSE
+  domain <- new.env(parent = emptyenv())
+  domain$onEnded <- function(callback) {
+    callbacks <<- c(callbacks, callback)
+  }
+  domain$isEnded <- function() {
+    ended
+  }
+  domain$reactlog <- function(logEntry) NULL
+  domain$end <- function() {
+    if (!ended) {
+      ended <<- TRUE
+      lapply(callbacks, do.call, list())
+    }
+    invisible()
+  }
+  return(domain)
+}
+
+#
+# 2. The initial value of "current domain" is null.
+#
+## ------------------------------------------------------------------------
+.globals$domain <- NULL
+
+#
+# 3. Objects that can be owned include observers, reactive expressions,
+# invalidateLater instances, reactiveTimer instances. Whenever one of these is
+# created, by default its owner will be the current domain.
+#
+## ------------------------------------------------------------------------
+
+#' @name domains
+#' @rdname domains
+#' @export
+getDefaultReactiveDomain <- function() {
+  .globals$domain
+}
+
+#
+# 4. While a session is being created and the shinyServer function is executed,
+# the current domain is set to the new session. When the shinyServer function
+# is done executing, the previous value of the current domain is restored. This
+# is made foolproof using a `withReactiveDomain` function.
+#
+## ------------------------------------------------------------------------
+
+#' @rdname domains
+#' @export
+withReactiveDomain <- function(domain, expr) {
+  oldValue <- .globals$domain
+  .globals$domain <- domain
+  on.exit(.globals$domain <- oldValue)
+
+  expr
+}
+
+#
+# 5. While an observer or reactive expression is executing, the current domain
+# is set to the owner of the observer. When the observer completes, the
+# previous value of the current domain is restored.
+#
+# 6. Note that once created, an observer/reactive expression belongs to the
+# same domain forever, regardless of how many times it is invalidated and
+# re-executed, and regardless of what caused the invalidation to happen.
+#
+# 7. When a session ends, any observers that it owns are suspended, any
+# invalidateLater/reactiveTimers are stopped.
+#
+## ------------------------------------------------------------------------
+
+#' @rdname domains
+#' @export
+onReactiveDomainEnded <- function(domain, callback, failIfNull = FALSE) {
+  if (is.null(domain)) {
+    if (isTRUE(failIfNull))
+      stop("onReactiveDomainEnded called with null domain and failIfNull=TRUE")
+    else
+      return()
+  }
+  domain$onEnded(callback)
+}
+
+#
+# 8. If an uncaught error occurs while executing an observer, the session gets
+# a chance to handle it. I suppose the default behavior would be to send the
+# message to the client if possible, and then perhaps end the session (or not,
+# I could argue either way).
+#
+# The basic idea here is inspired by Node.js domains, which you can think of as
+# a way to track execution contexts across callback- or listener-oriented
+# asynchronous code. They use it to unify error handling code across a graph of
+# related objects. Our domains will be to unify both lifetime and error
+# handling across a graph of related reactive primitives.
+#
+# (You could imagine that as a client update is being processed, the session
+# associated with that client would become the current domain. IIRC this is how
+# showcase mode is implemented today. I don't think this would cover any cases
+# not covered by rule 5 above, and the absence of rule 5 would leave cases that
+# this rule would not cover.)
+#
+# Pitfalls/open issues:
+#
+# 1. Our current approach has the issue of observers staying alive longer than
+# they ought to. This proposal introduces the opposite risk: that
+# observers/invalidateLater/reactiveTimer instances, having implicitly been
+# assigned a parent, are suspended/disposed earlier than they ought to have
+# been. I find this especially worrisome for invalidateLater/reactiveTimer,
+# which will often be called in a reactive expression, and thus execute under
+# unpredictable circumstances. Perhaps those should continue to accept an
+# explicit "session=" parameter that the user is warned about if they don't
+# provide a value.
+#
+# 2. Are there situations where it is ambiguous what the right thing to do is,
+# and we should warn/error to ask the user to provide a domain explicitly?
+#
+## ------------------------------------------------------------------------
+
+#' Reactive domains
+#'
+#' Reactive domains are a mechanism for establishing ownership over reactive
+#' primitives (like reactive expressions and observers), even if the set of
+#' reactive primitives is dynamically created. This is useful for lifetime
+#' management (i.e. destroying observers when the Shiny session that created
+#' them ends) and error handling.
+#'
+#' At any given time, there can be either a single "default" reactive domain
+#' object, or none (i.e. the reactive domain object is \code{NULL}). You can
+#' access the current default reactive domain by calling
+#' \code{getDefaultReactiveDomain}.
+#'
+#' Unless you specify otherwise, newly created observers and reactive
+#' expressions will be assigned to the current default domain (if any). You can
+#' override this assignment by providing an explicit \code{domain} argument to
+#' \code{\link{reactive}} or \code{\link{observe}}.
+#'
+#' For advanced usage, it's possible to override the default domain using
+#' \code{withReactiveDomain}. The \code{domain} argument will be made the
+#' default domain while \code{expr} is evaluated.
+#'
+#' Implementers of new reactive primitives can use \code{onReactiveDomainEnded}
+#' as a convenience function for registering callbacks. If the reactive domain
+#' is \code{NULL} and \code{failIfNull} is \code{FALSE}, then the callback will
+#' never be invoked.
+#'
+#' @name domains
+#' @param domain A valid domain object (for example, a Shiny session), or
+#'   \code{NULL}
+#' @param expr An expression to evaluate under \code{domain}
+#' @param callback A callback function to be invoked
+#' @param failIfNull If \code{TRUE} then an error is given if the \code{domain}
+#'   is \code{NULL}
+NULL
+
+#
+# Example 1
+# ---
+# ```
+# obs1 <- observe({
+# })
+# shinyServer(function(input, output) {
+#   obs2 <- observe({
+#     obs3 <- observe({
+#     })
+#   })
+# })
+# # obs1 would have no domain, obs2 and obs3 would be owned by the session
+# ```
+#
+# Example 2
+# ---
+# ```
+# globalValues <- reactiveValues(broadcast="")
+# shinyServer(function(input, output) {
+#   sessionValues <- reactiveValues()
+#   output$messageOutput <- renderText({
+#     globalValues$broadcast
+#     obs1 <- observe({...})
+#   })
+#   observe({
+#     if (input$goButton == 0) return()
+#     isolate( globalValues$broadcast <- input$messageInput )
+#   })
+# })
+# # The observer behind messageOutput would be owned by the session,
+# # as would all the many instances of obs1 that were created.
+# ```
+# ---
+#
+# Example 3
+# ---
+# ```
+# rexpr1 <- reactive({
+#   invalidateLater(1000)
+#   obs1 <- observe({...})
+# })
+# observeSomething <- function() {
+#   obs2 <- observe({...})
+# })
+# shinyServer(function(input, output) {
+#   obs3 <- observe({
+#     observeSomething()
+#     rexpr1()
+#   })
+# })
+# # rexpr1, the invalidateLater call, and obs1 would all have no owner;
+# # obs2 and obs3 would be owned by the session.
+# ```

R/render-plot.R

@@ -0,0 +1,591 @@
+#' Plot Output
+#'
+#' Renders a reactive plot that is suitable for assigning to an \code{output}
+#' slot.
+#'
+#' The corresponding HTML output tag should be \code{div} or \code{img} and have
+#' the CSS class name \code{shiny-plot-output}.
+#'
+#' @seealso For the corresponding client-side output function, and example
+#'   usage, see \code{\link{plotOutput}}. For more details on how the plots are
+#'   generated, and how to control the output, see \code{\link{plotPNG}}.
+#'
+#' @param expr An expression that generates a plot.
+#' @param width,height The width/height of the rendered plot, in pixels; or
+#'   \code{'auto'} to use the \code{offsetWidth}/\code{offsetHeight} of the HTML
+#'   element that is bound to this plot. You can also pass in a function that
+#'   returns the width/height in pixels or \code{'auto'}; in the body of the
+#'   function you may reference reactive values and functions. When rendering an
+#'   inline plot, you must provide numeric values (in pixels) to both
+#'   \code{width} and \code{height}.
+#' @param res Resolution of resulting plot, in pixels per inch. This value is
+#'   passed to \code{\link{png}}. Note that this affects the resolution of PNG
+#'   rendering in R; it won't change the actual ppi of the browser.
+#' @param ... Arguments to be passed through to \code{\link[grDevices]{png}}.
+#'   These can be used to set the width, height, background color, etc.
+#' @param env The environment in which to evaluate \code{expr}.
+#' @param quoted Is \code{expr} a quoted expression (with \code{quote()})? This
+#'   is useful if you want to save an expression in a variable.
+#' @param func A function that generates a plot (deprecated; use \code{expr}
+#'   instead).
+#'
+#' @export
+renderPlot <- function(expr, width='auto', height='auto', res=72, ...,
+                       env=parent.frame(), quoted=FALSE, func=NULL) {
+  if (!is.null(func)) {
+    shinyDeprecated(msg="renderPlot: argument 'func' is deprecated. Please use 'expr' instead.")
+  } else {
+    installExprFunction(expr, "func", env, quoted)
+  }
+
+  args <- list(...)
+
+  if (is.function(width))
+    widthWrapper <- reactive({ width() })
+  else
+    widthWrapper <- NULL
+
+  if (is.function(height))
+    heightWrapper <- reactive({ height() })
+  else
+    heightWrapper <- NULL
+
+  # If renderPlot isn't going to adapt to the height of the div, then the
+  # div needs to adapt to the height of renderPlot. By default, plotOutput
+  # sets the height to 400px, so to make it adapt we need to override it
+  # with NULL.
+  outputFunc <- plotOutput
+  if (!identical(height, 'auto')) formals(outputFunc)['height'] <- list(NULL)
+
+  return(markRenderFunction(outputFunc, function(shinysession, name, ...) {
+    if (!is.null(widthWrapper))
+      width <- widthWrapper()
+    if (!is.null(heightWrapper))
+      height <- heightWrapper()
+
+    # Note that these are reactive calls. A change to the width and height
+    # will inherently cause a reactive plot to redraw (unless width and
+    # height were explicitly specified).
+    prefix <- 'output_'
+    if (width == 'auto')
+      width <- shinysession$clientData[[paste(prefix, name, '_width', sep='')]];
+    if (height == 'auto')
+      height <- shinysession$clientData[[paste(prefix, name, '_height', sep='')]];
+
+    if (is.null(width) || is.null(height) || width <= 0 || height <= 0)
+      return(NULL)
+
+    # Resolution multiplier
+    pixelratio <- shinysession$clientData$pixelratio
+    if (is.null(pixelratio))
+      pixelratio <- 1
+
+    coordmap <- NULL
+    plotFunc <- function() {
+      # Actually perform the plotting
+      result <- withVisible(func())
+
+      coordmap <<- NULL
+
+      if (result$visible) {
+        # Use capture.output to squelch printing to the actual console; we
+        # are only interested in plot output
+
+        # Special case for ggplot objects - need to capture coordmap
+        if (inherits(result$value, "ggplot")) {
+          utils::capture.output(coordmap <<- getGgplotCoordmap(result$value, pixelratio))
+        } else {
+          utils::capture.output(print(result$value))
+        }
+      }
+
+      if (is.null(coordmap)) {
+        coordmap <<- getPrevPlotCoordmap(width, height)
+      }
+    }
+
+    outfile <- do.call(plotPNG, c(plotFunc, width=width*pixelratio,
+                                  height=height*pixelratio, res=res*pixelratio, args))
+    on.exit(unlink(outfile))
+
+    # A list of attributes for the img
+    res <- list(
+      src=shinysession$fileUrl(name, outfile, contentType='image/png'),
+      width=width, height=height, coordmap=coordmap
+    )
+
+    # Get error message if present (from attribute on the coordmap)
+    error <- attr(coordmap, "error", exact = TRUE)
+    if (!is.null(error)) {
+      res$error <- error
+    }
+
+    res
+  }))
+}
+
+# The coordmap extraction functions below return something like the examples
+# below. For base graphics:
+# plot(mtcars$wt, mtcars$mpg)
+# str(getPrevPlotCoordmap(400, 300))
+# List of 1
+#  $ :List of 4
+#   ..$ domain :List of 4
+#   .. ..$ left  : num 1.36
+#   .. ..$ right : num 5.58
+#   .. ..$ bottom: num 9.46
+#   .. ..$ top   : num 34.8
+#   ..$ range  :List of 4
+#   .. ..$ left  : num 50.4
+#   .. ..$ right : num 373
+#   .. ..$ bottom: num 199
+#   .. ..$ top   : num 79.6
+#   ..$ log    :List of 2
+#   .. ..$ x: NULL
+#   .. ..$ y: NULL
+#   ..$ mapping: Named list()
+#
+# For ggplot2, it might be something like:
+# p <- ggplot(mtcars, aes(wt, mpg)) + geom_point()
+# str(getGgplotCoordmap(p, 1))
+# List of 1
+#  $ :List of 10
+#   ..$ panel     : int 1
+#   ..$ row       : int 1
+#   ..$ col       : int 1
+#   ..$ panel_vars: Named list()
+#   ..$ scale_x   : int 1
+#   ..$ scale_y   : int 1
+#   ..$ log       :List of 2
+#   .. ..$ x: NULL
+#   .. ..$ y: NULL
+#   ..$ domain    :List of 4
+#   .. ..$ left  : num 1.32
+#   .. ..$ right : num 5.62
+#   .. ..$ bottom: num 9.22
+#   .. ..$ top   : num 35.1
+#   ..$ mapping   :List of 2
+#   .. ..$ x: chr "wt"
+#   .. ..$ y: chr "mpg"
+#   ..$ range     :List of 4
+#   .. ..$ left  : num 40.8
+#   .. ..$ right : num 446
+#   .. ..$ bottom: num 263
+#   .. ..$ top   : num 14.4
+#
+# With a faceted ggplot2 plot, the outer list contains two objects, each of
+# which represents one panel. In this example, there is one panelvar, but there
+# can be up to two of them.
+# mtc <- mtcars
+# mtc$am <- factor(mtc$am)
+# p <- ggplot(mtcars, aes(wt, mpg)) + geom_point() + facet_wrap(~ am)
+# str(getGgplotCoordmap(p, 1))
+# List of 2
+#  $ :List of 10
+#   ..$ panel     : int 1
+#   ..$ row       : int 1
+#   ..$ col       : int 1
+#   ..$ panel_vars:List of 1
+#   .. ..$ panelvar1: Factor w/ 2 levels "0","1": 1
+#   ..$ scale_x   : int 1
+#   ..$ scale_y   : int 1
+#   ..$ log       :List of 2
+#   .. ..$ x: NULL
+#   .. ..$ y: NULL
+#   ..$ domain    :List of 4
+#   .. ..$ left  : num 1.32
+#   .. ..$ right : num 5.62
+#   .. ..$ bottom: num 9.22
+#   .. ..$ top   : num 35.1
+#   ..$ mapping   :List of 3
+#   .. ..$ x        : chr "wt"
+#   .. ..$ y        : chr "mpg"
+#   .. ..$ panelvar1: chr "am"
+#   ..$ range     :List of 4
+#   .. ..$ left  : num 45.6
+#   .. ..$ right : num 317
+#   .. ..$ bottom: num 251
+#   .. ..$ top   : num 35.7
+#  $ :List of 10
+#   ..$ panel     : int 2
+#   ..$ row       : int 1
+#   ..$ col       : int 2
+#   ..$ panel_vars:List of 1
+#   .. ..$ panelvar1: Factor w/ 2 levels "0","1": 2
+#   ..$ scale_x   : int 1
+#   ..$ scale_y   : int 1
+#   ..$ log       :List of 2
+#   .. ..$ x: NULL
+#   .. ..$ y: NULL
+#   ..$ domain    :List of 4
+#   .. ..$ left  : num 1.32
+#   .. ..$ right : num 5.62
+#   .. ..$ bottom: num 9.22
+#   .. ..$ top   : num 35.1
+#   ..$ mapping   :List of 3
+#   .. ..$ x        : chr "wt"
+#   .. ..$ y        : chr "mpg"
+#   .. ..$ panelvar1: chr "am"
+#   ..$ range     :List of 4
+#   .. ..$ left  : num 322
+#   .. ..$ right : num 594
+#   .. ..$ bottom: num 251
+#   .. ..$ top   : num 35.7
+
+
+# Get a coordmap for the previous plot made with base graphics.
+# Requires width and height of output image, in pixels.
+# Must be called before the graphics device is closed.
+getPrevPlotCoordmap <- function(width, height) {
+  usrCoords <- graphics::par('usr')
+  usrBounds <- usrCoords
+  if (graphics::par('xlog')) {
+    usrBounds[c(1,2)] <- 10 ^ usrBounds[c(1,2)]
+  }
+  if (graphics::par('ylog')) {
+    usrBounds[c(3,4)] <- 10 ^ usrBounds[c(3,4)]
+  }
+
+  # Wrapped in double list because other types of plots can have multiple panels.
+  list(list(
+    # Bounds of the plot area, in data space
+    domain = list(
+      left = usrCoords[1],
+      right = usrCoords[2],
+      bottom = usrCoords[3],
+      top = usrCoords[4]
+    ),
+    # The bounds of the plot area, in DOM pixels
+    range = list(
+      left = graphics::grconvertX(usrBounds[1], 'user', 'nfc') * width,
+      right = graphics::grconvertX(usrBounds[2], 'user', 'nfc') * width,
+      bottom = (1-graphics::grconvertY(usrBounds[3], 'user', 'nfc')) * height - 1,
+      top = (1-graphics::grconvertY(usrBounds[4], 'user', 'nfc')) * height - 1
+    ),
+    log = list(
+      x = if (graphics::par('xlog')) 10 else NULL,
+      y = if (graphics::par('ylog')) 10 else NULL
+    ),
+    # We can't extract the original variable names from a base graphic.
+    # `mapping` is an empty _named_ list, so that it is converted to an object
+    # (not an array) in JSON.
+    mapping = list(x = NULL)[0]
+  ))
+}
+
+# Print a ggplot object and return a coordmap for it.
+getGgplotCoordmap <- function(p, pixelratio) {
+  if (!inherits(p, "ggplot"))
+    return(NULL)
+
+  # A modified version of print.ggplot which returns the built ggplot object as
+  # well as the gtable grob. This overrides the ggplot::print.ggplot method, but
+  # only within the context of getGgplotCoordmap. The reason this needs to be an
+  # (pseudo) S3 method is so that, if an object has a class in addition to
+  # ggplot, and there's a print method for that class, that we won't override
+  # that method.
+  # https://github.com/rstudio/shiny/issues/841
+  print.ggplot <- function(x) {
+    grid::grid.newpage()
+
+    build <- ggplot2::ggplot_build(x)
+
+    gtable <- ggplot2::ggplot_gtable(build)
+    grid::grid.draw(gtable)
+
+    list(
+      build = build,
+      gtable = gtable
+    )
+  }
+
+  # Given the name of a generic function and an object, return the class name
+  # for the method that would be used on the object.
+  which_method <- function(generic, x) {
+    classes <- class(x)
+    method_names <- paste(generic, classes, sep = ".")
+    idx <- which(method_names %in% utils::methods(generic))
+
+    if (length(idx) == 0)
+      return(NULL)
+
+    # Return name of first class with matching method
+    classes[idx[1]]
+  }
+
+
+  # Given a built ggplot object, return x and y domains (data space coords) for
+  # each panel.
+  find_panel_info <- function(b) {
+    layout <- b$panel$layout
+    # Convert factor to numbers
+    layout$PANEL <- as.integer(as.character(layout$PANEL))
+
+    # Names of facets
+    facet <- b$plot$facet
+    facet_vars <- NULL
+    if (inherits(facet, "grid")) {
+      facet_vars <- vapply(c(facet$cols, facet$rows), as.character, character(1))
+    } else if (inherits(facet, "wrap")) {
+      facet_vars <- vapply(facet$facets, as.character, character(1))
+    }
+
+    # Iterate over each row in the layout data frame
+    lapply(seq_len(nrow(layout)), function(i) {
+      # Slice out one row
+      l <- layout[i, ]
+
+      scale_x <- l$SCALE_X
+      scale_y <- l$SCALE_Y
+
+      mapping <- find_plot_mappings(b)
+
+      # For each of the faceting variables, get the value of that variable in
+      # the current panel. Default to empty _named_ list so that it's sent as a
+      # JSON object, not array.
+      panel_vars <- list(a = NULL)[0]
+      for (i in seq_along(facet_vars)) {
+        var_name <- facet_vars[[i]]
+        vname <- paste0("panelvar", i)
+
+        mapping[[vname]] <- var_name
+        panel_vars[[vname]] <- l[[var_name]]
+      }
+
+      list(
+        panel   = l$PANEL,
+        row     = l$ROW,
+        col     = l$COL,
+        panel_vars = panel_vars,
+        scale_x = scale_x,
+        scale_y = scale_x,
+        log     = check_log_scales(b, scale_x, scale_y),
+        domain  = find_panel_domain(b, l$PANEL, scale_x, scale_y),
+        mapping = mapping
+      )
+    })
+  }
+
+  # Given a single range object (representing the data domain) from a built
+  # ggplot object, return the domain.
+  find_panel_domain <- function(b, panel_num, scalex_num = 1, scaley_num = 1) {
+    range <- b$panel$ranges[[panel_num]]
+    res <- list(
+      left   = range$x.range[1],
+      right  = range$x.range[2],
+      bottom = range$y.range[1],
+      top    = range$y.range[2]
+    )
+
+    # Check for reversed scales
+    xscale <- b$panel$x_scales[[scalex_num]]
+    yscale <- b$panel$y_scales[[scaley_num]]
+
+    if (!is.null(xscale$trans) && xscale$trans$name == "reverse") {
+      res$left  <- -res$left
+      res$right <- -res$right
+    }
+    if (!is.null(yscale$trans) && yscale$trans$name == "reverse") {
+      res$top    <- -res$top
+      res$bottom <- -res$bottom
+    }
+
+    res
+  }
+
+  # Given built ggplot object, return object with the log base for x and y if
+  # there are log scales or coord transforms.
+  check_log_scales <- function(b, scalex_num = 1, scaley_num = 1) {
+
+    # Given a vector of transformation names like c("log-10", "identity"),
+    # return the first log base, like 10. If none are present, return NULL.
+    extract_log_base <- function(names) {
+      names <- names[grepl("^log-", names)]
+
+      if (length(names) == 0)
+        return(NULL)
+
+      names <- names[1]
+
+      as.numeric(sub("^log-", "", names))
+    }
+
+    # Look for log scales and log coord transforms. People shouldn't use both.
+    x_names <- character(0)
+    y_names <- character(0)
+
+    # Continuous scales have a trans; discrete ones don't
+    if (!is.null(b$panel$x_scales[[scalex_num]]$trans))
+      x_names <- b$panel$x_scales[[scalex_num]]$trans$name
+    if (!is.null(b$panel$y_scales[[scaley_num]]$trans))
+      y_names <- b$panel$y_scales[[scaley_num]]$trans$name
+
+    coords <- b$plot$coordinates
+    if (!is.null(coords$trans)) {
+      if (!is.null(coords$trans$x))
+        x_names <- c(x_names, coords$trans$x$name)
+      if (!is.null(coords$trans$y))
+        y_names <- c(y_names, coords$trans$y$name)
+    }
+
+    # Keep only scale/trans names that start with "log-"
+    x_names <- x_names[grepl("^log-", x_names)]
+    y_names <- y_names[grepl("^log-", y_names)]
+
+    # Extract the log base from the trans name -- a string like "log-10".
+    list(
+      x = extract_log_base(x_names),
+      y = extract_log_base(y_names)
+    )
+  }
+
+  # Given a built ggplot object, return a named list of variables mapped to x
+  # and y. This function will be called for each panel, but in practice the
+  # result is always the same across panels, so we'll cache the result.
+  mappings_cache <- NULL
+  find_plot_mappings <- function(b) {
+    if (!is.null(mappings_cache))
+      return(mappings_cache)
+
+    # lapply'ing as.character results in unexpected behavior for expressions
+    # like `wt/2`. This works better.
+    mappings <- as.list(as.character(b$plot$mapping))
+
+    # If x or y mapping is missing, look in each layer for mappings and return
+    # the first one.
+    missing_mappings <- setdiff(c("x", "y"), names(mappings))
+    if (length(missing_mappings) != 0) {
+      # Grab mappings for each layer
+      layer_mappings <- lapply(b$plot$layers, function(layer) {
+        lapply(layer$mapping, as.character)
+      })
+
+      # Get just the first x or y value in the combined list of plot and layer
+      # mappings.
+      mappings <- c(list(mappings), layer_mappings)
+      mappings <- Reduce(x = mappings, init = list(x = NULL, y = NULL),
+        function(init, m) {
+          if (is.null(init$x) && !is.null(m$x)) init$x <- m$x
+          if (is.null(init$y) && !is.null(m$y)) init$y <- m$y
+          init
+        }
+      )
+    }
+
+    mappings_cache <<- mappings
+    mappings
+  }
+
+  # Given a gtable object, return the x and y ranges (in pixel dimensions)
+  find_panel_ranges <- function(g, pixelratio) {
+    # Given a vector of unit objects, return logical vector indicating which ones
+    # are "null" units. These units use the remaining available width/height --
+    # that is, the space not occupied by elements that have an absolute size.
+    is_null_unit <- function(x) {
+      vapply(x, FUN.VALUE = logical(1), function(u) {
+        isTRUE(attr(u, "unit", exact = TRUE) == "null")
+      })
+    }
+
+    # Convert a unit (or vector of units) to a numeric vector of pixel sizes
+    h_px <- function(x) as.numeric(grid::convertHeight(x, "native"))
+    w_px <- function(x) as.numeric(grid::convertWidth(x, "native"))
+
+    # Given a vector of relative sizes (in grid units), and a function for
+    # converting grid units to numeric pixels, return a numeric vector of
+    # pixel sizes.
+    find_px_sizes <- function(rel_sizes, unit_to_px) {
+      # Total pixels (in height or width)
+      total_px <- unit_to_px(grid::unit(1, "npc"))
+      # Calculate size of all panel(s) together. Panels (and only panels) have
+      # null size.
+      null_idx <- is_null_unit(rel_sizes)
+      # All the absolute heights. At this point, null heights are 0. We need to
+      # calculate them separately and add them in later.
+      px_sizes <- unit_to_px(rel_sizes)
+      # Total size for panels is image size minus absolute (non-panel) elements
+      panel_px_total <- total_px - sum(px_sizes)
+      # Divide up the total panel size up into the panels (scaled by size)
+      panel_sizes_rel <- as.numeric(rel_sizes[null_idx])
+      panel_sizes_rel <- panel_sizes_rel / sum(panel_sizes_rel)
+      px_sizes[null_idx] <- panel_px_total * panel_sizes_rel
+      abs(px_sizes)
+    }
+
+    px_heights <- find_px_sizes(g$heights, h_px)
+    px_widths <- find_px_sizes(g$widths, w_px)
+
+    # Convert to absolute pixel positions
+    x_pos <- cumsum(px_widths)
+    y_pos <- cumsum(px_heights)
+
+    # Match up the pixel dimensions to panels
+    layout <- g$layout
+    # For panels:
+    # * For facet_wrap, they'll be named "panel-1", "panel-2", etc.
+    # * For no facet or facet_grid, they'll just be named "panel". For
+    #   facet_grid, we need to re-order the layout table. Assume that panel
+    #   numbers go from left to right, then next row.
+    # Assign a number to each panel, corresponding to PANEl in the built ggplot
+    # object.
+    layout <- layout[grepl("^panel", layout$name), ]
+    layout <- layout[order(layout$t, layout$l), ]
+    layout$panel <- seq_len(nrow(layout))
+
+    # When using a HiDPI client on a Linux server, the pixel
+    # dimensions are doubled, so we have to divide the dimensions by
+    # `pixelratio`. When a HiDPI client is used on a Mac server (with
+    # the quartz device), the pixel dimensions _aren't_ doubled, even though
+    # the image has double size. In the latter case we don't have to scale the
+    # numbers down.
+    pix_ratio <- 1
+    if (!grepl("^quartz", names(grDevices::dev.cur()))) {
+      pix_ratio <- pixelratio
+    }
+
+    # Return list of lists, where each inner list has left, right, top, bottom
+    # values for a panel
+    lapply(seq_len(nrow(layout)), function(i) {
+      p <- layout[i, , drop = FALSE]
+      list(
+        left   = x_pos[p$l - 1] / pix_ratio,
+        right  = x_pos[p$r] / pix_ratio,
+        bottom = y_pos[p$b] / pix_ratio,
+        top    = y_pos[p$t - 1] / pix_ratio
+      )
+    })
+  }
+
+  # If print(p) gets dispatched to print.ggplot(p), attempt to extract coordmap.
+  # If dispatched to another method, just print the object and don't attempt to
+  # extract the coordmap. This can happen if there's another print method that
+  # takes precedence.
+  if (identical(which_method("print", p), "ggplot")) {
+    res <- print(p)
+
+    tryCatch({
+      # Get info from built ggplot object
+      info <- find_panel_info(res$build)
+
+      # Get ranges from gtable - it's possible for this to return more elements than
+      # info, because it calculates positions even for panels that aren't present.
+      # This can happen with facet_wrap.
+      ranges <- find_panel_ranges(res$gtable, pixelratio)
+
+      for (i in seq_along(info)) {
+        info[[i]]$range <- ranges[[i]]
+      }
+
+      return(info)
+
+    }, error = function(e) {
+      # If there was an error extracting info from the ggplot object, just return
+      # a list with the error message.
+      return(structure(list(), error = e$message))
+    })
+
+  } else {
+    print(p)
+    return(list())
+  }
+}

R/run-url.R

@@ -1,124 +1,35 @@
-#' Run a Shiny application from https://gist.github.com
-#'
-#' Download and launch a Shiny application that is hosted on GitHub as a gist.
-#'
-#' @param gist The identifier of the gist. For example, if the gist is
-#'   https://gist.github.com/jcheng5/3239667, then \code{3239667},
-#'   \code{'3239667'}, and \code{'https://gist.github.com/jcheng5/3239667'}
-#'   are all valid values.
-#' @param port The TCP port that the application should listen on. Defaults to
-#'   port 8100.
-#' @param launch.browser If true, the system's default web browser will be
-#'   launched automatically after the app is started. Defaults to true in
-#'   interactive sessions only.
-#'
-#' @examples
-#' \dontrun{
-#' runGist(3239667)
-#' runGist("https://gist.github.com/jcheng5/3239667")
-#'
-#' # Old URL format without username
-#' runGist("https://gist.github.com/3239667")
-#' }
-#'
-#' @export
-runGist <- function(gist,
-                    port=8100L,
-                    launch.browser=getOption('shiny.launch.browser',
-                                             interactive())) {
-
-  gistUrl <- if (is.numeric(gist) || grepl('^[0-9a-f]+$', gist)) {
-    sprintf('https://gist.github.com/%s/download', gist)
-  } else if(grepl('^https://gist.github.com/([^/]+/)?([0-9a-f]+)$', gist)) {
-    paste(gist, '/download', sep='')
-  } else {
-    stop('Unrecognized gist identifier format')
-  }
-
-  runUrl(gistUrl, filetype=".tar.gz", subdir=NULL, port=port,
-    launch.browser=launch.browser)
-}
-
-
-#' Run a Shiny application from a GitHub repository
-#'
-#' Download and launch a Shiny application that is hosted in a GitHub repository.
-#'
-#' @param repo Name of the repository
-#' @param username GitHub username
-#' @param ref Desired git reference. Could be a commit, tag, or branch
-#'   name. Defaults to \code{"master"}.
-#' @param subdir A subdirectory in the repository that contains the app. By
-#'   default, this function will run an app from the top level of the repo, but
-#'   you can use a path such as `\code{"inst/shinyapp"}.
-#' @param port The TCP port that the application should listen on. Defaults to
-#'   port 8100.
-#' @param launch.browser If true, the system's default web browser will be
-#'   launched automatically after the app is started. Defaults to true in
-#'   interactive sessions only.
-#'
-#' @examples
-#' \dontrun{
-#' runGitHub("shiny_example", "rstudio")
-#'
-#' # Can run an app from a subdirectory in the repo
-#' runGitHub("shiny_example", "rstudio", subdir = "inst/shinyapp/")
-#' }
-#'
-#' @export
-runGitHub <- function(repo, username = getOption("github.user"),
-  ref = "master", subdir = NULL, port = 8100,
-  launch.browser = getOption('shiny.launch.browser', interactive())) {
-
-  if (is.null(ref)) {
-    stop("Must specify either a ref. ")
-  }
-
-  message("Downloading github repo(s) ",
-    paste(repo, ref, sep = "/", collapse = ", "),
-    " from ",
-    paste(username, collapse = ", "))
-  name <- paste(username, "-", repo, sep = "")
-
-  url <- paste("https://github.com/", username, "/", repo, "/archive/",
-    ref, ".tar.gz", sep = "")
-
-  runUrl(url, subdir=subdir, port=port, launch.browser=launch.browser)
-}
-
-
 #' Run a Shiny application from a URL
 #'
-#' Download and launch a Shiny application that is hosted at a downloadable
-#' URL. The Shiny application must be saved in a .zip, .tar, or .tar.gz file.
-#' The Shiny application files must be contained in a subdirectory in the
-#' archive. For example, the files might be \code{myapp/server.r} and
-#' \code{myapp/ui.r}.
-#'
+#' \code{runUrl()} downloads and launches a Shiny application that is hosted at
+#' a downloadable URL. The Shiny application must be saved in a .zip, .tar, or
+#' .tar.gz file. The Shiny application files must be contained in the root
+#' directory or a subdirectory in the archive. For example, the files might be
+#' \code{myapp/server.r} and \code{myapp/ui.r}. The functions \code{runGitHub()}
+#' and \code{runGist()} are based on \code{runUrl()}, using URL's from GitHub
+#' (\url{https://github.com}) and GitHub gists (\url{https://gist.github.com}),
+#' respectively.
 #' @param url URL of the application.
 #' @param filetype The file type (\code{".zip"}, \code{".tar"}, or
 #'   \code{".tar.gz"}. Defaults to the file extension taken from the url.
 #' @param subdir A subdirectory in the repository that contains the app. By
 #'   default, this function will run an app from the top level of the repo, but
 #'   you can use a path such as `\code{"inst/shinyapp"}.
-#' @param port The TCP port that the application should listen on. Defaults to
-#'   port 8100.
-#' @param launch.browser If true, the system's default web browser will be
-#'   launched automatically after the app is started. Defaults to true in
-#'   interactive sessions only.
-#'
-#' @examples
-#' \dontrun{
-#' runUrl('https://github.com/rstudio/shiny_example/archive/master.tar.gz')
-#'
-#' # Can run an app from a subdirectory in the archive
-#' runUrl("https://github.com/rstudio/shiny_example/archive/master.zip",
-#'  subdir = "inst/shinyapp/")
-#' }
-#'
+#' @param destdir Directory to store the downloaded application files. If \code{NULL}
+#'   (the default), the application files will be stored in a temporary directory
+#'   and removed when the app exits
+#' @param ... Other arguments to be passed to \code{\link{runApp}()}, such as
+#'   \code{port} and \code{launch.browser}.
 #' @export
-runUrl <- function(url, filetype = NULL, subdir = NULL, port = 8100,
-  launch.browser = getOption('shiny.launch.browser', interactive())) {
+#' @examples
+#' ## Only run this example in interactive R sessions
+#'   if (interactive()) {
+#'   runUrl('https://github.com/rstudio/shiny_example/archive/master.tar.gz')
+#'
+#'   # Can run an app from a subdirectory in the archive
+#'   runUrl("https://github.com/rstudio/shiny_example/archive/master.zip",
+#'     subdir = "inst/shinyapp/")
+#' }
+runUrl <- function(url, filetype = NULL, subdir = NULL, destdir = NULL, ...) {
 
   if (!is.null(subdir) && ".." %in% strsplit(subdir, '/')[[1]])
     stop("'..' not allowed in subdir")
@@ -136,7 +47,15 @@ runUrl <- function(url, filetype = NULL, subdir = NULL, port = 8100,
     stop("Unknown file extension.")
 
   message("Downloading ", url)
-  filePath <- tempfile('shinyapp', fileext=fileext)
+  if (is.null(destdir)) {
+    filePath <- tempfile('shinyapp', fileext = fileext)
+    fileDir  <- tempfile('shinyapp')
+  } else {
+    fileDir <- destdir
+    filePath <- paste(destdir, fileext)
+  }
+
+  dir.create(fileDir, showWarnings = FALSE)
   if (download(url, filePath, mode = "wb", quiet = TRUE) != 0)
     stop("Failed to download URL ", url)
   on.exit(unlink(filePath))
@@ -148,17 +67,83 @@ runUrl <- function(url, filetype = NULL, subdir = NULL, port = 8100,
     #   2) If the internal untar implementation is used, it chokes on the 'g'
     #      type flag that github uses (to stash their commit hash info).
     # By using our own forked/modified untar2 we sidestep both issues.
-    dirname <- untar2(filePath, list=TRUE)[1]
-    untar2(filePath, exdir = dirname(filePath))
+    first <- untar2(filePath, list=TRUE)[1]
+    untar2(filePath, exdir = fileDir)
 
   } else if (fileext == ".zip") {
-    dirname <- as.character(unzip(filePath, list=TRUE)$Name[1])
-    unzip(filePath, exdir = dirname(filePath))
+    first <- as.character(utils::unzip(filePath, list=TRUE)$Name)[1]
+    utils::unzip(filePath, exdir = fileDir)
   }
 
-  appdir <- file.path(dirname(filePath), dirname)
-  on.exit(unlink(appdir, recursive = TRUE), add = TRUE)
+  if(is.null(destdir)){
+    on.exit(unlink(fileDir, recursive = TRUE), add = TRUE)
+  }
 
-  appsubdir <- ifelse(is.null(subdir), appdir, file.path(appdir, subdir))
-  runApp(appsubdir, port=port, launch.browser=launch.browser)
+  appdir <- file.path(fileDir, first)
+  if (!utils::file_test('-d', appdir)) appdir <- dirname(appdir)
+
+  if (!is.null(subdir)) appdir <- file.path(appdir, subdir)
+  runApp(appdir, ...)
+}
+
+#' @rdname runUrl
+#' @param gist The identifier of the gist. For example, if the gist is
+#'   https://gist.github.com/jcheng5/3239667, then \code{3239667},
+#'   \code{'3239667'}, and \code{'https://gist.github.com/jcheng5/3239667'} are
+#'   all valid values.
+#' @export
+#' @examples
+#' ## Only run this example in interactive R sessions
+#' if (interactive()) {
+#'   runGist(3239667)
+#'   runGist("https://gist.github.com/jcheng5/3239667")
+#'
+#'   # Old URL format without username
+#'   runGist("https://gist.github.com/3239667")
+#' }
+#'
+runGist <- function(gist, destdir = NULL, ...) {
+
+  gistUrl <- if (is.numeric(gist) || grepl('^[0-9a-f]+$', gist)) {
+    sprintf('https://gist.github.com/%s/download', gist)
+  } else if(grepl('^https://gist.github.com/([^/]+/)?([0-9a-f]+)$', gist)) {
+    paste(gist, '/download', sep='')
+  } else {
+    stop('Unrecognized gist identifier format')
+  }
+
+  runUrl(gistUrl, filetype = ".zip", destdir = destdir, ...)
+}
+
+
+#' @rdname runUrl
+#' @param repo Name of the repository.
+#' @param username GitHub username. If \code{repo} is of the form
+#'   \code{"username/repo"}, \code{username} will be taken from \code{repo}.
+#' @param ref Desired git reference. Could be a commit, tag, or branch name.
+#'   Defaults to \code{"master"}.
+#' @export
+#' @examples
+#' ## Only run this example in interactive R sessions
+#' if (interactive()) {
+#'   runGitHub("shiny_example", "rstudio")
+#'   # or runGitHub("rstudio/shiny_example")
+#'
+#'   # Can run an app from a subdirectory in the repo
+#'   runGitHub("shiny_example", "rstudio", subdir = "inst/shinyapp/")
+#' }
+runGitHub <- function(repo, username = getOption("github.user"),
+                      ref = "master", subdir = NULL, destdir = NULL, ...) {
+
+  if (grepl('/', repo)) {
+    res <- strsplit(repo, '/')[[1]]
+    if (length(res) != 2) stop("'repo' must be of the form 'username/repo'")
+    username <- res[1]
+    repo     <- res[2]
+  }
+
+  url <- paste("https://github.com/", username, "/", repo, "/archive/",
+               ref, ".tar.gz", sep = "")
+
+  runUrl(url, subdir = subdir, destdir = destdir, ...)
 }

R/server-input-handlers.R

@@ -0,0 +1,111 @@
+# Create a map for input handlers and register the defaults.
+inputHandlers <- Map$new()
+
+#' Register an Input Handler
+#'
+#' Adds an input handler for data of this type. When called, Shiny will use the
+#' function provided to refine the data passed back from the client (after being
+#' deserialized by jsonlite) before making it available in the \code{input}
+#' variable of the \code{server.R} file.
+#'
+#' This function will register the handler for the duration of the R process
+#' (unless Shiny is explicitly reloaded). For that reason, the \code{type} used
+#' should be very specific to this package to minimize the risk of colliding
+#' with another Shiny package which might use this data type name. We recommend
+#' the format of "packageName.widgetName".
+#'
+#' Currently Shiny registers the following handlers: \code{shiny.matrix},
+#' \code{shiny.number}, and \code{shiny.date}.
+#'
+#' The \code{type} of a custom Shiny Input widget will be deduced using the
+#' \code{getType()} JavaScript function on the registered Shiny inputBinding.
+#' @param type The type for which the handler should be added -- should be a
+#' single-element character vector.
+#' @param fun The handler function. This is the function that will be used to
+#'   parse the data delivered from the client before it is available in the
+#'   \code{input} variable. The function will be called with the following three
+#'   parameters:
+#'    \enumerate{
+#'      \item{The value of this input as provided by the client, deserialized
+#'      using jsonlite.}
+#'      \item{The \code{shinysession} in which the input exists.}
+#'      \item{The name of the input.}
+#'    }
+#' @param force If \code{TRUE}, will overwrite any existing handler without
+#' warning. If \code{FALSE}, will throw an error if this class already has
+#' a handler defined.
+#' @examples
+#' \dontrun{
+#' # Register an input handler which rounds a input number to the nearest integer
+#' registerInputHandler("mypackage.validint", function(x, shinysession, name) {
+#'   if (is.null(x)) return(NA)
+#'   round(x)
+#' })
+#'
+#' ## On the Javascript side, the associated input binding must have a corresponding getType method:
+#' getType: function(el) {
+#'   return "mypackage.validint";
+#' }
+#'
+#' }
+#' @seealso \code{\link{removeInputHandler}}
+#' @export
+registerInputHandler <- function(type, fun, force=FALSE){
+  if (inputHandlers$containsKey(type) && !force){
+    stop("There is already an input handler for type: ", type)
+  }
+  inputHandlers$set(type, fun)
+}
+
+#' Deregister an Input Handler
+#'
+#' Removes an Input Handler. Rather than using the previously specified handler
+#' for data of this type, the default jsonlite serialization will be used.
+#'
+#' @param type The type for which handlers should be removed.
+#' @return The handler previously associated with this \code{type}, if one
+#'   existed. Otherwise, \code{NULL}.
+#' @seealso \code{\link{registerInputHandler}}
+#' @export
+removeInputHandler <- function(type){
+  inputHandlers$remove(type)
+}
+
+# Takes a list-of-lists and returns a matrix. The lists
+# must all be the same length. NULL is replaced by NA.
+registerInputHandler("shiny.matrix", function(data, ...) {
+  if (length(data) == 0)
+    return(matrix(nrow=0, ncol=0))
+
+  m <- matrix(unlist(lapply(data, function(x) {
+    sapply(x, function(y) {
+      ifelse(is.null(y), NA, y)
+    })
+  })), nrow = length(data[[1]]), ncol = length(data))
+  return(m)
+})
+
+registerInputHandler("shiny.number", function(val, ...){
+  ifelse(is.null(val), NA, val)
+})
+
+registerInputHandler("shiny.date", function(val, ...){
+  # First replace NULLs with NA, then convert to Date vector
+  datelist <- ifelse(lapply(val, is.null), NA, val)
+  as.Date(unlist(datelist))
+})
+
+registerInputHandler("shiny.datetime", function(val, ...){
+  # First replace NULLs with NA, then convert to POSIXct vector
+  times <- lapply(val, function(x) {
+    if (is.null(x)) NA
+    else x
+  })
+  as.POSIXct(unlist(times), origin = "1970-01-01", tz = "UTC")
+})
+
+registerInputHandler("shiny.action", function(val, ...) {
+  # mark up the action button value with a special class so we can recognize it later
+  class(val) <- c(class(val), "shinyActionButtonValue")
+  val
+})

R/server.R

@@ -0,0 +1,735 @@
+#' @include server-input-handlers.R
+
+appsByToken <- Map$new()
+
+# Provide a character representation of the WS that can be used
+# as a key in a Map.
+wsToKey <- function(WS) {
+  as.character(WS$socket)
+}
+
+.globals$clients <- function(req) NULL
+
+
+clearClients <- function() {
+  .globals$clients <- function(req) NULL
+}
+
+
+registerClient <- function(client) {
+  .globals$clients <- append(.globals$clients, client)
+}
+
+
+.globals$resources <- list()
+
+.globals$showcaseDefault <- 0
+
+.globals$showcaseOverride <- FALSE
+
+#' Resource Publishing
+#'
+#' Adds a directory of static resources to Shiny's web server, with the given
+#' path prefix. Primarily intended for package authors to make supporting
+#' JavaScript/CSS files available to their components.
+#'
+#' @param prefix The URL prefix (without slashes). Valid characters are a-z,
+#'   A-Z, 0-9, hyphen, period, and underscore; and must begin with a-z or A-Z.
+#'   For example, a value of 'foo' means that any request paths that begin with
+#'   '/foo' will be mapped to the given directory.
+#' @param directoryPath The directory that contains the static resources to be
+#'   served.
+#'
+#' @details You can call \code{addResourcePath} multiple times for a given
+#'   \code{prefix}; only the most recent value will be retained. If the
+#'   normalized \code{directoryPath} is different than the directory that's
+#'   currently mapped to the \code{prefix}, a warning will be issued.
+#'
+#' @seealso \code{\link{singleton}}
+#'
+#' @examples
+#' addResourcePath('datasets', system.file('data', package='datasets'))
+#'
+#' @export
+addResourcePath <- function(prefix, directoryPath) {
+  prefix <- prefix[1]
+  if (!grepl('^[a-z][a-z0-9\\-_.]*$', prefix, ignore.case=TRUE, perl=TRUE)) {
+    stop("addResourcePath called with invalid prefix; please see documentation")
+  }
+
+  if (prefix %in% c('shared')) {
+    stop("addResourcePath called with the reserved prefix '", prefix, "'; ",
+         "please use a different prefix")
+  }
+
+  directoryPath <- normalizePath(directoryPath, mustWork=TRUE)
+
+  existing <- .globals$resources[[prefix]]
+
+  .globals$resources[[prefix]] <- list(directoryPath=directoryPath,
+                                       func=staticHandler(directoryPath))
+}
+
+resourcePathHandler <- function(req) {
+  if (!identical(req$REQUEST_METHOD, 'GET'))
+    return(NULL)
+
+  path <- req$PATH_INFO
+
+  match <- regexpr('^/([^/]+)/', path, perl=TRUE)
+  if (match == -1)
+    return(NULL)
+  len <- attr(match, 'capture.length')
+  prefix <- substr(path, 2, 2 + len - 1)
+
+  resInfo <- .globals$resources[[prefix]]
+  if (is.null(resInfo))
+    return(NULL)
+
+  suffix <- substr(path, 2 + len, nchar(path))
+
+  subreq <- as.environment(as.list(req, all.names=TRUE))
+  subreq$PATH_INFO <- suffix
+  subreq$SCRIPT_NAME <- paste(subreq$SCRIPT_NAME, substr(path, 1, 2 + len), sep='')
+
+  return(resInfo$func(subreq))
+}
+
+#' Define Server Functionality
+#'
+#' Defines the server-side logic of the Shiny application. This generally
+#' involves creating functions that map user inputs to various kinds of output.
+#' In older versions of Shiny, it was necessary to call \code{shinyServer()} in
+#' the \code{server.R} file, but this is no longer required as of Shiny 0.10.
+#' Now the \code{server.R} file may simply return the appropriate server
+#' function (as the last expression in the code), without calling
+#' \code{shinyServer()}.
+#'
+#' Call \code{shinyServer} from your application's \code{server.R}
+#' file, passing in a "server function" that provides the server-side logic of
+#' your application.
+#'
+#' The server function will be called when each client (web browser) first loads
+#' the Shiny application's page. It must take an \code{input} and an
+#' \code{output} parameter. Any return value will be ignored. It also takes an
+#' optional \code{session} parameter, which is used when greater control is
+#' needed.
+#'
+#' See the \href{http://rstudio.github.com/shiny/tutorial/}{tutorial} for more
+#' on how to write a server function.
+#'
+#' @param func The server function for this application. See the details section
+#'   for more information.
+#'
+#' @examples
+#' \dontrun{
+#' # A very simple Shiny app that takes a message from the user
+#' # and outputs an uppercase version of it.
+#' shinyServer(function(input, output, session) {
+#'   output$uppercase <- renderText({
+#'     toupper(input$message)
+#'   })
+#' })
+#'
+#'
+#' # It is also possible for a server.R file to simply return the function,
+#' # without calling shinyServer().
+#' # For example, the server.R file could contain just the following:
+#' function(input, output, session) {
+#'   output$uppercase <- renderText({
+#'     toupper(input$message)
+#'   })
+#' }
+#' }
+#'
+#' @export
+shinyServer <- function(func) {
+  .globals$server <- list(func)
+  invisible(func)
+}
+
+decodeMessage <- function(data) {
+  readInt <- function(pos) {
+    packBits(rawToBits(data[pos:(pos+3)]), type='integer')
+  }
+
+  if (readInt(1) != 0x01020202L) {
+    # Treat message as UTF-8
+    charData <- rawToChar(data)
+    Encoding(charData) <- 'UTF-8'
+    return(jsonlite::fromJSON(charData, simplifyVector=FALSE))
+  }
+
+  i <- 5
+  parts <- list()
+  while (i <= length(data)) {
+    length <- readInt(i)
+    i <- i + 4
+    if (length != 0)
+      parts <- append(parts, list(data[i:(i+length-1)]))
+    else
+      parts <- append(parts, list(raw(0)))
+    i <- i + length
+  }
+
+  mainMessage <- decodeMessage(parts[[1]])
+  mainMessage$blobs <- parts[2:length(parts)]
+  return(mainMessage)
+}
+
+createAppHandlers <- function(httpHandlers, serverFuncSource) {
+  appvars <- new.env()
+  appvars$server <- NULL
+
+  sys.www.root <- system.file('www', package='shiny')
+
+  # This value, if non-NULL, must be present on all HTTP and WebSocket
+  # requests as the Shiny-Shared-Secret header or else access will be
+  # denied (403 response for HTTP, and instant close for websocket).
+  sharedSecret <- getOption('shiny.sharedSecret')
+
+  appHandlers <- list(
+    http = joinHandlers(c(
+      sessionHandler,
+      httpHandlers,
+      sys.www.root,
+      resourcePathHandler,
+      reactLogHandler)),
+    ws = function(ws) {
+      if (!is.null(sharedSecret)
+          && !identical(sharedSecret, ws$request$HTTP_SHINY_SHARED_SECRET)) {
+        ws$close()
+        return(TRUE)
+      }
+
+      shinysession <- ShinySession$new(ws)
+      appsByToken$set(shinysession$token, shinysession)
+      shinysession$setShowcase(.globals$showcaseDefault)
+
+      ws$onMessage(function(binary, msg) {
+        # To ease transition from websockets-based code. Should remove once we're stable.
+        if (is.character(msg))
+          msg <- charToRaw(msg)
+
+        if (isTRUE(getOption('shiny.trace'))) {
+          if (binary)
+            message("RECV ", '$$binary data$$')
+          else
+            message("RECV ", rawToChar(msg))
+        }
+
+        if (identical(charToRaw("\003\xe9"), msg))
+          return()
+
+        msg <- decodeMessage(msg)
+
+        # Do our own list simplifying here. sapply/simplify2array give names to
+        # character vectors, which is rarely what we want.
+        if (!is.null(msg$data)) {
+          for (name in names(msg$data)) {
+            val <- msg$data[[name]]
+
+            splitName <- strsplit(name, ':')[[1]]
+            if (length(splitName) > 1) {
+              msg$data[[name]] <- NULL
+
+              if (!inputHandlers$containsKey(splitName[[2]])){
+                # No input handler registered for this type
+                stop("No handler registered for for type ", name)
+              }
+
+              msg$data[[ splitName[[1]] ]] <-
+                  inputHandlers$get(splitName[[2]])(
+                      val,
+                      shinysession,
+                      splitName[[1]] )
+            }
+            else if (is.list(val) && is.null(names(val))) {
+              val_flat <- unlist(val, recursive = TRUE)
+
+              if (is.null(val_flat)) {
+                # This is to assign NULL instead of deleting the item
+                msg$data[name] <- list(NULL)
+              } else {
+                msg$data[[name]] <- val_flat
+              }
+            }
+          }
+        }
+
+        switch(
+          msg$method,
+          init = {
+
+            serverFunc <- serverFuncSource()
+            if (!identicalFunctionBodies(serverFunc, appvars$server)) {
+              appvars$server <- serverFunc
+              if (!is.null(appvars$server))
+              {
+                # Tag this function as the Shiny server function. A debugger may use this
+                # tag to give this function special treatment.
+                # It's very important that it's appvars$server itself and NOT a copy that
+                # is invoked, otherwise new breakpoints won't be picked up.
+                attr(appvars$server, "shinyServerFunction") <- TRUE
+                registerDebugHook("server", appvars, "Server Function")
+              }
+            }
+
+            # Check for switching into/out of showcase mode
+            if (.globals$showcaseOverride &&
+                exists(".clientdata_url_search", where = msg$data)) {
+              mode <- showcaseModeOfQuerystring(msg$data$.clientdata_url_search)
+              if (!is.null(mode))
+                shinysession$setShowcase(mode)
+            }
+
+            shinysession$manageInputs(msg$data)
+
+            # The client tells us what singletons were rendered into
+            # the initial page
+            if (!is.null(msg$data$.clientdata_singletons)) {
+              shinysession$singletons <<- strsplit(
+                msg$data$.clientdata_singletons, ',')[[1]]
+            }
+
+            local({
+              args <- list(
+                input=shinysession$input,
+                output=.createOutputWriter(shinysession))
+
+              # The clientData and session arguments are optional; check if
+              # each exists
+              if ('clientData' %in% names(formals(serverFunc)))
+                args$clientData <- shinysession$clientData
+
+              if ('session' %in% names(formals(serverFunc)))
+                args$session <- shinysession
+
+              withReactiveDomain(shinysession, {
+                do.call(appvars$server, args)
+              })
+            })
+          },
+          update = {
+            shinysession$manageInputs(msg$data)
+          },
+          shinysession$dispatch(msg)
+        )
+        shinysession$manageHiddenOutputs()
+
+        if (exists(".shiny__stdout", globalenv()) &&
+            exists("HTTP_GUID", ws$request)) {
+          # safe to assume we're in shiny-server
+          shiny_stdout <- get(".shiny__stdout", globalenv())
+
+          # eNter a flushReact
+          writeLines(paste("_n_flushReact ", get("HTTP_GUID", ws$request),
+                           " @ ", sprintf("%.3f", as.numeric(Sys.time())),
+                           sep=""), con=shiny_stdout)
+          flush(shiny_stdout)
+
+          flushReact()
+
+          # eXit a flushReact
+          writeLines(paste("_x_flushReact ", get("HTTP_GUID", ws$request),
+                           " @ ", sprintf("%.3f", as.numeric(Sys.time())),
+                           sep=""), con=shiny_stdout)
+          flush(shiny_stdout)
+        } else {
+          flushReact()
+        }
+        lapply(appsByToken$values(), function(shinysession) {
+          shinysession$flushOutput()
+          NULL
+        })
+      })
+
+      ws$onClose(function() {
+        shinysession$wsClosed()
+        appsByToken$remove(shinysession$token)
+      })
+
+      return(TRUE)
+    }
+  )
+  return(appHandlers)
+}
+
+getEffectiveBody <- function(func) {
+  # Note: NULL values are OK. isS4(NULL) returns FALSE, body(NULL)
+  # returns NULL.
+  if (isS4(func) && class(func) == "functionWithTrace")
+    body(func@original)
+  else
+    body(func)
+}
+
+identicalFunctionBodies <- function(a, b) {
+  identical(getEffectiveBody(a), getEffectiveBody(b))
+}
+
+handlerManager <- HandlerManager$new()
+
+addSubApp <- function(appObj, autoRemove = TRUE) {
+  path <- createUniqueId(16, "/app")
+  appHandlers <- createAppHandlers(appObj$httpHandler, appObj$serverFuncSource)
+
+  # remove the leading / from the path so a relative path is returned
+  # (needed for the case where the root URL for the Shiny app isn't /, such
+  # as portmapped URLs)
+  finalPath <- paste(
+    substr(path, 2, nchar(path)),
+    "/?w=", workerId(),
+    "&__subapp__=1",
+    sep="")
+  handlerManager$addHandler(routeHandler(path, appHandlers$http), finalPath)
+  handlerManager$addWSHandler(routeWSHandler(path, appHandlers$ws), finalPath)
+
+  if (autoRemove) {
+    # If a session is currently active, remove this subapp automatically when
+    # the current session ends
+    onReactiveDomainEnded(getDefaultReactiveDomain(), function() {
+      removeSubApp(finalPath)
+    })
+  }
+
+  return(finalPath)
+}
+
+removeSubApp <- function(path) {
+  handlerManager$removeHandler(path)
+  handlerManager$removeWSHandler(path)
+}
+
+startApp <- function(appObj, port, host, quiet) {
+  appHandlers <- createAppHandlers(appObj$httpHandler, appObj$serverFuncSource)
+  handlerManager$addHandler(appHandlers$http, "/", tail = TRUE)
+  handlerManager$addWSHandler(appHandlers$ws, "/", tail = TRUE)
+
+  if (is.numeric(port) || is.integer(port)) {
+    if (!quiet) {
+      message('\n', 'Listening on http://', host, ':', port)
+    }
+    return(startServer(host, port, handlerManager$createHttpuvApp()))
+  } else if (is.character(port)) {
+    if (!quiet) {
+      message('\n', 'Listening on domain socket ', port)
+    }
+    mask <- attr(port, 'mask')
+    return(startPipeServer(port, mask, handlerManager$createHttpuvApp()))
+  }
+}
+
+# Run an application that was created by \code{\link{startApp}}. This
+# function should normally be called in a \code{while(TRUE)} loop.
+serviceApp <- function() {
+  if (timerCallbacks$executeElapsed()) {
+    for (shinysession in appsByToken$values()) {
+      shinysession$manageHiddenOutputs()
+    }
+
+    flushReact()
+
+    for (shinysession in appsByToken$values()) {
+      shinysession$flushOutput()
+    }
+  }
+
+  # If this R session is interactive, then call service() with a short timeout
+  # to keep the session responsive to user input
+  maxTimeout <- ifelse(interactive(), 100, 1000)
+
+  timeout <- max(1, min(maxTimeout, timerCallbacks$timeToNextEvent()))
+  service(timeout)
+}
+
+.shinyServerMinVersion <- '0.3.4'
+
+#' Run Shiny Application
+#'
+#' Runs a Shiny application. This function normally does not return; interrupt R
+#' to stop the application (usually by pressing Ctrl+C or Esc).
+#'
+#' The host parameter was introduced in Shiny 0.9.0. Its default value of
+#' \code{"127.0.0.1"} means that, contrary to previous versions of Shiny, only
+#' the current machine can access locally hosted Shiny apps. To allow other
+#' clients to connect, use the value \code{"0.0.0.0"} instead (which was the
+#' value that was hard-coded into Shiny in 0.8.0 and earlier).
+#'
+#' @param appDir The directory of the application. Should contain
+#'   \code{server.R}, plus, either \code{ui.R} or a \code{www} directory that
+#'   contains the file \code{index.html}. Alternately, instead of
+#'   \code{server.R} and \code{ui.R}, the directory may contain just
+#'   \code{app.R}. Defaults to the working directory. Instead of a directory,
+#'   this could be a list with \code{ui} and \code{server} components, or a
+#'   Shiny app object created by \code{\link{shinyApp}}.
+#' @param port The TCP port that the application should listen on. If the
+#'   \code{port} is not specified, and the \code{shiny.port} option is set (with
+#'   \code{options(shiny.port = XX)}), then that port will be used. Otherwise,
+#'   use a random port.
+#' @param launch.browser If true, the system's default web browser will be
+#'   launched automatically after the app is started. Defaults to true in
+#'   interactive sessions only. This value of this parameter can also be a
+#'   function to call with the application's URL.
+#' @param host The IPv4 address that the application should listen on. Defaults
+#'   to the \code{shiny.host} option, if set, or \code{"127.0.0.1"} if not. See
+#'   Details.
+#' @param workerId Can generally be ignored. Exists to help some editions of
+#'   Shiny Server Pro route requests to the correct process.
+#' @param quiet Should Shiny status messages be shown? Defaults to FALSE.
+#' @param display.mode The mode in which to display the application. If set to
+#'   the value \code{"showcase"}, shows application code and metadata from a
+#'   \code{DESCRIPTION} file in the application directory alongside the
+#'   application. If set to \code{"normal"}, displays the application normally.
+#'   Defaults to \code{"auto"}, which displays the application in the mode given
+#'   in its \code{DESCRIPTION} file, if any.
+#'
+#' @examples
+#' \dontrun{
+#' # Start app in the current working directory
+#' runApp()
+#'
+#' # Start app in a subdirectory called myapp
+#' runApp("myapp")
+#' }
+#'
+#' ## Only run this example in interactive R sessions
+#' if (interactive()) {
+#'   # Apps can be run without a server.r and ui.r file
+#'   runApp(list(
+#'     ui = bootstrapPage(
+#'       numericInput('n', 'Number of obs', 100),
+#'       plotOutput('plot')
+#'     ),
+#'     server = function(input, output) {
+#'       output$plot <- renderPlot({ hist(runif(input$n)) })
+#'     }
+#'   ))
+#'
+#'
+#'   # Running a Shiny app object
+#'   app <- shinyApp(
+#'     ui = bootstrapPage(
+#'       numericInput('n', 'Number of obs', 100),
+#'       plotOutput('plot')
+#'     ),
+#'     server = function(input, output) {
+#'       output$plot <- renderPlot({ hist(runif(input$n)) })
+#'     }
+#'   )
+#'   runApp(app)
+#' }
+#' @export
+runApp <- function(appDir=getwd(),
+                   port=getOption('shiny.port'),
+                   launch.browser=getOption('shiny.launch.browser',
+                                            interactive()),
+                   host=getOption('shiny.host', '127.0.0.1'),
+                   workerId="", quiet=FALSE,
+                   display.mode=c("auto", "normal", "showcase")) {
+  on.exit({
+    handlerManager$clear()
+  }, add = TRUE)
+
+
+  if (is.null(host) || is.na(host))
+    host <- '0.0.0.0'
+
+  # Make warnings print immediately
+  ops <- options(warn = 1)
+  on.exit(options(ops), add = TRUE)
+
+  workerId(workerId)
+
+  if (nzchar(Sys.getenv('SHINY_PORT'))) {
+    # If SHINY_PORT is set, we're running under Shiny Server. Check the version
+    # to make sure it is compatible. Older versions of Shiny Server don't set
+    # SHINY_SERVER_VERSION, those will return "" which is considered less than
+    # any valid version.
+    ver <- Sys.getenv('SHINY_SERVER_VERSION')
+    if (utils::compareVersion(ver, .shinyServerMinVersion) < 0) {
+      warning('Shiny Server v', .shinyServerMinVersion,
+              ' or later is required; please upgrade!')
+    }
+  }
+
+  # Showcase mode is disabled by default; it must be explicitly enabled in
+  # either the DESCRIPTION file for directory-based apps, or via
+  # the display.mode parameter. The latter takes precedence.
+  setShowcaseDefault(0)
+
+  # If appDir specifies a path, and display mode is specified in the
+  # DESCRIPTION file at that path, apply it here.
+  if (is.character(appDir)) {
+    desc <- file.path.ci(appDir, "DESCRIPTION")
+    if (file.exists(desc)) {
+      con <- file(desc, encoding = checkEncoding(desc))
+      on.exit(close(con), add = TRUE)
+      settings <- read.dcf(con)
+      if ("DisplayMode" %in% colnames(settings)) {
+        mode <- settings[1,"DisplayMode"]
+        if (mode == "Showcase") {
+          setShowcaseDefault(1)
+        }
+      }
+    }
+  }
+
+  # If display mode is specified as an argument, apply it (overriding the
+  # value specified in DESCRIPTION, if any).
+  display.mode <- match.arg(display.mode)
+  if (display.mode == "normal")
+    setShowcaseDefault(0)
+  else if (display.mode == "showcase")
+    setShowcaseDefault(1)
+
+  require(shiny)
+
+  # determine port if we need to
+  if (is.null(port)) {
+
+    # Try up to 20 random ports. If we don't succeed just plow ahead
+    # with the final value we tried, and let the "real" startServer
+    # somewhere down the line fail and throw the error to the user.
+    #
+    # If we (think we) succeed, save the value as .globals$lastPort,
+    # and try that first next time the user wants a random port.
+
+    for (i in 1:20) {
+      if (!is.null(.globals$lastPort)) {
+        port <- .globals$lastPort
+        .globals$lastPort <- NULL
+      }
+      else {
+        # Try up to 20 random ports
+        port <- p_randomInt(3000, 8000)
+      }
+
+      # Test port to see if we can use it
+      tmp <- try(startServer(host, port, list()), silent=TRUE)
+      if (!inherits(tmp, 'try-error')) {
+        stopServer(tmp)
+        .globals$lastPort <- port
+        break
+      }
+    }
+  }
+
+  appParts <- as.shiny.appobj(appDir)
+  # Set up the onEnd before we call onStart, so that it gets called even if an
+  # error happens in onStart.
+  if (!is.null(appParts$onEnd))
+    on.exit(appParts$onEnd(), add = TRUE)
+  if (!is.null(appParts$onStart))
+    appParts$onStart()
+
+  server <- startApp(appParts, port, host, quiet)
+
+  on.exit({
+    stopServer(server)
+  }, add = TRUE)
+
+  if (!is.character(port)) {
+    # http://0.0.0.0/ doesn't work on QtWebKit (i.e. RStudio viewer)
+    browseHost <- if (identical(host, "0.0.0.0")) "127.0.0.1" else host
+
+    appUrl <- paste("http://", browseHost, ":", port, sep="")
+    if (is.function(launch.browser))
+      launch.browser(appUrl)
+    else if (launch.browser)
+      utils::browseURL(appUrl)
+  } else {
+    appUrl <- NULL
+  }
+
+  # call application hooks
+  callAppHook("onAppStart", appUrl)
+  on.exit({
+    callAppHook("onAppStop", appUrl)
+  }, add = TRUE)
+
+  .globals$retval <- NULL
+  .globals$stopped <- FALSE
+  shinyCallingHandlers(
+    while (!.globals$stopped) {
+      serviceApp()
+      Sys.sleep(0.001)
+    }
+  )
+
+  return(.globals$retval)
+}
+
+#' Stop the currently running Shiny app
+#'
+#' Stops the currently running Shiny app, returning control to the caller of
+#' \code{\link{runApp}}.
+#'
+#' @param returnValue The value that should be returned from
+#'   \code{\link{runApp}}.
+#'
+#' @export
+stopApp <- function(returnValue = NULL) {
+  .globals$retval <- returnValue
+  .globals$stopped <- TRUE
+  httpuv::interrupt()
+}
+
+#' Run Shiny Example Applications
+#'
+#' Launch Shiny example applications, and optionally, your system's web browser.
+#'
+#' @param example The name of the example to run, or \code{NA} (the default) to
+#'   list the available examples.
+#' @param port The TCP port that the application should listen on. Defaults to
+#'   choosing a random port.
+#' @param launch.browser If true, the system's default web browser will be
+#'   launched automatically after the app is started. Defaults to true in
+#'   interactive sessions only.
+#' @param host The IPv4 address that the application should listen on. Defaults
+#'   to the \code{shiny.host} option, if set, or \code{"127.0.0.1"} if not.
+#' @param display.mode The mode in which to display the example. Defaults to
+#'   \code{showcase}, but may be set to \code{normal} to see the example without
+#'   code or commentary.
+#'
+#' @examples
+#' ## Only run this example in interactive R sessions
+#' if (interactive()) {
+#'   # List all available examples
+#'   runExample()
+#'
+#'   # Run one of the examples
+#'   runExample("01_hello")
+#'
+#'   # Print the directory containing the code for all examples
+#'   system.file("examples", package="shiny")
+#' }
+#' @export
+runExample <- function(example=NA,
+                       port=NULL,
+                       launch.browser=getOption('shiny.launch.browser',
+                                                interactive()),
+                       host=getOption('shiny.host', '127.0.0.1'),
+                       display.mode=c("auto", "normal", "showcase")) {
+  examplesDir <- system.file('examples', package='shiny')
+  dir <- resolve(examplesDir, example)
+  if (is.null(dir)) {
+    if (is.na(example)) {
+      errFun <- message
+      errMsg <- ''
+    }
+    else {
+      errFun <- stop
+      errMsg <- paste('Example', example, 'does not exist. ')
+    }
+
+    errFun(errMsg,
+           'Valid examples are "',
+           paste(list.files(examplesDir), collapse='", "'),
+           '"')
+  }
+  else {
+    runApp(dir, port = port, host = host, launch.browser = launch.browser,
+           display.mode = display.mode)
+  }
+}

R/shinyui.R

@@ -1,252 +1,133 @@
+#' @include globals.R
+NULL
 
-#' @export
-p <- function(...) tags$p(...)
-
-#' @export
-h1 <- function(...) tags$h1(...)
-
-#' @export
-h2 <- function(...) tags$h2(...)
-
-#' @export
-h3 <- function(...) tags$h3(...)
-
-#' @export
-h4 <- function(...) tags$h4(...)
-
-#' @export
-h5 <- function(...) tags$h5(...)
-
-#' @export
-h6 <- function(...) tags$h6(...)
-
-#' @export
-a <- function(...) tags$a(...)
-
-#' @export
-br <- function(...) tags$br(...)
-
-#' @export
-div <- function(...) tags$div(...)
-
-#' @export
-span <- function(...) tags$span(...)
-
-#' @export
-pre <- function(...) tags$pre(...)
-
-#' @export
-code <- function(...) tags$code(...)
-
-#' @export
-img <- function(...) tags$img(...)
-
-#' @export
-strong <- function(...) tags$strong(...)
-
-#' @export
-em <- function(...) tags$em(...)
-
-#' Include Content From a File
-#' 
-#' Include HTML, text, or rendered Markdown into a \link[=shinyUI]{Shiny UI}.
-#' 
-#' These functions provide a convenient way to include an extensive amount of 
-#' HTML, textual, Markdown, CSS, or JavaScript content, rather than using a
-#' large literal R string.
-#' 
-#' @note \code{includeText} escapes its contents, but does no other processing. 
-#'   This means that hard breaks and multiple spaces will be rendered as they 
-#'   usually are in HTML: as a single space character. If you are looking for 
-#'   preformatted text, wrap the call with \code{\link{pre}}, or consider using 
-#'   \code{includeMarkdown} instead.
-#'   
-#' @note The \code{includeMarkdown} function requires the \code{markdown} 
-#'   package.
-#'   
-#' @param path The path of the file to be included. It is highly recommended to 
-#'   use a relative path (the base path being the Shiny application directory), 
-#'   not an absolute path.
-#'   
-#' @rdname include
-#' @export
-includeHTML <- function(path) {
-  dependsOnFile(path)
-  lines <- readLines(path, warn=FALSE, encoding='UTF-8')
-  return(HTML(paste(lines, collapse='\r\n')))
-}
-
-#' @rdname include
-#' @export
-includeText <- function(path) {
-  dependsOnFile(path)
-  lines <- readLines(path, warn=FALSE, encoding='UTF-8')
-  return(paste(lines, collapse='\r\n'))
-}
-
-#' @rdname include
-#' @export
-includeMarkdown <- function(path) {
-  if (!require(markdown))
-    stop("Markdown package is not installed")
-  
-  dependsOnFile(path)
-  html <- markdown::markdownToHTML(path, fragment.only=TRUE)
-  Encoding(html) <- 'UTF-8'
-  return(HTML(html))
-}
-
-#' @param ... Any additional attributes to be applied to the generated tag.
-#' @rdname include
-#' @export
-includeCSS <- function(path, ...) {
-  dependsOnFile(path)
-  lines <- readLines(path, warn=FALSE, encoding='UTF-8')
-  args <- list(...)
-  if (is.null(args$type))
-    args$type <- 'text/css'
-  return(do.call(tags$style,
-                 c(list(HTML(paste(lines, collapse='\r\n'))), args)))
-}
-
-#' @rdname include
-#' @export
-includeScript <- function(path, ...) {
-  dependsOnFile(path)
-  lines <- readLines(path, warn=FALSE, encoding='UTF-8')
-  return(tags$script(HTML(paste(lines, collapse='\r\n')), ...))
-}
-
-
-#' Include Content Only Once
-#' 
-#' Use \code{singleton} to wrap contents (tag, text, HTML, or lists) that should
-#' be included in the generated document only once, yet may appear in the 
-#' document-generating code more than once. Only the first appearance of the 
-#' content (in document order) will be used. Useful for custom components that 
-#' have JavaScript files or stylesheets.
-#' 
-#' @param x A \code{\link{tag}}, text, \code{\link{HTML}}, or list.
+#' Load the MathJax library and typeset math expressions
 #'
+#' This function adds MathJax to the page and typeset the math expressions (if
+#' found) in the content \code{...}. It only needs to be called once in an app
+#' unless the content is rendered \emph{after} the page is loaded, e.g. via
+#' \code{\link{renderUI}}, in which case we have to call it explicitly every
+#' time we write math expressions to the output.
+#' @param ... any HTML elements to apply MathJax to
 #' @export
-singleton <- function(x) {
-  class(x) <- c(class(x), 'shiny.singleton')
-  return(x)
+#' @examples withMathJax(helpText("Some math here $$\\alpha+\\beta$$"))
+#' # now we can just write "static" content without withMathJax()
+#' div("more math here $$\\sqrt{2}$$")
+withMathJax <- function(...) {
+  path <- 'https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'
+  tagList(
+    tags$head(
+      singleton(tags$script(src = path, type = 'text/javascript'))
+    ),
+    ...,
+    tags$script(HTML('MathJax.Hub.Queue(["Typeset", MathJax.Hub]);'))
+  )
 }
 
-renderPage <- function(ui, connection) {
-  
-  # provide a filter so we can intercept head tag requests
-  context <- new.env()
-  context$head <- character()
-  context$singletons <- character()
-  context$filter <- function(content) {
-    if (inherits(content, 'shiny.singleton')) {
-      sig <- digest(content, algo='sha1')
-      if (sig %in% context$singletons)
-        return(FALSE)
-      context$singletons <- c(sig, context$singletons)
-    }
-    
-    if (isTag(content) && identical(content$name, "head")) {
-      textConn <- textConnection(NULL, "w") 
-      textConnWriter <- function(text) cat(text, file = textConn)
-      tagWrite(content$children, textConnWriter, 1, context)
-      context$head <- append(context$head, textConnectionValue(textConn))
-      close(textConn)
-      return (FALSE)
-    }
-    else {
-      return (TRUE)
-    }
-  }
-  
-  # write ui HTML to a character vector
-  textConn <- textConnection(NULL, "w") 
-  tagWrite(ui, function(text) cat(text, file = textConn), 0, context)
-  uiHTML <- textConnectionValue(textConn)
-  close(textConn)
- 
+renderPage <- function(ui, connection, showcase=0) {
+
+  if (showcase > 0)
+    ui <- showcaseUI(ui)
+
+  # Wrap ui in body tag if it doesn't already have a single top-level body tag.
+  if (!(inherits(ui, "shiny.tag") && ui$name == "body"))
+    ui <- tags$body(ui)
+
+  result <- renderTags(ui)
+
+  deps <- c(
+    list(
+      htmlDependency("json2", "2014.02.04", c(href="shared"), script = "json2-min.js"),
+      htmlDependency("jquery", "1.11.0", c(href="shared"), script = "jquery.min.js"),
+      htmlDependency("shiny", utils::packageVersion("shiny"), c(href="shared"),
+        script = if (getOption("shiny.minified", TRUE)) "shiny.min.js" else "shiny.js",
+        stylesheet = "shiny.css")
+    ),
+    result$dependencies
+  )
+  deps <- resolveDependencies(deps)
+  deps <- lapply(deps, createWebDependency)
+  depStr <- paste(sapply(deps, function(dep) {
+    sprintf("%s[%s]", dep$name, dep$version)
+  }), collapse = ";")
+  depHtml <- renderDependencies(deps, "href")
+
   # write preamble
   writeLines(c('<!DOCTYPE html>',
                '<html>',
                '<head>',
                '  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>',
-               '  <script src="shared/jquery.js" type="text/javascript"></script>',
-               '  <script src="shared/shiny.js" type="text/javascript"></script>',
-               '  <link rel="stylesheet" type="text/css" href="shared/shiny.css"/>',
-               context$head,
+               sprintf('  <script type="application/shiny-singletons">%s</script>',
+                       paste(result$singletons, collapse = ',')
+               ),
+               sprintf('  <script type="application/html-dependencies">%s</script>',
+                       depStr
+               ),
+               depHtml
+              ),
+              con = connection)
+  writeLines(c(result$head,
                '</head>',
-               '<body>', 
                recursive=TRUE),
              con = connection)
-  
-  # write UI html to connection
-  writeLines(uiHTML, con = connection)
-  
+
+  writeLines(result$html, con = connection)
+
   # write end document
-  writeLines(c('</body>',
-               '</html>'),
+  writeLines('</html>',
              con = connection)
 }
 
 #' Create a Shiny UI handler
-#' 
-#' Register a UI handler by providing a UI definition (created with e.g. 
-#' \link{pageWithSidebar}) and web server path (typically "/", the default
-#' value).
-#' 
-#' @param ui A user-interace definition
-#' @param path The web server path to server the UI from
-#' @return Called for its side-effect of registering a UI handler
-#' 
-#' @examples
-#' el <- div(HTML("I like <u>turtles</u>"))
-#' cat(as.character(el))
-#'   
-#' @examples
-#' # Define UI
-#' shinyUI(pageWithSidebar(
-#'   
-#'   # Application title
-#'   headerPanel("Hello Shiny!"),
-#'   
-#'   # Sidebar with a slider input
-#'   sidebarPanel(
-#'     sliderInput("obs", 
-#'                 "Number of observations:", 
-#'                 min = 0, 
-#'                 max = 1000, 
-#'                 value = 500)
-#'   ),
-#'   
-#'   # Show a plot of the generated distribution
-#'   mainPanel(
-#'     plotOutput("distPlot")
-#'   )
-#' ))
+#'
+#' Historically this function was used in ui.R files to register a user
+#' interface with Shiny. It is no longer required as of Shiny 0.10; simply
+#' ensure that the last expression to be returned from ui.R is a user interface.
+#' This function is kept for backwards compatibility with older applications. It
+#' returns the value that is passed to it.
+#'
+#' @param ui A user interace definition
+#' @return The user interface definition, without modifications or side effects.
 #'
 #' @export
-shinyUI <- function(ui, path='/') {
-  
-  force(ui)
-  
-  registerClient({
-    
-    function(req) {
-      if (!identical(req$REQUEST_METHOD, 'GET'))
-        return(NULL)
-
-      if (req$PATH_INFO != path)
-        return(NULL)
-      
-      textConn <- textConnection(NULL, "w") 
-      on.exit(close(textConn))
-      
-      renderPage(ui, textConn)
-      html <- paste(textConnectionValue(textConn), collapse='\n')
-      return(httpResponse(200, content=html))
-    }
-  })
+shinyUI <- function(ui) {
+  .globals$ui <- list(ui)
+  ui
 }
 
+uiHttpHandler <- function(ui, uiPattern = "^/$") {
+
+  force(ui)
+
+  function(req) {
+    if (!identical(req$REQUEST_METHOD, 'GET'))
+      return(NULL)
+
+    if (!isTRUE(grepl(uiPattern, req$PATH_INFO)))
+      return(NULL)
+
+    textConn <- textConnection(NULL, "w")
+    on.exit(close(textConn))
+
+    showcaseMode <- .globals$showcaseDefault
+    if (.globals$showcaseOverride) {
+      mode <- showcaseModeOfReq(req)
+      if (!is.null(mode))
+        showcaseMode <- mode
+    }
+    uiValue <- if (is.function(ui)) {
+      if (length(formals(ui)) > 0)
+        ui(req)
+      else
+        ui()
+    } else {
+      ui
+    }
+    if (is.null(uiValue))
+      return(NULL)
+
+    renderPage(uiValue, textConn, showcaseMode)
+    html <- paste(textConnectionValue(textConn), collapse='\n')
+    return(httpResponse(200, content=enc2utf8(html)))
+  }
+}

R/shinywrappers.R

@@ -1,100 +1,46 @@
-suppressPackageStartupMessages({
-  library(caTools)
-  library(xtable)
-})
+globalVariables('func')
 
-#' Plot Output
-#' 
-#' Renders a reactive plot that is suitable for assigning to an \code{output} 
-#' slot.
-#' 
-#' The corresponding HTML output tag should be \code{div} or \code{img} and have
-#' the CSS class name \code{shiny-plot-output}.
+#' Mark a function as a render function
 #'
-#' @seealso For more details on how the plots are generated, and how to control
-#'   the output, see \code{\link{plotPNG}}.
+#' Should be called by implementers of \code{renderXXX} functions in order to
+#' mark their return values as Shiny render functions, and to provide a hint to
+#' Shiny regarding what UI function is most commonly used with this type of
+#' render function. This can be used in R Markdown documents to create complete
+#' output widgets out of just the render function.
+#'
+#' @param uiFunc A function that renders Shiny UI. Must take a single argument:
+#'   an output ID.
+#' @param renderFunc A function that is suitable for assigning to a Shiny output
+#'   slot.
+#' @return The \code{renderFunc} function, with annotations.
 #'
-#' @param expr An expression that generates a plot.
-#' @param width The width of the rendered plot, in pixels; or \code{'auto'} to 
-#'   use the \code{offsetWidth} of the HTML element that is bound to this plot. 
-#'   You can also pass in a function that returns the width in pixels or 
-#'   \code{'auto'}; in the body of the function you may reference reactive 
-#'   values and functions.
-#' @param height The height of the rendered plot, in pixels; or \code{'auto'} to
-#'   use the \code{offsetHeight} of the HTML element that is bound to this plot.
-#'   You can also pass in a function that returns the width in pixels or 
-#'   \code{'auto'}; in the body of the function you may reference reactive 
-#'   values and functions.
-#' @param res Resolution of resulting plot, in pixels per inch. This value is
-#'   passed to \code{\link{png}}. Note that this affects the resolution of PNG
-#'   rendering in R; it won't change the actual ppi of the browser.
-#' @param ... Arguments to be passed through to \code{\link[grDevices]{png}}. 
-#'   These can be used to set the width, height, background color, etc.
-#' @param env The environment in which to evaluate \code{expr}.
-#' @param quoted Is \code{expr} a quoted expression (with \code{quote()})? This
-#'   is useful if you want to save an expression in a variable.
-#' @param func A function that generates a plot (deprecated; use \code{expr}
-#'   instead).
-#'   
 #' @export
-renderPlot <- function(expr, width='auto', height='auto', res=72, ...,
-                       env=parent.frame(), quoted=FALSE, func=NULL) {
-  if (!is.null(func)) {
-    shinyDeprecated(msg="renderPlot: argument 'func' is deprecated. Please use 'expr' instead.")
-  } else {
-    func <- exprToFunction(expr, env, quoted)
-  }
+markRenderFunction <- function(uiFunc, renderFunc) {
+  structure(renderFunc,
+            class      = c("shiny.render.function", "function"),
+            outputFunc = uiFunc)
+}
 
+useRenderFunction <- function(renderFunc, inline = FALSE) {
+  outputFunction <- attr(renderFunc, "outputFunc")
+  id <- createUniqueId(8, "out")
+  o <- getDefaultReactiveDomain()$output
+  if (!is.null(o))
+    o[[id]] <- renderFunc
+  if (is.logical(formals(outputFunction)[["inline"]])) {
+    outputFunction(id, inline = inline)
+  } else outputFunction(id)
+}
 
-  args <- list(...)
-  
-  if (is.function(width))
-    widthWrapper <- reactive({ width() })
-  else
-    widthWrapper <- NULL
-
-  if (is.function(height))
-    heightWrapper <- reactive({ height() })
-  else
-    heightWrapper <- NULL
-
-  return(function(shinysession, name, ...) {
-    if (!is.null(widthWrapper))
-      width <- widthWrapper()
-    if (!is.null(heightWrapper))
-      height <- heightWrapper()
-    
-    # Note that these are reactive calls. A change to the width and height
-    # will inherently cause a reactive plot to redraw (unless width and 
-    # height were explicitly specified).
-    prefix <- 'output_'
-    if (width == 'auto')
-      width <- shinysession$clientData[[paste(prefix, name, '_width', sep='')]];
-    if (height == 'auto')
-      height <- shinysession$clientData[[paste(prefix, name, '_height', sep='')]];
-    
-    if (is.null(width) || is.null(height) || width <= 0 || height <= 0)
-      return(NULL)
-
-    # Resolution multiplier
-    pixelratio <- shinysession$clientData$pixelratio
-    if (is.null(pixelratio))
-      pixelratio <- 1
-
-    outfile <- do.call(plotPNG, c(func, width=width*pixelratio,
-                                  height=height*pixelratio, res=res*pixelratio, args))
-    on.exit(unlink(outfile))
-    
-    # Return a list of attributes for the img
-    return(list(
-      src=shinysession$fileUrl(name, outfile, contentType='image/png'),
-      width=width, height=height))
-  })
+#' @export
+#' @method as.tags shiny.render.function
+as.tags.shiny.render.function <- function(x, ..., inline = FALSE) {
+  useRenderFunction(x, inline = inline)
 }
 
 #' Image file output
 #'
-#' Renders a reactive image that is suitable for assigning to an \code{output} 
+#' Renders a reactive image that is suitable for assigning to an \code{output}
 #' slot.
 #'
 #' The expression \code{expr} must return a list containing the attributes for
@@ -120,7 +66,7 @@ renderPlot <- function(expr, width='auto', height='auto', res=72, ...,
 #' @param quoted Is \code{expr} a quoted expression (with \code{quote()})? This
 #'   is useful if you want to save an expression in a variable.
 #' @param deleteFile Should the file in \code{func()$src} be deleted after
-#'   it is sent to the client browser? Genrrally speaking, if the image is a
+#'   it is sent to the client browser? Generally speaking, if the image is a
 #'   temp file generated within \code{func}, then this should be \code{TRUE};
 #'   if the image is not a temp file, this should be \code{FALSE}.
 #'
@@ -182,9 +128,9 @@ renderPlot <- function(expr, width='auto', height='auto', res=72, ...,
 #' }
 renderImage <- function(expr, env=parent.frame(), quoted=FALSE,
                         deleteFile=TRUE) {
-  func <- exprToFunction(expr, env, quoted)
+  installExprFunction(expr, "func", env, quoted)
 
-  return(function(shinysession, name, ...) {
+  return(markRenderFunction(imageOutput, function(shinysession, name, ...) {
     imageinfo <- func()
     # Should the file be deleted after being sent? If .deleteFile not set or if
     # TRUE, then delete; otherwise don't delete.
@@ -193,11 +139,7 @@ renderImage <- function(expr, env=parent.frame(), quoted=FALSE,
     }
 
     # If contentType not specified, autodetect based on extension
-    if (is.null(imageinfo$contentType)) {
-      contentType <- getContentType(sub('^.*\\.', '', basename(imageinfo$src)))
-    } else {
-      contentType <- imageinfo$contentType
-    }
+    contentType <- imageinfo$contentType %OR% getContentType(imageinfo$src)
 
     # Extra values are everything in imageinfo except 'src' and 'contentType'
     extra_attr <- imageinfo[!names(imageinfo) %in% c('src', 'contentType')]
@@ -205,115 +147,114 @@ renderImage <- function(expr, env=parent.frame(), quoted=FALSE,
     # Return a list with src, and other img attributes
     c(src = shinysession$fileUrl(name, file=imageinfo$src, contentType=contentType),
       extra_attr)
-  })
+  }))
 }
 
 
 #' Table Output
-#' 
-#' Creates a reactive table that is suitable for assigning to an \code{output} 
+#'
+#' Creates a reactive table that is suitable for assigning to an \code{output}
 #' slot.
-#' 
+#'
 #' The corresponding HTML output tag should be \code{div} and have the CSS class
 #' name \code{shiny-html-output}.
-#' 
-#' @param expr An expression that returns an R object that can be used with 
+#'
+#' @param expr An expression that returns an R object that can be used with
 #'   \code{\link[xtable]{xtable}}.
 #' @param ... Arguments to be passed through to \code{\link[xtable]{xtable}} and
 #'   \code{\link[xtable]{print.xtable}}.
 #' @param env The environment in which to evaluate \code{expr}.
 #' @param quoted Is \code{expr} a quoted expression (with \code{quote()})? This
 #'   is useful if you want to save an expression in a variable.
-#' @param func A function that returns an R object that can be used with 
+#' @param func A function that returns an R object that can be used with
 #'   \code{\link[xtable]{xtable}} (deprecated; use \code{expr} instead).
-#'   
+#'
 #' @export
 renderTable <- function(expr, ..., env=parent.frame(), quoted=FALSE, func=NULL) {
   if (!is.null(func)) {
     shinyDeprecated(msg="renderTable: argument 'func' is deprecated. Please use 'expr' instead.")
   } else {
-    func <- exprToFunction(expr, env, quoted)
+    installExprFunction(expr, "func", env, quoted)
   }
 
-  function() {
-    classNames <- getOption('shiny.table.class', 'data table table-bordered table-condensed')
+  markRenderFunction(tableOutput, function() {
+    classNames <- getOption('shiny.table.class') %OR% 'data table table-bordered table-condensed'
     data <- func()
 
     if (is.null(data) || identical(data, data.frame()))
       return("")
-    
+
     return(paste(
-      capture.output(
-        print(xtable(data, ...), 
-              type='html', 
+      utils::capture.output(
+        print(xtable(data, ...),
+              type='html',
               html.table.attributes=paste('class="',
                                           htmlEscape(classNames, TRUE),
                                           '"',
                                           sep=''), ...)),
       collapse="\n"))
-  }
+  })
 }
 
 #' Printable Output
-#' 
-#' Makes a reactive version of the given function that captures any printed 
-#' output, and also captures its printable result (unless 
-#' \code{\link{invisible}}), into a string. The resulting function is suitable 
+#'
+#' Makes a reactive version of the given function that captures any printed
+#' output, and also captures its printable result (unless
+#' \code{\link{invisible}}), into a string. The resulting function is suitable
 #' for assigning to an  \code{output} slot.
-#' 
-#' The corresponding HTML output tag can be anything (though \code{pre} is 
+#'
+#' The corresponding HTML output tag can be anything (though \code{pre} is
 #' recommended if you need a monospace font and whitespace preserved) and should
 #' have the CSS class name \code{shiny-text-output}.
-#' 
-#' The result of executing \code{func} will be printed inside a 
+#'
+#' The result of executing \code{func} will be printed inside a
 #' \code{\link[utils]{capture.output}} call.
-#' 
-#' Note that unlike most other Shiny output functions, if the given function 
-#' returns \code{NULL} then \code{NULL} will actually be visible in the output. 
+#'
+#' Note that unlike most other Shiny output functions, if the given function
+#' returns \code{NULL} then \code{NULL} will actually be visible in the output.
 #' To display nothing, make your function return \code{\link{invisible}()}.
-#' 
-#' @param expr An expression that may print output and/or return a printable R 
+#'
+#' @param expr An expression that may print output and/or return a printable R
 #'   object.
 #' @param env The environment in which to evaluate \code{expr}.
 #' @param quoted Is \code{expr} a quoted expression (with \code{quote()})? This
-#' @param func A function that may print output and/or return a printable R 
+#' @param func A function that may print output and/or return a printable R
 #'   object (deprecated; use \code{expr} instead).
-#'   
-#' @seealso \code{\link{renderText}} for displaying the value returned from a 
+#' @param width The value for \code{\link{options}('width')}.
+#' @seealso \code{\link{renderText}} for displaying the value returned from a
 #'   function, instead of the printed output.
 #'
 #' @example res/text-example.R
-#'   
+#'
 #' @export
-renderPrint <- function(expr, env=parent.frame(), quoted=FALSE, func=NULL) {
+renderPrint <- function(expr, env = parent.frame(), quoted = FALSE, func = NULL,
+                        width = getOption('width')) {
   if (!is.null(func)) {
     shinyDeprecated(msg="renderPrint: argument 'func' is deprecated. Please use 'expr' instead.")
   } else {
-    func <- exprToFunction(expr, env, quoted)
+    installExprFunction(expr, "func", env, quoted)
   }
 
-  function() {
-    return(paste(capture.output({
-      result <- withVisible(func())
-      if (result$visible)
-        print(result$value)
-    }), collapse="\n"))
-  }
+  markRenderFunction(verbatimTextOutput, function() {
+    op <- options(width = width)
+    on.exit(options(op), add = TRUE)
+    paste(utils::capture.output(func()), collapse = "\n")
+  })
 }
 
 #' Text Output
-#' 
-#' Makes a reactive version of the given function that also uses 
-#' \code{\link[base]{cat}} to turn its result into a single-element character 
+#'
+#' Makes a reactive version of the given function that also uses
+#' \code{\link[base]{cat}} to turn its result into a single-element character
 #' vector.
-#' 
-#' The corresponding HTML output tag can be anything (though \code{pre} is 
+#'
+#' The corresponding HTML output tag can be anything (though \code{pre} is
 #' recommended if you need a monospace font and whitespace preserved) and should
 #' have the CSS class name \code{shiny-text-output}.
-#' 
-#' The result of executing \code{func} will passed to \code{cat}, inside a 
+#'
+#' The result of executing \code{func} will passed to \code{cat}, inside a
 #' \code{\link[utils]{capture.output}} call.
-#' 
+#'
 #' @param expr An expression that returns an R object that can be used as an
 #'   argument to \code{cat}.
 #' @param env The environment in which to evaluate \code{expr}.
@@ -321,50 +262,50 @@ renderPrint <- function(expr, env=parent.frame(), quoted=FALSE, func=NULL) {
 #'   is useful if you want to save an expression in a variable.
 #' @param func A function that returns an R object that can be used as an
 #'   argument to \code{cat}.(deprecated; use \code{expr} instead).
-#'   
+#'
 #' @seealso \code{\link{renderPrint}} for capturing the print output of a
 #'   function, rather than the returned text value.
 #'
 #' @example res/text-example.R
-#'   
+#'
 #' @export
 renderText <- function(expr, env=parent.frame(), quoted=FALSE, func=NULL) {
   if (!is.null(func)) {
     shinyDeprecated(msg="renderText: argument 'func' is deprecated. Please use 'expr' instead.")
   } else {
-    func <- exprToFunction(expr, env, quoted)
+    installExprFunction(expr, "func", env, quoted)
   }
 
-  function() {
+  markRenderFunction(textOutput, function() {
     value <- func()
-    return(paste(capture.output(cat(value)), collapse="\n"))
-  }
+    return(paste(utils::capture.output(cat(value)), collapse="\n"))
+  })
 }
 
 #' UI Output
-#' 
+#'
 #' \bold{Experimental feature.} Makes a reactive version of a function that
 #' generates HTML using the Shiny UI library.
-#' 
+#'
 #' The corresponding HTML output tag should be \code{div} and have the CSS class
 #' name \code{shiny-html-output} (or use \code{\link{uiOutput}}).
-#' 
-#' @param expr An expression that returns a Shiny tag object, \code{\link{HTML}}, 
+#'
+#' @param expr An expression that returns a Shiny tag object, \code{\link{HTML}},
 #'   or a list of such objects.
 #' @param env The environment in which to evaluate \code{expr}.
 #' @param quoted Is \code{expr} a quoted expression (with \code{quote()})? This
 #'   is useful if you want to save an expression in a variable.
-#' @param func A function that returns a Shiny tag object, \code{\link{HTML}}, 
+#' @param func A function that returns a Shiny tag object, \code{\link{HTML}},
 #'   or a list of such objects (deprecated; use \code{expr} instead).
-#'   
+#'
 #' @seealso conditionalPanel
-#'   
+#'
 #' @export
 #' @examples
 #' \dontrun{
 #'   output$moreControls <- renderUI({
 #'     list(
-#'       
+#'
 #'     )
 #'   })
 #' }
@@ -372,42 +313,54 @@ renderUI <- function(expr, env=parent.frame(), quoted=FALSE, func=NULL) {
   if (!is.null(func)) {
     shinyDeprecated(msg="renderUI: argument 'func' is deprecated. Please use 'expr' instead.")
   } else {
-    func <- exprToFunction(expr, env, quoted)
+    installExprFunction(expr, "func", env, quoted)
   }
 
-  function() {
+  markRenderFunction(uiOutput, function(shinysession, name, ...) {
     result <- func()
     if (is.null(result) || length(result) == 0)
       return(NULL)
-    # Wrap result in tagList in case it is an ordinary list
-    return(as.character(tagList(result)))
-  }
+
+    result <- takeSingletons(result, shinysession$singletons, desingleton=FALSE)$ui
+    result <- surroundSingletons(result)
+    dependencies <- lapply(resolveDependencies(findDependencies(result)),
+      createWebDependency)
+    names(dependencies) <- NULL
+
+    # renderTags returns a list with head, singletons, and html
+    output <- list(
+      html = doRenderTags(result),
+      deps = dependencies
+    )
+
+    return(output)
+  })
 }
 
 #' File Downloads
-#' 
+#'
 #' Allows content from the Shiny application to be made available to the user as
-#' file downloads (for example, downloading the currently visible data as a CSV 
-#' file). Both filename and contents can be calculated dynamically at the time 
-#' the user initiates the download. Assign the return value to a slot on 
-#' \code{output} in your server function, and in the UI use 
+#' file downloads (for example, downloading the currently visible data as a CSV
+#' file). Both filename and contents can be calculated dynamically at the time
+#' the user initiates the download. Assign the return value to a slot on
+#' \code{output} in your server function, and in the UI use
 #' \code{\link{downloadButton}} or \code{\link{downloadLink}} to make the
 #' download available.
-#' 
-#' @param filename A string of the filename, including extension, that the 
-#'   user's web browser should default to when downloading the file; or a 
-#'   function that returns such a string. (Reactive values and functions may be 
+#'
+#' @param filename A string of the filename, including extension, that the
+#'   user's web browser should default to when downloading the file; or a
+#'   function that returns such a string. (Reactive values and functions may be
 #'   used from this function.)
-#' @param content A function that takes a single argument \code{file} that is a 
+#' @param content A function that takes a single argument \code{file} that is a
 #'   file path (string) of a nonexistent temp file, and writes the content to
 #'   that file path. (Reactive values and functions may be used from this
 #'   function.)
-#' @param contentType A string of the download's 
-#'   \href{http://en.wikipedia.org/wiki/Internet_media_type}{content type}, for 
-#'   example \code{"text/csv"} or \code{"image/png"}. If \code{NULL} or 
-#'   \code{NA}, the content type will be guessed based on the filename 
+#' @param contentType A string of the download's
+#'   \href{http://en.wikipedia.org/wiki/Internet_media_type}{content type}, for
+#'   example \code{"text/csv"} or \code{"image/png"}. If \code{NULL} or
+#'   \code{NA}, the content type will be guessed based on the filename
 #'   extension, or \code{application/octet-stream} if the extension is unknown.
-#'   
+#'
 #' @examples
 #' \dontrun{
 #' # In server.R:
@@ -419,18 +372,151 @@ renderUI <- function(expr, env=parent.frame(), quoted=FALSE, func=NULL) {
 #'     write.csv(data, file)
 #'   }
 #' )
-#' 
+#'
 #' # In ui.R:
 #' downloadLink('downloadData', 'Download')
 #' }
-#' 
+#'
 #' @export
 downloadHandler <- function(filename, content, contentType=NA) {
-  return(function(shinysession, name, ...) {
+  return(markRenderFunction(downloadButton, function(shinysession, name, ...) {
     shinysession$registerDownload(name, filename, contentType, content)
+  }))
+}
+
+#' Table output with the JavaScript library DataTables
+#'
+#' Makes a reactive version of the given function that returns a data frame (or
+#' matrix), which will be rendered with the DataTables library. Paging,
+#' searching, filtering, and sorting can be done on the R side using Shiny as
+#' the server infrastructure.
+#'
+#' For the \code{options} argument, the character elements that have the class
+#' \code{"AsIs"} (usually returned from \code{\link{I}()}) will be evaluated in
+#' JavaScript. This is useful when the type of the option value is not supported
+#' in JSON, e.g., a JavaScript function, which can be obtained by evaluating a
+#' character string. Note this only applies to the root-level elements of the
+#' options list, and the \code{I()} notation does not work for lower-level
+#' elements in the list.
+#' @param expr An expression that returns a data frame or a matrix.
+#' @param options A list of initialization options to be passed to DataTables,
+#'   or a function to return such a list.
+#' @param searchDelay The delay for searching, in milliseconds (to avoid too
+#'   frequent search requests).
+#' @param callback A JavaScript function to be applied to the DataTable object.
+#'   This is useful for DataTables plug-ins, which often require the DataTable
+#'   instance to be available (\url{http://datatables.net/extensions/}).
+#' @param escape Whether to escape HTML entities in the table: \code{TRUE} means
+#'   to escape the whole table, and \code{FALSE} means not to escape it.
+#'   Alternatively, you can specify numeric column indices or column names to
+#'   indicate which columns to escape, e.g. \code{1:5} (the first 5 columns),
+#'   \code{c(1, 3, 4)}, or \code{c(-1, -3)} (all columns except the first and
+#'   third), or \code{c('Species', 'Sepal.Length')}.
+#' @references \url{http://datatables.net}
+#' @note This function only provides the server-side version of DataTables
+#'   (using R to process the data object on the server side). There is a
+#'   separate package \pkg{DT} (\url{https://github.com/rstudio/DT}) that allows
+#'   you to create both server-side and client-side DataTables, and supports
+#'   additional DataTables features. Consider using \code{DT::renderDataTable()}
+#'   and \code{DT::dataTableOutput()} (see
+#'   \url{http://rstudio.github.io/DT/shiny.html} for more information).
+#' @export
+#' @inheritParams renderPlot
+#' @examples
+#' ## Only run this example in interactive R sessions
+#' if (interactive()) {
+#'   # pass a callback function to DataTables using I()
+#'   shinyApp(
+#'     ui = fluidPage(
+#'       fluidRow(
+#'         column(12,
+#'           dataTableOutput('table')
+#'         )
+#'       )
+#'     ),
+#'     server = function(input, output) {
+#'       output$table <- renderDataTable(iris,
+#'         options = list(
+#'           pageLength = 5,
+#'           initComplete = I("function(settings, json) {alert('Done.');}")
+#'         )
+#'       )
+#'     }
+#'   )
+#' }
+renderDataTable <- function(expr, options = NULL, searchDelay = 500,
+                            callback = 'function(oTable) {}', escape = TRUE,
+                            env = parent.frame(), quoted = FALSE) {
+  installExprFunction(expr, "func", env, quoted)
+
+  markRenderFunction(dataTableOutput, function(shinysession, name, ...) {
+    if (is.function(options)) options <- options()
+    options <- checkDT9(options)
+    res <- checkAsIs(options)
+    data <- func()
+    if (length(dim(data)) != 2) return() # expects a rectangular data object
+    if (is.data.frame(data)) data <- as.data.frame(data)
+    action <- shinysession$registerDataObj(name, data, dataTablesJSON)
+    colnames <- colnames(data)
+    # if escape is column names, turn names to numeric indices
+    if (is.character(escape)) {
+      escape <- stats::setNames(seq_len(ncol(data)), colnames)[escape]
+      if (any(is.na(escape)))
+        stop("Some column names in the 'escape' argument not found in data")
+    }
+    colnames[escape] <- htmlEscape(colnames[escape])
+    if (!is.logical(escape)) {
+      if (!is.numeric(escape))
+        stop("'escape' must be TRUE, FALSE, or a numeric vector, or column names")
+      escape <- paste(escape, collapse = ',')
+    }
+    list(
+      colnames = colnames, action = action, options = res$options,
+      evalOptions = if (length(res$eval)) I(res$eval), searchDelay = searchDelay,
+      callback = paste(callback, collapse = '\n'), escape = escape
+    )
   })
 }
 
+# a data frame containing the DataTables 1.9 and 1.10 names
+DT10Names <- function() {
+  rbind(
+    utils::read.table(
+      system.file('www/shared/datatables/upgrade1.10.txt', package = 'shiny'),
+      stringsAsFactors = FALSE
+    ),
+    c('aoColumns', 'Removed')  # looks like an omission on the upgrade guide
+  )
+}
+
+# check DataTables 1.9.x options, and give instructions for upgrading to 1.10.x
+checkDT9 <- function(options) {
+  nms <- names(options)
+  if (length(nms) == 0L) return(options)
+  DT10 <- DT10Names()
+  # e.g. the top level option name for oLanguage.sSearch should be oLanguage
+  i <- nms %in% gsub('[.].*', '', DT10[, 1])
+  if (!any(i)) return(options)  # did not see old option names, ready to go!
+  msg <- paste(
+    'shiny (>= 0.10.2) has upgraded DataTables from 1.9.4 to 1.10.2, ',
+    'and DataTables 1.10.x uses different parameter names with 1.9.x. ',
+    'Please follow the upgrade guide https://datatables.net/upgrade/1.10-convert',
+    ' to change your DataTables parameter names:\n\n',
+    paste(utils::formatUL(nms[i]), collapse = '\n'), '\n', sep = ''
+  )
+  j <- gsub('[.].*', '', DT10[, 1]) %in% nms
+  # I cannot help you upgrade automatically in these cases, so I have to stop
+  if (any(grepl('[.]', DT10[j, 1])) || any(grepl('[.]', DT10[j, 2]))) stop(msg)
+  warning(msg)
+  nms10 <- DT10[match(nms[i], DT10[, 1]), 2]
+  if (any(nms10 == 'Removed')) stop(
+    "These parameters have been removed in DataTables 1.10.x:\n\n",
+    paste(utils::formatUL(nms[i][nms10 == 'Removed']), collapse = '\n'),
+    "\n\n", msg
+  )
+  names(options)[i] <- nms10
+  options
+}
 
 # Deprecated functions ------------------------------------------------------
 

R/showcase.R

@@ -0,0 +1,179 @@
+#' @include globals.R
+NULL
+
+# Given the name of a license, return the appropriate link HTML for the
+# license, which may just be the name of the license if the name is
+# unrecognized.
+#
+# Recognizes the 'standard' set of licenses used for R packages
+# (see http://cran.r-project.org/doc/manuals/R-exts.html)
+licenseLink <- function(licenseName) {
+  licenses <- list(
+    "GPL-2" = "https://gnu.org/licenses/gpl-2.0.txt",
+    "GPL-3" = "https://gnu.org/licenses/gpl-3.0.txt",
+    "LGPL-3" = "https://www.gnu.org/licenses/lgpl-3.0.txt",
+    "LGPL-2" = "http://www.gnu.org/licenses/old-licenses/lgpl-2.0.txt",
+    "LGPL-2.1" = "http://www.gnu.org/licenses/lgpl-2.1.txt",
+    "AGPL-3" = "http://www.gnu.org/licenses/agpl-3.0.txt",
+    "Artistic-2.0" = "http://www.r-project.org/Licenses/Artistic-2.0",
+    "BSD_2_clause" = "http://www.r-project.org/Licenses/BSD_2_clause",
+    "BSD_3_clause" = "http://www.r-project.org/Licenses/BSD_3_clause",
+    "MIT" = "http://www.r-project.org/Licenses/MIT")
+  if (exists(licenseName, where = licenses)) {
+    tags$a(href=licenses[[licenseName]], licenseName)
+  } else {
+    licenseName
+  }
+}
+
+# Returns tags containing showcase directives intended for the <HEAD> of the
+# document.
+showcaseHead <- function() {
+
+  deps  <- list(
+    htmlDependency("jqueryui", "1.10.4", c(href="shared/jqueryui/1.10.4"),
+      script = "jquery-ui.min.js"),
+    htmlDependency("showdown", "0.3.1", c(href="shared/showdown/compressed"),
+      script = "showdown.js"),
+    htmlDependency("highlight.js", "6.2", c(href="shared/highlight"),
+      script = "highlight.pack.js")
+  )
+
+  mdfile <- file.path.ci(getwd(), 'Readme.md')
+  html <- with(tags, tagList(
+    script(src="shared/shiny-showcase.js"),
+    link(rel="stylesheet", type="text/css",
+         href="shared/highlight/rstudio.css"),
+    link(rel="stylesheet", type="text/css",
+         href="shared/shiny-showcase.css"),
+    if (file.exists(mdfile))
+      script(type="text/markdown", id="showcase-markdown-content",
+        paste(readUTF8(mdfile), collapse="\n"))
+    else ""
+  ))
+
+  return(attachDependencies(html, deps))
+}
+
+# Returns tags containing the application metadata (title and author) in
+# showcase mode.
+appMetadata <- function(desc) {
+  cols <- colnames(desc)
+  if ("Title" %in% cols)
+    with(tags, h4(class="text-muted shiny-showcase-apptitle", desc[1,"Title"],
+      if ("Author" %in% cols) small(
+        br(), "by",
+        if ("AuthorUrl" %in% cols)
+          a(href=desc[1,"AuthorUrl"], class="shiny-showcase-appauthor",
+            desc[1,"Author"])
+        else
+          desc[1,"Author"],
+        if ("AuthorEmail" %in% cols)
+          a(href=paste("mailto:", desc[1,"AuthorEmail"], sep = ''),
+            class="shiny-showcase-appauthoreemail",
+            desc[1,"AuthorEmail"])
+        else "")
+      else ""))
+  else ""
+}
+
+# Returns tags containing the application's code in Bootstrap-style tabs in
+# showcase mode.
+showcaseCodeTabs <- function(codeLicense) {
+  rFiles <- list.files(pattern = "\\.[rR]$")
+  with(tags, div(id="showcase-code-tabs",
+    a(id="showcase-code-position-toggle",
+      class="btn btn-default btn-sm",
+      onclick="toggleCodePosition()",
+      icon("level-up"),
+      "show with app"),
+    ul(class="nav nav-tabs",
+       lapply(rFiles, function(rFile) {
+         li(class=if (tolower(rFile) %in% c("app.r", "server.r")) "active" else "",
+            a(href=paste("#", gsub(".", "_", rFile, fixed=TRUE),
+                         "_code", sep=""),
+              "data-toggle"="tab", rFile))
+       })),
+    div(class="tab-content", id="showcase-code-content",
+        lapply(rFiles, function(rFile) {
+          div(class=paste("tab-pane",
+                          if (tolower(rFile) %in% c("app.r", "server.r")) " active"
+                          else "",
+                          sep=""),
+              id=paste(gsub(".", "_", rFile, fixed=TRUE),
+                       "_code", sep=""),
+              pre(class="shiny-code",
+                  # we need to prevent the indentation of <code> ... </code>
+                  HTML(format(tags$code(
+                    class="language-r",
+                    paste(readUTF8(file.path.ci(getwd(), rFile)), collapse="\n")
+                  ), indent = FALSE))))
+        })),
+    codeLicense))
+}
+
+# Returns tags containing the showcase application information (readme and
+# code).
+showcaseAppInfo <- function() {
+  descfile <- file.path.ci(getwd(), "DESCRIPTION")
+  hasDesc <- file.exists(descfile)
+  readmemd <- file.path.ci(getwd(), "Readme.md")
+  hasReadme <- file.exists(readmemd)
+  if (hasDesc) {
+    con <- textConnection(readUTF8(descfile))
+    on.exit(close(con), add = TRUE)
+    desc <- read.dcf(con)
+  }
+  with(tags,
+    div(class="container-fluid shiny-code-container well",
+        id="showcase-well",
+        div(class="row",
+          if (hasDesc || hasReadme) {
+            div(id="showcase-app-metadata", class="col-sm-4",
+                if (hasDesc) appMetadata(desc) else "",
+                if (hasReadme) div(id="readme-md"))
+          } else "",
+          div(id="showcase-code-inline",
+              class=if (hasReadme || hasDesc) "col-sm-8" else "col-sm-10 col-sm-offset-1",
+              showcaseCodeTabs(
+                if (hasDesc && "License" %in% colnames(desc)) {
+                  small(class="showcase-code-license text-muted",
+                        "Code license: ",
+                        licenseLink(desc[1,"License"]))
+                } else "")))))
+}
+
+
+# Returns the body of the showcase document, given the HTML it should wrap.
+showcaseBody <- function(htmlBody) {
+  with(tags, tagList(
+    table(id="showcase-app-code",
+          tr(td(id="showcase-app-container",
+                class="showcase-app-container-expanded",
+                htmlBody,
+             td(id="showcase-sxs-code",
+                class="showcase-sxs-code-collapsed")))),
+    showcaseAppInfo()))
+}
+
+# Sets the defaults for showcase mode (for app boot).
+setShowcaseDefault <- function(showcaseDefault) {
+  .globals$showcaseDefault <- showcaseDefault
+  .globals$showcaseOverride <- as.logical(showcaseDefault)
+}
+
+
+# Given a UI tag/tagList, wrap it in appropriate tags for showcase mode.
+showcaseUI <- function(ui) {
+  # If top-level tag is a body, replace its children with children wrapped in
+    # showcase stuff.
+  if (inherits(ui, "shiny.tag") && ui$name == "body") {
+    ui$children <- showcaseUI(ui$children)
+    return(ui)
+  }
+
+  tagList(
+    tags$head(showcaseHead()),
+    showcaseBody(ui)
+  )
+}

R/slider.R

@@ -1,133 +0,0 @@
-hasDecimals <- function(value) {
-  truncatedValue <- round(value)
-  return (!identical(value, truncatedValue))
-}
-
-#' Animation Options
-#' 
-#' Creates an options object for customizing animations for \link{sliderInput}.
-#' 
-#' @param interval The interval, in milliseconds, between each animation step.
-#' @param loop \code{TRUE} to automatically restart the animation when it 
-#'   reaches the end.
-#' @param playButton Specifies the appearance of the play button. Valid values 
-#'   are a one-element character vector (for a simple text label), an HTML tag 
-#'   or list of tags (using \code{\link{tag}} and friends), or raw HTML (using 
-#'   \code{\link{HTML}}).
-#' @param pauseButton Similar to \code{playButton}, but for the pause button.
-#'   
-#' @export
-animationOptions <- function(interval=1000,
-                             loop=FALSE,
-                             playButton=NULL,
-                             pauseButton=NULL) {
-  list(interval=interval,
-       loop=loop,
-       playButton=playButton,
-       pauseButton=pauseButton)
-}
-
-# Create a new slider control (list of slider input element and the script
-# tag used to configure it). This is a lower level control that should
-# be wrapped in an "input" construct (e.g. sliderInput in bootstrap.R)
-# 
-# this is a wrapper for: https://github.com/egorkhmelev/jslider
-# (www/shared/slider contains js, css, and img dependencies) 
-slider <- function(inputId, min, max, value, step = NULL, ...,
-                   round=FALSE, format='#,##0.#####', locale='us',
-                   ticks=TRUE, animate=FALSE) {
-  # validate inputId
-  inputId <- as.character(inputId)
-  if (!is.character(inputId))
-    stop("inputId not specified")
-    
-  # validate numeric inputs
-  if (!is.numeric(value) || !is.numeric(min) || !is.numeric(max)) 
-    stop("min, max, and value must all be numeric values")
-  else if (min(value) < min) 
-    stop(paste("slider initial value", value, 
-               "is less than the specified minimum"))
-  else if (max(value) > max) 
-    stop(paste("slider initial value", value, 
-               "is greater than the specified maximum"))
-  else if (min > max) 
-    stop(paste("slider maximum is greater than minimum"))
-  else if (!is.null(step)) {
-    if (!is.numeric(step)) 
-      stop("step is not a numeric value")
-    if (step > (max - min)) 
-      stop("step is greater than range")
-  }
-  
-  # step
-  range <- max - min
-  if (is.null(step)) {
-    # short range or decimals means continuous decimal
-    if (range < 2 || hasDecimals(min) || hasDecimals(max))
-      step <- range / 250 # ~ one step per pixel
-    else
-      step = 1
-  }
-  
-  # Default state is to not have ticks
-  if (identical(ticks, TRUE)) {
-    # Automatic ticks
-    tickCount <- (range / step) + 1
-    if (tickCount <= 26)
-      ticks <- paste(rep('|', floor(tickCount)), collapse=';')
-    else {
-      ticks <- NULL
-#       # This is a smarter auto-tick algorithm, but to be truly useful
-#       # we need jslider to be able to space ticks irregularly
-#       tickSize <- 10^(floor(log10(range/0.39)))
-#       if ((range / tickSize) == floor(range / tickSize)) {
-#         ticks <- paste(rep('|', (range / tickSize) + 1), collapse=';')
-#       }
-#       else {
-#         ticks <- NULL
-#       }
-    }
-  }
-  else if (is.numeric(ticks) && length(ticks) == 1) {
-    # Use n ticks
-    ticks <- paste(rep('|', ticks), collapse=';')
-  }
-  else if (length(ticks) > 1 && (is.numeric(ticks) || is.character(ticks))) {
-    # Explicit ticks
-    ticks <- paste(ticks, collapse=';')
-  }
-  else {
-    ticks <- NULL
-  }
-  
-  # build slider
-  sliderFragment <- list(tags$input(
-    id=inputId, type="slider", 
-    name=inputId, value=paste(value, collapse=';'), class="jslider",
-    'data-from'=min, 'data-to'=max, 'data-step'=step,
-    'data-skin'='plastic', 'data-round'=round, 'data-locale'=locale,
-    'data-format'=format, 'data-scale'=ticks,
-    'data-smooth'=FALSE))
-
-  if (identical(animate, TRUE))
-    animate <- animationOptions()
-  
-  if (!is.null(animate) && !identical(animate, FALSE)) {
-    if (is.null(animate$playButton))
-      animate$playButton <- 'Play'
-    if (is.null(animate$pauseButton))
-      animate$pauseButton <- 'Pause'
-    
-    sliderFragment[[length(sliderFragment)+1]] <-
-      tags$div(class='slider-animate-container',
-               tags$a(href='#',
-                      class='slider-animate-button',
-                      'data-target-id'=inputId,
-                      'data-interval'=animate$interval,
-                      'data-loop'=animate$loop,
-                      tags$span(class='play', animate$playButton),
-                      tags$span(class='pause', animate$pauseButton)))
-  }
-  
-  return(sliderFragment)
-}

R/stack.R

@@ -0,0 +1,70 @@
+# A Stack object backed by a list. The backing list will grow or shrink as
+# the stack changes in size.
+Stack <- R6Class(
+  'Stack',
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+
+    initialize = function(init = 20L) {
+      # init is the initial size of the list. It is also used as the minimum
+      # size of the list as it shrinks.
+      private$stack <- vector("list", init)
+      private$init <- init
+    },
+
+    push = function(..., .list = NULL) {
+      args <- c(list(...), .list)
+      new_size <- count + length(args)
+
+      # Grow if needed; double in size
+      while (new_size > length(stack)) {
+        stack[length(stack) * 2] <<- list(NULL)
+      }
+      stack[count + seq_along(args)] <<- args
+      count <<- new_size
+
+      invisible(self)
+    },
+
+    pop = function() {
+      if (count == 0L)
+        return(NULL)
+
+      value <- stack[[count]]
+      stack[count] <<- list(NULL)
+      count <<- count - 1L
+
+      # Shrink list if < 1/4 of the list is used, down to a minimum size of `init`
+      len <- length(stack)
+      if (len > init && count < len/4) {
+        new_len <- max(init, ceiling(len/2))
+        stack <<- stack[seq_len(new_len)]
+      }
+
+      value
+    },
+
+    peek = function() {
+      if (count == 0L)
+        return(NULL)
+      stack[[count]]
+    },
+
+    size = function() {
+      count
+    },
+
+    # Return the entire stack as a list, where the first item in the list is the
+    # oldest item in the stack, and the last item is the most recently added.
+    as_list = function() {
+      stack[seq_len(count)]
+    }
+  ),
+
+  private = list(
+    stack = NULL,   # A list that holds the items
+    count = 0L,     # Current number of items in the stack
+    init = 20L      # Initial and minimum size of the stack
+  )
+)

R/tags.R

@@ -1,402 +0,0 @@
-
-
-htmlEscape <- local({
-  .htmlSpecials <- list(
-    `&` = '&amp;',
-    `<` = '&lt;',
-    `>` = '&gt;'
-  )
-  .htmlSpecialsPattern <- paste(names(.htmlSpecials), collapse='|')
-  .htmlSpecialsAttrib <- c(
-    .htmlSpecials,
-    `'` = '&#39;',
-    `"` = '&quot;',
-    `\r` = '&#13;',
-    `\n` = '&#10;'
-  )
-  .htmlSpecialsPatternAttrib <- paste(names(.htmlSpecialsAttrib), collapse='|')
-  
-  function(text, attribute=TRUE) {
-    pattern <- if(attribute)
-      .htmlSpecialsPatternAttrib 
-    else
-      .htmlSpecialsPattern
-    
-    # Short circuit in the common case that there's nothing to escape
-    if (!grepl(pattern, text))
-      return(text)
-    
-    specials <- if(attribute)
-      .htmlSpecialsAttrib
-    else
-      .htmlSpecials
-    
-    for (chr in names(specials)) {
-      text <- gsub(chr, specials[[chr]], text, fixed=TRUE)
-    }
-    
-    return(text)
-  }
-})
-
-isTag <- function(x) {
-  inherits(x, "shiny.tag")
-}
-
-#' @S3method print shiny.tag
-print.shiny.tag <- function(x, ...) {
-  print(as.character(x), ...)
-}
-
-#' @S3method format shiny.tag
-format.shiny.tag <- function(x, ...) {
-  as.character.shiny.tag(x)
-}
-
-#' @S3method as.character shiny.tag
-as.character.shiny.tag <- function(x, ...) {
-  f = file()
-  on.exit(close(f))
-  textWriter <- function(text) {
-    cat(text, file=f)
-  }
-  tagWrite(x, textWriter)
-  return(HTML(paste(readLines(f, warn=FALSE), collapse='\n')))
-}
-
-#' @S3method print shiny.tag.list
-print.shiny.tag.list <- print.shiny.tag
-
-#' @S3method format shiny.tag.list
-format.shiny.tag.list <- format.shiny.tag
-
-#' @S3method as.character shiny.tag.list
-as.character.shiny.tag.list <- as.character.shiny.tag
-
-normalizeText <- function(text) {
-  if (!is.null(attr(text, "html")))
-    text
-  else
-    htmlEscape(text, attribute=FALSE)
-  
-}
-
-#' @export
-tagList <- function(...) {
-  lst <- list(...)
-  class(lst) <- c("shiny.tag.list", "list")
-  return(lst)
-}
-
-#' @export
-tagAppendChild <- function(tag, child) {
-  tag$children[[length(tag$children)+1]] <- child
-  tag
-}
-
-#' @export
-tagAppendChildren <- function(tag, ..., list = NULL) {
-  tag$children <- c(tag$children, c(list(...), list))
-  tag
-}
-
-#' @export
-tagSetChildren <- function(tag, ..., list = NULL) {
-  tag$children <- c(list(...), list)
-  tag
-}
-
-#' @export
-tag <- function(`_tag_name`, varArgs) {
-  # Get arg names; if not a named list, use vector of empty strings
-  varArgsNames <- names(varArgs)
-  if (is.null(varArgsNames))
-    varArgsNames <- character(length=length(varArgs))
-
-  # Named arguments become attribs, dropping NULL values
-  named_idx <- nzchar(varArgsNames)
-  attribs <- dropNulls(varArgs[named_idx])
-  
-  # Unnamed arguments are flattened and added as children.
-  # Use unname() to remove the names attribute from the list, which would
-  # consist of empty strings anyway.
-  children <- flattenTags(unname(varArgs[!named_idx]))
-
-  # Return tag data structure
-  structure(
-    list(name = `_tag_name`,
-         attribs = attribs,
-         children = children),
-    class = "shiny.tag"
-  )
-}
-
-tagWrite <- function(tag, textWriter, indent=0, context = NULL, eol = "\n") {
-  
-  # optionally process a list of tags
-  if (!isTag(tag) && is.list(tag)) {
-    sapply(tag, function(t) tagWrite(t, textWriter, indent, context))
-    return (NULL)
-  }
-  
-  # first call optional filter -- exit function if it returns false
-  if (!is.null(context) && !is.null(context$filter) && !context$filter(tag))
-    return (NULL)
-  
-  # compute indent text
-  indentText <- paste(rep(" ", indent*2), collapse="")
-  
-  # Check if it's just text (may either be plain-text or HTML)
-  if (is.character(tag)) {
-    textWriter(paste(indentText, normalizeText(tag), eol, sep=""))
-    return (NULL)
-  }
-  
-  # write tag name
-  textWriter(paste(indentText, "<", tag$name, sep=""))
-  
-  # write attributes
-  for (attrib in names(tag$attribs)) {
-    attribValue <- tag$attribs[[attrib]]
-    if (!is.na(attribValue)) {
-      if (is.logical(attribValue))
-        attribValue <- tolower(attribValue)
-      text <- htmlEscape(attribValue, attribute=TRUE) 
-      textWriter(paste(" ", attrib,"=\"", text, "\"", sep=""))
-    }
-    else {
-      textWriter(paste(" ", attrib, sep=""))
-    }
-  }
-  
-  # write any children
-  if (length(tag$children) > 0) {
-    textWriter(">")
-    
-    # special case for a single child text node (skip newlines and indentation)
-    if ((length(tag$children) == 1) && is.character(tag$children[[1]]) ) {
-      tagWrite(tag$children[[1]], textWriter, 0, context, "")
-      textWriter(paste("</", tag$name, ">", eol, sep=""))
-    }
-    else {
-      textWriter("\n")
-      for (child in tag$children)
-        tagWrite(child, textWriter, indent+1, context)
-      textWriter(paste(indentText, "</", tag$name, ">", eol, sep=""))
-    }
-  }
-  else {
-    # only self-close void elements 
-    # (see: http://dev.w3.org/html5/spec/single-page.html#void-elements)
-    if (tag$name %in% c("area", "base", "br", "col", "command", "embed", "hr", 
-                        "img", "input", "keygen", "link", "meta", "param",
-                        "source", "track", "wbr")) {
-      textWriter(paste("/>", eol, sep=""))
-    }
-    else {
-      textWriter(paste("></", tag$name, ">", eol, sep=""))
-    }
-  }
-}
-
-
-# environment used to store all available tags
-#' @export
-tags <- list(
-  a = function(...) tag("a", list(...)),
-  abbr = function(...) tag("abbr", list(...)),
-  address = function(...) tag("address", list(...)),
-  area = function(...) tag("area", list(...)),
-  article = function(...) tag("article", list(...)),
-  aside = function(...) tag("aside", list(...)),
-  audio = function(...) tag("audio", list(...)),
-  b = function(...) tag("b", list(...)),
-  base = function(...) tag("base", list(...)),
-  bdi = function(...) tag("bdi", list(...)),
-  bdo = function(...) tag("bdo", list(...)),
-  blockquote = function(...) tag("blockquote", list(...)),
-  body = function(...) tag("body", list(...)),
-  br = function(...) tag("br", list(...)),
-  button = function(...) tag("button", list(...)),
-  canvas = function(...) tag("canvas", list(...)),
-  caption = function(...) tag("caption", list(...)),
-  cite = function(...) tag("cite", list(...)),
-  code = function(...) tag("code", list(...)),
-  col = function(...) tag("col", list(...)),
-  colgroup = function(...) tag("colgroup", list(...)),
-  command = function(...) tag("command", list(...)),
-  data = function(...) tag("data", list(...)),
-  datalist = function(...) tag("datalist", list(...)),
-  dd = function(...) tag("dd", list(...)),
-  del = function(...) tag("del", list(...)),
-  details = function(...) tag("details", list(...)),
-  dfn = function(...) tag("dfn", list(...)),
-  div = function(...) tag("div", list(...)),
-  dl = function(...) tag("dl", list(...)),
-  dt = function(...) tag("dt", list(...)),
-  em = function(...) tag("em", list(...)),
-  embed = function(...) tag("embed", list(...)),
-  eventsource = function(...) tag("eventsource", list(...)),
-  fieldset = function(...) tag("fieldset", list(...)),
-  figcaption = function(...) tag("figcaption", list(...)),
-  figure = function(...) tag("figure", list(...)),
-  footer = function(...) tag("footer", list(...)),
-  form = function(...) tag("form", list(...)),
-  h1 = function(...) tag("h1", list(...)),
-  h2 = function(...) tag("h2", list(...)),
-  h3 = function(...) tag("h3", list(...)),
-  h4 = function(...) tag("h4", list(...)),
-  h5 = function(...) tag("h5", list(...)),
-  h6 = function(...) tag("h6", list(...)),
-  head = function(...) tag("head", list(...)),
-  header = function(...) tag("header", list(...)),
-  hgroup = function(...) tag("hgroup", list(...)),
-  hr = function(...) tag("hr", list(...)),
-  html = function(...) tag("html", list(...)),
-  i = function(...) tag("i", list(...)),
-  iframe = function(...) tag("iframe", list(...)),
-  img = function(...) tag("img", list(...)),
-  input = function(...) tag("input", list(...)),
-  ins = function(...) tag("ins", list(...)),
-  kbd = function(...) tag("kbd", list(...)),
-  keygen = function(...) tag("keygen", list(...)),
-  label = function(...) tag("label", list(...)),
-  legend = function(...) tag("legend", list(...)),
-  li = function(...) tag("li", list(...)),
-  link = function(...) tag("link", list(...)),
-  mark = function(...) tag("mark", list(...)),
-  map = function(...) tag("map", list(...)),
-  menu = function(...) tag("menu", list(...)),
-  meta = function(...) tag("meta", list(...)),
-  meter = function(...) tag("meter", list(...)),
-  nav = function(...) tag("nav", list(...)),
-  noscript = function(...) tag("noscript", list(...)),
-  object = function(...) tag("object", list(...)),
-  ol = function(...) tag("ol", list(...)),
-  optgroup = function(...) tag("optgroup", list(...)),
-  option = function(...) tag("option", list(...)),
-  output = function(...) tag("output", list(...)),
-  p = function(...) tag("p", list(...)),
-  param = function(...) tag("param", list(...)),
-  pre = function(...) tag("pre", list(...)),
-  progress = function(...) tag("progress", list(...)),
-  q = function(...) tag("q", list(...)),
-  ruby = function(...) tag("ruby", list(...)),
-  rp = function(...) tag("rp", list(...)),
-  rt = function(...) tag("rt", list(...)),
-  s = function(...) tag("s", list(...)),
-  samp = function(...) tag("samp", list(...)),
-  script = function(...) tag("script", list(...)),
-  section = function(...) tag("section", list(...)),
-  select = function(...) tag("select", list(...)),
-  small = function(...) tag("small", list(...)),
-  source = function(...) tag("source", list(...)),
-  span = function(...) tag("span", list(...)),
-  strong = function(...) tag("strong", list(...)),
-  style = function(...) tag("style", list(...)),
-  sub = function(...) tag("sub", list(...)),
-  summary = function(...) tag("summary", list(...)),
-  sup = function(...) tag("sup", list(...)),
-  table = function(...) tag("table", list(...)),
-  tbody = function(...) tag("tbody", list(...)),
-  td = function(...) tag("td", list(...)),
-  textarea = function(...) tag("textarea", list(...)),
-  tfoot = function(...) tag("tfoot", list(...)),
-  th = function(...) tag("th", list(...)),
-  thead = function(...) tag("thead", list(...)),
-  time = function(...) tag("time", list(...)),
-  title = function(...) tag("title", list(...)),
-  tr = function(...) tag("tr", list(...)),
-  track = function(...) tag("track", list(...)),
-  u = function(...) tag("u", list(...)),
-  ul = function(...) tag("ul", list(...)),
-  var = function(...) tag("var", list(...)),
-  video = function(...) tag("video", list(...)),
-  wbr = function(...) tag("wbr", list(...))
-)
-
-#' Mark Characters as HTML
-#' 
-#' Marks the given text as HTML, which means the \link{tag} functions will know
-#' not to perform HTML escaping on it.
-#' 
-#' @param text The text value to mark with HTML
-#' @param ... Any additional values to be converted to character and
-#'   concatenated together
-#' @return The same value, but marked as HTML.
-#' 
-#' @examples
-#' el <- div(HTML("I like <u>turtles</u>"))
-#' cat(as.character(el))
-#'   
-#' @export
-HTML <- function(text, ...) {
-  htmlText <- c(text, as.character(list(...)))
-  htmlText <- paste(htmlText, collapse=" ")
-  attr(htmlText, "html") <- TRUE
-  htmlText
-}
-
-#' Evaluate an expression using the \code{tags}
-#'
-#' This function makes it simpler to write HTML-generating code. Instead of
-#' needing to specify \code{tags} each time a tag function is used, as in
-#' \code{tags$div()} and \code{tags$p()}, code inside \code{withTags} is
-#' evaluated with \code{tags} searched first, so you can simply use
-#' \code{div()} and \code{p()}.
-#'
-#' If your code uses an object which happens to have the same name as an
-#' HTML tag function, such as \code{source()} or \code{summary()}, it will call
-#' the tag function. To call the intended (non-tags function), specify the
-#' namespace, as in \code{base::source()} or \code{base::summary()}.
-#'
-#' @param code A set of tags.
-#'
-#' @examples
-#' # Using tags$ each time
-#' tags$div(class = "myclass",
-#'   tags$h3("header"),
-#'   tags$p("text")
-#' )
-#'
-#' # Equivalent to above, but using withTags
-#' withTags(
-#'   div(class = "myclass",
-#'     h3("header"),
-#'     p("text")
-#'   )
-#' )
-#'
-#'
-#' @export
-withTags <- function(code) {
-  eval(substitute(code), envir = as.list(tags), enclos = parent.frame())
-}
-
-
-# Given a list of tags, lists, and other items, return a flat list, where the
-# items from the inner, nested lists are pulled to the top level, recursively.
-flattenTags <- function(x) {
-  if (isTag(x)) {
-    # For tags, wrap them into a list (which will be unwrapped by caller)
-    list(x)
-  } else if (is.list(x)) {
-    if (length(x) == 0) {
-      # Empty lists are simply returned
-      x
-    } else {
-      # For items that are lists (but not tags), recurse
-      unlist(lapply(x, flattenTags), recursive = FALSE)
-    }
-
-  } else if (is.character(x)){
-    # This will preserve attributes if x is a character with attribute,
-    # like what HTML() produces
-    list(x)
-
-  } else {
-    # For other items, coerce to character and wrap them into a list (which
-    # will be unwrapped by caller). Note that this will strip attributes.
-    list(as.character(x))
-  }
-}

R/tar.R

@@ -46,7 +46,7 @@ untar2 <- function(tarfile, files = NULL, list = FALSE, exdir = ".")
     mydir.create <- function(path, ...) {
         ## for Windows' sake
         path <- sub("[\\/]$", "", path)
-        if(file_test("-d", path)) return()
+        if(utils::file_test("-d", path)) return()
         if(!dir.create(path, showWarnings = TRUE, recursive = TRUE, ...))
            stop(gettextf("failed to create directory %s", sQuote(path)),
                 domain = NA)
@@ -141,7 +141,7 @@ untar2 <- function(tarfile, files = NULL, list = FALSE, exdir = ".")
                             warning(gettextf("failed to copy %s to %s", sQuote(name2), sQuote(name)), domain = NA)
                     }
                 } else {
-                    if(.Platform$OS.type == "windows") {
+                    if(isWindows()) {
                         ## this will not work for links to dirs
                         from <- file.path(dirname(name), name2)
                         if (!file.copy(from, name))

R/timer.R

@@ -4,16 +4,17 @@ now <- function() {
   as.numeric(Sys.time()) * 1000
 }
 
-TimerCallbacks <- setRefClass(
+TimerCallbacks <- R6Class(
   'TimerCallbacks',
-  fields = list(
-    .nextId = 'integer',
+  portable = FALSE,
+  class = FALSE,
+  public = list(
+    .nextId = 0L,
     .funcs = 'Map',
-    .times = 'data.frame'
-  ),
-  methods = list(
+    .times = data.frame(),
+
     initialize = function() {
-      .nextId <<- 0L
+      .funcs <<- Map$new()
     },
     clear = function() {
       .nextId <<- 0L
@@ -23,17 +24,17 @@ TimerCallbacks <- setRefClass(
     schedule = function(millis, func) {
       id <- .nextId
       .nextId <<- .nextId + 1L
-      
+
       t <- now()
-      
+
       # TODO: Horribly inefficient, use a heap instead
       .times <<- rbind(.times, data.frame(time=t+millis,
                                           scheduled=t,
                                           id=id))
       .times <<- .times[order(.times$time),]
-      
+
       .funcs$set(as.character(id), func)
-      
+
       return(id)
     },
     timeToNextEvent = function() {
@@ -46,18 +47,18 @@ TimerCallbacks <- setRefClass(
       elapsed <- .times$time < now()
       result <- .times[elapsed,]
       .times <<- .times[!elapsed,]
-      
+
       # TODO: Examine scheduled column to check if any funny business
       #       has occurred with the system clock (e.g. if scheduled
       #       is later than now())
-      
+
       return(result)
     },
     executeElapsed = function() {
       elapsed <- takeElapsed()
       if (length(elapsed) == 0)
         return(FALSE)
-      
+
       for (id in elapsed$id) {
         thisFunc <- .funcs$remove(as.character(id))
         # TODO: Catch exception, and...?

R/update-input.R

@@ -54,38 +54,6 @@ updateTextInput <- function(session, inputId, label = NULL, value = NULL) {
 updateCheckboxInput <- updateTextInput
 
 
-#' Change the value of a slider input on the client
-#'
-#' @template update-input
-#' @param value The value to set for the input object.
-#'
-#' @seealso \code{\link{sliderInput}}
-#'
-#' @examples
-#' \dontrun{
-#' shinyServer(function(input, output, session) {
-#'
-#'   observe({
-#'     # We'll use the input$controller variable multiple times, so save it as x
-#'     # for convenience.
-#'     x <- input$controller
-#'
-#'     # Similar to number and text. only label and value can be set for slider
-#'     updateSliderInput(session, "inSlider",
-#'       label = paste("Slider label", x),
-#'       value = x)
-#'
-#'     # For sliders that pick out a range, pass in a vector of 2 values.
-#'     updateSliderInput(session, "inSlider2", value = c(x-1, x+1))
-#'
-#'     # An NA means to not change that value (the low or high one)
-#'     updateSliderInput(session, "inSlider3", value = c(NA, x+2))
-#'   })
-#' })
-#' }
-#' @export
-updateSliderInput <- updateTextInput
-
 #' Change the value of a date input on the client
 #'
 #' @template update-input
@@ -118,7 +86,7 @@ updateSliderInput <- updateTextInput
 #' }
 #' @export
 updateDateInput <- function(session, inputId, label = NULL, value = NULL,
-    min = NULL, max = NULL) {
+                            min = NULL, max = NULL) {
 
   # If value is a date object, convert it to a string with yyyy-mm-dd format
   # Same for min and max
@@ -163,8 +131,8 @@ updateDateInput <- function(session, inputId, label = NULL, value = NULL,
 #' }
 #' @export
 updateDateRangeInput <- function(session, inputId, label = NULL,
-    start = NULL, end = NULL, min = NULL, max = NULL) {
-
+                                 start = NULL, end = NULL, min = NULL,
+                                 max = NULL) {
   # Make sure start and end are strings, not date objects. This is for
   # consistency across different locales.
   if (inherits(start, "Date"))  start <- format(start, '%Y-%m-%d')
@@ -186,10 +154,12 @@ updateDateRangeInput <- function(session, inputId, label = NULL,
 #'
 #' @param session The \code{session} object passed to function given to
 #'   \code{shinyServer}.
-#' @param inputId The id of the tabset panel object.
+#' @param inputId The id of the \code{tabsetPanel}, \code{navlistPanel},
+#' or \code{navbarPage} object.
 #' @param selected The name of the tab to make active.
 #'
-#' @seealso \code{\link{tabsetPanel}}
+#' @seealso \code{\link{tabsetPanel}}, \code{\link{navlistPanel}},
+#' \code{\link{navbarPage}}
 #'
 #' @examples
 #' \dontrun{
@@ -200,7 +170,7 @@ updateDateRangeInput <- function(session, inputId, label = NULL,
 #'     x_even <- input$controller %% 2 == 0
 #'
 #'     # Change the selected tab.
-#'     # Note that the tabsetPanel must have been created with an 'id' argument
+#'     # Note that the tabset container must have been created with an 'id' argument
 #'     if (x_even) {
 #'       updateTabsetPanel(session, "inTabset", selected = "panel2")
 #'     } else {
@@ -215,6 +185,13 @@ updateTabsetPanel <- function(session, inputId, selected = NULL) {
   session$sendInputMessage(inputId, message)
 }
 
+#' @rdname updateTabsetPanel
+#' @export
+updateNavbarPage <- updateTabsetPanel
+
+#' @rdname updateTabsetPanel
+#' @export
+updateNavlistPanel <- updateTabsetPanel
 
 #' Change the value of a number input on the client
 #'
@@ -247,17 +224,107 @@ updateTabsetPanel <- function(session, inputId, selected = NULL) {
 updateNumericInput <- function(session, inputId, label = NULL, value = NULL,
     min = NULL, max = NULL, step = NULL) {
 
-  message <- dropNulls(list(label=label, value=value, min=min, max=max, step=step))
+  message <- dropNulls(list(
+    label = label, value = formatNoSci(value),
+    min = formatNoSci(min), max = formatNoSci(max), step = formatNoSci(step)
+  ))
+  session$sendInputMessage(inputId, message)
+}
+
+#' Change the value of a slider input on the client
+#'
+#' @template update-input
+#' @param value The value to set for the input object.
+#' @param min Minimum value.
+#' @param max Maximum value.
+#' @param step Step size.
+#'
+#' @seealso \code{\link{sliderInput}}
+#'
+#' @examples
+#' ## Only run this example in interactive R sessions
+#' if (interactive()) {
+#'   shinyApp(
+#'     ui = fluidPage(
+#'       sidebarLayout(
+#'         sidebarPanel(
+#'           p("The first slider controls the second"),
+#'           sliderInput("control", "Controller:", min=0, max=20, value=10,
+#'                        step=1),
+#'           sliderInput("receive", "Receiver:", min=0, max=20, value=10,
+#'                        step=1)
+#'         ),
+#'         mainPanel()
+#'       )
+#'     ),
+#'     server = function(input, output, session) {
+#'       observe({
+#'         val <- input$control
+#'         # Control the value, min, max, and step.
+#'         # Step size is 2 when input value is even; 1 when value is odd.
+#'         updateSliderInput(session, "receive", value = val,
+#'           min = floor(val/2), max = val+4, step = (val+1)%%2 + 1)
+#'       })
+#'     }
+#'   )
+#' }
+#' @export
+updateSliderInput <- function(session, inputId, label = NULL, value = NULL,
+  min = NULL, max = NULL, step = NULL)
+{
+  # Make sure that value, min, max all have the same type, because we need
+  # special handling for dates and datetimes.
+  vals <- dropNulls(list(value, min, max))
+
+  type <- unique(lapply(vals, function(x) {
+    if      (inherits(x, "Date"))   "date"
+    else if (inherits(x, "POSIXt")) "datetime"
+    else                            "number"
+  }))
+  if (length(type) > 1) {
+    stop("Type mismatch for value, min, and max")
+  }
+
+  if (type == "date" || type == "datetime") {
+    to_ms <- function(x) 1000 * as.numeric(as.POSIXct(x))
+    if (!is.null(min))   min   <- to_ms(min)
+    if (!is.null(max))   max   <- to_ms(max)
+    if (!is.null(value)) value <- to_ms(value)
+  }
+
+  message <- dropNulls(list(
+    label = label,
+    value = formatNoSci(value),
+    min = formatNoSci(min),
+    max = formatNoSci(max),
+    step = formatNoSci(step)
+  ))
   session$sendInputMessage(inputId, message)
 }
 
 
+updateInputOptions <- function(session, inputId, label = NULL, choices = NULL,
+                               selected = NULL, inline = FALSE,
+                               type = 'checkbox') {
+
+  choices <- choicesWithNames(choices)
+  if (!is.null(selected))
+    selected <- validateSelected(selected, choices, inputId)
+
+  options <- if (length(choices))
+    format(tagList(
+      generateOptions(inputId, choices, selected, inline, type = type)
+    ))
+
+  message <- dropNulls(list(label = label, options = options, value = selected))
+
+  session$sendInputMessage(inputId, message)
+}
+
 #' Change the value of a checkbox group input on the client
 #'
 #' @template update-input
-#' @param choices A named vector or named list of options. For each item, the
-#'   name will be used as the label, and the value will be used as the value.
-#' @param selected A vector or list of options which will be selected.
+#' @inheritParams checkboxGroupInput
 #'
 #' @seealso \code{\link{checkboxGroupInput}}
 #'
@@ -283,38 +350,23 @@ updateNumericInput <- function(session, inputId, label = NULL, value = NULL,
 #'     updateCheckboxGroupInput(session, "inCheckboxGroup2",
 #'       label = paste("checkboxgroup label", x),
 #'       choices = cb_options,
-#'       selected = sprintf("option label %d 2", x)
+#'       selected = sprintf("option-%d-2", x)
 #'     )
 #'   })
 #' })
 #' }
 #' @export
 updateCheckboxGroupInput <- function(session, inputId, label = NULL,
-  choices = NULL, selected = NULL) {
-
-  choices <- choicesWithNames(choices)
-
-  options <- mapply(choices, names(choices),
-    SIMPLIFY = FALSE, USE.NAMES = FALSE,
-    FUN = function(value, name) {
-      list(value = value,
-           label = name,
-           checked = name %in% selected)
-    }
-  )
-
-  message <- dropNulls(list(label = label, options = options))
-
-  session$sendInputMessage(inputId, message)
+                                     choices = NULL, selected = NULL,
+                                     inline = FALSE) {
+  updateInputOptions(session, inputId, label, choices, selected, inline)
 }
 
 
 #' Change the value of a radio input on the client
 #'
 #' @template update-input
-#' @param choices A named vector or named list of options. For each item, the
-#'   name will be used as the label, and the value will be used as the value.
-#' @param selected A vector or list of options which will be selected.
+#' @inheritParams radioButtons
 #'
 #' @seealso \code{\link{radioButtons}}
 #'
@@ -338,21 +390,24 @@ updateCheckboxGroupInput <- function(session, inputId, label = NULL,
 #'     updateRadioButtons(session, "inRadio2",
 #'       label = paste("Radio label", x),
 #'       choices = r_options,
-#'       selected = sprintf("option label %d 2", x)
+#'       selected = sprintf("option-%d-2", x)
 #'     )
 #'   })
 #' })
 #' }
 #' @export
-updateRadioButtons <- updateCheckboxGroupInput
+updateRadioButtons <- function(session, inputId, label = NULL, choices = NULL,
+                               selected = NULL, inline = FALSE) {
+  # you must select at least one radio button
+  if (is.null(selected) && !is.null(choices)) selected <- choices[[1]]
+  updateInputOptions(session, inputId, label, choices, selected, inline, type = 'radio')
+}
 
 
 #' Change the value of a select input on the client
 #'
 #' @template update-input
-#' @param choices A named vector or named list of options. For each item, the
-#'   name will be used as the label, and the value will be used as the value.
-#' @param selected A vector or list of options which will be selected.
+#' @inheritParams selectInput
 #'
 #' @seealso \code{\link{selectInput}}
 #'
@@ -379,27 +434,92 @@ updateRadioButtons <- updateCheckboxGroupInput
 #'     updateSelectInput(session, "inSelect2",
 #'       label = paste("Select label", x),
 #'       choices = s_options,
-#'       selected = sprintf("option label %d 2", x)
+#'       selected = sprintf("option-%d-2", x)
 #'     )
 #'   })
 #' })
 #' }
 #' @export
 updateSelectInput <- function(session, inputId, label = NULL, choices = NULL,
-    selected = NULL) {
-
-  choices <- choicesWithNames(choices)
-
-  options <- mapply(choices, names(choices),
-    SIMPLIFY = FALSE, USE.NAMES = FALSE,
-    FUN = function(value, name) {
-      list(value = value,
-           label = name,
-           selected = name %in% selected)
-    }
-  )
-
-  message <- dropNulls(list(label = label, options = options))
-
+                              selected = NULL) {
+  choices <- if (!is.null(choices)) choicesWithNames(choices)
+  if (!is.null(selected))
+    selected <- validateSelected(selected, choices, inputId)
+  options <- if (!is.null(choices)) selectOptions(choices, selected)
+  message <- dropNulls(list(label = label, options = options, value = selected))
   session$sendInputMessage(inputId, message)
 }
+
+#' @rdname updateSelectInput
+#' @inheritParams selectizeInput
+#' @param server whether to store \code{choices} on the server side, and load
+#'   the select options dynamically on searching, instead of writing all
+#'   \code{choices} into the page at once (i.e., only use the client-side
+#'   version of \pkg{selectize.js})
+#' @export
+updateSelectizeInput <- function(session, inputId, label = NULL, choices = NULL,
+                                 selected = NULL, options = list(),
+                                 server = FALSE) {
+  if (length(options)) {
+    res <- checkAsIs(options)
+    cfg <- tags$script(
+      type = 'application/json',
+      `data-for` = inputId,
+      `data-eval` = if (length(res$eval)) HTML(toJSON(res$eval)),
+      HTML(toJSON(res$options))
+    )
+    session$sendInputMessage(inputId, list(config = as.character(cfg)))
+  }
+  if (!server) {
+    return(updateSelectInput(session, inputId, label, choices, selected))
+  }
+  value <- unname(selected)
+  selected <- choicesWithNames(selected)
+  message <- dropNulls(list(
+    label = label,
+    value = value,
+    selected = if (length(selected)) {
+      columnToRowData(list(label = names(selected), value = selected))
+    },
+    url = session$registerDataObj(inputId, choices, selectizeJSON)
+  ))
+  session$sendInputMessage(inputId, message)
+}
+
+selectizeJSON <- function(data, req) {
+  query <- parseQueryString(req$QUERY_STRING)
+  # extract the query variables, conjunction (and/or), search string, maximum options
+  var <- c(jsonlite::fromJSON(query$field))
+  cjn <- if (query$conju == 'and') all else any
+  # all keywords in lower-case, for case-insensitive matching
+  key <- unique(strsplit(tolower(query$query), '\\s+')[[1]])
+  if (identical(key, '')) key <- character(0)
+  mop <- query$maxop
+
+  # convert a single vector to a data frame so it returns {label: , value: }
+  # later in JSON; other objects return arbitrary JSON {x: , y: , foo: , ...}
+  data <- if (is.atomic(data)) {
+    data.frame(label = names(choicesWithNames(data)), value = data,
+               stringsAsFactors = FALSE)
+  } else as.data.frame(data, stringsAsFactors = FALSE)
+
+  # start searching for keywords in all specified columns
+  idx <- logical(nrow(data))
+  if (length(key)) for (v in var) {
+    matches <- do.call(
+      cbind,
+      lapply(key, function(k) {
+        grepl(k, tolower(as.character(data[[v]])), fixed = TRUE)
+      })
+    )
+    # merge column matches using OR, and match multiple keywords in one column
+    # using the conjunction setting (AND or OR)
+    idx <- idx | apply(matches, 1, cjn)
+  }
+  # only return the first n rows (n = maximum options in configuration)
+  idx <- utils::head(if (length(key)) which(idx) else seq_along(idx), mop)
+  data <- data[idx, ]
+
+  res <- toJSON(columnToRowData(data))
+  httpResponse(200, 'application/json', enc2utf8(res))
+}

README.md

@@ -1,8 +1,10 @@
-# Shiny 
+# Shiny
+
+[![Build Status](https://travis-ci.org/rstudio/shiny.svg?branch=master)](https://travis-ci.org/rstudio/shiny)
 
 Shiny is a new package from RStudio that makes it incredibly easy to build interactive web applications with R.
 
-For an introduction and examples, visit the [Shiny homepage](http://www.rstudio.com/shiny/).
+For an introduction and examples, visit the [Shiny Dev Center](http://shiny.rstudio.com/).
 
 ## Features
 
@@ -10,26 +12,50 @@ For an introduction and examples, visit the [Shiny homepage](http://www.rstudio.
 * Shiny applications are automatically "live" in the same way that spreadsheets are live. Outputs change instantly as users modify inputs, without requiring a reload of the browser.
 * Shiny user interfaces can be built entirely using R, or can be written directly in HTML, CSS, and JavaScript for more flexibility.
 * Works in any R environment (Console R, Rgui for Windows or Mac, ESS, StatET, RStudio, etc.)
-* Attractive default UI theme based on [Twitter Bootstrap](http://twitter.github.com/bootstrap).
+* Attractive default UI theme based on [Bootstrap](http://getbootstrap.com/2.3.2/).
 * A highly customizable slider widget with built-in support for animation.
 * Pre-built output widgets for displaying plots, tables, and printed output of R objects.
-* Fast bidirectional communication between the web browser and R using the [websockets](http://illposed.net/websockets.html) package.
+* Fast bidirectional communication between the web browser and R using the [httpuv](https://github.com/rstudio/httpuv) package.
 * Uses a [reactive](http://en.wikipedia.org/wiki/Reactive_programming) programming model that eliminates messy event handling code, so you can focus on the code that really matters.
 * Develop and redistribute your own Shiny widgets that other developers can easily drop into their own applications (coming soon!).
 
 ## Installation
 
-From an R console:
+To install the stable version from CRAN, simply run the following from an R console:
 
 ```r
 install.packages("shiny")
 ```
 
+To install the latest development builds directly from GitHub, run this instead:
+
+```r
+if (!require("devtools"))
+  install.packages("devtools")
+devtools::install_github("rstudio/shiny")
+```
+
 ## Getting Started
 
-To learn more we highly recommend you check out the [Shiny Tutorial](http://rstudio.github.com/shiny/tutorial). The tutorial explains the framework in-depth, walks you through building a simple application, and includes extensive annotated examples.
+To learn more we highly recommend you check out the [Shiny Tutorial](http://shiny.rstudio.com/tutorial/). The tutorial explains the framework in-depth, walks you through building a simple application, and includes extensive annotated examples.
 
-We hope you enjoy using Shiny. As you learn more and work with the package please [let us know](https://github.com/rstudio/shiny/issues) what problems you encounter and how you'd like to see Shiny evolve.
+We hope you enjoy using Shiny. If you have general questions about using Shiny, please use the Shiny [mailing list](https://groups.google.com/forum/#!forum/shiny-discuss). For bug reports, please use the [issue tracker](https://github.com/rstudio/shiny/issues).
+
+## Bootstrap 3 migration
+
+Shiny versions 0.10.2.2 and below used the Bootstrap 2 web framework. After 0.10.2.2, Shiny switched to Bootstrap 3. For most users, the upgrade should be seamless. However, if you have have customized your HTML-generating code to use features specific to Bootstrap 2, you may need to update your code to work with Bootstrap 3.
+
+If you do not wish to update your code at this time, you can use the [shinybootstrap2](https://github.com/rstudio/shinybootstrap2) package for backward compatibility.
+
+If you prefer to install an older version of Shiny, you can do it using the devtools package:
+
+```R
+devtools::install_version("shiny", version = "0.10.2.2")
+```
+
+## Development notes
+
+The Javascript code in Shiny is minified using tools that run on Node.js. See the tools/ directory for more information.
 
 ## License
 

inst/COPYING

@@ -1,678 +0,0 @@
-The shiny package is licensed to you under the GPLv3, the terms of 
-which are included below. The markdown pacakge includes other open 
-source software whose license terms can be found in the file NOTICE.
-
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

inst/NOTICE

@@ -1,265 +0,0 @@
-The shiny package inludes other open source software components. The following
-is a list of these components (full copies of the license agreements used by
-these components are included below):
-
-- jQuery
-- Bootstrap
-- bootstrap-datepicker, from https://github.com/eternicode/bootstrap-datepicker
-- jslider
-
-
-jQuery License
-----------------------------------------------------------------------   
-
-Copyright (c) 2012 jQuery Foundation and other contributors, 
-http://jquery.com/
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-Bootstrap and bootstrap-datepicker License
-----------------------------------------------------------------------   
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-jslider License
-----------------------------------------------------------------------   
-
-The MIT License (MIT)
-Copyright (c) 2012 Egor Khmelev
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

inst/examples/01_hello/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: Hello Shiny!
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/01_hello/Readme.md

@@ -0,0 +1,4 @@
+This small Shiny application demonstrates Shiny's automatic UI updates. Move
+the *Number of bins* slider and notice how the `renderPlot` expression is
+automatically re-evaluated when its dependant, `input$bins`, changes,
+causing a histogram with a new number of bins to be rendered.

inst/examples/01_hello/rsconnect/localhost/admin/01_hello.dcf

@@ -0,0 +1,6 @@
+name: 01_hello
+account: admin
+server: localhost
+bundleId: 1
+url: http://localhost:3939/admin/01_hello/
+when: 1436550957.65385

inst/examples/01_hello/server.R

@@ -1,20 +1,21 @@
 library(shiny)
 
-# Define server logic required to generate and plot a random distribution
+# Define server logic required to draw a histogram
 shinyServer(function(input, output) {
-   
-  # Expression that generates a plot of the distribution. The expression
-  # is wrapped in a call to renderPlot to indicate that:
+
+  # Expression that generates a histogram. The expression is
+  # wrapped in a call to renderPlot to indicate that:
   #
-  #  1) It is "reactive" and therefore should be automatically 
+  #  1) It is "reactive" and therefore should be automatically
   #     re-executed when inputs change
-  #  2) Its output type is a plot 
-  #
+  #  2) Its output type is a plot
+
   output$distPlot <- renderPlot({
-        
-    # generate an rnorm distribution and plot it
-    dist <- rnorm(input$obs)
-    hist(dist)
+    x    <- faithful[, 2]  # Old Faithful Geyser data
+    bins <- seq(min(x), max(x), length.out = input$bins + 1)
+
+    # draw the histogram with the specified number of bins
+    hist(x, breaks = bins, col = 'darkgray', border = 'white')
   })
-  
+
 })

inst/examples/01_hello/ui.R

@@ -1,22 +1,24 @@
 library(shiny)
 
-# Define UI for application that plots random distributions 
-shinyUI(pageWithSidebar(
-  
+# Define UI for application that draws a histogram
+shinyUI(fluidPage(
+
   # Application title
-  headerPanel("Hello Shiny!"),
-  
-  # Sidebar with a slider input for number of observations
-  sidebarPanel(
-    sliderInput("obs", 
-                "Number of observations:", 
-                min = 0, 
-                max = 1000, 
-                value = 500)
-  ),
-  
-  # Show a plot of the generated distribution
-  mainPanel(
-    plotOutput("distPlot")
+  titlePanel("Hello Shiny!"),
+
+  # Sidebar with a slider input for the number of bins
+  sidebarLayout(
+    sidebarPanel(
+      sliderInput("bins",
+                  "Number of bins:",
+                  min = 1,
+                  max = 50,
+                  value = 30)
+    ),
+
+    # Show a plot of the generated distribution
+    mainPanel(
+      plotOutput("distPlot")
+    )
   )
 ))

inst/examples/02_text/DESCRIPTION

@@ -0,0 +1,8 @@
+Title: Shiny Text
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny
+

inst/examples/02_text/Readme.md

@@ -0,0 +1 @@
+This example demonstrates output of raw text from R using the `renderPrint` function in `server.R` and the `verbatimTextOutput` function in `ui.R`. In this case, a textual summary of the data is shown using R's built-in `summary` function. 

inst/examples/02_text/server.R

@@ -1,7 +1,8 @@
 library(shiny)
 library(datasets)
 
-# Define server logic required to summarize and view the selected dataset
+# Define server logic required to summarize and view the selected
+# dataset
 shinyServer(function(input, output) {
   
   # Return the requested dataset

inst/examples/02_text/ui.R

@@ -1,25 +1,27 @@
 library(shiny)
 
 # Define UI for dataset viewer application
-shinyUI(pageWithSidebar(
+shinyUI(fluidPage(
   
   # Application title
-  headerPanel("Shiny Text"),
+  titlePanel("Shiny Text"),
   
-  # Sidebar with controls to select a dataset and specify the number
-  # of observations to view
-  sidebarPanel(
-    selectInput("dataset", "Choose a dataset:", 
-                choices = c("rock", "pressure", "cars")),
+  # Sidebar with controls to select a dataset and specify the
+  # number of observations to view
+  sidebarLayout(
+    sidebarPanel(
+      selectInput("dataset", "Choose a dataset:", 
+                  choices = c("rock", "pressure", "cars")),
+      
+      numericInput("obs", "Number of observations to view:", 10)
+    ),
     
-    numericInput("obs", "Number of observations to view:", 10)
-  ),
-  
-  # Show a summary of the dataset and an HTML table with the requested
-  # number of observations
-  mainPanel(
-    verbatimTextOutput("summary"),
-    
-    tableOutput("view")
+    # Show a summary of the dataset and an HTML table with the 
+	 # requested number of observations
+    mainPanel(
+      verbatimTextOutput("summary"),
+      
+      tableOutput("view")
+    )
   )
 ))

inst/examples/03_reactivity/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: Reactivity
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/03_reactivity/Readme.md

@@ -0,0 +1,5 @@
+This example demonstrates a core feature of Shiny: **reactivity**. In `server.R`, a reactive called `datasetInput` is declared. 
+
+Notice that the reactive expression depends on the input expression `input$dataset`, and that it's used by both the output expression `output$summary` and `output$view`. Try changing the dataset (using *Choose a dataset*) while looking at the reactive and then at the outputs; you will see first the reactive and then its dependencies flash. 
+
+Notice also that the reactive expression doesn't just update whenever anything changes--only the inputs it depends on will trigger an update. Change the "Caption" field and notice how only the `output$caption` expression is re-evaluated; the reactive and its dependents are left alone.

inst/examples/03_reactivity/server.R

@@ -1,17 +1,16 @@
 library(shiny)
 library(datasets)
 
-# Define server logic required to summarize and view the selected dataset
+# Define server logic required to summarize and view the selected
+# dataset
 shinyServer(function(input, output) {
 
-  # By declaring databaseInput as a reactive expression we ensure that:
+  # By declaring datasetInput as a reactive expression we ensure 
+  # that:
   #
   #  1) It is only called when the inputs it depends on changes
-  #  2) The computation and result are shared by all the callers (it 
-  #     only executes a single time)
-  #  3) When the inputs change and the expression is re-executed, the
-  #     new result is compared to the previous result; if the two are
-  #     identical, then the callers are not notified
+  #  2) The computation and result are shared by all the callers 
+  #	  (it only executes a single time)
   #
   datasetInput <- reactive({
     switch(input$dataset,
@@ -20,30 +19,34 @@ shinyServer(function(input, output) {
            "cars" = cars)
   })
   
-  # The output$caption is computed based on a reactive expression that
-  # returns input$caption. When the user changes the "caption" field:
+  # The output$caption is computed based on a reactive expression
+  # that returns input$caption. When the user changes the
+  # "caption" field:
   #
-  #  1) This function is automatically called to recompute the output 
-  #  2) The new caption is pushed back to the browser for re-display
+  #  1) This function is automatically called to recompute the 
+  #     output 
+  #  2) The new caption is pushed back to the browser for 
+  #     re-display
   # 
-  # Note that because the data-oriented reactive expressions below don't 
-  # depend on input$caption, those expressions are NOT called when 
-  # input$caption changes.
+  # Note that because the data-oriented reactive expressions
+  # below don't depend on input$caption, those expressions are
+  # NOT called when input$caption changes.
   output$caption <- renderText({
     input$caption
   })
   
-  # The output$summary depends on the datasetInput reactive expression, 
-  # so will be re-executed whenever datasetInput is re-executed 
+  # The output$summary depends on the datasetInput reactive
+  # expression, so will be re-executed whenever datasetInput is
+  # invalidated
   # (i.e. whenever the input$dataset changes)
   output$summary <- renderPrint({
     dataset <- datasetInput()
     summary(dataset)
   })
   
-  # The output$view depends on both the databaseInput reactive expression
-  # and input$obs, so will be re-executed whenever input$dataset or 
-  # input$obs is changed. 
+  # The output$view depends on both the databaseInput reactive
+  # expression and input$obs, so will be re-executed whenever
+  # input$dataset or input$obs is changed. 
   output$view <- renderTable({
     head(datasetInput(), n = input$obs)
   })

inst/examples/03_reactivity/ui.R

@@ -1,32 +1,34 @@
 library(shiny)
 
 # Define UI for dataset viewer application
-shinyUI(pageWithSidebar(
+shinyUI(fluidPage(
   
   # Application title
-  headerPanel("Reactivity"),
+  titlePanel("Reactivity"),
   
-  # Sidebar with controls to provide a caption, select a dataset, and 
-  # specify the number of observations to view. Note that changes made
-  # to the caption in the textInput control are updated in the output
-  # area immediately as you type
-  sidebarPanel(
-    textInput("caption", "Caption:", "Data Summary"),
+  # Sidebar with controls to provide a caption, select a dataset,
+  # and specify the number of observations to view. Note that
+  # changes made to the caption in the textInput control are
+  # updated in the output area immediately as you type
+  sidebarLayout(
+    sidebarPanel(
+      textInput("caption", "Caption:", "Data Summary"),
+      
+      selectInput("dataset", "Choose a dataset:", 
+                  choices = c("rock", "pressure", "cars")),
+      
+      numericInput("obs", "Number of observations to view:", 10)
+    ),
     
-    selectInput("dataset", "Choose a dataset:", 
-                choices = c("rock", "pressure", "cars")),
     
-    numericInput("obs", "Number of observations to view:", 10)
-  ),
-  
-  
-  # Show the caption, a summary of the dataset and an HTML table with
-  # the requested number of observations
-  mainPanel(
-    h3(textOutput("caption")), 
-    
-    verbatimTextOutput("summary"), 
-    
-    tableOutput("view")
+    # Show the caption, a summary of the dataset and an HTML 
+	 # table with the requested number of observations
+    mainPanel(
+      h3(textOutput("caption", container = span)),
+      
+      verbatimTextOutput("summary"), 
+      
+      tableOutput("view")
+    )
   )
 ))

inst/examples/04_mpg/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: Miles Per Gallon
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/04_mpg/Readme.md

@@ -0,0 +1,4 @@
+This example demonstrates the following concepts:
+
+* **Global variables**: The `mpgData` variable is declared outside the `shinyServer` function. This makes it available anywhere inside `shinyServer`. The code in `server.R` outside `shinyServer` is only run once when the app starts up, so it can't contain user input.
+* **Reactive expressions**: `formulaText` is a reactive expression. Note how it re-evaluates when the Variable field is changed, but not when the Show Outliers box is ticked. 

inst/examples/04_mpg/server.R

@@ -1,31 +1,33 @@
 library(shiny)
 library(datasets)
 
-# We tweak the "am" field to have nicer factor labels. Since this doesn't
-# rely on any user inputs we can do this once at startup and then use the
-# value throughout the lifetime of the application
+# We tweak the "am" field to have nicer factor labels. Since
+# this doesn't rely on any user inputs we can do this once at
+# startup and then use the value throughout the lifetime of the
+# application
 mpgData <- mtcars
 mpgData$am <- factor(mpgData$am, labels = c("Automatic", "Manual"))
 
 
-# Define server logic required to plot various variables against mpg
+# Define server logic required to plot various variables against
+# mpg
 shinyServer(function(input, output) {
-  
-  # Compute the forumla text in a reactive expression since it is 
+
+  # Compute the formula text in a reactive expression since it is
   # shared by the output$caption and output$mpgPlot functions
   formulaText <- reactive({
     paste("mpg ~", input$variable)
   })
-   
+
   # Return the formula text for printing as a caption
   output$caption <- renderText({
     formulaText()
   })
-  
-  # Generate a plot of the requested variable against mpg and only 
-  # include outliers if requested
+
+  # Generate a plot of the requested variable against mpg and
+  # only include outliers if requested
   output$mpgPlot <- renderPlot({
-    boxplot(as.formula(formulaText()), 
+    boxplot(as.formula(formulaText()),
             data = mpgData,
             outline = input$outliers)
   })

inst/examples/04_mpg/ui.R

@@ -1,26 +1,29 @@
 library(shiny)
 
 # Define UI for miles per gallon application
-shinyUI(pageWithSidebar(
+shinyUI(fluidPage(
   
   # Application title
-  headerPanel("Miles Per Gallon"),
+  titlePanel("Miles Per Gallon"),
   
-  # Sidebar with controls to select the variable to plot against mpg
-  # and to specify whether outliers should be included
-  sidebarPanel(
-    selectInput("variable", "Variable:",
-                c("Cylinders" = "cyl",
-                  "Transmission" = "am",
-                  "Gears" = "gear")),
-
-    checkboxInput("outliers", "Show outliers", FALSE)
-  ),
+  # Sidebar with controls to select the variable to plot against
+  # mpg and to specify whether outliers should be included
+  sidebarLayout(
+    sidebarPanel(
+      selectInput("variable", "Variable:",
+                  c("Cylinders" = "cyl",
+                    "Transmission" = "am",
+                    "Gears" = "gear")),
   
-  # Show the caption and plot of the requested variable against mpg
-  mainPanel(
-    h3(textOutput("caption")),
+      checkboxInput("outliers", "Show outliers", FALSE)
+    ),
     
-    plotOutput("mpgPlot")
+	 # Show the caption and plot of the requested variable against
+	 # mpg
+    mainPanel(
+      h3(textOutput("caption")),
+      
+      plotOutput("mpgPlot")
+    )
   )
 ))

inst/examples/05_sliders/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: Sliders
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/05_sliders/Readme.md

@@ -0,0 +1,3 @@
+This example demonstrates Shiny's versatile `sliderInput` widget. 
+
+Slider inputs can be used to select single values, to select a continuous range of values, and even to animate over a range.

inst/examples/05_sliders/server.R

@@ -3,7 +3,8 @@ library(shiny)
 # Define server logic for slider examples
 shinyServer(function(input, output) {
   
-  # Reactive expression to compose a data frame containing all of the values
+  # Reactive expression to compose a data frame containing all of
+  # the values
   sliderValues <- reactive({
     
     # Compose data frame

inst/examples/05_sliders/ui.R

@@ -1,37 +1,43 @@
 library(shiny)
 
 # Define UI for slider demo application
-shinyUI(pageWithSidebar(
-  
+shinyUI(fluidPage(
+
   #  Application title
-  headerPanel("Sliders"),
-  
-  # Sidebar with sliders that demonstrate various available options
-  sidebarPanel(
-    # Simple integer interval
-    sliderInput("integer", "Integer:", 
-                min=0, max=1000, value=500),
-    
-    # Decimal interval with step value
-    sliderInput("decimal", "Decimal:", 
-                min = 0, max = 1, value = 0.5, step= 0.1),
-   
-    # Specification of range within an interval
-    sliderInput("range", "Range:",
-                min = 1, max = 1000, value = c(200,500)),
-    
-    # Provide a custom currency format for value display, with basic animation
-    sliderInput("format", "Custom Format:", 
-                min = 0, max = 10000, value = 0, step = 2500,
-                format="$#,##0", locale="us", animate=TRUE),
-    
-    # Animation with custom interval (in ms) to control speed, plus looping
-    sliderInput("animation", "Looping Animation:", 1, 2000, 1, step = 10, 
-                animate=animationOptions(interval=300, loop=TRUE))
-  ),
-  
-  # Show a table summarizing the values entered
-  mainPanel(
-    tableOutput("values")
+  titlePanel("Sliders"),
+
+  # Sidebar with sliders that demonstrate various available
+  # options
+  sidebarLayout(
+    sidebarPanel(
+      # Simple integer interval
+      sliderInput("integer", "Integer:",
+                  min=0, max=1000, value=500),
+
+      # Decimal interval with step value
+      sliderInput("decimal", "Decimal:",
+                  min = 0, max = 1, value = 0.5, step= 0.1),
+
+      # Specification of range within an interval
+      sliderInput("range", "Range:",
+                  min = 1, max = 1000, value = c(200,500)),
+
+      # Provide a custom currency format for value display,
+		# with basic animation
+      sliderInput("format", "Custom Format:",
+                  min = 0, max = 10000, value = 0, step = 2500,
+                  pre = "$", sep = ",", animate=TRUE),
+
+      # Animation with custom interval (in ms) to control speed,
+		# plus looping
+      sliderInput("animation", "Looping Animation:", 1, 2000, 1,
+					  	step = 10, animate=
+							animationOptions(interval=300, loop=TRUE))
+    ),
+
+    # Show a table summarizing the values entered
+    mainPanel(
+      tableOutput("values")
+    )
   )
-))
+))

inst/examples/06_tabsets/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: Tabsets
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/06_tabsets/Readme.md

@@ -0,0 +1,9 @@
+This example demonstrates the `tabsetPanel` and `tabPanel` widgets.
+
+Notice that outputs that are not visible are not re-evaluated until they become visible. Try this: 
+
+1. Scroll to the bottom of `server.R`
+2. Change the number of observations, and observe that only `output$plot` is evaluated.
+3. Click the Summary tab, and observe that `output$summary` is evaluated.
+4. Change the number of observations again, and observe that now only `output$summary` is evaluated.
+

inst/examples/06_tabsets/server.R

@@ -3,9 +3,10 @@ library(shiny)
 # Define server logic for random distribution application
 shinyServer(function(input, output) {
   
-  # Reactive expression to generate the requested distribution. This is 
-  # called whenever the inputs change. The output functions defined 
-  # below then all use the value computed from this expression
+  # Reactive expression to generate the requested distribution.
+  # This is called whenever the inputs change. The output
+  # functions defined below then all use the value computed from
+  # this expression
   data <- reactive({
     dist <- switch(input$dist,
                    norm = rnorm,
@@ -17,10 +18,11 @@ shinyServer(function(input, output) {
     dist(input$n)
   })
   
-  # Generate a plot of the data. Also uses the inputs to build the 
-  # plot label. Note that the dependencies on both the inputs and
-  # the data reactive expression are both tracked, and all expressions 
-  # are called in the sequence implied by the dependency graph
+  # Generate a plot of the data. Also uses the inputs to build
+  # the plot label. Note that the dependencies on both the inputs
+  # and the data reactive expression are both tracked, and
+  # all expressions are called in the sequence implied by the
+  # dependency graph
   output$plot <- renderPlot({
     dist <- input$dist
     n <- input$n

inst/examples/06_tabsets/ui.R

@@ -1,36 +1,38 @@
 library(shiny)
 
 # Define UI for random distribution application 
-shinyUI(pageWithSidebar(
+shinyUI(fluidPage(
     
   # Application title
-  headerPanel("Tabsets"),
+  titlePanel("Tabsets"),
   
   # Sidebar with controls to select the random distribution type
-  # and number of observations to generate. Note the use of the br()
-  # element to introduce extra vertical spacing
-  sidebarPanel(
-    radioButtons("dist", "Distribution type:",
-                 c("Normal" = "norm",
-                   "Uniform" = "unif",
-                   "Log-normal" = "lnorm",
-                   "Exponential" = "exp")),
-    br(),
+  # and number of observations to generate. Note the use of the
+  # br() element to introduce extra vertical spacing
+  sidebarLayout(
+    sidebarPanel(
+      radioButtons("dist", "Distribution type:",
+                   c("Normal" = "norm",
+                     "Uniform" = "unif",
+                     "Log-normal" = "lnorm",
+                     "Exponential" = "exp")),
+      br(),
+      
+      sliderInput("n", 
+                  "Number of observations:", 
+                   value = 500,
+                   min = 1, 
+                   max = 1000)
+    ),
     
-    sliderInput("n", 
-                "Number of observations:", 
-                 value = 500,
-                 min = 1, 
-                 max = 1000)
-  ),
-  
-  # Show a tabset that includes a plot, summary, and table view
-  # of the generated distribution
-  mainPanel(
-    tabsetPanel(
-      tabPanel("Plot", plotOutput("plot")), 
-      tabPanel("Summary", verbatimTextOutput("summary")), 
-      tabPanel("Table", tableOutput("table"))
+    # Show a tabset that includes a plot, summary, and table view
+    # of the generated distribution
+    mainPanel(
+      tabsetPanel(type = "tabs", 
+        tabPanel("Plot", plotOutput("plot")), 
+        tabPanel("Summary", verbatimTextOutput("summary")), 
+        tabPanel("Table", tableOutput("table"))
+      )
     )
   )
 ))

inst/examples/07_widgets/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: Widgets
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/07_widgets/Readme.md

@@ -0,0 +1 @@
+This example demonstrates some additional widgets included in Shiny, such as `helpText` and `submitButton`. The latter is used to delay rendering output until the user explicitly requests it.

inst/examples/07_widgets/server.R

@@ -1,7 +1,8 @@
 library(shiny)
 library(datasets)
 
-# Define server logic required to summarize and view the selected dataset
+# Define server logic required to summarize and view the 
+# selected dataset
 shinyServer(function(input, output) {
   
   # Return the requested dataset

inst/examples/07_widgets/ui.R

@@ -1,39 +1,43 @@
 library(shiny)
 
 # Define UI for dataset viewer application
-shinyUI(pageWithSidebar(
+shinyUI(fluidPage(
   
   # Application title.
-  headerPanel("More Widgets"),
+  titlePanel("More Widgets"),
   
-  # Sidebar with controls to select a dataset and specify the number
-  # of observations to view. The helpText function is also used to 
-  # include clarifying text. Most notably, the inclusion of a 
-  # submitButton defers the rendering of output until the user 
-  # explicitly clicks the button (rather than doing it immediately
-  # when inputs change). This is useful if the computations required
-  # to render output are inordinately time-consuming.
-  sidebarPanel(
-    selectInput("dataset", "Choose a dataset:", 
-                choices = c("rock", "pressure", "cars")),
+  # Sidebar with controls to select a dataset and specify the
+  # number of observations to view. The helpText function is
+  # also used to include clarifying text. Most notably, the
+  # inclusion of a submitButton defers the rendering of output
+  # until the user explicitly clicks the button (rather than
+  # doing it immediately when inputs change). This is useful if
+  # the computations required to render output are inordinately
+  # time-consuming.
+  sidebarLayout(
+    sidebarPanel(
+      selectInput("dataset", "Choose a dataset:", 
+                  choices = c("rock", "pressure", "cars")),
+      
+      numericInput("obs", "Number of observations to view:", 10),
+      
+      helpText("Note: while the data view will show only the specified",
+               "number of observations, the summary will still be based",
+               "on the full dataset."),
+      
+      submitButton("Update View")
+    ),
     
-    numericInput("obs", "Number of observations to view:", 10),
-    
-    helpText("Note: while the data view will show only the specified",
-             "number of observations, the summary will still be based",
-             "on the full dataset."),
-    
-    submitButton("Update View")
-  ),
-  
-  # Show a summary of the dataset and an HTML table with the requested
-  # number of observations. Note the use of the h4 function to provide
-  # an additional header above each output section.
-  mainPanel(
-    h4("Summary"),
-    verbatimTextOutput("summary"),
-    
-    h4("Observations"),
-    tableOutput("view")
+    # Show a summary of the dataset and an HTML table with the
+    # requested number of observations. Note the use of the h4
+    # function to provide an additional header above each output
+    # section.
+    mainPanel(
+      h4("Summary"),
+      verbatimTextOutput("summary"),
+      
+      h4("Observations"),
+      tableOutput("view")
+    )
   )
-))
+))

inst/examples/08_html/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: Custom HTML UI
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/08_html/Readme.md

@@ -0,0 +1,4 @@
+Normally we use the built-in functions, such as `textInput()`, to generate
+the HTML UI in the R script `ui.R`. Actually **shiny** also works with a
+custom HTML page `www/index.html`. See [the
+tutorial](http://rstudio.github.io/shiny/tutorial/#html-ui) for more details.

inst/examples/09_upload/DESCRIPTION

@@ -0,0 +1,7 @@
+Title: File Upload
+Author: RStudio, Inc.
+AuthorUrl: http://www.rstudio.com/
+License: MIT
+DisplayMode: Showcase
+Tags: getting-started
+Type: Shiny

inst/examples/09_upload/Readme.md

@@ -0,0 +1,4 @@
+We can add a file upload input in the UI using the function `fileInput()`,
+e.g. `fileInput('foo')`. In `server.R`, we can access the uploaded files via
+`input$foo`. See [the
+tutorial](http://rstudio.github.io/shiny/tutorial/#uploads) for more details.

inst/examples/09_upload/server.R

@@ -3,16 +3,18 @@ library(shiny)
 shinyServer(function(input, output) {
   output$contents <- renderTable({
     
-    # input$file1 will be NULL initially. After the user selects and uploads a 
-    # file, it will be a data frame with 'name', 'size', 'type', and 'datapath' 
-    # columns. The 'datapath' column will contain the local filenames where the 
-    # data can be found.
+    # input$file1 will be NULL initially. After the user selects
+    # and uploads a file, it will be a data frame with 'name',
+    # 'size', 'type', and 'datapath' columns. The 'datapath'
+    # column will contain the local filenames where the data can
+    # be found.
 
     inFile <- input$file1
 
     if (is.null(inFile))
       return(NULL)
     
-    read.csv(inFile$datapath, header=input$header, sep=input$sep, quote=input$quote)
+    read.csv(inFile$datapath, header=input$header, sep=input$sep, 
+				 quote=input$quote)
   })
 })

inst/examples/09_upload/ui.R

@@ -1,24 +1,28 @@
 library(shiny)
 
-shinyUI(pageWithSidebar(
-  headerPanel("Uploading Files"),
-  sidebarPanel(
-    fileInput('file1', 'Choose CSV File',
-              accept=c('text/csv', 'text/comma-separated-values,text/plain')),
-    tags$hr(),
-    checkboxInput('header', 'Header', TRUE),
-    radioButtons('sep', 'Separator',
-                 c(Comma=',',
-                   Semicolon=';',
-                   Tab='\t'),
-                 'Comma'),
-    radioButtons('quote', 'Quote',
-                 c(None='',
-                   'Double Quote'='"',
-                   'Single Quote'="'"),
-                 'Double Quote')
-  ),
-  mainPanel(
-    tableOutput('contents')
+shinyUI(fluidPage(
+  titlePanel("Uploading Files"),
+  sidebarLayout(
+    sidebarPanel(
+      fileInput('file1', 'Choose CSV File',
+                accept=c('text/csv', 
+								 'text/comma-separated-values,text/plain', 
+								 '.csv')),
+      tags$hr(),
+      checkboxInput('header', 'Header', TRUE),
+      radioButtons('sep', 'Separator',
+                   c(Comma=',',
+                     Semicolon=';',
+                     Tab='\t'),
+                   ','),
+      radioButtons('quote', 'Quote',
+                   c(None='',
+                     'Double Quote'='"',
+                     'Single Quote'="'"),
+                   '"')
+    ),
+    mainPanel(
+      tableOutput('contents')
+    )
   )
 ))