react_on_rails 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 984a06acb85284e918de174680caf56447f1bbdf
-  data.tar.gz: 36ac020e260f26fa8b61ec053ada82c362633de6
+  metadata.gz: 80be69dda56a35cb09284a210eda3b03d30aad07
+  data.tar.gz: 1d2ebaeeb0a8e96017adba8b8193e712154fce01
 SHA512:
-  metadata.gz: 5093d94e30d8a8a049127ee0da9f83c79197c89738447663a377bbb6cfd81719b75fa2433d5e4cd63214fcc294b17986e8dcd3f4ecaf691331206fd4038e332b
-  data.tar.gz: 8adc548734d303cc2776f1e5069b6d72c38c0fcef45cc06f502d6e41696496984260c68543162ce7a0793216615354c525df181a78979fb7ba5fe2d604e97b23
+  metadata.gz: 787b0760428d7256c9cbf5475540ec08d56042f9659e3b87601dcfec762ee0f0204eb7ef0f45596245e67827d0b4de27fa68bf9fff12c2a7629baef64c88a9fb
+  data.tar.gz: a5e2b275fcd3690a127d18e7d666b5fa5dc165180793410cc16b45f4ca1ea55c2b44c8de4670b32e273c114e59b5bef2f270d19b2000cf18dc3b99fb2f614abd

data/.eslintignore

@@ -1,3 +1,5 @@
 node_modules
 coverage
 spec/react_on_rails/dummy-for-generators
+spec/dummy
+spec/dummy-react-013

data/.eslintrc

@@ -6,12 +6,43 @@ extends: eslint-config-airbnb
 plugins:
   - react
 
+globals:
+  __DEBUG_SERVER_ERRORS__: true
+  __SERVER_ERRORS__: true
+
 env:
   browser: true
   node: true
+  mocha: true
 
 rules:
+  ### Variables
+  no-undef: 2
+  no-unused-vars: [2, { vars: all, args: none }]
+
+  ### Stylistic issues
   indent: [1, 2, { SwitchCase: 1, VariableDeclarator: 2 }]
-  react/sort-comp: 0
-  react/jsx-quotes: 0
   id-length: [1, { min: 2, exceptions: [_, e, i, k, v] }]
+
+  ### React
+  jsx-quotes: [1, prefer-double]
+  react/display-name: 0
+  react/jsx-boolean-value: [1, always]
+  react/jsx-curly-spacing: [1, never]
+  react/jsx-no-duplicate-props: [2, { ignoreCase: true }]
+  react/jsx-no-undef: 2
+  react/jsx-sort-prop-types: 0
+  react/jsx-sort-props: 0
+  react/jsx-uses-react: 2
+  react/jsx-uses-vars: 2
+  react/no-danger: 0
+  react/no-did-mount-set-state: 1
+  react/no-did-update-set-state: 0
+  react/no-multi-comp: 2
+  react/no-unknown-property: 2
+  react/prop-types: 1
+  react/react-in-jsx-scope: 2
+  react/require-extension: [1, { extensions: [.js, .jsx] }]
+  react/self-closing-comp: 2
+  react/sort-comp: 0                                                            # Should be 1. `statics` should be on top.
+  react/wrap-multilines: 2

data/.jscsrc

@@ -1,7 +1,26 @@
 {
   "preset": "airbnb",
-  "fileExtensions": [".js", ".jsx"],
-  "excludeFiles": ["**/build/**", "**/node_modules/**", "**/generated/**", "**/docs/**", "**/tmp/**", "**/sample_generated/**", "**/coverage/**", "**/vendor/**", "**/dummy-for-generators/**"],
-  "requireTrailingComma": { "ignoreSingleValue": true, "ignoreSingleLine": true },
-  "validateQuoteMarks": false
+  "fileExtensions": [
+    ".js",
+    ".jsx"
+  ],
+  "excludeFiles": [
+    "**/build/**",
+    "**/node_modules/**",
+    "**/generated/**",
+    "**/docs/**",
+    "**/tmp/**",
+    "**/sample_generated/**",
+    "**/coverage/**",
+    "**/vendor/**",
+    "**/dummy-for-generators/**",
+    "**/dummy/**",
+    "**/dummy-react-013/**"
+  ],
+  "esprima": "babel-jscs",
+  "validateQuoteMarks": {
+    "mark": "'",
+    "escape": true,
+    "ignoreJSX": true
+  }
 }

data/.rubocop.yml

@@ -58,7 +58,7 @@ Metrics/MethodLength:
 # Offense count: 1
 # Configuration parameters: CountComments.
 Metrics/ModuleLength:
-  Max: 110
+  Max: 150
 
 # Offense count: 3
 # Configuration parameters: AllowedVariables.

data/README.md

@@ -41,6 +41,8 @@ Please see [Getting Started](#getting-started) for how to set up your Rails proj
     - [Building the Bundles](#building-the-bundles)
     - [Globally Exposing Your React Components](#globally-exposing-your-react-components)
     - [Rails View Helpers In-Depth](#rails-view-helpers-in-depth)
+    - [Redux](#redux)
+    - [React-Router](#react-router)
 + [Generator](#generator)
     - [Understanding the Organization of the Generated Client Code](#understanding-the-organization-of-the-generated-client-code)
     - [Redux](#redux)
@@ -94,7 +96,6 @@ We're definitely not doing that. With react_on_rails, webpack is mainly generati
   
   ```ruby
   gem "react_on_rails"
-  gem "therubyracer"
   ```
 
 2. Run the generator with a simple "Hello World" example:
@@ -123,7 +124,9 @@ The generator installs your webpack files in the `client` folder. Foreman uses w
 Inside your Rails views, you can now use the `react_component` helper method provided by React on Rails.
 
 ### Client-Side Rendering vs. Server-Side Rendering
-In most cases, you should use the `prerender: false` (default behavior) with the provided helper method to render the React component from your Rails views. In some cases, such as when SEO is vital or many users will not have JavaScript enabled, you can enable server-rendering by passing `prerender: true` to your helper, or you can simply change the default in `config/initializers/react_on_rails`. Your JavaScript can then be first rendered on the server and passed to the client as HTML.
+In most cases, you should use the `prerender: false` (default behavior) with the provided helper method to render the React component from your Rails views. In some cases, such as when SEO is vital or many users will not have JavaScript enabled, you can enable server-rendering by passing `prerender: true` to your helper, or you can simply change the default in `config/initializers/react_on_rails`.
+
+Now the server will interpret your JavaScript using [ExecJS](https://github.com/rails/execjs) and pass the resulting HTML to the client. We recommend using [therubyracer](https://github.com/cowboyd/therubyracer) as ExecJS's runtime. The generator will automatically add it to your Gemfile for you.
 
 Note that **server-rendering requires globally exposing your components by setting them to `global`, not `window`** (as is the case with client-rendering). If using the generator, you can pass the `--server-rendering` option to configure your application for server-side rendering. 
 
@@ -181,8 +184,10 @@ This is how you actually render the React components you exposed to `window` ins
 + **options:**
   + **generator_function:** default is false, set to true if you want to use a generator function rather than a React Component. Why would you do this? For example, you may want the ability to use the passed-in props to initialize a redux store or setup react-router. Or you may want to return different components depending on what's in the props.
   + **prerender:** enable server-side rendering of component. Set to false when debugging!
+  + **router_redirect_callback:** Use this option if you want to provide a custom handler for redirects on server rendering. If you don't specify this, we'll simply change the rendered output to a script that sets window.location to the new route. Set this up exactly like a generator_function. Your function will will take one parameter, containing all the values that react-router gives on a redirect request, such as pathname, search, etc.
   + **trace:** set to true to print additional debugging information in the browser. Defaults to true for development, off otherwise.
   + **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 default configuration of logging_on_server set to true, you'll still see the errors on 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.
 + Any other options are passed to the content tag, including the id
 
 #### server_render_js
@@ -315,6 +320,7 @@ As you add more routes to your front-end application, you will need to make the
 + [Manual Installation](docs/additional_reading/manual_installation.md)
 + [Node Dependencies and NPM](docs/additional_reading/node_dependencies_and_npm.md)
 + [Optional  Configuration](docs/additional_reading/optional_configuration.md)
++ [React Router](docs/additional_reading/react_router.md)
 + [Server Rendering Tips](docs/additional_reading/server_rendering_tips.md)
 + [Tips](docs/additional_reading/tips.md)
 

data/app/assets/javascripts/react_on_rails.js

@@ -1,79 +1,43 @@
 (function() {
   this.ReactOnRails = {};
-
-  ReactOnRails.clientRenderReactComponent = function(options) {
-    var componentName = options.componentName;
-    var domId = options.domId;
-    var propsVarName = options.propsVarName;
-    var props = options.props;
-    var trace = options.trace;
-    var generatorFunction = options.generatorFunction;
-    var expectTurboLinks = options.expectTurboLinks;
-
-    this[propsVarName] = props;
-
-    var renderIfDomNodePresent = function() {
-      try {
-        var domNode = document.getElementById(domId);
-        if (domNode) {
-          var reactElement = createReactElement(componentName, propsVarName, props,
-            domId, trace, generatorFunction);
-          provideClientReact().render(reactElement, domNode);
-        }
-      }
-      catch (e) {
-        ReactOnRails.handleError({
-          e: e,
-          componentName: componentName,
-          serverSide: false,
-        });
-      }
-    };
-
-    var turbolinksInstalled = (typeof Turbolinks !== 'undefined');
-    if (!expectTurboLinks || (!turbolinksInstalled && expectTurboLinks)) {
-      if (expectTurboLinks) {
-        console.warn('WARNING: NO TurboLinks detected in JS, but it is in your Gemfile');
-      }
-
-      document.addEventListener('DOMContentLoaded', function(event) {
-        renderIfDomNodePresent();
-      });
-    } else {
-      function onPageChange(event) {
-        var removePageChangeListener = function() {
-          document.removeEventListener('page:change', onPageChange);
-          document.removeEventListener('page:before-unload', removePageChangeListener);
-          var domNode = document.getElementById(domId);
-          provideClientReact().unmountComponentAtNode(domNode);
-        };
-
-        document.addEventListener('page:before-unload', removePageChangeListener);
-
-        renderIfDomNodePresent();
-      }
-
-      document.addEventListener('page:change', onPageChange);
-    }
-  };
+  var turbolinksInstalled = (typeof Turbolinks !== 'undefined');
 
   ReactOnRails.serverRenderReactComponent = function(options) {
     var componentName = options.componentName;
     var domId = options.domId;
-    var propsVarName = options.propsVarName;
     var props = options.props;
     var trace = options.trace;
     var generatorFunction = options.generatorFunction;
-
+    var location = options.location;
     var htmlResult = '';
     var consoleReplay = '';
+    var hasErrors = false;
 
     try {
-      var reactElement = createReactElement(componentName, propsVarName, props,
-        domId, trace, generatorFunction);
-      htmlResult = provideServerReact().renderToString(reactElement);
+      var reactElementOrRouterResult = createReactElementOrRouterResult(componentName, props,
+        domId, trace, generatorFunction, location);
+      if (isRouterResult(reactElementOrRouterResult)) {
+
+        // We let the client side handle any redirect
+        // Set hasErrors in case we want to throw a Rails exception
+        hasErrors = !!reactElementOrRouterResult.routeError;
+        if (hasErrors) {
+          console.error('React Router ERROR: ' +
+            JSON.stringify(reactElementOrRouterResult.routeError));
+        } else {
+          if (trace) {
+            redirectLocation = reactElementOrRouterResult.redirectLocation;
+            redirectPath = redirectLocation.pathname + redirectLocation.search;
+            console.log('ROUTER REDIRECT: ' + componentName + ' to dom node with id: ' + domId +
+              ', redirect to ' + redirectPath);
+          }
+        }
+      } else {
+        htmlResult = provideServerReact().renderToString(reactElementOrRouterResult);
+      }
     }
     catch (e) {
+      hasErrors = true;
       htmlResult = ReactOnRails.handleError({
         e: e,
         componentName: componentName,
@@ -81,8 +45,13 @@
       });
     }
 
-    consoleReplay = ReactOnRails.buildConsoleReplay();
-    return JSON.stringify([htmlResult, consoleReplay]);
+    consoleReplayScript = ReactOnRails.buildConsoleReplay();
+
+    return JSON.stringify({
+      html: htmlResult,
+      consoleReplayScript: consoleReplayScript,
+      hasErrors: hasErrors,
+    });
   };
 
   // Passing either componentName or jsCode
@@ -139,31 +108,91 @@
     }
   };
 
+  ReactOnRails.wrapInScriptTags = function(scriptBody) {
+    if (!scriptBody) {
+      return '';
+    }
+
+    return '\n<script>' + scriptBody + '\n</script>';
+  };
+
   ReactOnRails.buildConsoleReplay = function() {
     var consoleReplay = '';
 
     var history = console.history;
     if (history && history.length > 0) {
-      consoleReplay += '\n<script>';
       history.forEach(function(msg) {
         consoleReplay += '\nconsole.' + msg.level + '.apply(console, ' +
           JSON.stringify(msg.arguments) + ');';
       });
+    }
+
+    return ReactOnRails.wrapInScriptTags(consoleReplay);
+  };
 
-      consoleReplay += '\n</script>';
+  function forEachComponent(fn) {
+    var els = document.getElementsByClassName('js-react-on-rails-component');
+    for (var i = 0; i < els.length; i++) {
+      fn(els[i]);
+    };
+  }
+
+  function reactOnRailsPageLoaded() {
+    forEachComponent(render);
+  }
+
+  function reactOnRailsPageUnloaded() {
+    forEachComponent(unmount);
+  }
+
+  function unmount(el) {
+    var domId = el.getAttribute('data-dom-id');
+    var domNode = document.getElementById(domId);
+    provideClientReact().unmountComponentAtNode(domNode);
+  }
+
+  function render(el) {
+    var componentName = el.getAttribute('data-component-name');
+    var domId = el.getAttribute('data-dom-id');
+    var props = JSON.parse(el.getAttribute('data-props'));
+    var trace = JSON.parse(el.getAttribute('data-trace'));
+    var generatorFunction = JSON.parse(el.getAttribute('data-generator-function'));
+    var expectTurboLinks = JSON.parse(el.getAttribute('data-expect-turbo-links'));
+
+    if (!turbolinksInstalled && expectTurboLinks) {
+      console.warn('WARNING: NO TurboLinks detected in JS, but it is in your Gemfile');
     }
 
-    return consoleReplay;
+    try {
+      var domNode = document.getElementById(domId);
+      if (domNode) {
+        var reactElementOrRouterResult = createReactElementOrRouterResult(componentName, props,
+          domId, trace, generatorFunction);
+        if (isRouterResult(reactElementOrRouterResult)) {
+          throw new Error('You returned a server side type of react-router error: ' +
+            JSON.stringify(reactElementOrRouterResult) +
+            '\nYou should return a React.Component always for the client side entry point.');
+        } else {
+          provideClientReact().render(reactElementOrRouterResult, domNode);
+        }
+      }
+    }
+    catch (e) {
+      ReactOnRails.handleError({
+        e: e,
+        componentName: componentName,
+        serverSide: false,
+      });
+    }
   };
 
-  function createReactElement(componentName, propsVarName, props, domId, trace, generatorFunction) {
+  function createReactElementOrRouterResult(componentName, props, domId, trace, generatorFunction, location) {
     if (trace) {
-      console.log('RENDERED ' + componentName + ' with data_variable ' +
-        propsVarName + ' to dom node with id: ' + domId);
+      console.log('RENDERED ' + componentName + ' to dom node with id: ' + domId);
     }
 
     if (generatorFunction) {
-      return this[componentName](props);
+      return this[componentName](props, location);
     } else {
       return React.createElement(this[componentName], props);
     }
@@ -184,4 +213,19 @@
 
     return ReactDOMServer;
   }
+
+  function isRouterResult(reactElementOrRouterResult) {
+    return !!(reactElementOrRouterResult.redirectLocation ||
+    reactElementOrRouterResult.error);
+  }
+
+  // Install listeners when running on the client.
+  if (typeof document !== 'undefined') {
+    if (!turbolinksInstalled) {
+      document.addEventListener('DOMContentLoaded', reactOnRailsPageLoaded);
+    } else {
+      document.addEventListener('page:before-unload', reactOnRailsPageUnloaded);
+      document.addEventListener('page:change', reactOnRailsPageLoaded);
+    }
+  }
 }.call(this));

data/app/helpers/react_on_rails_helper.rb

@@ -2,6 +2,7 @@
 # For any heredoc JS:
 # 1. The white spacing in this file matters!
 # 2. Keep all #{some_var} fully to the left so that all indentation is done evenly in that var
+require "react_on_rails/prerender_error"
 
 module ReactOnRailsHelper
   # react_component_name: can be a React component, created using a ES6 class, or
@@ -19,7 +20,7 @@ module ReactOnRailsHelper
   #      global.MyReactComponentApp = MyReactComponentApp;
   #    See spec/dummy/client/app/startup/serverGlobals.jsx and
   #      spec/dummy/client/app/startup/ClientApp.jsx for examples of this
-  # props: Ruby Hash which contains the properties to pass to the react object
+  # props: Ruby Hash or JSON string which contains the properties to pass to the react object
   #
   #  options:
   #    generator_function: <true/false> default is false, set to true if you want to use a
@@ -31,6 +32,8 @@ module ReactOnRailsHelper
   #                    logs to browser. While this can make troubleshooting server rendering difficult,
   #                    so long as you have the default configuration of logging_on_server set to
   #                    true, you'll still see the errors on the server.
+  #    raise_on_prerender_error: <true/false> Default to false. True will raise exception on server
+  #       if the JS code throws
   #  Any other options are passed to the content tag, including the id.
   def react_component(component_name, props = {}, options = {})
     # Create the JavaScript and HTML to allow either client or server rendering of the
@@ -50,35 +53,31 @@ module ReactOnRailsHelper
 
     # Setup the page_loaded_js, which is the same regardless of prerendering or not!
     # The reason is that React is smart about not doing extra work if the server rendering did its job.
-    data_variable_name = "__#{component_name.camelize(:lower)}Data#{react_component_index}__"
     turbolinks_loaded = Object.const_defined?(:Turbolinks)
-    # NOTE: props might include closing script tag that might cause XSS
-    props_string = sanitized_props_string(props)
-    page_loaded_js = <<-JS
-(function() {
-  window.#{data_variable_name} = #{props_string};
-  ReactOnRails.clientRenderReactComponent({
-    componentName: '#{react_component_name}',
-    domId: '#{dom_id}',
-    propsVarName: '#{data_variable_name}',
-    props: window.#{data_variable_name},
-    trace: #{trace(options)},
-    generatorFunction: #{generator_function(options)},
-    expectTurboLinks: #{turbolinks_loaded}
-  });
-})();
-    JS
 
-    data_from_server_script_tag = javascript_tag(page_loaded_js)
+    component_specification_tag =
+      content_tag(:div,
+                  "",
+                  class: "js-react-on-rails-component",
+                  style: "display:none",
+                  data: {
+                    component_name: react_component_name,
+                    props: props,
+                    trace: trace(options),
+                    generator_function: generator_function(options),
+                    expect_turbolinks: turbolinks_loaded,
+                    dom_id: dom_id
+                  })
 
     # Create the HTML rendering part
-    server_rendered_html, console_script =
-      server_rendered_react_component_html(options, props_string, react_component_name,
-                                           data_variable_name, dom_id)
+    result = server_rendered_react_component_html(options, props, react_component_name, dom_id)
+
+    server_rendered_html = result["html"]
+    console_script = result["consoleReplayScript"]
 
     content_tag_options = options.except(:generator_function, :prerender, :trace,
                                          :replay_console, :id, :react_component_name,
-                                         :server_side)
+                                         :server_side, :raise_on_prerender_error)
     content_tag_options[:id] = dom_id
 
     rendered_output = content_tag(:div,
@@ -87,7 +86,7 @@ module ReactOnRailsHelper
 
     # IMPORTANT: Ensure that we mark string as html_safe to avoid escaping.
     <<-HTML.html_safe
-#{data_from_server_script_tag}
+#{component_specification_tag}
 #{rendered_output}
 #{replay_console(options) ? console_script : ''}
     HTML
@@ -104,7 +103,8 @@ module ReactOnRailsHelper
     wrapper_js = <<-JS
 (function() {
   var htmlResult = '';
-  var consoleReplay = '';
+  var consoleReplayScript = '';
+  var hasErrors = false;
 
   try {
     htmlResult =
@@ -114,17 +114,32 @@ module ReactOnRailsHelper
   } catch(e) {
     htmlResult = ReactOnRails.handleError({e: e, componentName: null,
       jsCode: '#{escape_javascript(js_expression)}', serverSide: true});
+    hasErrors = true;
   }
 
-  consoleReplay = ReactOnRails.buildConsoleReplay();
-  return JSON.stringify([htmlResult, consoleReplay]);
+  consoleReplayScript = ReactOnRails.buildConsoleReplay();
+
+  return JSON.stringify({
+      html: htmlResult,
+      consoleReplayScript: consoleReplayScript,
+      hasErrors: hasErrors
+  });
+
 })()
     JS
 
     result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
 
     # IMPORTANT: To ensure that Rails doesn't auto-escape HTML tags, use the 'raw' method.
-    raw("#{result[0]}#{replay_console(options) ? result[1] : ''}")
+    html = result["html"]
+    console_log_script = result["consoleLogScript"]
+    raw("#{html}#{replay_console(options) ? console_log_script : ''}")
+  rescue ExecJS::ProgramError => err
+    # rubocop:disable Style/RaiseArgs
+    raise ReactOnRails::PrerenderError.new(component_name: "N/A (server_render_js called)",
+                                           err: err,
+                                           js_code: wrapper_js)
+    # rubocop:enable Style/RaiseArgs
   end
 
   private
@@ -136,29 +151,59 @@ module ReactOnRailsHelper
 
   # Returns Array [0]: html, [1]: script to console log
   # NOTE, these are NOT html_safe!
-  def server_rendered_react_component_html(options, props_string, react_component_name, data_variable_name, dom_id)
-    return ["", ""] unless prerender(options)
+  def server_rendered_react_component_html(options, props, react_component_name, dom_id)
+    return { "html" => "", "consoleReplayScript" => "" } unless prerender(options)
+
+    # On server `location` option is added (`location = request.fullpath`)
+    # React Router needs this to match the current route
 
     # Make sure that we use up-to-date server-bundle
     ReactOnRails::ServerRenderingPool.reset_pool_if_server_bundle_was_modified
 
+    # Since this code is not inserted on a web page, we don't need to escape.
+    props_string = props.is_a?(String) ? props : props.to_json
+
     wrapper_js = <<-JS
 (function() {
   var props = #{props_string};
   return ReactOnRails.serverRenderReactComponent({
     componentName: '#{react_component_name}',
     domId: '#{dom_id}',
-    propsVarName: '#{data_variable_name}',
     props: props,
     trace: #{trace(options)},
-    generatorFunction: #{generator_function(options)}
+    generatorFunction: #{generator_function(options)},
+    location: '#{request.fullpath}'
   });
 })()
     JS
 
-    ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+    result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+
+    if result["hasErrors"] && raise_on_prerender_error(options)
+      # We caught this exception on our backtrace handler
+      # rubocop:disable Style/RaiseArgs
+      fail ReactOnRails::PrerenderError.new(component_name: react_component_name,
+                                            # Sanitize as this might be browser logged
+                                            props: sanitized_props_string(props),
+                                            err: nil,
+                                            js_code: wrapper_js,
+                                            console_messages: result["consoleReplayScript"])
+      # rubocop:enable Style/RaiseArgs
+    end
+    result
   rescue ExecJS::ProgramError => err
-    raise ReactOnRails::ServerRenderingPool::PrerenderError.new(react_component_name, props_string, err)
+    # This error came from execJs
+    # rubocop:disable Style/RaiseArgs
+    raise ReactOnRails::PrerenderError.new(component_name: react_component_name,
+                                           # Sanitize as this might be browser logged
+                                           props: sanitized_props_string(props),
+                                           err: err,
+                                           js_code: wrapper_js)
+    # rubocop:enable Style/RaiseArgs
+  end
+
+  def raise_on_prerender_error(options)
+    options.fetch(:raise_on_prerender_error) { ReactOnRails.configuration.raise_on_prerender_error }
   end
 
   def trace(options)