Loading things before the UI (resolving hard dependencies on global.r)

[D3SL]

I've seen from previous issues that Golem is adamantly opposed to the use of global.r, which can be accommodated with varying degrees of difficulty for anything that can be moved to server.r. What I can't figure out is how to refactor things that need to be loaded before the UI as well.

I use tidymodules for modules. It's the R6 class object approach but beefed up, with both the server and the UI built right in to each object. This means that I need to call module_name$new("foo") in global.r in order for the UI element to be ready in ui.r by the time it gets to mod("foo")$ui().

Is there a clean reliable way to do this that doesn't rely on hacky solutions like in #6 ?

[D3SL]

@ColinFay Removing the ability to load anything before ui.r fundamentally breaks core Shiny functionality, breaks any package that makes use of what Golem broke, and introduces a soft-break to every single package that depends on Shiny and wasn't built downstream from Golem. It's on the same level as a package breaking by-reference modification when loaded, leading to data.table and all other packages that depend on that base R functionality being broken outright or having a soft-break waiting to happen.

I would maintain that "Golem fundamentally breaks any app where objects need to be instantiated before ui.r" is very much an issue and not a discussion. A discussion post can definitely be started about whether or not it's appropriate for a package to fundamentally break its parent and every other package dependent on that parent without extremely clear up front disclosure though.

[ColinFay]

Hey @D3SL.

Let's take a step back.

Packages are a core functionality in the R universe.
When using a package, you launch this package in the very same way that you are currently launching a {golem} based app.

Let's say then that you're building a package that contains a function called arrange(). This is the first in your list of script, called arrange.R. Then in this function, you need something in xyz.R. How do you do this? Yes, this question is the same for any package, not just {golem} based app, and there is a standard R approach to do exactly that.

To do what you cant to do with R6, you can use the @include roxygen skeleton, that will generate a Collate entry in the DESCRIPTION file, and R will load the file in a specific order. Please see https://roxygen2.r-lib.org/reference/update_collate.html.

Another approach would be to define your R6 class as data object: https://r-pkgs.org/data.html

So to sum up, {golem} doesn't remove the ability to load everything before the ui.R. You can definitely do this using a standard R package approach, and if you need one script to be explicitly loaded before app_ui.R, you can use the @include roxygen tag.

[asadow]

@ColinFay I think a section on this in the book would be great. Especially your recommendations below:

Here is the methodology for integrating what you've got in globals.R inside your golem app:

- all the datasets that are fixed should be added as a package dataset 
- functions should be integrated as package functions 
- things that need to be launched at runtime should be listed in the app_server function

You can also use golem_opts for things needed at runtime, to have something like run_app(param = this). 

Best, 
Colin

_Originally posted by @ColinFay in https://github.com/ThinkR-open/golem/issues/6#issuecomment-583559626_

Edit: It'd be great to also have some recommendations on handling no visible binding for global variable and no visible global function definition that results from having function definitions and objects in app_server() e.g.