react_on_rails 5.2.0 → 6.0.0.beta.1

data/lib/react_on_rails/server_rendering_pool/node.rb

@@ -0,0 +1,77 @@
+module ReactOnRails
+  module ServerRenderingPool
+    class Node
+      # This implementation of the rendering pool uses NodeJS to execute javasript code
+      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
+        # No need for this method, the server bundle is automatically reset by node when changes
+        # Empty implementation to conform to ServerRenderingPool interface
+      end
+
+      # 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 trace_react_on_rails?
+          @file_index ||= 1
+          trace_messsage(js_code, "tmp/server-generated-#{@file_index % 10}.js")
+          @file_index += 1
+        end
+        json_string = eval_js(js_code)
+        JSON.parse(json_string)
+      end
+
+      class << self
+        private
+
+        def trace_messsage(js_code, file_name = "tmp/server-generated.js", force = false)
+          return unless trace_react_on_rails? || force
+          # Set to anything to print generated code.
+          puts "Z" * 80
+          puts "react_renderer.rb: 92"
+          puts "wrote file #{file_name}"
+          File.write(file_name, js_code)
+          puts "Z" * 80
+        end
+
+        def trace_react_on_rails?
+          ENV["TRACE_REACT_ON_RAILS"].present?
+        end
+
+        def eval_js(js_code)
+          max_int = (2**(32 - 2) - 1)
+          @js_context_pool.with do |js_context|
+            js_context.send(js_code, 0)
+            result = js_context.recv(max_int)
+            result
+          end
+        end
+
+        def create_js_context
+          begin
+            client = UNIXSocket.new("client/node/node.sock")
+            client.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+          rescue StandardError => e
+            Rails.logger.error("Unable to connect to socket: client/node/node.sock.
+Make sure node server is up and running.")
+            Rails.logger.error(e)
+            raise e
+          end
+          client
+        end
+      end
+    end
+  end
+end

data/lib/react_on_rails/test_helper.rb

@@ -44,8 +44,6 @@ module ReactOnRails
     # Typical usage passes all params as nil defaults.
     # webpack_assets_status_checker: provide: `up_to_date?`, `whats_not_up_to_date`, `client_dir`
     #                         defaults to ReactOnRails::TestHelper::WebpackAssetsStatusChecker
-    # webpack_process_checker: provide one method: `def running?`
-    #                         defaults to ReactOnRails::TestHelper::WebpackProcessChecker
     # webpack_assets_compiler: provide one method: `def compile`
     #                         defaults to ReactOnRails::TestHelper::WebpackAssetsCompiler
     # client_dir and generated_assets_dir are passed into the default webpack_assets_status_checker if you
@@ -54,7 +52,6 @@ module ReactOnRails
     #                        webpack_generated_files in your configuration
     def self.ensure_assets_compiled(webpack_assets_status_checker: nil,
                                     webpack_assets_compiler: nil,
-                                    webpack_process_checker: nil,
                                     client_dir: nil,
                                     generated_assets_dir: nil,
                                     webpack_generated_files: nil)
@@ -80,12 +77,10 @@ module ReactOnRails
       end
 
       webpack_assets_compiler ||= WebpackAssetsCompiler.new
-      webpack_process_checker ||= WebpackProcessChecker.new
 
       ReactOnRails::TestHelper::EnsureAssetsCompiled.new(
         webpack_assets_status_checker: webpack_assets_status_checker,
-        webpack_assets_compiler: webpack_assets_compiler,
-        webpack_process_checker: webpack_process_checker
+        webpack_assets_compiler: webpack_assets_compiler
       ).call
     end
   end

data/lib/react_on_rails/test_helper/ensure_assets_compiled.rb

@@ -1,31 +1,20 @@
 module ReactOnRails
   module TestHelper
     class EnsureAssetsCompiled
-      SECONDS_TO_WAIT = 10
-
       class << self
         attr_accessor :has_been_run
         @has_been_run = false
       end
 
       attr_reader :webpack_assets_status_checker,
-                  :webpack_assets_compiler,
-                  :webpack_process_checker
-
-      MAX_TIME_TO_WAIT = 5
+                  :webpack_assets_compiler
 
       def initialize(webpack_assets_status_checker: nil,
-                     webpack_assets_compiler: nil,
-                     webpack_process_checker: nil)
+                     webpack_assets_compiler: nil)
         @webpack_assets_status_checker = webpack_assets_status_checker
         @webpack_assets_compiler = webpack_assets_compiler
-        @webpack_process_checker = webpack_process_checker
       end
 
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-
       # Several Scenarios:
       # 1. No webpack watch processes for static assets and files are mising or out of date.
       # 2. Only webpack watch process for server bundle as we're the  hot reloading setup.
@@ -46,79 +35,17 @@ module ReactOnRails
         # Inform the developer that we're ensuring gen assets are ready.
         puts_start_compile_check_message(stale_gen_files)
 
-        hot_running = webpack_process_checker.hot_running?
-        client_running = webpack_process_checker.client_running?
-        server_running = webpack_process_checker.server_running?
-        already_compiled_client_file = false
-
-        # Check if running "hot" and not running a process to statically compile the client files.
-        if hot_running && !client_running
-          puts "Appears you're running hot reloading and are not rebuilding client files "\
-            "automatically. We'll try rebuilding only your client files first."
-          webpack_assets_compiler.compile_client(stale_gen_files)
-          already_compiled_client_file = true
-
-          stale_gen_files = webpack_assets_status_checker.stale_generated_webpack_files
-
-          # Return if we're all done!
-          return if stale_gen_files.empty?
-        end
-
-        loop_count = 0
-        if (already_compiled_client_file && server_running) ||
-           (!already_compiled_client_file && client_running)
-          puts "Waiting #{SECONDS_TO_WAIT} for webpack watch processes to compile files"
-          loop do
-            sleep 1
-            stale_gen_files = webpack_assets_status_checker.stale_generated_webpack_files
-            loop_count += 1
-            break if loop_count == SECONDS_TO_WAIT || stale_gen_files.empty?
-          end
-        end
-
-        final_compilation_check(already_compiled_client_file, client_running, server_running, stale_gen_files)
-      end
-
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
-
-      def final_compilation_check(already_compiled_client_file, client_running, server_running, stale_gen_files)
-        return unless stale_gen_files.present?
-        if client_running || server_running
-          puts <<-MSG
-Arghhhhhh! We still have the following stale generated files after waiting for Webpack to compile:
-#{stale_gen_files.join("\n")}
-
-This can happen if you removed the generated files after they've been created by your webpack
-watch processes, such by running a clean on your generated bundles before starting your tests.
-          MSG
-        end
-
-        puts <<-MSG
-
-If you are frequently running tests, you can run webpack in watch mode for static assets to
-speed up this process. See the official documentation:
-https://github.com/shakacode/react_on_rails/blob/master/docs/additional-reading/rspec-configuration.md
-        MSG
-
-        if already_compiled_client_file
-          # So only do serer file
-          webpack_assets_compiler.compile_server(stale_gen_files)
-        else
-          webpack_assets_compiler.compile_as_necessary(stale_gen_files)
-        end
+        webpack_assets_compiler.compile_assets
       end
 
       def puts_start_compile_check_message(stale_files)
-        server_msg = Utils.server_rendering_is_enabled? ? "and `build:server`" : ""
         puts <<-MSG
 
 Detected are the following stale generated files:
 #{stale_files.join("\n")}
 
 React on Rails will ensure your JavaScript generated files are up to date, using your
-top level package.json `build:client` #{server_msg} commands.
+/client level package.json `build:test` command.
 
         MSG
       end

data/lib/react_on_rails/test_helper/node_process_launcher.rb

@@ -0,0 +1,12 @@
+module ReactOnRails
+  module TestHelper
+    def self.launch_node
+      if ReactOnRails.configuration.server_render_method == "NodeJS"
+        path = "#{::Rails.root}/client/node"
+        puts "Launching NodeJS server at #{path}"
+        system("cd #{path} && npm start &")
+        sleep(1)
+      end
+    end
+  end
+end

data/lib/react_on_rails/test_helper/webpack_assets_compiler.rb

@@ -3,38 +3,14 @@
 module ReactOnRails
   module TestHelper
     class WebpackAssetsCompiler
-      def compile_as_necessary(stale_files)
-        compile_client(stale_files)
-        compile_server(stale_files)
-      end
-
-      def compile_client(stale_files)
-        compile_type(:client) if needs_client_compile?(stale_files)
-      end
-
-      def compile_server(stale_files)
-        compile_type(:server) if needs_server_compile?(stale_files)
-      end
-
-      private
+      def compile_assets
+        puts "\nBuilding Webpack assets..."
 
-      def compile_type(type)
-        puts "\nBuilding Webpack #{type}-rendering assets..."
-
-        build_output = `cd client && npm run build:#{type}`
+        build_output = `cd client && #{ReactOnRails.configuration.npm_build_test_command}`
 
         raise "Error in building assets!\n#{build_output}" unless Utils.last_process_completed_successfully?
 
-        puts "Completed building Webpack #{type}-rendering assets."
-      end
-
-      def needs_client_compile?(stale_files)
-        !stale_files.all? { |name| name.include?("server") }
-      end
-
-      def needs_server_compile?(stale_files)
-        return false unless Utils.server_rendering_is_enabled?
-        stale_files.any? { |name| name.include?("server") }
+        puts "Completed building Webpack assets."
       end
     end
   end

data/lib/react_on_rails/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ReactOnRails
-  VERSION = "5.2.0".freeze
+  VERSION = "6.0.0.beta.1".freeze
 end

data/lib/tasks/assets.rake

@@ -0,0 +1,115 @@
+module ReactOnRails
+  class << self
+    def assets_path
+      dir = File.join(Rails.configuration.paths['public'].first,
+                      Rails.configuration.assets.prefix)
+      Pathname.new(dir)
+    end
+
+    def symlink_file(target, symlink)
+      if not File.exist?(symlink) or File.lstat(symlink).symlink?
+        if File.exist?(target)
+          puts "React On Rails: Symlinking #{target} to #{symlink}"
+          FileUtils.ln_s target, symlink, force: true
+        end
+      else
+        puts "React On Rails: File #{symlink} already exists. Failed to symlink #{target}"
+      end
+    end
+  end
+end
+
+namespace :react_on_rails do
+  namespace :assets do
+
+    if ReactOnRails.configuration.symlink_non_digested_assets_regex
+      desc "Creates non-digested symlinks for the assets in the public asset dir"
+      task symlink_non_digested_assets: :"assets:environment" do
+        manifest_path = Dir.glob(ReactOnRails::assets_path.join(".sprockets-manifest-*.json"))
+                          .first
+        manifest_data = JSON.load(File.new(manifest_path))
+
+        manifest_data["assets"].each do |logical_path, digested_path|
+          regex = ReactOnRails.configuration.symlink_non_digested_assets_regex
+          if logical_path =~ regex
+            full_digested_path = ReactOnRails::assets_path.join(digested_path)
+            full_nondigested_path = ReactOnRails::assets_path.join(logical_path)
+            extension = full_digested_path.extname
+            full_digested_gz_path = full_digested_path.sub_ext("#{extension}.gz")
+            full_nondigested_gz_path = full_nondigested_path.sub_ext("#{extension}.gz")
+            ReactOnRails::symlink_file(full_digested_path, full_nondigested_path)
+            ReactOnRails::symlink_file(full_digested_gz_path, full_nondigested_gz_path)
+          end
+        end
+      end
+
+      desc "Cleans all broken symlinks for the assets in the public asset dir"
+      task delete_broken_symlinks: :"assets:environment" do
+        Dir.glob(ReactOnRails::assets_path.join("*")).each do |filename|
+          if File.lstat(filename).symlink?
+            begin
+              target = File.readlink(filename)
+            rescue
+              puts "React on Rails: Warning: your platform doesn't support File::readlink method."/
+                     "Skipping broken link check."
+              return
+            end
+            path = Pathname.new(File.dirname(filename))
+            target_path = path.join(target)
+            unless File.exist?(target_path)
+              puts "React on Rails: Deleting broken link: #{filename}"
+              File.delete(filename)
+            end
+          end
+        end
+      end
+    end
+
+
+    # We might need the clear_prerequisites (delete after testing without)
+    # Rake::Task["assets:precompile"]
+    #   .clear_prerequisites
+    #   .enhance(["assets:compile_environment"])
+
+    if ReactOnRails.configuration.npm_build_production_command.present?
+      # In this task, set prerequisites for the assets:precompile task
+      desc <<-DESC
+Create webpack assets before calling assets:environment
+The webpack task must run before assets:environment task.
+Otherwise Sprockets cannot find the files that webpack produces.
+This is the secret sauce for how a Heroku deployment knows to create the webpack generated JavaScript files.
+      DESC
+      task compile_environment: :webpack do
+        Rake::Task["assets:environment"].invoke
+      end
+
+      desc <<-DESC
+Compile assets with webpack
+Uses command defined with ReactOnRails.configuration.npm_build_production_command
+sh "cd client && #{ReactOnRails.configuration.npm_build_production_command}"
+      DESC
+      task :webpack do
+        sh "cd client && #{ReactOnRails.configuration.npm_build_production_command}"
+      end
+
+      desc "Delete assets created with webpack, in #{ReactOnRails.configuration.generated_assets_dir}"
+      task :clobber do
+        rm_r Dir.glob(Rails.root.join("#{ReactOnRails.configuration.generated_assets_dir}/*"))
+      end
+    end
+  end
+end
+
+if ReactOnRails.configuration.symlink_non_digested_assets_regex
+  Rake::Task["assets:precompile"].enhance do
+    Rake::Task["react_on_rails:assets:symlink_non_digested_assets"].invoke
+    Rake::Task["react_on_rails:assets:delete_broken_symlinks"].invoke
+  end
+end
+
+if ReactOnRails.configuration.npm_build_production_command.present?
+  Rake::Task["assets:precompile"].enhance do
+    Rake::Task["react_on_rails:assets:compile_environment"].invoke
+  end
+end
+

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-on-rails",
-  "version": "5.2.0",
+  "version": "6.0.0-beta.1",
   "description": "react-on-rails JavaScript for react_on_rails Ruby gem",
   "main": "node_package/lib/ReactOnRails.js",
   "directories": {
@@ -15,6 +15,7 @@
     "babel-preset-es2015": "^6.6.0",
     "babel-preset-react": "^6.5.0",
     "babel-preset-stage-0": "^6.5.0",
+    "babel-runtime": "^6.6.1",
     "babel-tape-runner": "^2.0.1",
     "babel-types": "^6.7.2",
     "babelify": "^7.2.0",

data/rakelib/example_type.rb

@@ -28,10 +28,6 @@ module ReactOnRails
         "#{@name} example app"
       end
 
-      def server_rendering?
-        generator_options.include?("--server-rendering")
-      end
-
       def dir
         File.join(examples_dir, name)
       end
@@ -53,14 +49,12 @@ module ReactOnRails
       end
 
       def webpack_bundles_dir
-        File.join(dir, "app", "assets", "javascripts", "generated")
+        File.join(dir, "app", "assets", "javascripts", "webpack")
       end
 
       def webpack_bundles
         bundles = []
-        bundles << File.join(webpack_bundles_dir, "app-bundle.js")
-        bundles << File.join(webpack_bundles_dir, "server-bundle.js") if server_rendering?
-        bundles << File.join(webpack_bundles_dir, "vendor-bundle.js")
+        bundles << File.join(webpack_bundles_dir, "webpack-bundle.js")
       end
 
       def gemfile
@@ -137,8 +131,7 @@ module ReactOnRails
       def build_webpack_bundles_shell_commands
         webpack_command = File.join("$(npm bin)", "webpack")
         shell_commands = []
-        shell_commands << "#{webpack_command} --config webpack.server.rails.config.js" if server_rendering?
-        shell_commands << "#{webpack_command} --config webpack.client.rails.config.js"
+        shell_commands << "#{webpack_command} --config webpack.config.js"
       end
 
       # Assumes we are inside a rails app's folder and necessary gems have been installed