react_on_rails_pro 16.2.0.beta.20 → 16.2.0.rc.0

data/docs/caching.md

@@ -4,25 +4,28 @@ Caching at the React on Rails level can greatly speed up your app and reduce the
 
 Consult the [Rails Guide on Caching](http://guides.rubyonrails.org/caching_with_rails.html#cache-stores) for details on:
 
-* [Cache Stores and Configuration](http://guides.rubyonrails.org/caching_with_rails.html#cache-stores)
-* [Determination of Cache Keys](http://guides.rubyonrails.org/caching_with_rails.html#cache-keys)
-* [Caching in Development](http://guides.rubyonrails.org/caching_with_rails.html#caching-in-development): **To toggle caching in development**, run `rails dev:cache`.
+- [Cache Stores and Configuration](http://guides.rubyonrails.org/caching_with_rails.html#cache-stores)
+- [Determination of Cache Keys](http://guides.rubyonrails.org/caching_with_rails.html#cache-keys)
+- [Caching in Development](http://guides.rubyonrails.org/caching_with_rails.html#caching-in-development): **To toggle caching in development**, run `rails dev:cache`.
 
 See the [bottom note on confirming and debugging cache keys](#confirming-and-debugging-cache-keys).
 
 ## Overview
+
 React on Rails Pro has caching at 2 levels:
 
-1. "Fragment caching" view helpers, `cached_react_component` and `cached_react_component_hash`.  
-2. Caching of requests for server rendering. 
+1. "Fragment caching" view helpers, `cached_react_component` and `cached_react_component_hash`.
+2. Caching of requests for server rendering.
 
 ### Tracing
+
 If tracing is turned on in your config/initializers/react_on_rails_pro.rb, you'll see timing log messages that begin with `[ReactOnRailsPro:1234]: exec_server_render_js` where 1234 is the process id and `exec_server_render_js` could be a different method being traced.
 
-* **exec_server_render_js**: Timing of server rendering, which may have the prerender_caching turned on.
-* **cached_react_component** and **cached_react_component_hash**: Timing of the cached view helper which maybe calling server rendering.
+- **exec_server_render_js**: Timing of server rendering, which may have the prerender_caching turned on.
+- **cached_react_component** and **cached_react_component_hash**: Timing of the cached view helper which may be calling server rendering.
 
 Here's a sample. Note the second request
+
 ```
 Started GET "/server_side_redux_app_cached" for ::1 at 2018-05-24 22:40:13 -1000
 [ReactOnRailsPro:63422] exec_server_render_js: ReduxApp, 230.7ms
@@ -40,16 +43,19 @@ Completed 200 OK in 19ms (Views: 16.4ms | ActiveRecord: 0.0ms)
 ## Prerender (Server Side Rendering) Caching
 
 ### Why?
-1. Server side rendering is typically done like a stateless functional component, meaning that the result should be idempotent from based on props passed in. 
+
+1. Server-side rendering is typically done like a stateless functional component, meaning that the result should be idempotent based on props passed in.
 1. It's much easier than configuring fragment caching. So long as you have some space in your Rails cache, "it should just work."
 
 ### Why not?
-If you're using regular caching for most componentas (cached_react_component_hash), and you don't want to use caching for other components, then having prerender caching still results in caching for all your rendering calls, increasing the liklihood of premature cache ejection.
 
-In the future, React on Rails will allow stateful server rendering. Thus, your server side JavaScript depend on externalities, such as AJAX calls for
+If you're using regular caching for most components (cached_react_component_hash), and you don't want to use caching for other components, then having prerender caching still results in caching for all your rendering calls, increasing the likelihood of premature cache ejection.
+
+In the future, React on Rails will allow stateful server rendering. Thus, your server-side JavaScript depend on externalities, such as AJAX calls for
 GraphQL. In that case, you will set this caching to false.
 
 ### When?
+
 The largest percentage gains will come from saving the time of server rendering. However, even when not doing server rendering, caching can be effective as the caching will prevent the calculation of the props and the conversion to a string of the prop values.
 
 ### How?
@@ -67,6 +73,7 @@ Server rendering JavaScript evaluation requests are cached by a cache key that c
 2. The JavaScript code to evaluate.
 
 ### Diagnostics
+
 if you're using `react_component_hash`, you'll get 2 extra keys returned:
 
 1. RORP_CACHE_KEY: the prerender cache key
@@ -76,7 +83,7 @@ It can be useful to log these to the rendered HTML page to debug caching issues.
 
 ## React on Rails Fragment Caching
 
-This is very similar to Rails fragment caching. 
+This is very similar to Rails fragment caching.
 
 From the [Rails docs](http://guides.rubyonrails.org/caching_with_rails.html#fragment-caching):
 
@@ -92,19 +99,22 @@ If you're already familiar with Rails fragment caching, the React on Rails imple
 The reasons "why" and "why not" are the same as for basic Rails fragment caching:
 
 ### Why Use Fragment Caching?
+
 1. Next to caching at the controller or HTTP level, this is the fastest type of caching.
 2. The additional complexity to add this with React on Rails Pro is minimal.
 3. The performance gains can be huge.
 4. The load on your Rails server can be far lessened.
 
 ### Why Not Use Fragment Caching?
+
 1. It's tricky to get all the right cache keys. You have to consider any values that can change and cause the rendering to change. See the [Rails docs for cache keys](http://guides.rubyonrails.org/caching_with_rails.html#cache-keys)
 2. Testing is a bit tricky or just not done for fragment caching.
 3. Some deployments require you to clear caches.
 
 ### Considerations for Determining Your Cache Key
+
 1. Consult the [Rails docs for cache keys](http://guides.rubyonrails.org/caching_with_rails.html#cache-keys) for help with cache key definitions.
-2. If your React code depends on any values from the [Rails Context](https://github.com/shakacode/react_on_rails/blob/master/docs/basics/generator-functions-and-railscontext.md#rails-context), such as the `locale` or the URL `location`, then be sure to include such values in your cache key. In other words, if you are using some JavaScript such as `react-router` that depends on your URL, or on a call to `toLocalString(locale)`, then be sure to include such values in your cache key. To find the values that React on Rails uses, use some code like this:
+2. If your React code depends on any values from the [Rails Context](https://github.com/shakacode/react_on_rails/blob/master/docs/core-concepts/render-functions-and-railscontext.md#rails-context), such as the `locale` or the URL `location`, then be sure to include such values in your cache key. In other words, if you are using some JavaScript such as `react-router` that depends on your URL, or on a call to `toLocalString(locale)`, then be sure to include such values in your cache key. To find the values that React on Rails uses, use some code like this:
 
 ```ruby
 the_rails_context = rails_context
@@ -114,14 +124,14 @@ location = the_rails_context[:location]
 
 If you are calling `rails_context` from your controller method, then prefix it like this: `helpers.rails_context` so long as you have react_on_rails > 11.2.2. If less than that, call `helpers.send(:rails_context, server_side: true)`
 
-
-If performance is particulary sensitive, consult the view helper definition for `rails_context`. For example, you can save the cost of calculating the rails_context by directly getting a value:
+If performance is particularly sensitive, consult the view helper definition for `rails_context`. For example, you can save the cost of calculating the rails_context by directly getting a value:
 
 ```ruby
 i18nLocale = I18n.locale
 ```
- 
+
 ### How: API
+
 Here is the doc for helpers `cached_react_component` and `cached_react_component_hash`. Consult the [docs in React on Rails](https://www.shakacode.com/react-on-rails/docs/api/view-helpers-api/) for the non-cached analogies `react_component` and `react_component_hash`. These docs only show the differences.
 
 ```ruby
@@ -131,10 +141,10 @@ Here is the doc for helpers `cached_react_component` and `cached_react_component
   # 1. You must pass the props as a block. This is so that the evaluation of the props is not done
   #    if the cache can be used.
   # 2. Provide the cache_key option
-  #    cache_key: String or Array (or Proc returning a String or Array) containing your cache keys. 
-  #    If prerender is set to true, the server bundle digest will be included in the cache key. 
+  #    cache_key: String or Array (or Proc returning a String or Array) containing your cache keys.
+  #    If prerender is set to true, the server bundle digest will be included in the cache key.
   #    The cache_key value is the same as used for conventional Rails fragment caching.
-  # 3. Optionally provide the `:cache_options` key with a value of a hash including as 
+  # 3. Optionally provide the `:cache_options` key with a value of a hash including as
   #    :compress, :expires_in, :race_condition_ttl as documented in the Rails Guides
   # 4. Provide boolean values for `:if` or `:unless` to conditionally use caching.
 ```
@@ -144,6 +154,7 @@ You can find the `:cache_options` documented in the [Rails docs for ActiveSuppor
 #### API Usage examples
 
 The fragment caching for `react_component`:
+
 ```ruby
 <%= cached_react_component("App", cache_key: [@user, @post], prerender: true) do
   some_slow_method_that_returns_props
@@ -151,6 +162,7 @@ end %>
 ```
 
 Suppose you only want to cache when `current_user.nil?`. Use the `:if` option (`unless:` is analogous):
+
 ```ruby
 <%= cached_react_component("App", cache_key: [@user, @post], prerender: true, if: current_user.nil?) do
   some_slow_method_that_returns_props
@@ -173,11 +185,11 @@ And a fragment caching version for the `react_component_hash`:
 
 <% printable_cache_key = ReactOnRailsPro::Utils.printable_cache_key(result[:RORP_CACHE_KEY]) %>
 <!-- <%= "CACHE_HIT: #{result[:RORP_CACHE_HIT]}, RORP_CACHE_KEY: #{printable_cache_key}" %> -->
-````
-Note in the above example, React on Rails Pro returns both the raw cache key and whether or not there was a cache hit.
+```
 
+Note in the above example, React on Rails Pro returns both the raw cache key and whether or not there was a cache hit.
 
-### Your JavaScript Bundles and Cache Keys 
+### Your JavaScript Bundles and Cache Keys
 
 When doing fragment caching of server rendering with React on Rails Pro, the cache key must reflect
 your React. This is analogous to how Rails puts an MD5 hash of your views in
@@ -191,15 +203,17 @@ case you have, React on Rails handles it.
 
 # Confirming and Debugging Cache Keys
 
-Cache key composition can be confirmed in development mode with the following steps. THe goal is to confirm that some change that should  trigger new cached data actually triggers a new cache key. For example, when the server bundle changes, does that trigger a new cache key for any server rendering?
+Cache key composition can be confirmed in development mode with the following steps. The goal is to confirm that some change that should trigger new cached data actually triggers a new cache key. For example, when the server bundle changes, does that trigger a new cache key for any server rendering?
 
 1. Run `Rails.cache.clear` to clear the cache.
-1. Run `rails dev:cache` to toggle caching in development mode. 
+1. Run `rails dev:cache` to toggle caching in development mode.
 
 You will see a message like:
+
 > Development mode is now being cached.
 
 You might need to check your `config/development.rb`contains the following:
+
 ```ruby
   # Enable/disable caching. By default caching is disabled.
   if Rails.root.join("tmp/caching-dev.txt").exist?
@@ -209,7 +223,7 @@ You might need to check your `config/development.rb`contains the following:
     config.public_file_server.headers = {
       "Cache-Control" => "public, max-age=172800"
     }
-    
+
     # For Rails >= 5.1 determines whether to log fragment cache reads and writes in verbose format as follows:
     config.action_controller.enable_fragment_cache_logging
   else
@@ -225,10 +239,8 @@ You might need to check your `config/development.rb`contains the following:
 
 5. Check the cache entry again. You should have noticed that it changed.
 
-
 To avoid seeing the cache calls to the prerender_caching, you can temporarily set:
+
 ```
 config.prerender_caching = false
 ```
-
-

data/docs/code-splitting-loadable-components.md

@@ -167,7 +167,7 @@ So, hydration will be fired only after all necessary chunks preloads. In this ex
 
 ```js
 import React from 'react';
-import ReactOnRails from 'react-on-rails';
+import ReactOnRails from 'react-on-rails-pro';
 import { hydrateRoot } from 'react-dom/client';
 import { loadableReady } from '@loadable/component';
 import App from './App';
@@ -191,7 +191,7 @@ style tags to the Rails view. In this example below, `ServerApp` is registering
 
 ```js
 import React from 'react';
-import ReactOnRails from 'react-on-rails';
+import ReactOnRails from 'react-on-rails-pro';
 import { ChunkExtractor } from '@loadable/server';
 import App from './App';
 import path from 'path';

data/docs/code-splitting.md

@@ -1,7 +1,8 @@
 # Server-side rendering with code-splitting in React on Rails
+
 by ShakaCode
 
-*Last updated June 13, 2019*
+_Last updated June 13, 2019_
 
 # Deprecated
 
@@ -21,14 +22,16 @@ If the project includes server rendering, then you need to exclude the use of dy
 # Dependencies
 
 Install following libraries in client folder:
+
 ```
 yarn add react-loadable webpack-conditional-loader
 ```
 
 - [react-loadable](https://github.com/jamiebuilds/react-loadable) - take cares of loading and correctly displaying our dynamic components.
-- [webpack-conditional-loader](https://www.npmjs.com/package/webpack-conditional-loader) - allow us conditionally extract parts of our code into different bundles. 
+- [webpack-conditional-loader](https://www.npmjs.com/package/webpack-conditional-loader) - allow us conditionally extract parts of our code into different bundles.
 
 Add `webpack-conditional-loader` to the loaders, like this:
+
 ```js
 {
   test: /\.jsx?$/,
@@ -45,6 +48,7 @@ Add `webpack-conditional-loader` to the loaders, like this:
 ```
 
 Optionally. Create alias for `DynamicImports.js` file in `resolve`:
+
 ```js
 alias: {
   DynamicImports: path.resolve(__dirname, 'client', 'DynamicImports.js'),
@@ -54,6 +58,7 @@ alias: {
 # Simple example of using dynamic components
 
 Consider the component that we want to convert to a dynamic:
+
 ```
 components
   |_ Map
@@ -61,6 +66,7 @@ components
 ```
 
 Let's create `index.jsx` in `Map` directory with the following contents:
+
 ```jsx
 let Component = null;
 
@@ -84,16 +90,16 @@ import Loadable from 'react-loadable';
 
 import Loading from '../Loading';
 
-const load = opts => Loadable({
-  delay: 10000,
-  loading: () => <Loading />,
-  render(loaded, props) {
-    const LoadedComponent = loaded.default;
-    return <LoadedComponent {...props} />;
-  },
-  ...opts,
-});
-
+const load = (opts) =>
+  Loadable({
+    delay: 10000,
+    loading: () => <Loading />,
+    render(loaded, props) {
+      const LoadedComponent = loaded.default;
+      return <LoadedComponent {...props} />;
+    },
+    ...opts,
+  });
 
 /* Here we're wrapping our component in react-loadable HOC */
 const DynamicComponent = load({
@@ -101,7 +107,7 @@ const DynamicComponent = load({
     We need to specify these params: `webpackChunkName`, `modules` and `webpack`
     so react-loadable can load our chunk correctly
   */
-  loader: () => import(/* webpackChunkName: "Map" */'./Map'),
+  loader: () => import(/* webpackChunkName: "Map" */ './Map'),
   modules: ['./Map'],
   webpack: () => [require.resolveWeak('./Map')],
 });
@@ -116,12 +122,15 @@ export default Component;
 ```
 
 Now, if we want to use this component we should import it like this:
+
 ```jsx
-import Map from './components/Map'
+import Map from './components/Map';
 ```
+
 in this case, webpack will load `index.jsx` instead of `Map.jsx` if not some other special order specified.
 
 Also, `IS_SSR=true` must added when creating server side bundle, like this:
+
 ```
 NODE_ENV=production IS_SSR=true webpack --config webpack.config.ssr.prod.js
 ```
@@ -141,33 +150,34 @@ More details can be found in the documentation react-loadable.
 
 But we can get rid of annoying flickering `Loading ...` the first time the page loads. The server renderer has already rendered the necessary components. Therefore, we can transfer this information from the server renderer to the client and preload the necessary modules.
 
-Unfortunately, the way specified in the documentation `react-loadable` does not work for us. 
+Unfortunately, the way specified in the documentation `react-loadable` does not work for us.
 
 Here is another similar method.
 
 For this we use the function `registerDynamicComponentOnServer`. We will place it in the new file `DynamicImports.js`:
 
-
 ```javascript
-export const registerDynamicComponentOnServer = name => {
-  const serverSide = typeof window === 'undefined'
+export const registerDynamicComponentOnServer = (name) => {
+  const serverSide = typeof window === 'undefined';
 
   if (serverSide) {
     if (typeof global.dynamicComponents === 'undefined') {
-      global.dynamicComponents = []
+      global.dynamicComponents = [];
     }
     if (global.dynamicComponents.indexOf(name) === -1) {
-      global.dynamicComponents.push(name)
+      global.dynamicComponents.push(name);
     }
   }
-}
+};
 ```
+
 As you can see from the function body, it runs only for server-side rendering.  
 It simply adds the name of the component to the global array `dynamicComponents` which will be transferred to the client later.
 
 It must be imported into the component that needs to be made dynamic and called in the render method of this component. For example:
 
 components/Map/Map.jsx:
+
 ```javascript
 ...
 import { registerDynamicComponentOnServer } from 'DynamicImports';
@@ -182,39 +192,33 @@ class Map extends React.Component {
 }
 ```
 
-
 Then this global array must be passed to the client.
 To do this, change server entry point as follows:
 
-
 **ServerApp.js**:
+
 ```javascript
 import React from 'react';
-import ReactOnRails from 'react-on-rails';
+import ReactOnRails from 'react-on-rails-pro';
 
 import App from './App';
 
 const ServerApp = (props, railsContext) => {
-
-  const html = renderToString(
-    <App
-      {...props}
-      components={{ MainPage, AboutPage }}
-    />
-  );
+  const html = renderToString(<App {...props} components={{ MainPage, AboutPage }} />);
 
   return {
     html,
     dynamicComponents: JSON.stringify(global.dynamicComponents),
   };
-}
+};
 
-ReactOnRails.register({ App: ServerApp })
+ReactOnRails.register({ App: ServerApp });
 
-export default ServerApp
+export default ServerApp;
 ```
 
 And add our array to view in rails, where our react_component is displayed
+
 ```slim
 <% component = react_component("App", props: {}, prerender: true) %>
 
@@ -237,90 +241,87 @@ To do this, we will create an object with the component names as the keys, and t
 We will add it to `DynamicImports.js` and add a check for the presence of the registered component in this object in the function` registerDynamicComponentOnServer`:
 
 **DynamicImports.js**
+
 ```javascript
 const DynamicImports = {
-  Map: () => import('./components/Map')
-}
+  Map: () => import('./components/Map'),
+};
 
-export const registerDynamicComponentOnServer = name => {
-  const serverSide = typeof window === 'undefined'
+export const registerDynamicComponentOnServer = (name) => {
+  const serverSide = typeof window === 'undefined';
 
   if (serverSide) {
     if (typeof global.dynamicComponents === 'undefined') {
-      global.dynamicComponents = []
+      global.dynamicComponents = [];
     }
     if (typeof DynamicImports[name] === 'undefined') {
-      throw new Error(`Dynamic import not defined for ${name}`)
+      throw new Error(`Dynamic import not defined for ${name}`);
     }
     if (global.dynamicComponents.indexOf(name) === -1) {
-      global.dynamicComponents.push(name)
+      global.dynamicComponents.push(name);
     }
   }
-}
+};
 
-export default DynamicImports
+export default DynamicImports;
 ```
 
 Now we can load the component we need, knowing its name
 For example:
+
 ```javascript
-DynamicImports ['Map'] ()
+DynamicImports['Map']();
 ```
+
 This function will return Promise, which can be used for client rendering.
 
 Change the Client.js to add the preloading of the required components:
 
-
 **Client.js**
+
 ```javascript
 import React from 'react';
 import { hydrateRoot } from 'react-dom/client';
-import Loadable from 'react-loadable'
+import Loadable from 'react-loadable';
 
 import App from './App';
 
-import DynamicImports from 'DynamicImports'
+import DynamicImports from 'DynamicImports';
 
 const App = (props, railsContext, domNodeId) => {
-
   const dynamicComponents =
-    typeof window.dynamicComponents !== 'undefined'
-      ? JSON.parse(window.dynamicComponents)
-      : []
-
+    typeof window.dynamicComponents !== 'undefined' ? JSON.parse(window.dynamicComponents) : [];
 
-  const dynamicImports = []
-  dynamicComponents.map(name => {
-    const dynamicImportInvoked = DynamicImports[name]()
-    dynamicImports.push(dynamicImportInvoked)
-  })
+  const dynamicImports = [];
+  dynamicComponents.map((name) => {
+    const dynamicImportInvoked = DynamicImports[name]();
+    dynamicImports.push(dynamicImportInvoked);
+  });
 
   Promise.all(dynamicImports)
     .then(() => Loadable.preloadReady())
     .then(() => {
       hydrateRoot(
-        <App
-          {...props}
-          components={{ MainPage, AboutPage }}
-        />,
+        <App {...props} components={{ MainPage, AboutPage }} />,
         document.getElementById(domNodeId),
-      )
-    })
-}
+      );
+    });
+};
 
-export default App
+export default App;
 ```
 
 This code requires explanation.
 
 The array with names of rendered components called `dynamicComponents` is used in the map function.  
 In this function, the dynamic import invoked and the result (promise) is added to `dynamicImports` array.
+
 ```javascript
-  const dynamicImports = []
-  dynamicComponents.map(name => {
-    const dynamicImportInvoked = DynamicImports[name]()
-    dynamicImports.push(dynamicImportInvoked)
-  })
+const dynamicImports = [];
+dynamicComponents.map((name) => {
+  const dynamicImportInvoked = DynamicImports[name]();
+  dynamicImports.push(dynamicImportInvoked);
+});
 ```
 
 This array is used in the function `Promise.all`
@@ -334,16 +335,19 @@ Then fires `Loadable.preloadReady()`
 ```javascript
 .then(() => Loadable.preloadReady())
 ```
+
 As in the doc:
 Check for modules that are already loaded in the browser and call the matching LoadableComponent.preload methods.
 
 We need to call this method to initialize already preloaded components.
 
 In addition, note that in the creation of dynamic modules, the `modules` and` webpack` options are used, per the docs for react-loadable.
+
 ```javascript
   modules: ['./AboutPage'],
   webpack: () => [require.resolveWeak('./AboutPage')],
 ```
+
 They are needed to make .preload method work properly
 
 Thus, all dynamic modules will be loaded up to hydrate, and there will be no flicker.

data/docs/configuration.md

@@ -1,6 +1,6 @@
 # Configuration
 
-`config/initializers/react_on_rails_pro.rb`  
+`config/initializers/react_on_rails_pro.rb`
 
 1. You don't need to create a initializer if you are satisfied with the defaults as described below.
 1. Values beginning with `renderer` pertain only to using an external rendering server. You will need to ensure these values are consistent with your configuration for the external rendering server, as given in [JS configuration](https://www.shakacode.com/react-on-rails-pro/docs/node-renderer/js-configuration/)
@@ -32,12 +32,12 @@ ReactOnRailsPro.configure do |config|
   # Remote bundle caching saves deployment time by caching bundles.
   # See /docs/bundle-caching.md for usage and an example of a module called S3BundleCacheAdapter.
   config.remote_bundle_cache_adapter = nil
-  
+
   # ALL OPTIONS BELOW ONLY APPLY IF SERVER RENDERING
 
   # If true, then cache the evaluation of JS for prerendering using the standard Rails cache.
   # Applies to all rendering engines.
-  # Default for `prerender_caching` is false.  
+  # Default for `prerender_caching` is false.
   config.prerender_caching = true
 
   # Retry request in case of time out on the node-renderer side
@@ -77,9 +77,9 @@ ReactOnRailsPro.configure do |config|
   # config.renderer_password = ENV["RENDERER_PASSWORD"]
 
   # Set the `ssr_timeout` configuration so the Rails server will not wait more than this many seconds
-  # for a SSR request to return once issued. 
+  # for a SSR request to return once issued.
   config.ssr_timeout = 5
-  
+
   # If false, then crash if no backup rendering when the remote renderer is not available
   # Can be useful to set to false in development or testing to make sure that the remote renderer
   # works and any non-availability of the remote renderer does not just do ExecJS.
@@ -103,7 +103,7 @@ ReactOnRailsPro.configure do |config|
   config.renderer_http_pool_warn_timeout = 0.25 # seconds
 
   # Snippet of JavaScript to be run right at the beginning of the server rendering process. The code
-  # to be executed must either be self contained or reference some globally exposed module.  
+  # to be executed must either be self contained or reference some globally exposed module.
   # For example, suppose that we had to call `SomeLibrary.clearCache()`between every call to server
   # renderer to ensure no leakage of state between calls. Note, SomeLibrary needs to be globally
   # exposed in the server rendering webpack bundle. This code is visible in the tracing of the calls

data/docs/contributors-info/onboarding-customers.md

@@ -1,6 +1,7 @@
 # Creating a github OAuth Token
 
-*[Document for ShakaCode Staff](https://docs.google.com/document/d/10snzXEWgkorcai76_OxlhjQcDae_WoxRfBCdVbmcQoU/edit)*
+_[Document for ShakaCode Staff](https://docs.google.com/document/d/10snzXEWgkorcai76_OxlhjQcDae_WoxRfBCdVbmcQoU/edit)_
 
 # Customer Steps
+
 See [Installation](../installation.md).

data/docs/contributors-info/releasing.md

@@ -33,6 +33,7 @@ rake release[17.0.0,false,verdaccio]
 ```
 
 This unified script releases all 5 packages together:
+
 - react-on-rails (NPM)
 - react-on-rails-pro (NPM)
 - react-on-rails-pro-node-renderer (NPM)