react_on_rails 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 829e8c7c5f08f5a219d996d2356c0bc6a0125b42
-  data.tar.gz: 1d5bf7c969a5f182e2f81bee3626f4f2acd0ff85
+  metadata.gz: bc9e4d7fb4efbba5c82f8c056cdc4a25dfd66752
+  data.tar.gz: 4a06b66bf0a5d1b7e88e3bc78d573aafab298994
 SHA512:
-  metadata.gz: fa2ef614a94bba6bcda082f6398889732ade8cc7c8885ba305fdee9638a599ac3b0e85d77175c4c2a05875463c3a654b76037de58830276c9b144ccb2bec9e39
-  data.tar.gz: 468c2014a1132b53ee9de227a10a30a4f4a07f435b1caa4ee64311541d1bb8ce034c235aaa5b51497e60f7ed852bf7fec499eed7b2d90b72e4e3b5bb50751ff8
+  metadata.gz: 4deb110a525ad5bfd570a55ccdedf03807b1cd743126b479773d8d5431e9f4ce5e23204efa881af86b2fc38175c4e27164f98ff79c7489ca0c18b0cb3bf8b943
+  data.tar.gz: 75de61e4804311370c9c86370b079a0456a74e0d638416bf7a65c1333d09a15d745513f090441725ae74d249b15b8b803b5c7692a96d7887729c1ad06b86c789

data/README.md

@@ -56,6 +56,11 @@ And then execute:
 
     $ bundle
 
+## What Happens?
+
+Here's what the browser will render with a call to the `react_component` helper.
+![2015-09-28_20-24-35](https://cloud.githubusercontent.com/assets/1118459/10157268/41435186-6624-11e5-9341-6fc4cf35ee90.png)
+
 ## Usage
 
 *See section below titled "Try it out"*
@@ -182,17 +187,17 @@ Contributions and pull requests welcome!
   npm i
   foreman start
   ```
-2. Caching is turned for development mode. Open the console and run `Rails.cache.clear` to clear
-  the cache. Note, even if you stop the server, you'll still have the cache entries around.
 3. Visit http://localhost:3000
 4. Notice that the first time you hit the page, you'll see a message that server is rendering.
    See `spec/dummy/app/views/pages/index.html.erb:17` for the generation of that message.
 5. Look at the layouts in `spec/dummy/app/views/pages` for samples of usage.
 5. Open up the browser console and see some tracing.
 6. Open up the source for the page and see the server rendered code.
-7. If you want to turn off server caching, run the server like:
-   `export RAILS_USE_CACHE=N && foreman start`
-8. If you click back and forth between the about and react page links, you can see the rails console
+7. If you want to turn on server caching for development, run the server like:
+   `export RAILS_USE_CACHE=YES && foreman start`
+2. If you're testing with caching, you'll need to open the console and run `Rails.cache.clear` to clear
+  the cache. Note, even if you stop the server, you'll still have the cache entries around.
+8. If you click back and forth between the react page links, you can see the rails console
    log as well as the browser console to see what's going on with regards to server rendering and
    caching.
 
@@ -297,7 +302,13 @@ The gem is available as open source under the terms of the [MIT License](http://
 See https://github.com/svenfuchs/gem-release
 
 ```bash
-gem bump --tag --release
+gem bump
+cd spec/dummy
+bundle
+git commit -am "Updated Gemfile.lock"
+cd ../..
+gem tag
+gem release
 ```
 
 # Authors

data/app/assets/javascripts/react_on_rails.js

@@ -0,0 +1,153 @@
+(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);
+          React.render(reactElement, domNode);
+        }
+      }
+      catch (e) {
+        handleError(e, componentName);
+      }
+    };
+
+    var turbolinksInstalled = typeof(Turbolinks) !== 'undefined';
+    if (!expectTurboLinks || (!turbolinksInstalled && expectTurboLinks)) {
+      if (expectTurboLinks) {
+        console.warn("WARNING: NO TurboLinks detected in JS, but it's 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);
+          React.unmountComponentAtNode(domNode);
+        };
+        document.addEventListener("page:before-unload", removePageChangeListener);
+
+        renderIfDomNodePresent();
+      }
+
+      document.addEventListener("page:change", onPageChange);
+    }
+  };
+
+  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 htmlResult = '';
+    var consoleReplay = '';
+
+    try {
+      var reactElement = createReactElement(componentName, propsVarName, props,
+        domId, trace, generatorFunction);
+      htmlResult = React.renderToString(reactElement);
+    }
+    catch (e) {
+      htmlResult = handleError(e, componentName);
+    }
+
+    consoleReplay = ReactOnRails.buildConsoleReplay();
+    return JSON.stringify([htmlResult, consoleReplay]);
+  };
+
+  function createReactElement(componentName, propsVarName, props, domId, trace, generatorFunction) {
+    if (trace) {
+      console.log('RENDERED ' + componentName + ' with data_variable ' +
+        propsVarName + ' to dom node with id: ' + domId);
+    }
+
+    if (generatorFunction) {
+      return this[componentName](props);
+    } else {
+      return React.createElement(this[componentName], props);
+    }
+  }
+
+  // Passing either componentName or jsCode
+  function handleError(e, componentName, jsCode) {
+    var lineOne =
+      'ERROR: You specified the option generator_function (could be in your defaults) to be\n';
+    var lastLine =
+      'A generator function takes a single arg of props and returns a ReactElement.';
+
+    console.error('Exception in rendering!');
+
+    var msg = '';
+    if (componentName) {
+      var shouldBeGeneratorError = lineOne +
+        'false, but the React component \'' + componentName + '\' seems to be a generator function.\n' +
+        lastLine;
+      var reMatchShouldBeGeneratorError = /Can't add property context, object is not extensible/;
+      if (reMatchShouldBeGeneratorError.test(e.message)) {
+        msg += shouldBeGeneratorError + '\n\n';
+        console.error(shouldBeGeneratorError);
+      }
+
+      var shouldBeGeneratorError = lineOne +
+        'true, but the React component \'' + componentName + '\' is not a generator function.\n' +
+        lastLine;
+      var reMatchShouldNotBeGeneratorError = /Cannot call a class as a function/;
+      if (reMatchShouldNotBeGeneratorError.test(e.message)) {
+        msg += shouldBeGeneratorError + '\n\n';
+        console.error(shouldBeGeneratorError);
+      }
+    }
+
+    if (jsCode) {
+      console.error('JS code was: ' + jsCode);
+    }
+
+    if (e.fileName) {
+      console.error('location: ' + e.fileName + ':' + e.lineNumber);
+    }
+    console.error('message: ' + e.message);
+    console.error('stack: ' + e.stack);
+    msg += 'Exception in rendering!\n' +
+      (e.fileName ? '\nlocation: ' + e.fileName + ':' + e.lineNumber : '') +
+      '\nMessage: ' + e.message + '\n\n' + e.stack;
+
+    var reactElement = React.createElement('pre', null, msg);
+    return React.renderToString(reactElement);
+  }
+
+  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) + ');';
+      });
+      consoleReplay += '\n</script>';
+    }
+
+    return consoleReplay;
+  }
+}.call(this));

data/app/helpers/react_on_rails_helper.rb

@@ -1,5 +1,3 @@
-require "react_on_rails/react_renderer"
-
 # NOTE:
 # For any heredoc JS:
 # 1. The white spacing in this file matters!
@@ -54,14 +52,20 @@ module ReactOnRailsHelper
     # 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)
-    install_render_events = turbolinks_loaded ? turbolinks_bootstrap(dom_id) : non_turbolinks_bootstrap
+    # NOTE: props might include closing script tag that might cause XSS
     props_string = props.is_a?(String) ? props : props.to_json
     page_loaded_js = <<-JS
 (function() {
   window.#{data_variable_name} = #{props_string};
-#{define_render_if_dom_node_present(react_component_name, data_variable_name, dom_id,
-                                    trace(options), generator_function(options))}
-#{install_render_events}
+  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
 
@@ -89,6 +93,35 @@ module ReactOnRailsHelper
     HTML
   end
 
+  # Helper method to take 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 are caught and console messages are handled properly.
+  def server_render_js(js_expression, options = {})
+    wrapper_js = <<-JS
+(function() {
+  var htmlResult = '';
+  var consoleReplay = '';
+
+  try {
+    htmlResult =
+      (function() {
+        return #{js_expression};
+      })();
+  } catch(e) {
+    htmlResult = handleError(e, null, '#{escape_javascript(js_expression)}');
+  }
+
+  consoleReplay = ReactOnRails.buildConsoleReplay();
+  return JSON.stringify([htmlResult, consoleReplay]);
+})()
+    JS
+
+    result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+    "#{result[0]}\n#{result[1]}".html_safe
+  end
+
+  private
+
   def next_react_component_index
     @react_component_index ||= -1
     @react_component_index += 1
@@ -96,49 +129,28 @@ 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, dom_id)
-    if prerender(options)
-      render_js_expression = <<-JS
-(function(React) {
-        #{debug_js(react_component_name, data_variable, dom_id, trace(options))}
-        var reactElement = #{render_js_react_element(react_component_name, props_string, generator_function(options))}
-        return React.renderToString(reactElement);
-      })(this.React);
-      JS
-      # create the server generated html of the react component with props
-      options[:react_component_name] = react_component_name
-      options[:server_side] = true
-      render_js_internal(render_js_expression, options)
-    else
-      ["",""]
-    end
-  rescue ExecJS::ProgramError => err
-    raise ReactOnRails::ServerRenderingPool::PrerenderError.new(react_component_name, props_string, err)
-  end
+  def server_rendered_react_component_html(options, props_string, react_component_name, data_variable_name, dom_id)
+    return ["", ""] unless prerender(options)
 
-  # Takes javascript code and returns the output from it. This is called by react_component, which
-  # sets up the JS code for rendering a react component.
-  # This method could be used by itself to render the output of any javascript that returns a
-  # string of proper HTML.
-  def render_js(js_expression, options = {})
-    result = render_js_internal(js_expression, options)
-    "#{result[0]}\n#{result[1]}".html_safe
-  end
+    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)}
+  });
+})()
+    JS
 
-  private
-  # Takes javascript code and returns the output from it. This is called by react_component, which
-  # sets up the JS code for rendering a react component.
-  # This method could be used by itself to render the output of any javascript that returns a
-  # string of proper HTML.
-  # Returns Array [0]: html, [1]: script to console log
-  def render_js_internal(js_expression, options = {})
-    # TODO: This should be changed so that we don't create a new context every time
-    # Example of doing this here: https://github.com/reactjs/react-rails/tree/master/lib/react/rails
-    ReactOnRails::ReactRenderer.render_js(js_expression,
-                                          options)
+    ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+  rescue ExecJS::ProgramError => err
+    raise ReactOnRails::ServerRenderingPool::PrerenderError.new(react_component_name, props_string, err)
   end
 
-
   def trace(options)
     options.fetch(:trace) { ReactOnRails.configuration.trace }
   end
@@ -154,85 +166,4 @@ module ReactOnRailsHelper
   def replay_console(options)
     options.fetch(:replay_console) { ReactOnRails.configuration.replay_console }
   end
-
-  def debug_js(react_component_name, data_variable, dom_id, trace)
-    if trace
-      "console.log(\"RENDERED #{react_component_name} with data_variable"\
-      " #{data_variable} to dom node with id: #{dom_id}\");"
-    else
-      ""
-    end
-  end
-
-  # react_component_name: See app/helpers/react_on_rails_helper.rb:5
-  # props_string: is either the variable name used to hold the props (client side) or the
-  #   stringified hash of props from the Ruby server side. In terms of the view helper, one is
-  #   simply passing in the Ruby Hash of props.
-  #
-  # Returns the JavaScript code to generate a React element.
-  def render_js_react_element(react_component_name, props_string, generator_function)
-    # "this" is defined by the calling context which is "global" in the execJs
-    # environment or window in the client side context.
-    js_create_element = if generator_function
-                          "#{react_component_name}(props)"
-                        else
-                          "React.createElement(#{react_component_name}, props)"
-                        end
-
-    <<-JS
-(function(React) {
-          var props = #{props_string};
-          return #{js_create_element};
-        })(this.React);
-    JS
-  end
-
-  def define_render_if_dom_node_present(react_component_name, data_variable, dom_id, trace, generator_function)
-    inner_js_code = <<-JS_CODE
-      var domNode = document.getElementById('#{dom_id}');
-      if (domNode) {
-        #{debug_js(react_component_name, data_variable, dom_id, trace)}
-        var reactElement = #{render_js_react_element(react_component_name, data_variable, generator_function)}
-        React.render(reactElement, domNode);
-      }
-JS_CODE
-
-    <<-JS
-  var renderIfDomNodePresent = function() {
-#{ReactOnRails::ReactRenderer.wrap_code_with_exception_handler(inner_js_code, react_component_name)}
-  }
-    JS
-  end
-
-  def non_turbolinks_bootstrap
-    <<-JS
-    document.addEventListener("DOMContentLoaded", function(event) {
-      console.log("DOMContentLoaded event fired");
-      renderIfDomNodePresent();
-    });
-    JS
-  end
-
-  def turbolinks_bootstrap(dom_id)
-    <<-JS
-  var turbolinksInstalled = typeof(Turbolinks) !== 'undefined';
-  if (!turbolinksInstalled) {
-    console.warn("WARNING: NO TurboLinks detected in JS, but it's in your Gemfile");
-#{non_turbolinks_bootstrap}
-  } else {
-    function onPageChange(event) {
-      var removePageChangeListener = function() {
-        document.removeEventListener("page:change", onPageChange);
-        document.removeEventListener("page:before-unload", removePageChangeListener);
-        var domNode = document.getElementById('#{dom_id}');
-        React.unmountComponentAtNode(domNode);
-      };
-      document.addEventListener("page:before-unload", removePageChangeListener);
-
-      renderIfDomNodePresent();
-    }
-    document.addEventListener("page:change", onPageChange);
-  }
-    JS
-  end
 end

data/lib/react_on_rails/server_rendering_pool.rb

@@ -9,9 +9,11 @@ module ReactOnRails
       @@js_context_pool = ConnectionPool.new(options) { create_js_context }
     end
 
-    def self.render(js_code)
+    def self.eval_js(js_code)
       @@js_context_pool.with do |js_context|
-        js_context.eval(js_code)
+        result = js_context.eval(js_code)
+        js_context.eval(CLEAR_CONSOLE)
+        result
       end
     end
 
@@ -22,6 +24,7 @@ module ReactOnRails
         base_js_code = <<-JS
 #{CONSOLE_POLYFILL}
 #{bundle_js_code};
+#{::Rails.application.assets['react_on_rails.js'].to_s};
         JS
         ExecJS.compile(base_js_code)
       else
@@ -32,6 +35,10 @@ module ReactOnRails
       end
     end
 
+    CLEAR_CONSOLE = <<-JS
+      console.history = []
+    JS
+
     # Reimplement console methods for replaying on the client
     CONSOLE_POLYFILL = <<-JS
 var console = { history: [] };
@@ -53,5 +60,42 @@ var console = { history: [] };
         super(message)
       end
     end
+
+    # js_code: JavaScript expression that returns a string.
+    # Returns an Array:
+    # [0]: string of HTML for direct insertion on the page by evaluating js_code
+    # [1]: console messages
+    #   Note, js_code does not have to be based on React.
+    # js_code MUST RETURN json stringify array of two elements
+    # Calling code will probably call 'html_safe' on return value before rendering to the view.
+    def self.server_render_js_with_console_logging(js_code)
+      if ENV["TRACE_REACT_ON_RAILS"].present? # Set to anything to print generated code.
+        puts "Z" * 80
+        puts "react_renderer.rb: 92"
+        puts "wrote file tmp/server-generated.js"
+        File.write("tmp/server-generated.js", js_code)
+        puts "Z" * 80
+      end
+
+      json_string = eval_js(js_code)
+      # element 0 is the html, element 1 is the script tag for the server console output
+      result = JSON.parse(json_string)
+
+      if ReactOnRails.configuration.logging_on_server
+        console_script = result[1]
+        console_script_lines = console_script.split("\n")
+        console_script_lines = console_script_lines[2..-2]
+        re = /console\.log\.apply\(console, \["\[SERVER\] (?<msg>.*)"\]\);/
+        if console_script_lines
+          console_script_lines.each do |line|
+            match = re.match(line)
+            if match
+              Rails.logger.info { "[react_on_rails] #{match[:msg]}" }
+            end
+          end
+        end
+      end
+      result
+    end
   end
 end

data/lib/react_on_rails/version.rb

@@ -1,3 +1,3 @@
 module ReactOnRails
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: react_on_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Justin Gordon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-28 00:00:00.000000000 Z
+date: 2015-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -145,11 +145,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/assets/javascripts/react_on_rails.js
 - app/helpers/react_on_rails_helper.rb
 - docker-compose.yml
 - lib/react_on_rails.rb
 - lib/react_on_rails/configuration.rb
-- lib/react_on_rails/react_renderer.rb
 - lib/react_on_rails/server_rendering_pool.rb
 - lib/react_on_rails/version.rb
 - react_on_rails.gemspec

data/lib/react_on_rails/react_renderer.rb

@@ -1,137 +0,0 @@
-# Kudos to react-rails for how to do the polyfill of the console!
-# https://github.com/reactjs/react-rails/blob/master/lib/react/server_rendering/sprockets_renderer.rb
-
-# require 'react_on_rails/server_rendering_pool'
-
-module ReactOnRails
-  class ReactRenderer
-    # Script to write to the browser console.
-    # NOTE: result comes from enclosing closure and is the server generated HTML
-    # that we intend to write to the browser. Thus, the script tag will get executed right after
-    # the HTML is rendered.
-    CONSOLE_REPLAY = <<-JS
-    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) + ');';
-      });
-      consoleReplay += '\\n</script>';
-    }
-    JS
-
-    DEBUGGER = <<-JS
-      if (typeof window !== 'undefined') { debugger; }
-    JS
-
-    # js_code: JavaScript expression that returns a string.
-    # Returns an Array:
-    # [0]: string of HTML for direct insertion on the page by evaluating js_code
-    # [1]: console messages
-    #   Note, js_code does not have to be based on React.
-    # Calling code will probably call 'html_safe' on return value before rendering to the view.
-    def self.render_js(js_code, options = {})
-      component_name = options.fetch(:react_component_name, "")
-      server_side = options.fetch(:server_side, false)
-
-      result_js_code = "      htmlResult = #{js_code}"
-
-      js_code_wrapper = <<-JS
-  (function () {
-    var htmlResult = '';
-    var consoleReplay = '';
-#{ReactOnRails::ReactRenderer.wrap_code_with_exception_handler(result_js_code, component_name)}
-#{console_replay_js_code(options)}
-    return JSON.stringify([htmlResult, consoleReplay]);
-  })()
-      JS
-
-      if ENV["TRACE_REACT_ON_RAILS"].present? # Set to anything to print generated code.
-        puts "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ"
-        puts "react_renderer.rb: 92"
-        puts "wrote file tmp/server-generated.js"
-        File.write("tmp/server-generated.js", js_code_wrapper)
-        puts "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ"
-      end
-
-      json_string = ReactOnRails::ServerRenderingPool.render(js_code_wrapper)
-      # element 0 is the html, element 1 is the script tag for the server console output
-      result = JSON.parse(json_string)
-
-      if ReactOnRails.configuration.logging_on_server
-        console_script = result[1]
-        console_script_lines = console_script.split("\n")
-        console_script_lines = console_script_lines[2..-2]
-        re = /console\.log\.apply\(console, \["\[SERVER\] (?<msg>.*)"\]\);/
-        if console_script_lines
-          console_script_lines.each do |line|
-            match = re.match(line)
-            if match
-              Rails.logger.info { "[react_on_rails] #{match[:msg]}" }
-            end
-          end
-        end
-      end
-      return result
-    end
-
-    def self.wrap_code_with_exception_handler(js_code, component_name)
-      <<-JS
-    try {
-#{js_code}
-    }
-    catch(e) {
-      var lineOne =
-            'ERROR: You specified the option generator_function (could be in your defaults) to be\\n';
-      var lastLine =
-            'A generator function takes a single arg of props and returns a ReactElement.';
-
-      var msg = '';
-      var shouldBeGeneratorError = lineOne +
-            'false, but the React component \\'#{component_name}\\' seems to be a generator function.\\n' +
-      lastLine;
-      var reMatchShouldBeGeneratorError = /Can't add property context, object is not extensible/;
-      if (reMatchShouldBeGeneratorError.test(e.message)) {
-        msg += shouldBeGeneratorError + '\\n\\n';
-        console.error(shouldBeGeneratorError);
-      }
-
-      var shouldBeGeneratorError = lineOne +
-            'true, but the React component \\'#{component_name}\\' is not a generator function.\\n' +
-      lastLine;
-      var reMatchShouldNotBeGeneratorError = /Cannot call a class as a function/;
-      if (reMatchShouldNotBeGeneratorError.test(e.message)) {
-        msg += shouldBeGeneratorError + '\\n\\n';
-        console.error(shouldBeGeneratorError);
-      }
-
-      #{render_error_messages}
-    }
-      JS
-    end
-
-    private
-
-    def self.render_error_messages
-      <<-JS
-      console.error('Exception in rendering!');
-      if (e.fileName) {
-        console.error('location: ' + e.fileName + ':' + e.lineNumber);
-      }
-      console.error('message: ' + e.message);
-      console.error('stack: ' + e.stack);
-      msg += 'Exception in rendering!\\n' +
-        (e.fileName ? '\\nlocation: ' + e.fileName + ':' + e.lineNumber : '') +
-        '\\nMessage: ' + e.message + '\\n\\n' + e.stack;
-
-      var reactElement = React.createElement('pre', null, msg);
-      result = React.renderToString(reactElement);
-      JS
-    end
-
-    def self.console_replay_js_code(options)
-      replay_console = options.fetch(:replay_console) { ReactOnRails.configuration.replay_console }
-      (replay_console || ReactOnRails.configuration.logging_on_server) ? CONSOLE_REPLAY : ""
-    end
-  end
-end