react_on_rails 16.6.0 → 16.7.0.rc.0

data/lib/react_on_rails/helper.rb

@@ -253,10 +253,9 @@ module ReactOnRails
       js_code = <<~JS
         (function() {
           var htmlResult = '';
-          var consoleReplayScript = '';
           var hasErrors = false;
           var renderingError = null;
-          var renderingErrorObject = {};
+          var renderingErrorObject = null;
 
           try {
             htmlResult =
@@ -290,15 +289,8 @@ module ReactOnRails
             };
           }
 
-          consoleReplayScript = ReactOnRails.getConsoleReplayScript();
-
-          return JSON.stringify({
-              html: htmlResult,
-              consoleReplayScript: consoleReplayScript,
-              hasErrors: hasErrors,
-              renderingError: renderingErrorObject
-          });
-
+          var consoleReplayScript = ReactOnRails.getConsoleReplayScript();
+          return ReactOnRails.prepareRenderResult(htmlResult, consoleReplayScript, hasErrors, renderingErrorObject);
         })()
       JS
 

data/lib/react_on_rails/js_code_builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ReactOnRails
+  # Structured builder for generating JavaScript code used in server-side rendering.
+  # Replaces the heredoc-based JS code generation in ServerRenderingJsCode with
+  # overridable section methods that Pro can extend.
+  #
+  # Part of the strategy pattern refactoring (see issue #2905).
+  # Currently additive — not yet wired into the main rendering path.
+  class JsCodeBuilder
+    # Build the complete JS code for a render request.
+    # @param render_request [RenderRequest] The render request to build JS for
+    # @return [String] JavaScript code to evaluate for SSR
+    def build(render_request)
+      body = build_sections(render_request).compact.join("\n")
+      wrap_in_iife(body, render_request)
+    end
+
+    protected
+
+    # Returns an array of JS code sections. Override in subclasses to add/reorder sections.
+    #
+    # == JS variable contract
+    # props_section, render_call_section, and wrap_in_iife share JS variable names:
+    # - props_section declares a variable (base: `props`) used by render_call_section
+    # - wrap_in_iife may introduce IIFE parameters that shadow or supply those variables
+    # When overriding any one of these methods, verify the JS variables still align.
+    # See ReactOnRailsPro::JsCodeBuilder for an example that changes all three.
+    def build_sections(render_request)
+      [
+        rails_context_section(render_request),
+        store_initialization_section(render_request),
+        props_section(render_request),
+        render_call_section(render_request)
+      ]
+    end
+
+    def rails_context_section(render_request)
+      "var railsContext = #{render_request.rails_context_json};"
+    end
+
+    def store_initialization_section(render_request)
+      render_request.store_initializations
+    end
+
+    def props_section(render_request)
+      "var props = #{render_request.props_string};"
+    end
+
+    def render_call_section(render_request)
+      <<~JS.chomp
+        return ReactOnRails.serverRenderReactComponent({
+          name: #{render_request.component_name.to_json},
+          domNodeId: #{render_request.dom_id.to_json},
+          props: props,
+          trace: #{render_request.render_options.trace},
+          railsContext: railsContext
+        });
+      JS
+    end
+
+    def wrap_in_iife(body, _render_request)
+      "(function() {\n#{body}\n})()"
+    end
+  end
+end

data/lib/react_on_rails/length_prefixed_parser.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ReactOnRails
+  # Parses the length-prefixed wire format used between Node renderer and Ruby.
+  #
+  # Wire format per chunk:
+  #   <metadata JSON>\t<content byte length hex>\n<raw content bytes>
+  #
+  # Used by both streaming (Pro) and non-streaming (OSS) paths.
+  # Strict protocol parser — any format violation raises an error.
+  class LengthPrefixedParser
+    # Parses a complete length-prefixed result string that must contain exactly one chunk.
+    # Used by the non-streaming rendering path where ExecJS/node renderer returns a single result.
+    # Returns a single Hash: { "html" => String|nil, "consoleReplayScript" => "...", ... }
+    # Raises if the input contains zero or more than one chunk.
+    def self.parse_one_chunk_result(str)
+      parser = new
+      results = []
+      parser.feed(str.to_s.b) { |chunk| results << chunk }
+      if results.empty?
+        raise ReactOnRails::Error,
+              "Malformed render result: expected exactly one length-prefixed chunk but found none"
+      end
+      if results.size > 1
+        raise ReactOnRails::Error,
+              "Malformed render result: expected exactly one length-prefixed chunk but found #{results.size}"
+      end
+      results.first
+    end
+
+    def initialize
+      # Binary encoding so that `index` returns byte positions (not character positions).
+      # Needed because `byteindex` requires Ruby 3.2+ and we support 3.0+.
+      # force_encoding is O(1) (flips a flag, no copy). .b allocates a new object but
+      # shares the byte buffer via copy-on-write for strings over ~23 bytes.
+      @buf = "".b
+      @state = :header
+      @content_len = 0
+      @metadata = nil
+    end
+
+    # Appends bytes to buffer and yields complete chunks as they become available.
+    # Yields Hash: { "html" => content, ...metadata }
+    # Raises on protocol errors (bad JSON, bad hex, missing tab).
+    # After an error, the parser enters :error state and all subsequent calls are no-ops.
+    def feed(chunk, &block)
+      return if @state == :error
+
+      @buf << (chunk.encoding == Encoding::BINARY ? chunk : chunk.b)
+
+      loop do
+        case @state
+        when :header
+          break unless try_parse_header(&block)
+        when :content
+          break unless try_read_content(&block)
+        end
+      end
+    rescue StandardError
+      @state = :error
+      raise
+    end
+
+    # Called when the stream ends to detect truncated responses.
+    # Logs a warning if the buffer still has unconsumed bytes (partial header or content).
+    def flush
+      return if @state == :header && @buf.empty?
+
+      Rails.logger.warn(
+        "[react_on_rails] Incomplete length-prefixed stream: " \
+        "#{@buf.bytesize} bytes remaining in state :#{@state}"
+      )
+    end
+
+    # True if the parser encountered a protocol error.
+    def error?
+      @state == :error
+    end
+
+    private
+
+    def try_parse_header
+      idx = @buf.index("\n")
+      return false unless idx
+
+      header = @buf.byteslice(0, idx)
+      @buf = @buf.byteslice(idx + 1, @buf.bytesize - idx - 1)
+
+      tab_idx = header.index("\t")
+      unless tab_idx
+        header_str = header.force_encoding(Encoding::UTF_8).inspect
+        raise ReactOnRails::Error,
+              "Malformed length-prefixed header: missing tab separator in: #{header_str}"
+      end
+
+      parse_length_prefixed_header(header, tab_idx)
+      true
+    end
+
+    def parse_length_prefixed_header(header, tab_idx)
+      meta_json = header.byteslice(0, tab_idx)
+      len_hex = header.byteslice(tab_idx + 1, header.bytesize - tab_idx - 1)
+
+      begin
+        @content_len = Integer(len_hex, 16)
+      rescue ArgumentError
+        raise ReactOnRails::Error, "Invalid content length hex: #{len_hex.force_encoding(Encoding::UTF_8).inspect}"
+      end
+
+      begin
+        @metadata = JSON.parse(meta_json.force_encoding(Encoding::UTF_8))
+      rescue JSON::ParserError => e
+        meta_str = meta_json.force_encoding(Encoding::UTF_8).inspect
+        raise ReactOnRails::Error,
+              "Malformed length-prefixed header: invalid metadata JSON: #{meta_str} (#{e.message})"
+      end
+
+      @state = :content
+    end
+
+    def try_read_content
+      return false if @buf.bytesize < @content_len
+
+      raw_content = @buf.byteslice(0, @content_len).force_encoding(Encoding::UTF_8)
+      @buf = @buf.byteslice(@content_len, @buf.bytesize - @content_len)
+
+      # Reconstruct html type based on payloadType:
+      #   "object" → JSON-serialized value (ServerRenderHash or null), needs JSON.parse
+      #   "string" → raw HTML string, used as-is
+      payload_type = @metadata.delete("payloadType")
+      @metadata["html"] = payload_type == "object" ? JSON.parse(raw_content) : raw_content
+
+      result = @metadata
+      @metadata = nil
+      @state = :header
+      yield result
+      true
+    end
+  end
+end

data/lib/react_on_rails/packs_generator.rb

@@ -32,6 +32,8 @@ module ReactOnRails
     # Auto-registration requires nested_entries support which was added in 7.0.0
     # Note: The gemspec requires Shakapacker >= 6.0 for basic functionality
     MINIMUM_SHAKAPACKER_VERSION_FOR_AUTO_BUNDLING = "7.0.0"
+    # Longer than any realistic pack generation; LOCK_NB still gates the actual clear.
+    GENERATED_PACKS_LOCK_TTL_SECONDS = 120
 
     def self.instance
       @instance ||= PacksGenerator.new
@@ -48,25 +50,76 @@ module ReactOnRails
 
       verbose = ENV["REACT_ON_RAILS_VERBOSE"] == "true"
 
-      add_generated_pack_to_server_bundle
+      with_generated_packs_lock(verbose: verbose) do
+        add_generated_pack_to_server_bundle
 
-      # Clean any non-generated files from directories
-      clean_non_generated_files_with_feedback(verbose: verbose)
+        if generated_files_present_and_up_to_date?
+          clean_non_generated_files_with_feedback(verbose: verbose)
+          puts Rainbow("✅ Generated packs are up to date, no regeneration needed").green if verbose
+        else
+          clean_generated_directories_with_feedback(verbose: verbose)
+          generate_packs(verbose: verbose)
+        end
+      end
+    end
 
-      are_generated_files_present_and_up_to_date = Dir.exist?(generated_packs_directory_path) &&
-                                                   File.exist?(generated_server_bundle_file_path) &&
-                                                   !stale_or_missing_packs?
+    private
 
-      if are_generated_files_present_and_up_to_date
-        puts Rainbow("✅ Generated packs are up to date, no regeneration needed").green if verbose
-        return
+    def generated_files_present_and_up_to_date?
+      server_bundle_ready =
+        ReactOnRails.configuration.server_bundle_js_file.blank? ||
+        File.exist?(generated_server_bundle_file_path)
+
+      Dir.exist?(generated_packs_directory_path) &&
+        server_bundle_ready &&
+        !stale_or_missing_packs?
+    end
+
+    def with_generated_packs_lock(verbose: false)
+      lock_path = generated_packs_lock_path
+      FileUtils.mkdir_p(lock_path.dirname)
+      clear_stale_generated_packs_lock(lock_path, verbose: verbose)
+
+      File.open(lock_path, File::RDWR | File::CREAT, 0o644) do |lock_file|
+        puts Rainbow("🔒 Acquiring generated packs lock at #{lock_path}").yellow if verbose
+        # flock waits until the holder releases; keep Rails tmp local so serialization is reliable.
+        lock_file.flock(File::LOCK_EX)
+        puts Rainbow("🔒 Generated packs lock acquired at #{lock_path}").yellow if verbose
+        lock_file.rewind
+        lock_file.truncate(0)
+        lock_file.write("pid=#{Process.pid}\nstarted_at=#{Time.now.utc}\n")
+        lock_file.flush
+
+        yield
+      ensure
+        # Release early so the next waiter can proceed even if the block raised.
+        lock_file.flock(File::LOCK_UN)
       end
+    end
+
+    def clear_stale_generated_packs_lock(lock_path, verbose: false)
+      return unless File.exist?(lock_path)
+      return unless File.mtime(lock_path) < Time.now - GENERATED_PACKS_LOCK_TTL_SECONDS
+
+      # Kernel locks are released when the holder exits; this only clears stale metadata.
+      lock_acquired = false
+      File.open(lock_path, File::RDWR) do |lock_file|
+        lock_acquired = lock_file.flock(File::LOCK_EX | File::LOCK_NB) != false
+        next unless lock_acquired
 
-      clean_generated_directories_with_feedback(verbose: verbose)
-      generate_packs(verbose: verbose)
+        lock_file.rewind
+        lock_file.truncate(0)
+        puts Rainbow("🧹 Cleared stale generated packs lock at #{lock_path}").yellow if verbose
+      ensure
+        lock_file.flock(File::LOCK_UN) if lock_acquired
+      end
+    rescue Errno::ENOENT, Errno::EACCES
+      nil
     end
 
-    private
+    def generated_packs_lock_path
+      Rails.root.join("tmp", "react_on_rails_generate_packs.lock")
+    end
 
     def generate_packs(verbose: false)
       # Check for name conflicts between components and stores

data/lib/react_on_rails/pro_migration.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module ReactOnRails
+  # Shared Pro migration facts and Gemfile parsing used by the generator and doctor.
+  module ProMigration
+    JS_SOURCE_ROOTS = %w[app/javascript app/frontend frontend javascript client].freeze
+    JS_SOURCE_EXTENSIONS = %w[js jsx ts tsx mjs cjs vue svelte].freeze
+
+    JEST_MODULE_SPECIFIER_METHOD_NAMES = %w[
+      createMockFromModule
+      mock unmock deepUnmock doMock dontMock setMock
+      requireActual requireMock unstable_mockModule unstable_unmockModule
+    ].freeze
+    VITEST_MODULE_SPECIFIER_METHOD_NAMES = %w[
+      mock unmock doMock doUnmock
+      importActual importMock
+    ].freeze
+    JEST_MODULE_SPECIFIER_METHOD_PATTERN = Regexp.union(JEST_MODULE_SPECIFIER_METHOD_NAMES)
+    VITEST_MODULE_SPECIFIER_METHOD_PATTERN = Regexp.union(VITEST_MODULE_SPECIFIER_METHOD_NAMES)
+
+    PRO_GEM_PATTERN = /^\s*gem(?:\s+|\(\s*(?:#.*\n\s*)*)["']react_on_rails_pro["']/
+    BASE_GEM_PATTERN = /^(\s*)gem(?:\s+|\(\s*)(["'])react_on_rails\2(?=\s*(?:,|\)|#|$))/
+    STRING_LITERAL_PATTERN = /"(?:\\.|[^"\\])*+"|'(?:\\.|[^'\\])*+'|`(?:\\.|[^`\\])*+`/
+
+    module_function
+
+    def pro_gem_entry?(gemfile_content)
+      gemfile_content.match?(PRO_GEM_PATTERN)
+    end
+
+    def base_gem_entry?(gemfile_content)
+      gemfile_lines = gemfile_content.lines
+      line_index = 0
+
+      while line_index < gemfile_lines.length
+        return true if base_gem_declaration_at(gemfile_lines, line_index)
+
+        line_index += 1
+      end
+
+      false
+    end
+
+    def base_gem_declaration_at(lines, start_index)
+      match_multiline_parenthesized_base_gem(lines, start_index) ||
+        match_non_parenthesized_base_gem(lines, start_index)
+    end
+
+    def match_multiline_parenthesized_base_gem(lines, start_index)
+      start_line = lines[start_index]
+      start_match = start_line.match(/^(\s*)gem\s*\(/)
+      return nil unless start_match
+
+      line_index = start_index
+      gem_name = nil
+      paren_depth = 0
+
+      while line_index < lines.length
+        line = lines[line_index]
+        gem_name_fragment_offset = line_index == start_index ? start_match.end(0) : 0
+        gem_name ||= parenthesized_base_gem_name(line, gem_name_fragment_offset, line_index)
+        return nil if gem_name == false
+
+        line_without_literals = line_without_string_literals_and_inline_comments(line, strip_ruby_comments: true)
+        paren_depth += parenthesis_delta(line_without_literals)
+
+        return parenthesized_base_gem_declaration(lines, start_match, gem_name, line_index) if paren_depth <= 0
+
+        line_index += 1
+      end
+
+      nil
+    end
+
+    def parenthesized_base_gem_name(line, fragment_offset, line_index)
+      gem_name_fragment = line[fragment_offset..].to_s
+      return nil if strip_ruby_inline_comment(gem_name_fragment).strip.empty?
+
+      gem_name_match = gem_name_fragment.match(/\A\s*(["'])react_on_rails\1(?=\s*(?:,|\)|#|$))/)
+      return false unless gem_name_match
+
+      {
+        quote: gem_name_match[1],
+        line_index: line_index,
+        match_end: fragment_offset + gem_name_match.end(0)
+      }
+    end
+
+    def parenthesized_base_gem_declaration(lines, start_match, gem_name, end_line_index)
+      return nil unless gem_name
+
+      declaration_fragment = lines[gem_name[:line_index]..end_line_index].join
+      suffix = declaration_fragment[gem_name[:match_end]..]
+      suffix = "\n" if suffix.nil? || suffix.empty?
+      {
+        indentation: start_match[1],
+        quote: gem_name[:quote],
+        next_index: end_line_index + 1,
+        trailing_suffix: suffix,
+        parenthesized_gem_call: true
+      }
+    end
+
+    def parenthesis_delta(line)
+      line.count("(") - line.count(")")
+    end
+
+    def match_non_parenthesized_base_gem(lines, start_index)
+      line = lines[start_index]
+      match = line.match(BASE_GEM_PATTERN)
+      return nil unless match
+
+      declaration = consume_non_parenthesized_base_gem_declaration(lines, start_index, match.end(0))
+      {
+        indentation: match[1],
+        quote: match[2],
+        next_index: declaration[:next_index],
+        trailing_suffix: declaration[:trailing_suffix],
+        parenthesized_gem_call: match[0].include?("(")
+      }
+    end
+
+    def consume_non_parenthesized_base_gem_declaration(lines, start_index, match_end)
+      line_index = start_index
+      current_line = lines[line_index]
+      declaration_lines = [current_line]
+      line_index += 1
+
+      while line_index < lines.length &&
+            line_continues_with_comma?(current_line) &&
+            gem_declaration_continues_on_next_line?(lines[line_index])
+        next_line = lines[line_index]
+        declaration_lines << next_line
+        current_line = next_line unless comment_or_blank_line?(next_line)
+        line_index += 1
+      end
+
+      trailing_suffix = lines[start_index][match_end..].to_s + declaration_lines.drop(1).join
+      { trailing_suffix: trailing_suffix, next_index: line_index }
+    end
+
+    def line_continues_with_comma?(line)
+      line_without_comment = strip_ruby_inline_comment(line).rstrip
+      line_without_comment.end_with?(",")
+    end
+
+    def gem_declaration_continues_on_next_line?(line)
+      stripped = line.lstrip
+      return true if stripped.empty?
+
+      !stripped.match?(/\Agem(?:\s|\()/)
+    end
+
+    def comment_or_blank_line?(line)
+      stripped = line.lstrip
+      stripped.empty? || stripped.start_with?("#")
+    end
+
+    def line_without_string_literals_and_inline_comments(line, strip_ruby_comments: false)
+      line_without_strings = line.gsub(STRING_LITERAL_PATTERN, "")
+      return line_without_strings unless strip_ruby_comments
+
+      strip_ruby_inline_comment(line_without_strings)
+    end
+
+    def strip_ruby_inline_comment(line)
+      hash_index = line.index("#")
+      return line unless hash_index
+
+      prefix = line[0, hash_index].rstrip
+      newline_index = line.index("\n", hash_index)
+      newline_index ? prefix + line[newline_index..] : prefix
+    end
+  end
+end

data/lib/react_on_rails/render_request.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ReactOnRails
+  # Structured data object encapsulating everything needed for a server render.
+  # Replaces the ad-hoc parameter passing of js_code strings and render_options
+  # through the delegation chain.
+  #
+  # Part of the strategy pattern refactoring (see issue #2905).
+  # Currently additive — not yet wired into the main rendering path.
+  class RenderRequest
+    attr_reader :component_name, :props, :rails_context, :store_initializations,
+                :render_options
+
+    # @param component_name [String] React component name
+    # @param props [Hash, String] Component props (Hash or JSON string)
+    # @param rails_context [Hash] Rails context data for the render
+    # @param store_initializations [String] JavaScript code for Redux store initialization
+    # @param render_options [ReactOnRails::ReactComponent::RenderOptions] Render configuration
+    def initialize(component_name:, props:, rails_context:, store_initializations:, render_options:)
+      @component_name = component_name
+      @props = props
+      @rails_context = rails_context
+      @store_initializations = store_initializations
+      @render_options = render_options
+    end
+
+    # Serialize to JS code via configured builder.
+    # Raises if server_bundle_js_file is not configured when prerender is true.
+    def to_js
+      validate_server_bundle_configured!
+      ReactOnRails.js_code_builder.build(self)
+    end
+
+    # Returns props as a JSON string, with unicode line/paragraph separators escaped
+    # for safe embedding in JavaScript.
+    def props_string
+      json = props.is_a?(String) ? props : props.to_json
+      json.gsub("\u2028", '\u2028').gsub("\u2029", '\u2029')
+    end
+
+    def rails_context_json
+      raise ArgumentError, "rails_context must be a Hash, got #{rails_context.class}" unless rails_context.is_a?(Hash)
+
+      rails_context.to_json.gsub("\u2028", '\u2028').gsub("\u2029", '\u2029')
+    end
+
+    def dom_id
+      render_options.dom_id
+    end
+
+    def streaming?
+      render_options.streaming?
+    end
+
+    def rsc_payload_streaming?
+      render_options.rsc_payload_streaming?
+    end
+
+    private
+
+    def validate_server_bundle_configured!
+      config_server_bundle_js = ReactOnRails.configuration.server_bundle_js_file
+      return unless render_options.prerender == true && config_server_bundle_js.blank?
+
+      msg = <<~MSG
+        The `prerender` option to allow Server Side Rendering is marked as true but the ReactOnRails configuration
+        for `server_bundle_js_file` is nil or not present in `config/initializers/react_on_rails.rb`.
+        Set `config.server_bundle_js_file` to your javascript bundle to allow server side rendering.
+        Read more at https://reactonrails.com/docs/core-concepts/react-server-rendering/
+      MSG
+      raise ReactOnRails::Error, msg
+    end
+  end
+end

data/lib/react_on_rails/rendering_strategy/exec_js_strategy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ReactOnRails
+  module RenderingStrategy
+    # ExecJS-based rendering strategy for the open-source React on Rails gem.
+    # Wraps the existing RubyEmbeddedJavaScript connection pool.
+    #
+    # Part of the strategy pattern refactoring (see issue #2905).
+    # Currently additive — not yet wired into the main rendering path.
+    class ExecJsStrategy
+      include ReactOnRails::RenderingStrategy
+
+      def execute(render_request)
+        js_code = render_request.to_js
+        ReactOnRails::ServerRenderingPool::RubyEmbeddedJavaScript
+          .exec_server_render_js(js_code, render_request.render_options)
+      end
+
+      def reset
+        ReactOnRails::ServerRenderingPool::RubyEmbeddedJavaScript.reset_pool
+      end
+
+      def reset_if_bundle_changed
+        ReactOnRails::ServerRenderingPool::RubyEmbeddedJavaScript
+          .reset_pool_if_server_bundle_was_modified
+      end
+    end
+  end
+end

data/lib/react_on_rails/rendering_strategy.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "rendering_strategy/exec_js_strategy"
+
+module ReactOnRails
+  # @abstract Include this module and implement all instance methods in your
+  #   concrete strategy class. Methods are instance methods, not class methods.
+  #
+  # Strategy interface for server-side rendering. Concrete strategies implement
+  # the rendering pipeline (JS execution, caching, streaming) for a specific
+  # runtime (ExecJS, Node renderer, etc.).
+  #
+  # Configured once at boot time via engine initializers, replacing runtime
+  # `react_on_rails_pro?` checks.
+  #
+  # Part of the strategy pattern refactoring (see issue #2905).
+  # Currently additive — not yet wired into the main rendering path.
+  module RenderingStrategy
+    # Execute a server render.
+    # @param render_request [RenderRequest] The render request to execute
+    # @return [Hash, Stream] Result hash with "html", "consoleReplayScript", "hasErrors" keys,
+    #   or a stream for streaming renders.
+    # :nocov:
+    def execute(render_request)
+      raise NotImplementedError, "#{self.class}#execute must be implemented"
+    end
+    # :nocov:
+
+    # Reset the rendering pool (e.g., after configuration changes).
+    # :nocov:
+    def reset
+      raise NotImplementedError, "#{self.class}#reset must be implemented"
+    end
+    # :nocov:
+
+    # Check if the server bundle has changed and reset the pool if so.
+    # Used in development mode to pick up bundle changes without restarting.
+    # :nocov:
+    def reset_if_bundle_changed
+      raise NotImplementedError, "#{self.class}#reset_if_bundle_changed must be implemented"
+    end
+    # :nocov:
+  end
+end