react_on_rails 13.4.0 → 14.0.0

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

@@ -1,102 +0,0 @@
-# Redux Store
-
-_This redux API is no longer recommended as it prevents dynamic code splitting for performance. Instead, you should use the standard react_component view helper passing in a "Render-Function."_
-
-You don't need to use the `redux_store` api to use redux. This api was setup to support multiple calls to `react_component` on one page that all talk to the same redux store.
-
-If you are only rendering one react component on a page, as is typical to do a "Single Page App" in React, then you should _probably_ pass the props to your React component in a "Render-Function."
-
-Consider using the `redux_store` helper for the two following use cases:
-
-1. You want to have multiple React components accessing the same store at once.
-2. You want to place the props to hydrate the client side stores at the very end of your HTML, probably server rendered, so that the browser can render all earlier HTML first. This is particularly useful if your props will be large. However, you're probably better off using [React on Rails Pro](https://github.com/shakacode/react_on_rails/wiki) if you're at all concerned about performance.
-
-## Multiple React Components on a Page with One Store
-
-You may wish to have 2 React components share the same the Redux store. For example, if your navbar is a React component, you may want it to use the same store as your component in the main area of the page. You may even want multiple React components in the main area, which allows for greater modularity. Also, you may want this to work with Turbolinks to minimize reloading the JavaScript.
-
-A good example of this would be something like a notifications counter in a header. As each notification is read in the body of the page, you would like to update the header. If both the header and body share the same Redux store, then this is trivial. Otherwise, we have to rely on other solutions, such as the header polling the server to see how many unread notifications exist.
-
-Suppose the Redux store is called `appStore`, and you have 3 React components that each needs to connect to a store: `NavbarApp`, `CommentsApp`, and `BlogsApp`. I named them with `App` to indicate that they are the registered components.
-
-You will need to make a function that can create the store you will be using for all components and register it via the `registerStore` method. Note: this is a **storeCreator**, meaning that it is a function that takes (props, location) and returns a store:
-
-```js
-function appStore(props, railsContext) {
-  // Create a hydrated redux store, using props and the railsContext (object with
-  // Rails contextual information).
-  return myAppStore;
-}
-
-ReactOnRails.registerStore({
-  appStore
-});
-```
-
-When registering your component with React on Rails, you can get the store via `ReactOnRails.getStore`:
-
-```js
-// getStore will initialize the store if not already initialized, so creates or retrieves store
-const appStore = ReactOnRails.getStore("appStore");
-return (
-  <Provider store={appStore}>
-    <CommentsApp />
-  </Provider>
-);
-```
-
-From your Rails view, you can use the provided helper `redux_store(store_name, props)` to create a fresh version of the store (because it may already exist if you came from visiting a previous page). Note: for this example, since we're initializing this from the main layout, we're using a generic name of `@react_props`. In other words, the Rails controller would set `@react_props` to the properties to hydrate the Redux store.
-
-**app/views/layouts/application.html.erb**
-
-```erb
-...
-<%= redux_store("appStore", props: @react_props) %>;
-<%= react_component("NavbarApp") %>
-yield
-...
-```
-
-Components should be created as [stateless function(al) components](https://facebook.github.io/react/docs/reusable-components.html#stateless-functions). Since you can pass in initial props via the helper `redux_store`, you do not need to pass any props directly to the component. Instead, the component hydrates by connecting to the store.
-
-**_comments.html.erb**
-
-```erb
-<%= react_component("CommentsApp") %>
-```
-
-**_blogs.html.erb**
-
-```erb
-<%= react_component("BlogsApp") %>
-```
-
-*Note:* You will not be doing any partial updates to the Redux store when loading a new page. When the page content loads, React on Rails will rehydrate a new version of the store with whatever props are placed on the page.
-
-## Controller Extension
-
-Include the module `ReactOnRails::Controller` in your controller, probably in ApplicationController. This will provide the following controller method, which you can call in your controller actions:
-
-`redux_store(store_name, props: {})`
-
-- **store_name:** A name for the store. You'll refer to this name in 2 places in your JavaScript:
-  1. You'll call `ReactOnRails.registerStore({storeName})` in the same place that you register your components.
-  2. In your component definition, you'll call `ReactOnRails.getStore('storeName')` to get the hydrated Redux store to attach to your components.
-- **props:**  Named parameter `props`. ReactOnRails takes care of setting up the hydration of your store with props from the view.
-
-For an example, see [spec/dummy/app/controllers/pages_controller.rb](https://github.com/shakacode/react_on_rails/tree/master/spec/dummy/app/controllers/pages_controller.rb). Note: this is preferable to using the equivalent view_helper `redux_store` in that you can be assured that the store is initialized before your components.
-
-## View Helper
-
-`redux_store(store_name, props: {})`
-
-This method has the same API as the controller extension. **HOWEVER**, we recommend the controller extension instead because the Rails executes the template code in the controller action's view file (`erb`, `haml`, `slim`, etc.) before the layout. So long as you call `redux_store` at the beginning of your action's view file, this will work. However, it's an easy mistake to put this call in the wrong place. Calling `redux_store` in the controller action ensures proper load order, regardless of where you call this in the controller action. Note: you won't know of this subtle ordering issue until you server render and you find that your store is not hydrated properly.
-
-`redux_store_hydration_data`
-
-Place this view helper (no parameters) at the end of your shared layout so ReactOnRails will render the redux store hydration data. Since we're going to be setting up the stores in the controllers, we need to know where on the view to put the client-side rendering of this hydration data, which is a hidden div with a matching class that contains a data props. For an example, see [spec/dummy/app/views/layouts/application.html.erb](https://github.com/shakacode/react_on_rails/tree/master/spec/dummy/app/views/layouts/application.html.erb).
-
-# More Details
-
-* [lib/react_on_rails/controller.rb](https://github.com/shakacode/react_on_rails/tree/master/lib/react_on_rails/controller.rb) source
-* [lib/react_on_rails/helper.rb](https://github.com/shakacode/react_on_rails/tree/master/lib/react_on_rails/helper.rb) source

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

@@ -1,133 +0,0 @@
-# View and Controller Helpers
-##  View Helpers API
-
-Once the bundled files have been generated in your `app/assets/webpack` folder and you have registered your components, you will want to render these components on your Rails views using the included helper method, [`react_component`](https://www.shakacode.com/react-on-rails/docs/api/view-helpers-api/#react_component).
-
-------------
-
-### react_component
-
-```ruby
-react_component(component_name,
-                props: {},
-                prerender: nil)
-                html_options: {})
-```
-
-Uncommonly used options:
-```
-  trace: nil,
-  replay_console: nil,
-  raise_on_prerender_error: nil,
-  id: nil,
-```
-
-- **component_name:** Can be a React component, created using a React Function Component, an ES6 class or a Render-Function that returns a React component (or, only on the server side, an object with shape { redirectLocation, error, renderedHtml }), or a "renderer function" that manually renders a React component to the dom (client side only). Note, a "renderer function" is a special type of "Render-Function." A "renderer function" takes a 3rd param of a DOM ID.
-  All options except `props, id, html_options` will inherit from your `react_on_rails.rb` initializer, as described [here](https://www.shakacode.com/react-on-rails/docs/guides/configuration/).
-- **general options:**
-  - **props:** Ruby Hash which contains the properties to pass to the react object, or a JSON string. If you pass a string, we'll escape it for you.
-  - **prerender:** enable server-side rendering of a component. Set to false when debugging!
-  - **auto_load_bundle:** will automatically load the bundle for component by calling `append_javascript_pack_tag` and `append_stylesheet_pack_tag` under the hood.
-  - **id:** Id for the div, will be used to attach the React component. This will get assigned automatically if you do not provide an id. Must be unique.
-  - **html_options:** Any other HTML options get placed on the added div for the component. For example, you can set a class (or inline style) on the outer div so that it behaves like a span, with the styling of `display:inline-block`. You may also use an option of `tag: "span"` to replace the use of the default DIV tag to be a SPAN tag.
-  - **trace:** set to true to print additional debugging information in the browser. Defaults to true for development, off otherwise. Only on the **client side** will you will see the `railsContext` and your props.
-  - **random_dom_id:** True to automatically generate random dom ids when using multiple instances of the same React component on one Rails view.
-- **options if prerender (server rendering) is true:**
-  - **replay_console:** Default is true. False will disable echoing server-rendering logs to the browser. While this can make troubleshooting server rendering difficult, so long as you have the configuration of `logging_on_server` set to true, you'll still see the errors on the server.
-  - **logging_on_server:** Default is true. True will log JS console messages and errors to the server.
-  - **raise_on_prerender_error:** Default is false. True will throw an error on the server side rendering. Your controller will have to handle the error.
-
--------------
-
-### react_component_hash
-
-`react_component_hash` is used to return multiple HTML strings for server rendering, such as for
-adding meta-tags to a page. It is exactly like react_component except for the following:
-
-1. `prerender: true` is automatically added to options, as this method doesn't make sense for
-   client only rendering.
-2. Your JavaScript Render-Function for server rendering must return an Object rather than a React Component.
-3. Your view code must expect an object and not a string.
-
-Here is an example of ERB view code:
-
-```erb
-  <% react_helmet_app = react_component_hash("ReactHelmetApp", prerender: true,
-                                             props: { helloWorldData: { name: "Mr. Server Side Rendering"}},
-                                             id: "react-helmet-0", trace: true) %>
-  <% content_for :title do %>
-    <%= react_helmet_app['title'] %>
-  <% end %>
-  <%= react_helmet_app["componentHtml"] %>
-```
-
-And here is the JavaScript code:
-
-```js
-export default (props, _railsContext) => {
-  const componentHtml = renderToString(<ReactHelmet {...props} />);
-  const helmet = Helmet.renderStatic();
-
-  const renderedHtml = {
-    componentHtml,
-    title: helmet.title.toString(),
-  };
-  return { renderedHtml };
-};
-```
-
-------------
-
-### cached_react_component and cached_react_component_hash
-Fragment caching is a [React on Rails Pro](https://github.com/shakacode/react_on_rails/wiki) feature. The API is the same as the above, but for 2 differences:
-
-1. The `cache_key` takes the same parameters as any Rails `cache` view helper.
-1. The **props** are passed via a block so that evaluation of the props is not done unless the cache is broken. Suppose you put your props calculation into some method called `some_slow_method_that_returns_props`:
-
-```ruby
-<%= cached_react_component("App", cache_key: [@user, @post], prerender: true) do
-  some_slow_method_that_returns_props
-end %>
-```
-------------
-
-### rails_context
-
-You can call `rails_context` or `rails_context(server_side: true|false)` from your controller or view to see what values are are in the Rails Context. Pass true or false depending on whether you want to see the server side or the client side rails_context. Typically, for computing cache keys, you should leave server_side as the default true. When calling this from a controller method, use `helpers.rails_context`.
-
-------------
-
-### Renderer Functions (function that will call ReactDOM.render or ReactDOM.hydrate)
-
-A "renderer function" is a Render-Function that accepts three arguments (rather than 2): `(props, railsContext, domNodeId) => { ... }`. Instead of returning a React component, a renderer is responsible for installing a callback that will call `ReactDOM.render` (in React 16+, `ReactDOM.hydrate`) to render a React component into the DOM. The "renderer function" is called at the same time the document ready event would instantate the React components into the DOM.
-
-Why would you want to call `ReactDOM.hydrate` yourself? One possible use case is [code splitting](https://www.shakacode.com/react-on-rails/docs/javascript/code-splitting/). In a nutshell, you don't want to load the React component on the DOM node yet. So you want to install some handler that will call `ReactDOM.hydrate` at a later time. In the case of code splitting with server rendering, the server rendered code has any async code loaded and used to server render. Thus, the client code must also fully load any asynch code before server rendering. Otherwise, the client code would first render partially, not matching the server rendering, and then a second later, the full code would render, resulting in an unpleasant flashing on the screen.
-
-Renderer functions are not meant to be used on the server since there's no DOM on the server. Instead, use a Render-Function. Attempting to server render with a renderer function will throw an error.
-
-------------
-
-### React Router
-
-[React Router](https://github.com/reactjs/react-router) is supported, including server-side rendering! See:
-
-1. [React on Rails docs for react-router](https://www.shakacode.com/react-on-rails/docs/javascript/react-router/)
-2. Examples in [spec/dummy/app/views/react_router](https://github.com/shakacode/react_on_rails/tree/master/spec/dummy/app/views/react_router) and follow to the JavaScript code in the [spec/dummy/client/app/startup/ServerRouterApp.jsx](https://github.com/shakacode/react_on_rails/tree/master/spec/dummy/client/app/startup/ServerRouterApp.jsx).
-3. [Code Splitting docs](https://www.shakacode.com/react-on-rails/docs/javascript/code-splitting/) for information about how to set up code splitting for server rendered routes.
-
-------------
-
-## server_render_js
-
-`server_render_js(js_expression, options = {})`
-
-- js_expression, like 2 + 3, and not a block of js code. If you have more than one line that needs to be executed, wrap it in an [IIFE](https://en.wikipedia.org/wiki/Immediately-invoked_function_expression). JS exceptions will be caught, and console messages will be handled properly
-- Currently, the only option you may pass is `replay_console` (boolean)
-
-This is a helper method that takes any JavaScript expression and returns the output from evaluating it. If you have more than one line that needs to be executed, wrap it in an IIFE. JS exceptions will be caught and console messages handled properly.
-
-------------
-
-# More details
-
-See the [lib/react_on_rails/helper.rb](https://github.com/shakacode/react_on_rails/tree/master/lib/react_on_rails/helper.rb) source.

data/docs/contributor-info/errors-with-hooks.md

@@ -1,45 +0,0 @@
-# Invalid hook call error
-
-```
-react.development.js:1465 Uncaught Error: Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
-1. You might have mismatching versions of React and the renderer (such as React DOM)
-2. You might be breaking the Rules of Hooks
-3. You might have more than one copy of React in the same app
-See https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem.
-```
-
-The main reason to get this is due to multiple versions of React installed.
-
-```
-cd <top level>
-npm ls react
-
-cd spec/dummy
-npm ls react
-```
-
-For the second one, you might get:
-
-```
-react_on_rails@ /Users/justin/shakacode/react-on-rails/react_on_rails/spec/dummy
-├── react@16.13.1
-└─┬ react-on-rails@12.0.0 -> /Users/justin/shakacode/react-on-rails/react_on_rails invalid
-  └── react@16.13.1  extraneous
-
-npm ERR! invalid: react-on-rails@12.0.0 /Users/justin/shakacode/react-on-rails/react_on_rails/spec/dummy/node_modules/react-on-rails
-npm ERR! extraneous: react@16.13.1 /Users/justin/shakacode/react-on-rails/react_on_rails/spec/dummy/node_modules/react-on-rails/node_modules/react
-```
-
-Make sure there is only one version of React installed!
-
-If you used yarn link, then you'll have two versions of React installed.
-
-Instead use [Yalc](https://github.com/whitecolor/yalc).
-
-```
-cd <top level>
-yalc publish
-
-cd spec/dummy
-yalc link react-on-rails
-```

data/docs/contributor-info/generator-testing.md

@@ -1,11 +0,0 @@
-# Generator Testing
-We create several applications that are examples of running the generator (see lib/generators/react_on_rails/install_generator.rb) with various different options. We can then run tests with these apps just like we would any Rails app and thus ensure that our generator makes apps that actually function properly.
-
-Special rake tasks in rakelib/examples.rake handle creating the example apps and running a special hidden generator (lib/generators/react_on_rails/dev_tests_generator.rb) that installs the tests we want to run for each app. These tests can be run manually like any Rails app, or they can be run via the `rake run_rspec:examples` command. There are also commands for running each app individually, i.e., `rake run_rspec:example_basic`.
-
-## Travis and Gemfiles
-We are currently using Travis for CI. Because of the way Travis works, it is not possible to `bundle install` multiple Gemfiles. Therefore, we have placed all dependencies for generated apps in the gem's main Gemfile. If you generate an app that has a new gem dependency in its Gemfile, you need to add that dependency to the main Gemfile or it will not work in CI.
-
-## Configuring what Apps are Generated
-You can specify additional apps to generate and test by adding to the rakelib/examples_config.yml file. The necessary build and test tasks will automatically be created for you dynamically at runtime.
-

data/docs/contributor-info/linters.md

@@ -1,68 +0,0 @@
-# Linters
-These linters support the [ShakaCode Style Guidelines](https://www.shakacode.com/react-on-rails/docs/misc/style/)
-
-## Autofix!
-
-If you haven't tried the autofix options for `eslint` and `rubocop`, you're seriously missing out!
-
-1. Be **SURE** you have a clean git status, as you'll want to review what the autofix does to your code!
-2. **Rubocop:**  Be sure to be in the right directory where you have Ruby files, probably the top level of your Rails project.
-  ```
-  rubocop -a
-  ```
-
-3. **eslint:**: Be sure to be in the right directory where you have JS files.
-  ```
-  eslint --fix .
-  ```
-
-  or
-
-  ```
-  npm run lint -- --fix
-  ```
-
-Autofixing is a **HUGE** time saver!
-
-## ESLint
-
-### Configuring Rules
-
-Rules are configured with a 0, 1 or 2. Setting a rule to 0 is turning it off, setting it to 1 triggers a warning if that rule is violated, and setting it to 2 triggers an error.
-
-Rules can also take a few additional options. In this case, the rule can be set to an array, the first item of which is the 0/1/2 flag and the rest are options.
-
-See file [.eslintrc](https://github.com/shakacode/react_on_rails/tree/master/.eslintrc) for examples of configuration
-
-### Specify/Override rules in code
-
-Rules can also be specified in the code file to be linted, as JavaScript comments. This can be useful when the rule is a one-off or is a override to a project-wide rule.
-
-For example, if your file assumes a few globals and you have the no-undef rule set in the .eslintrc file, you might want to relax the rule in the current file.
-
-```
-/* global $, window, angular */
-// rest of code
-```
-
-It's also useful to disable ESLint for particular lines or blocks of lines.
-
-```
-console.log('console.log not allowed'); // eslint-disable-line
-
-alert('alert not allowed'); // eslint-disable-line no-alert
-
-/* eslint-disable no-console, no-alert */
-console.log('more console.log');
-alert('more alert');
-/* eslint-enable no-console, no-alert */
-```
-
-You can disable all rules for a line or block, or only specific rules, as shown above.
-
-### Useful Reference Links
-
-* [Configuring ESLint](http://eslint.org/docs/user-guide/configuring.html#configuring-rules)
-* [ESLint quick start](http://untilfalse.com/eslint-quick-start/)
-* [RuboCop](https://github.com/bbatsov/rubocop)
-* [ESLint](http://eslint.org/)

data/docs/contributor-info/pull-requests.md

@@ -1,42 +0,0 @@
-# Pull Requests
-
-## Checklist before Committing
-1. `rake`: runs all linters and specs (you need Docker setup, see below)
-2. Did you need any more tests for your change?
-3. Did you document your change? Update the README.md?
-4. Did you add a CHANGELOG.md entry?
-
-
-For non-doc fixes:
-
-* Provide changelog entry in the [unreleased section of the CHANGELOG.md](https://github.com/shakacode/react_on_rails/blob/master/CHANGELOG.md#unreleased).
-* Ensure CI passes and that you added a test that passes with the fix and fails without the fix.
-* Squash all commits down to one with a nice commit message *ONLY* once final review is given. Make sure this single commit is rebased on top of master.
-* Please address all code review comments.
-* Ensure that docs are updated accordingly if a feature is added.
-
-## Commit Messages
-
-From [How to Write a Git Commit Message](http://chris.beams.io/posts/git-commit/)
-
-#### The seven rules of a great git commit message
-> Keep in mind: This has all been said before.
-
-1. Separate subject from body with a blank line
-1. Limit the subject line to 50 characters
-1. Capitalize the subject line
-1. Do not end the subject line with a period
-1. Use the imperative mood in the subject line
-1. Wrap the body at 72 characters
-1. Use the body to explain what and why vs. how
-
-## Doc Changes
-
-When making doc changes, we want the change to work on both the gitbook and the regular github site. The issue is that non-doc files will not go to the gitbook site, so doc references to non doc files must use the github URL.
-
-### Links to other docs:
-* When making references to doc files, use a relative URL path like:
-`[Installation Overview](https://www.shakacode.com/react-on-rails/docs/additional-details/manual-installation-overview/)`
-
-* When making references to source code files, use a full url path like:
-`[spec/dummy/config/initializers/react_on_rails.rb](https://github.com/shakacode/react_on_rails/tree/master/spec/dummy/config/initializers/react_on_rails.rb)`

data/docs/contributor-info/releasing.md

@@ -1,76 +0,0 @@
-# Install and Release
-
-We're now releasing this as a combined ruby gem plus npm package. We will keep the version numbers in sync.
-
-## Testing the Gem before Release from a Rails App
-See [Contributing](https://github.com/shakacode/react_on_rails/tree/master/CONTRIBUTING.md)
-
-## Releasing a new gem version
-Run `rake -D release` to see instructions on how to release via the rake task.
-
-
-As of 01-26-2016, this would give you an output like this:
-
-```
-rake release[gem_version,dry_run,tools_install]
-    Releases both the gem and node package using the given version.
-
-    IMPORTANT: the gem version must be in valid rubygem format (no dashes).
-    It will be automatically converted to a valid npm semver by the rake task
-    for the node package version. This only makes a difference for pre-release
-    versions such as `3.0.0.beta.1` (npm version would be `3.0.0-beta.1`).
-
-    This task will also globally install gem-release (ruby gem) and
-    release-it (node package) unless you specify skip installing tools.
-
-    2nd argument: Perform a dry run by passing 'true' as a second argument.
-    3rd argument: Skip installing tools by passing 'false' as a third argument (default is true).
-
-    Example: `rake release[2.1.0,false,false]`
-```
-
-Running `rake release[2.1.0]` will create a commit that looks like this:
-
-```
-commit d07005cde9784c69e41d73fb9a0ebe8922e556b3
-Author: Rob Wise <robert.wise@outlook.com>
-Date:   Tue Jan 26 19:49:14 2016 -0500
-
-    Release 2.1.0
-
-diff --git a/lib/react_on_rails/version.rb b/lib/react_on_rails/version.rb
-index 3de9606..b71aa7a 100644
---- a/lib/react_on_rails/version.rb
-+++ b/lib/react_on_rails/version.rb
-@@ -1,3 +1,3 @@
- module ReactOnRails
--  VERSION = "2.0.2".freeze
-+  VERSION = "2.1.0".freeze
- end
-diff --git a/package.json b/package.json
-index aa7b000..af8761e 100644
---- a/package.json
-+++ b/package.json
-@@ -1,6 +1,6 @@
- {
-   "name": "react-on-rails",
--  "version": "2.0.2",
-+  "version": "2.1.0",
-   "description": "react-on-rails JavaScript for react_on_rails Ruby gem",
-   "main": "node_package/lib/ReactOnRails.js",
-   "directories": {
-diff --git a/spec/dummy/Gemfile.lock b/spec/dummy/Gemfile.lock
-index 8ef51df..4489bfe 100644
---- a/spec/dummy/Gemfile.lock
-+++ b/spec/dummy/Gemfile.lock
-@@ -1,7 +1,7 @@
- PATH
-   remote: ../..
-   specs:
--    react_on_rails (2.0.2)
-+    react_on_rails (2.1.0)
-       connection_pool
-       execjs (~> 2.5)
-       rails (>= 3.2)
-(END)
-```

data/docs/deployment/elastic-beanstalk.md

@@ -1,63 +0,0 @@
-# Deploying React on Rails to Elastic Beanstalk
-
-In order to deploy a React on Rails app to elastic beanstalk, you must install yarn on each instance.
-If yarn is not installed, asset compilation will fail on the elastic beanstalk instance.
-
-You can install `yarn` by adding a `0x_install_yarn.config` file to your `.ebextensions` folder which contains these commands.
-
-```
-files:
-  "/opt/elasticbeanstalk/hooks/appdeploy/pre/09_yarn.sh" :
-    mode: "000755"
-    owner: root
-    group: root
-    content: |
-      #!/usr/bin/env bash
-      set -xe
-
-      EB_SCRIPT_DIR=$(/opt/elasticbeanstalk/bin/get-config container -k script_dir)
-      EB_APP_STAGING_DIR=$(/opt/elasticbeanstalk/bin/get-config container -k app_staging_dir)
-      EB_APP_USER=$(/opt/elasticbeanstalk/bin/get-config container -k app_user)
-      EB_SUPPORT_DIR=$(/opt/elasticbeanstalk/bin/get-config container -k support_dir)
-
-      . $EB_SUPPORT_DIR/envvars
-      . $EB_SCRIPT_DIR/use-app-ruby.sh
-
-      # Install nodejs
-      echo "install nodejs"
-      curl --silent --location https://rpm.nodesource.com/setup_6.x | sudo bash -
-      yum -y install nodejs
-      echo "install yarn"
-      # install yarn
-      wget https://dl.yarnpkg.com/rpm/yarn.repo -O /etc/yum.repos.d/yarn.repo;
-      yum -y install yarn;
-
-      # yarn install
-      cd $EB_APP_STAGING_DIR
-      yarn
-
-      # mkdir /home/webapp
-      mkdir -p /home/webapp
-      chown webapp:webapp /home/webapp
-      chmod 700 /home/webapp
-```
-
-This script installs `yarn` and all `node.js` dependencies before the rails do `assets:precompile`. Also, it creates `/home/webapp` directory allowing the precompile task to create temp files. 
-
-Your app can be deployed to elastic beanstalk successfully. However, the react app javascript files are under `public/packs`. If you are using nginx, you need to let it know the location of `https://yourhost/packs`. 
-
-In your `proxy.conf` setting, please add the following code.
-
-```
-...
-server{
-  ...
-  location /packs {
-    root /var/app/current/public;
-  }
-  ...
-}
-...
-```
-
-You can find an example code here: https://github.com/imgarylai/react_on_rails_with_aws_ebs.

data/docs/deployment/heroku-deployment.md

@@ -1,39 +0,0 @@
-# Heroku Deployment
-## Heroku buildpacks
-
-React on Rails requires both a ruby environment (for Rails) and a Node environment (for Webpack), so you will need to have Heroku use multiple buildpacks.
-
-Assuming you have downloaded and installed the Heroku command-line utility and have initialized the app, you will need to tell Heroku to use both buildpacks via the command-line:
-
-```bash
-heroku buildpacks:set heroku/ruby
-heroku buildpacks:add --index 1 heroku/nodejs
-```
-
-For more information, see [Using Multiple Buildpacks for an App](https://devcenter.heroku.com/articles/using-multiple-buildpacks-for-an-app)
-
-## assets:precompile
-
-### Shakapacker webpack configuration
-
-Shakapacker hooks up a new `shakapacker:compile` task to `assets:precompile`, which gets run whenever you run `assets:precompile`.
-If you are not using Sprockets, `shakapacker:compile` is automatically aliased to `assets:precompile`.
-
-If you're using the standard `shakacode/shakapacker` configuration of webpack, then `shakacode/shakapacker`
-will automatically modify or create an `assets:precompile` task to build your assets.
-
-Alternatively, you can specify `config.build_production_command` to have
-`react_on_rails` invoke a command for you during `assets:precompile`.
-
-```bash
-config.build_production_command = "RAILS_ENV=production NODE_ENV=production bin/shakapacker"
-```
-
-### Consider Removing Shakapacker's clean task
-
-If you are deploying on Heroku, then you don't need Shakapacker's clean task which
-might delete files that you need.
-
-```bash
-Rake::Task['shakapacker:clean'].clear
-```