react_on_rails 11.0.0 → 12.0.0

data/lib/react_on_rails/server_rendering_pool/ruby_embedded_java_script.rb

@@ -1,68 +1,86 @@
 # frozen_string_literal: true
 
 require "open-uri"
+require "execjs"
 
 module ReactOnRails
   module ServerRenderingPool
+    # rubocop:disable Metrics/ClassLength
     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
+      # rubocop:enable Metrics/ClassLength
+      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
+          if ReactOnRails::Utils.server_bundle_path_is_http?
+            return if @server_bundle_url == ReactOnRails::Utils.server_bundle_js_file_path
 
-        ReactOnRails::ServerRenderingPool.reset_pool
-      end
+            @server_bundle_url = ReactOnRails::Utils.server_bundle_js_file_path
+          else
+            file_mtime = File.mtime(ReactOnRails::Utils.server_bundle_js_file_path)
+            @server_bundle_timestamp ||= file_mtime
+            return if @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
+            @server_bundle_timestamp = file_mtime
+          end
+          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, render_options)
+          result = nil
+          begin
+            result = JSON.parse(json_string)
+          rescue JSON::ParserError => e
+            raise ReactOnRails::JsonParseError.new(e, json_string)
+          end
+
+          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
+
           # Set to anything to print generated code.
           File.write(file_name, js_code)
           msg = <<-MSG.strip_heredoc
@@ -78,7 +96,7 @@ module ReactOnRails
           end
         end
 
-        def eval_js(js_code)
+        def eval_js(js_code, _render_options)
           @js_context_pool.with do |js_context|
             result = js_context.eval(js_code)
             js_context.eval("console.history = []")
@@ -86,30 +104,37 @@ module ReactOnRails
           end
         end
 
-        def create_js_context
-          return if ReactOnRails.configuration.server_bundle_js_file.blank?
-
+        def read_bundle_js_code
           server_js_file = ReactOnRails::Utils.server_bundle_js_file_path
-
-          begin
-            bundle_js_code = File.read(server_js_file)
-          rescue StandardError => e
-            msg = "You specified server rendering JS file: #{server_js_file}, but it cannot be "\
+          if ReactOnRails::Utils.server_bundle_path_is_http?
+            file_url_to_string(server_js_file)
+          else
+            File.read(server_js_file)
+          end
+        rescue StandardError => e
+          msg = "You specified server rendering JS file: #{server_js_file}, but it cannot be "\
                 "read. You may set the server_bundle_js_file in your configuration to be \"\" to "\
                 "avoid this warning.\nError is: #{e}"
-            raise ReactOnRails::Error, msg
-          end
-          # rubocop:disable Layout/IndentHeredoc
-          base_js_code = <<-JS
-#{console_polyfill}
-#{execjs_timer_polyfills}
-#{bundle_js_code};
+          raise ReactOnRails::Error, msg
+        end
+
+        def create_js_context
+          return if ReactOnRails.configuration.server_bundle_js_file.blank?
+
+          bundle_js_code = read_bundle_js_code
+          base_js_code = <<~JS
+            #{console_polyfill}
+            #{execjs_timer_polyfills}
+            #{bundle_js_code};
           JS
-          # rubocop:enable Layout/IndentHeredoc
+
           file_name = "tmp/base_js_code.js"
           begin
             if ReactOnRails.configuration.trace
-              Rails.logger.info { "[react_on_rails] Created JavaScript context with file #{server_js_file}" }
+              Rails.logger.info do
+                "[react_on_rails] Created JavaScript context with file "\
+                "#{ReactOnRails::Utils.server_bundle_js_file_path}"
+              end
             end
             ExecJS.compile(base_js_code)
           rescue StandardError => e
@@ -125,39 +150,36 @@ module ReactOnRails
         end
 
         def execjs_timer_polyfills
-          # rubocop:disable Layout/IndentHeredoc
-          <<-JS
-function getStackTrace () {
-  var stack;
-  try {
-    throw new Error('');
-  }
-  catch (error) {
-    stack = error.stack || '';
-  }
-  stack = stack.split('\\n').map(function (line) { return line.trim(); });
-  return stack.splice(stack[0] == 'Error' ? 2 : 1);
-}
-
-function setInterval() {
-  #{undefined_for_exec_js_logging('setInterval')}
-}
-
-function setTimeout() {
-  #{undefined_for_exec_js_logging('setTimeout')}
-}
-
-function clearTimeout() {
-  #{undefined_for_exec_js_logging('clearTimeout')}
-}
+          <<~JS
+            function getStackTrace () {
+              var stack;
+              try {
+                throw new Error('');
+              }
+              catch (error) {
+                stack = error.stack || '';
+              }
+              stack = stack.split('\\n').map(function (line) { return line.trim(); });
+              return stack.splice(stack[0] == 'Error' ? 2 : 1);
+            }
+
+            function setInterval() {
+              #{undefined_for_exec_js_logging('setInterval')}
+            }
+
+            function setTimeout() {
+              #{undefined_for_exec_js_logging('setTimeout')}
+            }
+
+            function clearTimeout() {
+              #{undefined_for_exec_js_logging('clearTimeout')}
+            }
           JS
-          # rubocop:enable Layout/IndentHeredoc
         end
 
         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
             ""
@@ -166,20 +188,31 @@ function clearTimeout() {
 
         # Reimplement console methods for replaying on the client
         def console_polyfill
-          # rubocop:disable Layout/IndentHeredoc
-          <<-JS
-var console = { history: [] };
-['error', 'log', 'info', 'warn'].forEach(function (level) {
-  console[level] = function () {
-    var argArray = Array.prototype.slice.call(arguments);
-    if (argArray.length > 0) {
-      argArray[0] = '[SERVER] ' + argArray[0];
-    }
-    console.history.push({level: level, arguments: argArray});
-  };
-});
+          <<~JS
+            var console = { history: [] };
+            ['error', 'log', 'info', 'warn'].forEach(function (level) {
+              console[level] = function () {
+                var argArray = Array.prototype.slice.call(arguments);
+                if (argArray.length > 0) {
+                  argArray[0] = '[SERVER] ' + argArray[0];
+                }
+                console.history.push({level: level, arguments: argArray});
+              };
+            });
           JS
-          # rubocop:enable Layout/IndentHeredoc
+        end
+
+        private
+
+        def file_url_to_string(url)
+          response = Net::HTTP.get_response(URI.parse(url))
+          content_type_header = response["content-type"]
+          match = content_type_header.match(/\A.*; charset=(?<encoding>.*)\z/)
+          encoding_type = match[:encoding]
+          response.body.force_encoding(encoding_type)
+        rescue StandardError => e
+          msg = "file_url_to_string #{url} failed\nError is: #{e}"
+          raise ReactOnRails::Error, msg
         end
       end
     end

data/lib/react_on_rails/server_rendering_pool.rb

@@ -5,33 +5,21 @@ require_relative "server_rendering_pool/ruby_embedded_java_script"
 
 # Based on the react-rails gem.
 # None of these methods should be called directly.
-# See app/helpers/react_on_rails_helper.rb
 module ReactOnRails
   module ServerRenderingPool
     class << self
-      def react_on_rails_pro?
-        @react_on_rails_pro ||= gem_available?("react_on_rails_pro")
-      end
-
       def pool
-        @pool ||= if react_on_rails_pro?
+        @pool ||= if ReactOnRails::Utils.react_on_rails_pro?
                     ReactOnRailsPro::ServerRenderingPool::ProRendering
                   else
                     ReactOnRails::ServerRenderingPool::RubyEmbeddedJavaScript
                   end
       end
 
-      delegate :server_render_js_with_console_logging, :reset_pool_if_server_bundle_was_modified,
-               :reset_pool, to: :pool
-
-      private
+      delegate :reset_pool_if_server_bundle_was_modified, :reset_pool, to: :pool
 
-      def gem_available?(name)
-        Gem::Specification.find_by_name(name)
-      rescue Gem::LoadError
-        false
-      rescue StandardError
-        Gem.available?(name)
+      def server_render_js_with_console_logging(js_code, render_options)
+        pool.exec_server_render_js(js_code, render_options)
       end
     end
   end

data/lib/react_on_rails/test_helper/ensure_assets_compiled.rb

@@ -5,6 +5,7 @@ module ReactOnRails
     class EnsureAssetsCompiled
       class << self
         attr_accessor :has_been_run
+
         @has_been_run = false
       end
 
@@ -29,7 +30,7 @@ module ReactOnRails
         # Be sure we don't do this again.
         self.class.has_been_run = true
 
-        ReactOnRails::LocalesToJs.new
+        ReactOnRails::Locales.compile
 
         stale_gen_files = webpack_assets_status_checker.stale_generated_webpack_files
 
@@ -43,17 +44,15 @@ module ReactOnRails
       end
 
       def puts_start_compile_check_message(stale_files)
-        # rubocop:disable Layout/IndentHeredoc
-        puts <<-MSG
+        puts <<~MSG
 
-Detected the following stale generated files:
-  #{stale_files.join("\n  ")}
+          Detected the following stale generated files:
+            #{stale_files.join("\n  ")}
 
-React on Rails will ensure your JavaScript generated files are up to date, using your
-`#{ReactOnRails::Utils.prepend_cd_node_modules_directory(ReactOnRails.configuration.build_test_command)}` command.
+          React on Rails will ensure your JavaScript generated files are up to date, using your
+          `#{ReactOnRails::Utils.prepend_cd_node_modules_directory(ReactOnRails.configuration.build_test_command)}` command.
 
         MSG
-        # rubocop:enable Layout/IndentHeredoc
       end
     end
   end

data/lib/react_on_rails/test_helper/webpack_assets_compiler.rb

@@ -6,6 +6,23 @@ module ReactOnRails
   module TestHelper
     class WebpackAssetsCompiler
       def compile_assets
+        if ReactOnRails.configuration.build_test_command.blank?
+          msg = <<~MSG
+            You are using the React on Rails test helper. 
+            Either you used:
+              ReactOnRails::TestHelper.configure_rspec_to_compile_assets or
+              ReactOnRails::TestHelper.ensure_assets_compiled
+            but you did not specify the config.build_test_command
+
+            React on Rails is aborting your test run
+
+            If you wish to use the config/webpacker.yml compile option for tests
+            them remove your call to the ReactOnRails test helper.
+          MSG
+          puts Rainbow(msg).red
+          exit!(1)
+        end
+
         puts "\nBuilding Webpack assets..."
 
         cmd = ReactOnRails::Utils.prepend_cd_node_modules_directory(

data/lib/react_on_rails/test_helper/webpack_assets_status_checker.rb

@@ -13,14 +13,14 @@ module ReactOnRails
       # source_path is typically configured in the webpacker.yml file
       # for `source_path`
       # or for legacy React on Rails, it's /client, where all client files go
-      attr_reader :source_path, :generated_assets_dir
+      attr_reader :source_path, :generated_assets_full_path
 
       def initialize(
-        generated_assets_dir: required("generated_assets_dir"),
+        generated_assets_full_path: required("generated_assets_full_path"),
         source_path: required("source_path"),
         webpack_generated_files: required("webpack_generated_files")
       )
-        @generated_assets_dir = generated_assets_dir
+        @generated_assets_full_path = generated_assets_full_path
         @source_path = source_path
         @webpack_generated_files = webpack_generated_files
       end
@@ -53,19 +53,23 @@ module ReactOnRails
       def all_compiled_assets
         @all_compiled_assets ||= begin
           webpack_generated_files = @webpack_generated_files.map do |bundle_name|
-            ReactOnRails::Utils.bundle_js_file_path(bundle_name)
+            if bundle_name == ReactOnRails.configuration.server_bundle_js_file
+              ReactOnRails::Utils.server_bundle_js_file_path
+            else
+              ReactOnRails::Utils.bundle_js_file_path(bundle_name)
+            end
           end
 
           if webpack_generated_files.present?
             webpack_generated_files
           else
-            file_list = make_file_list(make_globs(generated_assets_dir)).to_ary
+            file_list = make_file_list(make_globs(generated_assets_full_path)).to_ary
             puts "V" * 80
             puts "Please define config.webpack_generated_files (array) so the test helper knows "\
             "which files are required. If you are using webpacker, you typically need to only "\
             "include 'manifest.json'."
             puts "Detected the possible following files to check for webpack compilation in "\
-              "#{generated_assets_dir}"
+              "#{generated_assets_full_path}"
             puts file_list.join("\n")
             puts "^" * 80
             file_list

data/lib/react_on_rails/test_helper.rb

@@ -31,7 +31,7 @@ module ReactOnRails
     # Params:
     # config - config for rspec
     # metatags - metatags to add the ensure_assets_compiled check.
-    #            Default is :js, :server_rendering
+    #            Default is :js, :server_rendering, :controller
     def self.configure_rspec_to_compile_assets(config, *metatags)
       metatags = %i[js server_rendering controller] if metatags.empty?
 
@@ -48,32 +48,43 @@ module ReactOnRails
     #                         defaults to ReactOnRails::TestHelper::WebpackAssetsStatusChecker
     # webpack_assets_compiler: provide one method: `def compile`
     #                         defaults to ReactOnRails::TestHelper::WebpackAssetsCompiler
-    # source_path and generated_assets_dir are passed into the default webpack_assets_status_checker if you
+    # source_path and generated_assets_full_path are passed into the default webpack_assets_status_checker if you
     #                        don't provide one.
     # webpack_generated_files List of files to check for up-to-date-status, defaulting to
     #                        webpack_generated_files in your configuration
     def self.ensure_assets_compiled(webpack_assets_status_checker: nil,
                                     webpack_assets_compiler: nil,
                                     source_path: nil,
-                                    generated_assets_dir: nil,
+                                    generated_assets_full_path: nil,
                                     webpack_generated_files: nil)
       ReactOnRails::WebpackerUtils.check_manifest_not_cached
       if webpack_assets_status_checker.nil?
         source_path ||= ReactOnRails::Utils.source_path
-        generated_assets_dir ||= ReactOnRails::Utils.generated_assets_dir
+        generated_assets_full_path ||= ReactOnRails::Utils.generated_assets_full_path
         webpack_generated_files ||= ReactOnRails.configuration.webpack_generated_files
 
         webpack_assets_status_checker ||=
           WebpackAssetsStatusChecker.new(source_path: source_path,
-                                         generated_assets_dir: generated_assets_dir,
+                                         generated_assets_full_path: generated_assets_full_path,
                                          webpack_generated_files: webpack_generated_files)
 
         unless @printed_once
           puts
-          puts "====> React On Rails: Checking #{webpack_assets_status_checker.generated_assets_dir} for "\
-          "outdated/missing bundles"
+          puts "====> React On Rails: Checking files in "\
+            "#{webpack_assets_status_checker.generated_assets_full_path} for "\
+            "outdated/missing bundles based on source_path #{source_path}"
           puts
           @printed_once = true
+
+          if ReactOnRails::WebpackerUtils.using_webpacker? &&
+             ReactOnRails::Utils.using_webpacker_source_path_is_not_defined_and_custom_node_modules?
+            msg = <<-MSG.strip_heredoc
+              WARNING: Define config.webpacker.yml to include sourcePath to configure
+              the location of your JavaScript source for React on Rails.
+              Default location of #{source_path} is used.
+            MSG
+            puts ReactOnRails::Utils.wrap_message(msg, :orange)
+          end
         end
       end