react_on_rails 4.0.0.beta.1 → 4.0.0.beta.2

data/lib/generators/react_on_rails/templates/base/base/lib/tasks/assets.rake.tt

@@ -21,6 +21,6 @@ namespace :assets do
   end
 
   task :clobber do
-    rm_r Dir.glob(Rails.root.join("app/assets/javascripts/generated/*"))
+    rm_r Dir.glob(Rails.root.join("app/assets/webpack/*"))
   end
 end

data/lib/generators/react_on_rails/templates/base/server_rendering/client/webpack.server.rails.config.js

@@ -16,7 +16,7 @@ module.exports = {
   ],
   output: {
     filename: 'server-bundle.js',
-    path: '../app/assets/javascripts/generated',
+    path: '../app/assets/webpack',
   },
   resolve: {
     extensions: ['', '.js', '.jsx'],

data/lib/react_on_rails/configuration.rb

@@ -1,15 +1,50 @@
 module ReactOnRails
   def self.configure
     yield(configuration)
+    setup_config_values
   end
 
-  DEFAULT_GENERATED_ASSETS_DIRS = [
-    %w(app assets webpack)
-  ].map { |dirs| File.join(*dirs) }.freeze
+  DEFAULT_GENERATED_ASSETS_DIR = File.join(%w(app assets webpack)).freeze
+
+  def self.setup_config_values
+    if @configuration.webpack_generated_files.empty?
+      files = ["client-bundle.js"]
+      if @configuration.server_bundle_js_file.present?
+        files << @configuration.server_bundle_js_file
+      end
+      @configuration.webpack_generated_files = files
+    end
+
+    if @configuration.generated_assets_dirs.present?
+      puts "[DEPRECATION] ReactOnRails: Use config.generated_assets_dir rather than "\
+        "generated_assets_dirs"
+      if @configuration.generated_assets_dir.blank?
+        @configuration.generated_assets_dir = @configuration.generated_assets_dirs
+      else
+        puts "[DEPRECATION] ReactOnRails. You have both generated_assets_dirs and "\
+          "generated_assets_dir defined. Define ONLY generated_assets_dir"
+      end
+    end
+
+    if @configuration.generated_assets_dir.blank?
+      @configuration.generated_assets_dir = DEFAULT_GENERATED_ASSETS_DIR
+      puts "ReactOnRails: Set generated_assets_dir to default: #{DEFAULT_GENERATED_ASSETS_DIR}"
+    end
+
+    if @configuration.server_bundle_js_file.include?(File::SEPARATOR)
+      puts "[DEPRECATION] ReactOnRails: remove path from server_bundle_js_file in configuration. "\
+        "All generated files must go in #{@configuration.generated_assets_dir}"
+      @configuration.server_bundle_js_file = File.basename(@configuration.server_bundle_js_file)
+    end
+  end
 
   def self.configuration
     @configuration ||= Configuration.new(
-      generated_assets_dirs: DEFAULT_GENERATED_ASSETS_DIRS,
+      generated_assets_dirs: nil,
+
+      # generated_assets_dirs is deprecated
+      generated_assets_dir: "",
+
       server_bundle_js_file: "",
       prerender: false,
       replay_console: true,
@@ -19,7 +54,9 @@ module ReactOnRails
       development_mode: Rails.env.development?,
       server_renderer_pool_size: 1,
       server_renderer_timeout: 20,
-      skip_display_none: false)
+      skip_display_none: false,
+      webpack_generated_files: []
+    )
   end
 
   class Configuration
@@ -27,18 +64,19 @@ module ReactOnRails
                   :trace, :development_mode,
                   :logging_on_server, :server_renderer_pool_size,
                   :server_renderer_timeout, :raise_on_prerender_error,
-                  :skip_display_none, :generated_assets_dirs
+                  :skip_display_none, :generated_assets_dirs, :generated_assets_dir,
+                  :webpack_generated_files
 
     def initialize(server_bundle_js_file: nil, prerender: nil, replay_console: nil,
                    trace: nil, development_mode: nil,
                    logging_on_server: nil, server_renderer_pool_size: nil,
                    server_renderer_timeout: nil, raise_on_prerender_error: nil,
-                   skip_display_none: nil, generated_assets_dirs: DEFAULT_GENERATED_ASSETS_DIRS)
-      self.server_bundle_js_file = if File.exist?(server_bundle_js_file)
-                                     server_bundle_js_file
-                                   end
-
+                   skip_display_none: nil, generated_assets_dirs: nil,
+                   generated_assets_dir: nil, webpack_generated_files: nil)
+      self.server_bundle_js_file = server_bundle_js_file
       self.generated_assets_dirs = generated_assets_dirs
+      self.generated_assets_dir = generated_assets_dir
+
       self.prerender = prerender
       self.replay_console = replay_console
       self.logging_on_server = logging_on_server
@@ -54,6 +92,8 @@ module ReactOnRails
       # Server rendering:
       self.server_renderer_pool_size = self.development_mode ? 1 : server_renderer_pool_size
       self.server_renderer_timeout = server_renderer_timeout # seconds
+
+      self.webpack_generated_files = webpack_generated_files
     end
   end
 end

data/lib/react_on_rails/controller.rb

@@ -12,8 +12,8 @@ module ReactOnRails
     def redux_store(store_name, props)
       redux_store_data = { store_name: store_name,
                            props: props }
-      @registered_stores_via_controller ||= []
-      @registered_stores_via_controller << redux_store_data
+      @registered_stores_defer_render ||= []
+      @registered_stores_defer_render << redux_store_data
     end
   end
 end

data/lib/react_on_rails/server_rendering_pool.rb

@@ -13,7 +13,7 @@ module ReactOnRails
 
     def self.reset_pool_if_server_bundle_was_modified
       return unless ReactOnRails.configuration.development_mode
-      file_mtime = File.mtime(ReactOnRails.configuration.server_bundle_js_file)
+      file_mtime = File.mtime(ReactOnRails::Utils.default_server_bundle_js_file_path)
       @server_bundle_timestamp ||= file_mtime
       return if @server_bundle_timestamp == file_mtime
       ReactOnRails::ServerRenderingPool.reset_pool
@@ -70,7 +70,7 @@ module ReactOnRails
       end
 
       def create_js_context
-        server_js_file = ReactOnRails.configuration.server_bundle_js_file
+        server_js_file = ReactOnRails::Utils.default_server_bundle_js_file_path
         if server_js_file.present? && File.exist?(server_js_file)
           bundle_js_code = File.read(server_js_file)
           base_js_code = <<-JS

data/lib/react_on_rails/test_helper.rb

@@ -13,9 +13,10 @@ module ReactOnRails
     # RSpec.configure do |config|
     #   ReactOnRails::TestHelper.configure_rspec_to_compile_assets(config)
     #
-    # You can pass an RSpec metatag as an optional second parameter to this helper method
-    # if you want this helper to run on examples other than where `js: true` (default). The helper
-    # will compile webpack files at most once per test run.
+    # You can pass an RSpec metatag as an list of parameter to this helper method
+    # if you want this helper to run on examples other than where `js: true` or
+    # `server_rendering: true` (default). The helper will compile webpack files at most
+    # once per test run.
     #
     # If you do not want to be slowed down by re-compiling webpack assets from scratch every test
     # run, you can call `npm run build:client` (and `npm run build:server` if doing server
@@ -24,8 +25,17 @@ module ReactOnRails
     # to be running.
     #
     # See docs/additional_reading/rspec_configuration.md for more info
-    def self.configure_rspec_to_compile_assets(config, metatag = :js)
-      config.before(:example, metatag) { ReactOnRails::TestHelper.ensure_assets_compiled }
+    #
+    # Params:
+    # config - config for rspec
+    # metatags - metatags to add the ensure_assets_compiled check.
+    #            Default is :js, :server_rendering
+    def self.configure_rspec_to_compile_assets(config, *metatags)
+      metatags = [:js, :server_rendering] if metatags.empty?
+
+      metatags.each do |metatag|
+        config.before(:example, metatag) { ReactOnRails::TestHelper.ensure_assets_compiled }
+      end
     end
 
     # Main entry point to ensuring assets are compiled. See `configure_rspec_to_compile_assets` for
@@ -38,36 +48,32 @@ module ReactOnRails
     #                         defaults to ReactOnRails::TestHelper::WebpackProcessChecker
     # webpack_assets_compiler: provide one method: `def compile`
     #                         defaults to ReactOnRails::TestHelper::WebpackAssetsCompiler
-    # server_bundle_js_file: The server rendering file, defaulting to server_bundle_js_file in
-    #                        your config
-    # client_dir and compiled_dirs are passed into the default webpack_assets_status_checker if you
-    #                         don't provide one.
+    # client_dir and generated_assets_dir 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,
-      webpack_process_checker: nil,
-      client_dir: nil,
-      compiled_dirs: nil,
-      server_bundle_js_file: nil)
+                                    webpack_assets_compiler: nil,
+                                    webpack_process_checker: nil,
+                                    client_dir: nil,
+                                    generated_assets_dir: nil,
+                                    webpack_generated_files: nil)
 
       if webpack_assets_status_checker.nil?
         client_dir ||= Rails.root.join("client")
-        compiled_dirs ||= ReactOnRails.configuration.generated_assets_dirs
-        server_bundle_js_file ||= ReactOnRails.configuration.server_bundle_js_file
+        generated_assets_dir ||= ReactOnRails.configuration.generated_assets_dir
+        webpack_generated_files ||= ReactOnRails.configuration.webpack_generated_files
 
-        if server_bundle_js_file.present?
-          dir = File.dirname(server_bundle_js_file)
-          compiled_dirs ||= []
-          compiled_dirs << dir unless compiled_dirs.include?(dir)
-        end
         webpack_assets_status_checker ||=
           WebpackAssetsStatusChecker.new(client_dir: client_dir,
-                                         compiled_dirs: compiled_dirs,
-                                         server_bundle_js_file: server_bundle_js_file)
+                                         generated_assets_dir: generated_assets_dir,
+                                         webpack_generated_files: webpack_generated_files
+                                        )
 
         unless @printed_once
           puts
-          puts "====> React On Rails: Checking dirs for outdated/missing bundles: "\
-            "#{webpack_assets_status_checker.compiled_dirs}"
+          puts "====> React On Rails: Checking #{webpack_assets_status_checker.generated_assets_dir} for "\
+          "outdated/missing bundles"
           puts
           @printed_once = true
         end

data/lib/react_on_rails/test_helper/ensure_assets_compiled.rb

@@ -1,6 +1,8 @@
 module ReactOnRails
   module TestHelper
     class EnsureAssetsCompiled
+      SECONDS_TO_WAIT = 10
+
       class << self
         attr_accessor :has_been_run
         @has_been_run = false
@@ -20,58 +22,106 @@ module ReactOnRails
         @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.
+      # 3. For whatever reason, the watch processes are running, but some clean script removed
+      #    the generated bundles.
       def call
+        # Only check this ONCE during a test run
         return if self.class.has_been_run
 
-        loop_count = 0
-        loop do
-          break if webpack_assets_status_checker.up_to_date?
+        # Be sure we don't do this again.
+        self.class.has_been_run = true
 
-          puts_first_iteration_message(loop_count)
+        stale_gen_files = webpack_assets_status_checker.stale_generated_webpack_files
 
-          if webpack_process_checker.running? && loop_count < MAX_TIME_TO_WAIT
-            loop_count += 1
-            sleep 1
-          else
-            puts_max_iterations_message(loop_count)
+        # All done if no stale files!
+        return if stale_gen_files.empty?
+
+        # Inform the developer that we're ensuring gen assets are ready.
+        puts_start_compile_check_message(stale_gen_files)
 
-            webpack_assets_compiler.compile
-            puts
-            break
+        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
 
-        self.class.has_been_run = true
+        final_compilation_check(already_compiled_client_file, client_running, server_running, stale_gen_files)
       end
 
-      def puts_first_iteration_message(loop_count)
-        return unless loop_count == 0
-
-        puts "\n\nReact on Rails is ensuring your JavaScript generated files are up to date!"
-      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
-      def puts_max_iterations_message(loop_count)
-        if loop_count == MAX_TIME_TO_WAIT
-          stale_files = webpack_assets_status_checker.whats_not_up_to_date.join("\n")
-          if stale_files.empty?
-            puts "Please check your config value for `config.generated_assets_dirs`."
-            puts "We're not finding your generated files for test runs."
-          else
-            puts <<-MSG
+      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")}
 
-Even though we detected the webpack watch processes are running, we found files modified that are
-not causing a rebuild of your generated files:
+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
 
-#{stale_files}
+        puts <<-MSG
 
-One possibility is that you modified a file in your directory that is not a dependency of
-your webpack files: #{webpack_assets_status_checker.client_dir}
+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
 
-To be sure, we will now rebuild your generated files.
-          MSG
-          end
+        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
       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.
+
+        MSG
+      end
     end
   end
 end

data/lib/react_on_rails/test_helper/webpack_assets_compiler.rb

@@ -3,23 +3,22 @@
 module ReactOnRails
   module TestHelper
     class WebpackAssetsCompiler
-      def compile
-        compile_type(:client)
-        compile_type(:server) if Utils.server_rendering_is_enabled?
+      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_type(type)
-        unless @printed_msg
-          puts <<-MSG
-If you are frequently running tests, you can run webpack in watch mode 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
-          @printed_msg = true
-        end
-
         puts "\nBuilding Webpack #{type}-rendering assets..."
 
         build_output = `cd client && npm run build:#{type}`
@@ -28,6 +27,15 @@ https://github.com/shakacode/react_on_rails/blob/master/docs/additional_reading/
 
         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") }
+      end
     end
   end
 end

data/lib/react_on_rails/test_helper/webpack_assets_status_checker.rb

@@ -6,51 +6,54 @@ require "fileutils"
 module ReactOnRails
   module TestHelper
     class WebpackAssetsStatusChecker
-      attr_reader :client_dir, :compiled_dirs, :server_bundle_js_file
+      # client_dir is typically /client, where all client files go
+      attr_reader :client_dir, :generated_assets_dir
 
-      def initialize(args = {})
-        @compiled_dirs = args.fetch(:compiled_dirs)
-        @client_dir = args.fetch(:client_dir)
-        @server_bundle_js_file = args.fetch(:server_bundle_js_file)
-        @last_stale_files = ""
+      def initialize(generated_assets_dir:, client_dir:, webpack_generated_files:)
+        @generated_assets_dir = generated_assets_dir
+        @client_dir = client_dir
+        @webpack_generated_files = webpack_generated_files
       end
 
-      def up_to_date?
-        return false unless assets_exist?
-        all_compiled_assets.all? do |asset|
-          FileUtils.uptodate?(asset, client_files)
-        end
-      end
-
-      def whats_not_up_to_date
-        return [] unless assets_exist?
-        result = []
-        all_compiled_assets.all? do |asset|
-          result += whats_not_up_to_date_worker(asset, client_files)
+      def stale_generated_webpack_files
+        most_recent_mtime = find_most_recent_mtime
+        all_compiled_assets.each_with_object([]) do |webpack_generated_file, stale_gen_list|
+          if !File.exist?(webpack_generated_file) ||
+             File.mtime(webpack_generated_file) < most_recent_mtime
+            stale_gen_list << webpack_generated_file
+          end
+          stale_gen_list
         end
-        result.uniq
       end
 
       private
 
-      def whats_not_up_to_date_worker(new, old_list)
-        # derived from lib/ruby/2.2.0/fileutils.rb:147
-        not_up_to_date = []
-        new_time = File.mtime(new)
-        old_list.each do |old|
-          if File.exist?(old)
-            not_up_to_date << old unless new_time > File.mtime(old)
-          end
+      def find_most_recent_mtime
+        client_files.reduce(1.year.ago) do |newest_time, file|
+          mt = File.mtime(file)
+          mt > newest_time ? mt : newest_time
         end
-        not_up_to_date
       end
 
       def all_compiled_assets
-        file_list = make_file_list(make_globs(compiled_dirs)).to_ary
-        if file_list && !file_list.empty?
-          file_list.delete(server_bundle_js_file)
+        @all_compiled_assets ||= begin
+          webpack_generated_files = @webpack_generated_files.map do |file|
+            File.join(@generated_assets_dir, file)
+          end
+          if webpack_generated_files.present?
+            webpack_generated_files
+          else
+            file_list = make_file_list(make_globs(generated_assets_dir)).to_ary
+            puts "V" * 80
+            puts "Please define config.webpack_generated_files (array) so the test helper knows "\
+            "which files are required."
+            puts "Detected the possible following files to check for webpack compilation in "\
+              "#{generated_assets_dir}"
+            puts file_list.join("\n")
+            puts "^" * 80
+            file_list
+          end
         end
-        file_list
       end
 
       def client_files