react_on_rails 12.0.0.pre.beta.2 → 12.0.2

data/docs/basics/render-functions-and-railscontext.md

@@ -15,7 +15,7 @@ side rendering, except for the key `serverSide` based on whether or not you are
 
 While you could manually configure your Rails code to pass the "`railsContext` information" with
 the rest of your "props", the `railsContext` is a convenience because it's passed consistently to
-all invocations of render functions.
+all invocations of Render-Functions.
 
 For example, suppose you create a "render-function" called MyAppComponent.
 

data/docs/basics/rspec-configuration.md

@@ -12,8 +12,7 @@ compiled by webpack before running tests and during production deployment:
 2. **Use the react_on_rails settings and helpers**. Use the settings in `config/initializers/react_on_rails.rb`. Refer to [docs/configuration](./configuration.md).
 
 ```yml
-  config.build_production_command = "RAILS_ENV=production bin/webpack"
-  config.build_test_command = "RAILS_ENV=test bin/webpack"
+  config.build_test_command = "NODE_ENV=test RAILS_ENV=test bin/webpack"
 ``` 
 
 Which should you use? If you're already using the `rails/webpacker` way to configure webpack, then
@@ -45,11 +44,11 @@ If you are using Webpack to build CSS assets, you should do something like this
 ```
 
 Please take note of the following:
-- If you are using Webpacker, be **SURE** to configure the `source_path` in your `config/webpacker.yml` unless you are using the defaults for webpacker. If you are not using webpacker, all files in the node_modules_location are used for your test sources.
+- If you are using Webpacker, be **SURE** to configure the `source_path` in your `config/webpacker.yml` unless you are using the defaults for webpacker. 
 
 - This utility uses your `build_test_command` to build the static generated files. This command **must not** include the `--watch` option. If you have different server and client bundle files, this command **must** create all the bundles. If you are using webpacker, the default value will come from the `config/webpacker.yml` value for the `public_output_path` and the `source_path`
 
-- If you add an older file to your source files, that is already older than the produced output files, no new recompilation is done. The solution to this issue is to clear out your directory of webpack generated files when adding new source files that may have older dates. This can happen when you've built your test generated files and then you sync up your repository files.
+- If you add an older file to your source files, that is already older than the produced output files, no new recompilation is done. The solution to this issue is to clear out your directory of webpack generated files when adding new source files that may have older dates. 
 
 - By default, the webpack processes look in the webpack generated files folder, configured via the `config/webpacker.yml` config values of `public_root_path` and `public_output_path`. If the webpack generated files folder is missing, is empty, or contains files in the `config.webpack_generated_files` list with `mtime`s older than any of the files in your `client` folder, the helper will recompile your assets. 
 

data/docs/basics/upgrading-react-on-rails.md

@@ -6,36 +6,55 @@ If you would like help in migrating between React on Rails versions or help with
 We specialize in helping companies to quickly and efficiently move from versions before 9 to current. The older versions use the Rails asset pipeline to package client assets. The current and recommended way is to use Webpack 4 for asset preparation. You may also need help migrating from the `rails/webpacker`'s Webpack configuration to a better setup ready for Server Side Rendering.
 
 ## Upgrading to v12
-* Make sure that you are on a relatively more recent version of rails and webpacker.
-* If the webpacker webpack config files exist, then React on Rails will not override the default
-  assets:precompile setup by rails/webpacker. The fix is to remove the JS files inside of config/webpack,
-  like config/webpack/production.js.
+### Recent versions
+Make sure that you are on a relatively more recent version of rails and webpacker.
+v12 is tested on Rails 6. It should work on Rails v5. If you're on any older version,
+and v12 doesn't work, please file an issue. 
+
+### Removed Configuration config.symlink_non_digested_assets_regex
+Remove `config.symlink_non_digested_assets_regex` from your `config/initializers/react_on_rails.rb`.
+If you still need that feature, please file an issue.
+
+### i18n default format changed to JSON
 * If you're using the internalization helper, then set `config.i18n_output_format = 'js'`. You can
-  later update to the default JSON format as you will need to update your usage of that file.
+  later update to the default JSON format as you will need to update your usage of that file. A JSON
+  format is more efficient.
 
-* Updated API for ReactOnRails.register.
+### Updated API for `ReactOnRails.register()`
 
 In order to solve the issues regarding React Hooks compatibility, the number of parameters
-for functions is used to determine if you have a render function that will get invoked to
+for functions is used to determine if you have a Render-Function that will get invoked to
 return a React component, or you are registering a React component defined by a function.
+Please see [Render-Functions and the Rails Context](./render-functions-and-railscontext.md) for
+more information on what a Render-Function is.
 
-Registered Objects are of the following types:
-
-##### Correct
-Either of these will work:
-1. Take **2 params** and return **a React function or class component**. A function component is a function
-   that takes zero or one params and returns a React Element, like JSX.
-    ```js
-    export default (props, _railsContext) => () => <Component {...props} />;
-    ```
+##### Update required for registered functions taking exactly 2 params.
 
-2. Take only zero or one params and you return a React Element, often JSX.
+Registered Objects are of the following type:
+1. **Function that takes only zero or one params and you return a React Element**, often JSX.  If the function takes zero or one params, there is **no migration needed** for that function.
     ```js
     export default (props) => <Component {...props} />;
+    ```       
+2. Function that takes **2 params** and returns **a React function or class component**. _Migration is needed as the older syntax returned a React Element._
+   A function component is a function that takes zero or one params and returns a React Element, like JSX. The correct syntax
+   looks like:
+    ```js
+    export default (props, railsContext) => () => <Component {{...props, railsContext}} />;
     ```
+   Note, you cannot return a React Element (JSX). See below for the migration steps. If your function that took **two params returned
+   an Object**, then no migration is required.
+3. Function that takes **3 params** and uses the 3rd param, `domNodeId`, to call `ReactDOM.hydrate`. If the function takes 3 params, there is **no migration needed** for that function.
+4. ES6 or ES5 class. There is **no migration needed**.
+  
+Previously, with case number 2, you could return a React Element.
+
+The fix is simple. Here is an example of the change you'll do:
+
+![2020-07-07_09-43-51 (1)](https://user-images.githubusercontent.com/1118459/86927351-eff79e80-c0ce-11ea-9172-d6855c45e2bb.png)
+ 
 ##### Broken, as this function takes two params and it returns a React Element from a JSX Literal
 ```js
-export default (props, _railsContext) => <Component {...props} />;
+export default (props, railsContext) => <Component {{...props, railsContext} />;
 ```
 
 If you make this mistake, you'll get this warning

data/docs/basics/webpack-configuration.md

@@ -6,8 +6,13 @@
 
 [rails/webpacker](https://github.com/rails/webpacker) is the Ruby gem that mainly gives us 2 things:
 
-1. View helpers for placing the Webpack bundles on your Rails views. React on Rails depends on these view helpers.
-2. A layer of abstraction on top of Webpack customization. This is great for demo projects, but most real world projects will want a customized version of Webpack.
+1. View helpers for placing the webpack bundles on your Rails views. React on Rails depends on these view helpers.
+2. A layer of abstraction on top of Webpack customization. The base setup works great for the client side webpack configuration.
+
+To get a deeper understanding of `rails/webpacker`, watch [RailsConf 2020 CE - Webpacker, It-Just-Works, But How? by Justin Gordon](https://youtu.be/sJLoOpc5LD8)
+
+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).
 
 # React on Rails
 
@@ -15,15 +20,15 @@ Version 9 of React on Rails added support for the rails/webpacker view helpers s
 
 A key decision in your use React on Rails is whether you go with the rails/webpacker default setup or the traditional React on Rails setup of putting all your client side files under the `/client` directory. While there are technically 2 independent choices involved, the directory structure and the mechanism of Webpack configuration, for simplicity sake we'll assume that these choices go together.
 
-## Option 1: Recommended: Traditional React on Rails using the /client directory
+## Option 1: Default Generator Setup: rails/webpacker app/javascript
 
-Until version 9, all React on Rails apps used the `/client` directory for configuring React on Rails in terms of the configuration of Webpack and location of your JavaScript and Webpack files, including the node_modules directory. Version 9 changed the default to `/` for the `node_modules` location using this value in `config/initializers/react_on_rails.rb`: `config.node_modules_location`. The  
+Typical rails/webpacker apps have a standard directory structure as documented [here](https://github.com/rails/webpacker/blob/master/docs/folder-structure.md). If you follow the steps in the the [basic tutorial](../../docs/tutorial.md), you will see this pattern in action. In order to customize the Webpack configuration, you need to consult with the [rails/webpacker Webpack configuration](https://github.com/rails/webpacker/blob/master/docs/webpack.md). 
 
-The [ShakaCode Team](http://www.shakacode.com) _recommends_ this approach for projects beyond the simplest cases as it provides the greatest transparency in your webpack and overall client-side setup. The *big advantage* to this is that almost everything within the `/client` directory will apply if you wish to convert your client-side code to a pure Single Page Application that runs without Rails. This allows you to google for how to do something with Webpack configuration and what applies to a non-Rails app will apply just as well to a React on Rails app.
+The *advantage* of using rails/webpacker to configure Webpack is that there is very little code needed to get started and you don't need to understand really anything about Webpack customization.
 
-The two best examples of this pattern are the [react-webpack-rails-tutorial](https://github.com/shakacode/react-webpack-rails-tutorial) and the integration test example in [spec/dummy](https://github.com/shakacode/react_on_rails/tree/master/spec/dummy).
+## Option 2: Traditional React on Rails using the /client directory
 
-In this case, you don't need to understand the nuances of customization of your Webpack config via the [Webpacker mechanism](./docs/additional-reading/webpack-tips.md).
+Until version 9, all React on Rails apps used the `/client` directory for configuring React on Rails in terms of the configuration of Webpack and location of your JavaScript and Webpack files, including the node_modules directory. Version 9 changed the default to `/` for the `node_modules` location using this value in `config/initializers/react_on_rails.rb`: `config.node_modules_location`. 
 
 You can access values in the `config/webpacker.yml`
 
@@ -36,19 +41,4 @@ You will want consider using some of the same values set in these files:
 * https://github.com/rails/webpacker/blob/master/package/environments/base.js
 * https://github.com/rails/webpacker/blob/master/package/environments/development.js
 
-**Note**, 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).
-
-## Option 2: Default Generator Setup: rails/webpacker app/javascript
-
-Typical rails/webpacker apps have a standard directory structure as documented [here](https://github.com/rails/webpacker/blob/master/docs/folder-structure.md). If you follow the steps in the the [basic tutorial](../../docs/tutorial.md), you will see this pattern in action. In order to customize the Webpack configuration, you need to consult with the [rails/webpacker Webpack configuration](https://github.com/rails/webpacker/blob/master/docs/webpack.md). 
-
-The *advantage* of using rails/webpacker to configure Webpack is that there is very little code needed to get started and you don't need to understand really anything about Webpack customization. The *big disadvantage* to this is that you will need to learn the ins and outs of the [rails/webpacker way to customize Webpack](https://github.com/rails/webpacker/blob/master/docs/webpack.md) which differs from the plain [Webpack way](https://webpack.js.org/).
-
-Overall, consider carefully if you prefer the `rails/webpacker` directory structure and Webpack configuration, over the placement of all client side files within the `/client` directory along with conventional Webpack configuration. Once again, the `/client` directory setup is recommended.
-
-You can find more details on this topic in [Recommended Project Structure](./recommended-project-structure.md). 
- 
-See [Issue 982: Tutorial Generating Correct Project Structure?](https://github.com/shakacode/react_on_rails/issues/982) to discuss this issue.
 
-For more details on project setup, see [Recommended Project Structure](./docs/basics/recommended-project-structure.md).

data/docs/misc/doctrine.md

@@ -19,13 +19,12 @@ 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](docs/outdated/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:
 * [Style Guide](../coding-style/style.md)
 * [linters](../contributor-info/linters.md)
-* [Recommended Project Structure](../basics/recommended-project-structure.md)
 
 We're big believers in this quote from the Rails Doctrine: 
 

data/docs/outdated/code-splitting.md

@@ -21,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 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.
+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 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.
+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:
 
@@ -134,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 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.
+Also, do not attempt to register a renderer function 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?
 

data/docs/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.dev).
+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](docs/basics/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/outdated/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/outdated/manual-installation-overview.md

@@ -25,6 +25,6 @@ The default path: `public/webpack` can be loaded with webpackConfigLoader as sho
 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. 
-1. If you are deploying to Heroku, see [heroku-deployment.md](/docs/outdated/heroku-deployment.md)
+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/outdated/rails-assets.md

@@ -36,13 +36,6 @@ _If you are interested in learning how to use assets in your React components, r
 _Note, this solution was removed in v14. If you're intersted in this symlink solution, please create
 a github issue._
 
-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`.
-
 ## Example from /spec/dummy
 
 ```

data/docs/tutorial.md

@@ -1,5 +1,11 @@
 # React on Rails Basic Tutorial
 
+-----
+
+**August 2, 2020**: See the example repo of [React on Rails Tutorial With SSR, HMR fast refresh, and TypeScript](https://github.com/shakacode/react_on_rails_tutorial_with_ssr_and_hmr_fast_refresh) for a new way to setup the creation of your SSR bundle with `rails/webpacker`. This file will be update shortly. Most of it is still relevant.
+
+-----
+
 *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.

data/lib/generators/react_on_rails/templates/base/base/config/initializers/react_on_rails.rb

@@ -23,6 +23,8 @@ ReactOnRails.configure do |config|
   # with rspec then this controls what yarn command is run
   # to automatically refresh your webpack assets on every test run.
   #
+  # Alternately, you can remove the `ReactOnRails::TestHelper.configure_rspec_to_compile_assets`
+  # and set the config/webpacker.yml option for test to true.
   config.build_test_command = "RAILS_ENV=test bin/webpack"
 
   ################################################################################

data/lib/react_on_rails/configuration.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
+
 module ReactOnRails
   def self.configure
     yield(configuration)
@@ -107,10 +109,46 @@ module ReactOnRails
       check_i18n_yml_directory_exists
       check_server_render_method_is_only_execjs
       error_if_using_webpacker_and_generated_assets_dir_not_match_public_output_path
+      check_deprecated_settings
     end
 
     private
 
+    def check_deprecated_settings
+      if build_production_command.present? &&
+         ReactOnRails::WebpackerUtils.webpacker_webpack_production_config_exists?
+        msg = <<~MSG
+          Setting ReactOnRails configuration for `build_production_command` is
+          not necessary if you have config/webpack/production.js. When that file
+          exists, React on Rails DOES NOT modify the standard assets:precompile.
+          If you want React on Rails to modify to the standard assets:precompile
+          to use your config/initializers/react_on_rails.rb config.build_production_command
+          then delete the config/webpack/production.js.
+        MSG
+        Rails.logger.warn(msg)
+      end
+      #
+      # msg = <<~MSG
+      #   ReactOnRails configuration for `build_production_command` is removed.
+      #   Move this command into `bin/webpack` converting the script to a shell script.
+      # MSG
+      # raise ReactOnRails::Error, msg
+      # Commenting out until v13 when
+      # https://github.com/rails/webpacker/issues/2640 gets resolved
+      # if node_modules_location.present?
+      #   Rails.logger.warn("ReactOnRails configuration for `node_modules_location` is deprecated. "\
+      #    "Instead, prepend a `cd client` (or whichever location) before your test command.")
+      # end
+      #
+      # return unless build_production_command.present?
+      #
+      # msg = <<~MSG
+      #   ReactOnRails configuration for `build_production_command` is removed.
+      #   Move this command into `bin/webpack` converting the script to a shell script.
+      # MSG
+      # raise ReactOnRails::Error, msg
+    end
+
     def error_if_using_webpacker_and_generated_assets_dir_not_match_public_output_path
       return unless ReactOnRails::WebpackerUtils.using_webpacker?
 
@@ -122,12 +160,12 @@ module ReactOnRails
         Rails.logger.warn("You specified generated_assets_dir in `config/initializers/react_on_rails.rb` "\
         "with Webpacker. Remove this line from your configuration file.")
       else
-        msg = <<-MSG.strip_heredoc
-        Error configuring /config/initializers/react_on_rails.rb: You are using webpacker
-        and your specified value for generated_assets_dir = #{generated_assets_dir}
-        that does not match the value for public_output_path specified in
-        webpacker.yml = #{webpacker_public_output_path}. You should remove the configuration
-        value for "generated_assets_dir" from your config/initializers/react_on_rails.rb file.
+        msg = <<~MSG
+          Error configuring /config/initializers/react_on_rails.rb: You are using webpacker
+          and your specified value for generated_assets_dir = #{generated_assets_dir}
+          that does not match the value for public_output_path specified in
+          webpacker.yml = #{webpacker_public_output_path}. You should remove the configuration
+          value for "generated_assets_dir" from your config/initializers/react_on_rails.rb file.
         MSG
         raise ReactOnRails::Error, msg
       end
@@ -214,3 +252,4 @@ module ReactOnRails
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/react_on_rails/helper.rb

@@ -17,13 +17,13 @@ module ReactOnRails
 
     COMPONENT_HTML_KEY = "componentHtml"
 
-    # react_component_name: can be a React function or class component or a "render function".
-    # "render functions" differ from a React function in that they take two parameters, the
+    # react_component_name: can be a React function or class component or a "Render-Function".
+    # "Render-Functions" differ from a React function in that they take two parameters, the
     #   props and the railsContext, like this:
     #
     #   let MyReactComponentApp = (props, railsContext) => <MyReactComponent {...props}/>;
     #
-    #   Alternately, you can define the render function with an additional property
+    #   Alternately, you can define the Render-Function with an additional property
     #   `.renderFunction = true`:
     #
     #   let MyReactComponentApp = (props) => <MyReactComponent {...props}/>;
@@ -79,7 +79,7 @@ module ReactOnRails
           Value:
           #{server_rendered_html}
 
-          If you're trying to use a render function to return a Hash to your ruby view code, then use
+          If you're trying to use a Render-Function to return a Hash to your ruby view code, then use
           react_component_hash instead of react_component and see
           https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
           for an example of the JavaScript code.
@@ -93,7 +93,7 @@ module ReactOnRails
     # It is exactly like react_component except for the following:
     # 1. prerender: true is automatically added, 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 the view code:
@@ -124,10 +124,10 @@ module ReactOnRails
         )
       else
         msg = <<~MSG
-          render function used by react_component_hash for #{component_name} is expected to return
+          Render-Function used by react_component_hash for #{component_name} is expected to return
           an Object. See https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
           for an example of the JavaScript code.
-          Note, your render function must either take 2 params or have the property
+          Note, your Render-Function must either take 2 params or have the property
           `.renderFunction = true` added to it to distinguish it from a React Function Component.
         MSG
         raise ReactOnRails::Error, msg
@@ -240,7 +240,7 @@ module ReactOnRails
     end
 
     # This is the definitive list of the default values used for the rails_context, which is the
-    # second parameter passed to both component and store render functions.
+    # second parameter passed to both component and store Render-Functions.
     # This method can be called from views and from the controller, as `helpers.rails_context`
     #
     # rubocop:disable Metrics/AbcSize

data/lib/react_on_rails/test_helper/webpack_assets_compiler.rb

@@ -6,6 +6,23 @@ module ReactOnRails
   module TestHelper
     class WebpackAssetsCompiler
       def compile_assets
+        if ReactOnRails.configuration.build_test_command.blank?
+          msg = <<~MSG
+            You are using the React on Rails test helper. 
+            Either you used:
+              ReactOnRails::TestHelper.configure_rspec_to_compile_assets or
+              ReactOnRails::TestHelper.ensure_assets_compiled
+            but you did not specify the config.build_test_command
+
+            React on Rails is aborting your test run
+
+            If you wish to use the config/webpacker.yml compile option for tests
+            them remove your call to the ReactOnRails test helper.
+          MSG
+          puts Rainbow(msg).red
+          exit!(1)
+        end
+
         puts "\nBuilding Webpack assets..."
 
         cmd = ReactOnRails::Utils.prepend_cd_node_modules_directory(

data/lib/react_on_rails/utils.rb

@@ -71,7 +71,11 @@ module ReactOnRails
       # 1. Using same bundle for both server and client, so server bundle will be hashed in manifest
       # 2. Using a different bundle (different Webpack config), so file is not hashed, and
       #    bundle_js_path will throw so the default path is used without a hash.
-      # 3. Not using webpacker, and this method returns the bundle_js_file_path
+      # 3. The third option of having the server bundle hashed and a different configuration than
+      #    the client bundle is not supported for 2 reasons:
+      #    a. The webpack manifest plugin would have a race condition where the same manifest.json
+      #       is edited by both the webpack-dev-server
+      #    b. There is no good reason to hash the server bundle name.
       return @server_bundle_path if @server_bundle_path && !Rails.env.development?
 
       bundle_name = ReactOnRails.configuration.server_bundle_js_file

data/lib/react_on_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReactOnRails
-  VERSION = "12.0.0-beta.2"
+  VERSION = "12.0.2"
 end