Bump version and update NEWS

Fixes for R CMD check
Fix test on Linux (sort locale)
2026-01-11 07:58:11 -05:00 · 2013-01-23 14:54:39 -06:00 · 2013-01-23 14:30:11 -06:00 · 2013-01-23 12:17:45 -08:00 · 2013-01-23 12:13:40 -08:00 · 2013-01-23 12:09:53 -08:00
41 changed files with 2503 additions and 366 deletions
--- a/.Rbuildignore
+++ b/.Rbuildignore
@@ -7,3 +7,4 @@
 ^shiny\.cmd$
 ^run\.R$
 ^\.gitignore$
+^res$
--- a/19
+++ b/19
@@ -1,34 +1,38 @@
 Package: shiny
 Type: Package
 Title: Web Application Framework for R
-Version: 0.1.9
-Date: 2012-11-06
+Version: 0.3.0
+Date: 2013-01-23
 Author: RStudio, Inc.
-Maintainer: Joe Cheng <joe@rstudio.org>
+Maintainer: Winston Chang <winston@rstudio.com>
 Description: Shiny 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
 Depends:
-    R (>= 2.14.1), websockets (>= 1.1.5)
+    R (>= 2.14.1)
 Imports:
    stats,
    tools,
    utils,
    datasets,
    methods,
+    websockets (>= 1.1.6),
    caTools,
    RJSONIO,
    xtable,
    digest
 Suggests:
-    markdown
-URL: https://github.com/rstudio/shiny, http://rstudio.github.com/shiny/tutorial
+    markdown,
+    Cairo,
+    testthat
+URL: http://www.rstudio.com/shiny/
 BugReports: https://github.com/rstudio/shiny/issues
 Collate:
    'map.R'
-    'random.R'
+    'utils.R'
+    'tar.R'
    'timer.R'
    'tags.R'
    'cache.R'
@@ -40,3 +44,4 @@ Collate:
    'shinyui.R'
    'slider.R'
    'bootstrap.R'
+    'run-url.R'
--- a/44
+++ b/44
@@ -1,3 +1,22 @@
+S3method("$",reactivevalues)
+S3method("$<-",reactivevalues)
+S3method("$<-",shinyoutput)
+S3method("[",reactivevalues)
+S3method("[<-",reactivevalues)
+S3method("[[",reactivevalues)
+S3method("[[<-",reactivevalues)
+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(names,reactivevalues)
+S3method(print,shiny.tag)
+S3method(print,shiny.tag.list)
+S3method(reactive,"function")
+S3method(reactive,default)
+export(HTML)
 export(a)
 export(addResourcePath)
 export(animationOptions)
@@ -8,6 +27,9 @@ export(checkboxInput)
 export(code)
 export(conditionalPanel)
 export(div)
+export(downloadButton)
+export(downloadHandler)
+export(downloadLink)
 export(em)
 export(fileInput)
 export(h1)
@@ -18,13 +40,13 @@ export(h5)
 export(h6)
 export(headerPanel)
 export(helpText)
-export(HTML)
 export(htmlOutput)
 export(img)
 export(includeHTML)
 export(includeMarkdown)
 export(includeText)
 export(invalidateLater)
+export(isolate)
 export(mainPanel)
 export(numericInput)
 export(observe)
@@ -40,10 +62,14 @@ export(reactiveTable)
 export(reactiveText)
 export(reactiveTimer)
 export(reactiveUI)
+export(reactiveValues)
+export(reactiveValuesToList)
 export(repeatable)
 export(runApp)
 export(runExample)
 export(runGist)
+export(runGitHub)
+export(runUrl)
 export(selectInput)
 export(shinyServer)
 export(shinyUI)
@@ -53,8 +79,8 @@ export(sliderInput)
 export(span)
 export(strong)
 export(submitButton)
-export(tableOutput)
 export(tabPanel)
+export(tableOutput)
 export(tabsetPanel)
 export(tag)
 export(tagAppendChild)
@@ -65,20 +91,8 @@ export(textOutput)
 export(uiOutput)
 export(verbatimTextOutput)
 export(wellPanel)
+import(RJSONIO)
 import(caTools)
 import(digest)
-import(RJSONIO)
 import(websockets)
 import(xtable)
-S3method(as.character,shiny.tag)
-S3method(as.character,shiny.tag.list)
-S3method(as.list,reactvaluesreader)
-S3method(format,shiny.tag)
-S3method(format,shiny.tag.list)
-S3method(names,reactvaluesreader)
-S3method(print,shiny.tag)
-S3method(print,shiny.tag.list)
-S3method(reactive,default)
-S3method(reactive,"function")
-S3method("$",reactvaluesreader)
-S3method("$<-",shinyoutput)
--- a/108
+++ b/108
@@ -1,3 +1,111 @@
+shiny 0.3.0
+--------------------------------------------------------------------------------
+
+* Reactive functions are now evaluated lazily.
+
+* Add `reactiveValues()`.
+
+* Using `as.list()` to convert a reactivevalues object (like `input`) to a list
+  is deprecated. The new function `reactiveValuesToList()` should be used
+  instead.
+
+* Add `isolate()`. This function is used for accessing reactive functions,
+  without them invalidating their parent contexts.
+
+* Fix issue #58: bug where reactive functions are not re-run when all items in
+  a checkboxGroup are unchecked.
+
+* Fix issue #71, where `reactiveTable()` would return blank if the first
+  element of a data frame was NA.
+
+* In `plotOutput`, better validation for CSS units when specifying width and
+  height.
+
+* `reactivePrint()` no longer displays invisible output.
+
+* `reactiveText()` no longer displays printed output, only the return value
+  from a function.
+
+* The `runGitHub()` and `runUrl()` functions have been added, for running
+  Shiny apps from GitHub repositories and zip/tar files at remote URLs.
+
+* Fix issue #64, where pressing Enter in a textbox would cause a form to
+  submit.
+
+shiny 0.2.4
+--------------------------------------------------------------------------------
+
+* `runGist` has been updated to use the new download URLs from
+  https://gist.github.com.
+
+* Shiny now uses `CairoPNG()` for output, when the Cairo package is available.
+  This provides better-looking output on Linux and Windows.
+
+shiny 0.2.3
+--------------------------------------------------------------------------------
+
+* Ignore request variables for routing purposes
+
+shiny 0.2.2
+--------------------------------------------------------------------------------
+
+* Fix CRAN warning (assigning to global environment)
+
+
+shiny 0.2.1
+--------------------------------------------------------------------------------
+
+* [BREAKING] Modify API of `downloadHandler`: The `content` function now takes
+  a file path, not writable connection, as an argument. This makes it much
+  easier to work with APIs that only write to file paths, not connections.
+
+
+shiny 0.2.0
+--------------------------------------------------------------------------------
+
+* Fix subtle name resolution bug--the usual symptom being S4 methods not being
+  invoked correctly when called from inside of ui.R or server.R
+
+
+shiny 0.1.14
+--------------------------------------------------------------------------------
+
+* Fix slider animator, which broke in 0.1.10
+
+
+shiny 0.1.13
+--------------------------------------------------------------------------------
+
+* Fix temp file leak in reactivePlot
+
+
+shiny 0.1.12
+--------------------------------------------------------------------------------
+
+* Fix problems with runGist on Windows
+* Add feature for on-the-fly file downloads (e.g. CSV data, PDFs)
+* Add CSS hooks for app-wide busy indicators
+
+
+shiny 0.1.11
+--------------------------------------------------------------------------------
+
+* Fix input binding with IE8 on Shiny Server
+* Fix issue #41: reactiveTable should allow print options too
+* Allow dynamic sizing of reactivePlot (i.e. using a function instead of a fixed
+  value)
+
+
+shiny 0.1.10
+--------------------------------------------------------------------------------
+
+* Support more MIME types when serving out of www
+* Fix issue #35: Allow modification of untar args
+* headerPanel can take an explicit window title parameter
+* checkboxInput uses correct attribute `checked` instead of `selected`
+* Fix plot rendering with IE8 on Shiny Server
+
+
 shiny 0.1.9
 --------------------------------------------------------------------------------

--- a/R/bootstrap.R
+++ b/R/bootstrap.R
@@ -24,6 +24,12 @@ bootstrapPage <- function(...) {
    bs <- "shared/bootstrap/"
    
    result <- tags$head(
+      tags$link(rel="stylesheet", 
+                type="text/css", 
+                href="shared/slider/css/jquery.slider.min.css"),
+      
+      tags$script(src="shared/slider/js/jquery.slider.min.js"),
+      
      tags$link(rel="stylesheet", 
                type="text/css", 
                href=paste(bs, "css/bootstrap", cssExt, sep="")),
@@ -109,14 +115,16 @@ pageWithSidebar <- function(headerPanel, sidebarPanel, mainPanel) {
 #' Create a header panel containing an application title.
 #' 
 #' @param title An application title to display
+#' @param windowTitle The title that should be displayed by the browser window. 
+#'   Useful if \code{title} is not a string.
 #' @return A headerPanel that can be passed to \link{pageWithSidebar}
-#' 
+#'   
 #' @examples
 #' headerPanel("Hello Shiny!")
 #' @export
-headerPanel <- function(title) {    
+headerPanel <- function(title, windowTitle=title) {    
  tagList(
-    tags$head(tags$title(title)),
+    tags$head(tags$title(windowTitle)),
    div(class="span12", style="padding: 10px 0px;",
      h1(title)
    )
@@ -365,7 +373,7 @@ checkboxGroupInput <- function(inputId, label, choices, selected = NULL) {
                           value = choices[[choiceName]])
    
    if (choiceName %in% selected)
-      checkbox$attribs$selected <- 'selected'
+      checkbox$attribs$checked <- 'checked'
    
    checkboxes[[length(checkboxes)+1]] <- checkbox
    checkboxes[[length(checkboxes)+1]] <- choiceName
@@ -734,7 +742,9 @@ verbatimTextOutput <- function(outputId) {
 #' 
 #' Render a \link{reactivePlot} within an application page.
 #' @param outputId output variable to read the plot from
-#' @param width Plot width
+#' @param width Plot width. Must be a valid CSS unit (like \code{"100\%"},
+#'   \code{"400px"}, \code{"auto"}) or a number, which will be coerced to a
+#'   string and have \code{"px"} appended.
 #' @param height Plot height
 #' @return A plot output element that can be included in a panel
 #' @examples
@@ -744,7 +754,8 @@ verbatimTextOutput <- function(outputId) {
 #' )
 #' @export
 plotOutput <- function(outputId, width = "100%", height="400px") {
-  style <- paste("width:", width, ";", "height:", height)
+  style <- paste("width:", validateCssUnit(width), ";",
+    "height:", validateCssUnit(height))
  div(id = outputId, class="shiny-plot-output", style = style)
 }

@@ -785,3 +796,63 @@ htmlOutput <- function(outputId) {
 uiOutput <- function(outputId) {
  htmlOutput(outputId)
 }
+
+#' Create a download button or link
+#' 
+#' Use these functions to create a download button or link; when clicked, it 
+#' will initiate a browser download. The filename and contents are specified by 
+#' the corresponding \code{\link{downloadHandler}} defined in the server 
+#' function.
+#' 
+#' @param outputId The name of the output slot that the \code{downloadHandler}
+#'   is assigned to.
+#' @param label The label that should appear on the button.
+#' @param class Additional CSS classes to apply to the tag, if any.
+#'   
+#' @examples
+#' \dontrun{
+#' # In server.R:
+#' output$downloadData <- downloadHandler(
+#'   filename = function() {
+#'     paste('data-', Sys.Date(), '.csv', sep='')
+#'   },
+#'   content = function(con) {
+#'     write.csv(data, con)
+#'   }
+#' )
+#' 
+#' # In ui.R:
+#' downloadLink('downloadData', 'Download')
+#' }
+#' 
+#' @aliases downloadLink
+#' @seealso downloadHandler
+#' @export
+downloadButton <- function(outputId, label="Download", class=NULL) {
+  tags$a(id=outputId,
+         class=paste(c('btn shiny-download-link', class), collapse=" "),
+         href='',
+         target='_blank',
+         label)
+}
+
+#' @rdname downloadButton
+#' @export
+downloadLink <- function(outputId, label="Download", class=NULL) {
+  tags$a(id=outputId,
+         class=paste(c('shiny-download-link', class), collapse=" "),
+         href='',
+         target='_blank',
+         label)
+}
+
+validateCssUnit <- function(x) {
+  if (is.character(x) &&
+     !grepl("^(auto|((\\.\\d+)|(\\d+(\\.\\d+)?))(%|in|cm|mm|em|ex|pt|pc|px))$", x)) {
+    stop('"', x, '" is not a valid CSS unit (e.g., "100%", "400px", "auto")')
+  }
+  if (is.numeric(x)) {
+    x <- paste(x, "px", sep = "")
+  }
+  x
+}
--- a/R/map.R
+++ b/R/map.R
@@ -28,6 +28,12 @@ Map <- setRefClass(
      assign(key, value, pos=.env, inherits=FALSE)
      return(value)
    },
+    mset = function(...) {
+      args <- list(...)
+      for (key in names(args))
+        set(key, args[[key]])
+      return()
+    },
    remove = function(key) {
      if (.self$containsKey(key)) {
        result <- .self$get(key)
@@ -55,15 +61,6 @@ Map <- setRefClass(
  )
 )

-`[.Map` <- function(map, name) {
-  map$get(name)
-}
-
-`[<-.Map` <- function(map, name, value) {
-  map$set(name, value)
-  return(map)
-}
-
 as.list.Map <- function(map) {
  sapply(map$keys(),
         map$get,
--- a/R/random.R
+++ b/R/random.R
@@ -1,41 +0,0 @@
-#' Make a random number generator repeatable
-#' 
-#' Given a function that generates random data, returns a wrapped version of 
-#' that function that always uses the same seed when called. The seed to use can
-#' be passed in explicitly if desired; otherwise, a random number is used.
-#' 
-#' @param rngfunc The function that is affected by the R session's seed.
-#' @param seed The seed to set every time the resulting function is called.
-#' @return A repeatable version of the function that was passed in.
-#'   
-#' @note When called, the returned function attempts to preserve the R session's
-#'   current seed by snapshotting and restoring
-#'   \code{\link[base]{.Random.seed}}.
-#'
-#' @examples
-#' rnormA <- repeatable(rnorm)
-#' rnormB <- repeatable(rnorm)
-#' rnormA(3)  # [1]  1.8285879 -0.7468041 -0.4639111
-#' rnormA(3)  # [1]  1.8285879 -0.7468041 -0.4639111
-#' rnormA(5)  # [1]  1.8285879 -0.7468041 -0.4639111 -1.6510126 -1.4686924
-#' rnormB(5)  # [1] -0.7946034  0.2568374 -0.6567597  1.2451387 -0.8375699
-#' 
-#' @export
-repeatable <- function(rngfunc, seed = runif(1, 0, .Machine$integer.max)) {
-  force(seed)
-  
-  function(...) {
-    # When we exit, restore the seed to its original state
-    if (exists('.Random.seed', where=globalenv())) {
-      currentSeed <- get('.Random.seed', pos=globalenv())
-      on.exit(assign('.Random.seed', currentSeed, pos=globalenv()))
-    }
-    else {
-      on.exit(rm('.Random.seed', pos=globalenv()))
-    }
-    
-    set.seed(seed)
-    
-    do.call(rngfunc, list(...))
-  }
-}
--- a/R/react.R
+++ b/R/react.R
@@ -2,38 +2,34 @@ Context <- setRefClass(
  'Context',
  fields = list(
    id = 'character',
+    .label = 'character',      # For debug purposes
    .invalidated = 'logical',
-    .callbacks = 'list',
-    .hintCallbacks = 'list'
+    .invalidateCallbacks = 'list',
+    .flushCallbacks = 'list'
  ),
  methods = list(
-    initialize = function() {
+    initialize = function(label=NULL) {
      id <<- .getReactiveEnvironment()$nextId()
      .invalidated <<- FALSE
-      .callbacks <<- list()
-      .hintCallbacks <<- list()
+      .invalidateCallbacks <<- list()
+      .flushCallbacks <<- list()
+      .label <<- label
    },
    run = function(func) {
      "Run the provided function under this context."
      env <- .getReactiveEnvironment()
      env$runWith(.self, func)
    },
-    invalidateHint = function() {
-      "Let this context know it may or may not be invalidated very soon; that
-      is, something in its dependency graph has been invalidated but there's no
-      guarantee that the cascade of invalidations will reach all the way here.
-      This is used to show progress in the UI."
-      lapply(.hintCallbacks, function(func) {
-        func()
-      })
-    },
    invalidate = function() {
-      "Schedule this context for invalidation. It will not actually be
-        invalidated until the next call to \\code{\\link{flushReact}}."
+      "Invalidate this context. It will immediately call the callbacks
+        that have been registered with onInvalidate()."
      if (.invalidated)
        return()
      .invalidated <<- TRUE
-      .getReactiveEnvironment()$addPendingInvalidate(.self)
+
+      lapply(.invalidateCallbacks, function(func) {
+        func()
+      })
      NULL
    },
    onInvalidate = function(func) {
@@ -43,15 +39,21 @@ Context <- setRefClass(
      if (.invalidated)
        func()
      else
-        .callbacks <<- c(.callbacks, func)
+        .invalidateCallbacks <<- c(.invalidateCallbacks, func)
      NULL
    },
-    onInvalidateHint = function(func) {
-      .hintCallbacks <<- c(.hintCallbacks, func)
+    addPendingFlush = function() {
+      "Tell the reactive environment that this context should be flushed the
+        next time flushReact() called."
+      .getReactiveEnvironment()$addPendingFlush(.self)
    },
-    executeCallbacks = function() {
+    onFlush = function(func) {
+      "Register a function to be called when this context is flushed."
+      .flushCallbacks <<- c(.flushCallbacks, func)
+    },
+    executeFlushCallbacks = function() {
      "For internal use only."
-      lapply(.callbacks, function(func) {
+      lapply(.flushCallbacks, function(func) {
        withCallingHandlers({
          func()
        }, warning = function(e) {
@@ -66,12 +68,12 @@ Context <- setRefClass(

 ReactiveEnvironment <- setRefClass(
  'ReactiveEnvironment',
-  fields = c('.currentContext', '.nextId', '.pendingInvalidate'),
+  fields = c('.currentContext', '.nextId', '.pendingFlush'),
  methods = list(
    initialize = function() {
      .currentContext <<- NULL
      .nextId <<- 0L
-      .pendingInvalidate <<- list()
+      .pendingFlush <<- list()
    },
    nextId = function() {
      .nextId <<- .nextId + 1L
@@ -90,27 +92,22 @@ ReactiveEnvironment <- setRefClass(
      on.exit(.currentContext <<- old.ctx)
      func()
    },
-    addPendingInvalidate = function(ctx) {
-      .pendingInvalidate <<- c(.pendingInvalidate, ctx)
+    addPendingFlush = function(ctx) {
+      .pendingFlush <<- c(ctx, .pendingFlush)
    },
    flush = function() {
-      while (length(.pendingInvalidate) > 0) {
-        contexts <- .pendingInvalidate
-        .pendingInvalidate <<- list()
-        lapply(contexts, function(ctx) {
-          ctx$executeCallbacks()
-          NULL
-        })
+      while (length(.pendingFlush) > 0) {
+        ctx <- .pendingFlush[[1]]
+        .pendingFlush <<- .pendingFlush[-1]
+        ctx$executeFlushCallbacks()
      }
    }
  )
 )

+.reactiveEnvironment <- ReactiveEnvironment$new()
 .getReactiveEnvironment <- function() {
-  if (!exists('.ReactiveEnvironment', envir=.GlobalEnv, inherits=FALSE)) {
-    assign('.ReactiveEnvironment', ReactiveEnvironment$new(), envir=.GlobalEnv)
-  }
-  get('.ReactiveEnvironment', envir=.GlobalEnv, inherits=FALSE)
+  .reactiveEnvironment
 }

 # Causes any pending invalidations to run.
--- a/R/reactives.R
+++ b/R/reactives.R
@@ -1,61 +1,55 @@
-Dependencies <- setRefClass(
-  'Dependencies',
+Dependents <- setRefClass(
+  'Dependents',
  fields = list(
-    .dependencies = 'Map'
+    .dependents = 'Map'
  ),
  methods = list(
    register = function() {
      ctx <- .getReactiveEnvironment()$currentContext()
-      if (!.dependencies$containsKey(ctx$id)) {
-        .dependencies$set(ctx$id, ctx)
+      if (!.dependents$containsKey(ctx$id)) {
+        .dependents$set(ctx$id, ctx)
        ctx$onInvalidate(function() {
-          .dependencies$remove(ctx$id)
+          .dependents$remove(ctx$id)
        })
      }
    },
    invalidate = function() {
      lapply(
-        .dependencies$values(),
+        .dependents$values(),
        function(ctx) {
-          ctx$invalidateHint()
          ctx$invalidate()
          NULL
        }
      )
-    },
-    invalidateHint = function() {
-      lapply(
-        .dependencies$values(),
-        function(dep.ctx) {
-          dep.ctx$invalidateHint()
-          NULL
-        })
    }
  )
 )

-Values <- setRefClass(
-  'Values',
+
+ReactiveValues <- setRefClass(
+  'ReactiveValues',
  fields = list(
    .values = 'environment',
-    .dependencies = 'environment',
-    # Dependencies for the list of names
-    .namesDeps = 'Dependencies',
-    # Dependencies for all values
-    .allDeps = 'Dependencies'
+    .dependents = 'environment',
+    # Dependents for the list of all names, including hidden
+    .namesDeps = 'Dependents',
+    # Dependents for all values, including hidden
+    .allValuesDeps = 'Dependents',
+    # Dependents for all values
+    .valuesDeps = 'Dependents'
  ),
  methods = list(
    initialize = function() {
      .values <<- new.env(parent=emptyenv())
-      .dependencies <<- new.env(parent=emptyenv())
+      .dependents <<- new.env(parent=emptyenv())
    },
    get = function(key) {
      ctx <- .getReactiveEnvironment()$currentContext()
      dep.key <- paste(key, ':', ctx$id, sep='')
-      if (!exists(dep.key, where=.dependencies, inherits=FALSE)) {
-        assign(dep.key, ctx, pos=.dependencies, inherits=FALSE)
+      if (!exists(dep.key, where=.dependents, inherits=FALSE)) {
+        assign(dep.key, ctx, pos=.dependents, inherits=FALSE)
        ctx$onInvalidate(function() {
-          rm(list=dep.key, pos=.dependencies, inherits=FALSE)
+          rm(list=dep.key, pos=.dependents, inherits=FALSE)
        })
      }
      
@@ -65,6 +59,8 @@ Values <- setRefClass(
        base::get(key, pos=.values, inherits=FALSE)
    },
    set = function(key, value) {
+      hidden <- substr(key, 1, 1) == "."
+
      if (exists(key, where=.values, inherits=FALSE)) {
        if (identical(base::get(key, pos=.values, inherits=FALSE), value)) {
          return(invisible())
@@ -73,18 +69,21 @@ Values <- setRefClass(
      else {
        .namesDeps$invalidate()
      }
-      .allDeps$invalidate()
+
+      if (hidden)
+        .allValuesDeps$invalidate()
+      else
+        .valuesDeps$invalidate()
      
      assign(key, value, pos=.values, inherits=FALSE)
      dep.keys <- objects(
-        pos=.dependencies,
+        pos=.dependents,
        pattern=paste('^\\Q', key, ':', '\\E', '\\d+$', sep=''),
        all.names=TRUE
      )
      lapply(
-        mget(dep.keys, envir=.dependencies),
+        mget(dep.keys, envir=.dependents),
        function(ctx) {
-          ctx$invalidateHint()
          ctx$invalidate()
          NULL
        }
@@ -101,88 +100,211 @@ Values <- setRefClass(
      .namesDeps$register()
      return(ls(.values, all.names=TRUE))
    },
-    toList = function() {
-      .allDeps$register()
-      return(as.list(.values))
+    toList = function(all.names=FALSE) {
+      if (all.names)
+        .allValuesDeps$register()
+
+      .valuesDeps$register()
+
+      return(as.list(.values, all.names=all.names))
    }
  )
 )

-`[.Values` <- function(values, name) {
-  values$get(name)
+
+# reactivevalues: S3 wrapper class for Values class -----------------------
+
+#' Create an object for storing reactive values
+#'
+#' This function returns an object for storing reactive values. It is similar
+#' to a list, but with special capabilities for reactive programming. When you
+#' read a value from it, the calling reactive function takes a reactive
+#' dependency on that value, and when you write to it, it notifies any reactive
+#' functions that depend on that value.
+#'
+#' @examples
+#' # Create the object with no values
+#' values <- reactiveValues()
+#'
+#' # Assign values to 'a' and 'b'
+#' values$a <- 3
+#' values[['b']] <- 4
+#'
+#' \dontrun{
+#' # From within a reactive context, you can access values with:
+#' values$a
+#' values[['a']]
+#' }
+#'
+#' # If not in a reactive context (e.g., at the console), you can use isolate()
+#' # to retrieve the value:
+#' isolate(values$a)
+#' isolate(values[['a']])
+#'
+#' # Set values upon creation
+#' values <- reactiveValues(a = 1, b = 2)
+#' isolate(values$a)
+#'
+#' @param ... Objects that will be added to the reactivevalues object. All of
+#'   these objects must be named.
+#'
+#' @seealso \code{\link{isolate}}.
+#'
+#' @export
+reactiveValues <- function(...) {
+  args <- list(...)
+  if ((length(args) > 0) && (is.null(names(args)) || any(names(args) == "")))
+    stop("All arguments passed to reactiveValues() must be named.")
+
+  values <- .createReactiveValues(ReactiveValues$new())
+
+  # Use .subset2() instead of [[, to avoid method dispatch
+  .subset2(values, 'impl')$mset(args)
+  values
 }

-`[<-.Values` <- function(values, name, value) {
-  values$set(name, value)
-  return(values)
-}
-
-.createValuesReader <- function(values) {
+# Create a reactivevalues object
+#
+# @param values A ReactiveValues object
+# @param readonly Should this object be read-only?
+.createReactiveValues <- function(values = NULL, readonly = FALSE) {
  acc <- list(impl=values)
-  class(acc) <- 'reactvaluesreader'
+  class(acc) <- 'reactivevalues'
+  attr(acc, 'readonly') <- readonly
  return(acc)
 }

-#' @S3method $ reactvaluesreader
-`$.reactvaluesreader` <- function(x, name) {
-  x[['impl']]$get(name)
+#' @S3method $ reactivevalues
+`$.reactivevalues` <- function(x, name) {
+  .subset2(x, 'impl')$get(name)
 }

-#' @S3method names reactvaluesreader
-names.reactvaluesreader <- function(x) {
-  x[['impl']]$names()
+#' @S3method [[ reactivevalues
+`[[.reactivevalues` <- `$.reactivevalues`
+
+#' @S3method $<- reactivevalues
+`$<-.reactivevalues` <- function(x, name, value) {
+  if (attr(x, 'readonly')) {
+    stop("Attempted to assign value to a read-only reactivevalues object")
+  } else if (length(name) != 1 || !is.character(name)) {
+    stop("Must use single string to index into reactivevalues")
+  } else {
+    .subset2(x, 'impl')$set(name, value)
+    x
+  }
 }

-#' @S3method as.list reactvaluesreader
-as.list.reactvaluesreader <- function(x, ...) {
-  x[['impl']]$toList()
+#' @S3method [[<- reactivevalues
+`[[<-.reactivevalues` <- `$<-.reactivevalues`
+
+#' @S3method [ reactivevalues
+`[.reactivevalues` <- function(values, name) {
+  stop("Single-bracket indexing of reactivevalues object is not allowed.")
+}
+
+#' @S3method [<- reactivevalues
+`[<-.reactivevalues` <- function(values, name, value) {
+  stop("Single-bracket indexing of reactivevalues object is not allowed.")
+}
+
+#' @S3method names reactivevalues
+names.reactivevalues <- function(x) {
+  .subset2(x, 'impl')$names()
+}
+
+#' @S3method names<- reactivevalues
+`names<-.reactivevalues` <- function(x, value) {
+  stop("Can't assign names to reactivevalues object")
+}
+
+#' @S3method as.list reactivevalues
+as.list.reactivevalues <- function(x, all.names=FALSE, ...) {
+  .Deprecated("reactiveValuesToList",
+    msg = paste("'as.list.reactivevalues' is deprecated. ",
+      "Use reactiveValuesToList instead.",
+      "\nPlease see ?reactiveValuesToList for more information.",
+      sep = ""))
+
+  reactiveValuesToList(x, all.names)
+}
+
+#' Convert a reactivevalues object to a list
+#'
+#' This function does something similar to what you might \code{\link{as.list}}
+#' to do. The difference is that the calling context will take dependencies on
+#' every object in the reactivevalues object. To avoid taking dependencies on
+#' all the objects, you can wrap the call with \code{\link{isolate}()}.
+#'
+#' @param x A reactivevalues object.
+#' @param all.names If \code{TRUE}, include objects with a leading dot. If
+#'   \code{FALSE} (the default) don't include those objects.
+#' @examples
+#' values <- reactiveValues(a = 1)
+#' \dontrun{
+#' reactiveValuesToList(values)
+#' }
+#'
+#' # To get the objects without taking dependencies on them, use isolate().
+#' # isolate() can also be used when calling from outside a reactive context (e.g.
+#' # at the console)
+#' isolate(reactiveValuesToList(values))
+#'
+#' @export
+reactiveValuesToList <- function(x, all.names=FALSE) {
+  .subset2(x, 'impl')$toList(all.names)
 }

 Observable <- setRefClass(
  'Observable',
  fields = list(
    .func = 'function',
-    .dependencies = 'Dependencies',
-    .initialized = 'logical',
-    .value = 'ANY'
+    .label = 'character',
+    .dependents = 'Dependents',
+    .dirty = 'logical',
+    .running = 'logical',
+    .value = 'ANY',
+    .execCount = 'integer'
  ),
  methods = list(
-    initialize = function(func) {
+    initialize = function(func, label=deparse(substitute(func))) {
      if (length(formals(func)) > 0)
        stop("Can't make a reactive function from a function that takes one ",
             "or more parameters; only functions without parameters can be ",
             "reactive.")
      .func <<- func
-      .initialized <<- FALSE
+      .dirty <<- TRUE
+      .running <<- FALSE
+      .label <<- label
+      .execCount <<- 0L
    },
    getValue = function() {
-      if (!.initialized) {
-        .initialized <<- TRUE
+      .dependents$register()
+
+      if (.dirty || .running) {
        .self$.updateValue()
      }
      
-      .dependencies$register()
-      
      if (identical(class(.value), 'try-error'))
        stop(attr(.value, 'condition'))
      return(.value)
    },
    .updateValue = function() {
-      old.value <- .value
-      
-      ctx <- Context$new()
+      ctx <- Context$new(.label)
      ctx$onInvalidate(function() {
-        .self$.updateValue()
-      })
-      ctx$onInvalidateHint(function() {
-        .dependencies$invalidateHint()
+        .dirty <<- TRUE
+        .dependents$invalidate()
      })
+      .execCount <<- .execCount + 1L
+
+      .dirty <<- FALSE
+
+      wasRunning <- .running
+      .running <<- TRUE
+      on.exit(.running <<- wasRunning)
+
      ctx$run(function() {
        .value <<- try(.func(), silent=FALSE)
      })
-      if (!identical(old.value, .value)) {
-        .dependencies$invalidate()
-      }
    }
  )
 )
@@ -214,49 +336,67 @@ reactive <- function(x) {
 }
 #' @S3method reactive function
 reactive.function <- function(x) {
-  return(Observable$new(x)$getValue)
+  return(Observable$new(x, deparse(substitute(x)))$getValue)
 }
 #' @S3method reactive default
 reactive.default <- function(x) {
  stop("Don't know how to make this object reactive!")
 }

+# Return the number of times that a reactive function or observer has been run
+execCount <- function(x) {
+  if (is.function(x))
+    return(environment(x)$.execCount)
+  else if (is(x, 'Observer'))
+    return(x$.execCount)
+  else
+    stop('Unexpected argument to execCount')
+}
+
 Observer <- setRefClass(
  'Observer',
  fields = list(
    .func = 'function',
-    .hintCallbacks = 'list'
+    .label = 'character',
+    .flushCallbacks = 'list',
+    .execCount = 'integer'
  ),
  methods = list(
-    initialize = function(func) {
+    initialize = function(func, label) {
      if (length(formals(func)) > 0)
        stop("Can't make an observer from a function that takes parameters; ",
             "only functions without parameters can be reactive.")

      .func <<- func
+      .label <<- label
+      .execCount <<- 0L

      # Defer the first running of this until flushReact is called
-      ctx <- Context$new()
-      ctx$onInvalidate(function() {
+      ctx <- Context$new(.label)
+      ctx$onFlush(function() {
        run()
      })
-      ctx$invalidate()
+      ctx$addPendingFlush()
    },
    run = function() {
-      ctx <- Context$new()
+      ctx <- Context$new(.label)
+
      ctx$onInvalidate(function() {
-        run()
-      })
-      ctx$onInvalidateHint(function() {
-        lapply(.hintCallbacks, function(func) {
+        lapply(.flushCallbacks, function(func) {
          func()
          NULL
        })
+        ctx$addPendingFlush()
      })
+
+      ctx$onFlush(function() {
+        run()
+      })
+      .execCount <<- .execCount + 1L
      ctx$run(.func)
    },
-    onInvalidateHint = function(func) {
-      .hintCallbacks <<- c(.hintCallbacks, func)
+    onInvalidate = function(func) {
+      .flushCallbacks <<- c(.flushCallbacks, func)
    }
  )
 )
@@ -282,8 +422,7 @@ Observer <- setRefClass(
 #'   
 #' @export
 observe <- function(func) {
-  Observer$new(func)
-  invisible()
+  invisible(Observer$new(func, deparse(substitute(func))))
 }

 #' Timer
@@ -307,11 +446,11 @@ observe <- function(func) {
 #' @seealso invalidateLater
 #' @export
 reactiveTimer <- function(intervalMs=1000) {
-  dependencies <- Map$new()
+  dependents <- Map$new()
  timerCallbacks$schedule(intervalMs, function() {
    timerCallbacks$schedule(intervalMs, sys.function())
    lapply(
-      dependencies$values(),
+      dependents$values(),
      function(dep.ctx) {
        dep.ctx$invalidate()
        NULL
@@ -319,10 +458,10 @@ reactiveTimer <- function(intervalMs=1000) {
  })
  return(function() {
    ctx <- .getReactiveEnvironment()$currentContext()
-    if (!dependencies$containsKey(ctx$id)) {
-      dependencies$set(ctx$id, ctx)
+    if (!dependents$containsKey(ctx$id)) {
+      dependents$set(ctx$id, ctx)
      ctx$onInvalidate(function() {
-        dependencies$remove(ctx$id)
+        dependents$remove(ctx$id)
      })
    }
    return(Sys.time())
@@ -343,3 +482,48 @@ invalidateLater <- function(millis) {
  })
  invisible()
 }
+
+#' Create a non-reactive scope for an expression
+#' 
+#' Executes the given expression in a scope where reactive values or functions 
+#' can be read, but they cannot cause the reactive scope of the caller to be 
+#' re-evaluated when they change.
+#' 
+#' Ordinarily, the simple act of reading a reactive value causes a relationship 
+#' to be established between the caller and the reactive value, where a change 
+#' to the reactive value will cause the caller to re-execute. (The same applies 
+#' for the act of getting a reactive function's value.) The \code{isolate} 
+#' function lets you read a reactive value or function without establishing this
+#' relationship.
+#' 
+#' @param expr An expression that can access reactive values or functions.
+#' 
+#' @examples
+#' \dontrun{
+#' observer(function() {
+#'   input$saveButton  # Do take a dependency on input$saveButton
+#'   
+#'   # isolate a simple expression
+#'   data <- get(isolate(input$dataset))  # No dependency on input$dataset
+#'   writeToDatabase(data)
+#' })
+#' 
+#' observer(function() {
+#'   input$saveButton  # Do take a dependency on input$saveButton
+#'   
+#'   # isolate a whole block
+#'   data <- isolate({
+#'     a <- input$valueA   # No dependency on input$valueA or input$valueB
+#'     b <- input$valueB
+#'     c(a=a, b=b)
+#'   })
+#'   writeToDatabase(data)
+#' })
+#' }
+#' @export
+isolate <- function(expr) {
+  ctx <- Context$new('[isolate]')
+  ctx$run(function() {
+    eval.parent(expr)
+  })
+}
--- a/R/run-url.R
+++ b/R/run-url.R
@@ -0,0 +1,157 @@
+#' 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/3239667, then \code{3239667}, \code{'3239667'}, and
+#'   \code{'https://gist.github.com/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(4034323)
+#' runGist("https://gist.github.com/4034323")
+#' }
+#'
+#' @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.
+#'
+#' @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/")
+#' }
+#'
+#' @export
+runUrl <- function(url, filetype = NULL, subdir = NULL, port = 8100,
+  launch.browser = getOption('shiny.launch.browser', interactive())) {
+
+  if (!is.null(subdir) && ".." %in% strsplit(subdir, '/')[[1]])
+    stop("'..' not allowed in subdir")
+
+  if (is.null(filetype))
+    filetype <- basename(url)
+
+  if (grepl("\\.tar\\.gz$", filetype))
+    fileext <- ".tar.gz"
+  else if (grepl("\\.tar$", filetype))
+    fileext <- ".tar"
+  else if (grepl("\\.zip$", filetype))
+    fileext <- ".zip"
+  else
+    stop("Unknown file extension.")
+
+  message("Downloading ", url)
+  filePath <- tempfile('shinyapp', fileext=fileext)
+  if (download(url, filePath, mode = "wb", quiet = TRUE) != 0)
+    stop("Failed to download URL ", url)
+  on.exit(unlink(filePath))
+
+  if (fileext %in% c(".tar", ".tar.gz")) {
+    # Regular untar commonly causes two problems on Windows with github tarballs:
+    #   1) If RTools' tar.exe is in the path, you get cygwin path warnings which
+    #      throw list=TRUE off;
+    #   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))
+
+  } else if (fileext == ".zip") {
+    dirname <- as.character(unzip(filePath, list=TRUE)$Name[1])
+    unzip(filePath, exdir = dirname(filePath))
+  }
+
+  appdir <- file.path(dirname(filePath), dirname)
+  on.exit(unlink(appdir, recursive = TRUE), add = TRUE)
+
+  appsubdir <- ifelse(is.null(subdir), appdir, file.path(appdir, subdir))
+  runApp(appsubdir, port=port, launch.browser=launch.browser)
+}
--- a/R/shiny.R
+++ b/R/shiny.R
@@ -7,6 +7,11 @@ suppressPackageStartupMessages({
  library(RJSONIO)
 })

+createUniqueId <- function(bytes) {
+  # TODO: Use a method that isn't affected by the R seed
+  paste(as.character(as.raw(floor(runif(bytes, min=1, max=255)))), collapse='')
+}
+
 ShinyApp <- setRefClass(
  'ShinyApp',
  fields = list(
@@ -15,7 +20,11 @@ ShinyApp <- setRefClass(
    .invalidatedOutputErrors = 'Map',
    .progressKeys = 'character',
    .fileUploadContext = 'FileUploadContext',
-    session = 'Values'
+    session = 'ReactiveValues',
+    token = 'character',  # Used to identify this instance in URLs
+    plots = 'Map',
+    downloads = 'Map',
+    allowDataUriScheme = 'logical'
  ),
  methods = list(
    initialize = function(ws) {
@@ -25,9 +34,13 @@ ShinyApp <- setRefClass(
      .progressKeys <<- character(0)
      # TODO: Put file upload context in user/app-specific dir if possible
      .fileUploadContext <<- FileUploadContext$new()
-      session <<- Values$new()
+      session <<- ReactiveValues$new()
+      
+      token <<- createUniqueId(16)
+      
+      allowDataUriScheme <<- TRUE
    },
-    defineOutput = function(name, func) {
+    defineOutput = function(name, func, label) {
      "Binds an output generating function to this name. The function can either
      take no parameters, or have named parameters for \\code{name} and
      \\code{shinyapp} (in the future this list may expand, so it is a good idea
@@ -61,9 +74,9 @@ ShinyApp <- setRefClass(
          }
          else
            .invalidatedOutputValues$set(name, value)
-        })
+        }, label)
        
-        obs$onInvalidateHint(function() {
+        obs$onInvalidate(function() {
          showProgress(name)
        })
      }
@@ -134,7 +147,8 @@ ShinyApp <- setRefClass(
    },
    .write = function(json) {
      if (getOption('shiny.trace', FALSE))
-        message('SEND ', json)
+        message('SEND ', 
+           gsub('(?m)base64,[a-zA-Z0-9+/=]+','[base64 data]',json,perl=TRUE))
      if (getOption('shiny.transcode.json', TRUE))
        json <- iconv(json, to='UTF-8')
      websocket_write(json, .websocket)
@@ -165,6 +179,110 @@ ShinyApp <- setRefClass(
      fileData <- .fileUploadContext$getUploadOperation(jobId)$finish()
      session$set(inputId, fileData)
      invisible()
+    },
+    # Provides a mechanism for handling direct HTTP requests that are posted
+    # to the session (rather than going through the websocket)
+    handleRequest = function(ws, header, subpath) {
+      # TODO: Turn off caching for the response
+      
+      matches <- regmatches(subpath,
+                            regexec("^/([a-z]+)/([^?]*)", 
+                                    subpath, 
+                                    ignore.case=TRUE))[[1]]
+      if (length(matches) == 0)
+        return(httpResponse(400, 'text/html', '<h1>Bad Request</h1>'))
+      
+      if (matches[2] == 'plot') {
+        savedPlot <- plots$get(utils::URLdecode(matches[3]))
+        if (is.null(savedPlot))
+          return(httpResponse(404, 'text/html', '<h1>Not Found</h1>'))
+        
+        return(httpResponse(200, savedPlot$contentType, savedPlot$data))
+      }
+      
+      if (matches[2] == 'download') {
+        
+        # A bunch of ugliness here. Filenames can be dynamically generated by
+        # the user code, so we don't know what they'll be in advance. But the
+        # most reliable way to use non-ASCII filenames for downloads is to
+        # put the actual filename in the URL. So we will start with URLs in
+        # the form:
+        # 
+        #   /session/$TOKEN/download/$NAME
+        #
+        # When a request matching that pattern is received, we will calculate
+        # the filename and see if it's non-ASCII; if so, we'll redirect to
+        #
+        #   /session/$TOKEN/download/$NAME/$FILENAME
+        #
+        # And when that pattern is received, we will actually return the file.
+        # Note that this means the filename and contents could be determined
+        # a few moments apart from each other (an HTTP roundtrip basically),
+        # hopefully that won't be enough to matter for anyone.
+        
+        dlmatches <- regmatches(matches[3],
+                                regexec("^([^/]+)(/[^/]+)?$",
+                                        matches[3]))[[1]]
+        dlname <- utils::URLdecode(dlmatches[2])
+        download <- downloads$get(dlname)
+        if (is.null(download))
+          return(httpResponse(404, 'text/html', '<h1>Not Found</h1>'))
+        
+        filename <- ifelse(is.function(download$filename),
+                           Context$new()$run(download$filename),
+                           download$filename)
+
+        # If the URL does not contain the filename, and the desired filename
+        # contains non-ASCII characters, then do a redirect with the desired
+        # name tacked on the end.
+        if (dlmatches[3] == '' && grepl('[^ -~]', filename)) {
+          
+          return(httpResponse(302, 'text/html', '<h1>Found</h1>', c(
+            'Location' = sprintf('%s/%s',
+                                 utils::URLencode(dlname, TRUE),
+                                 utils::URLencode(filename, TRUE)),
+            'Cache-Control' = 'no-cache')))
+        }
+        
+        tmpdata <- tempfile()
+        on.exit(unlink(tmpdata))
+        result <- try(Context$new()$run(function() { download$func(tmpdata) }))
+        if (is(result, 'try-error')) {
+          return(httpResponse(500, 'text/plain', 
+                              attr(result, 'condition')$message))
+        }
+        return(httpResponse(
+          200,
+          download$contentType %OR% getContentType(tools::file_ext(filename)),
+          readBin(tmpdata, 'raw', n=file.info(tmpdata)$size),
+          c(
+            'Content-Disposition' = ifelse(
+              dlmatches[3] == '',
+              'attachment; filename="' %.% 
+                gsub('(["\\\\])', '\\\\\\1', filename) %.%  # yes, that many \'s
+                '"',
+              'attachment'
+            ),
+            'Cache-Control'='no-cache')))
+      }
+      
+      return(httpResponse(404, 'text/html', '<h1>Not Found</h1>'))
+    },
+    savePlot = function(name, data, contentType) {
+      plots$set(name, list(data=data, contentType=contentType))
+      return(sprintf('session/%s/plot/%s?%s',
+                     URLencode(token, TRUE),
+                     URLencode(name, TRUE),
+                     createUniqueId(8)))
+    },
+    registerDownload = function(name, filename, contentType, func) {
+      
+      downloads$set(name, list(filename = filename,
+                               contentType = contentType,
+                               func = func))
+      return(sprintf('session/%s/download/%s',
+                     URLencode(token, TRUE),
+                     URLencode(name, TRUE)))
    }
  )
 )
@@ -177,7 +295,7 @@ ShinyApp <- setRefClass(

 #' @S3method $<- shinyoutput
 `$<-.shinyoutput` <- function(x, name, value) {
-  x[['impl']]$defineOutput(name, value)
+  x[['impl']]$defineOutput(name, value, deparse(substitute(value)))
  return(invisible(x))
 }

@@ -198,12 +316,24 @@ resolve <- function(dir, relpath) {

 httpResponse <- function(status = 200,
                         content_type = "text/html; charset=UTF-8", 
-                         content = "") {
-  resp <- list(status = status, content_type = content_type, content = content);
+                         content = "",
+                         headers = c()) {
+  resp <- list(status = status, content_type = content_type, content = content,
+               headers = headers)
  class(resp) <- 'httpResponse'
  return(resp)
 }

+fixupRequestPath <- function(header) {
+  # Separate the path from the query
+  pathEnd <- regexpr('?', header$RESOURCE, fixed=TRUE)
+  if (pathEnd > 0)
+    header$PATH <- substring(header$RESOURCE, 1, pathEnd - 1)
+  else
+    header$PATH <- header$RESOURCE
+  return(header)
+}
+
 httpServer <- function(handlers) {
  handler <- joinHandlers(handlers)

@@ -212,6 +342,8 @@ httpServer <- function(handlers) {
    filter <- function(ws, header, response) response
  
  function(ws, header) {
+    header <- fixupRequestPath(header)
+    
    response <- handler(ws, header)
    if (is.null(response))
      response <- httpResponse(404, content="<h1>Not Found</h1>")
@@ -221,7 +353,8 @@ httpServer <- function(handlers) {
    return(http_response(ws,
                         status=response$status,
                         content_type=response$content_type,
-                         content=response$content))
+                         content=response$content,
+                         headers=response$headers))
  }
 }

@@ -251,6 +384,25 @@ joinHandlers <- function(handlers) {
  }
 }

+sessionHandler <- function(ws, header) {
+  path <- header$PATH
+  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]][2]
+  subpath <- matches[[1]][3]
+  
+  shinyapp <- appsByToken$get(session)
+  if (is.null(shinyapp))
+    return(NULL)
+  
+  return(shinyapp$handleRequest(ws, header, subpath))
+}
+
 dynamicHandler <- function(filePath, dependencyFiles=filePath) {
  lastKnownTimestamps <- NA
  metaHandler <- function(ws, header) NULL
@@ -271,7 +423,7 @@ dynamicHandler <- function(filePath, dependencyFiles=filePath) {
      if (file.exists(filePath)) {
        local({
          cacheContext$with(function() {
-            source(filePath, local=TRUE)
+            source(filePath, local=new.env(parent=.GlobalEnv))
          })
        })
      }
@@ -285,7 +437,7 @@ dynamicHandler <- function(filePath, dependencyFiles=filePath) {

 staticHandler <- function(root) {
  return(function(ws, header) {
-    path <- header$RESOURCE
+    path <- header$PATH
    
    if (is.null(path))
      return(httpResponse(400, content="<h1>Bad Request</h1>"))
@@ -298,22 +450,14 @@ staticHandler <- function(root) {
      return(NULL)
    
    ext <- tools::file_ext(abs.path)
-    content.type <- switch(ext,
-                           html='text/html; charset=UTF-8',
-                           htm='text/html; charset=UTF-8',
-                           js='text/javascript',
-                           css='text/css',
-                           png='image/png',
-                           jpg='image/jpeg',
-                           jpeg='image/jpeg',
-                           gif='image/gif',
-                           'application/octet-stream')
+    content.type <- getContentType(ext)
    response.content <- readBin(abs.path, 'raw', n=file.info(abs.path)$size)
    return(httpResponse(200, content.type, response.content))
  })
 }

 apps <- Map$new()
+appsByToken <- Map$new()

 # Provide a character representation of the WS that can be used
 # as a key in a Map.
@@ -406,6 +550,7 @@ resourcePathHandler <- function(ws, header) {
  suffix <- substr(path, 2 + len, nchar(path))
  
  header$RESOURCE <- suffix
+  header <- fixupRequestPath(header)
  
  return(resInfo$func(ws, header))
 }
@@ -526,7 +671,7 @@ startApp <- function(port=8101L) {
  serverFileTimestamp <- NULL
  local({
    serverFileTimestamp <<- file.info(serverR)$mtime
-    source(serverR, local=TRUE)
+    source(serverR, local=new.env(parent=.GlobalEnv))
    if (is.null(.globals$server))
      stop("No server was defined in server.R")
  })
@@ -534,7 +679,8 @@ startApp <- function(port=8101L) {
  
  ws_env <- create_server(
    port=port,
-    webpage=httpServer(c(dynamicHandler(uiR),
+    webpage=httpServer(c(sessionHandler,
+                         dynamicHandler(uiR),
                         wwwDir,
                         sys.www.root,
                         resourcePathHandler)))
@@ -542,9 +688,13 @@ startApp <- function(port=8101L) {
  set_callback('established', function(WS, ...) {
    shinyapp <- ShinyApp$new(WS)
    apps$set(wsToKey(WS), shinyapp)
+    appsByToken$set(shinyapp$token, shinyapp)
  }, ws_env)
  
  set_callback('closed', function(WS, ...) {
+    shinyapp <- apps$get(wsToKey(WS))
+    if (!is.null(shinyapp))
+      appsByToken$remove(shinyapp$token)
    apps$remove(wsToKey(WS))
  }, ws_env)
  
@@ -580,8 +730,16 @@ startApp <- function(port=8101L) {
            stop('Unknown type specified for ', name)
          )
        }
-        else if (is.list(val) && is.null(names(val)))
-          msg$data[[name]] <- unlist(val, recursive=FALSE)
+        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
+          }
+        }
      }
    }
    
@@ -595,17 +753,19 @@ startApp <- function(port=8101L) {
          shinyServer(NULL)
          local({
            serverFileTimestamp <<- mtime
-            source(serverR, local=TRUE)
+            source(serverR, local=new.env(parent=.GlobalEnv))
            if (is.null(.globals$server))
              stop("No server was defined in server.R")
          })
          serverFunc <<- .globals$server
        }
        
+        shinyapp$allowDataUriScheme <- msg$data[['__allowDataUriScheme']]
+        msg$data[['__allowDataUriScheme']] <- NULL
        shinyapp$session$mset(msg$data)
        flushReact()
        local({
-          serverFunc(input=.createValuesReader(shinyapp$session),
+          serverFunc(input=.createReactiveValues(shinyapp$session, readonly=TRUE),
                     output=.createOutputWriter(shinyapp))
        })
      },
@@ -671,7 +831,9 @@ runApp <- function(appDir=getwd(),
  
  orig.wd <- getwd()
  setwd(appDir)
-  on.exit(setwd(orig.wd))
+  on.exit(setwd(orig.wd), add = TRUE)
+  
+  require(shiny)
  
  ws_env <- startApp(port=port)
  
@@ -778,47 +940,3 @@ download <- function(url, ...) {
    download.file(url, ...)
  }
 }
-
-#' 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/3239667, then \code{3239667}, \code{'3239667'}, and
-#'   \code{'https://gist.github.com/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.
-#'   
-#' @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/gists/%s/download', gist)
-  } else if(grepl('^https://gist.github.com/([0-9a-f]+)$', gist)) {
-    paste(sub('https://gist.github.com/',
-              'https://gist.github.com/gists/',
-              gist),
-          '/download',
-          sep='')
-  } else {
-    stop('Unrecognized gist identifier format')
-  }
-  filePath <- tempfile('shinygist', fileext='.tar.gz')
-  if (download(gistUrl, filePath, mode = "wb", quiet = TRUE) != 0)
-    stop("Failed to download URL ", gistUrl)
-  on.exit(unlink(filePath))
-  
-  dirname <- untar(filePath, list=TRUE)[1]
-  untar(filePath, exdir=dirname(filePath))
-  
-  appdir <- file.path(dirname(filePath), dirname)
-  on.exit(unlink(appdir, recursive = TRUE))
-  
-  runApp(appdir, port=port, launch.browser=launch.browser)
-}
--- a/R/shinyui.R
+++ b/R/shinyui.R
@@ -106,7 +106,7 @@ renderPage <- function(ui, connection) {
    if (isTag(content) && identical(content$name, "head")) {
      textConn <- textConnection(NULL, "w") 
      textConnWriter <- function(text) cat(text, file = textConn)
-      tagWriteChildren(content, textConnWriter, 1, context)
+      tagWrite(content$children, textConnWriter, 1, context)
      context$head <- append(context$head, textConnectionValue(textConn))
      close(textConn)
      return (FALSE)
@@ -126,10 +126,10 @@ renderPage <- function(ui, connection) {
  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"/>',
+               '  <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,
               '</head>',
               '<body>', 
@@ -189,7 +189,8 @@ shinyUI <- function(ui, path='/') {
  registerClient({
    
    function(ws, header) {
-      if (header$RESOURCE != path)
+
+      if (header$PATH != path)
        return(NULL)
      
      textConn <- textConnection(NULL, "w") 
--- a/R/shinywrappers.R
+++ b/R/shinywrappers.R
@@ -10,12 +10,24 @@ suppressPackageStartupMessages({
 #' 
 #' The corresponding HTML output tag should be \code{div} or \code{img} and have
 #' the CSS class name \code{shiny-plot-output}.
+#'
+#' For output, it will try to use the following devices, in this order:
+#' quartz (via \code{\link[grDevices]{png}}), then \code{\link[Cairo]{CairoPNG}},
+#' and finally \code{\link[grDevices]{png}}. This is in order of quality of
+#' output. Notably, plain \code{png} output on Linux and Windows may not
+#' antialias some point shapes, resulting in poor quality output.
 #' 
 #' @param func A function 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.
-#' @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.
+#' @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 ... Arguments to be passed through to \code{\link[grDevices]{png}}. 
 #'   These can be used to set the width, height, background color, etc.
 #'   
@@ -23,9 +35,19 @@ suppressPackageStartupMessages({
 reactivePlot <- function(func, width='auto', height='auto', ...) {
  args <- list(...)
  
+  if (is.function(width))
+    width <- reactive(width)
+  if (is.function(height))
+    height <- reactive(height)
+
  return(function(shinyapp, name, ...) {
    png.file <- tempfile(fileext='.png')
    
+    if (is.function(width))
+      width <- width()
+    if (is.function(height))
+      height <- height()
+    
    # 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).
@@ -37,8 +59,21 @@ reactivePlot <- function(func, width='auto', height='auto', ...) {
    
    if (width <= 0 || height <= 0)
      return(NULL)
-    
-    do.call(png, c(args, filename=png.file, width=width, height=height))
+
+    # If quartz is available, use png() (which will default to quartz).
+    # Otherwise, if the Cairo package is installed, use CairoPNG().
+    # Finally, if neither quartz nor Cairo, use png().
+    if (capabilities("aqua")) {
+      pngfun <- png
+    } else if (nchar(system.file(package = "Cairo"))) {
+      require(Cairo)
+      pngfun <- CairoPNG
+    } else {
+      pngfun <- png
+    }
+
+    do.call(pngfun, c(args, filename=png.file, width=width, height=height))
+    on.exit(unlink(png.file))
    tryCatch(
      func(),
      finally=dev.off())
@@ -47,8 +82,15 @@ reactivePlot <- function(func, width='auto', height='auto', ...) {
    if (is.na(bytes))
      return(NULL)
    
-    b64 <- base64encode(readBin(png.file, 'raw', n=bytes))
-    return(paste("data:image/png;base64,", b64, sep=''))
+    pngData <- readBin(png.file, 'raw', n=bytes)
+    if (shinyapp$allowDataUriScheme) {
+      b64 <- base64encode(pngData)
+      return(paste("data:image/png;base64,", b64, sep=''))
+    }
+    else {
+      imageUrl <- shinyapp$savePlot(name, pngData, 'image/png')
+      return(imageUrl)
+    }
  })
 }

@@ -62,7 +104,8 @@ reactivePlot <- function(func, width='auto', height='auto', ...) {
 #' 
 #' @param func A function 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}}.
+#' @param ... Arguments to be passed through to \code{\link[xtable]{xtable}} and
+#'   \code{\link[xtable]{print.xtable}}.
 #'   
 #' @export
 reactiveTable <- function(func, ...) {
@@ -70,7 +113,7 @@ reactiveTable <- function(func, ...) {
    classNames <- getOption('shiny.table.class', 'data table table-bordered table-condensed')
    data <- func()

-    if (is.null(data) || is.na(data))
+    if (is.null(data))
      return("")
    
    return(paste(
@@ -80,16 +123,17 @@ reactiveTable <- function(func, ...) {
              html.table.attributes=paste('class="',
                                          htmlEscape(classNames, TRUE),
                                          '"',
-                                          sep=''))),
+                                          sep=''), ...)),
      collapse="\n"))
  })
 }

 #' Printable Output
 #' 
-#' Makes a reactive version of the given function that also turns its printable
-#' result into a string. The reactive function is suitable for assigning to an 
-#' \code{output} slot.
+#' 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 
 #' recommended if you need a monospace font and whitespace preserved) and should
@@ -98,12 +142,26 @@ reactiveTable <- function(func, ...) {
 #' The result of executing \code{func} will be printed inside a 
 #' \code{\link[utils]{capture.output}} call.
 #' 
-#' @param func A function that returns a printable R object.
+#' 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 func A function that may print output and/or return a printable R 
+#'   object.
+#'   
+#' @seealso \code{\link{reactiveText}} for displaying the value returned from a 
+#'   function, instead of the printed output.
+#'
+#' @example res/text-example.R
 #'   
 #' @export
 reactivePrint <- function(func) {
  reactive(function() {
-    return(paste(capture.output(print(func())), collapse="\n"))
+    return(paste(capture.output({
+      result <- withVisible(func())
+      if (result$visible)
+        print(result$value)
+    }), collapse="\n"))
  })
 }

@@ -123,10 +181,16 @@ reactivePrint <- function(func) {
 #' @param func A function that returns an R object that can be used as an
 #'   argument to \code{cat}.
 #'   
+#' @seealso \code{\link{reactivePrint}} for capturing the print output of a
+#'   function, rather than the returned text value.
+#'
+#' @example res/text-example.R
+#'   
 #' @export
 reactiveText <- function(func) {
  reactive(function() {
-    return(paste(capture.output(cat(func())), collapse="\n"))
+    value <- func()
+    return(paste(capture.output(cat(value)), collapse="\n"))
  })
 }

@@ -157,6 +221,54 @@ reactiveUI <- function(func) {
    result <- func()
    if (is.null(result) || length(result) == 0)
      return(NULL)
-    return(as.character(result))
+    # Wrap result in tagList in case it is an ordinary list
+    return(as.character(tagList(result)))
  })
 }
+
+#' 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 
+#' \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 
+#'   used from this function.)
+#' @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 
+#'   extension, or \code{application/octet-stream} if the extension is unknown.
+#'   
+#' @examples
+#' \dontrun{
+#' # In server.R:
+#' output$downloadData <- downloadHandler(
+#'   filename = function() {
+#'     paste('data-', Sys.Date(), '.csv', sep='')
+#'   },
+#'   content = function(file) {
+#'     write.csv(data, file)
+#'   }
+#' )
+#' 
+#' # In ui.R:
+#' downloadLink('downloadData', 'Download')
+#' }
+#' 
+#' @export
+downloadHandler <- function(filename, content, contentType=NA) {
+  return(function(shinyapp, name, ...) {
+    shinyapp$registerDownload(name, filename, contentType, content)
+  })
+}
--- a/R/slider.R
+++ b/R/slider.R
@@ -101,24 +101,14 @@ slider <- function(inputId, min, max, value, step = NULL, ...,
  }
  
  # build slider
-  sliderFragment <- list(
-    singleton(
-      tags$head(
-        tags$link(rel="stylesheet", 
-                  type="text/css", 
-                  href="shared/slider/css/jquery.slider.min.css"),
-        
-        tags$script(src="shared/slider/js/jquery.slider.min.js")
-      )
-    ),
-    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)
-  )
-  
+  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()
  
--- a/R/tags.R
+++ b/R/tags.R
@@ -61,7 +61,7 @@ as.character.shiny.tag <- function(x, ...) {
    cat(text, file=f)
  }
  tagWrite(x, textWriter)
-  return(HTML(paste(readLines(f), collapse='\n')))
+  return(HTML(paste(readLines(f, warn=FALSE), collapse='\n')))
 }

 #' @S3method print shiny.tag.list
@@ -160,23 +160,7 @@ tag <- function(`_tag_name`, varArgs) {
  return (tag)
 }

-tagWriteChildren <- function(tag, textWriter, indent, context) {
-  for (child in tag$children) {
-    if (isTag(child)) {
-      tagWrite(child, textWriter, indent, context)
-    }
-    else {
-      # first call optional filter -- exit function if it returns false
-      if (is.null(context) || is.null(context$filter) || context$filter(child)) {
-        child <- normalizeText(child)
-        indentText <- paste(rep(" ", indent*3), collapse="")
-        textWriter(paste(indentText, child, "\n", sep=""))
-      }
-    }
-  }
-}
-
-tagWrite <- function(tag, textWriter, indent=0, context = NULL) {
+tagWrite <- function(tag, textWriter, indent=0, context = NULL, eol = "\n") {
  
  # optionally process a list of tags
  if (!isTag(tag) && is.list(tag)) {
@@ -189,7 +173,13 @@ tagWrite <- function(tag, textWriter, indent=0, context = NULL) {
    return (NULL)
  
  # compute indent text
-  indentText <- paste(rep(" ", indent*3), collapse="")
+  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=""))
@@ -210,19 +200,18 @@ tagWrite <- function(tag, textWriter, indent=0, context = NULL) {
  
  # 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]]) ) {
-      if (is.null(context) || is.null(context$filter) 
-          || context$filter(tag$children[[1]])) {
-        text <- normalizeText(tag$children[[1]])
-        textWriter(paste(">", text, "</", tag$name, ">\n", sep=""))
-      }
+      tagWrite(tag$children[[1]], textWriter, 0, context, "")
+      textWriter(paste("</", tag$name, ">", eol, sep=""))
    }
    else {
-      textWriter(">\n")
-      tagWriteChildren(tag, textWriter, indent+1, context)
-      textWriter(paste(indentText, "</", tag$name, ">\n", sep=""))
+      textWriter("\n")
+      for (child in tag$children)
+        tagWrite(child, textWriter, indent+1, context)
+      textWriter(paste(indentText, "</", tag$name, ">", eol, sep=""))
    }
  }
  else {
@@ -231,16 +220,15 @@ tagWrite <- function(tag, textWriter, indent=0, context = NULL) {
    if (tag$name %in% c("area", "base", "br", "col", "command", "embed", "hr", 
                        "img", "input", "keygen", "link", "meta", "param",
                        "source", "track", "wbr")) {
-      textWriter("/>\n")
+      textWriter(paste("/>", eol, sep=""))
    }
    else {
-      textWriter(paste("></", tag$name, ">\n", sep=""))
+      textWriter(paste("></", tag$name, ">", eol, sep=""))
    }
  }
 }


-
 # environment used to store all available tags
 #' @export
 tags <- new.env()
--- a/R/tar.R
+++ b/R/tar.R
@@ -0,0 +1,191 @@
+# This file was pulled from the R code base as of
+# Thursday, November 22, 2012 at 6:24:55 AM UTC
+# and edited to remove everything but the copyright
+# header and untar2, and to make untar2 more tolerant
+# of the 'x' and 'g' extended block indicators, the
+# latter of which is used in tar files generated by
+# GitHub.
+
+
+#  File src/library/utils/R/tar.R
+#  Part of the R package, http://www.R-project.org
+#
+#  Copyright (C) 1995-2012 The R Core Team
+#
+#  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 2 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.
+#
+#  A copy of the GNU General Public License is available at
+#  http://www.r-project.org/Licenses/
+
+untar2 <- function(tarfile, files = NULL, list = FALSE, exdir = ".")
+{
+    getOct <- function(x, offset, len)
+    {
+        x <- 0L
+        for(i in offset + seq_len(len)) {
+            z <- block[i]
+            if(!as.integer(z)) break; # terminate on nul
+            switch(rawToChar(z),
+                   " " = {},
+                   "0"=,"1"=,"2"=,"3"=,"4"=,"5"=,"6"=,"7"=
+                   {x <- 8*x + (as.integer(z)-48)},
+                   stop("invalid octal digit")
+                   )
+        }
+        x
+    }
+
+    mydir.create <- function(path, ...) {
+        ## for Windows' sake
+        path <- sub("[\\/]$", "", path)
+        if(file_test("-d", path)) return()
+        if(!dir.create(path, showWarnings = TRUE, recursive = TRUE, ...))
+           stop(gettextf("failed to create directory %s", sQuote(path)),
+                domain = NA)
+    }
+
+    warn1 <- character()
+
+    ## A tar file is a set of 512 byte records,
+    ## a header record followed by file contents (zero-padded).
+    ## See http://en.wikipedia.org/wiki/Tar_%28file_format%29
+    if(is.character(tarfile) && length(tarfile) == 1L) {
+        con <- gzfile(path.expand(tarfile), "rb") # reads compressed formats
+        on.exit(close(con))
+    } else if(inherits(tarfile, "connection")) con <- tarfile
+    else stop("'tarfile' must be a character string or a connection")
+    if (!missing(exdir)) {
+        mydir.create(exdir)
+        od <- setwd(exdir)
+        on.exit(setwd(od), add = TRUE)
+    }
+    contents <- character()
+    llink <- lname <- NULL
+    repeat{
+        block <- readBin(con, "raw", n = 512L)
+        if(!length(block)) break
+        if(length(block) < 512L) stop("incomplete block on file")
+        if(all(block == 0)) break
+        ns <- max(which(block[1:100] > 0))
+        name <- rawToChar(block[seq_len(ns)])
+        magic <- rawToChar(block[258:262])
+        if ((magic == "ustar") && block[346] > 0) {
+            ns <- max(which(block[346:500] > 0))
+            prefix <- rawToChar(block[345+seq_len(ns)])
+            name <- file.path(prefix, name)
+        }
+        ## mode zero-padded 8 bytes (including nul) at 101
+        ## Aargh: bsdtar has this one incorrectly with 6 bytes+space
+        mode <- as.octmode(getOct(block, 100, 8))
+        size <- getOct(block, 124, 12)
+        ts <- getOct(block, 136, 12)
+        ft <- as.POSIXct(as.numeric(ts), origin="1970-01-01", tz="UTC")
+        csum <- getOct(block, 148, 8)
+        block[149:156] <- charToRaw(" ")
+        xx <- as.integer(block)
+        checksum <- sum(xx) %% 2^24 # 6 bytes
+        if(csum != checksum) {
+            ## try it with signed bytes.
+            checksum <- sum(ifelse(xx > 127, xx - 128, xx)) %% 2^24 # 6 bytes
+            if(csum != checksum)
+                warning(gettextf("checksum error for entry '%s'", name),
+                        domain = NA)
+        }
+        type <- block[157L]
+        ctype <- rawToChar(type)
+        if(type == 0L || ctype == "0") {
+            if(!is.null(lname)) {name <- lname; lname <- NULL}
+            contents <- c(contents, name)
+            remain <- size
+            dothis <- !list
+            if(dothis && length(files)) dothis <- name %in% files
+            if(dothis) {
+                mydir.create(dirname(name))
+                out <- file(name, "wb")
+            }
+            for(i in seq_len(ceiling(size/512L))) {
+                block <- readBin(con, "raw", n = 512L)
+                if(length(block) < 512L)
+                    stop("incomplete block on file")
+                if (dothis) {
+                    writeBin(block[seq_len(min(512L, remain))], out)
+                    remain <- remain - 512L
+                }
+            }
+            if(dothis) {
+                close(out)
+                Sys.chmod(name, mode, FALSE) # override umask
+                Sys.setFileTime(name, ft)
+            }
+        } else if(ctype %in% c("1", "2")) { # hard and symbolic links
+            contents <- c(contents, name)
+            ns <- max(which(block[158:257] > 0))
+            name2 <- rawToChar(block[157L + seq_len(ns)])
+            if(!is.null(lname)) {name <- lname; lname <- NULL}
+            if(!is.null(llink)) {name2 <- llink; llink <- NULL}
+            if(!list) {
+                if(ctype == "1") {
+                    if (!file.link(name2, name)) { # will give a warning
+                        ## link failed, so try a file copy
+                        if(file.copy(name2, name))
+                             warn1 <- c(warn1, "restoring hard link as a file copy")
+                        else
+                            warning(gettextf("failed to copy %s to %s", sQuote(name2), sQuote(name)), domain = NA)
+                    }
+                } else {
+                    if(.Platform$OS.type == "windows") {
+                        ## this will not work for links to dirs
+                        from <- file.path(dirname(name), name2)
+                        if (!file.copy(from, name))
+                            warning(gettextf("failed to copy %s to %s", sQuote(from), sQuote(name)), domain = NA)
+                        else
+                            warn1 <- c(warn1, "restoring symbolic link as a file copy")
+                   } else {
+                       if(!file.symlink(name2, name)) { # will give a warning
+                        ## so try a file copy: will not work for links to dirs
+                        from <- file.path(dirname(name), name2)
+                        if (file.copy(from, name))
+                            warn1 <- c(warn1, "restoring symbolic link as a file copy")
+                           else
+                               warning(gettextf("failed to copy %s to %s", sQuote(from), sQuote(name)), domain = NA)
+                       }
+                   }
+                }
+            }
+        } else if(ctype == "5") {
+            contents <- c(contents, name)
+            if(!list) {
+                mydir.create(name)
+                Sys.chmod(name, mode, TRUE) # FIXME: check result
+                ## no point is setting time, as dir will be populated later.
+            }
+        } else if(ctype %in% c("L", "K")) {
+            ## This is a GNU extension that should no longer be
+            ## in use, but it is.
+            name_size <- 512L * ceiling(size/512L)
+            block <- readBin(con, "raw", n = name_size)
+            if(length(block) < name_size)
+                stop("incomplete block on file")
+            ns <- max(which(block > 0)) # size on file may or may not include final nul
+            if(ctype == "L")
+                lname <- rawToChar(block[seq_len(ns)])
+            else
+                llink <- rawToChar(block[seq_len(ns)])
+        } else if(ctype %in% c("x", "g")) {
+            readBin(con, "raw", n = 512L*ceiling(size/512L))
+        } else stop("unsupported entry type ", sQuote(ctype))
+    }
+    if(length(warn1)) {
+        warn1 <- unique(warn1)
+        for (w in warn1) warning(w, domain = NA)
+    }
+    if(list) contents else invisible(0L)
+}
--- a/R/utils.R
+++ b/R/utils.R
@@ -0,0 +1,104 @@
+#' Make a random number generator repeatable
+#' 
+#' Given a function that generates random data, returns a wrapped version of 
+#' that function that always uses the same seed when called. The seed to use can
+#' be passed in explicitly if desired; otherwise, a random number is used.
+#' 
+#' @param rngfunc The function that is affected by the R session's seed.
+#' @param seed The seed to set every time the resulting function is called.
+#' @return A repeatable version of the function that was passed in.
+#'   
+#' @note When called, the returned function attempts to preserve the R session's
+#'   current seed by snapshotting and restoring
+#'   \code{\link[base]{.Random.seed}}.
+#'
+#' @examples
+#' rnormA <- repeatable(rnorm)
+#' rnormB <- repeatable(rnorm)
+#' rnormA(3)  # [1]  1.8285879 -0.7468041 -0.4639111
+#' rnormA(3)  # [1]  1.8285879 -0.7468041 -0.4639111
+#' rnormA(5)  # [1]  1.8285879 -0.7468041 -0.4639111 -1.6510126 -1.4686924
+#' rnormB(5)  # [1] -0.7946034  0.2568374 -0.6567597  1.2451387 -0.8375699
+#' 
+#' @export
+repeatable <- function(rngfunc, seed = runif(1, 0, .Machine$integer.max)) {
+  force(seed)
+  
+  function(...) {
+    # When we exit, restore the seed to its original state
+    if (exists('.Random.seed', where=globalenv())) {
+      currentSeed <- get('.Random.seed', pos=globalenv())
+      on.exit(assign('.Random.seed', currentSeed, pos=globalenv()))
+    }
+    else {
+      on.exit(rm('.Random.seed', pos=globalenv()))
+    }
+    
+    set.seed(seed)
+    
+    do.call(rngfunc, list(...))
+  }
+}
+
+`%OR%` <- function(x, y) {
+  ifelse(is.null(x) || is.na(x), y, x)
+}
+
+`%AND%` <- function(x, y) {
+  if (!is.null(x) && !is.na(x))
+    if (!is.null(y) && !is.na(y))
+      return(y)
+  return(NULL)
+}
+
+`%.%` <- function(x, y) {
+  paste(x, y, sep='')
+}
+
+knownContentTypes <- Map$new()
+knownContentTypes$mset(
+  html='text/html; charset=UTF-8',
+  htm='text/html; charset=UTF-8',
+  js='text/javascript',
+  css='text/css',
+  png='image/png',
+  jpg='image/jpeg',
+  jpeg='image/jpeg',
+  gif='image/gif',
+  svg='image/svg+xml',
+  txt='text/plain',
+  pdf='application/pdf',
+  ps='application/postscript',
+  xml='application/xml',
+  m3u='audio/x-mpegurl',
+  m4a='audio/mp4a-latm',
+  m4b='audio/mp4a-latm',
+  m4p='audio/mp4a-latm',
+  mp3='audio/mpeg',
+  wav='audio/x-wav',
+  m4u='video/vnd.mpegurl',
+  m4v='video/x-m4v',
+  mp4='video/mp4',
+  mpeg='video/mpeg',
+  mpg='video/mpeg',
+  avi='video/x-msvideo',
+  mov='video/quicktime',
+  ogg='application/ogg',
+  swf='application/x-shockwave-flash',
+  doc='application/msword',
+  xls='application/vnd.ms-excel',
+  ppt='application/vnd.ms-powerpoint',
+  xlsx='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  xltx='application/vnd.openxmlformats-officedocument.spreadsheetml.template',
+  potx='application/vnd.openxmlformats-officedocument.presentationml.template',
+  ppsx='application/vnd.openxmlformats-officedocument.presentationml.slideshow',
+  pptx='application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  sldx='application/vnd.openxmlformats-officedocument.presentationml.slide',
+  docx='application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  dotx='application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+  xlam='application/vnd.ms-excel.addin.macroEnabled.12',
+  xlsb='application/vnd.ms-excel.sheet.binary.macroEnabled.12')
+
+getContentType <- function(ext, defaultType='application/octet-stream') {
+  knownContentTypes$get(tolower(ext)) %OR% defaultType
+}
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@

 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/).
+
 ## Features

 * Build useful web applications with only a few lines of code&mdash;no JavaScript required.
@@ -20,7 +22,6 @@ Shiny is a new package from RStudio that makes it incredibly easy to build inter
 From an R console:

 ```r
-options(repos=c(RStudio="http://rstudio.org/_packages", getOption("repos")))
 install.packages("shiny")
 ```

--- a/inst/examples/10_download/server.R
+++ b/inst/examples/10_download/server.R
@@ -0,0 +1,19 @@
+shinyServer(function(input, output) {
+  datasetInput <- reactive(function() {
+    switch(input$dataset,
+           "rock" = rock,
+           "pressure" = pressure,
+           "cars" = cars)
+  })
+  
+  output$table <- reactiveTable(function() {
+    datasetInput()
+  })
+  
+  output$downloadData <- downloadHandler(
+    filename = function() { paste(input$dataset, '.csv', sep='') },
+    content = function(file) {
+      write.csv(datasetInput(), file)
+    }
+  )
+})
--- a/inst/examples/10_download/ui.R
+++ b/inst/examples/10_download/ui.R
@@ -0,0 +1,11 @@
+shinyUI(pageWithSidebar(
+  headerPanel('Downloading Data'),
+  sidebarPanel(
+    selectInput("dataset", "Choose a dataset:", 
+                choices = c("rock", "pressure", "cars")),
+    downloadButton('downloadData', 'Download')
+  ),
+  mainPanel(
+    tableOutput('table')
+  )
+))
--- a/inst/tests/test-bootstrap.r
+++ b/inst/tests/test-bootstrap.r
@@ -0,0 +1,17 @@
+context("bootstrap")
+
+test_that("CSS unit validation", {
+  # On error, return NA; on success, return result
+  validateCssUnit_wrap <- function(x) {
+    tryCatch(validateCssUnit(x), error = function(e) { NA_character_ })
+  }
+
+  # Test strings and expected results
+  strings  <- c("100x", "10px", "10.4px", ".4px", "1px0", "px", "5", "%", "5%", "auto", "1auto", "") 
+  expected <- c(NA,     "10px", "10.4px", ".4px", NA,     NA,   NA,  NA,  "5%", "auto", NA,      NA)
+  results <- vapply(strings, validateCssUnit_wrap, character(1), USE.NAMES = FALSE)
+  expect_equal(results, expected)
+
+  # Numbers should return string with "px"
+  expect_equal(validateCssUnit(100), "100px")
+})
--- a/inst/tests/test-reactivity.r
+++ b/inst/tests/test-reactivity.r
@@ -0,0 +1,467 @@
+context("reactivity")
+
+
+# Test for correct behavior of ReactiveValues
+test_that("ReactiveValues", {
+  # Creation and indexing into ReactiveValues -------------------------------
+  values <- reactiveValues()
+
+  # $ indexing
+  values$a <- 3
+  expect_equal(isolate(values$a), 3)
+
+  # [[ indexing
+  values[['a']] <- 4
+  expect_equal(isolate(values[['a']]), 4)
+
+  # Create with initialized values
+  values <- reactiveValues(a=1, b=2)
+  expect_equal(isolate(values$a), 1)
+  expect_equal(isolate(values[['b']]), 2)
+
+  # NULL values -------------------------------------------------------------
+  # Initializing with NULL value
+  values <- reactiveValues(a=NULL, b=2)
+  # a should exist and be NULL
+  expect_equal(isolate(names(values)), c("a", "b"))
+  expect_true(is.null(isolate(values$a)))
+
+  # Assigning NULL should keep object (not delete it), and set value to NULL
+  values$b <- NULL
+  expect_equal(isolate(names(values)), c("a", "b"))
+  expect_true(is.null(isolate(values$b)))
+
+
+  # Errors -----------------------------------------------------------------
+  # Error: indexing with non-string
+  expect_error(isolate(values[[1]]))
+  expect_error(isolate(values[[NULL]]))
+  expect_error(isolate(values[[list('a')]]))
+
+  # Error: [ indexing shouldn't work
+  expect_error(isolate(values['a']))
+  expect_error(isolate(values['a'] <- 1))
+
+  # Error: unnamed arguments
+  expect_error(reactiveValues(1))
+  expect_error(reactiveValues(1, b=2))
+
+  # Error: assignment to readonly values
+  values <- .createReactiveValues(ReactiveValues$new(), readonly = TRUE)
+  expect_error(values$a <- 1)
+})
+
+
+# Test for overreactivity. funcB has an indirect dependency on valueA (via
+# funcA) and also a direct dependency on valueA. When valueA changes, funcB
+# should only execute once.
+test_that("Functions are not over-reactive", {
+
+  values <- reactiveValues(A=10)
+
+  funcA <- reactive(function() {
+    values$A
+  })
+
+  funcB <- reactive(function() {
+    funcA()
+    values$A
+  })
+
+  obsC <- observe(function() {
+    funcB()
+  })
+
+  flushReact()
+  expect_equal(execCount(funcB), 1)
+  expect_equal(execCount(obsC), 1)
+
+  values$A <- 11
+  flushReact()
+  expect_equal(execCount(funcB), 2)
+  expect_equal(execCount(obsC), 2)
+})
+
+## "foo => bar" is defined as "foo is a dependency of bar"
+##
+## vA => fB
+## (fB, vA) => obsE
+## (fB, vA) => obsF
+##
+## obsE and obsF should each execute once when vA changes.
+test_that("overreactivity2", {
+  # ----------------------------------------------
+  # Test 1
+  # B depends on A, and observer depends on A and B. The observer uses A and
+  # B, in that order.
+
+  # This is to store the value from observe()
+  observed_value1 <- NA
+  observed_value2 <- NA
+
+  values <- reactiveValues(A=1)
+  funcB  <- reactive(function() {
+    values$A + 5
+  })
+  obsC <- observe(function() {
+    observed_value1 <<-  funcB() * values$A
+  })
+  obsD <- observe(function() {
+    observed_value2 <<-  funcB() * values$A
+  })
+
+  flushReact()
+  expect_equal(observed_value1, 6)   # Should be 1 * (1 + 5) = 6
+  expect_equal(observed_value2, 6)   # Should be 1 * (1 + 5) = 6
+  expect_equal(execCount(funcB), 1)
+  expect_equal(execCount(obsC), 1)
+  expect_equal(execCount(obsD), 1)
+
+  values$A <- 2
+  flushReact()
+  expect_equal(observed_value1, 14)  # Should be 2 * (2 + 5) = 14
+  expect_equal(observed_value2, 14)  # Should be 2 * (2 + 5) = 14
+  expect_equal(execCount(funcB), 2)
+  expect_equal(execCount(obsC), 2)
+  expect_equal(execCount(obsD), 2)
+})
+
+## Test for isolation. funcB depends on funcA depends on valueA. When funcA
+## is invalidated, if its new result is not different than its old result,
+## then it doesn't invalidate its dependents. This is done by adding an observer
+## (valueB) between obsA and funcC.
+##
+## valueA => obsB => valueC => funcD => obsE
+test_that("isolation", {
+  values <- reactiveValues(A=10, C=NULL)
+
+  obsB <- observe(function() {
+    values$C <- values$A > 0
+  })
+
+  funcD <- reactive(function() {
+    values$C
+  })
+
+  obsE <- observe(function() {
+    funcD()
+  })
+
+  flushReact()
+  countD <- execCount(funcD)
+
+  values$A <- 11
+  flushReact()
+  expect_equal(execCount(funcD), countD)
+})
+
+
+## Test for laziness. With lazy evaluation, the observers should "pull" values
+## from their dependent functions. In contrast, eager evaluation would have
+## reactive values and functions "push" their changes down to their descendents.
+test_that("laziness", {
+
+  values <- reactiveValues(A=10)
+
+  funcA <- reactive(function() {
+    values$A > 0
+  })
+
+  funcB <- reactive(function() {
+    funcA()
+  })
+
+  obsC <- observe(function() {
+    if (values$A > 10)
+      return()
+    funcB()
+  })
+
+  flushReact()
+  expect_equal(execCount(funcA), 1)
+  expect_equal(execCount(funcB), 1)
+  expect_equal(execCount(obsC), 1)
+
+  values$A <- 11
+  flushReact()
+  expect_equal(execCount(funcA), 1)
+  expect_equal(execCount(funcB), 1)
+  expect_equal(execCount(obsC), 2)
+})
+
+
+## Suppose B depends on A and C depends on A and B. Then when A is changed,
+## the evaluation order should be A, B, C. Also, each time A is changed, B and
+## C should be run once, if we want to be maximally efficient.
+test_that("order of evaluation", {
+  # ----------------------------------------------
+  # Test 1
+  # B depends on A, and observer depends on A and B. The observer uses A and
+  # B, in that order.
+
+  # This is to store the value from observe()
+  observed_value <- NA
+
+  values <- reactiveValues(A=1)
+  funcB  <- reactive(function() {
+    values$A + 5
+  })
+  obsC <- observe(function() {
+    observed_value <<- values$A * funcB()
+  })
+
+  flushReact()
+  expect_equal(observed_value, 6)   # Should be 1 * (1 + 5) = 6
+  expect_equal(execCount(funcB), 1)
+  expect_equal(execCount(obsC), 1)
+
+  values$A <- 2
+  flushReact()
+  expect_equal(observed_value, 14)  # Should be 2 * (2 + 5) = 14
+  expect_equal(execCount(funcB), 2)
+  expect_equal(execCount(obsC), 2)
+
+
+  # ----------------------------------------------
+  # Test 2:
+  # Same as Test 1, except the observer uses A and B in reversed order.
+  # Resulting values should be the same.
+
+  observed_value <- NA
+
+  values <- reactiveValues(A=1)
+  funcB <- reactive(function() {
+    values$A + 5
+  })
+  obsC <- observe(function() {
+    observed_value <<- funcB() * values$A
+  })
+
+  flushReact()
+  # Should be 1 * (1 + 5) = 6
+  expect_equal(observed_value, 6)
+  expect_equal(execCount(funcB), 1)
+  expect_equal(execCount(obsC), 1)
+
+  values$A <- 2
+  flushReact()
+  # Should be 2 * (2 + 5) = 14
+  expect_equal(observed_value, 14)
+  expect_equal(execCount(funcB), 2)
+  expect_equal(execCount(obsC), 2)
+})
+
+
+## Expressions in isolate() should not invalidate the parent context.
+test_that("isolate() blocks invalidations from propagating", {
+
+  obsC_value <- NA
+  obsD_value <- NA
+
+  values <- reactiveValues(A=1, B=10)
+  funcB <- reactive(function() {
+    values$B + 100
+  })
+
+  # References to valueB and funcB are isolated
+  obsC <- observe(function() {
+    obsC_value <<-
+      values$A + isolate(values$B) + isolate(funcB())
+  })
+
+  # In contrast with obsC, this has a non-isolated reference to funcB
+  obsD <- observe(function() {
+    obsD_value <<-
+      values$A + isolate(values$B) + funcB()
+  })
+
+
+  flushReact()
+  expect_equal(obsC_value, 121)
+  expect_equal(execCount(obsC), 1)
+  expect_equal(obsD_value, 121)
+  expect_equal(execCount(obsD), 1)
+
+  # Changing A should invalidate obsC and obsD
+  values$A <- 2
+  flushReact()
+  expect_equal(obsC_value, 122)
+  expect_equal(execCount(obsC), 2)
+  expect_equal(obsD_value, 122)
+  expect_equal(execCount(obsD), 2)
+
+  # Changing B shouldn't invalidate obsC becuause references to B are in isolate()
+  # But it should invalidate obsD.
+  values$B <- 20
+  flushReact()
+  expect_equal(obsC_value, 122)
+  expect_equal(execCount(obsC), 2)
+  expect_equal(obsD_value, 142)
+  expect_equal(execCount(obsD), 3)
+
+  # Changing A should invalidate obsC and obsD, and they should see updated
+  # values for valueA, valueB, and funcB
+  values$A <- 3
+  flushReact()
+  expect_equal(obsC_value, 143)
+  expect_equal(execCount(obsC), 3)
+  expect_equal(obsD_value, 143)
+  expect_equal(execCount(obsD), 4)
+})
+
+test_that("Circular refs/reentrancy in reactive functions work", {
+
+  values <- reactiveValues(A=3)
+
+  funcB <- reactive(function() {
+    # Each time fB executes, it reads and then writes valueA,
+    # effectively invalidating itself--until valueA becomes 0.
+    if (values$A == 0)
+      return()
+    values$A <- values$A - 1
+    return(values$A)
+  })
+
+  obsC <- observe(function() {
+    funcB()
+  })
+
+  flushReact()
+  expect_equal(execCount(obsC), 4)
+
+  values$A <- 3
+
+  flushReact()
+  expect_equal(execCount(obsC), 8)
+
+})
+
+test_that("Simple recursion", {
+
+  values <- reactiveValues(A=5)
+  funcB <- reactive(function() {
+    if (values$A == 0)
+      return(0)
+    values$A <- values$A - 1
+    funcB()
+  })
+
+  obsC <- observe(function() {
+    funcB()
+  })
+
+  flushReact()
+  expect_equal(execCount(obsC), 2)
+  expect_equal(execCount(funcB), 6)
+})
+
+test_that("Non-reactive recursion", {
+  nonreactiveA <- 3
+  outputD <- NULL
+
+  funcB <- reactive(function() {
+    if (nonreactiveA == 0)
+      return(0)
+    nonreactiveA <<- nonreactiveA - 1
+    return(funcB())
+  })
+  obsC <- observe(function() {
+    outputD <<- funcB()
+  })
+
+  flushReact()
+  expect_equal(execCount(funcB), 4)
+  expect_equal(outputD, 0)
+})
+
+test_that("Circular dep with observer only", {
+
+  values <- reactiveValues(A=3)
+  obsB <- observe(function() {
+    if (values$A == 0)
+      return()
+    values$A <- values$A - 1
+  })
+
+  flushReact()
+  expect_equal(execCount(obsB), 4)
+})
+
+test_that("Writing then reading value is not circular", {
+
+  values <- reactiveValues(A=3)
+  funcB <- reactive(function() {
+    values$A <- isolate(values$A) - 1
+    values$A
+  })
+
+  obsC <- observe(function() {
+    funcB()
+  })
+
+  flushReact()
+  expect_equal(execCount(obsC), 1)
+
+  values$A <- 10
+
+  flushReact()
+  expect_equal(execCount(obsC), 2)
+})
+
+test_that("names() and reactiveValuesToList()", {
+
+  values <- reactiveValues(A=1, .B=2)
+
+  # Dependent on names
+  depNames <- observe(function() {
+    names(values)
+  })
+
+  # Dependent on all non-hidden objects
+  depValues <- observe(function() {
+    reactiveValuesToList(values)
+  })
+
+  # Dependent on all objects, including hidden
+  depAllValues <- observe(function() {
+    reactiveValuesToList(values, all.names = TRUE)
+  })
+
+  # names() returns all names
+  expect_equal(sort(isolate(names(values))), sort(c(".B", "A")))
+  # Assigning names fails
+  expect_error(isolate(names(v) <- c('x', 'y')))
+
+  expect_equal(isolate(reactiveValuesToList(values)), list(A=1))
+  expect_equal(isolate(reactiveValuesToList(values, all.names=TRUE)), list(A=1, .B=2))
+
+
+  flushReact()
+  expect_equal(execCount(depNames), 1)
+  expect_equal(execCount(depValues), 1)
+  expect_equal(execCount(depAllValues), 1)
+
+  values$A <- 2
+  flushReact()
+  expect_equal(execCount(depNames), 1)
+  expect_equal(execCount(depValues), 2)
+  expect_equal(execCount(depAllValues), 2)
+
+  values$.B <- 3
+  flushReact()
+  expect_equal(execCount(depNames), 1)
+  expect_equal(execCount(depValues), 2)
+  expect_equal(execCount(depAllValues), 3)
+
+  values$C <- 1
+  flushReact()
+  expect_equal(execCount(depNames), 2)
+  expect_equal(execCount(depValues), 3)
+  expect_equal(execCount(depAllValues), 4)
+
+  values$.D <- 1
+  flushReact()
+  expect_equal(execCount(depNames), 3)
+  expect_equal(execCount(depValues), 3)
+  expect_equal(execCount(depAllValues), 5)
+})
--- a/inst/tests/test-tags.r
+++ b/inst/tests/test-tags.r
@@ -0,0 +1,23 @@
+context("tags")
+
+test_that("Basic tag writing works", {
+  expect_equal(as.character(tagList("hi")), HTML("hi"))
+  expect_equal(
+    as.character(tagList("one", "two", tagList("three"))),
+    HTML("one\ntwo\nthree"))
+  expect_equal(
+    as.character(tags$b("one")),
+    HTML("<b>one</b>"))
+  expect_equal(
+    as.character(tags$b("one", "two")),
+    HTML("<b>\n  one\n  two\n</b>"))
+  expect_equal(
+    as.character(tagList(list("one"))),
+    HTML("one"))
+  expect_equal(
+    as.character(tagList(list(tagList("one")))),
+    HTML("one"))
+  expect_equal(
+    as.character(tagList(tags$br(), "one")),
+    HTML("<br/>\none"))
+})
--- a/inst/tests/test-text.R
+++ b/inst/tests/test-text.R
@@ -0,0 +1,29 @@
+context("text")
+
+test_that("reactivePrint and reactiveText behavior is correct", {
+  expect_equal(isolate(reactivePrint(function() "foo")()),
+               '[1] "foo"')
+  expect_equal(isolate(reactivePrint(function() invisible("foo"))()),
+               '')
+  expect_equal(isolate(reactivePrint(function() { print("foo"); "bar"})()),
+               '[1] "foo"\n[1] "bar"')
+  expect_equal(isolate(reactivePrint(function() NULL)()),
+               'NULL')
+  expect_equal(isolate(reactivePrint(function() invisible())()),
+               '')
+  expect_equal(isolate(reactivePrint(function() 1:5)()),
+               '[1] 1 2 3 4 5')
+  
+  expect_equal(isolate(reactiveText(function() "foo")()),
+               'foo')
+  expect_equal(isolate(reactiveText(function() invisible("foo"))()),
+               'foo')
+  expect_equal(isolate(reactiveText(function() { print("foo"); "bar"})()),
+               'bar')
+  expect_equal(isolate(reactiveText(function() NULL)()),
+               '')
+  expect_equal(isolate(reactiveText(function() invisible())()),
+               '')
+  expect_equal(isolate(reactiveText(function() 1:5)()),
+               '1 2 3 4 5')  
+})
--- a/inst/www/shared/shiny.js
+++ b/inst/www/shared/shiny.js
@@ -4,6 +4,10 @@

  var exports = window.Shiny = window.Shiny || {};

+  $(document).on('submit', 'form:not([action])', function(e) {
+    e.preventDefault();
+  });
+
  function randomId() {
    return Math.floor(0x100000000 + (Math.random() * 0xF00000000)).toString(16);
  }
@@ -350,12 +354,12 @@
    }

    // Don't mutate list argument
-    list = slice(list, 0);
+    list = list.slice(0);

    for (var chunkSize = 1; chunkSize < list.length; chunkSize *= 2) {
      for (var i = 0; i < list.length; i += chunkSize * 2) {
-        var listA = slice(list, i, i + chunkSize);
-        var listB = slice(list, i + chunkSize, i + chunkSize * 2);
+        var listA = list.slice(i, i + chunkSize);
+        var listB = list.slice(i + chunkSize, i + chunkSize * 2);
        var merged = merge(sortfunc, listA, listB);
        var args = [i, merged.length];
        Array.prototype.push.apply(args, merged);
@@ -394,6 +398,11 @@
      if (this.$socket)
        throw "Connect was already called on this application object";

+      $.extend(initialInput, {
+        // IE8 and IE9 have some limitations with data URIs
+        "__allowDataUriScheme": typeof WebSocket !== 'undefined'
+      });
+
      this.$socket = this.createSocket();
      this.$initialInput = initialInput;
      $.extend(this.$inputValues, initialInput);
@@ -563,6 +572,7 @@
        exports.oncustommessage(msgObj.custom);
      }
      if (msgObj.values) {
+        $(document.documentElement).removeClass('shiny-busy');
        for (name in this.$bindings)
          this.$bindings[name].showProgress(false);
      }
@@ -578,6 +588,7 @@
        }
      }
      if (msgObj.progress) {
+        $(document.documentElement).addClass('shiny-busy');
        for (var i = 0; i < msgObj.progress.length; i++) {
          var key = msgObj.progress[i];
          var binding = this.$bindings[key];
@@ -905,6 +916,17 @@
    }
  });
  outputBindings.register(htmlOutputBinding, 'shiny.htmlOutput');
+  
+  var downloadLinkOutputBinding = new OutputBinding();
+  $.extend(downloadLinkOutputBinding, {
+    find: function(scope) {
+      return $(scope).find('a.shiny-download-link');
+    },
+    renderValue: function(el, data) {
+      $(el).attr('href', data);
+    }
+  })
+  outputBindings.register(downloadLinkOutputBinding, 'shiny.downloadLink');


  var InputBinding = exports.InputBinding = function() {
--- a/man/downloadButton.Rd
+++ b/man/downloadButton.Rd
@@ -0,0 +1,46 @@
+\name{downloadButton}
+\alias{downloadButton}
+\alias{downloadLink}
+\title{Create a download button or link}
+\usage{
+  downloadButton(outputId, label = "Download",
+    class = NULL)
+
+  downloadLink(outputId, label = "Download", class = NULL)
+}
+\arguments{
+  \item{outputId}{The name of the output slot that the
+  \code{downloadHandler} is assigned to.}
+
+  \item{label}{The label that should appear on the button.}
+
+  \item{class}{Additional CSS classes to apply to the tag,
+  if any.}
+}
+\description{
+  Use these functions to create a download button or link;
+  when clicked, it will initiate a browser download. The
+  filename and contents are specified by the corresponding
+  \code{\link{downloadHandler}} defined in the server
+  function.
+}
+\examples{
+\dontrun{
+# In server.R:
+output$downloadData <- downloadHandler(
+  filename = function() {
+    paste('data-', Sys.Date(), '.csv', sep='')
+  },
+  content = function(con) {
+    write.csv(data, con)
+  }
+)
+
+# In ui.R:
+downloadLink('downloadData', 'Download')
+}
+}
+\seealso{
+  downloadHandler
+}
+
--- a/man/downloadHandler.Rd
+++ b/man/downloadHandler.Rd
@@ -0,0 +1,55 @@
+\name{downloadHandler}
+\alias{downloadHandler}
+\title{File Downloads}
+\usage{
+  downloadHandler(filename, content, contentType = NA)
+}
+\arguments{
+  \item{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.)}
+
+  \item{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.)}
+
+  \item{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.}
+}
+\description{
+  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 \code{\link{downloadButton}}
+  or \code{\link{downloadLink}} to make the download
+  available.
+}
+\examples{
+\dontrun{
+# In server.R:
+output$downloadData <- downloadHandler(
+  filename = function() {
+    paste('data-', Sys.Date(), '.csv', sep='')
+  },
+  content = function(file) {
+    write.csv(data, file)
+  }
+)
+
+# In ui.R:
+downloadLink('downloadData', 'Download')
+}
+}
+
--- a/man/headerPanel.Rd
+++ b/man/headerPanel.Rd
@@ -2,10 +2,14 @@
 \alias{headerPanel}
 \title{Create a header panel}
 \usage{
-  headerPanel(title)
+  headerPanel(title, windowTitle = title)
 }
 \arguments{
  \item{title}{An application title to display}
+
+  \item{windowTitle}{The title that should be displayed by
+  the browser window.  Useful if \code{title} is not a
+  string.}
 }
 \value{
  A headerPanel that can be passed to
--- a/man/isolate.Rd
+++ b/man/isolate.Rd
@@ -0,0 +1,50 @@
+\name{isolate}
+\alias{isolate}
+\title{Create a non-reactive scope for an expression}
+\usage{
+  isolate(expr)
+}
+\arguments{
+  \item{expr}{An expression that can access reactive values
+  or functions.}
+}
+\description{
+  Executes the given expression in a scope where reactive
+  values or functions can be read, but they cannot cause
+  the reactive scope of the caller to be re-evaluated when
+  they change.
+}
+\details{
+  Ordinarily, the simple act of reading a reactive value
+  causes a relationship to be established between the
+  caller and the reactive value, where a change to the
+  reactive value will cause the caller to re-execute. (The
+  same applies for the act of getting a reactive function's
+  value.) The \code{isolate} function lets you read a
+  reactive value or function without establishing this
+  relationship.
+}
+\examples{
+\dontrun{
+observer(function() {
+  input$saveButton  # Do take a dependency on input$saveButton
+
+  # isolate a simple expression
+  data <- get(isolate(input$dataset))  # No dependency on input$dataset
+  writeToDatabase(data)
+})
+
+observer(function() {
+  input$saveButton  # Do take a dependency on input$saveButton
+
+  # isolate a whole block
+  data <- isolate({
+    a <- input$valueA   # No dependency on input$valueA or input$valueB
+    b <- input$valueB
+    c(a=a, b=b)
+  })
+  writeToDatabase(data)
+})
+}
+}
+
--- a/man/plotOutput.Rd
+++ b/man/plotOutput.Rd
@@ -7,7 +7,10 @@
 \arguments{
  \item{outputId}{output variable to read the plot from}

-  \item{width}{Plot width}
+  \item{width}{Plot width. Must be a valid CSS unit (like
+  \code{"100\%"}, \code{"400px"}, \code{"auto"}) or a
+  number, which will be coerced to a string and have
+  \code{"px"} appended.}

  \item{height}{Plot height}
 }
--- a/man/reactivePlot.Rd
+++ b/man/reactivePlot.Rd
@@ -9,11 +9,17 @@

  \item{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.}
+  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.}

  \item{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.}
+  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.}

  \item{...}{Arguments to be passed through to
  \code{\link[grDevices]{png}}.  These can be used to set
@@ -27,5 +33,13 @@
  The corresponding HTML output tag should be \code{div} or
  \code{img} and have the CSS class name
  \code{shiny-plot-output}.
+
+  For output, it will try to use the following devices, in
+  this order: quartz (via \code{\link[grDevices]{png}}),
+  then \code{\link[Cairo]{CairoPNG}}, and finally
+  \code{\link[grDevices]{png}}. This is in order of quality
+  of output. Notably, plain \code{png} output on Linux and
+  Windows may not antialias some point shapes, resulting in
+  poor quality output.
 }

--- a/man/reactivePrint.Rd
+++ b/man/reactivePrint.Rd
@@ -5,14 +5,15 @@
  reactivePrint(func)
 }
 \arguments{
-  \item{func}{A function that returns a printable R
-  object.}
+  \item{func}{A function that may print output and/or
+  return a printable R object.}
 }
 \description{
-  Makes a reactive version of the given function that also
-  turns its printable result into a string. The reactive
-  function is suitable for assigning to an \code{output}
-  slot.
+  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.
 }
 \details{
  The corresponding HTML output tag can be anything (though
@@ -22,5 +23,79 @@

  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. To display
+  nothing, make your function return
+  \code{\link{invisible}()}.
+}
+\examples{
+isolate({
+
+# reactivePrint captures any print output, converts it to a string, and
+# returns it
+visFun <- reactivePrint(function() "foo")
+visFun()
+# '[1] "foo"'
+
+invisFun <- reactivePrint(function() invisible("foo"))
+invisFun()
+# ''
+
+multiprintFun <- reactivePrint(function() {
+  print("foo");
+  "bar"
+})
+multiprintFun()
+# '[1] "foo"\\n[1] "bar"'
+
+nullFun <- reactivePrint(function() NULL)
+nullFun()
+# 'NULL'
+
+invisNullFun <- reactivePrint(function() invisible(NULL))
+invisNullFun()
+# ''
+
+vecFun <- reactivePrint(function() 1:5)
+vecFun()
+# '[1] 1 2 3 4 5'
+
+
+# Contrast with reactiveText, which takes the value returned from the function
+# and uses cat() to convert it to a string
+visFun <- reactiveText(function() "foo")
+visFun()
+# 'foo'
+
+invisFun <- reactiveText(function() invisible("foo"))
+invisFun()
+# 'foo'
+
+multiprintFun <- reactiveText(function() {
+  print("foo");
+  "bar"
+})
+multiprintFun()
+# 'bar'
+
+nullFun <- reactiveText(function() NULL)
+nullFun()
+# ''
+
+invisNullFun <- reactiveText(function() invisible(NULL))
+invisNullFun()
+# ''
+
+vecFun <- reactiveText(function() 1:5)
+vecFun()
+# '1 2 3 4 5'
+
+})
+}
+\seealso{
+  \code{\link{reactiveText}} for displaying the value
+  returned from a function, instead of the printed output.
 }

--- a/man/reactiveTable.Rd
+++ b/man/reactiveTable.Rd
@@ -9,7 +9,8 @@
  be used with \code{\link[xtable]{xtable}}.}

  \item{...}{Arguments to be passed through to
-  \code{\link[xtable]{xtable}}.}
+  \code{\link[xtable]{xtable}} and
+  \code{\link[xtable]{print.xtable}}.}
 }
 \description{
  Creates a reactive table that is suitable for assigning
--- a/man/reactiveText.Rd
+++ b/man/reactiveText.Rd
@@ -23,4 +23,73 @@
  \code{cat}, inside a \code{\link[utils]{capture.output}}
  call.
 }
+\examples{
+isolate({
+
+# reactivePrint captures any print output, converts it to a string, and
+# returns it
+visFun <- reactivePrint(function() "foo")
+visFun()
+# '[1] "foo"'
+
+invisFun <- reactivePrint(function() invisible("foo"))
+invisFun()
+# ''
+
+multiprintFun <- reactivePrint(function() {
+  print("foo");
+  "bar"
+})
+multiprintFun()
+# '[1] "foo"\\n[1] "bar"'
+
+nullFun <- reactivePrint(function() NULL)
+nullFun()
+# 'NULL'
+
+invisNullFun <- reactivePrint(function() invisible(NULL))
+invisNullFun()
+# ''
+
+vecFun <- reactivePrint(function() 1:5)
+vecFun()
+# '[1] 1 2 3 4 5'
+
+
+# Contrast with reactiveText, which takes the value returned from the function
+# and uses cat() to convert it to a string
+visFun <- reactiveText(function() "foo")
+visFun()
+# 'foo'
+
+invisFun <- reactiveText(function() invisible("foo"))
+invisFun()
+# 'foo'
+
+multiprintFun <- reactiveText(function() {
+  print("foo");
+  "bar"
+})
+multiprintFun()
+# 'bar'
+
+nullFun <- reactiveText(function() NULL)
+nullFun()
+# ''
+
+invisNullFun <- reactiveText(function() invisible(NULL))
+invisNullFun()
+# ''
+
+vecFun <- reactiveText(function() 1:5)
+vecFun()
+# '1 2 3 4 5'
+
+})
+}
+\seealso{
+  \code{\link{reactivePrint}} for capturing the print
+  output of a function, rather than the returned text
+  value.
+}

--- a/man/reactiveValues.Rd
+++ b/man/reactiveValues.Rd
@@ -0,0 +1,47 @@
+\name{reactiveValues}
+\alias{reactiveValues}
+\title{Create an object for storing reactive values}
+\usage{
+  reactiveValues(...)
+}
+\arguments{
+  \item{...}{Objects that will be added to the
+  reactivevalues object. All of these objects must be
+  named.}
+}
+\description{
+  This function returns an object for storing reactive
+  values. It is similar to a list, but with special
+  capabilities for reactive programming. When you read a
+  value from it, the calling reactive function takes a
+  reactive dependency on that value, and when you write to
+  it, it notifies any reactive functions that depend on
+  that value.
+}
+\examples{
+# Create the object with no values
+values <- reactiveValues()
+
+# Assign values to 'a' and 'b'
+values$a <- 3
+values[['b']] <- 4
+
+\dontrun{
+# From within a reactive context, you can access values with:
+values$a
+values[['a']]
+}
+
+# If not in a reactive context (e.g., at the console), you can use isolate()
+# to retrieve the value:
+isolate(values$a)
+isolate(values[['a']])
+
+# Set values upon creation
+values <- reactiveValues(a = 1, b = 2)
+isolate(values$a)
+}
+\seealso{
+  \code{\link{isolate}}.
+}
+
--- a/man/reactiveValuesToList.Rd
+++ b/man/reactiveValuesToList.Rd
@@ -0,0 +1,33 @@
+\name{reactiveValuesToList}
+\alias{reactiveValuesToList}
+\title{Convert a reactivevalues object to a list}
+\usage{
+  reactiveValuesToList(x, all.names = FALSE)
+}
+\arguments{
+  \item{x}{A reactivevalues object.}
+
+  \item{all.names}{If \code{TRUE}, include objects with a
+  leading dot. If \code{FALSE} (the default) don't include
+  those objects.}
+}
+\description{
+  This function does something similar to what you might
+  \code{\link{as.list}} to do. The difference is that the
+  calling context will take dependencies on every object in
+  the reactivevalues object. To avoid taking dependencies
+  on all the objects, you can wrap the call with
+  \code{\link{isolate}()}.
+}
+\examples{
+values <- reactiveValues(a = 1)
+\dontrun{
+reactiveValuesToList(values)
+}
+
+# To get the objects without taking dependencies on them, use isolate().
+# isolate() can also be used when calling from outside a reactive context (e.g.
+# at the console)
+isolate(reactiveValuesToList(values))
+}
+
--- a/man/runGist.Rd
+++ b/man/runGist.Rd
@@ -23,4 +23,10 @@
  Download and launch a Shiny application that is hosted on
  GitHub as a gist.
 }
+\examples{
+\dontrun{
+runGist(4034323)
+runGist("https://gist.github.com/4034323")
+}
+}

--- a/man/runGitHub.Rd
+++ b/man/runGitHub.Rd
@@ -0,0 +1,41 @@
+\name{runGitHub}
+\alias{runGitHub}
+\title{Run a Shiny application from a GitHub repository}
+\usage{
+  runGitHub(repo, username = getOption("github.user"),
+    ref = "master", subdir = NULL, port = 8100,
+    launch.browser = getOption("shiny.launch.browser", interactive()))
+}
+\arguments{
+  \item{repo}{Name of the repository}
+
+  \item{username}{GitHub username}
+
+  \item{ref}{Desired git reference. Could be a commit, tag,
+  or branch name. Defaults to \code{"master"}.}
+
+  \item{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"}.}
+
+  \item{port}{The TCP port that the application should
+  listen on. Defaults to port 8100.}
+
+  \item{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.}
+}
+\description{
+  Download and launch a Shiny application that is hosted in
+  a GitHub repository.
+}
+\examples{
+\dontrun{
+runGitHub("shiny_example", "rstudio")
+
+# Can run an app from a subdirectory in the repo
+runGitHub("shiny_example", "rstudio", subdir = "inst/shinyapp/")
+}
+}
+
--- a/man/runUrl.Rd
+++ b/man/runUrl.Rd
@@ -0,0 +1,41 @@
+\name{runUrl}
+\alias{runUrl}
+\title{Run a Shiny application from a URL}
+\usage{
+  runUrl(url, filetype = NULL, subdir = NULL, port = 8100,
+    launch.browser = getOption("shiny.launch.browser", interactive()))
+}
+\arguments{
+  \item{url}{URL of the application.}
+
+  \item{filetype}{The file type (\code{".zip"},
+  \code{".tar"}, or \code{".tar.gz"}. Defaults to the file
+  extension taken from the url.}
+
+  \item{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"}.}
+
+  \item{port}{The TCP port that the application should
+  listen on. Defaults to port 8100.}
+
+  \item{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.}
+}
+\description{
+  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.
+}
+\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/")
+}
+}
+
--- a/res/text-example.R
+++ b/res/text-example.R
@@ -0,0 +1,62 @@
+isolate({
+
+# reactivePrint captures any print output, converts it to a string, and
+# returns it
+visFun <- reactivePrint(function() "foo")
+visFun()
+# '[1] "foo"'
+
+invisFun <- reactivePrint(function() invisible("foo"))
+invisFun()
+# ''
+
+multiprintFun <- reactivePrint(function() {
+  print("foo");
+  "bar"
+})
+multiprintFun()
+# '[1] "foo"\n[1] "bar"'
+
+nullFun <- reactivePrint(function() NULL)
+nullFun()
+# 'NULL'
+
+invisNullFun <- reactivePrint(function() invisible(NULL))
+invisNullFun()
+# ''
+
+vecFun <- reactivePrint(function() 1:5)
+vecFun()
+# '[1] 1 2 3 4 5'
+
+
+# Contrast with reactiveText, which takes the value returned from the function
+# and uses cat() to convert it to a string
+visFun <- reactiveText(function() "foo")
+visFun()
+# 'foo'
+
+invisFun <- reactiveText(function() invisible("foo"))
+invisFun()
+# 'foo'
+
+multiprintFun <- reactiveText(function() {
+  print("foo");
+  "bar"
+})
+multiprintFun()
+# 'bar'
+
+nullFun <- reactiveText(function() NULL)
+nullFun()
+# ''
+
+invisNullFun <- reactiveText(function() invisible(NULL))
+invisNullFun()
+# ''
+
+vecFun <- reactiveText(function() 1:5)
+vecFun()
+# '1 2 3 4 5'
+
+})
--- a/tests/test-all.R
+++ b/tests/test-all.R
@@ -0,0 +1,4 @@
+library(testthat)
+library(shiny)
+
+test_package("shiny")
Author	SHA1	Message	Date
Winston Chang	5af49c8a82	Bump version and update NEWS	2013-01-23 14:54:39 -06:00
Winston Chang	85aa98e8e2	Fixes for R CMD check	2013-01-23 14:30:11 -06:00
Joe Cheng	330d102f62	Fix test on Linux (sort locale)	2013-01-23 12:17:45 -08:00
Joe Cheng	32b33a7910	Add res dir to .Rbuildignore	2013-01-23 12:13:40 -08:00
Joe Cheng	17c6a0f28a	Merge branch 'reactivePrint-invisible' Conflicts: man/plotOutput.Rd	2013-01-23 12:09:53 -08:00
Joe Cheng	7341eed1cf	Merge pull request #80 from wch/run-github Add functions runGithub and runUrl	2013-01-23 12:06:46 -08:00
Joe Cheng	ff99fbfbc9	Fix #64 : Hitting Enter in textbox causes form submit	2013-01-23 11:54:06 -08:00
Winston Chang	9f67fdc771	Re-document	2013-01-23 13:44:18 -06:00
Winston Chang	521143a16b	Add subdir argument for runGitHub and runUrl	2013-01-23 13:44:17 -06:00
Winston Chang	2622a25b12	Add runGitHub and runUrl functions	2013-01-23 13:44:17 -06:00
Joe Cheng	a91e925221	Remove failure comment	2013-01-23 11:33:06 -08:00
Joe Cheng	6c3289d5a5	Documentation and examples for reactivePrint/reactiveText	2013-01-23 11:32:13 -08:00
Joe Cheng	988a91ac06	reactiveText shouldn't capture print output	2013-01-23 11:31:51 -08:00
Winston Chang	aa7c913e9a	Escape percent sign in documentation	2013-01-23 09:42:08 -06:00
Joe Cheng	56db9feaa4	reactivePrint should not display invisibles	2013-01-22 23:36:51 -08:00
Winston Chang	5ace0f13c9	Move validateCssUnit to separate function	2013-01-23 00:02:16 -06:00
Winston Chang	076e6c9479	Re-roxgenize	2013-01-22 23:25:36 -06:00
Winston Chang	8277b1192e	Update NEWS	2013-01-22 23:23:02 -06:00
Winston Chang	150b978b0e	Fix tests with reactiveValuesToList	2013-01-22 23:22:41 -06:00
Winston Chang	6c72096bfe	Better CSS unit validation	2013-01-22 19:18:18 -06:00
Winston Chang	87c18cea80	Merge pull request #79 from wch/better-deps Finer grained dependencies when converting reactiveValues to list	2013-01-22 17:15:38 -08:00
Winston Chang	e658734084	Rename reactivevalues_to_list to reactiveValuesToList	2013-01-22 19:14:30 -06:00
Winston Chang	ec4f350baa	reactivevalues_to_list: add all.names option	2013-01-22 14:53:14 -06:00
Winston Chang	095f583211	Deprecate as.list.reactivevalues and add reactivevalues_to_list	2013-01-22 14:51:43 -06:00
Winston Chang	3c864cf6d2	reactiveValues(): improved check for unnamed arguments	2013-01-22 13:59:31 -06:00
Joe Cheng	eb4b21ce9f	Fix #77 : tagWriteChildren error	2013-01-21 22:40:08 -08:00
Joe Cheng	ff5349fd90	Fix #65 : tagWrite doesn't expect strings except as direct children of tags	2013-01-21 16:31:09 -08:00
Winston Chang	1f34ffa85d	plotOutput: check that height has proper format	2013-01-18 19:16:50 -06:00
Winston Chang	e98cab1f7c	Fix test	2013-01-17 00:11:38 -06:00
Winston Chang	aabc9659a2	Update NEWS Some news items were under the wrong version heading. Those have also been fixed.	2013-01-16 23:00:07 -06:00
Winston Chang	8d8d308f7a	Rename 'dependencies' to 'dependents'	2013-01-16 22:42:03 -06:00
Winston Chang	3ebd4595c6	Add read-write wrapper class for ReactiveValues	2013-01-16 19:02:26 -06:00
Winston Chang	7e1168946f	Re-roxygenize	2013-01-16 16:08:12 -06:00
Joe Cheng	134689d8aa	Remove subsetting operators from Map and Values The correct operators would be [[/[[<- but since we don't use them I just removed them instead.	2013-01-16 13:48:50 -08:00
Winston Chang	56282f9cbb	Merge branch 'lazy'	2013-01-16 12:32:32 -06:00
Joe Cheng	b4713741b1	Two new recursion/circularity tests	2013-01-16 10:27:20 -08:00
Joe Cheng	e42fe3bd61	Fix problem with circular dependencies The first of the included tests did not pass without the changes to Observable. The problem occurred when a function read a reactive value and then wrote it. Any dependents on the function would not receive any invalidations, then or ever after. The first problem was that the dirty state was unilaterally set to FALSE after the function finished executing, which might not be accurate if the function's newly created was invalidated during its own execution. Instead we set dirty state to FALSE before executing. But to prevent reentrant calls from thinking the cached value can be used, we add a .running field that is also consulted during getValue. The second problem was that Observable$getValue didn't register the dependent until after updateValue. That is a problem if updateValue creates and invalidates a context before returning. So now we register the dependent before calling updateValue.	2013-01-15 17:37:26 -08:00
Winston Chang	4fd2dade60	reactiveTable: don't return blank if first element is NA. Fixes #71	2013-01-15 16:04:18 -06:00
Joe Cheng	e12b03504c	Fix bad calls to on.exit I didn't realize on.exit replaces previous calls to on.exit by default.	2013-01-15 12:07:27 -08:00
Winston Chang	153156c1fa	Add back onInvalidate to Observer class	2013-01-15 11:13:46 -06:00
Winston Chang	3ecc69da2b	Un-export execCount	2013-01-15 11:13:46 -06:00
Winston Chang	07ad29da41	Clarify isolation test	2013-01-15 11:13:46 -06:00
Winston Chang	7d0de0b26f	Remove onInvalidateHint The recent changes to onInvalidate make it do almost exactly the same thing.	2013-01-15 11:13:46 -06:00
Winston Chang	77fab9c78f	Remove all pendingInvalidate	2013-01-15 11:13:46 -06:00
Winston Chang	3a8f3272c7	Don't call observers until flushReact()	2013-01-15 11:13:46 -06:00
Joe Cheng	2d44cbac1b	Failing overreactivity test	2013-01-08 14:06:10 -06:00
Joe Cheng	893d72677b	Try LIFO pendingInvalidates?	2013-01-08 14:06:10 -06:00
Joe Cheng	979eca4066	Add execCount	2013-01-08 14:06:10 -06:00
Joe Cheng	258d13e746	Add ctx$.label to help with debugging Shows the code that the context "belongs" to.	2013-01-08 14:06:10 -06:00
Winston Chang	779531da5d	Use lazy evaluation of reactive functions	2013-01-08 14:06:10 -06:00
Winston Chang	31d71006d7	Add tests for isolate()	2013-01-08 14:06:10 -06:00
Winston Chang	64ca66c062	Add test for reactive evaluation order	2013-01-08 14:06:10 -06:00
Winston Chang	6e1a2b3427	reactive tests: count number of times observers are run	2013-01-08 14:06:10 -06:00
Winston Chang	f585235192	Add reactivity tests	2013-01-08 14:06:10 -06:00
Winston Chang	9355643554	Update NEWS	2013-01-08 14:03:23 -06:00
Winston Chang	ccc6055926	Fix reactivity for empty checkbox groups. Fixes #58	2013-01-08 13:57:10 -06:00
Joe Cheng	6639446bb8	Update README.md	2013-01-07 22:39:07 -08:00
Joe Cheng	e2925c585f	Add isolate function for accessing reactives non-reactively	2013-01-03 12:16:50 -08:00
Joe Cheng	6c76b0473c	Add implementation of reactive values	2013-01-02 16:00:21 -08:00
Joe Cheng	e1e19632a5	Update URL in DESCRIPTION	2012-12-21 14:46:52 -08:00
Winston Chang	3e5364d5c0	Bump version number to .99 for development	2012-12-18 11:17:12 -06:00
Winston Chang	6c98de4c8b	Update NEWS	2012-12-17 16:24:40 -06:00
Winston Chang	9613dde4d2	Increment version to 0.2.4	2012-12-17 15:30:08 -06:00
Winston Chang	d47df2e538	Re-roxygenize	2012-12-17 15:23:59 -06:00
Winston Chang	6fcacd5159	Use different method of accessing CairoPNG R CMD check didn't like Cairo::CairoPNG. With this method, check wants Cairo to be imported in NAMESPACE, but it shouldn't be - Cairo should be optional.	2012-12-17 15:23:08 -06:00
Winston Chang	11b39cb020	Change maintainer	2012-12-17 14:30:47 -06:00
Winston Chang	d81f132db6	Update NEWS	2012-12-17 13:40:50 -06:00
Winston Chang	095697e789	Use new URL for runGist. Fixes #57	2012-12-17 12:18:19 -06:00
Joe Cheng	62d98c3137	Revert "Run invalidated hints only once per context" This reverts commit `e80d5dc172`. The original commit could cause under-reporting of progress.	2012-12-14 16:41:12 -08:00
jeffreyhorner	e80d5dc172	Run invalidated hints only once per context	2012-12-13 16:02:47 -06:00
jeffreyhorner	421e29db2d	Suppress base64 output when tracing websocket messages	2012-12-13 16:00:58 -06:00
Joe Cheng	9e6e53583c	Merge pull request #49 from wch/png-cairo For png output, try quartz and CairoPNG before plain png	2012-12-05 09:56:11 -08:00
Joe Cheng	3f59a7d84e	Fix bug where reactiveUI doesn't accept plain lists	2012-12-05 09:54:31 -08:00
Winston Chang	21ffd788ab	For png output, try quartz and CairoPNG before plain png	2012-12-03 12:06:31 -06:00
Joe Cheng	8dadfea724	Separate request parameters from path; version 0.2.3	2012-11-30 09:31:09 -08:00
Joe Cheng	00ce52ecf7	Fix CRAN warning; version 0.2.2	2012-11-30 09:05:20 -08:00
Joe Cheng	50ac13d3fd	[BREAKING] Modify API of `downloadHandler` The `content` function now takes a file path, not writable connection, as an argument. This makes it much easier to work with APIs that only write to file paths, not connections.	2012-11-29 17:14:44 -08:00
Joe Cheng	58318fec46	Update package metadata for v0.2.0	2012-11-27 16:32:27 -08:00
Joe Cheng	a49941113e	Require Shiny at app startup Some of our examples omit library(shiny) from the top of ui.R and server.R, which worked fine before but not with the namespace fix from yesterday. Requiring shiny at startup fixes the problem.	2012-11-27 16:29:01 -08:00
Joe Cheng	595801cb99	Trivial style copy edits to example 10_download	2012-11-26 21:48:12 -08:00
Joe Cheng	0b469f09df	Fix subtle name resolution bugs See in particular: http://stackoverflow.com/questions/13575353/how-does-the-shiny-r-package-deal-with-data-frames Also reported at different times by Dirk Eddelbuettel and Jay Emerson. The observed behavior is that S3/S4 method dispatch does not always seem to work; the desired methods are not invoked despite appearing to be in the search path. The problem was that sourcing files with local=TRUE creates a new environment based on the parent frame, which in our case is Shiny's package environment. What we really want is to read from the global environment but write to a throwaway environment. The correct way to do that is to make a new environment with .GlobalEnv as the parent.	2012-11-26 21:45:28 -08:00
Joe Cheng	1e1f4e4a47	Update metadata for 0.1.14	2012-11-24 01:47:47 -08:00
Joe Cheng	c63e2ae7c8	Fix slider animation controls	2012-11-24 00:30:44 -08:00
Joe Cheng	d3d3fa990e	Update version metadata	2012-11-23 23:47:27 -08:00
Joe Cheng	21980b7e71	Clean up PNG file when no longer needed	2012-11-23 22:44:37 -08:00
Joe Cheng	844ca0d387	I am stupid.	2012-11-21 23:02:40 -08:00
Joe Cheng	972ae35300	Update metadata for 0.1.12	2012-11-21 22:44:19 -08:00
Joe Cheng	57bfb8eb96	Bring untar operations in-house Very simple tweak to R's untar2 code was all that was required to fix the built-in untar's problems with gists. Seemed best to just fork it and start using the forked version directly, regardless of what is installed on your machine.	2012-11-21 22:37:47 -08:00
Joe Cheng	ed6e6a9fb2	Squash another cygwin warning	2012-11-21 21:43:32 -08:00
Joe Cheng	ed402267b6	Fix runGist cygwin warning bug	2012-11-21 21:39:16 -08:00
Joe Cheng	6eec570828	Add CSS hooks for app-wide busy indicators	2012-11-21 00:04:16 -08:00
Joe Cheng	22fc1e3f0b	Add param docs	2012-11-20 18:08:59 -08:00
Joe Cheng	ae9bd868f1	Implement arbitrary file downloads	2012-11-20 17:42:34 -08:00
Joe Cheng	a887012aca	Update metadata for v0.1.11	2012-11-19 17:22:57 -08:00
Joe Cheng	bc73048ab9	Fix IE8 slice bug IE8 doesn't like slice(0, undefined)--rather than interpreting it as slice(0), it returns an array of length 0.	2012-11-19 17:19:51 -08:00
Joe Cheng	c89dd6c379	Fix issue #41 : reactiveTable should allow print options too	2012-11-19 15:26:34 -08:00
Joe Cheng	9662debe5e	Dynamic plot sizing	2012-11-19 15:26:02 -08:00
Joe Cheng	057262d917	Update metadata for v0.1.10	2012-11-19 13:11:07 -08:00
Joe Cheng	b6723a6219	Add per-session GET infrastructure. Allow IE8/9 to avoid data URIs.	2012-11-19 13:08:09 -08:00
Joe Cheng	068f3e0a43	Merge pull request #32 from edwindj/master small bug: checkboxInputGroup sets html attribute "selected" in stead of "checked"	2012-11-15 23:30:28 -08:00
Joe Cheng	95635a8c47	Issue #37 : headerPanel HTML argument shows up in title	2012-11-13 01:52:33 -08:00
Joe Cheng	3ec2071820	Address issue #35 : Allow modification of untar args	2012-11-13 00:09:27 -08:00
Joe Cheng	1696db3044	Fix issue #36 : reactiveUI does not always correctly render sliders There is a deeper problem here, that reactiveUI output that renders stuff to the <head> will generally not work. We're not in a position to fix that yet and this problem has been reported twice, so we'll just fix this instance by making the slider dependencies built into the framework.	2012-11-11 18:32:34 -08:00
Joe Cheng	e1a1eab2b3	More MIME types	2012-11-10 15:18:29 -08:00
Edwin de Jonge	f7865f3358	changed html attribute of checkboxInputGroup from "selected" into "checked"	2012-11-08 23:09:08 +01:00
Joe Cheng	6d5f8ed5f3	Pointer to Shiny homepage	2012-11-08 03:29:23 -08:00
Joe Cheng	96a737379f	Add linked example	2012-11-07 10:36:42 -08:00
Joe Cheng	d73feec013	Turns out GitHub doesn't like iframes	2012-11-07 10:28:47 -08:00
Joe Cheng	2ccead1da5	Add example to README	2012-11-07 10:28:06 -08:00