react_on_rails 11.3.0 → 12.0.0.pre.beta.4

data/docs/misc/doctrine.md

@@ -19,7 +19,7 @@ The React on Rails setup provides several key components related to front-end de
 6. Happiness for us is actively participating in open source, so we want to be where the action is, which is with the npm libraries on github.com.
 7. You can get set up on React on Rails **FAST** using our application generator.
 8. By placing all client-side development inside of the `/client` directory, pure JavaScript developers can productively do development separate from Rails. Instead of Rails APIs, stub APIs on an express server can provide a simple backend, allowing for rapid iteration of UI prototypes.
-9. Just because we're not relying on the Rails asset pipeline for ES6 conversion does not mean that we're deploying Rails apps in any different way. We still use the asset pipeline to include our Webpack compiled JavaScript. This only requires a few small modifications, as explained in our doc [Heroku Deployment](../additional-reading/heroku-deployment.md).
+9. Just because we're not relying on the Rails asset pipeline for ES6 conversion does not mean that we're deploying Rails apps in any different way. We still use the asset pipeline to include our Webpack compiled JavaScript. This only requires a few small modifications, as explained in our doc [Heroku Deployment](docs/basics/heroku-deployment.md).
 
 ## Convention over Configuration
 * React on Rails has taken the hard work out of figuring out the JavaScript tooling that works best with Rails. Not only could you spend lots of time researching different tooling, but then you'd have to figure out how to splice it all together. This is where a lot of "JavaScript fatigue" comes from. The following keep the code clean and consistent:

data/docs/{misc-pending → outdated}/code-splitting.md

@@ -1,6 +1,10 @@
-# Code Splitting
+# Code Splitting (Outdated)
 
-*Note: This document needs updating for Webpack v4, React-Router v4, and using webpacker.*
+_Note: This document is outdated._ Please email [justin@shakacode.com](mailto:justin@shakacode.com) 
+if you would be interested in help with code splitting using
+[loadable-components.com](https://loadable-components.com/docs) with React on Rails.
+
+-----
 
 What is code splitting? From the webpack documentation:
 
@@ -17,11 +21,11 @@ Let's say you're requesting a page that needs to fetch a code chunk from the ser
 > (server) <div data-reactroot="
 <!--This comment is here because the comment beginning on line 13 messes up Sublime's markdown parsing-->
 
-Different markup is generated on the client than on the server. Why does this happen? When you register a component or generator function with `ReactOnRails.register`, react on rails will render the component as soon as the page loads. However, react-router renders a comment while waiting for the code chunk to be fetched from the server. This means that react will tear all of the server rendered code out of the DOM, and then rerender it a moment later once the code chunk arrives from the server, defeating most of the purpose of server rendering.
+Different markup is generated on the client than on the server. Why does this happen? When you register a component or render function with `ReactOnRails.register`, react on rails will render the component as soon as the page loads. However, react-router renders a comment while waiting for the code chunk to be fetched from the server. This means that react will tear all of the server rendered code out of the DOM, and then rerender it a moment later once the code chunk arrives from the server, defeating most of the purpose of server rendering.
 
 ### The solution
 
-To prevent this, you have to wait until the code chunk is fetched before doing the initial render on the client side. To accomplish this, react on rails allows you to register a renderer. This works just like registering a generator function, except that the function you pass takes three arguments: `renderer(props, railsContext, domNodeId)`, and is responsible for calling `ReactDOM.render` or `ReactDOM.hydrate` to render the component to the DOM. React on rails will automatically detect when a generator function takes three arguments, and will not call `ReactDOM.render` or `ReactDOM.hydrate`, instead allowing you to control the initial render yourself. Note, you have to be careful to call `ReactDOM.hydrate` rather than `ReactDOM.render` if you are are server rendering.
+To prevent this, you have to wait until the code chunk is fetched before doing the initial render on the client side. To accomplish this, react on rails allows you to register a renderer. This works just like registering a render function, except that the function you pass takes three arguments: `renderer(props, railsContext, domNodeId)`, and is responsible for calling `ReactDOM.render` or `ReactDOM.hydrate` to render the component to the DOM. React on rails will automatically detect when a render function takes three arguments, and will **not** call `ReactDOM.render` or `ReactDOM.hydrate`, instead allowing you to control the initial render yourself. Note, you have to be careful to call `ReactDOM.hydrate` rather than `ReactDOM.render` if you are are server rendering.
 
 Here's an example of how you might use this in practice:
 
@@ -34,7 +38,7 @@ Here's an example of how you might use this in practice:
 
 #### clientRegistration.js
 ```js
-import ReactOnRails from 'react-on-rails';
+import ReactOnRails from 'node_package/lib/ReactOnRails';
 import NavigationApp from './NavigationApp';
 
 // Note that we're importing a different RouterApp than in serverRegistration.js
@@ -78,7 +82,7 @@ import { Provider } from 'react-redux';
 
 import routes from '../routes/routes';
 
-
+// NOTE how this function takes 3 params, and is thus responsible for calling ReactDOM.render
 const RouterAppRenderer = (props, railsContext, domNodeId) => {
   const store = ReactOnRails.getStore('applicationStore');
   const history = browserHistory;
@@ -130,7 +134,7 @@ If you're going to try to do code splitting with server rendered routes, you'll
 
 The reason is we do server rendering with ExecJS, which is not capable of doing anything asynchronous. It would be impossible to asyncronously fetch a code chunk while server rendering. See [this issue](https://github.com/shakacode/react_on_rails/issues/477) for a discussion.
 
-Also, do not attempt to register a renderer on the server. Instead, register either a generator function or a component. If you register a renderer in the server bundle, you'll get an error when react on rails tries to server render the component.
+Also, do not attempt to register a renderer on the server. Instead, register either a render function or a component. If you register a renderer in the server bundle, you'll get an error when react on rails tries to server render the component.
 
 ## How does Webpack know where to find my code chunks?
 
@@ -146,7 +150,7 @@ config = {
 
 This causes Webpack to prepend the code chunk filename with `/assets/` in the request url. The react on rails sets up the webpack config to put webpack bundles in `app/assets/javascripts/webpack`, and modifies `config/initializers/assets.rb` so that rails detects the bundles. This means that when we prepend the request url with `/assets/`, rails will know what webpack is asking for.
 
-See [rails-assets.md](rails-assets.md) to learn more about static assets.
+See [rails-assets.md](docs/outdated/rails-assets.md) to learn more about static assets.
 
 If you forget to set the public path, webpack will request the code chunk at `/{filename}`. This will cause the request to be handled by the Rails router, which will send back a 404 response, assuming that you don't have a catch-all route. In your javascript console, you'll get the following error:
 

data/docs/{basics → outdated}/how-react-on-rails-works.md

@@ -28,13 +28,17 @@ You can see all this on the source for [reactrails.com](https://www.reactrails.c
 
 ## Building the Bundles
 
-Each time you change your client code, you will need to re-generate the bundles (the webpack-created JavaScript files included in application.js). The included example Foreman `Procfile.dev` files will take care of this for you by starting a webpack process with the watch flag. This will watch your JavaScript code files for changes. 
+Each time you change your client code, you will need to re-generate the bundles (the webpack-created JavaScript files included in application.js). The included example Foreman `Procfile.dev` files will take care of this for you by starting a webpack process with the watch flag. This will watch your JavaScript code files for changes. Alternately, the `rails/webpacker` library also can ensure that your bundles are built. 
 
-Simply run `foreman start -f Procfile.dev`. [Example](spec/dummy/Procfile.static).
+For example, you might create a [Procfile.dev](spec/dummy/Procfile.dev).
 
-On production deployments that use asset precompilation, such as Heroku deployments, React on Rails, by default, will automatically run webpack to build your JavaScript bundles. You configure the command used as `config.build_production_command` in your [config/initializers/react_on_rails.rb](./configuration.md).
+On production deployments that use asset precompilation, such as Heroku deployments, `rails/webpacker`, by default, will automatically run webpack to build your JavaScript bundles, running the command `bin/webpack` in your app.
 
-You can see the source code for what gets added to your precompilation [here](https://github.com/shakacode/react_on_rails/tree/master/lib/tasks/assets.rake). For more information on this topic, see [the doc on Heroku deployment](docs/additional-reading/heroku-deployment.md#more-details-on-precompilation-using-webpack-to-create-javascript-assets).
+However, if you want to run a custom command to run webpack to build your bundles, then you will:
+1. Ensure you do not have a `config/webpack/production.js` file
+1. Define `config.build_production_command` in your [config/initializers/react_on_rails.rb](docs/basics/configuration.md)
+
+Then React on Rails modifies the `assets:precompile` task to run your `build_production_command`.
 
 If you have used the provided generator, these bundles will automatically be added to your `.gitignore` to prevent extraneous noise from re-generated code in your pull requests. You will want to do this manually if you do not use the provided generator.
 

data/docs/{misc-pending → outdated}/manual-installation-overview.md

@@ -14,17 +14,17 @@ The only requirements within this directory for basic React on Rails integration
 1. Your webpack configuration files:
    1. Create outputs in a directory like `/public/webpack`, which is customizable in your `config/initializers/react_on_rails.rb`.
    1. Provide server rendering if you wish to use that feature.
-1. Your JavaScript code "registers" any components and stores per the ReactOnRails APIs of ReactOnRails.register(components) and ReactOnRails.registerStore(stores). See API docs in [README.md](../../README.md) and the [ReactOnRails.js source](../../node_package/src/ReactOnRails.js).
+1. Your JavaScript code "registers" any components and stores per the ReactOnRails APIs of ReactOnRails.register(components) and ReactOnRails.registerStore(stores). See API docs in [README.md](README.md) and the [ReactOnRails.js source](../../node_package/src/ReactOnRails.js).
 1. Set your registration file as an "entry" point in your Webpack configs.
 1. Add the [Manifest plugin](https://github.com/danethurber/webpack-manifest-plugin) to your config. For examples see [dummy config](../../spec/dummy/client/webpack.client.base.config.js).
 The default path: `public/webpack` can be loaded with webpackConfigLoader as shown in the dummy example.
 1. You create scripts in `client/package.json` per the example apps. These are used for building your Webpack assets. Also do this for your top level `package.json`.
 
 ## Rails Steps (outside of /client)
-1. Add  `gem "webpacker"` to the Gemfile, run bundle. The gem provides the `stylesheet_pack_tag` and `javascript_pack_tag` helpers which is used to load the bundled assets to your layouts.[Dummy Example](../../spec/dummy/app/views/layouts/application.html.erb)
-1. Configure the `config/initializers/react_on_rails.rb`. You can adjust some necessary settings and defaults. See file [spec/dummy/config/initializers/react_on_rails.rb](../../spec/dummy/config/initializers/react_on_rails.rb) for a detailed example of configuration, including comments on the different values to configure.
+1. Add  `gem "webpacker"` to the Gemfile, run bundle. The gem provides the `stylesheet_pack_tag` and `javascript_pack_tag` helpers which is used to load the bundled assets to your layouts.[Dummy Example](spec/dummy/app/views/layouts/application.html.erb)
+1. Configure the `config/initializers/react_on_rails.rb`. You can adjust some necessary settings and defaults. See file [spec/dummy/config/initializers/react_on_rails.rb](spec/dummy/config/initializers/react_on_rails.rb) for a detailed example of configuration, including comments on the different values to configure.
 1. Configure your Procfiles per the example apps. These are at the root of your Rails installation.
-1. Configure your top level JavaScript files for inclusion in your layout. You'll want a version that you use for static assets, and you want a file for any files in your setup that are not part of your webpack build. The reason for this is for use with hot-reloading. If you are not using hot reloading, then you only need to configure your `application.js` file to include your Webpack generated files. For more information on hot reloading, see [Hot Reloading of Assets For Rails Development](../additional-reading/hot-reloading-rails-development-asset-pipeline.md)
-1. If you are deploying to Heroku, see [heroku-deployment.md](/docs/additional-reading/heroku-deployment.md)
+1. Configure your top level JavaScript files for inclusion in your layout. You'll want a version that you use for static assets, and you want a file for any files in your setup that are not part of your webpack build. The reason for this is for use with hot-reloading. If you are not using hot reloading, then you only need to configure your `application.js` file to include your Webpack generated files. 
+1. If you are deploying to Heroku, see [heroku-deployment.md](/docs/basics/heroku-deployment.md)
 
 If I missed anything, please submit a PR or file an issue.

data/docs/{additional-reading → outdated}/rails-assets-relative-paths.md

@@ -1,4 +1,4 @@
-*Note: this doc needs updating to reflect how v8.x+ no longer puts Webpack generated files through the asset pipeline. PR's welcome!*
+*Note: this doc reflects using Sprockets for assets and has not been updated for rails/webpacker*
 
 # Using Webpack bundled assets with the Rails Asset Pipeline
 
@@ -77,7 +77,7 @@ Note: _You can output these files in the asset pipeline wherever you see fit. My
 
 Lastly, we will set the publicPath to our file(s). This will be the endpoint on our rails web server that you can visit to reach the asset (if you don't know how this works, read the [intro](#using-webpack-bundled-assets-with-the-rails-asset-pipeline)). If you've been following the previous steps, you know that we set our outputPath for our assets to be absolute at `app/assets/webpack/webpack-assets/`, which your rails app should end up hosting at `/assets/webpack-assets/file-name+hash.ext` when the server is run.
 
-Note: _If you're having a hard time figuring out what an asset's path will be on your rails server, simply run `rake assets:precompile` and `cd public/`. The path from there to your file will then be the path/url on your web server to that asset. On top of this, it is also a good idea to check out [this doc](../misc-pending/rails-assets.md) to understand how `react_on_rails` allows us to access these files after precompilation, when Rails applies another hash onto the asset._
+Note: _If you're having a hard time figuring out what an asset's path will be on your rails server, simply run `rake assets:precompile` and `cd public/`. The path from there to your file will then be the path/url on your web server to that asset. On top of this, it is also a good idea to check out [this doc](docs/outdated/rails-assets.md) to understand how `react_on_rails` allows us to access these files after precompilation, when Rails applies another hash onto the asset._
 
 Our publicPath setting will match the path to our outputted assets on our rails web server. Given our assets in this example will be outputted to `/app/assets/webpack/webpack-assets/` and hosted at `/assets/webpack-assets/`, our publicPath would be:
 
@@ -192,4 +192,4 @@ module.exports = {
 };
 ```
 
-If you'd like to understand how react_on_rails handles these bundled assets after asset precompilation and in production mode, check out: [Rails Assets](../misc-pending/rails-assets.md).
+If you'd like to understand how react_on_rails handles these bundled assets after asset precompilation and in production mode, check out: [Rails Assets](docs/outdated/rails-assets.md).

data/docs/{misc-pending → outdated}/rails-assets.md

@@ -33,21 +33,11 @@ fail to load.
 _If you are interested in learning how to use assets in your React components, read this doc: [Webpack, the Asset Pipeline, and Using Assets w/ React](../additional-reading/rails-assets-relative-paths.md)._
 
 ## The Solution: Symlink Original File Names to New File Names
-React on Rails creates symlinks of non-digested versions (original webpack digested file names) 
-to the Rails deployed digested versions when doing a Rails assets compile. The solution is 
-implemented using `assets:precompile` after-hook in 
-file [lib/tasks/assets.rake](../../lib/tasks/assets.rake)
-The assets for symlinking are defined by `config.symlink_non_digested_assets_regex` in 
-`config/initializers/react_on_rails.rb`.
-
-## Disabling the Symlinking
-To disable symlinks set this parameter to `nil`.
-
+_Note, this solution was removed in v14. If you're intersted in this symlink solution, please create
+a github issue._
 
 ## Example from /spec/dummy
 
-If you run
-
 ```
 cd spec/dummy
 RAILS_ENV=production bundle exec rake assets:precompile

data/docs/tutorial.md

@@ -1,6 +1,8 @@
 # React on Rails Basic Tutorial
 
-This tutorial guides you through setting up a new or existing Rails app with **React on Rails**, demonstrating Rails + React + Redux + Server Rendering. It is updated to 11.2.1.
+*Updated for Ruby 2.7.1, Rails 6.0.3.1, and React on Rails v12.0.0*
+
+This tutorial guides you through setting up a new or existing Rails app with **React on Rails**, demonstrating Rails + React + Redux + Server Rendering.
 
 After finishing this tutorial you will get an application that can do the following (live on Heroku):
 
@@ -17,9 +19,9 @@ By the time you read this, the latest may have changed. Be sure to check the ver
 
 _Note: some of the screen images below show the "npm" command. react_on_rails 6.6.0 and greater uses `yarn`._
 
-## Setting up the environment
+## Setting up your environment
 
-Trying out **React on Rails** is super easy, so long as you have the basic prerequisites. This includes the basics for Rails 5.x and node version 6+. I recommend `rvm` and `nvm` to install Ruby and Node, and [brew](https://brew.sh/) to install [yarn](https://yarnpkg.com/en/docs/install#mac-tab). Rails can be installed as an ordinary gem.
+Trying out **React on Rails** is super easy, so long as you have the basic prerequisites. This includes the basics for Rails 6.x and node version 13+. I recommend `rvm` and `nvm` to install Ruby and Node, and [brew](https://brew.sh/) to install [yarn](https://yarnpkg.com/en/docs/install#mac-tab). Rails can be installed as an ordinary gem.
 
 ```
 nvm install node                # download and install latest stable Node
@@ -27,15 +29,15 @@ nvm alias default node          # make it default version
 nvm list                        # check
 
 brew install yarn               # you can use other installer if desired
-11\.\d+\.\d+
-rvm install 2.5.0               # download and install latest stable Ruby (update to exact version)
-rvm use 2.5.0 --default         # use it and make it default
+rvm install 2.7                 # download and install latest stable Ruby (update to exact version)
+rvm use 2.7 --default           # use it and make it default
 rvm list                        # check
 
 gem install rails               # download and install latest stable Rails
 gem install foreman             # download and install Foreman
 ```
 
+## Create a new Ruby on Rails App
 Then we need to create a fresh Rails application with webpacker react support as following.
 
 First be sure to run `rails -v` and check you are using Rails 5.1.3 or above. If you are using an older version of Rails, you'll need to install webpacker with react per the instructions [here](https://github.com/rails/webpacker).
@@ -43,98 +45,87 @@ First be sure to run `rails -v` and check you are using Rails 5.1.3 or above. If
 ```
 cd <directory where you want to create your new Rails app>
 
-# any name you like for the rails app
-rails new test-react-on-rails --webpack=react 
+# Any name you like for the rails app
+# Skip javascript so will add that next and get the current version 
+rails new --skip-sprockets -J --skip-turbolinks test-react-on-rails-v12-no-sprockets
 
 cd test-react-on-rails
 bundle
 ```
 
-Note: if you are installing React On Rails in an existing app or an app that uses **Rails pre 5.1.3** (*not for Rails > 5.2*), you will need to run these two commands as well:
+## Add the webpacker gem
 
 ```
-bundle exec rails webpacker:install
-bundle exec rails webpacker:install:react
+bundle add webpacker                 
+bundle add react_on_rails
 ```
 
-Add the **React On Rails** gem to your `Gemfile`:
+## Run the webpacker generator
 
 ```
-gem 'react_on_rails', '11.2.1'         # prefer exact gem version to match npm version
+bundle exec rails webpacker:install
+bundle exec rails webpacker:install:react
 ```
 
-Note: Latest released React On Rails version is considered stable. Please use the latest version to ensure you get all the security patches and the best support.
-
-Run `bundle` and commit the git repository (or `rails generate` will not work properly)
-
+Let's commit everything before installing React on Rails.
 
 ```
-bundle
-
 # Here are git commands to make a new git repo and commit everything.
 # Newer versions of Rails create the git repo by default.
 git add -A
 git commit -m "Initial commit"
 ```
 
-Install React on Rails: `rails generate react_on_rails:install` or `rails generate react_on_rails:install --redux`. You need to first git commit your files before running the generator, or else it will generate an error.
+## Add the **React On Rails** gem to your `Gemfile`:
+
+To avoid issues regarding inconsistent gem and npm versions, you should specify the exact versions
+of both the gem and npm package. In other words, don't use the `^` or `~` in the version specifications.
 
 ```
-rails generate react_on_rails:install
-bundle && yarn
+gem 'react_on_rails', '12.0.0'         # prefer exact gem version to match npm version
 ```
 
-Then run server with static client side files:
+Note: The latest released React On Rails version is considered stable. Please use the latest 
+version to ensure you get all the security patches and the best support.
 
-```
-foreman start -f Procfile.dev
-```
+Run `bundle` and commit the changes.
 
-To run with the webpack-dev-server:
-```
-foreman start -f Procfile.dev-server
 ```
+bundle
 
-Visit [http://localhost:3000/hello_world](http://localhost:3000/hello_world) and see your **React On Rails** app running!
-Note, foreman defaults to PORT 5000 unless you set the value of PORT in your environment or in the Procfile.
+git commit -am "Added React on Rails Gem"
+```
 
-## Using a pre-release of rails/webpacker
-Until `rails/webpacker` v4 ships, or if you ever want to try out the master branch, you can modify the React on Rails tutorial instructions slightly. You can see the sequence of commits here. To summarize:
+Install React on Rails: `rails generate react_on_rails:install`. You need to first git commit your files before running the generator, or else it will generate an error.
 
-**Don't run `rails new` with the `--webpack=react` option**. Instead, add the webpacker gem to the Gemfile such that it points to master, like this if `11.2.1` is the version you want.
+Note, using `redux` is no longer recommended as the basic installer uses React Hooks. 
+If you want the redux install: `rails generate react_on_rails:install --redux`
 
-```ruby
-gem 'webpacker', github: "rails/webpacker"
-gem 'react_on_rails', '11.2.1' # always use exact version
 ```
-
-Then run these commands:
-
-```sh
-bundle exec rails webpacker:install
-yarn add "rails/webpacker" # because the installer has a bug that puts in an invalid version in your package.json.
-bundle exec rails webpacker:install:react
-yarn add --dev webpack-dev-server
-run rails generate react_on_rails:install && bundle && yarn
+rails generate react_on_rails:install
 ```
 
-### Custom IP & PORT setup (Cloud9 example)
+Then run server with a static client bundle. Static means that the bundle is saved in your
+public/webpack/packs directory.
 
-In case you are running some custom setup with different IP or PORT you should also edit Procfile.dev. For example to be able to run on free Cloud9 IDE we are putting IP 0.0.0.0 and PORT 8080. The default generated file `Procfile.dev` uses `-p 3000`.
+```
+foreman start -f Procfile.dev
+```
 
-``` Procfile.dev
-web: rails s -p 8080 -b 0.0.0.0
+## To run with the webpack-dev-server:
+```
+foreman start -f Procfile.dev-hmr
 ```
 
-Then visit https://your-shared-addr.c9users.io:8080/hello_world 
+Visit [http://localhost:3000/hello_world](http://localhost:3000/hello_world) and see your **React On Rails** app running!
 
+# HMR vs. React Hot Reloading
 
-## RubyMine
+First, check that the `hmr` and the `inline` options are `true` in your `config/webpacker.yml` file.
 
-It's super important to exclude certain directories from RubyMine or else it will slow to a crawl as it tries to parse all the npm files.
-
-* Generated files, per the settings in your `config/webpacker.yml`, which default to `public/packs` and `public/packs-test`
-* `node_modules`
+The basic setup will have HMR working with the default webpacker setup. The basic
+[HMR](https://webpack.js.org/concepts/hot-module-replacement/), without a special
+React setup, will cause a full page refresh each time you save a file. 
 
 ## Deploying to Heroku
 
@@ -157,17 +148,16 @@ Set heroku to use multiple buildpacks:
 
 ### Swap out sqlite for postgres by doing the following:
 
-1. Delete the line with `sqlite` and replace it with:
+Run these two commands:
 
-```ruby
-   gem 'pg'
 ```
-
-2. Run `bundle`
+bundle remove sqlite3
+bundle add pg
+```
 
 ![07](https://cloud.githubusercontent.com/assets/20628911/17465015/1f2f4042-5cf4-11e6-8287-2fb077550809.png)
 
-3. Replace your `database.yml` file with this (assuming your app name is "ror").
+### Replace your `database.yml` file with this (assuming your app name is "ror").
 
 ```yml
 default: &default
@@ -195,7 +185,6 @@ production:
 Then you need to setup postgres so you can run locally:
 
 ```
-bundle
 rake db:setup
 rake db:migrate
 ```
@@ -219,7 +208,7 @@ Create `/Procfile`. This is what Heroku uses to start your app.
 web: bundle exec puma -C config/puma.rb
 ```
 
-Note, newer versions of Rails create this file automatically. However, the [docs on Heroku](https://devcenter.heroku.com/articles/deploying-rails-applications-with-the-puma-web-server#config) have something a bit different, so please make it conform to those docs. As of 2018-10-13, the docs looked like this:
+Note, newer versions of Rails create this file automatically. However, the [docs on Heroku](https://devcenter.heroku.com/articles/deploying-rails-applications-with-the-puma-web-server#config) have something a bit different, so please make it conform to those docs. As of 2020-06-04, the docs looked like this:
 
 `config/puma.rb`
 ```rb
@@ -240,6 +229,15 @@ on_worker_boot do
 end
 ```
 
+Next, update your `package.json` to specify the version of yarn and node. Add this section:
+
+```json
+  "engines": {
+    "node": "13.9.0",
+    "yarn": "1.22.4"
+  },
+```
+
 Then after all changes are done don't forget to commit them with git and finally you can push your app to Heroku!
 
 ```
@@ -256,7 +254,6 @@ heroku open
 
 and you will see your live app and you can share this URL with your friends. Congrats!
 
-
 ## Turning on Server Rendering
 
 You can turn on server rendering by simply changing the `prerender` option to `true`:
@@ -265,6 +262,16 @@ You can turn on server rendering by simply changing the `prerender` option to `t
 <%= react_component("HelloWorld", props: @hello_world_props, prerender: true) %>
 ```
 
+If you want to test this out with HMR, then you also need to add this line to your
+`config/intializers/react_on_rails.rb`
+
+```ruby
+  config.same_bundle_for_client_and_server = true
+```
+
+More likely, you will create a different build file for server rendering. However, if you want to
+use the same file from the webpack-dev-server, you'll need to add that line.
+
 Then push to Heroku:
 
 ```
@@ -309,7 +316,7 @@ mv app/javascript client
 
 ## Using HMR with the rails/webpacker setup
 
-Start the app using `foreman start -f Procfile.dev-server`.
+Start the app using `foreman start -f Procfile.dev-hmr`.
 
 When you change a JSX file and save, the browser will automatically refresh!
 
@@ -318,11 +325,30 @@ So you get some basics from HMR with no code changes. If you want to go further,
 * https://github.com/rails/webpacker/blob/master/docs/webpack-dev-server.md
 * https://webpack.js.org/configuration/dev-server/
 * https://webpack.js.org/concepts/hot-module-replacement/
-* https://gaearon.github.io/react-hot-loader/getstarted/
-* https://github.com/gaearon/react-hot-loader
 
 React on Rails will automatically handle disabling server rendering if there is only one bundle file created by the Webpack development server by rails/webpacker.
 
+
+### Custom IP & PORT setup (Cloud9 example)
+
+In case you are running some custom setup with different IP or PORT you should also edit Procfile.dev. For example to be able to run on free Cloud9 IDE we are putting IP 0.0.0.0 and PORT 8080. The default generated file `Procfile.dev` uses `-p 3000`.
+
+``` Procfile.dev
+web: rails s -p 8080 -b 0.0.0.0
+```
+
+Then visit https://your-shared-addr.c9users.io:8080/hello_world 
+
+## RubyMine
+
+It's super important to exclude certain directories from RubyMine or else it will slow to a crawl as it tries to parse all the npm files.
+
+* Generated files, per the settings in your `config/webpacker.yml`, which default to `public/packs` and `public/packs-test`
+* `node_modules`
+
+
+
+
 ## Conclusion
 
 * Browse the docs either on the [gitbook](https://shakacode.gitbooks.io/react-on-rails/content/) or in the [docs directory on github](https://github.com/shakacode/react_on_rails/tree/master/docs)