react_on_rails 11.0.0 → 11.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31c09a3e5f99dd68c101be042157d0df07ce3d28
-  data.tar.gz: c1b5a351538f6f66b02fd6b7d9dbc9016f9b7a5a
+  metadata.gz: 5dab379803c8e9755573723bf8f5d13189d61254
+  data.tar.gz: 0c85fc367c83791aaa117a6a07661b6bee147ba7
 SHA512:
-  metadata.gz: ed448da2f9649ab1fe01df7e3f9f5391a0ab0a0d00d19588d4d4ec7463d0967ba4680c820175e20dc4c9a083561aa7783c9d0925c0a9013c8e0af49755c23309
-  data.tar.gz: c4db1f97a32d563a83e11fd0987160cabe408caa88fef4880d96be89da8ca752a5218a426370cf1834bdbdc36ea537c3d97bd5b98eb70110fd299d2ac9a72072
+  metadata.gz: ab6c86b708e00be5bb572740c6a980d814199babe92333327bbcfab731ecba0ff106a42d609e1807ba48ad956382488d2c3f2a36b812cbf3368090c9d6378451
+  data.tar.gz: c8a08183a9463ff35a32c64f284005b9bd044369ae4ec24bef4dec67291176ea033cb1ea9448932c56c12a8d79347c4d030de822d8457cd1c5a8bae0c6cb2519

data/CHANGELOG.md

@@ -10,19 +10,29 @@ Changes since last non-beta release.
 
 *Please add entries here for your pull requests that are not yet released.*
 
+### [11.0.1] - 2018-04-23
+
+#### Added
+- `react_component` allows logging_on_server specified at the component level. [PR 1068](https://github.com/shakacode/react_on_rails/pull/1068) by [justin808](https://github.com/justin808).
+
+#### Fixed
+- Missing class when throwing some error messages. [PR 1068](https://github.com/shakacode/react_on_rails/pull/1068) by [justin808](https://github.com/justin808).
+
+### [11.0.0] - 2018-04-21
+
 ## MIGRATION for v11
 - Unused `server_render_method` was removed from the configuration. If you want to use a custom renderer, contact justin@shakacode.com. We have a custom node rendering solution in production for egghead.io.
 - Removed ReactOnRails::Utils.server_bundle_file_name and ReactOnRails::Utils.bundle_file_name. These are part of the performance features of "React on Rails Pro".
 - Removed ENV["TRACE_REACT_ON_RAILS"] usage and replacing it with config.trace.
 
-#### Enhanchements: Better Error Messages, Support for React on Rails Pro
+#### Enhancements: Better Error Messages, Support for React on Rails Pro
 - Tracing (debugging) options are simplified with a single `config.trace` setting that defaults to true for development and false otherwise.
 - Calls to setTimeout, setInterval, clearTimeout will now always log some message if config.trace is true. Your JavaScript code should not be calling setTimout when server rendering. 
 - Errors raised are of type ReactOnRailsError, so you can see they came from React on Rails for debugging.
 - Removed ReactOnRails::Utils.server_bundle_file_name and ReactOnRails::Utils.bundle_file_name.
 - No longer logging the `railsContext` when server logging.
 - Rails.env is provided in the default railsContext, as suggested in [issue #697](https://github.com/shakacode/react_on_rails/issues/697).
-[PR 1018](https://github.com/shakacode/react_on_rails/pull/1065) by [justin808](https://github.com/justin808).
+[PR 1065](https://github.com/shakacode/react_on_rails/pull/1065) by [justin808](https://github.com/justin808).
 
 #### Fixes
 - More exact version checking. We keep the react_on_rails gem and the react-on-rails node package at
@@ -724,7 +734,8 @@ Best done with Object destructing:
 ##### Fixed
 - Fix several generator related issues.
 
-[Unreleased]: https://github.com/shakacode/react_on_rails/compare/10.1.4...master
+[Unreleased]: https://github.com/shakacode/react_on_rails/compare/11.0.0...master
+[11.0.0]: https://github.com/shakacode/react_on_rails/compare/10.1.4...11.0.0
 [10.1.4]: https://github.com/shakacode/react_on_rails/compare/10.1.3...10.1.4
 [10.1.3]: https://github.com/shakacode/react_on_rails/compare/10.1.2...10.1.3
 [10.1.2]: https://github.com/shakacode/react_on_rails/compare/10.1.1...10.1.2

data/README.md

@@ -523,13 +523,17 @@ react_component(component_name,
 ```
 
 + **component_name:** Can be a React component, created using an ES6 class or a generator function that returns a React component (or, only on the server side, an object with shape { redirectLocation, error, renderedHtml }), or a "renderer function" that manually renders a React component to the dom (client side only).
-+ **options:**
+All options except `props, id, html_options` will inherit from your `react_on_rails.rb` initializer, as described [here](./docs/basics/configuration.md).
+
++ **general options:**
   + **props:** Ruby Hash which contains the properties to pass to the react object, or a JSON string. If you pass a string, we'll escape it for you.
   + **prerender:** enable server-side rendering of a component. Set to false when debugging!
   + **id:** Id for the div, will be used to attach the React component. This will get assigned automatically if you do not provide an id. Must be unique.
   + **html_options:** Any other HTML options get placed on the added div for the component. For example, you can set a class (or inline style) on the outer div so that it behaves like a span, with the styling of `display:inline-block`.
-  + **trace:** set to true to print additional debugging information in the browser. Defaults to true for development, off otherwise. Note: on the client, you will see both the `railsContext` and your props. On the server, you only see the `railsContext` being logged.
-  + **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.
+  + **trace:** set to true to print additional debugging information in the browser. Defaults to true for development, off otherwise. Only on the **client side** will you will see the `railsContext` and your props.
++ **options if prerender (server rendering) is true:**
+  + **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 configuration of `logging_on_server` set to true, you'll still see the errors on the server.
+  + **logging_on_server:** Default is true. True will log JS console messages and errors to 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.
 
 ### redux_store

data/docs/basics/upgrading-react-on-rails.md

@@ -2,7 +2,7 @@
 
 ## Upgrading to version 11
 * Remove `server_render_method` from config/initializers/react_on_rails.rb. Alternate server rendering methods are part of React on Rails Pro. If you want to use a custom renderer, contact justin@shakacode.com. We have a custom node rendering solution in production for egghead.io.
-* Remove your usage of ENV["TRACE_REACT_ON_RAILS"] usage. You can get all tracing with either specifying trace at your component or in your config/initializers/react_on_rails.rb file.
+* Remove your usage of ENV["TRACE_REACT_ON_RAILS"] usage. You can get all tracing with either specifying **`trace`** at your component or in your config/initializers/react_on_rails.rb file.
 * ReactOnRails::Utils.server_bundle_file_name and ReactOnRails::Utils.bundle_file_name were removed. React on Rails Pro contains upgrades to enable component and other types caching with React on Rails.
 
 

data/lib/react_on_rails.rb

@@ -10,7 +10,7 @@ require "react_on_rails/version_checker"
 require "react_on_rails/configuration"
 require "react_on_rails/server_rendering_pool"
 require "react_on_rails/engine"
-require "react_on_rails/react_component/options"
+require "react_on_rails/react_component/render_options"
 require "react_on_rails/version_syntax_converter"
 require "react_on_rails/test_helper"
 require "react_on_rails/git_utils"

data/lib/react_on_rails/configuration.rb

@@ -9,6 +9,8 @@ module ReactOnRails
   end
 
   DEFAULT_GENERATED_ASSETS_DIR = File.join(%w[public webpack], Rails.env).freeze
+  DEFAULT_SERVER_RENDER_TIMEOUT = 20
+  DEFAULT_POOL_SIZE = 1
 
   def self.setup_config_values
     ensure_webpack_generated_files_exists
@@ -112,8 +114,8 @@ module ReactOnRails
       raise_on_prerender_error: false,
       trace: Rails.env.development?,
       development_mode: Rails.env.development?,
-      server_renderer_pool_size: 1,
-      server_renderer_timeout: 20,
+      server_renderer_pool_size: DEFAULT_POOL_SIZE,
+      server_renderer_timeout: DEFAULT_SERVER_RENDER_TIMEOUT,
       skip_display_none: nil,
       # skip_display_none is deprecated
       webpack_generated_files: %w[manifest.json],

data/lib/react_on_rails/react_component/{options.rb → render_options.rb}

@@ -4,24 +4,22 @@ require "react_on_rails/utils"
 
 module ReactOnRails
   module ReactComponent
-    class Options
+    class RenderOptions
       include Utils::Required
 
       NO_PROPS = {}.freeze
 
-      def initialize(name: required("name"), options: required("options"))
-        @name = name
+      def initialize(react_component_name: required("react_component_name"), options: required("options"))
+        @react_component_name = react_component_name.camelize
         @options = options
       end
 
+      attr_reader :react_component_name
+
       def props
         options.fetch(:props) { NO_PROPS }
       end
 
-      def name
-        @name.camelize
-      end
-
       def dom_id
         @dom_id ||= options.fetch(:id) { generate_unique_dom_id }
       end
@@ -46,12 +44,20 @@ module ReactOnRails
         retrieve_key(:raise_on_prerender_error)
       end
 
+      def logging_on_server
+        retrieve_key(:logging_on_server)
+      end
+
+      def to_s
+        "{ react_component_name = #{react_component_name}, options = #{options}"
+      end
+
       private
 
       attr_reader :options
 
       def generate_unique_dom_id
-        "#{@name}-react-component-#{SecureRandom.uuid}"
+        "#{react_component_name}-react-component-#{SecureRandom.uuid}"
       end
 
       def retrieve_key(key)

data/lib/react_on_rails/react_on_rails_helper.rb

@@ -98,17 +98,17 @@ module ReactOnRails
     #   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, raw_options = {})
-      internal_result = internal_react_component(component_name, raw_options)
-      server_rendered_html = internal_result["result"]["html"]
-      console_script = internal_result["result"]["consoleReplayScript"]
+    def react_component(component_name, options = {})
+      internal_result = internal_react_component(component_name, options)
+      server_rendered_html = internal_result[:result]["html"]
+      console_script = internal_result[:result]["consoleReplayScript"]
 
       if server_rendered_html.is_a?(String)
         build_react_component_result_for_server_rendered_string(
           server_rendered_html: server_rendered_html,
-          component_specification_tag: internal_result["tag"],
+          component_specification_tag: internal_result[:tag],
           console_script: console_script,
-          options: internal_result["options"]
+          render_options: internal_result[:render_options]
         )
       elsif server_rendered_html.is_a?(Hash)
         msg = <<-MSG.strip_heredoc
@@ -116,7 +116,7 @@ module ReactOnRails
         https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
         for an example of the necessary javascript configuration."
         MSG
-        raise ReactOnRailsPro::Error, msg
+        raise ReactOnRails::Error, msg
 
       else
         msg = <<-MSG.strip_heredoc
@@ -126,17 +126,17 @@ module ReactOnRails
         https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
         for an example of the necessary javascript configuration."
         MSG
-        raise ReactOnRailsPro::Error, msg
+        raise ReactOnRails::Error, msg
       end
     end
 
-    def react_component_hash(component_name, raw_options = {})
-      internal_result = internal_react_component(component_name, raw_options)
-      server_rendered_html = internal_result["result"]["html"]
-      console_script = internal_result["result"]["consoleReplayScript"]
+    def react_component_hash(component_name, options = {})
+      internal_result = internal_react_component(component_name, options)
+      server_rendered_html = internal_result[:result]["html"]
+      console_script = internal_result[:result]["consoleReplayScript"]
 
-      if server_rendered_html.is_a?(String) && internal_result["result"]["hasErrors"]
-        server_rendered_html = { COMPONENT_HTML_KEY => internal_result["result"]["html"] }
+      if server_rendered_html.is_a?(String) && internal_result[:result]["hasErrors"]
+        server_rendered_html = { COMPONENT_HTML_KEY => internal_result[:result]["html"] }
       end
 
       if server_rendered_html.is_a?(Hash)
@@ -144,7 +144,7 @@ module ReactOnRails
           server_rendered_html: server_rendered_html,
           component_specification_tag: internal_result["tag"],
           console_script: console_script,
-          options: internal_result["options"]
+          render_options: internal_result[:render_options]
         )
       else
         msg = <<-MSG.strip_heredoc
@@ -152,7 +152,7 @@ module ReactOnRails
         https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
         for an example of the necessary javascript configuration.
         MSG
-        raise ReactOnRailsPro::Error, msg
+        raise ReactOnRails::Error, msg
       end
     end
 
@@ -199,8 +199,12 @@ module ReactOnRails
     # 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.
+    # Options include:{ prerender:, trace:, raise_on_prerender_error: }
     def server_render_js(js_expression, options = {})
-      wrapper_js = <<-JS.strip_heredoc
+      render_options = ReactOnRails::ReactComponent::RenderOptions
+                       .new(react_component_name: "generic-js", options: options)
+
+      js_code = <<-JS.strip_heredoc
       (function() {
         var htmlResult = '';
         var consoleReplayScript = '';
@@ -228,15 +232,16 @@ module ReactOnRails
       })()
       JS
 
-      result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+      result = ReactOnRails::ServerRenderingPool
+               .server_render_js_with_console_logging(js_code, render_options)
 
       html = result["html"]
       console_log_script = result["consoleLogScript"]
-      raw("#{html}#{replay_console_option(options[:replay_console_option]) ? console_log_script : ''}")
+      raw("#{html}#{render_options.replay_console ? console_log_script : ''}")
     rescue ExecJS::ProgramError => err
       raise ReactOnRails::PrerenderError, component_name: "N/A (server_render_js called)",
                                           err: err,
-                                          js_code: wrapper_js
+                                          js_code: js_code
     end
 
     def json_safe_and_pretty(hash_or_string)
@@ -257,16 +262,16 @@ module ReactOnRails
       server_rendered_html: required("server_rendered_html"),
       component_specification_tag: required("component_specification_tag"),
       console_script: required("console_script"),
-      options: required("options")
+      render_options: required("render_options")
     )
-      content_tag_options = options.html_options
-      content_tag_options[:id] = options.dom_id
+      content_tag_options = render_options.html_options
+      content_tag_options[:id] = render_options.dom_id
 
       rendered_output = content_tag(:div,
                                     server_rendered_html.html_safe,
                                     content_tag_options)
 
-      result_console_script = options.replay_console ? console_script : ""
+      result_console_script = render_options.replay_console ? console_script : ""
       result = compose_react_component_html_with_spec_and_console(
         component_specification_tag, rendered_output, result_console_script
       )
@@ -278,20 +283,20 @@ module ReactOnRails
       server_rendered_html: required("server_rendered_html"),
       component_specification_tag: required("component_specification_tag"),
       console_script: required("console_script"),
-      options: required("options")
+      render_options: required("render_options")
     )
-      content_tag_options = options.html_options
-      content_tag_options[:id] = options.dom_id
+      content_tag_options = render_options.html_options
+      content_tag_options[:id] = render_options.dom_id
 
       unless server_rendered_html[COMPONENT_HTML_KEY]
-        raise ReactOnRailsPro::Error, "server_rendered_html hash expected to contain \"#{COMPONENT_HTML_KEY}\" key."
+        raise ReactOnRails::Error, "server_rendered_html hash expected to contain \"#{COMPONENT_HTML_KEY}\" key."
       end
 
       rendered_output = content_tag(:div,
                                     server_rendered_html[COMPONENT_HTML_KEY].html_safe,
                                     content_tag_options)
 
-      result_console_script = options.replay_console ? console_script : ""
+      result_console_script = render_options.replay_console ? console_script : ""
       result = compose_react_component_html_with_spec_and_console(
         component_specification_tag, rendered_output, result_console_script
       )
@@ -335,7 +340,7 @@ module ReactOnRails
       "#{rails_context_content}\n#{render_value}".html_safe
     end
 
-    def internal_react_component(component_name, raw_options = {})
+    def internal_react_component(react_component_name, options = {})
       # Create the JavaScript and HTML to allow either client or server rendering of the
       # react_component.
       #
@@ -343,27 +348,27 @@ module ReactOnRails
       # (re-hydrate the data). This enables react rendered on the client to see that the
       # server has already rendered the HTML.
 
-      options = ReactOnRails::ReactComponent::Options.new(name: component_name, options: raw_options)
+      render_options = ReactOnRails::ReactComponent::RenderOptions.new(react_component_name: react_component_name,
+                                                                       options: options)
 
       # 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.
       component_specification_tag = content_tag(:script,
-                                                json_safe_and_pretty(options.props).html_safe,
+                                                json_safe_and_pretty(render_options.props).html_safe,
                                                 type: "application/json",
                                                 class: "js-react-on-rails-component",
-                                                "data-component-name" => options.name,
-                                                "data-trace" => (options.trace ? true : nil),
-                                                "data-dom-id" => options.dom_id)
+                                                "data-component-name" => render_options.react_component_name,
+                                                "data-trace" => (render_options.trace ? true : nil),
+                                                "data-dom-id" => render_options.dom_id)
 
       # Create the HTML rendering part
-      result = server_rendered_react_component_html(options.props,
-                                                    options.name,
-                                                    options.dom_id,
-                                                    prerender: options.prerender,
-                                                    trace: options.trace,
-                                                    raise_on_prerender_error: options.raise_on_prerender_error)
-
-      { "options" => options, "tag" => component_specification_tag, "result" => result }
+      result = server_rendered_react_component(render_options)
+
+      {
+        render_options: render_options,
+        tag: component_specification_tag,
+        result: result
+      }
     end
 
     def render_redux_store_data(redux_store_data)
@@ -379,15 +384,12 @@ module ReactOnRails
       props.is_a?(String) ? props : props.to_json
     end
 
-    # Returns Array [0]: html, [1]: script to console log
-    # NOTE, these are NOT html_safe!
-    def server_rendered_react_component_html(
-      props, react_component_name, dom_id,
-      prerender: required("prerender"),
-      trace: required("trace"),
-      raise_on_prerender_error: required("raise_on_prerender_error")
-    )
-      return { "html" => "", "consoleReplayScript" => "" } unless prerender
+    # Returns object with values that are NOT html_safe!
+    def server_rendered_react_component(render_options)
+      return { "html" => "", "consoleReplayScript" => "" } unless render_options.prerender
+
+      react_component_name = render_options.react_component_name
+      props = render_options.props
 
       # On server `location` option is added (`location = request.fullpath`)
       # React Router needs this to match the current route
@@ -411,42 +413,44 @@ module ReactOnRails
       # Read more here: http://timelessrepo.com/json-isnt-a-javascript-subset
 
       # rubocop:disable Layout/IndentHeredoc
-      wrapper_js = <<-JS
+      js_code = <<-JS
 (function() {
   var railsContext = #{rails_context(server_side: true).to_json};
 #{initialize_redux_stores}
   var props = #{props_string(props).gsub("\u2028", '\u2028').gsub("\u2029", '\u2029')};
   return ReactOnRails.serverRenderReactComponent({
     name: '#{react_component_name}',
-    domNodeId: '#{dom_id}',
+    domNodeId: '#{render_options.dom_id}',
     props: props,
-    trace: #{trace},
+    trace: #{render_options.trace},
     railsContext: railsContext
   });
 })()
       JS
       # rubocop:enable Layout/IndentHeredoc
 
-      result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+      begin
+        result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(js_code, render_options)
+      rescue StandardError => err
+        # This error came from the renderer
+        raise ReactOnRails::PrerenderError, component_name: react_component_name,
+                                            # Sanitize as this might be browser logged
+                                            props: sanitized_props_string(props),
+                                            err: err,
+                                            js_code: js_code
+      end
 
-      if result["hasErrors"] && raise_on_prerender_error
+      if result["hasErrors"] && render_options.raise_on_prerender_error
         # We caught this exception on our backtrace handler
         raise ReactOnRails::PrerenderError, component_name: react_component_name,
                                             # Sanitize as this might be browser logged
                                             props: sanitized_props_string(props),
                                             err: nil,
-                                            js_code: wrapper_js,
+                                            js_code: js_code,
                                             console_messages: result["consoleReplayScript"]
 
       end
       result
-    rescue ExecJS::ProgramError => err
-      # This error came from execJs
-      raise ReactOnRails::PrerenderError, component_name: react_component_name,
-                                          # Sanitize as this might be browser logged
-                                          props: sanitized_props_string(props),
-                                          err: err,
-                                          js_code: wrapper_js
     end
 
     def initialize_redux_stores

data/lib/react_on_rails/server_rendering_pool.rb

@@ -21,8 +21,11 @@ module ReactOnRails
                   end
       end
 
-      delegate :server_render_js_with_console_logging, :reset_pool_if_server_bundle_was_modified,
-               :reset_pool, to: :pool
+      delegate :reset_pool_if_server_bundle_was_modified, :reset_pool, to: :pool
+
+      def server_render_js_with_console_logging(js_code, render_options)
+        @pool.exec_server_render_js(js_code, render_options)
+      end
 
       private
 

data/lib/react_on_rails/server_rendering_pool/ruby_embedded_java_script.rb

@@ -5,61 +5,65 @@ require "open-uri"
 module ReactOnRails
   module ServerRenderingPool
     class RubyEmbeddedJavaScript
-      def self.reset_pool
-        options = {
-          size: ReactOnRails.configuration.server_renderer_pool_size,
-          timeout: ReactOnRails.configuration.server_renderer_timeout
-        }
-        @js_context_pool = ConnectionPool.new(options) { create_js_context }
-      end
-
-      def self.reset_pool_if_server_bundle_was_modified
-        return unless ReactOnRails.configuration.development_mode
+      class << self
+        def reset_pool
+          options = {
+            size: ReactOnRails.configuration.server_renderer_pool_size,
+            timeout: ReactOnRails.configuration.server_renderer_timeout
+          }
+          @js_context_pool = ConnectionPool.new(options) { create_js_context }
+        end
 
-        file_mtime = File.mtime(ReactOnRails::Utils.server_bundle_js_file_path)
-        @server_bundle_timestamp ||= file_mtime
-        return if @server_bundle_timestamp == file_mtime
+        def reset_pool_if_server_bundle_was_modified
+          return unless ReactOnRails.configuration.development_mode
 
-        @server_bundle_timestamp = file_mtime
+          file_mtime = File.mtime(ReactOnRails::Utils.server_bundle_js_file_path)
+          @server_bundle_timestamp ||= file_mtime
+          return if @server_bundle_timestamp == file_mtime
 
-        ReactOnRails::ServerRenderingPool.reset_pool
-      end
+          @server_bundle_timestamp = file_mtime
 
-      # js_code: JavaScript expression that returns a string.
-      # Returns a Hash:
-      #   html: string of HTML for direct insertion on the page by evaluating js_code
-      #   consoleReplayScript: script for replaying console
-      #   hasErrors: true if server rendering errors
-      # Note, js_code does not have to be based on React.
-      # js_code MUST RETURN json stringify Object
-      # 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 ReactOnRails.configuration.trace
-          @file_index ||= 1
-          trace_js_code_used("Evaluating code to server render.", js_code,
-                             "tmp/server-generated-#{@file_index % 10}.js")
-          @file_index += 1
+          ReactOnRails::ServerRenderingPool.reset_pool
         end
-        json_string = eval_js(js_code)
-        result = JSON.parse(json_string)
-
-        if ReactOnRails.configuration.logging_on_server
-          console_script = result["consoleReplayScript"]
-          console_script_lines = console_script.split("\n")
-          console_script_lines = console_script_lines[2..-2]
-          re = /console\.(log|error)\.apply\(console, \["\[SERVER\] (?<msg>.*)"\]\);/
-          if console_script_lines
-            console_script_lines.each do |line|
-              match = re.match(line)
-              Rails.logger.info { "[react_on_rails] #{match[:msg]}" } if match
+
+        # js_code: JavaScript expression that returns a string.
+        # render_options: lib/react_on_rails/react_component/render_options.rb
+        # Using these options:
+        #    trace: saves the executed JS to a file, used in development
+        #    logging_on_server: put on server logs, not just in browser console
+        #
+        # Returns a Hash:
+        #   html: string of HTML for direct insertion on the page by evaluating js_code
+        #   consoleReplayScript: script for replaying console
+        #   hasErrors: true if server rendering errors
+        # Note, js_code does not have to be based on React.
+        # js_code MUST RETURN json stringify Object
+        # Calling code will probably call 'html_safe' on return value before rendering to the view.
+        def exec_server_render_js(js_code, render_options, js_evaluator = nil)
+          js_evaluator ||= self
+          if render_options.trace
+            @file_index ||= 1
+            trace_js_code_used("Evaluating code to server render.", js_code,
+                               "tmp/server-generated-#{@file_index % 10}.js")
+            @file_index += 1
+          end
+          json_string = js_evaluator.eval_js(js_code)
+          result = JSON.parse(json_string)
+
+          if render_options.logging_on_server
+            console_script = result["consoleReplayScript"]
+            console_script_lines = console_script.split("\n")
+            console_script_lines = console_script_lines[2..-2]
+            re = /console\.(log|error)\.apply\(console, \["\[SERVER\] (?<msg>.*)"\]\);/
+            if console_script_lines
+              console_script_lines.each do |line|
+                match = re.match(line)
+                Rails.logger.info { "[react_on_rails] #{match[:msg]}" } if match
+              end
             end
           end
+          result
         end
-        result
-      end
-
-      class << self
-        private
 
         def trace_js_code_used(msg, js_code, file_name = "tmp/server-generated.js", force: false)
           return unless ReactOnRails.configuration.trace || force
@@ -156,8 +160,7 @@ function clearTimeout() {
 
         def undefined_for_exec_js_logging(function_name)
           if ReactOnRails.configuration.trace
-            "console.error('[React on Rails Rendering] #{function_name} is not defined for execJS. See "\
-            "https://github.com/sstephenson/execjs#faq. Note babel-polyfill may call this.');\n"\
+            "console.error('[React on Rails Rendering] #{function_name} is not defined for server rendering.');\n"\
             "  console.error(getStackTrace().join('\\n'));"
           else
             ""

data/lib/react_on_rails/utils.rb

@@ -114,7 +114,7 @@ exitstatus: #{status.exitstatus}#{stdout_msg}#{stderr_msg}
 
     module Required
       def required(arg_name)
-        raise ReactOnRailsPro::Error, "#{arg_name} is required"
+        raise ReactOnRails::Error, "#{arg_name} is required"
       end
     end
 

data/lib/react_on_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReactOnRails
-  VERSION = "11.0.0".freeze
+  VERSION = "11.0.1".freeze
 end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-on-rails",
-  "version": "11.0.0",
+  "version": "11.0.1",
   "description": "react-on-rails JavaScript for react_on_rails Ruby gem",
   "main": "node_package/lib/ReactOnRails.js",
   "directories": {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: react_on_rails
 version: !ruby/object:Gem::Version
-  version: 11.0.0
+  version: 11.0.1
 platform: ruby
 authors:
 - Justin Gordon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-22 00:00:00.000000000 Z
+date: 2018-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -438,7 +438,7 @@ files:
 - lib/react_on_rails/json_output.rb
 - lib/react_on_rails/locales_to_js.rb
 - lib/react_on_rails/prerender_error.rb
-- lib/react_on_rails/react_component/options.rb
+- lib/react_on_rails/react_component/render_options.rb
 - lib/react_on_rails/react_on_rails_helper.rb
 - lib/react_on_rails/server_rendering_pool.rb
 - lib/react_on_rails/server_rendering_pool/ruby_embedded_java_script.rb