react_on_rails 12.0.0.pre.beta.2 → 12.0.2

data/docs/additional-reading/converting-from-custom-webpack-config-to-rails-webpacker-config.md

@@ -0,0 +1,10 @@
+# Converting from Custom Webpack Config to Rails Webpacker Config
+
+1. Compare your package.json and the dependencies in https://github.com/rails/webpacker/blob/master/package.json#L14-L48
+  and avoid any duplicates. We don't want different versions of the same packages. 
+  We want the versions from rails/webpacker unless we specifically want to override them.
+2. Search the rails/webpacker repo for anything you're not sure about in terms of package names.
+3. run `bin/webpack` and make sure there are zero errors
+4. update webpack plugins and loaders to current or close to current
+5. Make sure that your bin/webpack and bin/webpacker match the latest on 
+https://github.com/rails/webpacker/tree/master/lib/install/bin

data/docs/additional-reading/react-router.md

@@ -39,7 +39,7 @@ For a fleshed out integration of react_on_rails with react-router, check out [Re
 
 # Server Rendering Using React Router V4
 
-Your render function may not return an object with the property `renderedHtml`. Thus, you call 
+Your Render-Function may not return an object with the property `renderedHtml`. Thus, you call 
 renderToString() and return an object with this property.
 
 This example **only applies to server rendering** and should be only used in the server side bundle.

data/docs/additional-reading/recommended-project-structure.md

@@ -0,0 +1,69 @@
+# Recommended Project structure
+
+The React on Rails generator uses the standard `rails/webpacker` convention of this structure:
+
+```yml
+app/javascript:
+  ├── bundles:
+  │   # Logical groups of files that can be used for code splitting
+  │   └── hello-world-bundle.js
+  ├── packs:
+  │   # only webpack entry files here
+  │   └── hello-world-bundle.js
+```
+
+Per the example repo [shakacode/react_on_rails_tutorial_with_ssr_and_hmr_fast_refresh](https://github.com/shakacode/react_on_rails_tutorial_with_ssr_and_hmr_fast_refresh),
+you should consider keeping your codebase mostly consistent with the defaults for [rails/webpacker](https://github.com/rails/webpacker).
+
+## Steps to convert from the generator defaults to use a `/client` directory for source code 
+
+1. Move the directory:
+
+```
+mv app/javascript client
+```
+
+2. Edit your `/config/webpacker.yml` file. Change the `default/source_path`:
+
+```yml
+  source_path: client
+```
+
+## Moving node_modules from `/` to `/client` with a custom webpack setup.
+
+`rails/webpacker` probably doesn't support having your main node_modules directory under `/client`, so only follow these steps if you want to use your own webpack configuration.
+
+1. Move the `/package.json` to `/client/package.json`
+2. Create a `/package.json` that delegates to `/client/package.json`. 
+   ```
+     "scripts": {
+       "heroku-postbuild": "cd ./client && yarn"
+     },
+   ```
+3. If your node_modules directory is not at the top level of the Rails project, then you will need to set the
+ENV value of WEBPACKER_CONFIG to the location of the `config/webpacker.yml` file per [rails/webpacker PR 2561](https://github.com/rails/webpacker/pull/2561).
+
+## CSS, Sass, Fonts, and Images
+Should you move your styling assets to Webpack? Or stick with the plain Rails asset pipeline. It depends!
+
+Here's a good discussion of this option: [Why does Rails 6 include both Webpacker and Sprockets?](https://rossta.net/blog/why-does-rails-install-both-webpacker-and-sprockets.html). 
+
+You have 2 basic choices:
+
+### Simple Rails Way
+This isn't really any technique, as you keep handling all your styling assets using Rails standard tools, such as using the [sass-rails gem](https://rubygems.org/gems/sass-rails/versions/5.0.4). Basically, Webpack doesn't get involved with styling. Your Rails layouts just doing the styling the standard Rails way.
+
+#### Advantages to the Simple Rails Way
+1. Much simpler! There's no changes really from your current processes.
+
+### Using Webpack to Manage Styling Assets
+This technique involves customization of the webpack config files to generate CSS, image, and font assets. 
+
+#### Directory structure
+1. `/client/app/assets`: Assets for CSS for client app.
+1. `/client/app/assets/fonts` and `/client/app/assets/styles`: Globally shared assets for styling. Note, most Sass and image assets will be stored next to the JavaScript files.
+
+#### Advantages to having Webpack Manage Styles
+1. You can use [CSS modules](https://github.com/css-modules/css-modules), which is super compelling once you seen the benefits.
+1. You can use CSS in JS.
+1. You can do hot reloading of your assets. Thus, you do not have to refresh your web page to see asset change, including changing styles.

data/docs/additional-reading/server-rendering-tips.md

@@ -13,7 +13,7 @@ Be sure to use mini_racer. See [issues/428](https://github.com/shakacode/react_o
 - You can conditionally avoid running code that references document by either checking if `window`
   is defined or using the "railsContext" 
   your top level react component. Since the passed in props Hash from the view helper applies to
-  client and server side code, the best way to do this is to use a render function.
+  client and server side code, the best way to do this is to use a Render-Function.
 - If you're serious about server rendering, it's worth the effort to have different entry points for client and server rendering. It's worth the extra complexity. The point is that you have separate files for top level client or server side, and you pass some extra option indicating that rendering is happening server side.
 - You can enable Node.js server rendering via [React on Rails Pro](https://github.com/shakacode/react_on_rails/wiki).
 
@@ -22,6 +22,9 @@ Be sure to use mini_racer. See [issues/428](https://github.com/shakacode/react_o
 1. First be sure your code works with server rendering disabled (`prerender: false`)
 2. Be sure that `config.trace` is true. You will get the server invocation code that renders your component. If you're not using Webpacker, you will also get the whole file used to setup the JavaScript context.
 
+## CSS
+Server bundles must always have CSS Extracted
+
 ## setTimeout, setInterval, and clearTimeout
 
 These methods are polyfilled for server rendering to be no-ops. We log calls to these when in `trace` mode. In the past, some libraries, namely babel-polyfill, did call setTimout. 

data/docs/api/javascript-api.md

@@ -25,10 +25,10 @@ The best source of docs is the main [ReactOnRails.js](https://github.com/shakaco
   /**
    * Main entry point to using the react-on-rails npm package. This is how Rails will be able to
    * find you components for rendering. Components get called with props, or you may use a
-   * "render function" to return a React component or an object with the following shape:
+   * "Render-Function" to return a React component or an object with the following shape:
    * { renderedHtml, redirectLocation, error }.
-   * For server rendering, if you wish to return multiple HTML strings from a render function,
-   * you may return an Object from your render function with a single top level property of
+   * For server rendering, if you wish to return multiple HTML strings from a Render-Function,
+   * you may return an Object from your Render-Function with a single top level property of
    * renderedHtml. Inside this Object, place a key called componentHtml, along with any other
    * needed keys. This is useful when you using side effects libraries like react helmet.
    * Your Ruby code with get this Object as a Hash containing keys componentHtml and any other

data/docs/api/redux-store-api.md

@@ -1,10 +1,10 @@
 # Redux Store
 
-_This redux API is no longer recommended as it prevents dynamic code splitting for performance. Instead, you should use the standard react_component view helper passing in a "render function."_
+_This redux API is no longer recommended as it prevents dynamic code splitting for performance. Instead, you should use the standard react_component view helper passing in a "Render-Function."_
 
 You don't need to use the `redux_store` api to use redux. This api was setup to support multiple calls to `react_component` on one page that all talk to the same redux store.
 
-If you are only rendering one react component on a page, as is typical to do a "Single Page App" in React, then you should _probably_ pass the props to your React component in a "render function."
+If you are only rendering one react component on a page, as is typical to do a "Single Page App" in React, then you should _probably_ pass the props to your React component in a "Render-Function."
 
 Consider using the `redux_store` helper for the two following use cases:
 

data/docs/api/view-helpers-api.md

@@ -22,7 +22,7 @@ Uncommonly used options:
   id: nil,
 ```
 
-- **component_name:** Can be a React component, created using an ES6 class or a render function that returns a React component (or, only on the server side, an object with shape { redirectLocation, error, renderedHtml }), or a "renderer function" that manually renders a React component to the dom (client side only).
+- **component_name:** Can be a React component, created using a React Function Component, an ES6 class or a Render-Function that returns a React component (or, only on the server side, an object with shape { redirectLocation, error, renderedHtml }), or a "renderer function" that manually renders a React component to the dom (client side only). Note, a "renderer function" is a special type of "Render-Function." A "renderer function" takes a 3rd param of a DOM ID.
   All options except `props, id, html_options` will inherit from your `react_on_rails.rb` initializer, as described [here](../basics/configuration.md).
 - **general options:**
   - **props:** Ruby Hash which contains the properties to pass to the react object, or a JSON string. If you pass a string, we'll escape it for you.
@@ -45,7 +45,7 @@ adding meta-tags to a page. It is exactly like react_component except for the fo
 
 1. `prerender: true` is automatically added to options, as this method doesn't make sense for 
    client only rendering.
-2. Your JavaScript render function for server rendering must return an Object rather than a React Component.
+2. Your JavaScript Render-Function for server rendering must return an Object rather than a React Component.
 3. Your view code must expect an object and not a string.
 
 Here is an example of ERB view code:
@@ -98,11 +98,11 @@ You can call `rails_context` or `rails_context(server_side: true|false)` from yo
 
 ### Renderer Functions (function that will call ReactDOM.render or ReactDOM.hydrate)
 
-A "renderer function" is a render function that accepts three arguments (rather than 2): `(props, railsContext, domNodeId) => { ... }`. Instead of returning a React component, a renderer is responsible for installing a callback that will call `ReactDOM.render` (in React 16+, `ReactDOM.hydrate`) to render a React component into the DOM. The "renderer function" is called at the same time the document ready event would instantate the React components into the DOM.
+A "renderer function" is a Render-Function that accepts three arguments (rather than 2): `(props, railsContext, domNodeId) => { ... }`. Instead of returning a React component, a renderer is responsible for installing a callback that will call `ReactDOM.render` (in React 16+, `ReactDOM.hydrate`) to render a React component into the DOM. The "renderer function" is called at the same time the document ready event would instantate the React components into the DOM.
 
 Why would you want to call `ReactDOM.hydrate` yourself? One possible use case is [code splitting](docs/outdated/code-splitting.md). In a nutshell, you don't want to load the React component on the DOM node yet. So you want to install some handler that will call `ReactDOM.hydrate` at a later time. In the case of code splitting with server rendering, the server rendered code has any async code loaded and used to server render. Thus, the client code must also fully load any asynch code before server rendering. Otherwise, the client code would first render partially, not matching the server rendering, and then a second later, the full code would render, resulting in an unpleasant flashing on the screen.
 
-Renderer functions are not meant to be used on the server since there's no DOM on the server. Instead, use a render function. Attempting to server render with a renderer function will throw an error.
+Renderer functions are not meant to be used on the server since there's no DOM on the server. Instead, use a Render-Function. Attempting to server render with a renderer function will throw an error.
 
 ------------
 

data/docs/basics/client-vs-server-rendering.md

@@ -1,5 +1,7 @@
 # Client-Side Rendering vs. Server-Side Rendering
 
+*See also [react-server-rendering.md](./react-server-rendering.md).*
+
 In most cases, you should use the `prerender: false` (default behavior) with the provided helper method to render the React component from your Rails views. In some cases, such as when SEO is vital, or many users will not have JavaScript enabled, you can enable server-rendering by passing `prerender: true` to your helper, or you can simply change the default in `config/initializers/react_on_rails`.
 
 Now the server will interpret your JavaScript. The default is to use [ExecJS](https://github.com/rails/execjs) and pass the resulting HTML to the client. We recommend using [mini_racer](https://github.com/discourse/mini_racer) as ExecJS's runtime.

data/docs/basics/configuration.md

@@ -12,21 +12,27 @@ default: &default
   # public_output_path folder
   manifest: manifest.json
   cache_manifest: false
+  
+  # Source path is used to check if webpack compilation needs to be run for `compile: true`
   source_path: client/app
 
 development:
   <<: *default
-  # generated files for development, in /public/webpack/dev
+  # Generated files for development, in /public/webpack/dev
   public_output_path: webpack/dev
 
 test:
   <<: *default
-  # generated files for tests, in /public/webpack/test
+  # Ensure that webpacker invokes webpack to build files for tests if not using the
+  #   ReactOnRails rspec helper. 
+  compile: true
+
+  # Generated files for tests, in /public/webpack/test
   public_output_path: webpack/test
 
 production:
   <<: *default
-  # generated files for tests, in /public/webpack/production
+  # Generated files for production, in /public/webpack/production
   public_output_path: webpack/production
   cache_manifest: true
 ```
@@ -45,7 +51,7 @@ ReactOnRails.configure do |config|
   # The default is true for development, off otherwise.
   # With true, you get detailed logs of rendering and stack traces if you call setTimout, 
   # setInterval, clearTimout when server rendering.
-  config.trace = Rails.env.development?
+  config.trace = Rails.env.development? # default
 
   # Configure if default DOM IDs have a random value or are fixed.
   # false ==> Sets the dom id to "#{react_component_name}-react-component"
@@ -54,18 +60,17 @@ ReactOnRails.configure do |config|
   # it is convenient to set this to true or else you have to either manually set the ids to 
   # avoid collisions. Most newer apps will have only one instance of a component on a page,
   # so this should be false in most cases.
-  # This value can be overrident for a given call to react_component
-  config.random_dom_id = false # default is true
+  # This value can be overridden for a given call to react_component
+  config.random_dom_id = true # default
 
-  # defaults to "" (top level)
-  #
-  config.node_modules_location = "client" # If using webpacker you should use "".
-
-  # This configures the script to run to build the production assets by webpack . Set this to nil
-  # if you don't want react_on_rails building this file for you.
-  # Note, if you want to use this command then you should remove the file
-  # config/webpack/production.js
-  # If that file exists, React on Rails thinks that you'll use the rails/webpacker bin/webpack compiler.
+  # defaults to "" (top level)	
+  config.node_modules_location = "client" # If using webpacker you should use "".	
+  
+  # This configures the script to run to build the production assets by webpack . Set this to nil	
+  # if you don't want react_on_rails building this file for you.	
+  # Note, if you want to use this command then you should remove the file	
+  # config/webpack/production.js	
+  # If that file exists, React on Rails thinks that you'll use the rails/webpacker bin/webpack compiler.	
   config.build_production_command = "RAILS_ENV=production bin/webpack"
 
   ################################################################################
@@ -210,7 +215,7 @@ Example of a RenderingExtension for custom values in the `rails_context`:
 module RenderingExtension
 
   # Return a Hash that contains custom values from the view context that will get merged with
-  # the standard rails_context values and passed to all calls to render functions used by the
+  # the standard rails_context values and passed to all calls to Render-Functions used by the
   # react_component and redux_store view helpers
   def self.custom_context(view_context)
     {

data/docs/basics/deployment.md

@@ -1,5 +1,4 @@
 # Deployment
 
-- React on Rails puts the necessary precompile steps automatically in the rake precompile step. You can, however, disable this by setting certain values to nil in the [config/initializers/react_on_rails.rb](./configuration.md).
-  - `build_production_command`: Set to nil to turn off the precompilation of the js assets.
-- See the [Heroku Deployment](docs/outdated/heroku-deployment.md) doc for specifics regarding Heroku. The information for Heroku may apply to other deployments.
+- `rails/webpacker` puts the necessary precompile steps automatically in the rake precompile step. 
+- See the [Heroku Deployment](docs/basics/heroku-deployment.md) doc for specifics regarding Heroku. The information for Heroku may apply to other deployments.

data/docs/basics/heroku-deployment.md

@@ -0,0 +1,24 @@
+# Heroku Deployment
+## Heroku buildpacks
+
+React on Rails requires both a ruby environment (for Rails) and a Node environment (for Webpack), so you will need to have Heroku use multiple buildpacks.
+
+Assuming you have downloaded and installed the Heroku command-line utility and have initialized the app, you will need to tell Heroku to use both buildpacks via the command-line:
+
+```
+heroku buildpacks:set heroku/ruby
+heroku buildpacks:add --index 1 heroku/nodejs
+```
+
+For more information, see [Using Multiple Buildpacks for an App](https://devcenter.heroku.com/articles/using-multiple-buildpacks-for-an-app)
+
+## assets:precompile
+
+### rails/webpacker webpack configuration
+If you're using the standard rails/webpacker configuration of webpack, then rails/webpacker
+will automatically modify or create an assets:precompile task to build your assets.
+
+### custom webpack configuration
+If you're a custom webpack configuration, and you **do not have the default
+`config/webpack/production.js`** file, then the `config/initializers/react_on_rails.rb`
+configuration `config.build_production_command` will be used.

data/docs/basics/hmr-and-hot-reloading-with-the-webpack-dev-server.md

@@ -8,22 +8,18 @@ The webpack-dev-server provides:
    abruptly lose any tweaks within the Chrome development tools.
 3. Optional hot-reloading. The older react-hot-loader has been deprecated in 
    favor of [fast-refresh](https://reactnative.dev/docs/fast-refresh).
-   For use with webpack, see [react-refresh-webpack-plugin](https://github.com/pmmmwh/react-refresh-webpack-plugin).
+   For use with webpack, see **Client Side rendering and HMR using react-refresh-webpack-plugin** section bellow or visit [react-refresh-webpack-plugin](https://github.com/pmmmwh/react-refresh-webpack-plugin) for additional details.
 
 If you are ***not*** using server-side rendering (***not*** using `prerender: true`),
 then you can follow all the regular docs for using the `bin/webpack-dev-server` 
 during development.
 
-
 # Server Side Rendering with the Default rails/webpacker bin/webpack-dev-server
 
 If you are using server-side rendering, then you have a couple options. The
 recommended technique is to have a different webpack configuration for server
 rendering.  
 
-
-
-
 ## If you use the same Webpack setup for your server and client bundles 
 If you do use the webpack-dev-server for prerendering, be sure to set the
 `config/initializers/react_on_rails.rb` setting of 
@@ -43,7 +39,64 @@ If you don't configure these two to false, you'll see errors like:
 * "ReferenceError: window is not defined" (if hmr is true)
 * "TypeError: Cannot read property 'prototype' of undefined" (if inline is true)
 
-
-
-
-
+# Client Side rendering with HMR using react-refresh-webpack-plugin
+## Basic installation
+To enable HMR functionality you have to use `./bin/webpack-dev-server`
+1. In `config/webpacker.yml` set **hmr** and **inline** `dev_server` properties to true. 
+    ```
+    dev_server:
+      https: false
+      host: localhost
+      port: 3035
+      public: localhost:3035
+      hmr: true
+      # Inline should be set to true if using HMR
+      inline: true
+    ```
+
+2. Add react refresh packages:
+    ` yarn add @pmmmwh/react-refresh-webpack-plugin react-refresh -D`
+
+3. HMR is for use with the webpack-dev-server, so we only add this for the webpack-dev-server.
+    ```
+    const isWebpackDevServer = process.env.WEBPACK_DEV_SERVER;
+    
+    //plugins
+    if(isWebpackDevServer) {
+      environment.plugins.append(
+         'ReactRefreshWebpackPlugin',
+         new ReactRefreshWebpackPlugin({                 
+                           overlay: {
+                               sockPort: 3035
+                           }
+                       })
+      );  
+    }
+    ```
+    We added overlay.sockedPort option in `ReactRefreshWebpackPlugin` to match the webpack dev-server port specified in config/webpacker.yml. Thats way we make sockjs works properly and suppress error in browser console `GET http://localhost:[port]/sockjs-node/info?t=[xxxxxxxxxx] 404 (Not Found)`. 
+
+4. Add react-refresh plugin in `babel.config.js`
+```
+  module.export = function(api) {
+    return {
+      plugins: [process.env.WEBPACK_DEV_SERVER && 'react-refresh/babel'].filter(Boolean)
+    }
+  }
+```
+That's it :).
+Now Browser should reflect .js along with .css changes without reloading.
+
+If by some reason plugin doesn't work you could revert changes and left only devServer hmr/inline to true affecting only css files.
+
+These plugins are working and tested with 
+   - babel 7
+   - webpacker 5
+   - bootstrap 4
+   - jest 26
+   - core-js 3
+   - node 12.10.0
+   - react-refresh-webpack-plugin@0.4.1
+   - react-refresh 0.8.3 
+   - react_on_rails 11.1.4 
+   
+   configuration.

data/docs/basics/i18n.md

@@ -25,7 +25,7 @@ Here's a summary of adding the I18n functionality.
 
 3. Javascript locale files must be generated before `yarn build`.
 
-  Once you setup `config.i18n_dir` as in the previous step, react_on_rails will automatically do this for testing (if using the `ReactOnRails::TestHelper.configure_rspec_to_compile_assets` and for production deployments if using the [default precompile rake hook](docs/outdated/heroku-deployment.md). 
+  Once you setup `config.i18n_dir` as in the previous step, you will need to make sure `rake react_on_rails:locale` runs before webpack. 
   
   For development, you should adjust your startup scripts (Procfiles) so that they run **`bundle exec rake react_on_rails:locale`** before running any webpack watch process (`yarn run build:development`). 
   
@@ -48,6 +48,7 @@ with `react-intl` supported via js files:
   ```
 
 2. Add `react-intl` & `intl` to `client/package.json`, and remember to `bundle && yarn install`.
+   Versions should be newer than these:
 
   ```js
   "dependencies": {
@@ -93,7 +94,6 @@ with `react-intl` supported via js files:
   ```
   
   # Notes
-  
   * See why using JSON could be better compare to JS if amount of data is hure [ https://v8.dev/blog/cost-of-javascript-2019#json]( https://v8.dev/blog/cost-of-javascript-2019#json).
   * See [Support for Rails' i18n pluralization #1000](https://github.com/shakacode/react_on_rails/issues/1000) for a discussion of issues around pluralization.
-  * [Outdated] You can refer to [react-webpack-rails-tutorial](https://github.com/shakacode/react-webpack-rails-tutorial) and [PR #340](https://github.com/shakacode/react-webpack-rails-tutorial/pull/340), [commmited](https://github.com/shakacode/react-webpack-rails-tutorial/commit/ef369ed9d922aea5116ca7e50208169fd7831389) for a complete example.
+  * *Outdated:* You can refer to [react-webpack-rails-tutorial](https://github.com/shakacode/react-webpack-rails-tutorial) and [PR #340](https://github.com/shakacode/react-webpack-rails-tutorial/pull/340), [commmited](https://github.com/shakacode/react-webpack-rails-tutorial/commit/ef369ed9d922aea5116ca7e50208169fd7831389) for a complete example.

data/docs/basics/installation-into-an-existing-rails-app.md

@@ -7,8 +7,8 @@
 1. Add the following to your Gemfile and `bundle install`. We recommend fixing the version of React on Rails, as you will need to keep the exact version in sync with the version in your `client/package.json` file.
 
    ```ruby
-   gem "react_on_rails", "11.1.4" # Update to the current version
-   gem "webpacker", "~> 3" # Newer versions might be supported
+   gem "react_on_rails", "12.0.0" # Update to the current version
+   gem "webpacker", "~> 5"
    ```
 
 2. Run the following 2 commands to install Webpacker with React. Note, if you are using an older version of Rails than 5.1, you'll need to install webpacker with React per the instructions [here](https://github.com/rails/webpacker).
@@ -57,8 +57,3 @@ $ yarn add react-on-rails --exact
 ```
 
 That will install the latest version and update your package.json. **NOTE:** the `--exact` flag will ensure that you do not have a "~" or "^" for your react-on-rails version in your package.json.
-
-## Webpacker Configuration
-
-React on Rails users should set configuration value `compile` to false, as React on Rails handles compilation for test and production environments.
-

data/docs/basics/react-server-rendering.md

@@ -1,6 +1,9 @@
 # React Server Rendering
 
-See also [Client vs. Server Rendering](./client-vs-server-rendering.md)
+See also [Client vs. Server Rendering](./client-vs-server-rendering.md).
+
+## What is the easiest way to setup a webpack configuration for server-side-rendering?
+See the example webpack setup here: [github.com/shakacode/react_on_rails_tutorial_with_ssr_and_hmr_fast_refresh](https://github.com/shakacode/react_on_rails_tutorial_with_ssr_and_hmr_fast_refresh).
 
 ## What is Server Rendering?
 
@@ -10,13 +13,13 @@ During the Rails rendering of HTML per a browser request, the Rails server will
 
 The default JavaScript interpretter is [ExecJS](https://github.com/rails/execjs). If you want to maximize the perfomance of your server rendering, then you want to use React on Rails Pro which uses NodeJS to do the server rendering. See the [docs for React on Rails Pro](https://github.com/shakacode/react_on_rails/wiki).
 
-See [this note](docs/outdated/how-react-on-rails-works.md#client-side-rendering-vs-server-side-rendering)
-
+See [this note](docs/outdated/how-react-on-rails-works.md#client-side-rendering-vs-server-side-rendering).
 
 ## How do you do Server Rendering with React on Rails?
 1. The `react_component` view helper method provides the `prerender:` option to switch on or off server rendering.
 1. Configure your Webpack setup to create a different server bundle per your needs. While you may reuse the same bundle as for client rendering, this is not common in larger apps for many reasons, such as as code splitting, handling CSS and images, different code paths for React Router on the server vs. client, etc.
-1. You need to configure `config.server_bundle_js_file = "my-server-bundle.js"` in your `config/initializers/react_on_rails.rb`
+1. You need to configure `config.server_bundle_js_file = "server-bundle.js"` in your `config/initializers/react_on_rails.rb`
+1. You should ***not*** put a hash on the server-bundle so that you can easily use the webpack-dev-server for client bundles and have the server bundle generated by a watch process. 
 
 ## Do you need server rendering?
 
@@ -26,4 +29,4 @@ Server rendering is used for either SEO or performance reasons.
 
 1. Never access `window`. Animations, globals on window, etc. just don't make sense when you're trying to run some JavaScript code to output a string of HTML.
 2. JavaScript calls to `setTimeout`, `setInterval`, and `clearInterval` similarly don't make sense when server rendering.
-3. Promises don't work when server rendering. Anything to be done in a promise will never complete. This includes concepts such as asynchronous code loading and AJAX calls. If you want to do server rendering with asynchronous calls, [get in touch](mailto:justin@shakacode.com) as we're working on a Node renderer that handles asynchronous calls.
+3. Promises and file system access don't work when server rendering with ExecJS. Instead, you can use the Node renderer or [React on Rails Pro](https://www.shakacode.com/react-on-rails-pro/).