react-rails 2.7.1 → 3.0.0.rc.0

data/lib/react/jsx/jsx_transformer.rb

@@ -1,26 +1,28 @@
+# frozen_string_literal: true
+
 module React
   module JSX
     # A {React::JSX}-compliant transformer which uses the deprecated `JSXTransformer.js` to transform JSX.
     class JSXTransformer
-      DEFAULT_ASSET_PATH = 'JSXTransformer.js'
+      DEFAULT_ASSET_PATH = "JSXTransformer.js"
 
       def initialize(options)
         @transform_options = {
           stripTypes: options.fetch(:strip_types, false),
-          harmony:    options.fetch(:harmony, false)
+          harmony: options.fetch(:harmony, false)
         }
 
         @asset_path = options.fetch(:asset_path, DEFAULT_ASSET_PATH)
 
         # If execjs uses therubyracer, there is no 'global'. Make sure
         # we have it so JSX script can work properly.
-        js_code = 'var global = global || this;' + jsx_transform_code
+        js_code = "var global = global || this;#{jsx_transform_code}"
         @context = ExecJS.compile(js_code)
       end
 
       def transform(code)
-        result = @context.call('JSXTransformer.transform', code, @transform_options)
-        result['code']
+        result = @context.call("JSXTransformer.transform", code, @transform_options)
+        result["code"]
       end
 
       # search for transformer file using sprockets - allows user to override

data/lib/react/jsx/processor.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module React
   module JSX
     # A Sprockets 3+-compliant processor
     class Processor
       def self.call(input)
-        JSX::transform(input[:data])
+        JSX.transform(input[:data])
       end
     end
   end

data/lib/react/jsx/sprockets_strategy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module JSX
     # Depending on the Sprockets version,
@@ -17,15 +19,15 @@ module React
       # @param [Symbol, Nil] A strategy name, or `nil` to detect a strategy
       def attach_with_strategy(sprockets_env, strategy_or_nil)
         strategy = strategy_or_nil || detect_strategy
-        self.public_send(strategy, sprockets_env)
+        public_send(strategy, sprockets_env)
       end
 
       # @return [Symbol] based on the environment, return a method name to call with the sprockets environment
       def detect_strategy
         sprockets_version = Gem::Version.new(Sprockets::VERSION)
-        if sprockets_version >= Gem::Version.new('4.a')
+        if sprockets_version >= Gem::Version.new("4.a")
           :register_processors
-        elsif sprockets_version >= Gem::Version.new('3.0.0')
+        elsif sprockets_version >= Gem::Version.new("3.0.0")
           :register_engine_with_mime_type
         else
           :register_engine
@@ -33,20 +35,24 @@ module React
       end
 
       def register_engine(sprockets_env)
-        sprockets_env.register_engine('.jsx', React::JSX::Template)
+        sprockets_env.register_engine(".jsx", React::JSX::Template)
       end
 
       def register_engine_with_mime_type(sprockets_env)
-        sprockets_env.register_engine('.jsx', React::JSX::Processor, mime_type: 'application/javascript', silence_deprecation: true)
+        sprockets_env.register_engine(".jsx", React::JSX::Processor, mime_type: "application/javascript",
+                                                                     silence_deprecation: true)
       end
 
       def register_processors(sprockets_env)
-        sprockets_env.register_mime_type('application/jsx', extensions: ['.jsx', '.js.jsx', '.es.jsx', '.es6.jsx'])
-        sprockets_env.register_mime_type('application/jsx+coffee', extensions: ['.jsx.coffee', '.js.jsx.coffee'])
-        sprockets_env.register_transformer('application/jsx', 'application/javascript', React::JSX::Processor)
-        sprockets_env.register_transformer('application/jsx+coffee', 'application/jsx', Sprockets::CoffeeScriptProcessor)
-        sprockets_env.register_preprocessor('application/jsx', Sprockets::DirectiveProcessor.new(comments: ['//', ['/*', '*/']]))
-        sprockets_env.register_preprocessor('application/jsx+coffee', Sprockets::DirectiveProcessor.new(comments: ['#', ['###', '###']]))
+        sprockets_env.register_mime_type("application/jsx", extensions: [".jsx", ".js.jsx", ".es.jsx", ".es6.jsx"])
+        sprockets_env.register_mime_type("application/jsx+coffee", extensions: [".jsx.coffee", ".js.jsx.coffee"])
+        sprockets_env.register_transformer("application/jsx", "application/javascript", React::JSX::Processor)
+        sprockets_env.register_transformer("application/jsx+coffee", "application/jsx",
+                                           Sprockets::CoffeeScriptProcessor)
+        sprockets_env.register_preprocessor("application/jsx",
+                                            Sprockets::DirectiveProcessor.new(comments: ["//", ["/*", "*/"]]))
+        sprockets_env.register_preprocessor("application/jsx+coffee",
+                                            Sprockets::DirectiveProcessor.new(comments: ["#", ["###", "###"]]))
       end
     end
   end

data/lib/react/jsx/template.rb

@@ -1,16 +1,17 @@
-require 'tilt'
+# frozen_string_literal: true
+
+require "tilt"
 
 module React
   module JSX
     # Sprockets 2-compliant processor
     class Template < Tilt::Template
-      self.default_mime_type = 'application/javascript'
+      self.default_mime_type = "application/javascript"
 
-      def prepare
-      end
+      def prepare; end
 
-      def evaluate(scope, locals, &block)
-        @output ||= JSX::transform(data)
+      def evaluate(_scope, _locals)
+        @evaluate ||= JSX.transform(data)
       end
     end
   end

data/lib/react/jsx.rb

@@ -1,10 +1,12 @@
-require 'execjs'
-require 'react/jsx/processor'
-require 'react/jsx/template'
-require 'react/jsx/jsx_transformer'
-require 'react/jsx/babel_transformer'
-require 'react/jsx/sprockets_strategy'
-require 'rails'
+# frozen_string_literal: true
+
+require "execjs"
+require "react/jsx/processor"
+require "react/jsx/template"
+require "react/jsx/jsx_transformer"
+require "react/jsx/babel_transformer"
+require "react/jsx/sprockets_strategy"
+require "rails"
 
 module React
   module JSX

data/lib/react/rails/asset_variant.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # This class accepts some options for which build you want, then exposes where you can find
     # them. In general, these paths should be added to the sprockets environment.
     class AssetVariant
-      GEM_ROOT = Pathname.new('../../../../').expand_path(__FILE__)
+      GEM_ROOT = Pathname.new("../../../../").expand_path(__FILE__)
       # @return [String] "production" or "development"
       attr_reader :react_build
 
@@ -15,12 +17,11 @@ module React
 
       # @param [Hash] Options for the asset variant
       # @option variant [Symbol] if `:production`, use the minified React.js build
-      def initialize(options={})
-
-        @react_build = options[:variant] == :production ? 'production' : 'development'
+      def initialize(options = {})
+        @react_build = options[:variant] == :production ? "production" : "development"
 
-        @react_directory = GEM_ROOT.join('lib/assets/react-source/').join(@react_build).to_s
-        @jsx_directory =   GEM_ROOT.join('lib/assets/javascripts/').to_s
+        @react_directory = GEM_ROOT.join("lib/assets/react-source/").join(@react_build).to_s
+        @jsx_directory =   GEM_ROOT.join("lib/assets/javascripts/").to_s
       end
     end
   end

data/lib/react/rails/component_mount.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # This is the default view helper implementation.
@@ -9,6 +11,7 @@ module React
       include ActionView::Helpers::TagHelper
       include ActionView::Helpers::TextHelper
       attr_accessor :output_buffer
+
       mattr_accessor :camelize_props_switch
 
       def initialize
@@ -21,57 +24,62 @@ module React
         @controller = controller
       end
 
-      def teardown(controller)
-      end
+      def teardown(controller); end
 
       # Render a UJS-type HTML tag annotated with data attributes, which
       # are used by react_ujs to actually instantiate the React component
       # on the client.
       def react_component(name, props = {}, options = {}, &block)
-        options = { :tag => options } if options.is_a?(Symbol)
-        if options.fetch(:camelize_props, camelize_props_switch)
-          props = React.camelize_props(props)
-        end
+        options = { tag: options } if options.is_a?(Symbol)
+        props = React.camelize_props(props) if options.fetch(:camelize_props, camelize_props_switch)
 
         prerender_options = options[:prerender]
-        if prerender_options
-          block = Proc.new{ concat(prerender_component(name, props, prerender_options)) }
-        end
+        block = proc { concat(prerender_component(name, props, prerender_options)) } if prerender_options
+
+        html_options = generate_html_options(name, options, props, prerender_options)
+
+        rendered_tag(html_options, &block)
+      end
+
+      private
+
+      # If this controller has checked out a renderer, use that one.
+      # Otherwise, use {React::ServerRendering} directly (which will check one out for this rendering).
+      def prerender_component(component_name, props, prerender_options)
+        renderer = @controller.try(:react_rails_prerenderer) || React::ServerRendering
+        renderer.render(component_name, props, prerender_options)
+      end
+
+      def generate_html_options(name, options, props, prerender_options)
+        html_options = options.reverse_merge(data: {})
 
-        html_options = options.reverse_merge(:data => {})
         unless prerender_options == :static
           html_options[:data].tap do |data|
             data[:react_class] = name
             data[:react_props] = (props.is_a?(String) ? props : props.to_json)
-            data[:hydrate] = 't' if prerender_options
+            data[:hydrate] = "t" if prerender_options
 
             num_components = @cache_ids.count { |c| c.start_with? name }
             data[:react_cache_id] = "#{name}-#{num_components}"
           end
         end
+
+        html_options
+      end
+
+      def rendered_tag(html_options, &block)
         html_tag = html_options[:tag] || :div
 
         # remove internally used properties so they aren't rendered to DOM
-        html_options.except!(:tag, :prerender, :camelize_props)
-
-        rendered_tag = content_tag(html_tag, '', html_options, &block)
-        if React::ServerRendering.renderer_options[:replay_console]
-          # Grab the server-rendered console replay script
-          # and move it _outside_ the container div
-          rendered_tag.sub!(/\n(<script class="react-rails-console-replay">.*<\/script>)<\/(\w+)>$/m,'</\2>\1')
-          rendered_tag.html_safe
-        else
-          rendered_tag
-        end
-      end
+        html_option_to_use = html_options.except(:tag, :prerender, :camelize_props)
 
-      private
+        tag = content_tag(html_tag, "", html_option_to_use, &block)
+        return tag unless React::ServerRendering.renderer_options[:replay_console]
 
-      # If this controller has checked out a renderer, use that one.
-      # Otherwise, use {React::ServerRendering} directly (which will check one out for this rendering).
-      def prerender_component(component_name, props, prerender_options)
-        renderer = @controller.try(:react_rails_prerenderer) || React::ServerRendering
-        renderer.render(component_name, props, prerender_options)
+        # Grab the server-rendered console replay script
+        # and move it _outside_ the container div
+        tag.sub!(%r{\n(<script class="react-rails-console-replay">.*</script>)</(\w+)>$}m, '</\2>\1')
+        tag.html_safe
       end
     end
   end

data/lib/react/rails/controller_lifecycle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # This module is included into ActionController so that

data/lib/react/rails/controller_renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # A renderer class suitable for `ActionController::Renderers`.
@@ -20,7 +22,7 @@ module React
 
       attr_accessor :output_buffer
 
-      def initialize(options={})
+      def initialize(options = {})
         controller = options[:controller]
         @__react_component_helper = controller.__react_component_helper
       end

data/lib/react/rails/railtie.rb

@@ -1,4 +1,6 @@
-require 'rails'
+# frozen_string_literal: true
+
+require "rails"
 
 module React
   module Rails
@@ -17,18 +19,17 @@ module React
       config.react.server_renderer            = nil # defaults to BundleRenderer
       config.react.server_renderer_options    = {}  # BundleRenderer provides defaults
       # Changing files with these extensions in these directories will cause the server renderer to reload:
-      config.react.server_renderer_directories = ['/app/assets/javascripts/', 'app/javascript']
-      config.react.server_renderer_extensions = ['jsx', 'js']
+      config.react.server_renderer_directories = ["/app/assets/javascripts/", "app/javascript"]
+      config.react.server_renderer_extensions = %w[jsx js]
       # View helper implementation:
       config.react.view_helper_implementation = nil # Defaults to ComponentMount
 
       # Watch .jsx files for changes in dev, so we can reload the JS VMs with the new JS code.
-      initializer 'react_rails.add_watchable_files', after: :load_config_initializers, group: :all do |app|
+      initializer "react_rails.add_watchable_files", after: :load_config_initializers, group: :all do |app|
         # Watch files ending in `server_renderer_extensions` in each of `server_renderer_directories`
-        reload_paths = config.react.server_renderer_directories.reduce({}) do |memo, dir|
+        reload_paths = config.react.server_renderer_directories.each_with_object({}) do |dir, memo|
           app_dir = File.join(app.root, dir)
           memo[app_dir] = config.react.server_renderer_extensions
-          memo
         end
 
         # Rails checks these objects for changes:
@@ -42,8 +43,7 @@ module React
       end
 
       # Include the react-rails view helper lazily
-      initializer 'react_rails.setup_view_helpers', after: :load_config_initializers, group: :all do |app|
-
+      initializer "react_rails.setup_view_helpers", after: :load_config_initializers, group: :all do |app|
         app.config.react.jsx_transformer_class ||= React::JSX::DEFAULT_TRANSFORMER
         React::JSX.transformer_class = app.config.react.jsx_transformer_class
         React::JSX.transform_options = app.config.react.jsx_transform_options
@@ -58,11 +58,11 @@ module React
 
         ActiveSupport.on_load(:action_view) do
           include ::React::Rails::ViewHelper
-          ActionDispatch::IntegrationTest.send(:include, React::Rails::TestHelper) if ::Rails.env.test?
+          ActionDispatch::IntegrationTest.include React::Rails::TestHelper if ::Rails.env.test?
         end
       end
 
-      initializer 'react_rails.add_component_renderer', group: :all do |app|
+      initializer "react_rails.add_component_renderer", group: :all do |_app|
         ActionController::Renderers.add :component do |component_name, options|
           renderer = ::React::Rails::ControllerRenderer.new(controller: self)
           html = renderer.call(component_name, options)
@@ -71,22 +71,21 @@ module React
         end
       end
 
-      initializer 'react_rails.bust_cache', after: :load_config_initializers, group: :all do |app|
+      initializer "react_rails.bust_cache", after: :load_config_initializers, group: :all do |app|
         asset_variant = React::Rails::AssetVariant.new({
-          variant: app.config.react.variant,
-        })
+                                                         variant: app.config.react.variant
+                                                       })
 
         sprockets_env = app.assets || app.config.try(:assets) # sprockets-rails 3.x attaches this at a different config
         unless sprockets_env.nil?
-          sprockets_env.version = [sprockets_env.version, "react-#{asset_variant.react_build}"].compact.join('-')
+          sprockets_env.version = [sprockets_env.version, "react-#{asset_variant.react_build}"].compact.join("-")
         end
-
       end
 
-      initializer 'react_rails.set_variant', after: :engines_blank_point, group: :all do |app|
+      initializer "react_rails.set_variant", after: :engines_blank_point, group: :all do |app|
         asset_variant = React::Rails::AssetVariant.new({
-          variant: app.config.react.variant,
-        })
+                                                         variant: app.config.react.variant
+                                                       })
 
         if app.config.respond_to?(:assets)
           app.config.assets.paths << asset_variant.react_directory
@@ -105,16 +104,14 @@ module React
         React::ServerRendering.reset_pool
       end
 
-      initializer 'react_rails.setup_engine', :group => :all do |app|
+      initializer "react_rails.setup_engine", group: :all do |app|
         # Sprockets 3.x expects this in a different place
-        sprockets_env = app.assets || defined?(Sprockets) && Sprockets
+        sprockets_env = app.assets || (defined?(Sprockets) && Sprockets)
 
         if app.config.react.sprockets_strategy == false
           # pass, Sprockets opt-out
         elsif sprockets_env.present?
           React::JSX::SprocketsStrategy.attach_with_strategy(sprockets_env, app.config.react.sprockets_strategy)
-        else
-          # pass, Sprockets is not preset
         end
       end
     end

data/lib/react/rails/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     module TestHelper
@@ -20,4 +22,4 @@ module React
       end
     end
   end
-end
+end

data/lib/react/rails/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # If you change this, make sure to update VERSIONS.md
     # and republish the UJS by updating package.json and `bundle exec rake ujs:publish`
-    VERSION = '2.7.1'
+    VERSION = "3.0.0.rc.0"
   end
 end

data/lib/react/rails/view_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     module ViewHelper
@@ -18,7 +20,7 @@ module React
       # Otherwise, make a new instance.
       def react_component(*args, &block)
         helper_obj = @__react_component_helper ||= helper_implementation_class.new
-        helper_obj.react_component(*args) { capture &block if block_given? }
+        helper_obj.react_component(*args) { capture(&block) if block }
       end
     end
   end

data/lib/react/rails.rb

@@ -1,7 +1,9 @@
-require 'react/rails/asset_variant'
-require 'react/rails/railtie'
-require 'react/rails/controller_lifecycle'
-require 'react/rails/version'
-require 'react/rails/component_mount'
-require 'react/rails/view_helper'
-require 'react/rails/controller_renderer'
+# frozen_string_literal: true
+
+require "react/rails/asset_variant"
+require "react/rails/railtie"
+require "react/rails/controller_lifecycle"
+require "react/rails/version"
+require "react/rails/component_mount"
+require "react/rails/view_helper"
+require "react/rails/controller_renderer"

data/lib/react/server_rendering/bundle_renderer.rb

@@ -1,27 +1,29 @@
-require 'react/server_rendering/environment_container'
-require 'react/server_rendering/manifest_container'
-require 'react/server_rendering/webpacker_manifest_container'
-require 'react/server_rendering/yaml_manifest_container'
+# frozen_string_literal: true
+
+require "react/server_rendering/environment_container"
+require "react/server_rendering/manifest_container"
+require "react/server_rendering/yaml_manifest_container"
+require "react/server_rendering/separate_server_bundle_container"
 
 module React
   module ServerRendering
     # Extends ExecJSRenderer for the Rails environment
-    # - fetches JS code from the Rails app (webpacker or sprockets)
+    # - fetches JS code from the Rails app (Shakapacker or Sprockets)
     # - stringifies props
     # - implements console replay
     class BundleRenderer < ExecJSRenderer
       # Reimplement console methods for replaying on the client
-      CONSOLE_POLYFILL = File.read(File.join(File.dirname(__FILE__), 'bundle_renderer/console_polyfill.js'))
-      CONSOLE_REPLAY   = File.read(File.join(File.dirname(__FILE__), 'bundle_renderer/console_replay.js'))
-      CONSOLE_RESET    = File.read(File.join(File.dirname(__FILE__), 'bundle_renderer/console_reset.js'))
-      TIMEOUT_POLYFILL = File.read(File.join(File.dirname(__FILE__), 'bundle_renderer/timeout_polyfill.js'))
+      CONSOLE_POLYFILL = File.read(File.join(File.dirname(__FILE__), "bundle_renderer/console_polyfill.js"))
+      CONSOLE_REPLAY   = File.read(File.join(File.dirname(__FILE__), "bundle_renderer/console_replay.js"))
+      CONSOLE_RESET    = File.read(File.join(File.dirname(__FILE__), "bundle_renderer/console_reset.js"))
+      TIMEOUT_POLYFILL = File.read(File.join(File.dirname(__FILE__), "bundle_renderer/timeout_polyfill.js"))
 
-      def initialize(options={})
+      def initialize(options = {})
         @replay_console = options.fetch(:replay_console, true)
-        filenames = options.fetch(:files, ['server_rendering.js'])
+        filenames = options.fetch(:files, ["server_rendering.js"])
         js_code = CONSOLE_POLYFILL.dup
         js_code << TIMEOUT_POLYFILL.dup
-        js_code << options.fetch(:code, '')
+        js_code << options.fetch(:code, "")
 
         filenames.each do |filename|
           js_code << asset_container.find_asset(filename)
@@ -40,12 +42,12 @@ module React
         super(component_name, t_props, t_options)
       end
 
-      def before_render(component_name, props, prerender_options)
-        @replay_console ? CONSOLE_RESET : ''
+      def before_render(_component_name, _props, _prerender_options)
+        @replay_console ? CONSOLE_RESET : ""
       end
 
-      def after_render(component_name, props, prerender_options)
-        @replay_console ? CONSOLE_REPLAY : ''
+      def after_render(_component_name, _props, _prerender_options)
+        @replay_console ? CONSOLE_REPLAY : ""
       end
 
       class << self
@@ -71,20 +73,19 @@ module React
       def prepare_options(options)
         r_func = render_function(options)
         opts = case options
-          when Hash then options
-          when TrueClass then {}
-          else
-            {}
-        end
+               when Hash then options
+               else
+                 {}
+               end
         # This seems redundant to pass
         opts.merge(render_function: r_func)
       end
 
       def render_function(opts)
         if opts == :static
-          'renderToStaticMarkup'.freeze
+          "renderToStaticMarkup"
         else
-          'renderToString'.freeze
+          "renderToString"
         end
       end
 
@@ -100,22 +101,16 @@ module React
       # Or, if the user has provided {.asset_container_class}, use that.
       # @return [Class] suitable for {#asset_container}
       def asset_container_class
-        if self.class.asset_container_class.present?
-          self.class.asset_container_class
-        elsif WebpackerManifestContainer.compatible?
-          WebpackerManifestContainer
-        elsif assets_precompiled?
-          if ManifestContainer.compatible?
-            ManifestContainer
-          elsif YamlManifestContainer.compatible?
-            YamlManifestContainer
-          else
-            # Even though they are precompiled, we can't find them :S
-            EnvironmentContainer
-          end
-        else
-          EnvironmentContainer
-        end
+        return self.class.asset_container_class if self.class.asset_container_class.present?
+        return SeparateServerBundleContainer if SeparateServerBundleContainer.compatible?
+
+        return EnvironmentContainer unless assets_precompiled?
+
+        return ManifestContainer if ManifestContainer.compatible?
+        return YamlManifestContainer if YamlManifestContainer.compatible?
+
+        # Even though they are precompiled, we can't find them :S
+        EnvironmentContainer
       end
     end
   end

data/lib/react/server_rendering/environment_container.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module ServerRendering
     # Return asset contents by getting them from a Sprockets::Environment instance.

data/lib/react/server_rendering/exec_js_renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module ServerRendering
     # A bare-bones renderer for React.js + Exec.js
@@ -8,9 +10,11 @@ module React
       # @return [ExecJS::Runtime::Context] The JS context for this renderer
       attr_reader :context
 
-      def initialize(options={})
-        js_code = options[:code] || raise('Pass `code:` option to instantiate a JS context!')
-        @context = ExecJS.compile(GLOBAL_WRAPPER + js_code)
+      def initialize(options = {})
+        js_code = options[:code] || raise("Pass `code:` option to instantiate a JS context!")
+        full_code = GLOBAL_WRAPPER + js_code
+        # File.write("./test/dummy/tmp/latest_js_context.js", full_code)
+        @context = ExecJS.compile(full_code)
       end
 
       def render(component_name, props, prerender_options)
@@ -23,8 +27,13 @@ module React
       end
 
       # Hooks for inserting JS before/after rendering
-      def before_render(component_name, props, prerender_options); ''; end
-      def after_render(component_name, props, prerender_options); ''; end
+      def before_render(_component_name, _props, _prerender_options)
+        ""
+      end
+
+      def after_render(_component_name, _props, _prerender_options)
+        ""
+      end
 
       # Handle Node.js & other ExecJS contexts
       GLOBAL_WRAPPER = <<-JS
@@ -40,7 +49,7 @@ module React
       end
 
       def main_render(component_name, props, prerender_options)
-        render_function = prerender_options.fetch(:render_function, 'renderToString')
+        render_function = prerender_options.fetch(:render_function, "renderToString")
         "this.ReactRailsUJS.serverRender('#{render_function}', '#{component_name}', #{props})"
       end