Refactor Pro helper methods and introduce utility for license validation

AbanoubGhadban · AbanoubGhadban · commit 153a6ce2ea48 · 2025-09-19T17:36:50.000+03:00
- Removed immediate hydration badge handling from helper methods to streamline rendering logic.
- Introduced `generate_component_script` and `generate_store_script` methods for improved script tag generation, including support for immediate hydration.
- Added `ReactOnRails::Pro::Utils` module to manage Pro feature licensing checks and disable options if the license is not valid.
- Updated `render_options` to incorporate Pro feature validation, ensuring proper handling of disabled options.

This refactor enhances the clarity and maintainability of the Pro features while ensuring compliance with licensing requirements.
diff --git a/lib/react_on_rails/helper.rb b/lib/react_on_rails/helper.rb
@@ -60,7 +60,6 @@ def react_component(component_name, options = {})
       server_rendered_html = internal_result[:result]["html"]
       console_script = internal_result[:result]["consoleReplayScript"]
       render_options = internal_result[:render_options]
-      badge = pro_warning_badge_if_needed(internal_result[:immediate_hydration_requested])
 
       case server_rendered_html
       when String
@@ -70,7 +69,7 @@ def react_component(component_name, options = {})
           console_script: console_script,
           render_options: render_options
         )
-        (badge + html).html_safe
+        html.html_safe
       when Hash
         msg = <<~MSG
           Use react_component_hash (not react_component) to return a Hash to your ruby view code. See
@@ -217,7 +216,6 @@ def react_component_hash(component_name, options = {})
       server_rendered_html = internal_result[:result]["html"]
       console_script = internal_result[:result]["consoleReplayScript"]
       render_options = internal_result[:render_options]
-      badge = pro_warning_badge_if_needed(internal_result[:immediate_hydration_requested])
 
       if server_rendered_html.is_a?(String) && internal_result[:result]["hasErrors"]
         server_rendered_html = { COMPONENT_HTML_KEY => internal_result[:result]["html"] }
@@ -230,7 +228,7 @@ def react_component_hash(component_name, options = {})
           console_script: console_script,
           render_options: render_options
         )
-        result[COMPONENT_HTML_KEY] = badge + result[COMPONENT_HTML_KEY]
+        result[COMPONENT_HTML_KEY] = result[COMPONENT_HTML_KEY]
         result
       else
         msg = <<~MSG
@@ -259,8 +257,6 @@ def react_component_hash(component_name, options = {})
     #                        hydrate this store immediately instead of waiting for the page to load.
     def redux_store(store_name, props: {}, defer: false, immediate_hydration: nil)
       immediate_hydration = ReactOnRails.configuration.immediate_hydration if immediate_hydration.nil?
-      badge = pro_warning_badge_if_needed(immediate_hydration)
-      immediate_hydration = false unless support_pro_features?
 
       redux_store_data = { store_name: store_name,
                            props: props,
@@ -272,7 +268,7 @@ def redux_store(store_name, props: {}, defer: false, immediate_hydration: nil)
       else
         registered_stores << redux_store_data
         result = render_redux_store_data(redux_store_data)
-        (badge + prepend_render_rails_context(result)).html_safe
+        (prepend_render_rails_context(result)).html_safe
       end
     end
 
@@ -647,23 +643,10 @@ def internal_react_component(react_component_name, options = {})
       # server has already rendered the HTML.
 
       render_options = create_render_options(react_component_name, options)
-      # Capture the originally requested value so we can show a badge while still disabling the feature.
-      immediate_hydration_requested = render_options.immediate_hydration
-      render_options.set_option(:immediate_hydration, false) unless support_pro_features?
 
       # 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(render_options.client_props).html_safe,
-                                                type: "application/json",
-                                                class: "js-react-on-rails-component",
-                                                id: "js-react-on-rails-component-#{render_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,
-                                                "data-store-dependencies" => render_options.store_dependencies&.to_json)
-
-      component_specification_tag = apply_immediate_hydration_if_supported(component_specification_tag, render_options)
+      component_specification_tag = generate_component_script(render_options)
 
       load_pack_for_generated_component(react_component_name, render_options)
       # Create the HTML rendering part
@@ -673,17 +656,11 @@ def internal_react_component(react_component_name, options = {})
         render_options: render_options,
         tag: component_specification_tag,
         result: result,
-        immediate_hydration_requested: immediate_hydration_requested
       }
     end
 
     def render_redux_store_data(redux_store_data)
-      store_hydration_data = content_tag(:script,
-                                         json_safe_and_pretty(redux_store_data[:props]).html_safe,
-                                         type: "application/json",
-                                         "data-js-react-on-rails-store" => redux_store_data[:store_name].html_safe)
-
-      store_hydration_data = apply_store_immediate_hydration_if_supported(store_hydration_data, redux_store_data)
+      store_hydration_data = generate_store_script(redux_store_data)
 
       prepend_render_rails_context(store_hydration_data)
     end
diff --git a/lib/react_on_rails/pro/helper.rb b/lib/react_on_rails/pro/helper.rb
@@ -14,72 +14,106 @@
 #  * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
 #  */
 
-module ReactOnRails
-  module Pro
-    module Helper
-      IMMEDIATE_HYDRATION_PRO_WARNING = "[REACT ON RAILS] The 'immediate_hydration' feature requires a " \
-                                        "React on Rails Pro license. " \
-                                        "Please visit https://shakacode.com/react-on-rails-pro to learn more."
+module ReactOnRails::Pro
+  module Helper
+    IMMEDIATE_HYDRATION_PRO_WARNING = "[REACT ON RAILS] The 'immediate_hydration' feature requires a " \
+                                      "React on Rails Pro license. " \
+                                      "Please visit https://shakacode.com/react-on-rails-pro to learn more."
 
-      # This method is responsible for generating the necessary attributes and script tags
-      # for the immediate_hydration feature. It is enabled only when a valid
-      # React on Rails Pro license is detected.
-      def apply_immediate_hydration_if_supported(component_specification_tag, render_options)
-        return component_specification_tag unless render_options.immediate_hydration && support_pro_features?
+    # Generates the complete component specification script tag.
+    # Handles both immediate hydration (Pro feature) and standard cases.
+    def generate_component_script(render_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(render_options.client_props).html_safe,
+        type: "application/json",
+        class: "js-react-on-rails-component",
+        id: "js-react-on-rails-component-#{render_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,
+        "data-store-dependencies" => render_options.store_dependencies&.to_json,
+        "data-immediate-hydration" =>
+          (render_options.immediate_hydration ? true : nil))
 
-        # Add data attribute
-        component_specification_tag.gsub!("<script ", '<script data-immediate-hydration="true" ')
-
-        # Add immediate invocation script
-        component_specification_tag.concat(
-          content_tag(:script, %(
-            typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsComponentLoaded('#{render_options.dom_id}');
-          ).html_safe)
-        )
+      # Add immediate invocation script if immediate hydration is enabled
+      spec_tag = if render_options.immediate_hydration
+        # Escape dom_id for JavaScript context
+        escaped_dom_id = escape_javascript(render_options.dom_id)
+        immediate_script = content_tag(:script, %(
+          typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsComponentLoaded('#{escaped_dom_id}');
+        ).html_safe)
+        "#{component_specification_tag}\n#{immediate_script}"
+      else
+        component_specification_tag
       end
 
-      # Similar logic for redux_store
-      def apply_store_immediate_hydration_if_supported(store_hydration_data, redux_store_data)
-        return store_hydration_data unless redux_store_data[:immediate_hydration] && support_pro_features?
+      pro_warning_badge = pro_warning_badge_if_needed(render_options.explicitly_disabled_pro_options)
+      "#{pro_warning_badge}\n#{spec_tag}".html_safe
+    end
 
-        # Add data attribute
-        store_hydration_data.gsub!("<script ", '<script data-immediate-hydration="true" ')
+    # Generates the complete store hydration script tag.
+    # Handles both immediate hydration (Pro feature) and standard cases.
+    def generate_store_script(redux_store_data)
+      pro_options_check_result = ReactOnRails::Pro::Utils.disable_pro_render_options_if_not_licensed(redux_store_data)
+      redux_store_data = pro_options_check_result[:raw_options]
+      explicitly_disabled_pro_options = pro_options_check_result[:explicitly_disabled_pro_options]
 
-        # Add immediate invocation script
-        store_hydration_data.concat(
-          content_tag(:script, <<~JS.strip_heredoc.html_safe
-            typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsStoreLoaded('#{redux_store_data[:store_name]}');
-          JS
-          )
+      store_hydration_data = content_tag(:script,
+        json_safe_and_pretty(redux_store_data[:props]).html_safe,
+        type: "application/json",
+        "data-js-react-on-rails-store" => redux_store_data[:store_name].html_safe,
+        "data-immediate-hydration" =>
+          (redux_store_data[:immediate_hydration] ? true : nil))
+
+      # Add immediate invocation script if immediate hydration is enabled and Pro license is valid
+      store_hydration_scripts =if redux_store_data[:immediate_hydration]
+        # Escape store_name for JavaScript context
+        escaped_store_name = escape_javascript(redux_store_data[:store_name])
+        immediate_script = content_tag(:script, <<~JS.strip_heredoc.html_safe
+          typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsStoreLoaded('#{escaped_store_name}');
+        JS
         )
+        "#{store_hydration_data}\n#{immediate_script}"
+      else
+        store_hydration_data
       end
 
-      # Checks if React on Rails Pro features are available
-      # @return [Boolean] true if Pro license is valid, false otherwise
-      def support_pro_features?
-        ReactOnRails::Utils.react_on_rails_pro_licence_valid?
-      end
+      pro_warning_badge = pro_warning_badge_if_needed(explicitly_disabled_pro_options)
+      "#{pro_warning_badge}\n#{store_hydration_scripts}".html_safe
+    end
 
-      def pro_warning_badge_if_needed(immediate_hydration)
-        return "".html_safe unless immediate_hydration
-        return "".html_safe if support_pro_features?
+    def pro_warning_badge_if_needed(explicitly_disabled_pro_options)
+      return "" unless explicitly_disabled_pro_options.any?
 
-        puts IMMEDIATE_HYDRATION_PRO_WARNING
-        Rails.logger.warn IMMEDIATE_HYDRATION_PRO_WARNING
+      disabled_features_message = disabled_pro_features_message(explicitly_disabled_pro_options)
+      warning_message = "[REACT ON RAILS] #{disabled_features_message}" + "\n" +
+                        "Please visit https://shakacode.com/react-on-rails-pro to learn more."
+      puts warning_message
+      Rails.logger.warn warning_message
 
-        tooltip_text = "The 'immediate_hydration' feature requires a React on Rails Pro license. Click to learn more."
+      tooltip_text = "#{disabled_features_message} Click to learn more."
 
-        badge_html = <<~HTML
-          <a href="https://shakacode.com/react-on-rails-pro" target="_blank" rel="noopener noreferrer" title="#{tooltip_text}">
-            <div style="position: fixed; top: 0; right: 0; width: 180px; height: 180px; overflow: hidden; z-index: 9999; pointer-events: none;">
-              <div style="position: absolute; top: 50px; right: -40px; transform: rotate(45deg); background-color: rgba(220, 53, 69, 0.85); color: white; padding: 7px 40px; text-align: center; font-weight: bold; font-family: sans-serif; font-size: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.3); pointer-events: auto;">
-                React On Rails Pro Required
-              </div>
+      badge_html = <<~HTML.strip
+        <a href="https://shakacode.com/react-on-rails-pro" target="_blank" rel="noopener noreferrer" title="#{tooltip_text}">
+          <div style="position: fixed; top: 0; right: 0; width: 180px; height: 180px; overflow: hidden; z-index: 9999; pointer-events: none;">
+            <div style="position: absolute; top: 50px; right: -40px; transform: rotate(45deg); background-color: rgba(220, 53, 69, 0.85); color: white; padding: 7px 40px; text-align: center; font-weight: bold; font-family: sans-serif; font-size: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.3); pointer-events: auto;">
+              React On Rails Pro Required
             </div>
-          </a>
-        HTML
-        badge_html.strip.html_safe
-      end
+          </div>
+        </a>
+      HTML
+      badge_html
+    end
+
+    def disabled_pro_features_message(explicitly_disabled_pro_options)
+      return "".html_safe unless explicitly_disabled_pro_options.any?
+
+      feature_list = explicitly_disabled_pro_options.join(', ')
+      feature_word = explicitly_disabled_pro_options.size == 1 ? "feature" : "features"
+      "The '#{feature_list}' #{feature_word} #{explicitly_disabled_pro_options.size == 1 ? 'requires' : 'require'} a " \
+      "React on Rails Pro license. "
     end
   end
 end
diff --git a/lib/react_on_rails/pro/utils.rb b/lib/react_on_rails/pro/utils.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# /*
+#  * Copyright (c) 2025 Shakacode LLC
+#  *
+#  * This file is NOT licensed under the MIT (open source) license.
+#  * It is part of the React on Rails Pro offering and is licensed separately.
+#  *
+#  * Unauthorized copying, modification, distribution, or use of this file,
+#  * via any medium, is strictly prohibited without a valid license agreement
+#  * from Shakacode LLC.
+#  *
+#  * For licensing terms, please see:
+#  * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+#  */
+
+module ReactOnRails::Pro
+  module Utils
+    PRO_ONLY_OPTIONS = %i[immediate_hydration].freeze
+
+    # Checks if React on Rails Pro features are available
+    # @return [Boolean] true if Pro license is valid, false otherwise
+    def self.support_pro_features?
+      ReactOnRails::Utils.react_on_rails_pro_licence_valid?
+    end
+
+    def self.disable_pro_render_options_if_not_licensed(raw_options)
+      if support_pro_features?
+        return {
+          raw_options: raw_options,
+          explicitly_disabled_pro_options: []
+        }
+      end
+
+      raw_options_after_disable = raw_options.dup
+
+      explicitly_disabled_pro_options = PRO_ONLY_OPTIONS.select do |option|
+        # Use global configuration if it's not overridden in the options
+        next ReactOnRails.configuration.send(option) if raw_options[option].nil?
+
+        raw_options[option]
+      end
+      explicitly_disabled_pro_options.each { |option| raw_options_after_disable[option] = false }
+
+      {
+        raw_options: raw_options_after_disable,
+        explicitly_disabled_pro_options: explicitly_disabled_pro_options
+      }
+    end
+  end
+end
diff --git a/lib/react_on_rails/react_component/render_options.rb b/lib/react_on_rails/react_component/render_options.rb
@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "react_on_rails/utils"
+require "react_on_rails/pro/utils"
 
 module ReactOnRails
   module ReactComponent
@@ -14,10 +15,13 @@ class RenderOptions
       # TODO: remove the required for named params
       def initialize(react_component_name: required("react_component_name"), options: required("options"))
         @react_component_name = react_component_name.camelize
-        @options = options
+
+        result = ReactOnRails::Pro::Utils.disable_pro_render_options_if_not_licensed(options)
+        @options = result[:raw_options]
+        @explicitly_disabled_pro_options = result[:explicitly_disabled_pro_options]
       end
 
-      attr_reader :react_component_name
+      attr_reader :react_component_name, :explicitly_disabled_pro_options
 
       def throw_js_errors
         options.fetch(:throw_js_errors, false)
