Skip to content


Switch branches/tags

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

complate for Ruby

This is a Ruby on Rails and pure Ruby adapter for complate. See for example usage.

Usage in Rails

First, add complate to your Gemfile:

gem "complate"

Now there are two options to call JSX/complate views from your controller:

  1. A render based approach which adds jsx files from your views folder automatically and generates your complate bundle for you and
  2. a custom approach to render views from precompiled complate bundles.

Using render

In the render based approach complate-ruby manages your bundles for you. It expects the faucet-pipeline and complate-stream to be present in the node_modules directory of your app. An minimal package.json for your app could look like:

  "private": true,
  "dependencies": {
    "complate-stream": "^0.16.5",
    "faucet-pipeline-jsx": "^1.1.1"

Now you can place views, layouts and partials ending with .jsx in your Rails view directories.

Your view file must export a function returning a JSX-element. A simple view could look like:

import { createElement } from 'complate-stream';
export default ({ name }) => {
  return <span>Hello {name}!</span>;

Controller instance variables will be passed into the parameters object of your exported function as seen above. So a compoller action calling the view above could look like:

class MyController < ApplicationController
  def greet
    @name = "World"

Chunking / streaming

The Rails render method makes it hard to implement real chunking. One reason is the layout/partial support it implements. This adapter provides the complate_stream method to render a jsx/complate view witout layout and partial support but with real streaming instead.

class MyController < ApplicationController
  include ActionController::Live
  def greet
    @name = "World"

Using complate precompiled bundles

This approach assumes that there already is some kind of complate bundle somewhere. This bundle should contain all your views (registered with complate.registerView), your components and complate-stream itself. The bundle should export an object complate with values

  • render: the renderView function bound to a renderer instance

  • safe: complate's safe string function

You can call the following to render the "NameOfView" macro in your controller actions with two parameters:

complate("NameOfView", param1: "x", param2: "y")

This gem expect your bundle to be located in dist/bundle.js, but you can reconfigure that with config.complate.bundle_path = '...' or by using the option :bundle_path in the complate call:

complate("MyView", foo: "bar", bundle_path: Rails.root.join('other_bundle.js'))


complate with Rails gives you access to rails helper methods. These are accessible via the global variable rails.

import { createElement } from 'complate-stream';
export default ({ name }) => {
  return <span><a href={rails.greet_url()}>Click me!</a></span>;

HTML safe strings

complate will htmlencode all strings for you. It does not support Rails HTML safe strings ("foo".html_safe) at the moment. So you'll have to use complate's safe function to prevent complate from escaping Strings.

The exception are helper calls. Here the usage of Rails HTML safe Strings leads to automatically safe strings for complate too. If you are using custom bundles you'll have to export complate's safe function to


Use complate with Ruby and Rails






No packages published