4 |
5 | [](https://github.com/Novartis/tidymodules/actions)
7 | [](https://www.tidyverse.org/lifecycle/#experimental)
8 |
9 | The `{tidymodules}` R package is built on top of shiny module using
10 | `{R6}` to provide a new object-oriented programming (OOP) approach for
11 | module development, new module interface using input/output ports and a
12 | set of tidy operators for handling cross-module communication.
13 |
14 | The main features of tidymodules and its comparison with conventional
15 | Shiny modules are presented in the table below.
16 |
17 |
22 |
23 | [](https://github.com/Novartis/tidymodules/actions)
24 | [](https://www.tidyverse.org/lifecycle/#experimental)
25 |
26 | The `{tidymodules}` R package is built on top of shiny module using `{R6}` to provide a new object-oriented programming (OOP) approach for module development, new module interface using input/output ports and a set of tidy operators for handling cross-module communication.
27 |
28 | The main features of tidymodules and its comparison with conventional Shiny modules are presented in the table below.
29 |
30 | | Features | | tidymodules | Conventional modules |
31 | |----|----------------------|---------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------|
32 | | [](articles/intro.html) | Programming style | - `{R6}` OOP * - Semantic reference | Functional | 33 | | [](articles/namespace.html) | Namespace management | - automatic/generated
- ID based lookup
- Grouping | - manual management
- must match between ui and server | 34 | | [](articles/communication.html) | Module communication | - new module input/output port structure
- module ports linked via tidy operators
- automatic network diagram | - parameter passing via module server()
- challenging to manage for complex app | 35 | | [](articles/inheritance.html) | Inheritance | - class inheritance
- port inheritance for nested modules | NA | 36 | | [](articles/session.html) | Session management | - flexible user session management
- Caching of modules coming soon | NA | 37 | 38 | \* OOP = Object Oriented Programming 39 | 40 | ## Installation 41 | 42 | You can install the most recent version of `{tidymodules}` from [GitHub](https://github.com/Novartis/tidymodules) with: 43 | 44 | ``` r 45 | library(devtools) 46 | install_github("Novartis/tidymodules") 47 | ``` 48 | 49 | ## Examples 50 | 51 | You can quickly launch an example after installing the R package by running the following. 52 | ``` r 53 | tidymodules::showExamples(4) 54 | ``` 55 | Some examples have been deployed on shinyapp.io, such as: 56 | 57 | - Example 1: [Simple addition ](https://tidymodules.shinyapps.io/1_simple_addition/) 58 | - Example 2: [Linked scatter ](https://tidymodules.shinyapps.io/2_linked_scatter/) 59 | - Example 2: [Nested module ](https://tidymodules.shinyapps.io/3_nested_modules/) 60 | - Example 4: [Module communication ](https://tidymodules.shinyapps.io/4_communication/) 61 | 62 | ## Learning More 63 | 64 | Please review the [Get Started](https://opensource.nibr.com/tidymodules/articles/tidymodules.html) page for a high level introduction to `{tidymodules}` and its usage in developing Shiny apps. 65 | 66 | If you are interested to develop modules using `{tidymodules}`, we recommend reading the vignettes under "Articles". 67 | 68 | ## Code of Conduct 69 | 70 | Please note that the `{tidymodules}` is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By contributing to this project, you agree to abide by its terms. 71 | 72 | ## Acknowledgment 73 | 74 | - The SCC team members @ NVS for their valuable feedbacks 75 | - 2019 Summer interns (Marzi, Stephen and Renan) for contributing to testing the framework and implementing the demo example 4 listed above. 76 | - Eric Nantz for accepting to introduce tidymodules in his [e-poster](https://rpodcast.shinyapps.io/highlights-shiny) @ rstudio::conf 2020 77 | 78 | ## Licence 79 | 80 | Copyright 2020 Novartis AG 81 | 82 | Licensed under the Apache License, Version 2.0 (the "License"); 83 | you may not use this file except in compliance with the License. 84 | You may obtain a copy of the License at 85 | 86 | http://www.apache.org/licenses/LICENSE-2.0 87 | 88 | Unless required by applicable law or agreed to in writing, software 89 | distributed under the License is distributed on an "AS IS" BASIS, 90 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 91 | See the License for the specific language governing permissions and 92 | limitations under the License. 93 | -------------------------------------------------------------------------------- /R/Store.R: -------------------------------------------------------------------------------- 1 | 2 | #' 3 | #' This TidyModule is used to explore the content of the ModStore. 4 | #' 5 | #' @description 6 | #' Store is a TidyModule that can be used in your application to list existing applications, sessions and display your session's modules and edges. 7 | #' 8 | #' @details 9 | #' Should be initialized and injected in your application. 10 | #' 11 | #' @export 12 | Store <- R6::R6Class( 13 | classname = "Store", 14 | inherit = TidyModule, 15 | public = list( 16 | #' @description 17 | #' Store's ui function. 18 | #' @return UI elements. 19 | ui = function() { 20 | tagList( 21 | tabsetPanel( 22 | id = "store_ID", 23 | type = "tabs", 24 | tabPanel( 25 | "Sessions", 26 | fluidRow( 27 | br(), 28 | DT::dataTableOutput(self$ns("sessions")) 29 | ) 30 | ), 31 | tabPanel( 32 | "Mods", 33 | fluidRow( 34 | br(), 35 | DT::dataTableOutput(self$ns("mods")) 36 | ) 37 | ), 38 | tabPanel( 39 | "Edges", 40 | fluidRow( 41 | br(), 42 | DT::dataTableOutput(self$ns("edges")) 43 | ) 44 | ), 45 | tabPanel( 46 | "Port Mapping", 47 | fluidRow( 48 | br(), 49 | visNetwork::visNetworkOutput(self$ns("portD"), width = "100%", height = "800px") 50 | ) 51 | ) 52 | ) 53 | ) 54 | }, 55 | #' @description 56 | #' Store's server function. 57 | #' @param input Shiny input. 58 | #' @param output Shiny output 59 | #' @param session Shiny session 60 | server = function(input, output, session) { 61 | # Mandatory 62 | super$server(input, output, session) 63 | 64 | self$react$session_df <- reactive({ 65 | s <- self$getStore() 66 | d <- data.frame(aid = NULL, path = NULL, sid = NULL, created = NULL, mod_cnt = NULL, edge_cnt = NULL) 67 | 68 | for (aid in names(s$getSessions())) { 69 | for (sid in names(s$getSessions()[[aid]])) { 70 | ses <- s$getSessions()[[aid]][[sid]] 71 | mcount <- length(ses$collection) 72 | ecount <- nrow(ses$edges) 73 | d <- rbind(d, data.frame( 74 | aid = aid, 75 | path = ses$path, 76 | sid = sid, 77 | created = ses$created, 78 | updated = ses$updated, 79 | mod_cnt = mcount, 80 | edge_cnt = ecount 81 | )) 82 | } 83 | } 84 | rownames(d) <- NULL 85 | 86 | d 87 | }) 88 | 89 | self$react$mods_df <- reactive({ 90 | s <- self$getStore() 91 | d <- do.call( 92 | rbind, 93 | lapply( 94 | s$getMods(self), 95 | function(l) { 96 | data.frame( 97 | namespace = l$module_ns, 98 | class = paste(class(l), collapse = " <- "), 99 | parent = ifelse(is.null(l$parent_ns), "", l$parent_ns), 100 | created = l$created, 101 | in_ports = l$countInputPort(), 102 | out_ports = l$countOutputPort() 103 | ) 104 | } 105 | ) 106 | ) 107 | 108 | rownames(d) <- seq_len(nrow(d)) 109 | 110 | d 111 | }) 112 | 113 | self$react$edges_df <- reactive({ 114 | s <- self$getStore() 115 | e <- s$getEdges(self) 116 | req(nrow(e) != 0) 117 | 118 | e 119 | }) 120 | 121 | output$sessions <- DT::renderDataTable({ 122 | self$react$session_df() 123 | }) 124 | 125 | output$edges <- DT::renderDataTable({ 126 | self$react$edges_df() 127 | }) 128 | 129 | output$mods <- DT::renderDataTable({ 130 | self$react$mods_df() 131 | }) 132 | 133 | output$portD <- visNetwork::renderVisNetwork({ 134 | edges <- self$react$edges_df() 135 | nodes <- self$react$mods_df() 136 | 137 | e <- edges %>% 138 | mutate( 139 | font.size = 5, 140 | label = paste0(fport, " ", mode, ifelse(is.na(comment), "", paste0("(", comment, ")")), " ", tport) 141 | ) %>% 142 | select(from, to, label, font.size) 143 | 144 | # # minimal example 145 | # nodes <- data.frame(id = 1:3) 146 | # edges <- data.frame(from = c(1,2), to = c(1,3)) 147 | 148 | nId <- c(as.vector(e$from), as.vector(e$to), as.vector(nodes$namespace)) %>% unique() 149 | nType <- rbind( 150 | data.frame(name = edges$from, class = edges$fclass), 151 | data.frame(name = edges$to, class = edges$tclass) 152 | ) %>% unique() 153 | nClass <- as.character(nType[match(nId, nType$name), "class"]) 154 | nShape <- ifelse(nClass == "TidyModule" | is.na(nClass), "square", 155 | ifelse(nClass == "reactive", "box", "box") 156 | ) 157 | nColor <- ifelse(nClass == "TidyModule" | is.na(nClass), "lightblue", 158 | ifelse(nClass == "reactive", "orange", "grey") 159 | ) 160 | 161 | nGroup <- ifelse(nClass == "TidyModule" | is.na(nClass), "A", 162 | ifelse(nClass == "reactive", "B", "C") 163 | ) 164 | 165 | visNetwork::visNetwork( 166 | data.frame( 167 | id = nId, 168 | label = nId, 169 | group = nGroup, 170 | shape = nShape, 171 | # color = nColor, 172 | shadow = TRUE, 173 | value = 10 174 | ), 175 | e, 176 | height = "100%", 177 | width = "100%" 178 | ) %>% 179 | visNetwork::visEdges( 180 | shadow = TRUE, 181 | arrows = list(to = list(enabled = TRUE, scaleFactor = 2)), 182 | color = list(color = "lightblue", highlight = "yellow") 183 | ) %>% 184 | # visHierarchicalLayout(direction = "RL", levelSeparation = 500) 185 | visNetwork::visLayout(randomSeed = 12) 186 | }) 187 | } 188 | ) 189 | ) 190 | -------------------------------------------------------------------------------- /inst/shiny/examples/4_communication/module/PlotGenerator.R: -------------------------------------------------------------------------------- 1 | 2 | PlotGenerator <- R6::R6Class( 3 | classname = "PlotGenerator", 4 | inherit = Panel, 5 | public = list( 6 | plots = list( 7 | line = c("LinePlot", "Xiao"), 8 | box = c("BoxPlot", "David"), 9 | scatter = c("ScatterPlot", "Mustapha"), 10 | scatter3D = c("Scatter3DPlot", "Mustapha") 11 | ), 12 | initialize = function(...) { 13 | # Mandatory 14 | super$initialize(...) 15 | 16 | # Ports definition starts here 17 | self$definePort({ 18 | # At least one input 19 | self$addInputPort( 20 | name = "mappings", 21 | description = "Named list of character vectors defining mapping of columns", 22 | sample = list( 23 | map1 = c("col1", "col2"), 24 | map2 = c("col4", "col7") 25 | ) 26 | ) 27 | 28 | self$addInputPort( 29 | name = "tables", 30 | description = "Named list of data tables forwarded to the plotting modules", 31 | sample = list( 32 | raw = data.frame(id = 1:10, val = 11:20), 33 | filtered = data.frame(id = 5:10, val = 15:20) 34 | ) 35 | ) 36 | 37 | # Add an output port (optional) 38 | self$addOutputPort( 39 | name = "selection", 40 | description = "Data table with user selected data points", 41 | sample = head(mtcars) 42 | ) 43 | }) 44 | }, 45 | ui = function() { 46 | controls <- tagList( 47 | tags$br(), tags$br(), 48 | div(style = "display: inline-block;vertical-align:middle; width: 150px;", shiny::selectInput(self$ns("data"), label = "data", choices = c())), 49 | div(style = "display: inline-block;vertical-align:middle; width: 150px;", shiny::selectInput(self$ns("mapping"), label = "mapping", choices = c())), 50 | div(style = "display: inline-block;vertical-align:middle; width: 150px;", shiny::selectInput(self$ns("plot"), label = "plot type", choices = names(self$plots))), 51 | div(style = "display: inline-block;vertical-align:middle; width: 130px;", shiny::checkboxInput(self$ns("disconect_data"), label = "disconnect data", value = TRUE)), 52 | div(style = "display: inline-block;vertical-align:middle; width: 130px;", shiny::checkboxInput(self$ns("disconect_mapping"), label = "disconnect mapping", value = TRUE)), 53 | div(style = "display: inline-block;vertical-align:middle; width: 150px;", shiny::actionButton(self$ns("add"), label = NULL, icon = icon("plus"))) 54 | ) 55 | 56 | super$ui( 57 | status = "success", 58 | header = controls, 59 | fluidRow( 60 | id = self$ns("plotContainer") 61 | ) 62 | ) 63 | }, 64 | server = function(input, output, session) { 65 | # Mandatory 66 | super$server(input, output, session) 67 | 68 | self$obser$updateData <- observe({ 69 | t <- self$getInput("tables") 70 | shiny::req(t) 71 | shiny::updateSelectInput(session, "data", choices = names(t), selected = "raw") 72 | }) 73 | 74 | self$obser$updateMapping <- observe({ 75 | mPort <- self$getInput("mappings") 76 | req(mPort) 77 | options <- names(mPort()) 78 | if (is.null(options)) { 79 | options <- list() 80 | } 81 | shiny::updateSelectInput(session, "mapping", choices = options) 82 | }) 83 | 84 | self$obser$logAddClick <- observe({ 85 | cat(paste0("\n\n\n", input$add, "\n\n\n")) 86 | }) 87 | 88 | self$obser$add <- observeEvent(input$add, { 89 | reactive_mapping <- self$getInput("mappings") 90 | reactive_table <- self$getInput("tables") 91 | 92 | selected_mapping <- input$mapping 93 | selected_data <- input$data 94 | selected_plot <- input$plot 95 | 96 | req(reactive_mapping) 97 | req(reactive_table) 98 | 99 | current_mapping <- reactive_mapping()[[selected_mapping]] 100 | req(length(current_mapping) != 0) 101 | 102 | current_data <- reactive_table[[selected_data]]() 103 | req(!is.null(current_data)) 104 | 105 | mod <- self$plots[[selected_plot]][1] 106 | author <- self$plots[[selected_plot]][2] 107 | mod <- eval(parse(text = mod)) 108 | 109 | # dynamically create the selected charting module 110 | # Note that these are nested modules (module namespace includes Doug_) 111 | # Also note that the parent module "self" need to be specified when dynamically 112 | # creating a nested module 113 | mod <- mod$new(paste0(author, "_", input$add), parent = self) 114 | 115 | # feed a static version of the data/mapping to the module 116 | if (input$disconect_data) { 117 | reactive(current_data) %->% mod$iport("data") 118 | } else { 119 | reactive_table[[selected_data]] %->% mod$iport("data") 120 | } 121 | 122 | if (input$disconect_mapping) { 123 | reactive(current_mapping) %->% mod$iport("mapping") 124 | } else { 125 | reactive({ 126 | reactive_mapping()[[selected_mapping]] 127 | }) %->% mod$iport("mapping") 128 | } 129 | 130 | # now call the module 131 | mod$callModule() 132 | 133 | mflag <- tagList(shiny::icon("bolt"), " ") 134 | if (input$disconect_mapping) { 135 | mflag <- "" 136 | } 137 | 138 | dflag <- tagList(shiny::icon("bolt"), " ") 139 | if (input$disconect_data) { 140 | dflag <- "" 141 | } 142 | 143 | header <- tagList(" - ", dflag, selected_data, " - ", mflag, selected_mapping) 144 | 145 | # render the module 146 | insertUI( 147 | selector = paste0("#", self$ns("plotContainer")), 148 | where = "afterBegin", 149 | immediate = TRUE, 150 | session = session, 151 | ui = tagList( 152 | column(6, mod$ui(header = header)) 153 | ) 154 | ) 155 | }) 156 | 157 | # Ports assignment starts here 158 | self$assignPort({ 159 | # TODO: Add output port, e.g. brushing selection ? 160 | # self$updateOutputPort( 161 | # id = "dataset", 162 | # output = modOut) 163 | }) 164 | 165 | return({}) 166 | } 167 | ) 168 | ) 169 | -------------------------------------------------------------------------------- /vignettes/namespace.Rmd: -------------------------------------------------------------------------------- 1 | --- 2 | pagetitle: "Namespace management" 3 | title: "Namespace management" 4 | subtitle: "
"
5 | author: "Mustapha Larbaoui"
6 | date: "`r Sys.Date()`"
7 | output: rmarkdown::html_vignette
8 | vignette: >
9 | %\VignetteIndexEntry{Namespace management}
10 | %\VignetteEngine{knitr::rmarkdown}
11 | %\VignetteEncoding{UTF-8}
12 | ---
13 |
14 | ```{r setup, include = FALSE}
15 | knitr::opts_chunk$set(
16 | collapse = TRUE,
17 | comment = "#>"
18 | )
19 | ```
20 |
21 |
22 | As a reminder, the namespace is an important aspect of shiny module that prevents collision of input and output IDs in your application. The namespace identify each unique instance of the modules and need to be provided by the caller.
23 |
24 | `{tidymodules}` can be considered as an object-oriented organisational layer on top of shiny that does conventional module in the background.
25 | It does use namespace but make it optional to the users. In other words, you don't need to remember it!
26 |
27 | ## Optional namespace Id
28 |
29 | In the example below a `{tm}` module `MyMod` is defined and called with the `new()` function and with no arguments supplied.
30 | Printing the instance `m` to the console shows the structure of the module.
31 |
32 | ```{r, eval=TRUE}
33 | library(tidymodules)
34 |
35 | MyMod <- R6::R6Class(
36 | "MyMod",
37 | inherit = TidyModule
38 | )
39 |
40 | m <- MyMod$new()
41 |
42 | m
43 | ```
44 |
45 | The namespace Id for module `m` above is `MyMod-1`. It is a unique Id generated by `{tidymodules}` and composed of the class name and the initialisation order of the module.
46 |
47 |
48 | ## User defined namespace Id
49 |
50 | The user can also provide a more informative name when initialising a module.
51 |
52 |
53 | ```{r, eval=TRUE}
54 |
55 | m <- MyMod$new("Tom")
56 |
57 | m
58 | ```
59 |
60 | `Tom` end up being the namespace Id of `m`.
61 |
62 | The provided name must begin with a letter `[A-Za-z]` and may be followed by any number of letters, digits `[0-9]`, hyphens `-`, underscores `_`.
63 | You should not use the following characters as they have a special meaning on the UI ( CSS / jQuery ).
64 |
65 | > ~ ! @ $ % ^ & * ( ) + = , . / ' ; : " ? > < [ ] \ { } | ` #
66 |
67 |
68 | ## Namespace and nested modules
69 |
70 | The code below illustrates a very simple example of nested module and the corresponding namespace Ids. Here are few things to note about this example:
71 |
72 | * `ModA` and `ModB` are both `{tm}` classes as they both inherit from `tidymodules::TidyModule`
73 | * `ModB` is used as a nested class of `ModA`
74 | * `ModA` has a public field named `nested_mod`
75 | * The namespace of a nested module is always prefixed with its parent
76 |
77 |
78 | ```{r, eval=TRUE}
79 | ModB <- R6::R6Class(
80 | "ModB",
81 | inherit = TidyModule
82 | )
83 |
84 | ModA <- R6::R6Class(
85 | "ModA",
86 | inherit = TidyModule,
87 | public = list(
88 | nested_mod = NULL,
89 | initialize = function(...) {
90 | super$initialize(...)
91 | self$nested_mod <- ModB$new()
92 | }
93 | )
94 | )
95 |
96 | m <- ModA$new()
97 | n <- m$nested_mod
98 |
99 | m
100 | n
101 | ```
102 |
103 | ## Grouping modules
104 |
105 | This option allows the grouping of `{tm}` modules together to facilitate their retrieval from the `ModStore` and to better visualize them later in a network diagram.
106 |
107 |
108 | ```{r, eval=TRUE}
109 |
110 | ta <- MyMod$new("Tom", group = "A")
111 | tb <- MyMod$new("Tom", group = "B")
112 |
113 | ta
114 | tb
115 | ```
116 |
117 | As you can see above the group argument is used to define the final namespace Id of the modules.
118 | Those modules share the same name but have different namespace IDs.
119 |
120 | ## module's IDs and UI function
121 |
122 | A `{tm}` module namespace is a concatenation of many fields.
123 |
124 | * Some are optional fields: `name` and `group`
125 | * And some are managed by `{tidymodules}`: `id`, `parent_ns` and `module_ns`
126 |
127 | the module's namespace is built like this
128 |
129 | ```
130 | id =
21 |
22 | This vignette aims to provide a high level introduction to tidymodules. We recommend reading this article for anyone who is new to tidymodules, especially those tidymodules module "consumers", who use existing module classes as a "black-box" in their Shiny app development. This article includes the following topics:
23 |
24 | - TidyModule ports: key infrastructure for managing cross-module communication
25 | - How to use tidymodules modules as a Shiny app developer and tidymodules consumer
26 | - Existing examples
27 |
28 | If you would like to develop new tidymodules modules, please refer to the vignettes under "Articles".
29 |
30 | ## TidyModule structure: ports
31 |
32 | ### Introducing ports
33 |
34 | In conventional Shiny modules, communication between modules is realized through the following
35 |
36 | - **Input:** passing reactives as functional parameters into the Shiny `callModule()` function
37 | - **Output:** returning reactives in the module `server()` function.
38 |
39 | It can be challenging to keep track of the arbitrary number of input and output reactives for complex apps with many interacting modules.
40 |
41 | To address this challenge, we introduced input/output ports as fields of the TidyModule class object in tidymodules.
42 | The concept is illustrated in the following diagram. In this example, Module1 and Module2 each have input and output ports that hold reactives.
43 | The ports defined in each modules provides a data structure that allow TidyModule to establish a communication between them.
44 |
45 | 
46 |
47 | The two modules are connected via a tidymodules pipe operator `%x>y%` where x and y could be any numbers from 1 to 10. For example,`%1>1%` means the left module's first output port (x = 1) is mapped to the first input port (y = 1) of the right module. Multiple connected tidymodules modules with such directed edges form a directed graph network, which will be further discussed later in this article.
48 |
49 | ### Finding out ports of a tidymodules module
50 |
51 | To find out the port structure, simply print the module object on the console. The following example shows that the `Addition` module has one input port named "left" and one output port named "total" that are both empty, i.e. not being assigned an input reactive (input ports) or injected into the server code (output ports).
52 | ```{r}
53 | library(shiny)
54 | library(tidymodules)
55 | source(system.file(package = "tidymodules", "shiny/examples/1_simple_addition/Addition.R"))
56 | Addition$new()
57 | ```
58 |
59 |
60 | ## Using tidymodules modules
61 |
62 | The basic workflow of using tidymodules modules in a Shiny app is the following
63 |
64 | - Load tidymodules module class definition
65 | - Identify module structure such as input/output ports, ui(), and server() functionalities
66 | - Instantiate new module objects from tidymodules classes
67 | - Construct app `ui()` using module `ui()` methods
68 | - In app `server()` inject tidymodules module `server()` logic using `callModules()` or the `callModule()` function of the module object, like `myMod$callModule()`.
69 | - Set up module communication/relationship via tidymodules pipe operators and functions.
70 |
71 | The workflow is illustrated in the following example, which is available at
72 |
73 | Example 1: Simple addition [](https://tidymodules.shinyapps.io/1_simple_addition/)
74 |
75 | ### Load module definition
76 |
77 | ```{r, eval=FALSE}
78 | library(tidymodules)
79 | # source tidymodules Addition module definition
80 | source(system.file(package = "tidymodules", "shiny/examples/1_simple_addition/Addition.R"))
81 | ```
82 |
83 | ### Instantiate module objects
84 |
85 | Notice that the namespace argument in `$new()` is optional and `tidymodules` will automatically generate a namespace ID if not provided.
86 | ```{r, eval=T}
87 | # Instantiate two Addition module objects
88 | Addition$new()
89 | Addition$new()
90 | ```
91 | Also notice that it is not necessary to give a name to the `Addition$new()` object. `tidymodules` provides `mod()` or `getMod()` function to help users conveniently retrieve module objects via their numerical ID or namespace ID.
92 |
93 | ### Adding `ui()`
94 |
95 | In the app `ui()`, we call the `ui()` method of each module object.
96 | ```{r, eval=FALSE}
97 | ui <- fixedPage(
98 | h2("tidymodules : Addition example"),
99 | shiny::fluidRow(
100 | sliderInput("first_number", label = "Enter your first number", min = 1, max = 100, value = 1), br(),
101 |
102 | # Calling module ui() methods
103 | mod(1)$ui(), br(),
104 | mod(2)$ui(), br(),
105 | "Total: ", textOutput("total_result")
106 | )
107 | )
108 | ```
109 |
110 | ### Add module `server()` logic using `callModules()`
111 | Here we use the `callModules()` function to call the server() methods for the two modules that we created.
112 | ```{r, eval=FALSE}
113 | server <- function(input, output, session) {
114 | # call the server() functions for all existing tidymodules modules in the global environment
115 | callModules()
116 | }
117 | ```
118 |
119 | ### Establish cross-module communication via 'tidy' pipe operators
120 |
121 | The module communication is established through the pipe operators: `first %>1% mod(1) %1>1% mod(2)`. Note that in `first` must be a Shiny reactive value or endpoint in order to server as an input to other tidymodules modules.
122 | ```{r, eval=FALSE}
123 | server <- function(input, output, session) {
124 | # call the server() functions for all existing tidymodules modules in the global environment
125 | callModules()
126 |
127 | first <- reactive({
128 | req(input$first_number)
129 | })
130 |
131 | # Setting up module commmunication
132 | observe({
133 | first %>1% mod(1) %1>1% mod(2)
134 | })
135 |
136 | output$total_result <- renderText({
137 | result <- mod(2)$getOutput(1)
138 | result()
139 | })
140 | }
141 |
142 | shinyApp(ui, server)
143 | ```
144 |
145 | We also provide utility functions to help identify and connect ports using the port names. For more information about the pipe operators, refer to the functional documentation under "Reference" tab.
146 |
147 | ### Module relational network
148 |
149 | Tidymodules module objects are mananged by `ModStore` in tidymodules. For example, in the
150 | example 2 - Linkled scatter [](https://tidymodules.shinyapps.io/2_linked_scatter/) you can find the sessions, module objects, edges and port mapping diagram in the "Help | ModStore" tab.
151 |
152 | Below is the module relationship network digram generated by `tidymodules` using the `visNetwork` package.
153 |
154 | 
155 |
156 | ### Inheritance and Entity Relational Diagram
157 |
158 | For more details about class and ports inheritance, see article [inheritance](inheritance.html).
159 | The diagram below illustrates the relation between the classes defined in the example 4 of tidymodules [](https://tidymodules.shinyapps.io/4_communication/).
160 |
161 | 
162 |
163 | ## Other examples
164 |
165 | You can list all Shiny examples that come with the `tidymodules` package by the `showExamples()` function. We recommend going through these examples to help you understand the use patterns.
166 | ```{r}
167 | showExamples()
168 | ```
169 |
170 | We have already used the first example to illustrate the basic usage of tidymodules, below we briefly describe the other examples.
171 |
172 | ### Example 2: linked scatter plot
173 |
174 | This example illustrates the tidymodules implementation of the classical Shiny module example of [two linked scatter plots](https://shiny.rstudio.com/gallery/module-example.html).
175 |
176 | ### Example 3: nested modules
177 |
178 | This example [](https://tidymodules.shinyapps.io/3_nested_modules/) illustrates constructing and using nested modules in the `tidymodules` framework, as well as dynamically creating tidymodules modules.
179 |
180 | ### Example 4: module communication
181 |
182 | This is a comprehensive example [](https://tidymodules.shinyapps.io/4_communication/) to illustrate mutiple advanced features such as
183 |
184 | - Inheritance
185 | - Port operations: `combine_ports()`
186 | - Enable/disable module communication
187 |
--------------------------------------------------------------------------------
/vignettes/intro.Rmd:
--------------------------------------------------------------------------------
1 | ---
2 | pagetitle: "Getting started with writing `{tidymodules}`"
3 | title: "Getting started with writing `{tidymodules}`"
4 | subtitle: ""
5 | author: "Xiao Ni, Mustapha Larbaoui"
6 | date: "`r Sys.Date()`"
7 | output: rmarkdown::html_vignette
8 | vignette: >
9 | %\VignetteIndexEntry{Getting started with writing `{tidymodules}`}
10 | %\VignetteEngine{knitr::rmarkdown}
11 | %\VignetteEncoding{UTF-8}
12 | ---
13 |
14 | ```{r setup, include = FALSE}
15 | knitr::opts_chunk$set(
16 | collapse = TRUE,
17 | eval = TRUE,
18 | comment = "#>"
19 | )
20 | ```
21 |
22 | ## A quick introduction to R6 and Object Oriented Programming (OOP)
23 |
24 | `{tidymodules}` or `{tm}` in short, is based on R6 ([https://r6.r-lib.org/](https://r6.r-lib.org/)), which is an implementation of encapsulated object-oriented programming for R. Therefore knowledge of R6 is a prerequisite to develop `{tm}` modules.
25 |
26 | R6 provides a framework for OOP in R. Unlike the functional programming style, R6 encapsulates methods and fields in classes that instantiate into objects. R6 classes are similar to R's reference classes, but are more efficient and do not depend on S4 classes and the methods package.
27 |
28 | This vignette provides a brief overview of R6 for developers new to R6. For more information, developers are recommended to review the R6 packagedown site ([https://r6.r-lib.org/](https://r6.r-lib.org/)), as well as Chapter 14 of the Advanced R book ([https://adv-r.hadley.nz/r6.html](https://adv-r.hadley.nz/r6.html))
29 |
30 | ### R6 classes and methods
31 |
32 | `{tm}` depends on the R6 package which you can install from CRAN and load:
33 | ```{r , eval=FALSE}
34 | library(R6)
35 | ```
36 |
37 | R6 classes are created using the [`R6::R6Class()` function](https://r6.r-lib.org/reference/R6Class.html), which is the only function from the R6 package that is typically used. The following is a simple example of defining an R6 class:
38 | ```{r, eval=TRUE}
39 | Calculator <- R6::R6Class(
40 | classname = "Calculator",
41 | public = list(
42 | value = NA,
43 | initialize = function(value) {
44 | self$value <- value
45 | },
46 | add = function(x = 1) {
47 | self$value <- self$value + x
48 | invisible(self)
49 | }
50 | )
51 | )
52 | ```
53 | The first argument `classname` by convention uses `UpperCamelCase`. The second argument `public` encapsulates a list of methods (functions) and fields (objects) that make up the public interface of the object. By convention methods and fields use `snake_case`. Methods can access the methods and fields of the current object using `self$`. One should always assign the result of `R6Class()` into a variable with the same names as the `classname` because `R6Class()` returns an R6 object that defines the class.
54 |
55 |
56 | You can print the class definition:
57 | ```{r}
58 | Calculator
59 | ```
60 |
61 |
62 | To create a new instance of `Calculator`, use the `$new()` method. The `$initialize()` is an important method, which overrides the default behavior of `$new()`. In the above example, the `$initialize()` method initializes the `calculator1` object with `value = 0`.
63 | ```{r}
64 | calculator1 <- Calculator$new(0)
65 | calculator1
66 | ```
67 |
68 |
69 | You can then call the methods and access fields using `$`:
70 | ```{r}
71 | calculator1$add(10)
72 | calculator1$value
73 | ```
74 |
75 | You can also add methods after class creation as illustrated below for the existing `Calculator` R6 class, although new methods and fields are only available to new objects.
76 | ```{r}
77 | Calculator$set("public", "subtract", function(x = 1) {
78 | self$value <- self$value - x
79 | invisible(self)
80 | })
81 | Calculator
82 | ```
83 |
84 |
85 | Below are some key features of R6.
86 |
87 | - **Reference semantics**: objects are not copied when modified. R6 provides a `$clone()` method for making copy of an object. For more details, refer to https://r6.r-lib.org/reference/R6Class.html#cloning-objects.
88 | - **Public vs. private members**: `R6Class()` has a `private` argument for you to define private methods and fileds that can only be accessed from within the class, not from the outside.
89 | - **Inheritance**: as in classical OOP, one R6 class can inherit from another R6 class. Superclass methods can be accessed with `super$`.
90 |
91 | ## `tidymodules::TidyModule` class
92 |
93 | The `tidymodules::TidyModule` class is a R6 class and the parent of all `{tm}` modules.
94 |
95 | Below is partial code of the `TidyModule` class for illustration purpose. The `TidyModule` class includes many public methods. There are utility functions such as `callModules()`, `definePorts()`, `assignPort()` as well as functions that need to be overwritten such as `ui()`, `server()`, etc.
96 |
97 | Unlike conventional Shiny modules in funtional programming style, `{tm}` encapsulates functions such as ui() and server() as methods in a TidyModule class object. Module namespace ID is seamlessly managed within the module class for the ui and server. For complete technical documentation that includes other methods and fields, see `?TidyModule`.
98 | ```{r, eval=FALSE}
99 | TidyModule <- R6::R6Class(
100 | "TidyModule",
101 | public = list(
102 | id = NULL,
103 | module_ns = NULL,
104 | parent_ns = NULL,
105 | parent_mod = NULL,
106 | parent_ports = NULL,
107 | group = NULL,
108 | created = NULL,
109 | o = NULL,
110 | i = NULL,
111 | initialize = function(id = NULL, inherit = TRUE, group = NULL) {
112 | # details omitted
113 | },
114 | # Other methods such
115 | ui = function() {
116 | return(shiny::tagList())
117 | },
118 | server = function(input,
119 | output,
120 | session) {
121 | # Need to isolate this block to avoid unecessary triggers
122 | shiny::isolate({
123 | private$shiny_session <- session
124 | private$shiny_input <- input
125 | private$shiny_output <- output
126 | })
127 | },
128 | definePort = function(x) {
129 | shiny::isolate(x)
130 | },
131 | assignPort = function(x) {
132 | shiny::observe({
133 | shiny::isolate(x)
134 | })
135 | },
136 | # Other public methods omitted
137 | ),
138 | private = list(
139 | # Details omitted
140 | )
141 | )
142 | ```
143 |
144 |
145 |
146 | ## Writing your first `{tm}` module
147 |
148 | You can develop new `{tm}` modules by inheriting and extending the `tidymodules::TidyModule` class.
149 |
150 | Below is a minimal example, `RandomNumberGenerator`, defined with one input port and one output port. The input port is a random number seed that feeds into a random number generator, whose result serves as the module output.
151 |
152 | ```{r}
153 | # Module definition
154 | RandomNumMod <- R6::R6Class(
155 | "RandomNumGenerator",
156 | inherit = tidymodules::TidyModule,
157 | public = list(
158 | initialize = function(id = NULL) {
159 | super$initialize(id)
160 |
161 | self$definePort({
162 | self$addInputPort(
163 | name = "seed",
164 | description = "random number seed",
165 | sample = 123
166 | )
167 |
168 | self$addOutputPort(
169 | name = "number",
170 | description = "Random number",
171 | sample = 123
172 | )
173 | })
174 | },
175 | ui = function() {
176 | tagList(
177 | verbatimTextOutput(self$ns("text"))
178 | )
179 | },
180 | server = function(input, output, session) {
181 | super$server(input, output, session)
182 |
183 | result <- reactive({
184 | s <- self$getInput("seed")
185 | set.seed(s())
186 | floor(runif(1) * 1e5)
187 | })
188 |
189 | output$text <- renderPrint({
190 | s <- self$getInput("seed")
191 | print(paste0("seed = ", s()))
192 | print(paste0("number = ", result()))
193 | })
194 |
195 | self$assignPort({
196 | self$updateOutputPort(
197 | id = "number",
198 | output = result
199 | )
200 | })
201 | return(result)
202 | }
203 | )
204 | )
205 | ```
206 |
207 | Cross-communication between two `{tm}` modules is established using several flavours of the pipe `%>%` operator, as illustrated in the following code. The first module's output is fed as the random number seed for the second module.
208 | ```{r, eval=FALSE}
209 | ## Calling app
210 | randomNumMod1 <- RandomNumMod$new()
211 | randomNumMod2 <- RandomNumMod$new()
212 |
213 | ui <- tagList(
214 | fluidPage(
215 | randomNumMod1$ui(),
216 | randomNumMod2$ui()
217 | )
218 | )
219 | server <- function(input, output, session) {
220 | randomNumMod1$callModule()
221 | randomNumMod2$callModule()
222 |
223 | seed_1 <- reactive(123)
224 |
225 | observe({
226 | seed_1 %>1% randomNumMod1 %1>1% randomNumMod2
227 | })
228 | }
229 |
230 | shinyApp(ui = ui, server = server)
231 | ```
232 |
233 | ## Next steps
234 |
235 | To learn more about writing `{tm}` modules, read the examples.
236 |
237 |
--------------------------------------------------------------------------------
/R/add_module.R:
--------------------------------------------------------------------------------
1 | #' Create a module
2 | #'
3 | #' This function creates a `{tm}` module class inside the current folder.
4 | #'
5 | #' @param name The class name of the module.
6 | #' @param path Where to created the file. Default is `getwd()`. The function will add `R` to the path if the sub-folder exists.
7 | #' @param prefix filename prefix. Default is `tm`. Set to `NULL`` to disable.
8 | #' @param inherit Parent module class. Default is TidyModule.
9 | #' @param open Should the file be opened?
10 | #' @param dir_create Creates the directory if it doesn't exist, default is `TRUE`.
11 | #' @param export Logical. Should the module be exported? Default is `FALSE`.
12 | #' @note As a convention, this function will automatically capitalize the first character of the `name` argument.
13 | #'
14 | #' @importFrom cli cat_bullet
15 | #' @importFrom utils file.edit
16 | #' @importFrom fs path_abs path file_create
17 | #' @importFrom snippr snippets_read
18 | #'
19 | #' @export
20 | add_module <- function(name,
21 | inherit = "TidyModule",
22 | path = getwd(),
23 | prefix = "tm",
24 | open = TRUE,
25 | dir_create = TRUE,
26 | export = FALSE) {
27 | name <- file_path_sans_ext(name)
28 | # Capitalize
29 | name <- paste0(toupper(substring(name, 1, 1)), substring(name, 2))
30 |
31 | dir_created <- create_if_needed(
32 | fs::path(path),
33 | type = "directory"
34 | )
35 | if (!dir_created) {
36 | cat_red_bullet(
37 | "File not added (needs a valid directory)"
38 | )
39 | return(invisible(FALSE))
40 | }
41 |
42 | if (dir.exists(fs::path(path, "R"))) {
43 | path <- fs::path(path, "R")
44 | }
45 |
46 | old <- setwd(path_abs(path))
47 | on.exit(setwd(old))
48 |
49 | where <- fs::path(
50 | paste0(ifelse(is.null(prefix), "", paste0(prefix, "_")), name, ".R")
51 | )
52 |
53 | if (!check_file_exist(where)) {
54 | cat_red_bullet(
55 | "File not created (already exists)"
56 | )
57 | return(invisible(FALSE))
58 | }
59 |
60 | # make sure the provided parent module is valid
61 | import <- NULL
62 | parent <- inherit
63 | # TidyModule object
64 | if (is(parent, "TidyModule")) {
65 | parent <- class(parent)[1]
66 | }
67 | # Load the class generator from the name
68 | if (class(parent) == "character") {
69 | tryCatch(
70 | {
71 | parent <- eval(parse(text = parent))
72 | },
73 | error = function(e) {
74 | cat_red_bullet(
75 | paste0("Could not find module defined with 'inherit' = ", inherit)
76 | )
77 | return(invisible(FALSE))
78 | }
79 | )
80 | }
81 | # Retrieve package dependency and parent module name
82 | if (is(parent, "R6ClassGenerator")) {
83 | clist <- get_R6CG_list(parent)
84 | if ("TidyModule" %in% clist) {
85 | import <- environmentName(parent$parent_env)
86 | if (import == "R_GlobalEnv") {
87 | import <- NULL
88 | }
89 | parent <- clist[1]
90 | } else {
91 | cat_red_bullet(
92 | paste0("Could not find module defined with 'inherit' = ", deparse(substitute(inherit)))
93 | )
94 | return(invisible(FALSE))
95 | }
96 | }
97 |
98 |
99 | # Retrieve content from package snippet
100 | file_content <- snippr::snippets_read(path = system.file("rstudio/r.snippets", package = "tidymodules"))$tm.mod.new
101 | file_content <- unlist(strsplit(file_content, "\\n"))
102 | for (l in seq_len(length(file_content))) {
103 | # remove $ escapes \\
104 | file_content[l] <- sub("\\$", "$", file_content[l], fixed = TRUE)
105 | # remove tabs
106 | file_content[l] <- sub("\t", "", file_content[l])
107 | # remove snippet placeholders
108 | file_content[l] <- gsub("\\$\\{\\d+:(\\w+)\\}", "%\\1", file_content[l])
109 | # remove cursor pointer
110 | file_content[l] <- sub("\\$\\{0\\}", "", file_content[l])
111 | # substitute module name
112 | if (grepl("MyModule", file_content[l])) {
113 | file_content[l] <- gsub("MyModule", "s", file_content[l])
114 | file_content[l] <- sprintf(file_content[l], name)
115 | }
116 | # substitute parent module
117 | if (grepl("TidyModule", file_content[l])) {
118 | file_content[l] <- gsub("TidyModule", "s", file_content[l])
119 | file_content[l] <- sprintf(file_content[l], parent)
120 | }
121 | # manage export
122 | if (grepl("@export", file_content[l])) {
123 | if (!export) {
124 | file_content[l] <- "#' @noRd "
125 | }
126 | if (!is.null(import)) {
127 | file_content[l] <- paste0("#'\n#' @import ", import, "\n", file_content[l])
128 | }
129 | }
130 | }
131 | writeLines(file_content, where, sep = "\n")
132 |
133 | cat_created(fs::path(path, where))
134 | open_or_go_to(where, open)
135 | }
136 |
137 | # bunch of utility functions copied from golem
138 | # WILL FACILITATE MIGRATING THIS FUNCTION TO GOLEM
139 |
140 | #' @importFrom utils menu
141 | yesno <- function(...) {
142 | cat(paste0(..., collapse = ""))
143 | menu(c("Yes", "No")) == 1
144 | }
145 |
146 | #' @importFrom fs file_exists
147 | check_file_exist <- function(file) {
148 | res <- TRUE
149 | if (file_exists(file)) {
150 | cat_orange_bullet(file)
151 | res <- yesno("This file already exists, override?")
152 | }
153 | return(res)
154 | }
155 |
156 | #' @importFrom fs dir_create file_create
157 | create_if_needed <- function(path,
158 | type = c("file", "directory"),
159 | content = NULL) {
160 | type <- match.arg(type)
161 | # Check if file or dir already exist
162 | if (type == "file") {
163 | dont_exist <- file_not_exist(path)
164 | } else if (type == "directory") {
165 | dont_exist <- dir_not_exist(path)
166 | }
167 | # If it doesn't exist, ask if we are allowed
168 | # to create it
169 | if (dont_exist) {
170 | ask <- yesno(
171 | sprintf(
172 | "The %s %s doesn't exist, create?",
173 | basename(path),
174 | type
175 | )
176 | )
177 | # Return early if the user doesn't allow
178 | if (!ask) {
179 | return(FALSE)
180 | } else {
181 | # Create the file
182 | if (type == "file") {
183 | if (dir_not_exist(dirname(path))) {
184 | dir_create(dirname(path), recurse = TRUE)
185 | }
186 | file_create(path)
187 | write(content, path, append = TRUE)
188 | } else if (type == "directory") {
189 | dir_create(path, recurse = TRUE)
190 | }
191 | }
192 | }
193 |
194 | # TRUE means that file exists (either
195 | # created or already there)
196 | return(TRUE)
197 | }
198 |
199 |
200 | #' @importFrom cli cat_bullet
201 | cat_green_tick <- function(...) {
202 | cat_bullet(
203 | ...,
204 | bullet = "tick",
205 | bullet_col = "green"
206 | )
207 | }
208 |
209 | #' @importFrom cli cat_bullet
210 | cat_red_bullet <- function(...) {
211 | cat_bullet(
212 | ...,
213 | bullet = "bullet",
214 | bullet_col = "red"
215 | )
216 | }
217 |
218 | #' @importFrom cli cat_bullet
219 | cat_orange_bullet <- function(...) {
220 | cat_bullet(
221 | ...,
222 | bullet = "bullet",
223 | bullet_col = "orange"
224 | )
225 | }
226 |
227 | #' @importFrom cli cat_bullet
228 | cat_info <- function(...) {
229 | cat_bullet(
230 | ...,
231 | bullet = "arrow_right",
232 | bullet_col = "grey"
233 | )
234 | }
235 |
236 | #' @importFrom fs path_file
237 | cat_exists <- function(where) {
238 | cat_red_bullet(
239 | sprintf(
240 | "%s already exists, skipping the copy.",
241 | path_file(where)
242 | )
243 | )
244 | cat_info(
245 | sprintf(
246 | "If you want replace it, remove the %s file first.",
247 | path_file(where)
248 | )
249 | )
250 | }
251 |
252 | cat_created <- function(where,
253 | file = "File") {
254 | cat_green_tick(
255 | sprintf(
256 | "%s created at %s",
257 | file,
258 | where
259 | )
260 | )
261 | }
262 |
263 | open_or_go_to <- function(where,
264 | open) {
265 | if (
266 | rstudioapi::isAvailable() &&
267 | open &&
268 | rstudioapi::hasFun("navigateToFile")
269 | ) {
270 | rstudioapi::navigateToFile(where)
271 | } else {
272 | cat_red_bullet(
273 | sprintf(
274 | "Go to %s",
275 | where
276 | )
277 | )
278 | }
279 | }
280 |
281 | desc_exist <- function(pkg) {
282 | file_exists(
283 | paste0(pkg, "/DESCRIPTION")
284 | )
285 | }
286 |
287 |
288 | file_created_dance <- function(where,
289 | fun,
290 | pkg,
291 | dir,
292 | name,
293 | open) {
294 | cat_created(where)
295 |
296 | fun(pkg, dir, name)
297 |
298 | open_or_go_to(where, open)
299 | }
300 |
301 | if_not_null <- function(x, ...) {
302 | if (!is.null(x)) {
303 | force(...)
304 | }
305 | }
306 |
307 | set_name <- function(x, y) {
308 | names(x) <- y
309 | x
310 | }
311 |
312 | # FROM tools::file_path_sans_ext() & tools::file_ext
313 | file_path_sans_ext <- function(x) {
314 | sub("([^.]+)\\.[[:alnum:]]+$", "\\1", x)
315 | }
316 |
317 | file_ext <- function(x) {
318 | pos <- regexpr("\\.([[:alnum:]]+)$", x)
319 | ifelse(pos > -1L, substring(x, pos + 1L), "")
320 | }
321 |
322 | #' @importFrom fs dir_exists file_exists
323 | dir_not_exist <- Negate(dir_exists)
324 | file_not_exist <- Negate(file_exists)
325 |
--------------------------------------------------------------------------------
/man/ModStore.Rd:
--------------------------------------------------------------------------------
1 | % Generated by roxygen2: do not edit by hand
2 | % Please edit documentation in R/ModStore.R
3 | \name{ModStore}
4 | \alias{ModStore}
5 | \title{R6 Class Representing a ModStore}
6 | \description{
7 | This class is used to create a storage for tidymodules objects.
8 | }
9 | \details{
10 | Manage applications, sessions and modules.
11 | }
12 | \examples{
13 |
14 | ## ------------------------------------------------
15 | ## Method `ModStore$new`
16 | ## ------------------------------------------------
17 |
18 | MyModule <- R6::R6Class("MyModule", inherit = tidymodules::TidyModule)
19 | m <- MyModule$new()
20 | s <- m$getStore()
21 |
22 | ## ------------------------------------------------
23 | ## Method `ModStore$isStored`
24 | ## ------------------------------------------------
25 |
26 | MyModule <- R6::R6Class("MyModule", inherit = tidymodules::TidyModule)
27 | m <- MyModule$new()
28 | s <- m$getStore()
29 | s$isStored(m)
30 | }
31 | \section{Methods}{
32 | \subsection{Public methods}{
33 | \itemize{
34 | \item \href{#method-ModStore-new}{\code{ModStore$new()}}
35 | \item \href{#method-ModStore-isStored}{\code{ModStore$isStored()}}
36 | \item \href{#method-ModStore-getGlobalSession}{\code{ModStore$getGlobalSession()}}
37 | \item \href{#method-ModStore-getSession}{\code{ModStore$getSession()}}
38 | \item \href{#method-ModStore-getSessions}{\code{ModStore$getSessions()}}
39 | \item \href{#method-ModStore-getMods}{\code{ModStore$getMods()}}
40 | \item \href{#method-ModStore-getEdges}{\code{ModStore$getEdges()}}
41 | \item \href{#method-ModStore-addEdge}{\code{ModStore$addEdge()}}
42 | \item \href{#method-ModStore-delEdges}{\code{ModStore$delEdges()}}
43 | \item \href{#method-ModStore-addMod}{\code{ModStore$addMod()}}
44 | \item \href{#method-ModStore-delMod}{\code{ModStore$delMod()}}
45 | \item \href{#method-ModStore-print}{\code{ModStore$print()}}
46 | \item \href{#method-ModStore-clone}{\code{ModStore$clone()}}
47 | }
48 | }
49 | \if{html}{\out{
}} 50 | \if{html}{\out{}} 51 | \if{latex}{\out{\hypertarget{method-ModStore-new}{}}} 52 | \subsection{Method \code{new()}}{ 53 | Create a new ModStore object. 54 | Should be called once by the TidyModule class. 55 | Not to be called directly outside TidyModule. 56 | The ModStore object can be retrieved from any TidyModule object, see example below. 57 | \subsection{Usage}{ 58 | \if{html}{\out{
}}\preformatted{ModStore$new()}\if{html}{\out{
}}
59 | }
60 |
61 | \subsection{Returns}{
62 | A new \code{ModStore} object.
63 | }
64 | \subsection{Examples}{
65 | \if{html}{\out{}}
66 | \preformatted{MyModule <- R6::R6Class("MyModule", inherit = tidymodules::TidyModule)
67 | m <- MyModule$new()
68 | s <- m$getStore()
69 | }
70 | \if{html}{\out{
}}
71 |
72 | }
73 |
74 | }
75 | \if{html}{\out{}} 76 | \if{html}{\out{}} 77 | \if{latex}{\out{\hypertarget{method-ModStore-isStored}{}}} 78 | \subsection{Method \code{isStored()}}{ 79 | Check if a module is stored in the current session. 80 | \subsection{Usage}{ 81 | \if{html}{\out{
}}\preformatted{ModStore$isStored(m)}\if{html}{\out{
}}
82 | }
83 |
84 | \subsection{Arguments}{
85 | \if{html}{\out{}}
86 | \describe{
87 | \item{\code{m}}{TidyModule object.}
88 | }
89 | \if{html}{\out{
}}
90 | }
91 | \subsection{Examples}{
92 | \if{html}{\out{}}
93 | \preformatted{MyModule <- R6::R6Class("MyModule", inherit = tidymodules::TidyModule)
94 | m <- MyModule$new()
95 | s <- m$getStore()
96 | s$isStored(m)
97 | }
98 | \if{html}{\out{
}}
99 |
100 | }
101 |
102 | }
103 | \if{html}{\out{}} 104 | \if{html}{\out{}} 105 | \if{latex}{\out{\hypertarget{method-ModStore-getGlobalSession}{}}} 106 | \subsection{Method \code{getGlobalSession()}}{ 107 | Retrieve the global session 'global_session'. 108 | This is the session that exists outside the application server function 109 | \subsection{Usage}{ 110 | \if{html}{\out{
}}\preformatted{ModStore$getGlobalSession()}\if{html}{\out{
}}
111 | }
112 |
113 | }
114 | \if{html}{\out{}} 115 | \if{html}{\out{}} 116 | \if{latex}{\out{\hypertarget{method-ModStore-getSession}{}}} 117 | \subsection{Method \code{getSession()}}{ 118 | Retrieve a module session. 119 | This could be the global session or a user session. 120 | \subsection{Usage}{ 121 | \if{html}{\out{
}}\preformatted{ModStore$getSession(m)}\if{html}{\out{
}}
122 | }
123 |
124 | \subsection{Arguments}{
125 | \if{html}{\out{}}
126 | \describe{
127 | \item{\code{m}}{TidyModule object.}
128 | }
129 | \if{html}{\out{
}}
130 | }
131 | }
132 | \if{html}{\out{}} 133 | \if{html}{\out{}} 134 | \if{latex}{\out{\hypertarget{method-ModStore-getSessions}{}}} 135 | \subsection{Method \code{getSessions()}}{ 136 | Retrieve all sessions. 137 | \subsection{Usage}{ 138 | \if{html}{\out{
}}\preformatted{ModStore$getSessions()}\if{html}{\out{
}}
139 | }
140 |
141 | }
142 | \if{html}{\out{}} 143 | \if{html}{\out{}} 144 | \if{latex}{\out{\hypertarget{method-ModStore-getMods}{}}} 145 | \subsection{Method \code{getMods()}}{ 146 | Retrieve all modules. 147 | \subsection{Usage}{ 148 | \if{html}{\out{
}}\preformatted{ModStore$getMods(m)}\if{html}{\out{
}}
149 | }
150 |
151 | \subsection{Arguments}{
152 | \if{html}{\out{}}
153 | \describe{
154 | \item{\code{m}}{TidyModule object.}
155 | }
156 | \if{html}{\out{
}}
157 | }
158 | }
159 | \if{html}{\out{}} 160 | \if{html}{\out{}} 161 | \if{latex}{\out{\hypertarget{method-ModStore-getEdges}{}}} 162 | \subsection{Method \code{getEdges()}}{ 163 | Retrieve modules connections. 164 | \subsection{Usage}{ 165 | \if{html}{\out{
}}\preformatted{ModStore$getEdges(m)}\if{html}{\out{
}}
166 | }
167 |
168 | \subsection{Arguments}{
169 | \if{html}{\out{}}
170 | \describe{
171 | \item{\code{m}}{TidyModule object.}
172 | }
173 | \if{html}{\out{
}}
174 | }
175 | }
176 | \if{html}{\out{}} 177 | \if{html}{\out{}} 178 | \if{latex}{\out{\hypertarget{method-ModStore-addEdge}{}}} 179 | \subsection{Method \code{addEdge()}}{ 180 | Add modules connections into ModStore. 181 | An edge is either a connection between a reactive object and a module 182 | or between two modules. 183 | \subsection{Usage}{ 184 | \if{html}{\out{
}}\preformatted{ModStore$addEdge(from, to, mode = "direct", comment = NA)}\if{html}{\out{
}}
185 | }
186 |
187 | \subsection{Arguments}{
188 | \if{html}{\out{}}
189 | \describe{
190 | \item{\code{from}}{list with three elements: m -> module, type -> input or output, port -> port Id.}
191 |
192 | \item{\code{to}}{list with three elements: m -> module, type -> input or output, port -> port Id.}
193 |
194 | \item{\code{mode}}{The type of edge, default to 'direct'.}
195 |
196 | \item{\code{comment}}{Any additional comment.}
197 | }
198 | \if{html}{\out{
}}
199 | }
200 | }
201 | \if{html}{\out{}} 202 | \if{html}{\out{}} 203 | \if{latex}{\out{\hypertarget{method-ModStore-delEdges}{}}} 204 | \subsection{Method \code{delEdges()}}{ 205 | Remove module edges 206 | \subsection{Usage}{ 207 | \if{html}{\out{
}}\preformatted{ModStore$delEdges(m)}\if{html}{\out{
}}
208 | }
209 |
210 | \subsection{Arguments}{
211 | \if{html}{\out{}}
212 | \describe{
213 | \item{\code{m}}{TidyModule object.}
214 | }
215 | \if{html}{\out{
}}
216 | }
217 | }
218 | \if{html}{\out{}} 219 | \if{html}{\out{}} 220 | \if{latex}{\out{\hypertarget{method-ModStore-addMod}{}}} 221 | \subsection{Method \code{addMod()}}{ 222 | Add module into the ModStore. 223 | \subsection{Usage}{ 224 | \if{html}{\out{
}}\preformatted{ModStore$addMod(m)}\if{html}{\out{
}}
225 | }
226 |
227 | \subsection{Arguments}{
228 | \if{html}{\out{}}
229 | \describe{
230 | \item{\code{m}}{TidyModule object.}
231 | }
232 | \if{html}{\out{
}}
233 | }
234 | }
235 | \if{html}{\out{}} 236 | \if{html}{\out{}} 237 | \if{latex}{\out{\hypertarget{method-ModStore-delMod}{}}} 238 | \subsection{Method \code{delMod()}}{ 239 | Delete a module from the ModStore. 240 | \subsection{Usage}{ 241 | \if{html}{\out{
}}\preformatted{ModStore$delMod(m)}\if{html}{\out{
}}
242 | }
243 |
244 | \subsection{Arguments}{
245 | \if{html}{\out{}}
246 | \describe{
247 | \item{\code{m}}{TidyModule object.}
248 | }
249 | \if{html}{\out{
}}
250 | }
251 | }
252 | \if{html}{\out{}} 253 | \if{html}{\out{}} 254 | \if{latex}{\out{\hypertarget{method-ModStore-print}{}}} 255 | \subsection{Method \code{print()}}{ 256 | Print the ModStore object. 257 | \subsection{Usage}{ 258 | \if{html}{\out{
}}\preformatted{ModStore$print()}\if{html}{\out{
}}
259 | }
260 |
261 | }
262 | \if{html}{\out{}} 263 | \if{html}{\out{}} 264 | \if{latex}{\out{\hypertarget{method-ModStore-clone}{}}} 265 | \subsection{Method \code{clone()}}{ 266 | The objects of this class are cloneable with this method. 267 | \subsection{Usage}{ 268 | \if{html}{\out{
}}\preformatted{ModStore$clone(deep = FALSE)}\if{html}{\out{
}}
269 | }
270 |
271 | \subsection{Arguments}{
272 | \if{html}{\out{}}
273 | \describe{
274 | \item{\code{deep}}{Whether to make a deep clone.}
275 | }
276 | \if{html}{\out{
}}
277 | }
278 | }
279 | }
280 |
--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | Apache License
2 | ==============
3 |
4 | _Version 2.0, January 2004_
5 | _<