[![Gem](https://img.shields.io/gem/v/react-rails.svg?style=flat-square)](http://rubygems.org/gems/react-rails)
[![Build Status](https://img.shields.io/travis/reactjs/react-rails/master.svg?style=flat-square)](https://travis-ci.org/reactjs/react-rails)
[![Gemnasium](https://img.shields.io/gemnasium/reactjs/react-rails.svg?style=flat-square)](https://gemnasium.com/reactjs/react-rails)
[![Code Climate](https://img.shields.io/codeclimate/github/reactjs/react-rails.svg?style=flat-square)](https://codeclimate.com/github/reactjs/react-rails)
[![Test Coverage](https://img.shields.io/codeclimate/coverage/github/reactjs/react-rails.svg?style=flat-square)](https://codeclimate.com/github/reactjs/react-rails/coverage)
* * *
# react-rails
`react-rails` makes it easy to use [React](http://facebook.github.io/react/) and [JSX](http://facebook.github.io/react/docs/jsx-in-depth.html)
in your Ruby on Rails (3.2+) application. `react-rails` can:
- Provide [various `react` builds](#reactjs-builds) to your asset bundle
- Transform [`.jsx` in the asset pipeline](#jsx)
- [Render components into views and mount them](#rendering--mounting) via view helper & `react_ujs`
- [Render components server-side](#server-rendering) with `prerender: true`
- [Generate components](#component-generator) with a Rails generator
- [Be extended](#extending-react-rails) with custom renderers, transformers and view helpers
## Installation
Add `react-rails` to your gemfile:
```ruby
gem 'react-rails', '~> 1.3.0'
```
Next, run the installation script:
```bash
rails g react:install
```
This will:
- create a `components.js` manifest file and a `app/assets/javascripts/components/` directory,
where you will put your components
- place the following in your `application.js`:
```js
//= require react
//= require react_ujs
//= require components
```
## Usage
### React.js builds
You can pick which React.js build (development, production, with or without [add-ons]((http://facebook.github.io/react/docs/addons.html)))
to serve in each environment by adding a config. Here are the defaults:
```ruby
# config/environments/development.rb
MyApp::Application.configure do
config.react.variant = :development
end
# config/environments/production.rb
MyApp::Application.configure do
config.react.variant = :production
end
```
To include add-ons, use this config:
```ruby
MyApp::Application.configure do
config.react.addons = true # defaults to false
end
```
After restarting your Rails server, `//= require react` will provide the build of React.js which
was specified by the configurations.
`react-rails` offers a few other options for versions & builds of React.js.
See [VERSIONS.md](https://github.com/reactjs/react-rails/blob/master/VERSIONS.md) for more info about
using the `react-source` gem or dropping in your own copies of React.js.
### JSX
After installing `react-rails`, restart your server. Now, `.js.jsx` files will be transformed in the asset pipeline.
`react-rails` currently ships with two transformers, to convert jsx code -
* `BabelTransformer` using [Babel](http://babeljs.io), which is the default transformer.
* `JSXTransformer` using `JSXTransformer.js`
You can use the deprecated `JSXTransformer` by setting it in an application config:
```ruby
config.react.jsx_transformer_class = React::JSX::JSXTransformer
```
#### BabelTransformer options
You can use babel's [transformers](http://babeljs.io/docs/advanced/transformers/) and [custom plugins](http://babeljs.io/docs/advanced/plugins/),
and pass [options](http://babeljs.io/docs/usage/options/) to the babel transpiler adding following configurations:
```ruby
config.react.jsx_transform_options = {
blacklist: ['spec.functionName', 'validation.react'], # default options
optional: ["transformerName"], # pass extra babel options
whitelist: ["useStrict"] # even more options
}
```
Under the hood, `react-rails` uses [ruby-babel-transpiler](https://github.com/babel/ruby-babel-transpiler), for transformation.
#### JSXTransformer options
You can use JSX `--harmony` or `--strip-types` options by adding a configuration:
```ruby
config.react.jsx_transform_options = {
harmony: true,
strip_types: true, # for removing Flow type annotations
asset_path: "path/to/JSXTransformer.js", # if your JSXTransformer is somewhere else
}
```
### Rendering & mounting
`react-rails` includes a view helper (`react_component`) and an unobtrusive JavaScript driver (`react_ujs`)
which work together to put React components on the page. You should require the UJS driver
in your manifest after `react` (and after `turbolinks` if you use [Turbolinks](https://github.com/rails/turbolinks)).
The __view helper__ puts a `div` on the page with the requested component class & props. For example:
```erb
<%= react_component('HelloMessage', name: 'John') %>
```
On page load, the __`react_ujs` driver__ will scan the page and mount components using `data-react-class`
and `data-react-props`.
If Turbolinks is present components are mounted on the `page:change` event, and unmounted on `page:before-unload`.
__Turbolinks >= 2.4.0__ is recommended because it exposes better events.
The view helper's signature is:
```ruby
react_component(component_class_name, props={}, html_options={})
```
- `component_class_name` is a string which names a globally-accessible component class. It may have dots (eg, `"MyApp.Header.MenuItem"`).
- `props` is either an object that responds to `#to_json` or an already-stringified JSON object (eg, made with Jbuilder, see note below).
- `html_options` may include:
- `tag:` to use an element other than a `div` to embed `data-react-class` and `-props`.
- `prerender: true` to render the component on the server.
- `**other` Any other arguments (eg `class:`, `id:`) are passed through to [`content_tag`](http://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-content_tag).
### Server rendering
To render components on the server, pass `prerender: true` to `react_component`:
```erb
<%= react_component('HelloMessage', {name: 'John'}, {prerender: true}) %>
Hello, John!
```
_(It will be also be mounted by the UJS on page load.)_
There are some requirements for this to work:
- `react-rails` must load your code. By convention it uses `components.js`, which was created
by the install task. This file must include your components _and_ their dependencies (eg, Underscore.js).
- Your components must be accessible in the global scope.
If you are using `.js.jsx.coffee` files then the wrapper function needs to be taken into account:
```coffee
# @ is `window`:
@Component = React.createClass
render: ->
``
```
- Your code can't reference `document`. Prerender processes don't have access to `document`,
so jQuery and some other libs won't work in this environment :(
You can configure your pool of JS virtual machines and specify where it should load code:
```ruby
# config/environments/application.rb
# These are the defaults if you dont specify any yourself
MyApp::Application.configure do
# Settings for the pool of renderers:
config.react.server_renderer_pool_size ||= 1 # ExecJS doesn't allow more than one on MRI
config.react.server_renderer_timeout ||= 20 # seconds
config.react.server_renderer = React::ServerRendering::SprocketsRenderer
config.react.server_renderer_options = {
files: ["react.js", "components.js"], # files to load for prerendering
replay_console: true, # if true, console.* will be replayed client-side
}
end
```
- On MRI, use `therubyracer` for the best performance (see [discussion](https://github.com/reactjs/react-rails/pull/290))
- On MRI, you'll get a deadlock with `pool_size` > 1
- If you're using JRuby, you can increase `pool_size` to have real multi-threaded rendering.
### Rendering components instead of views
Components can also be prerendered directly from a controller action with the custom `component` renderer. For example:
```ruby
class TodoController < ApplicationController
def index
@todos = Todo.all
render component: 'TodoList', props: { todos: @todos }, tag: 'span'
end
end
```
This custom renderer behaves the same as a normal view renderer and accepts the usual arguments - `content_type`, `layout`, `location` and `status`.
By default, your current layout will be used and the component, rather than a view, will be rendered in place of `yield`.
### Component generator
`react-rails` ships with a Rails generator to help you get started with a simple component scaffold.
You can run it using `rails generate react:component ComponentName (--es6)`.
The generator takes an optional list of arguments for default propTypes,
which follow the conventions set in the [Reusable Components](http://facebook.github.io/react/docs/reusable-components.html)
section of the React documentation.
For example:
```shell
rails generate react:component Post title:string body:string published:bool published_by:instanceOf{Person}
```
would generate the following in `app/assets/javascripts/components/post.js.jsx`:
```jsx
var Post = React.createClass({
propTypes: {
title: React.PropTypes.string,
body: React.PropTypes.string,
published: React.PropTypes.bool,
publishedBy: React.PropTypes.instanceOf(Person)
},
render: function() {
return (
Title: {this.props.title}
Body: {this.props.body}
Published: {this.props.published}
Published By: {this.props.publishedBy}
);
}
});
```
#### Options
**--es6** : Generate the same component but using cutting edge es6 class
For example:
```shell
rails generate react:component Label label:string --es6
```
#### Arguments
The generator can use the following arguments to create basic propTypes:
* any
* array
* bool
* element
* func
* number
* object
* node
* shape
* string
The following additional arguments have special behavior:
* `instanceOf` takes an optional class name in the form of {className}.
* `oneOf` behaves like an enum, and takes an optional list of strings in the form of `'name:oneOf{one,two,three}'`.
* `oneOfType` takes an optional list of react and custom types in the form of `'model:oneOfType{string,number,OtherType}'`.
Note that the arguments for `oneOf` and `oneOfType` must be enclosed in single quotes
to prevent your terminal from expanding them into an argument list.
### Jbuilder & react-rails
If you use Jbuilder to pass a JSON string to `react_component`, make sure your JSON is a stringified hash,
not an array. This is not the Rails default -- you should add the root node yourself. For example:
```ruby
# BAD: returns a stringified array
json.array!(@messages) do |message|
json.extract! message, :id, :name
json.url message_url(message, format: :json)
end
# GOOD: returns a stringified hash
json.messages(@messages) do |message|
json.extract! message, :id, :name
json.url message_url(message, format: :json)
end
```
## CoffeeScript
It is possible to use JSX with CoffeeScript. To use CoffeeScript, create files with an extension `.js.jsx.coffee`.
We also need to embed JSX code inside backticks so that CoffeeScript ignores the syntax it doesn't understand.
Here's an example:
```coffee
Component = React.createClass
render: ->
``
```
## Extending `react-rails`
You can extend some of the core functionality of `react-rails` by injecting new implementations during configuration.
### Custom Server Renderer
`react-rails` depends on a renderer class for rendering components on the server. You can provide a custom renderer class to `config.react.server_renderer`. The class must implement:
- `#initialize(options={})`, which accepts the hash from `config.react.server_renderer_options`
- `#render(component_name, props, prerender_options)` to return a string of HTML
`react-rails` provides two renderer classes: `React::ServerRendering::ExecJSRenderer` and `React::ServerRendering::SprocketsRenderer`.
`ExecJSRenderer` offers two other points for extension:
- `#before_render(component_name, props, prerender_options)` to return a string of JavaScript to execute _before_ calling `React.render`
- `#after_render(component_name, props, prerender_options)` to return a string of JavaScript to execute _after_ calling `React.render`
Any subclass of `ExecJSRenderer` may use those hooks (for example, `SprocketsRenderer` uses them to handle `console.*` on the server).
### Custom View Helper
`react-rails` uses a "helper implementation" class to generate the output of the `react_component` helper. The helper is initialized once per request and used for each `react_component` call during that request. You can provide a custom helper class to `config.react.view_helper_implementation`. The class must implement:
- `#react_component(name, props = {}, options = {}, &block)` to return a string to inject into the Rails view
- `#setup(controller_instance)`, called when the helper is initialized at the start of the request
- `#teardown(controller_instance)`, called at the end of the request
`react-rails` provides one implementation, `React::Rails::ComponentMount`.
### Custom JSX Transformer
`react-rails` uses a transformer class to transform JSX for the browser. The transformer is initialized once, at boot. You can provide a custom transformer to `config.react.jsx_transformer_class`. The transformer must implement:
- `#initialize(options)`, where options is the value passed to `config.react.jsx_transform_options`
- `#transform(code_string)` to return a string of transformed code
`react-rails` provides two transformers, `React::JSX::JSXTransformer` and `React::JSX::BabelTransformer`.