Add license attribution comment and refactor license validation methods for clarity

Author: AbanoubGhadban

lib/react_on_rails/helper.rb

@@ -620,10 +620,23 @@ def rails_context_if_not_already_rendered
 
       @rendered_rails_context = true
 
-      content_tag(:script,
-                  json_safe_and_pretty(data).html_safe,
-                  type: "application/json",
-                  id: "js-react-on-rails-context")
+      attribution_comment = react_on_rails_attribution_comment
+      script_tag = content_tag(:script,
+                               json_safe_and_pretty(data).html_safe,
+                               type: "application/json",
+                               id: "js-react-on-rails-context")
+
+      "#{attribution_comment}\n#{script_tag}".html_safe
+    end
+
+    # Generates the HTML attribution comment
+    # Pro version calls ReactOnRailsPro::Utils for license-specific details
+    def react_on_rails_attribution_comment
+      if ReactOnRails::Utils.react_on_rails_pro?
+        ReactOnRailsPro::Utils.pro_attribution_comment
+      else
+        "<!-- Powered by React on Rails (c) ShakaCode | Open Source -->"
+      end
     end
 
     # prepend the rails_context if not yet applied

react_on_rails_pro/lib/react_on_rails_pro/engine.rb

@@ -15,7 +15,7 @@ class Engine < Rails::Engine
       config.after_initialize do
         Rails.logger.info "[React on Rails Pro] Validating license..."
 
-        ReactOnRailsPro::LicenseValidator.validate!
+        ReactOnRailsPro::LicenseValidator.validated_license_data!
 
         Rails.logger.info "[React on Rails Pro] License validation successful"
       end

react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb

@@ -5,82 +5,110 @@
 module ReactOnRailsPro
   class LicenseValidator
     class << self
-      # Validates the license and raises an exception if invalid.
-      # Caches the result after first validation.
-      #
-      # @return [Boolean] true if license is valid
+      # Validates the license and returns the license data
+      # Caches the result after first validation
+      # @return [Hash] The license data
       # @raise [ReactOnRailsPro::Error] if license is invalid
-      def validate!
-        return @validate if defined?(@validate)
-
-        @validate = validate_license
+      def validated_license_data!
+        return @license_data if defined?(@license_data)
+
+        begin
+          # Load and decode license (but don't cache yet)
+          license_data = load_and_decode_license
+
+          # Validate the license (raises if invalid, returns grace_days)
+          grace_days = validate_license_data(license_data)
+
+          # Validation passed - now cache both data and grace days
+          @license_data = license_data
+          @grace_days_remaining = grace_days
+
+          @license_data
+        rescue JWT::DecodeError => e
+          error = "Invalid license signature: #{e.message}. " \
+                  "Your license file may be corrupted. " \
+                  "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
+          handle_invalid_license(error)
+        rescue StandardError => e
+          error = "License validation error: #{e.message}. " \
+                  "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
+          handle_invalid_license(error)
+        end
       end
 
       def reset!
-        remove_instance_variable(:@validate) if defined?(@validate)
         remove_instance_variable(:@license_data) if defined?(@license_data)
-        remove_instance_variable(:@validation_error) if defined?(@validation_error)
+        remove_instance_variable(:@grace_days_remaining) if defined?(@grace_days_remaining)
       end
 
-      def license_data
-        @license_data ||= load_and_decode_license
+      # Checks if the current license is an evaluation/free license
+      # @return [Boolean] true if plan is not "paid"
+      def evaluation?
+        data = validated_license_data!
+        plan = data["plan"]
+        plan != "paid"
       end
 
-      attr_reader :validation_error
+      # Returns remaining grace period days if license is expired but in grace period
+      # @return [Integer, nil] Number of days remaining, or nil if not in grace period
+      def grace_days_remaining
+        # Ensure license is validated and cached
+        validated_license_data!
+
+        # Return cached grace days (nil if not in grace period)
+        @grace_days_remaining
+      end
 
       private
 
       # Grace period: 1 month (in seconds)
       GRACE_PERIOD_SECONDS = 30 * 24 * 60 * 60
 
-      def validate_license
-        license = load_and_decode_license
-
+      # Validates the license data and raises if invalid
+      # Logs info/errors and handles grace period logic
+      # @param license [Hash] The decoded license data
+      # @return [Integer, nil] Grace days remaining if in grace period, nil otherwise
+      # @raise [ReactOnRailsPro::Error] if license is invalid
+      def validate_license_data(license)
         # Check that exp field exists
         unless license["exp"]
-          @validation_error = "License is missing required expiration field. " \
-                              "Your license may be from an older version. " \
-                              "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
-          handle_invalid_license(@validation_error)
+          error = "License is missing required expiration field. " \
+                  "Your license may be from an older version. " \
+                  "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
+          handle_invalid_license(error)
         end
 
         # Check expiry with grace period for production
         current_time = Time.now.to_i
         exp_time = license["exp"]
+        grace_days = nil
 
         if current_time > exp_time
           days_expired = ((current_time - exp_time) / (24 * 60 * 60)).to_i
 
-          @validation_error = "License has expired #{days_expired} day(s) ago. " \
-                              "Get a FREE evaluation license (3 months) at https://shakacode.com/react-on-rails-pro " \
-                              "or upgrade to a paid license for production use."
+          error = "License has expired #{days_expired} day(s) ago. " \
+                  "Get a FREE evaluation license (3 months) at https://shakacode.com/react-on-rails-pro " \
+                  "or upgrade to a paid license for production use."
 
           # In production, allow a grace period of 1 month with error logging
           if production? && within_grace_period?(exp_time)
-            grace_days_remaining = grace_days_remaining(exp_time)
+            # Calculate grace days once here
+            grace_days = calculate_grace_days_remaining(exp_time)
             Rails.logger.error(
-              "[React on Rails Pro] WARNING: #{@validation_error} " \
-              "Grace period: #{grace_days_remaining} day(s) remaining. " \
+              "[React on Rails Pro] WARNING: #{error} " \
+              "Grace period: #{grace_days} day(s) remaining. " \
               "Application will fail to start after grace period expires."
             )
           else
-            handle_invalid_license(@validation_error)
+            handle_invalid_license(error)
           end
         end
 
         # Log license type if present (for analytics)
         log_license_info(license)
 
-        true
-      rescue JWT::DecodeError => e
-        @validation_error = "Invalid license signature: #{e.message}. " \
-                            "Your license file may be corrupted. " \
-                            "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
-        handle_invalid_license(@validation_error)
-      rescue StandardError => e
-        @validation_error = "License validation error: #{e.message}. " \
-                            "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
-        handle_invalid_license(@validation_error)
+        # Return grace days (nil if not in grace period)
+        grace_days
       end
 
       def production?
@@ -91,9 +119,14 @@ def within_grace_period?(exp_time)
         Time.now.to_i <= exp_time + GRACE_PERIOD_SECONDS
       end
 
-      def grace_days_remaining(exp_time)
+      # Calculates remaining grace period days
+      # @param exp_time [Integer] Expiration timestamp
+      # @return [Integer] Days remaining (0 or more)
+      def calculate_grace_days_remaining(exp_time)
         grace_end = exp_time + GRACE_PERIOD_SECONDS
         seconds_remaining = grace_end - Time.now.to_i
+        return 0 if seconds_remaining <= 0
+
         (seconds_remaining / (24 * 60 * 60)).to_i
       end
 
@@ -114,7 +147,7 @@ def load_and_decode_license
           algorithm: "RS256",
           # Disable automatic expiration verification so we can handle it manually with custom logic
           verify_expiration: false
-        # JWT.decode returns an array [data, header]; we use `.first` to get the data (payload).
+          # JWT.decode returns an array [data, header]; we use `.first` to get the data (payload).
         ).first
       end
 

react_on_rails_pro/lib/react_on_rails_pro/utils.rb

@@ -164,5 +164,23 @@ def self.printable_cache_key(cache_key)
         end
       end.join("_").underscore
     end
+
+    # Generates the Pro-specific HTML attribution comment based on license status
+    # Called by React on Rails helper to generate license-specific attribution
+    def self.pro_attribution_comment
+      base = "Powered by React on Rails Pro (c) ShakaCode"
+
+      # Check if in grace period
+      grace_days = ReactOnRailsPro::LicenseValidator.grace_days_remaining
+      comment = if grace_days
+                  "#{base} | Licensed (Expired - Grace Period: #{grace_days} days remaining)"
+                elsif ReactOnRailsPro::LicenseValidator.evaluation?
+                  "#{base} | Evaluation License"
+                else
+                  "#{base} | Licensed"
+                end
+
+      "<!-- #{comment} -->"
+    end
   end
 end